1 /*
2  * Copyright (c) 2013 Eugene Krasnikov <k.eugene.e@gmail.com>
3  *
4  * Permission to use, copy, modify, and/or distribute this software for any
5  * purpose with or without fee is hereby granted, provided that the above
6  * copyright notice and this permission notice appear in all copies.
7  *
8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
11  * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
13  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
14  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15  */
16 
17 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
18 
19 #include <linux/bitfield.h>
20 #include <linux/etherdevice.h>
21 #include <linux/firmware.h>
22 #include <linux/bitops.h>
23 #include <linux/rpmsg.h>
24 #include "smd.h"
25 
26 struct wcn36xx_cfg_val {
27 	u32 cfg_id;
28 	u32 value;
29 };
30 
31 #define WCN36XX_CFG_VAL(id, val) \
32 { \
33 	.cfg_id = WCN36XX_HAL_CFG_ ## id, \
34 	.value = val \
35 }
36 
37 static struct wcn36xx_cfg_val wcn36xx_cfg_vals[] = {
38 	WCN36XX_CFG_VAL(CURRENT_TX_ANTENNA, 1),
39 	WCN36XX_CFG_VAL(CURRENT_RX_ANTENNA, 1),
40 	WCN36XX_CFG_VAL(LOW_GAIN_OVERRIDE, 0),
41 	WCN36XX_CFG_VAL(POWER_STATE_PER_CHAIN, 785),
42 	WCN36XX_CFG_VAL(CAL_PERIOD, 5),
43 	WCN36XX_CFG_VAL(CAL_CONTROL, 1),
44 	WCN36XX_CFG_VAL(PROXIMITY, 0),
45 	WCN36XX_CFG_VAL(NETWORK_DENSITY, 3),
46 	WCN36XX_CFG_VAL(MAX_MEDIUM_TIME, 6000),
47 	WCN36XX_CFG_VAL(MAX_MPDUS_IN_AMPDU, 64),
48 	WCN36XX_CFG_VAL(RTS_THRESHOLD, 2347),
49 	WCN36XX_CFG_VAL(SHORT_RETRY_LIMIT, 15),
50 	WCN36XX_CFG_VAL(LONG_RETRY_LIMIT, 15),
51 	WCN36XX_CFG_VAL(FRAGMENTATION_THRESHOLD, 8000),
52 	WCN36XX_CFG_VAL(DYNAMIC_THRESHOLD_ZERO, 5),
53 	WCN36XX_CFG_VAL(DYNAMIC_THRESHOLD_ONE, 10),
54 	WCN36XX_CFG_VAL(DYNAMIC_THRESHOLD_TWO, 15),
55 	WCN36XX_CFG_VAL(FIXED_RATE, 0),
56 	WCN36XX_CFG_VAL(RETRYRATE_POLICY, 4),
57 	WCN36XX_CFG_VAL(RETRYRATE_SECONDARY, 0),
58 	WCN36XX_CFG_VAL(RETRYRATE_TERTIARY, 0),
59 	WCN36XX_CFG_VAL(FORCE_POLICY_PROTECTION, 5),
60 	WCN36XX_CFG_VAL(FIXED_RATE_MULTICAST_24GHZ, 1),
61 	WCN36XX_CFG_VAL(FIXED_RATE_MULTICAST_5GHZ, 5),
62 	WCN36XX_CFG_VAL(DEFAULT_RATE_INDEX_5GHZ, 5),
63 	WCN36XX_CFG_VAL(MAX_BA_SESSIONS, 40),
64 	WCN36XX_CFG_VAL(PS_DATA_INACTIVITY_TIMEOUT, 200),
65 	WCN36XX_CFG_VAL(PS_ENABLE_BCN_FILTER, 1),
66 	WCN36XX_CFG_VAL(PS_ENABLE_RSSI_MONITOR, 1),
67 	WCN36XX_CFG_VAL(NUM_BEACON_PER_RSSI_AVERAGE, 20),
68 	WCN36XX_CFG_VAL(STATS_PERIOD, 10),
69 	WCN36XX_CFG_VAL(CFP_MAX_DURATION, 30000),
70 	WCN36XX_CFG_VAL(FRAME_TRANS_ENABLED, 0),
71 	WCN36XX_CFG_VAL(BA_THRESHOLD_HIGH, 128),
72 	WCN36XX_CFG_VAL(MAX_BA_BUFFERS, 2560),
73 	WCN36XX_CFG_VAL(DYNAMIC_PS_POLL_VALUE, 0),
74 	WCN36XX_CFG_VAL(TX_PWR_CTRL_ENABLE, 1),
75 	WCN36XX_CFG_VAL(ENABLE_CLOSE_LOOP, 1),
76 	WCN36XX_CFG_VAL(ENABLE_LPWR_IMG_TRANSITION, 0),
77 	WCN36XX_CFG_VAL(BTC_STATIC_LEN_LE_BT, 120000),
78 	WCN36XX_CFG_VAL(BTC_STATIC_LEN_LE_WLAN, 30000),
79 	WCN36XX_CFG_VAL(MAX_ASSOC_LIMIT, 10),
80 	WCN36XX_CFG_VAL(ENABLE_MCC_ADAPTIVE_SCHEDULER, 0),
81 	WCN36XX_CFG_VAL(ENABLE_DYNAMIC_RA_START_RATE, 133), /* MCS 5 */
82 	WCN36XX_CFG_VAL(LINK_FAIL_TX_CNT, 1000),
83 };
84 
85 static struct wcn36xx_cfg_val wcn3680_cfg_vals[] = {
86 	WCN36XX_CFG_VAL(CURRENT_TX_ANTENNA, 1),
87 	WCN36XX_CFG_VAL(CURRENT_RX_ANTENNA, 1),
88 	WCN36XX_CFG_VAL(LOW_GAIN_OVERRIDE, 0),
89 	WCN36XX_CFG_VAL(POWER_STATE_PER_CHAIN, 785),
90 	WCN36XX_CFG_VAL(CAL_PERIOD, 5),
91 	WCN36XX_CFG_VAL(CAL_CONTROL, 1),
92 	WCN36XX_CFG_VAL(PROXIMITY, 0),
93 	WCN36XX_CFG_VAL(NETWORK_DENSITY, 3),
94 	WCN36XX_CFG_VAL(MAX_MEDIUM_TIME, 4096),
95 	WCN36XX_CFG_VAL(MAX_MPDUS_IN_AMPDU, 64),
96 	WCN36XX_CFG_VAL(RTS_THRESHOLD, 2347),
97 	WCN36XX_CFG_VAL(SHORT_RETRY_LIMIT, 15),
98 	WCN36XX_CFG_VAL(LONG_RETRY_LIMIT, 15),
99 	WCN36XX_CFG_VAL(FRAGMENTATION_THRESHOLD, 8000),
100 	WCN36XX_CFG_VAL(DYNAMIC_THRESHOLD_ZERO, 5),
101 	WCN36XX_CFG_VAL(DYNAMIC_THRESHOLD_ONE, 10),
102 	WCN36XX_CFG_VAL(DYNAMIC_THRESHOLD_TWO, 15),
103 	WCN36XX_CFG_VAL(FIXED_RATE, 0),
104 	WCN36XX_CFG_VAL(RETRYRATE_POLICY, 4),
105 	WCN36XX_CFG_VAL(RETRYRATE_SECONDARY, 0),
106 	WCN36XX_CFG_VAL(RETRYRATE_TERTIARY, 0),
107 	WCN36XX_CFG_VAL(FORCE_POLICY_PROTECTION, 5),
108 	WCN36XX_CFG_VAL(FIXED_RATE_MULTICAST_24GHZ, 1),
109 	WCN36XX_CFG_VAL(FIXED_RATE_MULTICAST_5GHZ, 5),
110 	WCN36XX_CFG_VAL(DEFAULT_RATE_INDEX_24GHZ, 1),
111 	WCN36XX_CFG_VAL(DEFAULT_RATE_INDEX_5GHZ, 5),
112 	WCN36XX_CFG_VAL(MAX_BA_SESSIONS, 40),
113 	WCN36XX_CFG_VAL(PS_DATA_INACTIVITY_TIMEOUT, 200),
114 	WCN36XX_CFG_VAL(PS_ENABLE_BCN_FILTER, 1),
115 	WCN36XX_CFG_VAL(PS_ENABLE_RSSI_MONITOR, 1),
116 	WCN36XX_CFG_VAL(NUM_BEACON_PER_RSSI_AVERAGE, 20),
117 	WCN36XX_CFG_VAL(STATS_PERIOD, 10),
118 	WCN36XX_CFG_VAL(CFP_MAX_DURATION, 30000),
119 	WCN36XX_CFG_VAL(FRAME_TRANS_ENABLED, 0),
120 	WCN36XX_CFG_VAL(BA_THRESHOLD_HIGH, 128),
121 	WCN36XX_CFG_VAL(MAX_BA_BUFFERS, 2560),
122 	WCN36XX_CFG_VAL(DYNAMIC_PS_POLL_VALUE, 0),
123 	WCN36XX_CFG_VAL(TX_PWR_CTRL_ENABLE, 1),
124 	WCN36XX_CFG_VAL(ENABLE_CLOSE_LOOP, 1),
125 	WCN36XX_CFG_VAL(ENABLE_LPWR_IMG_TRANSITION, 0),
126 	WCN36XX_CFG_VAL(BTC_STATIC_LEN_LE_BT, 120000),
127 	WCN36XX_CFG_VAL(BTC_STATIC_LEN_LE_WLAN, 30000),
128 	WCN36XX_CFG_VAL(MAX_ASSOC_LIMIT, 10),
129 	WCN36XX_CFG_VAL(ENABLE_MCC_ADAPTIVE_SCHEDULER, 0),
130 	WCN36XX_CFG_VAL(TDLS_PUAPSD_MASK, 0),
131 	WCN36XX_CFG_VAL(TDLS_PUAPSD_BUFFER_STA_CAPABLE, 1),
132 	WCN36XX_CFG_VAL(TDLS_PUAPSD_INACTIVITY_TIME, 0),
133 	WCN36XX_CFG_VAL(TDLS_PUAPSD_RX_FRAME_THRESHOLD, 10),
134 	WCN36XX_CFG_VAL(TDLS_OFF_CHANNEL_CAPABLE, 1),
135 	WCN36XX_CFG_VAL(ENABLE_ADAPTIVE_RX_DRAIN, 1),
136 	WCN36XX_CFG_VAL(FLEXCONNECT_POWER_FACTOR, 0),
137 	WCN36XX_CFG_VAL(ANTENNA_DIVERSITY, 3),
138 	WCN36XX_CFG_VAL(ATH_DISABLE, 0),
139 	WCN36XX_CFG_VAL(BTC_STATIC_OPP_WLAN_ACTIVE_WLAN_LEN, 60000),
140 	WCN36XX_CFG_VAL(BTC_STATIC_OPP_WLAN_ACTIVE_BT_LEN, 90000),
141 	WCN36XX_CFG_VAL(BTC_SAP_STATIC_OPP_ACTIVE_WLAN_LEN, 30000),
142 	WCN36XX_CFG_VAL(BTC_SAP_STATIC_OPP_ACTIVE_BT_LEN, 30000),
143 	WCN36XX_CFG_VAL(ASD_PROBE_INTERVAL, 50),
144 	WCN36XX_CFG_VAL(ASD_TRIGGER_THRESHOLD, -60),
145 	WCN36XX_CFG_VAL(ASD_RTT_RSSI_HYST_THRESHOLD, 3),
146 	WCN36XX_CFG_VAL(BTC_CTS2S_ON_STA_DURING_SCO, 0),
147 	WCN36XX_CFG_VAL(RA_FILTER_ENABLE, 0),
148 	WCN36XX_CFG_VAL(RA_RATE_LIMIT_INTERVAL, 60),
149 	WCN36XX_CFG_VAL(BTC_FATAL_HID_NSNIFF_BLK, 2),
150 	WCN36XX_CFG_VAL(BTC_CRITICAL_HID_NSNIFF_BLK, 1),
151 	WCN36XX_CFG_VAL(BTC_DYN_A2DP_TX_QUEUE_THOLD, 0),
152 	WCN36XX_CFG_VAL(BTC_DYN_OPP_TX_QUEUE_THOLD, 1),
153 	WCN36XX_CFG_VAL(MAX_UAPSD_CONSEC_SP, 10),
154 	WCN36XX_CFG_VAL(MAX_UAPSD_CONSEC_RX_CNT, 50),
155 	WCN36XX_CFG_VAL(MAX_UAPSD_CONSEC_TX_CNT, 50),
156 	WCN36XX_CFG_VAL(MAX_UAPSD_CONSEC_TX_CNT_MEAS_WINDOW, 500),
157 	WCN36XX_CFG_VAL(MAX_UAPSD_CONSEC_RX_CNT_MEAS_WINDOW, 500),
158 	WCN36XX_CFG_VAL(MAX_PSPOLL_IN_WMM_UAPSD_PS_MODE, 0),
159 	WCN36XX_CFG_VAL(MAX_UAPSD_INACTIVITY_INTERVALS, 10),
160 	WCN36XX_CFG_VAL(ENABLE_DYNAMIC_WMMPS, 1),
161 	WCN36XX_CFG_VAL(BURST_MODE_BE_TXOP_VALUE, 0),
162 	WCN36XX_CFG_VAL(ENABLE_DYNAMIC_RA_START_RATE, 136),
163 	WCN36XX_CFG_VAL(BTC_FAST_WLAN_CONN_PREF, 1),
164 	WCN36XX_CFG_VAL(ENABLE_RTSCTS_HTVHT, 0),
165 	WCN36XX_CFG_VAL(BTC_STATIC_OPP_WLAN_IDLE_WLAN_LEN, 30000),
166 	WCN36XX_CFG_VAL(BTC_STATIC_OPP_WLAN_IDLE_BT_LEN, 120000),
167 	WCN36XX_CFG_VAL(LINK_FAIL_TX_CNT, 1000),
168 	WCN36XX_CFG_VAL(TOGGLE_ARP_BDRATES, 0),
169 	WCN36XX_CFG_VAL(OPTIMIZE_CA_EVENT, 0),
170 	WCN36XX_CFG_VAL(EXT_SCAN_CONC_MODE, 0),
171 	WCN36XX_CFG_VAL(BAR_WAKEUP_HOST_DISABLE, 0),
172 	WCN36XX_CFG_VAL(SAR_BOFFSET_CORRECTION_ENABLE, 0),
173 	WCN36XX_CFG_VAL(BTC_DISABLE_WLAN_LINK_CRITICAL, 5),
174 	WCN36XX_CFG_VAL(DISABLE_SCAN_DURING_SCO, 2),
175 	WCN36XX_CFG_VAL(CONS_BCNMISS_COUNT, 0),
176 	WCN36XX_CFG_VAL(UNITS_OF_BCN_WAIT_TIME, 0),
177 	WCN36XX_CFG_VAL(TRIGGER_NULLFRAME_BEFORE_HB, 0),
178 	WCN36XX_CFG_VAL(ENABLE_POWERSAVE_OFFLOAD, 0),
179 };
180 
181 static int put_cfg_tlv_u32(struct wcn36xx *wcn, size_t *len, u32 id, u32 value)
182 {
183 	struct wcn36xx_hal_cfg *entry;
184 	u32 *val;
185 
186 	if (*len + sizeof(*entry) + sizeof(u32) >= WCN36XX_HAL_BUF_SIZE) {
187 		wcn36xx_err("Not enough room for TLV entry\n");
188 		return -ENOMEM;
189 	}
190 
191 	entry = (struct wcn36xx_hal_cfg *) (wcn->hal_buf + *len);
192 	entry->id = id;
193 	entry->len = sizeof(u32);
194 	entry->pad_bytes = 0;
195 	entry->reserve = 0;
196 
197 	val = (u32 *) (entry + 1);
198 	*val = value;
199 
200 	*len += sizeof(*entry) + sizeof(u32);
201 
202 	return 0;
203 }
204 
205 static void wcn36xx_smd_set_bss_nw_type(struct wcn36xx *wcn,
206 		struct ieee80211_sta *sta,
207 		struct wcn36xx_hal_config_bss_params *bss_params)
208 {
209 	if (NL80211_BAND_5GHZ == WCN36XX_BAND(wcn))
210 		bss_params->nw_type = WCN36XX_HAL_11A_NW_TYPE;
211 	else if (sta && sta->ht_cap.ht_supported)
212 		bss_params->nw_type = WCN36XX_HAL_11N_NW_TYPE;
213 	else if (sta && (sta->supp_rates[NL80211_BAND_2GHZ] & 0x7f))
214 		bss_params->nw_type = WCN36XX_HAL_11G_NW_TYPE;
215 	else
216 		bss_params->nw_type = WCN36XX_HAL_11B_NW_TYPE;
217 }
218 
219 static inline u8 is_cap_supported(unsigned long caps, unsigned long flag)
220 {
221 	return caps & flag ? 1 : 0;
222 }
223 
224 static void wcn36xx_smd_set_bss_ht_params(struct ieee80211_vif *vif,
225 		struct ieee80211_sta *sta,
226 		struct wcn36xx_hal_config_bss_params *bss_params)
227 {
228 	if (sta && sta->ht_cap.ht_supported) {
229 		unsigned long caps = sta->ht_cap.cap;
230 		bss_params->ht = sta->ht_cap.ht_supported;
231 		bss_params->tx_channel_width_set = is_cap_supported(caps,
232 			IEEE80211_HT_CAP_SUP_WIDTH_20_40);
233 		bss_params->lsig_tx_op_protection_full_support =
234 			is_cap_supported(caps,
235 					 IEEE80211_HT_CAP_LSIG_TXOP_PROT);
236 
237 		bss_params->ht_oper_mode = vif->bss_conf.ht_operation_mode;
238 		bss_params->lln_non_gf_coexist =
239 			!!(vif->bss_conf.ht_operation_mode &
240 			   IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT);
241 		/* IEEE80211_HT_STBC_PARAM_DUAL_CTS_PROT */
242 		bss_params->dual_cts_protection = 0;
243 		/* IEEE80211_HT_OP_MODE_PROTECTION_20MHZ */
244 		bss_params->ht20_coexist = 0;
245 	}
246 }
247 
248 static void
249 wcn36xx_smd_set_bss_vht_params(struct ieee80211_vif *vif,
250 			       struct ieee80211_sta *sta,
251 			       struct wcn36xx_hal_config_bss_params_v1 *bss)
252 {
253 	if (sta && sta->vht_cap.vht_supported)
254 		bss->vht_capable = 1;
255 }
256 
257 static void wcn36xx_smd_set_sta_ht_params(struct ieee80211_sta *sta,
258 		struct wcn36xx_hal_config_sta_params *sta_params)
259 {
260 	if (sta->ht_cap.ht_supported) {
261 		unsigned long caps = sta->ht_cap.cap;
262 		sta_params->ht_capable = sta->ht_cap.ht_supported;
263 		sta_params->tx_channel_width_set = is_cap_supported(caps,
264 			IEEE80211_HT_CAP_SUP_WIDTH_20_40);
265 		sta_params->lsig_txop_protection = is_cap_supported(caps,
266 			IEEE80211_HT_CAP_LSIG_TXOP_PROT);
267 
268 		sta_params->max_ampdu_size = sta->ht_cap.ampdu_factor;
269 		sta_params->max_ampdu_density = sta->ht_cap.ampdu_density;
270 		/* max_amsdu_size: 1 : 3839 bytes, 0 : 7935 bytes (max) */
271 		sta_params->max_amsdu_size = !is_cap_supported(caps,
272 			IEEE80211_HT_CAP_MAX_AMSDU);
273 		sta_params->sgi_20Mhz = is_cap_supported(caps,
274 			IEEE80211_HT_CAP_SGI_20);
275 		sta_params->sgi_40mhz =	is_cap_supported(caps,
276 			IEEE80211_HT_CAP_SGI_40);
277 		sta_params->green_field_capable = is_cap_supported(caps,
278 			IEEE80211_HT_CAP_GRN_FLD);
279 		sta_params->delayed_ba_support = is_cap_supported(caps,
280 			IEEE80211_HT_CAP_DELAY_BA);
281 		sta_params->dsss_cck_mode_40mhz = is_cap_supported(caps,
282 			IEEE80211_HT_CAP_DSSSCCK40);
283 	}
284 }
285 
286 static void wcn36xx_smd_set_sta_vht_params(struct wcn36xx *wcn,
287 		struct ieee80211_sta *sta,
288 		struct wcn36xx_hal_config_sta_params_v1 *sta_params)
289 {
290 	if (sta->vht_cap.vht_supported) {
291 		unsigned long caps = sta->vht_cap.cap;
292 
293 		sta_params->vht_capable = sta->vht_cap.vht_supported;
294 		sta_params->vht_ldpc_enabled =
295 			is_cap_supported(caps, IEEE80211_VHT_CAP_RXLDPC);
296 		if (get_feat_caps(wcn->fw_feat_caps, MU_MIMO)) {
297 			sta_params->vht_tx_mu_beamformee_capable =
298 				is_cap_supported(caps, IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE);
299 			if (sta_params->vht_tx_mu_beamformee_capable)
300 			       sta_params->vht_tx_bf_enabled = 1;
301 		} else {
302 			sta_params->vht_tx_mu_beamformee_capable = 0;
303 		}
304 		sta_params->vht_tx_channel_width_set = 0;
305 	}
306 }
307 
308 static void wcn36xx_smd_set_sta_ht_ldpc_params(struct ieee80211_sta *sta,
309 		struct wcn36xx_hal_config_sta_params_v1 *sta_params)
310 {
311 	if (sta->ht_cap.ht_supported) {
312 		sta_params->ht_ldpc_enabled =
313 			is_cap_supported(sta->ht_cap.cap, IEEE80211_HT_CAP_LDPC_CODING);
314 	}
315 }
316 
317 static void wcn36xx_smd_set_sta_default_ht_params(
318 		struct wcn36xx_hal_config_sta_params *sta_params)
319 {
320 	sta_params->ht_capable = 1;
321 	sta_params->tx_channel_width_set = 1;
322 	sta_params->lsig_txop_protection = 1;
323 	sta_params->max_ampdu_size = 3;
324 	sta_params->max_ampdu_density = 5;
325 	sta_params->max_amsdu_size = 0;
326 	sta_params->sgi_20Mhz = 1;
327 	sta_params->sgi_40mhz = 1;
328 	sta_params->green_field_capable = 1;
329 	sta_params->delayed_ba_support = 0;
330 	sta_params->dsss_cck_mode_40mhz = 1;
331 }
332 
333 static void wcn36xx_smd_set_sta_default_vht_params(struct wcn36xx *wcn,
334 		struct wcn36xx_hal_config_sta_params_v1 *sta_params)
335 {
336 	if (wcn->rf_id == RF_IRIS_WCN3680) {
337 		sta_params->vht_capable = 1;
338 		sta_params->vht_tx_mu_beamformee_capable = 1;
339 	} else {
340 		sta_params->vht_capable = 0;
341 		sta_params->vht_tx_mu_beamformee_capable = 0;
342 	}
343 
344 	sta_params->vht_ldpc_enabled = 0;
345 	sta_params->vht_tx_channel_width_set = 0;
346 	sta_params->vht_tx_bf_enabled = 0;
347 }
348 
349 static void wcn36xx_smd_set_sta_default_ht_ldpc_params(struct wcn36xx *wcn,
350 		struct wcn36xx_hal_config_sta_params_v1 *sta_params)
351 {
352 	if (wcn->rf_id == RF_IRIS_WCN3680)
353 		sta_params->ht_ldpc_enabled = 1;
354 	else
355 		sta_params->ht_ldpc_enabled = 0;
356 }
357 
358 static void wcn36xx_smd_set_sta_params(struct wcn36xx *wcn,
359 		struct ieee80211_vif *vif,
360 		struct ieee80211_sta *sta,
361 		struct wcn36xx_hal_config_sta_params *sta_params)
362 {
363 	struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
364 	struct wcn36xx_sta *sta_priv = NULL;
365 	if (vif->type == NL80211_IFTYPE_ADHOC ||
366 	    vif->type == NL80211_IFTYPE_AP ||
367 	    vif->type == NL80211_IFTYPE_MESH_POINT) {
368 		sta_params->type = 1;
369 		sta_params->sta_index = WCN36XX_HAL_STA_INVALID_IDX;
370 	} else {
371 		sta_params->type = 0;
372 		sta_params->sta_index = vif_priv->self_sta_index;
373 	}
374 
375 	sta_params->listen_interval = WCN36XX_LISTEN_INTERVAL(wcn);
376 
377 	/*
378 	 * In STA mode ieee80211_sta contains bssid and ieee80211_vif
379 	 * contains our mac address. In  AP mode we are bssid so vif
380 	 * contains bssid and ieee80211_sta contains mac.
381 	 */
382 	if (NL80211_IFTYPE_STATION == vif->type)
383 		memcpy(&sta_params->mac, vif->addr, ETH_ALEN);
384 	else
385 		memcpy(&sta_params->bssid, vif->addr, ETH_ALEN);
386 
387 	sta_params->encrypt_type = vif_priv->encrypt_type;
388 	sta_params->short_preamble_supported = true;
389 
390 	sta_params->rifs_mode = 0;
391 	sta_params->rmf = 0;
392 	sta_params->action = 0;
393 	sta_params->uapsd = 0;
394 	sta_params->mimo_ps = WCN36XX_HAL_HT_MIMO_PS_STATIC;
395 	sta_params->max_ampdu_duration = 0;
396 	sta_params->bssid_index = vif_priv->bss_index;
397 	sta_params->p2p = 0;
398 
399 	if (sta) {
400 		sta_priv = wcn36xx_sta_to_priv(sta);
401 		if (NL80211_IFTYPE_STATION == vif->type)
402 			memcpy(&sta_params->bssid, sta->addr, ETH_ALEN);
403 		else
404 			memcpy(&sta_params->mac, sta->addr, ETH_ALEN);
405 		sta_params->wmm_enabled = sta->wme;
406 		sta_params->max_sp_len = sta->max_sp;
407 		sta_params->aid = sta_priv->aid;
408 		wcn36xx_smd_set_sta_ht_params(sta, sta_params);
409 		memcpy(&sta_params->supported_rates, &sta_priv->supported_rates,
410 			sizeof(struct wcn36xx_hal_supported_rates));
411 	} else {
412 		wcn36xx_set_default_rates((struct wcn36xx_hal_supported_rates *)
413 					  &sta_params->supported_rates);
414 		wcn36xx_smd_set_sta_default_ht_params(sta_params);
415 	}
416 }
417 
418 static int wcn36xx_smd_send_and_wait(struct wcn36xx *wcn, size_t len)
419 {
420 	int ret;
421 	unsigned long start;
422 	struct wcn36xx_hal_msg_header *hdr =
423 		(struct wcn36xx_hal_msg_header *)wcn->hal_buf;
424 	u16 req_type = hdr->msg_type;
425 
426 	wcn36xx_dbg_dump(WCN36XX_DBG_SMD_DUMP, "HAL >>> ", wcn->hal_buf, len);
427 
428 	init_completion(&wcn->hal_rsp_compl);
429 	start = jiffies;
430 	ret = rpmsg_send(wcn->smd_channel, wcn->hal_buf, len);
431 	if (ret) {
432 		wcn36xx_err("HAL TX failed for req %d\n", req_type);
433 		goto out;
434 	}
435 	if (wait_for_completion_timeout(&wcn->hal_rsp_compl,
436 		msecs_to_jiffies(HAL_MSG_TIMEOUT)) <= 0) {
437 		wcn36xx_err("Timeout! No SMD response to req %d in %dms\n",
438 			    req_type, HAL_MSG_TIMEOUT);
439 		ret = -ETIME;
440 		goto out;
441 	}
442 	wcn36xx_dbg(WCN36XX_DBG_SMD,
443 		    "SMD command (req %d, rsp %d) completed in %dms\n",
444 		    req_type, hdr->msg_type,
445 		    jiffies_to_msecs(jiffies - start));
446 out:
447 	return ret;
448 }
449 
450 #define __INIT_HAL_MSG(msg_body, type, version) \
451 	do {								\
452 		memset(&(msg_body), 0, sizeof(msg_body));		\
453 		(msg_body).header.msg_type = type;			\
454 		(msg_body).header.msg_version = version;		\
455 		(msg_body).header.len = sizeof(msg_body);		\
456 	} while (0)							\
457 
458 #define INIT_HAL_MSG(msg_body, type)	\
459 	__INIT_HAL_MSG(msg_body, type, WCN36XX_HAL_MSG_VERSION0)
460 
461 #define INIT_HAL_MSG_V1(msg_body, type) \
462 	__INIT_HAL_MSG(msg_body, type, WCN36XX_HAL_MSG_VERSION1)
463 
464 #define INIT_HAL_PTT_MSG(p_msg_body, ppt_msg_len) \
465 	do { \
466 		memset(p_msg_body, 0, sizeof(*p_msg_body) + ppt_msg_len); \
467 		p_msg_body->header.msg_type = WCN36XX_HAL_PROCESS_PTT_REQ; \
468 		p_msg_body->header.msg_version = WCN36XX_HAL_MSG_VERSION0; \
469 		p_msg_body->header.len = sizeof(*p_msg_body) + ppt_msg_len; \
470 	} while (0)
471 
472 #define PREPARE_HAL_BUF(send_buf, msg_body) \
473 	do {							\
474 		memset(send_buf, 0, msg_body.header.len);	\
475 		memcpy(send_buf, &msg_body, sizeof(msg_body));	\
476 	} while (0)						\
477 
478 #define PREPARE_HAL_PTT_MSG_BUF(send_buf, p_msg_body) \
479 	do {							\
480 		memcpy(send_buf, p_msg_body, p_msg_body->header.len); \
481 	} while (0)
482 
483 static int wcn36xx_smd_rsp_status_check(void *buf, size_t len)
484 {
485 	struct wcn36xx_fw_msg_status_rsp *rsp;
486 
487 	if (len < sizeof(struct wcn36xx_hal_msg_header) +
488 	    sizeof(struct wcn36xx_fw_msg_status_rsp))
489 		return -EIO;
490 
491 	rsp = (struct wcn36xx_fw_msg_status_rsp *)
492 		(buf + sizeof(struct wcn36xx_hal_msg_header));
493 
494 	if (WCN36XX_FW_MSG_RESULT_SUCCESS != rsp->status)
495 		return rsp->status;
496 
497 	return 0;
498 }
499 
500 int wcn36xx_smd_load_nv(struct wcn36xx *wcn)
501 {
502 	struct nv_data *nv_d;
503 	struct wcn36xx_hal_nv_img_download_req_msg msg_body;
504 	int fw_bytes_left;
505 	int ret;
506 	u16 fm_offset = 0;
507 
508 	if (!wcn->nv) {
509 		ret = request_firmware(&wcn->nv, wcn->nv_file, wcn->dev);
510 		if (ret) {
511 			wcn36xx_err("Failed to load nv file %s: %d\n",
512 				    wcn->nv_file, ret);
513 			goto out;
514 		}
515 	}
516 
517 	nv_d = (struct nv_data *)wcn->nv->data;
518 	INIT_HAL_MSG(msg_body, WCN36XX_HAL_DOWNLOAD_NV_REQ);
519 
520 	msg_body.header.len += WCN36XX_NV_FRAGMENT_SIZE;
521 
522 	msg_body.frag_number = 0;
523 	/* hal_buf must be protected with  mutex */
524 	mutex_lock(&wcn->hal_mutex);
525 
526 	do {
527 		fw_bytes_left = wcn->nv->size - fm_offset - 4;
528 		if (fw_bytes_left > WCN36XX_NV_FRAGMENT_SIZE) {
529 			msg_body.last_fragment = 0;
530 			msg_body.nv_img_buffer_size = WCN36XX_NV_FRAGMENT_SIZE;
531 		} else {
532 			msg_body.last_fragment = 1;
533 			msg_body.nv_img_buffer_size = fw_bytes_left;
534 
535 			/* Do not forget update general message len */
536 			msg_body.header.len = sizeof(msg_body) + fw_bytes_left;
537 
538 		}
539 
540 		/* Add load NV request message header */
541 		memcpy(wcn->hal_buf, &msg_body,	sizeof(msg_body));
542 
543 		/* Add NV body itself */
544 		memcpy(wcn->hal_buf + sizeof(msg_body),
545 		       &nv_d->table + fm_offset,
546 		       msg_body.nv_img_buffer_size);
547 
548 		ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
549 		if (ret)
550 			goto out_unlock;
551 		ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf,
552 						   wcn->hal_rsp_len);
553 		if (ret) {
554 			wcn36xx_err("hal_load_nv response failed err=%d\n",
555 				    ret);
556 			goto out_unlock;
557 		}
558 		msg_body.frag_number++;
559 		fm_offset += WCN36XX_NV_FRAGMENT_SIZE;
560 
561 	} while (msg_body.last_fragment != 1);
562 
563 out_unlock:
564 	mutex_unlock(&wcn->hal_mutex);
565 out:	return ret;
566 }
567 
568 static int wcn36xx_smd_start_rsp(struct wcn36xx *wcn, void *buf, size_t len)
569 {
570 	struct wcn36xx_hal_mac_start_rsp_msg *rsp;
571 
572 	if (len < sizeof(*rsp))
573 		return -EIO;
574 
575 	rsp = (struct wcn36xx_hal_mac_start_rsp_msg *)buf;
576 
577 	if (WCN36XX_FW_MSG_RESULT_SUCCESS != rsp->start_rsp_params.status)
578 		return -EIO;
579 
580 	memcpy(wcn->crm_version, rsp->start_rsp_params.crm_version,
581 	       WCN36XX_HAL_VERSION_LENGTH);
582 	memcpy(wcn->wlan_version, rsp->start_rsp_params.wlan_version,
583 	       WCN36XX_HAL_VERSION_LENGTH);
584 
585 	/* null terminate the strings, just in case */
586 	wcn->crm_version[WCN36XX_HAL_VERSION_LENGTH] = '\0';
587 	wcn->wlan_version[WCN36XX_HAL_VERSION_LENGTH] = '\0';
588 
589 	wcn->fw_revision = rsp->start_rsp_params.version.revision;
590 	wcn->fw_version = rsp->start_rsp_params.version.version;
591 	wcn->fw_minor = rsp->start_rsp_params.version.minor;
592 	wcn->fw_major = rsp->start_rsp_params.version.major;
593 
594 	if (wcn->first_boot) {
595 		wcn->first_boot = false;
596 		wcn36xx_info("firmware WLAN version '%s' and CRM version '%s'\n",
597 			     wcn->wlan_version, wcn->crm_version);
598 
599 		wcn36xx_info("firmware API %u.%u.%u.%u, %u stations, %u bssids\n",
600 			     wcn->fw_major, wcn->fw_minor,
601 			     wcn->fw_version, wcn->fw_revision,
602 			     rsp->start_rsp_params.stations,
603 			     rsp->start_rsp_params.bssids);
604 	}
605 	return 0;
606 }
607 
608 int wcn36xx_smd_start(struct wcn36xx *wcn)
609 {
610 	struct wcn36xx_hal_mac_start_req_msg msg_body, *body;
611 	int ret;
612 	int i;
613 	size_t len;
614 	int cfg_elements;
615 	static struct wcn36xx_cfg_val *cfg_vals;
616 
617 	mutex_lock(&wcn->hal_mutex);
618 	INIT_HAL_MSG(msg_body, WCN36XX_HAL_START_REQ);
619 
620 	msg_body.params.type = DRIVER_TYPE_PRODUCTION;
621 	msg_body.params.len = 0;
622 
623 	PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
624 
625 	body = (struct wcn36xx_hal_mac_start_req_msg *)wcn->hal_buf;
626 	len = body->header.len;
627 
628 	if (wcn->rf_id == RF_IRIS_WCN3680) {
629 		cfg_vals = wcn3680_cfg_vals;
630 		cfg_elements = ARRAY_SIZE(wcn3680_cfg_vals);
631 	} else {
632 		cfg_vals = wcn36xx_cfg_vals;
633 		cfg_elements = ARRAY_SIZE(wcn36xx_cfg_vals);
634 	}
635 
636 	for (i = 0; i < cfg_elements; i++) {
637 		ret = put_cfg_tlv_u32(wcn, &len, cfg_vals[i].cfg_id,
638 				      cfg_vals[i].value);
639 		if (ret)
640 			goto out;
641 	}
642 	body->header.len = len;
643 	body->params.len = len - sizeof(*body);
644 
645 	wcn36xx_dbg(WCN36XX_DBG_HAL, "hal start type %d\n",
646 		    msg_body.params.type);
647 
648 	ret = wcn36xx_smd_send_and_wait(wcn, body->header.len);
649 	if (ret) {
650 		wcn36xx_err("Sending hal_start failed\n");
651 		goto out;
652 	}
653 
654 	ret = wcn36xx_smd_start_rsp(wcn, wcn->hal_buf, wcn->hal_rsp_len);
655 	if (ret) {
656 		wcn36xx_err("hal_start response failed err=%d\n", ret);
657 		goto out;
658 	}
659 
660 out:
661 	mutex_unlock(&wcn->hal_mutex);
662 	return ret;
663 }
664 
665 int wcn36xx_smd_stop(struct wcn36xx *wcn)
666 {
667 	struct wcn36xx_hal_mac_stop_req_msg msg_body;
668 	int ret;
669 
670 	mutex_lock(&wcn->hal_mutex);
671 	INIT_HAL_MSG(msg_body, WCN36XX_HAL_STOP_REQ);
672 
673 	msg_body.stop_req_params.reason = HAL_STOP_TYPE_RF_KILL;
674 
675 	PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
676 
677 	ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
678 	if (ret) {
679 		wcn36xx_err("Sending hal_stop failed\n");
680 		goto out;
681 	}
682 	ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
683 	if (ret) {
684 		wcn36xx_err("hal_stop response failed err=%d\n", ret);
685 		goto out;
686 	}
687 out:
688 	mutex_unlock(&wcn->hal_mutex);
689 	return ret;
690 }
691 
692 int wcn36xx_smd_init_scan(struct wcn36xx *wcn, enum wcn36xx_hal_sys_mode mode,
693 			  struct ieee80211_vif *vif)
694 {
695 	struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
696 	struct wcn36xx_hal_init_scan_req_msg msg_body;
697 	int ret;
698 
699 	mutex_lock(&wcn->hal_mutex);
700 	INIT_HAL_MSG(msg_body, WCN36XX_HAL_INIT_SCAN_REQ);
701 
702 	msg_body.mode = mode;
703 	if (vif_priv->bss_index != WCN36XX_HAL_BSS_INVALID_IDX) {
704 		/* Notify BSSID with null DATA packet */
705 		msg_body.frame_type = 2;
706 		msg_body.notify = 1;
707 		msg_body.scan_entry.bss_index[0] = vif_priv->bss_index;
708 		msg_body.scan_entry.active_bss_count = 1;
709 	}
710 
711 	PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
712 
713 	wcn36xx_dbg(WCN36XX_DBG_HAL, "hal init scan mode %d\n", msg_body.mode);
714 
715 	ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
716 	if (ret) {
717 		wcn36xx_err("Sending hal_init_scan failed\n");
718 		goto out;
719 	}
720 	ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
721 	if (ret) {
722 		wcn36xx_err("hal_init_scan response failed err=%d\n", ret);
723 		goto out;
724 	}
725 	wcn->sw_scan_init = true;
726 out:
727 	mutex_unlock(&wcn->hal_mutex);
728 	return ret;
729 }
730 
731 int wcn36xx_smd_start_scan(struct wcn36xx *wcn, u8 scan_channel)
732 {
733 	struct wcn36xx_hal_start_scan_req_msg msg_body;
734 	int ret;
735 
736 	mutex_lock(&wcn->hal_mutex);
737 	INIT_HAL_MSG(msg_body, WCN36XX_HAL_START_SCAN_REQ);
738 
739 	msg_body.scan_channel = scan_channel;
740 
741 	PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
742 
743 	wcn36xx_dbg(WCN36XX_DBG_HAL, "hal start scan channel %d\n",
744 		    msg_body.scan_channel);
745 
746 	ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
747 	if (ret) {
748 		wcn36xx_err("Sending hal_start_scan failed\n");
749 		goto out;
750 	}
751 	ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
752 	if (ret) {
753 		wcn36xx_err("hal_start_scan response failed err=%d\n", ret);
754 		goto out;
755 	}
756 	wcn->sw_scan_channel = scan_channel;
757 out:
758 	mutex_unlock(&wcn->hal_mutex);
759 	return ret;
760 }
761 
762 int wcn36xx_smd_end_scan(struct wcn36xx *wcn, u8 scan_channel)
763 {
764 	struct wcn36xx_hal_end_scan_req_msg msg_body;
765 	int ret;
766 
767 	mutex_lock(&wcn->hal_mutex);
768 	INIT_HAL_MSG(msg_body, WCN36XX_HAL_END_SCAN_REQ);
769 
770 	msg_body.scan_channel = scan_channel;
771 
772 	PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
773 
774 	wcn36xx_dbg(WCN36XX_DBG_HAL, "hal end scan channel %d\n",
775 		    msg_body.scan_channel);
776 
777 	ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
778 	if (ret) {
779 		wcn36xx_err("Sending hal_end_scan failed\n");
780 		goto out;
781 	}
782 	ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
783 	if (ret) {
784 		wcn36xx_err("hal_end_scan response failed err=%d\n", ret);
785 		goto out;
786 	}
787 	wcn->sw_scan_channel = 0;
788 out:
789 	mutex_unlock(&wcn->hal_mutex);
790 	return ret;
791 }
792 
793 int wcn36xx_smd_finish_scan(struct wcn36xx *wcn,
794 			    enum wcn36xx_hal_sys_mode mode,
795 			    struct ieee80211_vif *vif)
796 {
797 	struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
798 	struct wcn36xx_hal_finish_scan_req_msg msg_body;
799 	int ret;
800 
801 	mutex_lock(&wcn->hal_mutex);
802 	INIT_HAL_MSG(msg_body, WCN36XX_HAL_FINISH_SCAN_REQ);
803 
804 	msg_body.mode = mode;
805 	msg_body.oper_channel = WCN36XX_HW_CHANNEL(wcn);
806 	if (vif_priv->bss_index != WCN36XX_HAL_BSS_INVALID_IDX) {
807 		/* Notify BSSID with null data packet */
808 		msg_body.notify = 1;
809 		msg_body.frame_type = 2;
810 		msg_body.scan_entry.bss_index[0] = vif_priv->bss_index;
811 		msg_body.scan_entry.active_bss_count = 1;
812 	}
813 
814 	PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
815 
816 	wcn36xx_dbg(WCN36XX_DBG_HAL, "hal finish scan mode %d\n",
817 		    msg_body.mode);
818 
819 	ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
820 	if (ret) {
821 		wcn36xx_err("Sending hal_finish_scan failed\n");
822 		goto out;
823 	}
824 	ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
825 	if (ret) {
826 		wcn36xx_err("hal_finish_scan response failed err=%d\n", ret);
827 		goto out;
828 	}
829 	wcn->sw_scan_init = false;
830 out:
831 	mutex_unlock(&wcn->hal_mutex);
832 	return ret;
833 }
834 
835 int wcn36xx_smd_start_hw_scan(struct wcn36xx *wcn, struct ieee80211_vif *vif,
836 			      struct cfg80211_scan_request *req)
837 {
838 	struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
839 	struct wcn36xx_hal_start_scan_offload_req_msg *msg_body;
840 	int ret, i;
841 
842 	if (req->ie_len > WCN36XX_MAX_SCAN_IE_LEN)
843 		return -EINVAL;
844 
845 	mutex_lock(&wcn->hal_mutex);
846 	msg_body = kzalloc(sizeof(*msg_body), GFP_KERNEL);
847 	if (!msg_body) {
848 		ret = -ENOMEM;
849 		goto out;
850 	}
851 
852 	INIT_HAL_MSG((*msg_body), WCN36XX_HAL_START_SCAN_OFFLOAD_REQ);
853 
854 	msg_body->scan_type = WCN36XX_HAL_SCAN_TYPE_ACTIVE;
855 	msg_body->min_ch_time = 30;
856 	msg_body->max_ch_time = 100;
857 	msg_body->scan_hidden = 1;
858 	memcpy(msg_body->mac, vif->addr, ETH_ALEN);
859 	msg_body->bss_type = vif_priv->bss_type;
860 	msg_body->p2p_search = vif->p2p;
861 
862 	msg_body->num_ssid = min_t(u8, req->n_ssids, ARRAY_SIZE(msg_body->ssids));
863 	for (i = 0; i < msg_body->num_ssid; i++) {
864 		msg_body->ssids[i].length = min_t(u8, req->ssids[i].ssid_len,
865 						sizeof(msg_body->ssids[i].ssid));
866 		memcpy(msg_body->ssids[i].ssid, req->ssids[i].ssid,
867 		       msg_body->ssids[i].length);
868 	}
869 
870 	msg_body->num_channel = min_t(u8, req->n_channels,
871 				     sizeof(msg_body->channels));
872 	for (i = 0; i < msg_body->num_channel; i++) {
873 		msg_body->channels[i] =
874 			HW_VALUE_CHANNEL(req->channels[i]->hw_value);
875 	}
876 
877 	msg_body->header.len -= WCN36XX_MAX_SCAN_IE_LEN;
878 
879 	if (req->ie_len > 0) {
880 		msg_body->ie_len = req->ie_len;
881 		msg_body->header.len += req->ie_len;
882 		memcpy(msg_body->ie, req->ie, req->ie_len);
883 	}
884 
885 	PREPARE_HAL_BUF(wcn->hal_buf, (*msg_body));
886 
887 	wcn36xx_dbg(WCN36XX_DBG_HAL,
888 		    "hal start hw-scan (channels: %u; ssids: %u; p2p: %s)\n",
889 		    msg_body->num_channel, msg_body->num_ssid,
890 		    msg_body->p2p_search ? "yes" : "no");
891 
892 	ret = wcn36xx_smd_send_and_wait(wcn, msg_body->header.len);
893 	if (ret) {
894 		wcn36xx_err("Sending hal_start_scan_offload failed\n");
895 		goto out;
896 	}
897 	ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
898 	if (ret) {
899 		wcn36xx_err("hal_start_scan_offload response failed err=%d\n",
900 			    ret);
901 		goto out;
902 	}
903 out:
904 	kfree(msg_body);
905 	mutex_unlock(&wcn->hal_mutex);
906 	return ret;
907 }
908 
909 int wcn36xx_smd_stop_hw_scan(struct wcn36xx *wcn)
910 {
911 	struct wcn36xx_hal_stop_scan_offload_req_msg msg_body;
912 	int ret;
913 
914 	mutex_lock(&wcn->hal_mutex);
915 	INIT_HAL_MSG(msg_body, WCN36XX_HAL_STOP_SCAN_OFFLOAD_REQ);
916 	PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
917 
918 	wcn36xx_dbg(WCN36XX_DBG_HAL, "hal stop hw-scan\n");
919 
920 	ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
921 	if (ret) {
922 		wcn36xx_err("Sending hal_stop_scan_offload failed\n");
923 		goto out;
924 	}
925 	ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
926 	if (ret) {
927 		wcn36xx_err("hal_stop_scan_offload response failed err=%d\n",
928 			    ret);
929 		goto out;
930 	}
931 out:
932 	mutex_unlock(&wcn->hal_mutex);
933 	return ret;
934 }
935 
936 int wcn36xx_smd_update_channel_list(struct wcn36xx *wcn, struct cfg80211_scan_request *req)
937 {
938 	struct wcn36xx_hal_update_channel_list_req_msg *msg_body;
939 	int ret, i;
940 
941 	msg_body = kzalloc(sizeof(*msg_body), GFP_KERNEL);
942 	if (!msg_body)
943 		return -ENOMEM;
944 
945 	INIT_HAL_MSG((*msg_body), WCN36XX_HAL_UPDATE_CHANNEL_LIST_REQ);
946 
947 	msg_body->num_channel = min_t(u8, req->n_channels, ARRAY_SIZE(msg_body->channels));
948 	for (i = 0; i < msg_body->num_channel; i++) {
949 		struct wcn36xx_hal_channel_param *param = &msg_body->channels[i];
950 		u32 min_power = WCN36XX_HAL_DEFAULT_MIN_POWER;
951 		u32 ant_gain = WCN36XX_HAL_DEFAULT_ANT_GAIN;
952 
953 		param->mhz = req->channels[i]->center_freq;
954 		param->band_center_freq1 = req->channels[i]->center_freq;
955 		param->band_center_freq2 = 0;
956 
957 		if (req->channels[i]->flags & IEEE80211_CHAN_NO_IR)
958 			param->channel_info |= WCN36XX_HAL_CHAN_INFO_FLAG_PASSIVE;
959 
960 		if (req->channels[i]->flags & IEEE80211_CHAN_RADAR)
961 			param->channel_info |= WCN36XX_HAL_CHAN_INFO_FLAG_DFS;
962 
963 		if (req->channels[i]->band == NL80211_BAND_5GHZ) {
964 			param->channel_info |= WCN36XX_HAL_CHAN_INFO_FLAG_HT;
965 			param->channel_info |= WCN36XX_HAL_CHAN_INFO_FLAG_VHT;
966 			param->channel_info |= WCN36XX_HAL_CHAN_INFO_PHY_11A;
967 		} else {
968 			param->channel_info |= WCN36XX_HAL_CHAN_INFO_PHY_11BG;
969 		}
970 
971 		if (min_power > req->channels[i]->max_power)
972 			min_power = req->channels[i]->max_power;
973 
974 		if (req->channels[i]->max_antenna_gain)
975 			ant_gain = req->channels[i]->max_antenna_gain;
976 
977 		u32p_replace_bits(&param->reg_info_1, min_power,
978 				  WCN36XX_HAL_CHAN_REG1_MIN_PWR_MASK);
979 		u32p_replace_bits(&param->reg_info_1, req->channels[i]->max_power,
980 				  WCN36XX_HAL_CHAN_REG1_MAX_PWR_MASK);
981 		u32p_replace_bits(&param->reg_info_1, req->channels[i]->max_reg_power,
982 				  WCN36XX_HAL_CHAN_REG1_REG_PWR_MASK);
983 		u32p_replace_bits(&param->reg_info_1, 0,
984 				  WCN36XX_HAL_CHAN_REG1_CLASS_ID_MASK);
985 		u32p_replace_bits(&param->reg_info_2, ant_gain,
986 				  WCN36XX_HAL_CHAN_REG2_ANT_GAIN_MASK);
987 
988 		wcn36xx_dbg(WCN36XX_DBG_HAL,
989 			    "%s: freq=%u, channel_info=%08x, reg_info1=%08x, reg_info2=%08x\n",
990 			    __func__, param->mhz, param->channel_info, param->reg_info_1,
991 			    param->reg_info_2);
992 	}
993 
994 	mutex_lock(&wcn->hal_mutex);
995 
996 	PREPARE_HAL_BUF(wcn->hal_buf, (*msg_body));
997 
998 	ret = wcn36xx_smd_send_and_wait(wcn, msg_body->header.len);
999 	if (ret) {
1000 		wcn36xx_err("Sending hal_update_channel_list failed\n");
1001 		goto out;
1002 	}
1003 
1004 	ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
1005 	if (ret) {
1006 		wcn36xx_err("hal_update_channel_list response failed err=%d\n", ret);
1007 		goto out;
1008 	}
1009 
1010 out:
1011 	kfree(msg_body);
1012 	mutex_unlock(&wcn->hal_mutex);
1013 	return ret;
1014 }
1015 
1016 static int wcn36xx_smd_switch_channel_rsp(void *buf, size_t len)
1017 {
1018 	struct wcn36xx_hal_switch_channel_rsp_msg *rsp;
1019 	int ret;
1020 
1021 	ret = wcn36xx_smd_rsp_status_check(buf, len);
1022 	if (ret)
1023 		return ret;
1024 	rsp = (struct wcn36xx_hal_switch_channel_rsp_msg *)buf;
1025 	wcn36xx_dbg(WCN36XX_DBG_HAL, "channel switched to: %d, status: %d\n",
1026 		    rsp->channel_number, rsp->status);
1027 	return ret;
1028 }
1029 
1030 int wcn36xx_smd_switch_channel(struct wcn36xx *wcn,
1031 			       struct ieee80211_vif *vif, int ch)
1032 {
1033 	struct wcn36xx_hal_switch_channel_req_msg msg_body;
1034 	int ret;
1035 
1036 	mutex_lock(&wcn->hal_mutex);
1037 	INIT_HAL_MSG(msg_body, WCN36XX_HAL_CH_SWITCH_REQ);
1038 
1039 	msg_body.channel_number = (u8)ch;
1040 	msg_body.tx_mgmt_power = 0xbf;
1041 	msg_body.max_tx_power = 0xbf;
1042 	memcpy(msg_body.self_sta_mac_addr, vif->addr, ETH_ALEN);
1043 
1044 	PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1045 
1046 	ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1047 	if (ret) {
1048 		wcn36xx_err("Sending hal_switch_channel failed\n");
1049 		goto out;
1050 	}
1051 	ret = wcn36xx_smd_switch_channel_rsp(wcn->hal_buf, wcn->hal_rsp_len);
1052 	if (ret) {
1053 		wcn36xx_err("hal_switch_channel response failed err=%d\n", ret);
1054 		goto out;
1055 	}
1056 out:
1057 	mutex_unlock(&wcn->hal_mutex);
1058 	return ret;
1059 }
1060 
1061 static int wcn36xx_smd_process_ptt_msg_rsp(void *buf, size_t len,
1062 					   void **p_ptt_rsp_msg)
1063 {
1064 	struct wcn36xx_hal_process_ptt_msg_rsp_msg *rsp;
1065 	int ret;
1066 
1067 	ret = wcn36xx_smd_rsp_status_check(buf, len);
1068 	if (ret)
1069 		return ret;
1070 
1071 	rsp = (struct wcn36xx_hal_process_ptt_msg_rsp_msg *)buf;
1072 
1073 	wcn36xx_dbg(WCN36XX_DBG_HAL, "process ptt msg responded with length %d\n",
1074 		    rsp->header.len);
1075 	wcn36xx_dbg_dump(WCN36XX_DBG_HAL_DUMP, "HAL_PTT_MSG_RSP:", rsp->ptt_msg,
1076 			 rsp->header.len - sizeof(rsp->ptt_msg_resp_status));
1077 
1078 	if (rsp->header.len > 0) {
1079 		*p_ptt_rsp_msg = kmemdup(rsp->ptt_msg, rsp->header.len,
1080 					 GFP_ATOMIC);
1081 		if (!*p_ptt_rsp_msg)
1082 			return -ENOMEM;
1083 	}
1084 	return ret;
1085 }
1086 
1087 int wcn36xx_smd_process_ptt_msg(struct wcn36xx *wcn,
1088 				struct ieee80211_vif *vif, void *ptt_msg, size_t len,
1089 		void **ptt_rsp_msg)
1090 {
1091 	struct wcn36xx_hal_process_ptt_msg_req_msg *p_msg_body;
1092 	int ret;
1093 
1094 	mutex_lock(&wcn->hal_mutex);
1095 	p_msg_body = kmalloc(
1096 		sizeof(struct wcn36xx_hal_process_ptt_msg_req_msg) + len,
1097 		GFP_ATOMIC);
1098 	if (!p_msg_body) {
1099 		ret = -ENOMEM;
1100 		goto out_nomem;
1101 	}
1102 	INIT_HAL_PTT_MSG(p_msg_body, len);
1103 
1104 	memcpy(&p_msg_body->ptt_msg, ptt_msg, len);
1105 
1106 	PREPARE_HAL_PTT_MSG_BUF(wcn->hal_buf, p_msg_body);
1107 
1108 	ret = wcn36xx_smd_send_and_wait(wcn, p_msg_body->header.len);
1109 	if (ret) {
1110 		wcn36xx_err("Sending hal_process_ptt_msg failed\n");
1111 		goto out;
1112 	}
1113 	ret = wcn36xx_smd_process_ptt_msg_rsp(wcn->hal_buf, wcn->hal_rsp_len,
1114 					      ptt_rsp_msg);
1115 	if (ret) {
1116 		wcn36xx_err("process_ptt_msg response failed err=%d\n", ret);
1117 		goto out;
1118 	}
1119 out:
1120 	kfree(p_msg_body);
1121 out_nomem:
1122 	mutex_unlock(&wcn->hal_mutex);
1123 	return ret;
1124 }
1125 
1126 static int wcn36xx_smd_update_scan_params_rsp(void *buf, size_t len)
1127 {
1128 	struct wcn36xx_hal_update_scan_params_resp *rsp;
1129 
1130 	rsp = (struct wcn36xx_hal_update_scan_params_resp *)buf;
1131 
1132 	/* Remove the PNO version bit */
1133 	rsp->status &= (~(WCN36XX_FW_MSG_PNO_VERSION_MASK));
1134 
1135 	if (WCN36XX_FW_MSG_RESULT_SUCCESS != rsp->status) {
1136 		wcn36xx_warn("error response from update scan\n");
1137 		return rsp->status;
1138 	}
1139 
1140 	return 0;
1141 }
1142 
1143 int wcn36xx_smd_update_scan_params(struct wcn36xx *wcn,
1144 				   u8 *channels, size_t channel_count)
1145 {
1146 	struct wcn36xx_hal_update_scan_params_req_ex msg_body;
1147 	int ret;
1148 
1149 	mutex_lock(&wcn->hal_mutex);
1150 	INIT_HAL_MSG(msg_body, WCN36XX_HAL_UPDATE_SCAN_PARAM_REQ);
1151 
1152 	msg_body.dot11d_enabled	= false;
1153 	msg_body.dot11d_resolved = true;
1154 
1155 	msg_body.channel_count = channel_count;
1156 	memcpy(msg_body.channels, channels, channel_count);
1157 	msg_body.active_min_ch_time = 60;
1158 	msg_body.active_max_ch_time = 120;
1159 	msg_body.passive_min_ch_time = 60;
1160 	msg_body.passive_max_ch_time = 110;
1161 	msg_body.state = PHY_SINGLE_CHANNEL_CENTERED;
1162 
1163 	PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1164 
1165 	wcn36xx_dbg(WCN36XX_DBG_HAL,
1166 		    "hal update scan params channel_count %d\n",
1167 		    msg_body.channel_count);
1168 
1169 	ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1170 	if (ret) {
1171 		wcn36xx_err("Sending hal_update_scan_params failed\n");
1172 		goto out;
1173 	}
1174 	ret = wcn36xx_smd_update_scan_params_rsp(wcn->hal_buf,
1175 						 wcn->hal_rsp_len);
1176 	if (ret) {
1177 		wcn36xx_err("hal_update_scan_params response failed err=%d\n",
1178 			    ret);
1179 		goto out;
1180 	}
1181 out:
1182 	mutex_unlock(&wcn->hal_mutex);
1183 	return ret;
1184 }
1185 
1186 static int wcn36xx_smd_add_sta_self_rsp(struct wcn36xx *wcn,
1187 					struct ieee80211_vif *vif,
1188 					void *buf,
1189 					size_t len)
1190 {
1191 	struct wcn36xx_hal_add_sta_self_rsp_msg *rsp;
1192 	struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
1193 
1194 	if (len < sizeof(*rsp))
1195 		return -EINVAL;
1196 
1197 	rsp = (struct wcn36xx_hal_add_sta_self_rsp_msg *)buf;
1198 
1199 	if (rsp->status != WCN36XX_FW_MSG_RESULT_SUCCESS) {
1200 		wcn36xx_warn("hal add sta self failure: %d\n",
1201 			     rsp->status);
1202 		return rsp->status;
1203 	}
1204 
1205 	wcn36xx_dbg(WCN36XX_DBG_HAL,
1206 		    "hal add sta self status %d self_sta_index %d dpu_index %d\n",
1207 		    rsp->status, rsp->self_sta_index, rsp->dpu_index);
1208 
1209 	vif_priv->self_sta_index = rsp->self_sta_index;
1210 	vif_priv->self_dpu_desc_index = rsp->dpu_index;
1211 
1212 	return 0;
1213 }
1214 
1215 int wcn36xx_smd_add_sta_self(struct wcn36xx *wcn, struct ieee80211_vif *vif)
1216 {
1217 	struct wcn36xx_hal_add_sta_self_req msg_body;
1218 	int ret;
1219 
1220 	mutex_lock(&wcn->hal_mutex);
1221 	INIT_HAL_MSG(msg_body, WCN36XX_HAL_ADD_STA_SELF_REQ);
1222 
1223 	memcpy(&msg_body.self_addr, vif->addr, ETH_ALEN);
1224 
1225 	PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1226 
1227 	wcn36xx_dbg(WCN36XX_DBG_HAL,
1228 		    "hal add sta self self_addr %pM status %d\n",
1229 		    msg_body.self_addr, msg_body.status);
1230 
1231 	ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1232 	if (ret) {
1233 		wcn36xx_err("Sending hal_add_sta_self failed\n");
1234 		goto out;
1235 	}
1236 	ret = wcn36xx_smd_add_sta_self_rsp(wcn,
1237 					   vif,
1238 					   wcn->hal_buf,
1239 					   wcn->hal_rsp_len);
1240 	if (ret) {
1241 		wcn36xx_err("hal_add_sta_self response failed err=%d\n", ret);
1242 		goto out;
1243 	}
1244 out:
1245 	mutex_unlock(&wcn->hal_mutex);
1246 	return ret;
1247 }
1248 
1249 int wcn36xx_smd_delete_sta_self(struct wcn36xx *wcn, u8 *addr)
1250 {
1251 	struct wcn36xx_hal_del_sta_self_req_msg msg_body;
1252 	int ret;
1253 
1254 	mutex_lock(&wcn->hal_mutex);
1255 	INIT_HAL_MSG(msg_body, WCN36XX_HAL_DEL_STA_SELF_REQ);
1256 
1257 	memcpy(&msg_body.self_addr, addr, ETH_ALEN);
1258 
1259 	PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1260 
1261 	ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1262 	if (ret) {
1263 		wcn36xx_err("Sending hal_delete_sta_self failed\n");
1264 		goto out;
1265 	}
1266 	ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
1267 	if (ret) {
1268 		wcn36xx_err("hal_delete_sta_self response failed err=%d\n",
1269 			    ret);
1270 		goto out;
1271 	}
1272 out:
1273 	mutex_unlock(&wcn->hal_mutex);
1274 	return ret;
1275 }
1276 
1277 int wcn36xx_smd_delete_sta(struct wcn36xx *wcn, u8 sta_index)
1278 {
1279 	struct wcn36xx_hal_delete_sta_req_msg msg_body;
1280 	int ret;
1281 
1282 	mutex_lock(&wcn->hal_mutex);
1283 	INIT_HAL_MSG(msg_body, WCN36XX_HAL_DELETE_STA_REQ);
1284 
1285 	msg_body.sta_index = sta_index;
1286 
1287 	PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1288 
1289 	wcn36xx_dbg(WCN36XX_DBG_HAL,
1290 		    "hal delete sta sta_index %d\n",
1291 		    msg_body.sta_index);
1292 
1293 	ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1294 	if (ret) {
1295 		wcn36xx_err("Sending hal_delete_sta failed\n");
1296 		goto out;
1297 	}
1298 	ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
1299 	if (ret) {
1300 		wcn36xx_err("hal_delete_sta response failed err=%d\n", ret);
1301 		goto out;
1302 	}
1303 out:
1304 	mutex_unlock(&wcn->hal_mutex);
1305 	return ret;
1306 }
1307 
1308 static int wcn36xx_smd_join_rsp(void *buf, size_t len)
1309 {
1310 	struct wcn36xx_hal_join_rsp_msg *rsp;
1311 
1312 	if (wcn36xx_smd_rsp_status_check(buf, len))
1313 		return -EIO;
1314 
1315 	rsp = (struct wcn36xx_hal_join_rsp_msg *)buf;
1316 
1317 	wcn36xx_dbg(WCN36XX_DBG_HAL,
1318 		    "hal rsp join status %d tx_mgmt_power %d\n",
1319 		    rsp->status, rsp->tx_mgmt_power);
1320 
1321 	return 0;
1322 }
1323 
1324 int wcn36xx_smd_join(struct wcn36xx *wcn, const u8 *bssid, u8 *vif, u8 ch)
1325 {
1326 	struct wcn36xx_hal_join_req_msg msg_body;
1327 	int ret;
1328 
1329 	mutex_lock(&wcn->hal_mutex);
1330 	INIT_HAL_MSG(msg_body, WCN36XX_HAL_JOIN_REQ);
1331 
1332 	memcpy(&msg_body.bssid, bssid, ETH_ALEN);
1333 	memcpy(&msg_body.self_sta_mac_addr, vif, ETH_ALEN);
1334 	msg_body.channel = ch;
1335 
1336 	if (conf_is_ht40_minus(&wcn->hw->conf))
1337 		msg_body.secondary_channel_offset =
1338 			PHY_DOUBLE_CHANNEL_HIGH_PRIMARY;
1339 	else if (conf_is_ht40_plus(&wcn->hw->conf))
1340 		msg_body.secondary_channel_offset =
1341 			PHY_DOUBLE_CHANNEL_LOW_PRIMARY;
1342 	else
1343 		msg_body.secondary_channel_offset =
1344 			PHY_SINGLE_CHANNEL_CENTERED;
1345 
1346 	msg_body.link_state = WCN36XX_HAL_LINK_PREASSOC_STATE;
1347 
1348 	msg_body.max_tx_power = 0xbf;
1349 	PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1350 
1351 	wcn36xx_dbg(WCN36XX_DBG_HAL,
1352 		    "hal join req bssid %pM self_sta_mac_addr %pM channel %d link_state %d\n",
1353 		    msg_body.bssid, msg_body.self_sta_mac_addr,
1354 		    msg_body.channel, msg_body.link_state);
1355 
1356 	ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1357 	if (ret) {
1358 		wcn36xx_err("Sending hal_join failed\n");
1359 		goto out;
1360 	}
1361 	ret = wcn36xx_smd_join_rsp(wcn->hal_buf, wcn->hal_rsp_len);
1362 	if (ret) {
1363 		wcn36xx_err("hal_join response failed err=%d\n", ret);
1364 		goto out;
1365 	}
1366 out:
1367 	mutex_unlock(&wcn->hal_mutex);
1368 	return ret;
1369 }
1370 
1371 int wcn36xx_smd_set_link_st(struct wcn36xx *wcn, const u8 *bssid,
1372 			    const u8 *sta_mac,
1373 			    enum wcn36xx_hal_link_state state)
1374 {
1375 	struct wcn36xx_hal_set_link_state_req_msg msg_body;
1376 	int ret;
1377 
1378 	mutex_lock(&wcn->hal_mutex);
1379 	INIT_HAL_MSG(msg_body, WCN36XX_HAL_SET_LINK_ST_REQ);
1380 
1381 	memcpy(&msg_body.bssid, bssid, ETH_ALEN);
1382 	memcpy(&msg_body.self_mac_addr, sta_mac, ETH_ALEN);
1383 	msg_body.state = state;
1384 
1385 	PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1386 
1387 	wcn36xx_dbg(WCN36XX_DBG_HAL,
1388 		    "hal set link state bssid %pM self_mac_addr %pM state %d\n",
1389 		    msg_body.bssid, msg_body.self_mac_addr, msg_body.state);
1390 
1391 	ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1392 	if (ret) {
1393 		wcn36xx_err("Sending hal_set_link_st failed\n");
1394 		goto out;
1395 	}
1396 	ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
1397 	if (ret) {
1398 		wcn36xx_err("hal_set_link_st response failed err=%d\n", ret);
1399 		goto out;
1400 	}
1401 out:
1402 	mutex_unlock(&wcn->hal_mutex);
1403 	return ret;
1404 }
1405 
1406 static void wcn36xx_smd_convert_sta_to_v1(struct wcn36xx *wcn,
1407 			const struct wcn36xx_hal_config_sta_params *orig,
1408 			struct wcn36xx_hal_config_sta_params_v1 *v1)
1409 {
1410 	/* convert orig to v1 format */
1411 	memcpy(&v1->bssid, orig->bssid, ETH_ALEN);
1412 	memcpy(&v1->mac, orig->mac, ETH_ALEN);
1413 	v1->aid = orig->aid;
1414 	v1->type = orig->type;
1415 	v1->short_preamble_supported = orig->short_preamble_supported;
1416 	v1->listen_interval = orig->listen_interval;
1417 	v1->wmm_enabled = orig->wmm_enabled;
1418 	v1->ht_capable = orig->ht_capable;
1419 	v1->tx_channel_width_set = orig->tx_channel_width_set;
1420 	v1->rifs_mode = orig->rifs_mode;
1421 	v1->lsig_txop_protection = orig->lsig_txop_protection;
1422 	v1->max_ampdu_size = orig->max_ampdu_size;
1423 	v1->max_ampdu_density = orig->max_ampdu_density;
1424 	v1->sgi_40mhz = orig->sgi_40mhz;
1425 	v1->sgi_20Mhz = orig->sgi_20Mhz;
1426 	v1->rmf = orig->rmf;
1427 	v1->encrypt_type = orig->encrypt_type;
1428 	v1->action = orig->action;
1429 	v1->uapsd = orig->uapsd;
1430 	v1->max_sp_len = orig->max_sp_len;
1431 	v1->green_field_capable = orig->green_field_capable;
1432 	v1->mimo_ps = orig->mimo_ps;
1433 	v1->delayed_ba_support = orig->delayed_ba_support;
1434 	v1->max_ampdu_duration = orig->max_ampdu_duration;
1435 	v1->dsss_cck_mode_40mhz = orig->dsss_cck_mode_40mhz;
1436 	memcpy(&v1->supported_rates, &orig->supported_rates,
1437 	       sizeof(orig->supported_rates));
1438 	v1->sta_index = orig->sta_index;
1439 	v1->bssid_index = orig->bssid_index;
1440 	v1->p2p = orig->p2p;
1441 }
1442 
1443 static void
1444 wcn36xx_smd_set_sta_params_v1(struct wcn36xx *wcn,
1445 			      struct ieee80211_vif *vif,
1446 			      struct ieee80211_sta *sta,
1447 			      struct wcn36xx_hal_config_sta_params_v1 *sta_par)
1448 {
1449 	struct wcn36xx_sta *sta_priv = NULL;
1450 	struct wcn36xx_hal_config_sta_params sta_par_v0;
1451 
1452 	wcn36xx_smd_set_sta_params(wcn, vif, sta, &sta_par_v0);
1453 	wcn36xx_smd_convert_sta_to_v1(wcn, &sta_par_v0, sta_par);
1454 
1455 	if (sta) {
1456 		sta_priv = wcn36xx_sta_to_priv(sta);
1457 		wcn36xx_smd_set_sta_vht_params(wcn, sta, sta_par);
1458 		wcn36xx_smd_set_sta_ht_ldpc_params(sta, sta_par);
1459 		memcpy(&sta_par->supported_rates, &sta_priv->supported_rates,
1460 		       sizeof(sta_par->supported_rates));
1461 	} else {
1462 		wcn36xx_set_default_rates_v1(&sta_par->supported_rates);
1463 		wcn36xx_smd_set_sta_default_vht_params(wcn, sta_par);
1464 		wcn36xx_smd_set_sta_default_ht_ldpc_params(wcn, sta_par);
1465 	}
1466 }
1467 
1468 static int wcn36xx_smd_config_sta_rsp(struct wcn36xx *wcn,
1469 				      struct ieee80211_sta *sta,
1470 				      void *buf,
1471 				      size_t len)
1472 {
1473 	struct wcn36xx_hal_config_sta_rsp_msg *rsp;
1474 	struct config_sta_rsp_params *params;
1475 	struct wcn36xx_sta *sta_priv = wcn36xx_sta_to_priv(sta);
1476 
1477 	if (len < sizeof(*rsp))
1478 		return -EINVAL;
1479 
1480 	rsp = (struct wcn36xx_hal_config_sta_rsp_msg *)buf;
1481 	params = &rsp->params;
1482 
1483 	if (params->status != WCN36XX_FW_MSG_RESULT_SUCCESS) {
1484 		wcn36xx_warn("hal config sta response failure: %d\n",
1485 			     params->status);
1486 		return -EIO;
1487 	}
1488 
1489 	sta_priv->sta_index = params->sta_index;
1490 	sta_priv->dpu_desc_index = params->dpu_index;
1491 	sta_priv->ucast_dpu_sign = params->uc_ucast_sig;
1492 
1493 	wcn36xx_dbg(WCN36XX_DBG_HAL,
1494 		    "hal config sta rsp status %d sta_index %d bssid_index %d uc_ucast_sig %d p2p %d\n",
1495 		    params->status, params->sta_index, params->bssid_index,
1496 		    params->uc_ucast_sig, params->p2p);
1497 
1498 	return 0;
1499 }
1500 
1501 static int wcn36xx_smd_config_sta_v1(struct wcn36xx *wcn,
1502 				     struct ieee80211_vif *vif,
1503 				     struct ieee80211_sta *sta)
1504 {
1505 	struct wcn36xx_hal_config_sta_req_msg_v1 msg_body;
1506 	struct wcn36xx_hal_config_sta_params_v1 *sta_params;
1507 
1508 	if (wcn->rf_id == RF_IRIS_WCN3680) {
1509 		INIT_HAL_MSG_V1(msg_body, WCN36XX_HAL_CONFIG_STA_REQ);
1510 	} else {
1511 		INIT_HAL_MSG(msg_body, WCN36XX_HAL_CONFIG_STA_REQ);
1512 		msg_body.header.len -= WCN36XX_DIFF_STA_PARAMS_V1_NOVHT;
1513 	}
1514 
1515 	sta_params = &msg_body.sta_params;
1516 
1517 	wcn36xx_smd_set_sta_params_v1(wcn, vif, sta, sta_params);
1518 
1519 	PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1520 
1521 	wcn36xx_dbg(WCN36XX_DBG_HAL,
1522 		    "hal config sta v1 action %d sta_index %d bssid_index %d bssid %pM type %d mac %pM aid %d\n",
1523 		    sta_params->action, sta_params->sta_index, sta_params->bssid_index,
1524 		    sta_params->bssid, sta_params->type, sta_params->mac, sta_params->aid);
1525 
1526 	return wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1527 }
1528 
1529 static int wcn36xx_smd_config_sta_v0(struct wcn36xx *wcn,
1530 				     struct ieee80211_vif *vif,
1531 				     struct ieee80211_sta *sta)
1532 {
1533 	struct wcn36xx_hal_config_sta_req_msg msg;
1534 	struct wcn36xx_hal_config_sta_params *sta_params;
1535 
1536 	INIT_HAL_MSG(msg, WCN36XX_HAL_CONFIG_STA_REQ);
1537 
1538 	sta_params = &msg.sta_params;
1539 
1540 	wcn36xx_smd_set_sta_params(wcn, vif, sta, sta_params);
1541 
1542 	PREPARE_HAL_BUF(wcn->hal_buf, msg);
1543 
1544 	wcn36xx_dbg(WCN36XX_DBG_HAL,
1545 		    "hal config sta action %d sta_index %d bssid_index %d bssid %pM type %d mac %pM aid %d\n",
1546 		    sta_params->action, sta_params->sta_index,
1547 		    sta_params->bssid_index, sta_params->bssid,
1548 		    sta_params->type, sta_params->mac, sta_params->aid);
1549 
1550 	return wcn36xx_smd_send_and_wait(wcn, msg.header.len);
1551 }
1552 
1553 int wcn36xx_smd_config_sta(struct wcn36xx *wcn, struct ieee80211_vif *vif,
1554 			   struct ieee80211_sta *sta)
1555 {
1556 	int ret;
1557 
1558 	mutex_lock(&wcn->hal_mutex);
1559 
1560 	if (!wcn36xx_is_fw_version(wcn, 1, 2, 2, 24))
1561 		ret = wcn36xx_smd_config_sta_v1(wcn, vif, sta);
1562 	else
1563 		ret = wcn36xx_smd_config_sta_v0(wcn, vif, sta);
1564 
1565 	if (ret) {
1566 		wcn36xx_err("Sending hal_config_sta failed\n");
1567 		goto out;
1568 	}
1569 	ret = wcn36xx_smd_config_sta_rsp(wcn,
1570 					 sta,
1571 					 wcn->hal_buf,
1572 					 wcn->hal_rsp_len);
1573 	if (ret) {
1574 		wcn36xx_err("hal_config_sta response failed err=%d\n", ret);
1575 		goto out;
1576 	}
1577 out:
1578 	mutex_unlock(&wcn->hal_mutex);
1579 	return ret;
1580 }
1581 
1582 static void wcn36xx_smd_set_bss_params(struct wcn36xx *wcn,
1583 				       struct ieee80211_vif *vif,
1584 				       struct ieee80211_sta *sta,
1585 				       const u8 *bssid,
1586 				       bool update,
1587 				       struct wcn36xx_hal_config_bss_params *bss)
1588 {
1589 	struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
1590 
1591 	WARN_ON(is_zero_ether_addr(bssid));
1592 
1593 	memcpy(&bss->bssid, bssid, ETH_ALEN);
1594 
1595 	memcpy(bss->self_mac_addr, vif->addr, ETH_ALEN);
1596 
1597 	if (vif->type == NL80211_IFTYPE_STATION) {
1598 		bss->bss_type = WCN36XX_HAL_INFRASTRUCTURE_MODE;
1599 
1600 		/* STA */
1601 		bss->oper_mode = 1;
1602 		bss->wcn36xx_hal_persona = WCN36XX_HAL_STA_MODE;
1603 	} else if (vif->type == NL80211_IFTYPE_AP ||
1604 		   vif->type == NL80211_IFTYPE_MESH_POINT) {
1605 		bss->bss_type = WCN36XX_HAL_INFRA_AP_MODE;
1606 
1607 		/* AP */
1608 		bss->oper_mode = 0;
1609 		bss->wcn36xx_hal_persona = WCN36XX_HAL_STA_SAP_MODE;
1610 	} else if (vif->type == NL80211_IFTYPE_ADHOC) {
1611 		bss->bss_type = WCN36XX_HAL_IBSS_MODE;
1612 
1613 		/* STA */
1614 		bss->oper_mode = 1;
1615 	} else {
1616 		wcn36xx_warn("Unknown type for bss config: %d\n", vif->type);
1617 	}
1618 
1619 	if (vif->type == NL80211_IFTYPE_STATION)
1620 		wcn36xx_smd_set_bss_nw_type(wcn, sta, bss);
1621 	else
1622 		bss->nw_type = WCN36XX_HAL_11N_NW_TYPE;
1623 
1624 	bss->short_slot_time_supported = vif->bss_conf.use_short_slot;
1625 	bss->lla_coexist = 0;
1626 	bss->llb_coexist = 0;
1627 	bss->llg_coexist = 0;
1628 	bss->rifs_mode = 0;
1629 	bss->beacon_interval = vif->bss_conf.beacon_int;
1630 	bss->dtim_period = vif_priv->dtim_period;
1631 
1632 	wcn36xx_smd_set_bss_ht_params(vif, sta, bss);
1633 
1634 	bss->oper_channel = WCN36XX_HW_CHANNEL(wcn);
1635 
1636 	if (conf_is_ht40_minus(&wcn->hw->conf))
1637 		bss->ext_channel = IEEE80211_HT_PARAM_CHA_SEC_BELOW;
1638 	else if (conf_is_ht40_plus(&wcn->hw->conf))
1639 		bss->ext_channel = IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
1640 	else
1641 		bss->ext_channel = IEEE80211_HT_PARAM_CHA_SEC_NONE;
1642 
1643 	bss->reserved = 0;
1644 
1645 	/* wcn->ssid is only valid in AP and IBSS mode */
1646 	bss->ssid.length = vif_priv->ssid.length;
1647 	memcpy(bss->ssid.ssid, vif_priv->ssid.ssid, vif_priv->ssid.length);
1648 
1649 	bss->obss_prot_enabled = 0;
1650 	bss->rmf = 0;
1651 	bss->max_probe_resp_retry_limit = 0;
1652 	bss->hidden_ssid = vif->bss_conf.hidden_ssid;
1653 	bss->proxy_probe_resp = 0;
1654 	bss->edca_params_valid = 0;
1655 
1656 	/* FIXME: set acbe, acbk, acvi and acvo */
1657 
1658 	bss->ext_set_sta_key_param_valid = 0;
1659 
1660 	/* FIXME: set ext_set_sta_key_param */
1661 
1662 	bss->spectrum_mgt_enable = 0;
1663 	bss->tx_mgmt_power = 0;
1664 	bss->max_tx_power = WCN36XX_MAX_POWER(wcn);
1665 	bss->action = update;
1666 
1667 	vif_priv->bss_type = bss->bss_type;
1668 }
1669 
1670 static int wcn36xx_smd_config_bss_v1(struct wcn36xx *wcn,
1671 				     struct ieee80211_vif *vif,
1672 				     struct ieee80211_sta *sta_80211,
1673 				     const u8 *bssid,
1674 				     bool update)
1675 {
1676 	struct wcn36xx_hal_config_bss_req_msg_v1 *msg_body;
1677 	struct wcn36xx_hal_config_bss_params_v1 *bss;
1678 	struct wcn36xx_hal_config_bss_params bss_v0;
1679 	struct wcn36xx_hal_config_sta_params_v1 *sta;
1680 	struct cfg80211_chan_def *chandef;
1681 	int ret;
1682 
1683 	msg_body = kzalloc(sizeof(*msg_body), GFP_KERNEL);
1684 	if (!msg_body)
1685 		return -ENOMEM;
1686 
1687 	if (wcn->rf_id == RF_IRIS_WCN3680) {
1688 		INIT_HAL_MSG_V1((*msg_body), WCN36XX_HAL_CONFIG_BSS_REQ);
1689 	} else {
1690 		INIT_HAL_MSG((*msg_body), WCN36XX_HAL_CONFIG_BSS_REQ);
1691 		msg_body->header.len -= WCN36XX_DIFF_BSS_PARAMS_V1_NOVHT;
1692 	}
1693 
1694 	bss = &msg_body->bss_params;
1695 	sta = &bss->sta;
1696 
1697 	memset(&bss_v0, 0x00, sizeof(bss_v0));
1698 	wcn36xx_smd_set_bss_params(wcn, vif, sta_80211, bssid, update, &bss_v0);
1699 	wcn36xx_smd_set_sta_params_v1(wcn, vif, sta_80211, sta);
1700 
1701 	/* convert orig to v1 */
1702 	memcpy(bss->bssid, &bss_v0.bssid, ETH_ALEN);
1703 	memcpy(bss->self_mac_addr, &bss_v0.self_mac_addr, ETH_ALEN);
1704 
1705 	bss->bss_type = bss_v0.bss_type;
1706 	bss->oper_mode = bss_v0.oper_mode;
1707 	bss->nw_type = bss_v0.nw_type;
1708 
1709 	bss->short_slot_time_supported =
1710 		bss_v0.short_slot_time_supported;
1711 	bss->lla_coexist = bss_v0.lla_coexist;
1712 	bss->llb_coexist = bss_v0.llb_coexist;
1713 	bss->llg_coexist = bss_v0.llg_coexist;
1714 	bss->ht20_coexist = bss_v0.ht20_coexist;
1715 	bss->lln_non_gf_coexist = bss_v0.lln_non_gf_coexist;
1716 
1717 	bss->lsig_tx_op_protection_full_support =
1718 		bss_v0.lsig_tx_op_protection_full_support;
1719 	bss->rifs_mode = bss_v0.rifs_mode;
1720 	bss->beacon_interval = bss_v0.beacon_interval;
1721 	bss->dtim_period = bss_v0.dtim_period;
1722 	bss->tx_channel_width_set = bss_v0.tx_channel_width_set;
1723 	bss->oper_channel = bss_v0.oper_channel;
1724 
1725 	if (wcn->hw->conf.chandef.width == NL80211_CHAN_WIDTH_80) {
1726 		chandef = &wcn->hw->conf.chandef;
1727 		bss->ext_channel = HW_VALUE_PHY(chandef->chan->hw_value);
1728 	} else {
1729 		bss->ext_channel = bss_v0.ext_channel;
1730 	}
1731 
1732 	bss->reserved = bss_v0.reserved;
1733 
1734 	memcpy(&bss->ssid, &bss_v0.ssid,
1735 	       sizeof(bss_v0.ssid));
1736 
1737 	bss->action = bss_v0.action;
1738 	bss->rateset = bss_v0.rateset;
1739 	bss->ht = bss_v0.ht;
1740 	bss->obss_prot_enabled = bss_v0.obss_prot_enabled;
1741 	bss->rmf = bss_v0.rmf;
1742 	bss->ht_oper_mode = bss_v0.ht_oper_mode;
1743 	bss->dual_cts_protection = bss_v0.dual_cts_protection;
1744 
1745 	bss->max_probe_resp_retry_limit =
1746 		bss_v0.max_probe_resp_retry_limit;
1747 	bss->hidden_ssid = bss_v0.hidden_ssid;
1748 	bss->proxy_probe_resp =	bss_v0.proxy_probe_resp;
1749 	bss->edca_params_valid = bss_v0.edca_params_valid;
1750 
1751 	memcpy(&bss->acbe, &bss_v0.acbe,
1752 	       sizeof(bss_v0.acbe));
1753 	memcpy(&bss->acbk, &bss_v0.acbk,
1754 	       sizeof(bss_v0.acbk));
1755 	memcpy(&bss->acvi, &bss_v0.acvi,
1756 	       sizeof(bss_v0.acvi));
1757 	memcpy(&bss->acvo, &bss_v0.acvo,
1758 	       sizeof(bss_v0.acvo));
1759 
1760 	bss->ext_set_sta_key_param_valid =
1761 		bss_v0.ext_set_sta_key_param_valid;
1762 
1763 	memcpy(&bss->ext_set_sta_key_param,
1764 	       &bss_v0.ext_set_sta_key_param,
1765 	       sizeof(bss_v0.acvo));
1766 
1767 	bss->wcn36xx_hal_persona = bss_v0.wcn36xx_hal_persona;
1768 	bss->spectrum_mgt_enable = bss_v0.spectrum_mgt_enable;
1769 	bss->tx_mgmt_power = bss_v0.tx_mgmt_power;
1770 	bss->max_tx_power = bss_v0.max_tx_power;
1771 
1772 	wcn36xx_smd_set_bss_vht_params(vif, sta_80211, bss);
1773 
1774 	PREPARE_HAL_BUF(wcn->hal_buf, (*msg_body));
1775 
1776 	wcn36xx_dbg(WCN36XX_DBG_HAL,
1777 		    "hal config bss v1 bssid %pM self_mac_addr %pM bss_type %d oper_mode %d nw_type %d\n",
1778 		    bss->bssid, bss->self_mac_addr, bss->bss_type,
1779 		    bss->oper_mode, bss->nw_type);
1780 
1781 	wcn36xx_dbg(WCN36XX_DBG_HAL,
1782 		    "- sta bssid %pM action %d sta_index %d bssid_index %d aid %d type %d mac %pM\n",
1783 		    sta->bssid, sta->action, sta->sta_index,
1784 		    sta->bssid_index, sta->aid, sta->type, sta->mac);
1785 
1786 	ret = wcn36xx_smd_send_and_wait(wcn, msg_body->header.len);
1787 	kfree(msg_body);
1788 
1789 	return ret;
1790 }
1791 
1792 static int wcn36xx_smd_config_bss_v0(struct wcn36xx *wcn,
1793 				     struct ieee80211_vif *vif,
1794 				     struct ieee80211_sta *sta,
1795 				     const u8 *bssid,
1796 				     bool update)
1797 {
1798 	struct wcn36xx_hal_config_bss_req_msg *msg;
1799 	struct wcn36xx_hal_config_bss_params *bss;
1800 	struct wcn36xx_hal_config_sta_params *sta_params;
1801 	int ret;
1802 
1803 	msg = kzalloc(sizeof(*msg), GFP_KERNEL);
1804 	if (!msg)
1805 		return -ENOMEM;
1806 
1807 	INIT_HAL_MSG((*msg), WCN36XX_HAL_CONFIG_BSS_REQ);
1808 
1809 	bss = &msg->bss_params;
1810 	sta_params = &bss->sta;
1811 
1812 	wcn36xx_smd_set_bss_params(wcn, vif, sta, bssid, update, bss);
1813 	wcn36xx_smd_set_sta_params(wcn, vif, sta, sta_params);
1814 
1815 	PREPARE_HAL_BUF(wcn->hal_buf, (*msg));
1816 
1817 	wcn36xx_dbg(WCN36XX_DBG_HAL,
1818 		    "hal config bss bssid %pM self_mac_addr %pM bss_type %d oper_mode %d nw_type %d\n",
1819 		    bss->bssid, bss->self_mac_addr, bss->bss_type,
1820 		    bss->oper_mode, bss->nw_type);
1821 
1822 	wcn36xx_dbg(WCN36XX_DBG_HAL,
1823 		    "- sta bssid %pM action %d sta_index %d bssid_index %d aid %d type %d mac %pM\n",
1824 		    sta_params->bssid, sta_params->action,
1825 		    sta_params->sta_index, sta_params->bssid_index,
1826 		    sta_params->aid, sta_params->type,
1827 		    sta_params->mac);
1828 
1829 	ret = wcn36xx_smd_send_and_wait(wcn, msg->header.len);
1830 	kfree(msg);
1831 
1832 	return ret;
1833 }
1834 
1835 static int wcn36xx_smd_config_bss_rsp(struct wcn36xx *wcn,
1836 				      struct ieee80211_vif *vif,
1837 				      struct ieee80211_sta *sta,
1838 				      void *buf,
1839 				      size_t len)
1840 {
1841 	struct wcn36xx_hal_config_bss_rsp_msg *rsp;
1842 	struct wcn36xx_hal_config_bss_rsp_params *params;
1843 	struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
1844 
1845 	if (len < sizeof(*rsp))
1846 		return -EINVAL;
1847 
1848 	rsp = (struct wcn36xx_hal_config_bss_rsp_msg *)buf;
1849 	params = &rsp->bss_rsp_params;
1850 
1851 	if (params->status != WCN36XX_FW_MSG_RESULT_SUCCESS) {
1852 		wcn36xx_warn("hal config bss response failure: %d\n",
1853 			     params->status);
1854 		return -EIO;
1855 	}
1856 
1857 	wcn36xx_dbg(WCN36XX_DBG_HAL,
1858 		    "hal config bss rsp status %d bss_idx %d dpu_desc_index %d"
1859 		    " sta_idx %d self_idx %d bcast_idx %d mac %pM"
1860 		    " power %d ucast_dpu_signature %d\n",
1861 		    params->status, params->bss_index, params->dpu_desc_index,
1862 		    params->bss_sta_index, params->bss_self_sta_index,
1863 		    params->bss_bcast_sta_idx, params->mac,
1864 		    params->tx_mgmt_power, params->ucast_dpu_signature);
1865 
1866 	vif_priv->bss_index = params->bss_index;
1867 
1868 	if (sta) {
1869 		struct wcn36xx_sta *sta_priv = wcn36xx_sta_to_priv(sta);
1870 		sta_priv->bss_sta_index = params->bss_sta_index;
1871 		sta_priv->bss_dpu_desc_index = params->dpu_desc_index;
1872 	}
1873 
1874 	vif_priv->self_ucast_dpu_sign = params->ucast_dpu_signature;
1875 
1876 	return 0;
1877 }
1878 
1879 int wcn36xx_smd_config_bss(struct wcn36xx *wcn, struct ieee80211_vif *vif,
1880 			   struct ieee80211_sta *sta, const u8 *bssid,
1881 			   bool update)
1882 {
1883 	int ret;
1884 
1885 	mutex_lock(&wcn->hal_mutex);
1886 
1887 	if (!wcn36xx_is_fw_version(wcn, 1, 2, 2, 24))
1888 		ret = wcn36xx_smd_config_bss_v1(wcn, vif, sta, bssid, update);
1889 	else
1890 		ret = wcn36xx_smd_config_bss_v0(wcn, vif, sta, bssid, update);
1891 
1892 	if (ret) {
1893 		wcn36xx_err("Sending hal_config_bss failed\n");
1894 		goto out;
1895 	}
1896 	ret = wcn36xx_smd_config_bss_rsp(wcn,
1897 					 vif,
1898 					 sta,
1899 					 wcn->hal_buf,
1900 					 wcn->hal_rsp_len);
1901 	if (ret)
1902 		wcn36xx_err("hal_config_bss response failed err=%d\n", ret);
1903 
1904 out:
1905 	mutex_unlock(&wcn->hal_mutex);
1906 	return ret;
1907 }
1908 
1909 int wcn36xx_smd_delete_bss(struct wcn36xx *wcn, struct ieee80211_vif *vif)
1910 {
1911 	struct wcn36xx_hal_delete_bss_req_msg msg_body;
1912 	struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
1913 	int ret = 0;
1914 
1915 	mutex_lock(&wcn->hal_mutex);
1916 
1917 	if (vif_priv->bss_index == WCN36XX_HAL_BSS_INVALID_IDX)
1918 		goto out;
1919 
1920 	INIT_HAL_MSG(msg_body, WCN36XX_HAL_DELETE_BSS_REQ);
1921 
1922 	msg_body.bss_index = vif_priv->bss_index;
1923 
1924 	PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1925 
1926 	wcn36xx_dbg(WCN36XX_DBG_HAL, "hal delete bss %d\n", msg_body.bss_index);
1927 
1928 	ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1929 	if (ret) {
1930 		wcn36xx_err("Sending hal_delete_bss failed\n");
1931 		goto out;
1932 	}
1933 	ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
1934 	if (ret) {
1935 		wcn36xx_err("hal_delete_bss response failed err=%d\n", ret);
1936 		goto out;
1937 	}
1938 
1939 	vif_priv->bss_index = WCN36XX_HAL_BSS_INVALID_IDX;
1940 out:
1941 	mutex_unlock(&wcn->hal_mutex);
1942 	return ret;
1943 }
1944 
1945 int wcn36xx_smd_send_beacon(struct wcn36xx *wcn, struct ieee80211_vif *vif,
1946 			    struct sk_buff *skb_beacon, u16 tim_off,
1947 			    u16 p2p_off)
1948 {
1949 	struct wcn36xx_hal_send_beacon_req_msg msg_body;
1950 	int ret, pad, pvm_len;
1951 
1952 	mutex_lock(&wcn->hal_mutex);
1953 	INIT_HAL_MSG(msg_body, WCN36XX_HAL_SEND_BEACON_REQ);
1954 
1955 	pvm_len = skb_beacon->data[tim_off + 1] - 3;
1956 	pad = TIM_MIN_PVM_SIZE - pvm_len;
1957 
1958 	/* Padding is irrelevant to mesh mode since tim_off is always 0. */
1959 	if (vif->type == NL80211_IFTYPE_MESH_POINT)
1960 		pad = 0;
1961 
1962 	msg_body.beacon_length = skb_beacon->len + pad;
1963 	/* TODO need to find out why + 6 is needed */
1964 	msg_body.beacon_length6 = msg_body.beacon_length + 6;
1965 
1966 	if (msg_body.beacon_length > BEACON_TEMPLATE_SIZE) {
1967 		wcn36xx_err("Beacon is too big: beacon size=%d\n",
1968 			      msg_body.beacon_length);
1969 		ret = -ENOMEM;
1970 		goto out;
1971 	}
1972 	memcpy(msg_body.beacon, skb_beacon->data, skb_beacon->len);
1973 	memcpy(msg_body.bssid, vif->addr, ETH_ALEN);
1974 
1975 	if (pad > 0) {
1976 		/*
1977 		 * The wcn36xx FW has a fixed size for the PVM in the TIM. If
1978 		 * given the beacon template from mac80211 with a PVM shorter
1979 		 * than the FW expectes it will overwrite the data after the
1980 		 * TIM.
1981 		 */
1982 		wcn36xx_dbg(WCN36XX_DBG_HAL, "Pad TIM PVM. %d bytes at %d\n",
1983 			    pad, pvm_len);
1984 		memmove(&msg_body.beacon[tim_off + 5 + pvm_len + pad],
1985 			&msg_body.beacon[tim_off + 5 + pvm_len],
1986 			skb_beacon->len - (tim_off + 5 + pvm_len));
1987 		memset(&msg_body.beacon[tim_off + 5 + pvm_len], 0, pad);
1988 		msg_body.beacon[tim_off + 1] += pad;
1989 	}
1990 
1991 	/* TODO need to find out why this is needed? */
1992 	if (vif->type == NL80211_IFTYPE_MESH_POINT)
1993 		/* mesh beacon don't need this, so push further down */
1994 		msg_body.tim_ie_offset = 256;
1995 	else
1996 		msg_body.tim_ie_offset = tim_off+4;
1997 	msg_body.p2p_ie_offset = p2p_off;
1998 	PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1999 
2000 	wcn36xx_dbg(WCN36XX_DBG_HAL,
2001 		    "hal send beacon beacon_length %d\n",
2002 		    msg_body.beacon_length);
2003 
2004 	ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
2005 	if (ret) {
2006 		wcn36xx_err("Sending hal_send_beacon failed\n");
2007 		goto out;
2008 	}
2009 	ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
2010 	if (ret) {
2011 		wcn36xx_err("hal_send_beacon response failed err=%d\n", ret);
2012 		goto out;
2013 	}
2014 out:
2015 	mutex_unlock(&wcn->hal_mutex);
2016 	return ret;
2017 }
2018 
2019 int wcn36xx_smd_update_proberesp_tmpl(struct wcn36xx *wcn,
2020 				      struct ieee80211_vif *vif,
2021 				      struct sk_buff *skb)
2022 {
2023 	struct wcn36xx_hal_send_probe_resp_req_msg msg;
2024 	int ret;
2025 
2026 	mutex_lock(&wcn->hal_mutex);
2027 	INIT_HAL_MSG(msg, WCN36XX_HAL_UPDATE_PROBE_RSP_TEMPLATE_REQ);
2028 
2029 	if (skb->len > BEACON_TEMPLATE_SIZE) {
2030 		wcn36xx_warn("probe response template is too big: %d\n",
2031 			     skb->len);
2032 		ret = -E2BIG;
2033 		goto out;
2034 	}
2035 
2036 	msg.probe_resp_template_len = skb->len;
2037 	memcpy(&msg.probe_resp_template, skb->data, skb->len);
2038 
2039 	memcpy(msg.bssid, vif->addr, ETH_ALEN);
2040 
2041 	PREPARE_HAL_BUF(wcn->hal_buf, msg);
2042 
2043 	wcn36xx_dbg(WCN36XX_DBG_HAL,
2044 		    "hal update probe rsp len %d bssid %pM\n",
2045 		    msg.probe_resp_template_len, msg.bssid);
2046 
2047 	ret = wcn36xx_smd_send_and_wait(wcn, msg.header.len);
2048 	if (ret) {
2049 		wcn36xx_err("Sending hal_update_proberesp_tmpl failed\n");
2050 		goto out;
2051 	}
2052 	ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
2053 	if (ret) {
2054 		wcn36xx_err("hal_update_proberesp_tmpl response failed err=%d\n",
2055 			    ret);
2056 		goto out;
2057 	}
2058 out:
2059 	mutex_unlock(&wcn->hal_mutex);
2060 	return ret;
2061 }
2062 
2063 int wcn36xx_smd_set_stakey(struct wcn36xx *wcn,
2064 			   enum ani_ed_type enc_type,
2065 			   u8 keyidx,
2066 			   u8 keylen,
2067 			   u8 *key,
2068 			   u8 sta_index)
2069 {
2070 	struct wcn36xx_hal_set_sta_key_req_msg msg_body;
2071 	int ret;
2072 
2073 	mutex_lock(&wcn->hal_mutex);
2074 	INIT_HAL_MSG(msg_body, WCN36XX_HAL_SET_STAKEY_REQ);
2075 
2076 	msg_body.set_sta_key_params.sta_index = sta_index;
2077 	msg_body.set_sta_key_params.enc_type = enc_type;
2078 
2079 	if (enc_type == WCN36XX_HAL_ED_WEP104 ||
2080 	    enc_type == WCN36XX_HAL_ED_WEP40) {
2081 		/* Use bss key for wep (static) */
2082 		msg_body.set_sta_key_params.def_wep_idx = keyidx;
2083 		msg_body.set_sta_key_params.wep_type = 0;
2084 	} else {
2085 		msg_body.set_sta_key_params.key[0].id = keyidx;
2086 		msg_body.set_sta_key_params.key[0].unicast = 1;
2087 		msg_body.set_sta_key_params.key[0].direction = WCN36XX_HAL_TX_RX;
2088 		msg_body.set_sta_key_params.key[0].pae_role = 0;
2089 		msg_body.set_sta_key_params.key[0].length = keylen;
2090 		memcpy(msg_body.set_sta_key_params.key[0].key, key, keylen);
2091 	}
2092 
2093 	msg_body.set_sta_key_params.single_tid_rc = 1;
2094 
2095 	PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
2096 
2097 	ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
2098 	if (ret) {
2099 		wcn36xx_err("Sending hal_set_stakey failed\n");
2100 		goto out;
2101 	}
2102 	ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
2103 	if (ret) {
2104 		wcn36xx_err("hal_set_stakey response failed err=%d\n", ret);
2105 		goto out;
2106 	}
2107 out:
2108 	mutex_unlock(&wcn->hal_mutex);
2109 	return ret;
2110 }
2111 
2112 int wcn36xx_smd_set_bsskey(struct wcn36xx *wcn,
2113 			   enum ani_ed_type enc_type,
2114 			   u8 bssidx,
2115 			   u8 keyidx,
2116 			   u8 keylen,
2117 			   u8 *key)
2118 {
2119 	struct wcn36xx_hal_set_bss_key_req_msg msg_body;
2120 	int ret;
2121 
2122 	mutex_lock(&wcn->hal_mutex);
2123 	INIT_HAL_MSG(msg_body, WCN36XX_HAL_SET_BSSKEY_REQ);
2124 	msg_body.bss_idx = bssidx;
2125 	msg_body.enc_type = enc_type;
2126 	msg_body.num_keys = 1;
2127 	msg_body.keys[0].id = keyidx;
2128 	msg_body.keys[0].unicast = 0;
2129 	msg_body.keys[0].direction = WCN36XX_HAL_RX_ONLY;
2130 	msg_body.keys[0].pae_role = 0;
2131 	msg_body.keys[0].length = keylen;
2132 	memcpy(msg_body.keys[0].key, key, keylen);
2133 
2134 	PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
2135 
2136 	ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
2137 	if (ret) {
2138 		wcn36xx_err("Sending hal_set_bsskey failed\n");
2139 		goto out;
2140 	}
2141 	ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
2142 	if (ret) {
2143 		wcn36xx_err("hal_set_bsskey response failed err=%d\n", ret);
2144 		goto out;
2145 	}
2146 out:
2147 	mutex_unlock(&wcn->hal_mutex);
2148 	return ret;
2149 }
2150 
2151 int wcn36xx_smd_remove_stakey(struct wcn36xx *wcn,
2152 			      enum ani_ed_type enc_type,
2153 			      u8 keyidx,
2154 			      u8 sta_index)
2155 {
2156 	struct wcn36xx_hal_remove_sta_key_req_msg msg_body;
2157 	int ret;
2158 
2159 	mutex_lock(&wcn->hal_mutex);
2160 	INIT_HAL_MSG(msg_body, WCN36XX_HAL_RMV_STAKEY_REQ);
2161 
2162 	msg_body.sta_idx = sta_index;
2163 	msg_body.enc_type = enc_type;
2164 	msg_body.key_id = keyidx;
2165 
2166 	PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
2167 
2168 	ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
2169 	if (ret) {
2170 		wcn36xx_err("Sending hal_remove_stakey failed\n");
2171 		goto out;
2172 	}
2173 	ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
2174 	if (ret) {
2175 		wcn36xx_err("hal_remove_stakey response failed err=%d\n", ret);
2176 		goto out;
2177 	}
2178 out:
2179 	mutex_unlock(&wcn->hal_mutex);
2180 	return ret;
2181 }
2182 
2183 int wcn36xx_smd_remove_bsskey(struct wcn36xx *wcn,
2184 			      enum ani_ed_type enc_type,
2185 			      u8 bssidx,
2186 			      u8 keyidx)
2187 {
2188 	struct wcn36xx_hal_remove_bss_key_req_msg msg_body;
2189 	int ret;
2190 
2191 	mutex_lock(&wcn->hal_mutex);
2192 	INIT_HAL_MSG(msg_body, WCN36XX_HAL_RMV_BSSKEY_REQ);
2193 	msg_body.bss_idx = bssidx;
2194 	msg_body.enc_type = enc_type;
2195 	msg_body.key_id = keyidx;
2196 
2197 	PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
2198 
2199 	ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
2200 	if (ret) {
2201 		wcn36xx_err("Sending hal_remove_bsskey failed\n");
2202 		goto out;
2203 	}
2204 	ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
2205 	if (ret) {
2206 		wcn36xx_err("hal_remove_bsskey response failed err=%d\n", ret);
2207 		goto out;
2208 	}
2209 out:
2210 	mutex_unlock(&wcn->hal_mutex);
2211 	return ret;
2212 }
2213 
2214 int wcn36xx_smd_enter_bmps(struct wcn36xx *wcn, struct ieee80211_vif *vif)
2215 {
2216 	struct wcn36xx_hal_enter_bmps_req_msg msg_body;
2217 	struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
2218 	int ret;
2219 
2220 	mutex_lock(&wcn->hal_mutex);
2221 	INIT_HAL_MSG(msg_body, WCN36XX_HAL_ENTER_BMPS_REQ);
2222 
2223 	msg_body.bss_index = vif_priv->bss_index;
2224 	msg_body.tbtt = vif->bss_conf.sync_tsf;
2225 	msg_body.dtim_period = vif_priv->dtim_period;
2226 
2227 	PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
2228 
2229 	ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
2230 	if (ret) {
2231 		wcn36xx_err("Sending hal_enter_bmps failed\n");
2232 		goto out;
2233 	}
2234 	ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
2235 	if (ret) {
2236 		wcn36xx_err("hal_enter_bmps response failed err=%d\n", ret);
2237 		goto out;
2238 	}
2239 out:
2240 	mutex_unlock(&wcn->hal_mutex);
2241 	return ret;
2242 }
2243 
2244 int wcn36xx_smd_exit_bmps(struct wcn36xx *wcn, struct ieee80211_vif *vif)
2245 {
2246 	struct wcn36xx_hal_exit_bmps_req_msg msg_body;
2247 	struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
2248 	int ret;
2249 
2250 	mutex_lock(&wcn->hal_mutex);
2251 	INIT_HAL_MSG(msg_body, WCN36XX_HAL_EXIT_BMPS_REQ);
2252 
2253 	msg_body.bss_index = vif_priv->bss_index;
2254 	msg_body.send_data_null = 1;
2255 
2256 	PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
2257 
2258 	ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
2259 	if (ret) {
2260 		wcn36xx_err("Sending hal_exit_bmps failed\n");
2261 		goto out;
2262 	}
2263 	ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
2264 	if (ret) {
2265 		wcn36xx_err("hal_exit_bmps response failed err=%d\n", ret);
2266 		goto out;
2267 	}
2268 out:
2269 	mutex_unlock(&wcn->hal_mutex);
2270 	return ret;
2271 }
2272 
2273 int wcn36xx_smd_enter_imps(struct wcn36xx *wcn)
2274 {
2275 	struct wcn36xx_hal_enter_imps_req_msg msg_body;
2276 	int ret;
2277 
2278 	mutex_lock(&wcn->hal_mutex);
2279 	INIT_HAL_MSG(msg_body, WCN36XX_HAL_ENTER_IMPS_REQ);
2280 
2281 	PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
2282 
2283 	ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
2284 	if (ret) {
2285 		wcn36xx_err("Sending hal_enter_imps failed\n");
2286 		goto out;
2287 	}
2288 	ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
2289 	if (ret) {
2290 		wcn36xx_err("hal_enter_imps response failed err=%d\n", ret);
2291 		goto out;
2292 	}
2293 
2294 	wcn36xx_dbg(WCN36XX_DBG_HAL, "Entered idle mode\n");
2295 out:
2296 	mutex_unlock(&wcn->hal_mutex);
2297 	return ret;
2298 }
2299 
2300 int wcn36xx_smd_exit_imps(struct wcn36xx *wcn)
2301 {
2302 	struct wcn36xx_hal_exit_imps_req_msg msg_body;
2303 	int ret;
2304 
2305 	mutex_lock(&wcn->hal_mutex);
2306 	INIT_HAL_MSG(msg_body, WCN36XX_HAL_EXIT_IMPS_REQ);
2307 
2308 	PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
2309 
2310 	ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
2311 	if (ret) {
2312 		wcn36xx_err("Sending hal_exit_imps failed\n");
2313 		goto out;
2314 	}
2315 	ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
2316 	if (ret) {
2317 		wcn36xx_err("hal_exit_imps response failed err=%d\n", ret);
2318 		goto out;
2319 	}
2320 	wcn36xx_dbg(WCN36XX_DBG_HAL, "Exited idle mode\n");
2321 out:
2322 	mutex_unlock(&wcn->hal_mutex);
2323 	return ret;
2324 }
2325 
2326 int wcn36xx_smd_set_power_params(struct wcn36xx *wcn, bool ignore_dtim)
2327 {
2328 	struct wcn36xx_hal_set_power_params_req_msg msg_body;
2329 	int ret;
2330 
2331 	mutex_lock(&wcn->hal_mutex);
2332 	INIT_HAL_MSG(msg_body, WCN36XX_HAL_SET_POWER_PARAMS_REQ);
2333 
2334 	/*
2335 	 * When host is down ignore every second dtim
2336 	 */
2337 	if (ignore_dtim) {
2338 		msg_body.ignore_dtim = 1;
2339 		msg_body.dtim_period = 2;
2340 	}
2341 	msg_body.listen_interval = WCN36XX_LISTEN_INTERVAL(wcn);
2342 
2343 	PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
2344 
2345 	ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
2346 	if (ret) {
2347 		wcn36xx_err("Sending hal_set_power_params failed\n");
2348 		goto out;
2349 	}
2350 
2351 out:
2352 	mutex_unlock(&wcn->hal_mutex);
2353 	return ret;
2354 }
2355 
2356 /* Notice: This function should be called after associated, or else it
2357  * will be invalid
2358  */
2359 int wcn36xx_smd_keep_alive_req(struct wcn36xx *wcn,
2360 			       struct ieee80211_vif *vif,
2361 			       int packet_type)
2362 {
2363 	struct wcn36xx_hal_keep_alive_req_msg msg_body;
2364 	struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
2365 	int ret;
2366 
2367 	mutex_lock(&wcn->hal_mutex);
2368 	INIT_HAL_MSG(msg_body, WCN36XX_HAL_KEEP_ALIVE_REQ);
2369 
2370 	if (packet_type == WCN36XX_HAL_KEEP_ALIVE_NULL_PKT) {
2371 		msg_body.bss_index = vif_priv->bss_index;
2372 		msg_body.packet_type = WCN36XX_HAL_KEEP_ALIVE_NULL_PKT;
2373 		msg_body.time_period = WCN36XX_KEEP_ALIVE_TIME_PERIOD;
2374 	} else if (packet_type == WCN36XX_HAL_KEEP_ALIVE_UNSOLICIT_ARP_RSP) {
2375 		/* TODO: it also support ARP response type */
2376 	} else {
2377 		wcn36xx_warn("unknown keep alive packet type %d\n", packet_type);
2378 		ret = -EINVAL;
2379 		goto out;
2380 	}
2381 
2382 	PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
2383 
2384 	ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
2385 	if (ret) {
2386 		wcn36xx_err("Sending hal_keep_alive failed\n");
2387 		goto out;
2388 	}
2389 	ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
2390 	if (ret) {
2391 		wcn36xx_err("hal_keep_alive response failed err=%d\n", ret);
2392 		goto out;
2393 	}
2394 out:
2395 	mutex_unlock(&wcn->hal_mutex);
2396 	return ret;
2397 }
2398 
2399 int wcn36xx_smd_dump_cmd_req(struct wcn36xx *wcn, u32 arg1, u32 arg2,
2400 			     u32 arg3, u32 arg4, u32 arg5)
2401 {
2402 	struct wcn36xx_hal_dump_cmd_req_msg msg_body;
2403 	int ret;
2404 
2405 	mutex_lock(&wcn->hal_mutex);
2406 	INIT_HAL_MSG(msg_body, WCN36XX_HAL_DUMP_COMMAND_REQ);
2407 
2408 	msg_body.arg1 = arg1;
2409 	msg_body.arg2 = arg2;
2410 	msg_body.arg3 = arg3;
2411 	msg_body.arg4 = arg4;
2412 	msg_body.arg5 = arg5;
2413 
2414 	PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
2415 
2416 	ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
2417 	if (ret) {
2418 		wcn36xx_err("Sending hal_dump_cmd failed\n");
2419 		goto out;
2420 	}
2421 	ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
2422 	if (ret) {
2423 		wcn36xx_err("hal_dump_cmd response failed err=%d\n", ret);
2424 		goto out;
2425 	}
2426 out:
2427 	mutex_unlock(&wcn->hal_mutex);
2428 	return ret;
2429 }
2430 
2431 void set_feat_caps(u32 *bitmap, enum place_holder_in_cap_bitmap cap)
2432 {
2433 	int arr_idx, bit_idx;
2434 
2435 	if (cap < 0 || cap > 127) {
2436 		wcn36xx_warn("error cap idx %d\n", cap);
2437 		return;
2438 	}
2439 
2440 	arr_idx = cap / 32;
2441 	bit_idx = cap % 32;
2442 	bitmap[arr_idx] |= (1 << bit_idx);
2443 }
2444 
2445 int get_feat_caps(u32 *bitmap, enum place_holder_in_cap_bitmap cap)
2446 {
2447 	int arr_idx, bit_idx;
2448 
2449 	if (cap < 0 || cap > 127) {
2450 		wcn36xx_warn("error cap idx %d\n", cap);
2451 		return -EINVAL;
2452 	}
2453 
2454 	arr_idx = cap / 32;
2455 	bit_idx = cap % 32;
2456 
2457 	return (bitmap[arr_idx] & (1 << bit_idx)) ? 1 : 0;
2458 }
2459 
2460 void clear_feat_caps(u32 *bitmap, enum place_holder_in_cap_bitmap cap)
2461 {
2462 	int arr_idx, bit_idx;
2463 
2464 	if (cap < 0 || cap > 127) {
2465 		wcn36xx_warn("error cap idx %d\n", cap);
2466 		return;
2467 	}
2468 
2469 	arr_idx = cap / 32;
2470 	bit_idx = cap % 32;
2471 	bitmap[arr_idx] &= ~(1 << bit_idx);
2472 }
2473 
2474 int wcn36xx_smd_feature_caps_exchange(struct wcn36xx *wcn)
2475 {
2476 	struct wcn36xx_hal_feat_caps_msg msg_body, *rsp;
2477 	int ret, i;
2478 
2479 	mutex_lock(&wcn->hal_mutex);
2480 	INIT_HAL_MSG(msg_body, WCN36XX_HAL_FEATURE_CAPS_EXCHANGE_REQ);
2481 
2482 	set_feat_caps(msg_body.feat_caps, STA_POWERSAVE);
2483 	if (wcn->rf_id == RF_IRIS_WCN3680) {
2484 		set_feat_caps(msg_body.feat_caps, DOT11AC);
2485 		set_feat_caps(msg_body.feat_caps, WLAN_CH144);
2486 		set_feat_caps(msg_body.feat_caps, ANTENNA_DIVERSITY_SELECTION);
2487 	}
2488 
2489 	PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
2490 
2491 	ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
2492 	if (ret) {
2493 		wcn36xx_err("Sending hal_feature_caps_exchange failed\n");
2494 		goto out;
2495 	}
2496 	if (wcn->hal_rsp_len != sizeof(*rsp)) {
2497 		wcn36xx_err("Invalid hal_feature_caps_exchange response");
2498 		goto out;
2499 	}
2500 
2501 	rsp = (struct wcn36xx_hal_feat_caps_msg *) wcn->hal_buf;
2502 
2503 	for (i = 0; i < WCN36XX_HAL_CAPS_SIZE; i++)
2504 		wcn->fw_feat_caps[i] = rsp->feat_caps[i];
2505 out:
2506 	mutex_unlock(&wcn->hal_mutex);
2507 	return ret;
2508 }
2509 
2510 static int wcn36xx_smd_add_ba_session_rsp(void *buf, int len, u8 *session)
2511 {
2512 	struct wcn36xx_hal_add_ba_session_rsp_msg *rsp;
2513 
2514 	if (len < sizeof(*rsp))
2515 		return -EINVAL;
2516 
2517 	rsp = (struct wcn36xx_hal_add_ba_session_rsp_msg *)buf;
2518 	if (rsp->status != WCN36XX_FW_MSG_RESULT_SUCCESS)
2519 		return rsp->status;
2520 
2521 	*session = rsp->ba_session_id;
2522 
2523 	return 0;
2524 }
2525 
2526 int wcn36xx_smd_add_ba_session(struct wcn36xx *wcn,
2527 		struct ieee80211_sta *sta,
2528 		u16 tid,
2529 		u16 *ssn,
2530 		u8 direction,
2531 		u8 sta_index)
2532 {
2533 	struct wcn36xx_hal_add_ba_session_req_msg msg_body;
2534 	u8 session_id;
2535 	int ret;
2536 
2537 	mutex_lock(&wcn->hal_mutex);
2538 	INIT_HAL_MSG(msg_body, WCN36XX_HAL_ADD_BA_SESSION_REQ);
2539 
2540 	msg_body.sta_index = sta_index;
2541 	memcpy(&msg_body.mac_addr, sta->addr, ETH_ALEN);
2542 	msg_body.dialog_token = 0x10;
2543 	msg_body.tid = tid;
2544 
2545 	/* Immediate BA because Delayed BA is not supported */
2546 	msg_body.policy = 1;
2547 	msg_body.buffer_size = WCN36XX_AGGR_BUFFER_SIZE;
2548 	msg_body.timeout = 0;
2549 	if (ssn)
2550 		msg_body.ssn = *ssn;
2551 	msg_body.direction = direction;
2552 
2553 	PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
2554 
2555 	ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
2556 	if (ret) {
2557 		wcn36xx_err("Sending hal_add_ba_session failed\n");
2558 		goto out;
2559 	}
2560 	ret = wcn36xx_smd_add_ba_session_rsp(wcn->hal_buf, wcn->hal_rsp_len,
2561 					     &session_id);
2562 	if (ret) {
2563 		wcn36xx_err("hal_add_ba_session response failed err=%d\n", ret);
2564 		ret = -EINVAL;
2565 		goto out;
2566 	}
2567 
2568 	ret = session_id;
2569 out:
2570 	mutex_unlock(&wcn->hal_mutex);
2571 	return ret;
2572 }
2573 
2574 int wcn36xx_smd_add_ba(struct wcn36xx *wcn, u8 session_id)
2575 {
2576 	struct wcn36xx_hal_add_ba_req_msg msg_body;
2577 	int ret;
2578 
2579 	mutex_lock(&wcn->hal_mutex);
2580 	INIT_HAL_MSG(msg_body, WCN36XX_HAL_ADD_BA_REQ);
2581 
2582 	msg_body.session_id = session_id;
2583 	msg_body.win_size = WCN36XX_AGGR_BUFFER_SIZE;
2584 
2585 	PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
2586 
2587 	ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
2588 	if (ret) {
2589 		wcn36xx_err("Sending hal_add_ba failed\n");
2590 		goto out;
2591 	}
2592 	ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
2593 	if (ret) {
2594 		wcn36xx_err("hal_add_ba response failed err=%d\n", ret);
2595 		goto out;
2596 	}
2597 out:
2598 	mutex_unlock(&wcn->hal_mutex);
2599 	return ret;
2600 }
2601 
2602 int wcn36xx_smd_del_ba(struct wcn36xx *wcn, u16 tid, u8 direction, u8 sta_index)
2603 {
2604 	struct wcn36xx_hal_del_ba_req_msg msg_body;
2605 	int ret;
2606 
2607 	mutex_lock(&wcn->hal_mutex);
2608 	INIT_HAL_MSG(msg_body, WCN36XX_HAL_DEL_BA_REQ);
2609 
2610 	msg_body.sta_index = sta_index;
2611 	msg_body.tid = tid;
2612 	msg_body.direction = direction;
2613 	PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
2614 
2615 	ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
2616 	if (ret) {
2617 		wcn36xx_err("Sending hal_del_ba failed\n");
2618 		goto out;
2619 	}
2620 	ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
2621 	if (ret) {
2622 		wcn36xx_err("hal_del_ba response failed err=%d\n", ret);
2623 		goto out;
2624 	}
2625 out:
2626 	mutex_unlock(&wcn->hal_mutex);
2627 	return ret;
2628 }
2629 
2630 static int wcn36xx_smd_trigger_ba_rsp(void *buf, int len, struct add_ba_info *ba_info)
2631 {
2632 	struct wcn36xx_hal_trigger_ba_rsp_candidate *candidate;
2633 	struct wcn36xx_hal_trigger_ba_rsp_msg *rsp;
2634 	int i;
2635 
2636 	if (len < sizeof(*rsp))
2637 		return -EINVAL;
2638 
2639 	rsp = (struct wcn36xx_hal_trigger_ba_rsp_msg *) buf;
2640 
2641 	if (rsp->candidate_cnt < 1)
2642 		return rsp->status ? rsp->status : -EINVAL;
2643 
2644 	candidate = (struct wcn36xx_hal_trigger_ba_rsp_candidate *)(buf + sizeof(*rsp));
2645 
2646 	for (i = 0; i < STACFG_MAX_TC; i++) {
2647 		ba_info[i] = candidate->ba_info[i];
2648 	}
2649 
2650 	return rsp->status;
2651 }
2652 
2653 int wcn36xx_smd_trigger_ba(struct wcn36xx *wcn, u8 sta_index, u16 tid, u16 *ssn)
2654 {
2655 	struct wcn36xx_hal_trigger_ba_req_msg msg_body;
2656 	struct wcn36xx_hal_trigger_ba_req_candidate *candidate;
2657 	struct add_ba_info ba_info[STACFG_MAX_TC];
2658 	int ret;
2659 
2660 	if (tid >= STACFG_MAX_TC)
2661 		return -EINVAL;
2662 
2663 	mutex_lock(&wcn->hal_mutex);
2664 	INIT_HAL_MSG(msg_body, WCN36XX_HAL_TRIGGER_BA_REQ);
2665 
2666 	msg_body.session_id = 0; /* not really used */
2667 	msg_body.candidate_cnt = 1;
2668 	msg_body.header.len += sizeof(*candidate);
2669 	PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
2670 
2671 	candidate = (struct wcn36xx_hal_trigger_ba_req_candidate *)
2672 		(wcn->hal_buf + sizeof(msg_body));
2673 	candidate->sta_index = sta_index;
2674 	candidate->tid_bitmap = 1 << tid;
2675 
2676 	ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
2677 	if (ret) {
2678 		wcn36xx_err("Sending hal_trigger_ba failed\n");
2679 		goto out;
2680 	}
2681 	ret = wcn36xx_smd_trigger_ba_rsp(wcn->hal_buf, wcn->hal_rsp_len, ba_info);
2682 	if (ret) {
2683 		wcn36xx_err("hal_trigger_ba response failed err=%d\n", ret);
2684 		goto out;
2685 	}
2686 out:
2687 	mutex_unlock(&wcn->hal_mutex);
2688 
2689 	if (ssn)
2690 		*ssn = ba_info[tid].starting_seq_num;
2691 
2692 	return ret;
2693 }
2694 
2695 static int wcn36xx_smd_tx_compl_ind(struct wcn36xx *wcn, void *buf, size_t len)
2696 {
2697 	struct wcn36xx_hal_tx_compl_ind_msg *rsp = buf;
2698 
2699 	if (len != sizeof(*rsp)) {
2700 		wcn36xx_warn("Bad TX complete indication\n");
2701 		return -EIO;
2702 	}
2703 
2704 	wcn36xx_dxe_tx_ack_ind(wcn, rsp->status);
2705 
2706 	return 0;
2707 }
2708 
2709 static int wcn36xx_smd_hw_scan_ind(struct wcn36xx *wcn, void *buf, size_t len)
2710 {
2711 	struct wcn36xx_hal_scan_offload_ind *rsp = buf;
2712 	struct cfg80211_scan_info scan_info = {};
2713 
2714 	if (len != sizeof(*rsp)) {
2715 		wcn36xx_warn("Corrupted delete scan indication\n");
2716 		return -EIO;
2717 	}
2718 
2719 	wcn36xx_dbg(WCN36XX_DBG_HAL, "scan indication (type %x)\n", rsp->type);
2720 
2721 	switch (rsp->type) {
2722 	case WCN36XX_HAL_SCAN_IND_FAILED:
2723 	case WCN36XX_HAL_SCAN_IND_DEQUEUED:
2724 		scan_info.aborted = true;
2725 		fallthrough;
2726 	case WCN36XX_HAL_SCAN_IND_COMPLETED:
2727 		mutex_lock(&wcn->scan_lock);
2728 		wcn->scan_req = NULL;
2729 		if (wcn->scan_aborted)
2730 			scan_info.aborted = true;
2731 		mutex_unlock(&wcn->scan_lock);
2732 		ieee80211_scan_completed(wcn->hw, &scan_info);
2733 		break;
2734 	case WCN36XX_HAL_SCAN_IND_STARTED:
2735 	case WCN36XX_HAL_SCAN_IND_FOREIGN_CHANNEL:
2736 	case WCN36XX_HAL_SCAN_IND_PREEMPTED:
2737 	case WCN36XX_HAL_SCAN_IND_RESTARTED:
2738 		break;
2739 	default:
2740 		wcn36xx_warn("Unknown scan indication type %x\n", rsp->type);
2741 	}
2742 
2743 	return 0;
2744 }
2745 
2746 static int wcn36xx_smd_missed_beacon_ind(struct wcn36xx *wcn,
2747 					 void *buf,
2748 					 size_t len)
2749 {
2750 	struct wcn36xx_hal_missed_beacon_ind_msg *rsp = buf;
2751 	struct ieee80211_vif *vif = NULL;
2752 	struct wcn36xx_vif *tmp;
2753 
2754 	/* Old FW does not have bss index */
2755 	if (wcn36xx_is_fw_version(wcn, 1, 2, 2, 24)) {
2756 		list_for_each_entry(tmp, &wcn->vif_list, list) {
2757 			wcn36xx_dbg(WCN36XX_DBG_HAL, "beacon missed bss_index %d\n",
2758 				    tmp->bss_index);
2759 			vif = wcn36xx_priv_to_vif(tmp);
2760 			ieee80211_beacon_loss(vif);
2761 		}
2762 		return 0;
2763 	}
2764 
2765 	if (len != sizeof(*rsp)) {
2766 		wcn36xx_warn("Corrupted missed beacon indication\n");
2767 		return -EIO;
2768 	}
2769 
2770 	list_for_each_entry(tmp, &wcn->vif_list, list) {
2771 		if (tmp->bss_index == rsp->bss_index) {
2772 			wcn36xx_dbg(WCN36XX_DBG_HAL, "beacon missed bss_index %d\n",
2773 				    rsp->bss_index);
2774 			vif = wcn36xx_priv_to_vif(tmp);
2775 			ieee80211_beacon_loss(vif);
2776 			return 0;
2777 		}
2778 	}
2779 
2780 	wcn36xx_warn("BSS index %d not found\n", rsp->bss_index);
2781 	return -ENOENT;
2782 }
2783 
2784 static int wcn36xx_smd_delete_sta_context_ind(struct wcn36xx *wcn,
2785 					      void *buf,
2786 					      size_t len)
2787 {
2788 	struct wcn36xx_hal_delete_sta_context_ind_msg *rsp = buf;
2789 	struct wcn36xx_vif *vif_priv;
2790 	struct ieee80211_vif *vif;
2791 	struct ieee80211_bss_conf *bss_conf;
2792 	struct ieee80211_sta *sta;
2793 	bool found = false;
2794 
2795 	if (len != sizeof(*rsp)) {
2796 		wcn36xx_warn("Corrupted delete sta indication\n");
2797 		return -EIO;
2798 	}
2799 
2800 	wcn36xx_dbg(WCN36XX_DBG_HAL,
2801 		    "delete station indication %pM index %d reason %d\n",
2802 		    rsp->addr2, rsp->sta_id, rsp->reason_code);
2803 
2804 	list_for_each_entry(vif_priv, &wcn->vif_list, list) {
2805 		rcu_read_lock();
2806 		vif = wcn36xx_priv_to_vif(vif_priv);
2807 
2808 		if (vif->type == NL80211_IFTYPE_STATION) {
2809 			/* We could call ieee80211_find_sta too, but checking
2810 			 * bss_conf is clearer.
2811 			 */
2812 			bss_conf = &vif->bss_conf;
2813 			if (vif_priv->sta_assoc &&
2814 			    !memcmp(bss_conf->bssid, rsp->addr2, ETH_ALEN)) {
2815 				found = true;
2816 				wcn36xx_dbg(WCN36XX_DBG_HAL,
2817 					    "connection loss bss_index %d\n",
2818 					    vif_priv->bss_index);
2819 				ieee80211_connection_loss(vif);
2820 			}
2821 		} else {
2822 			sta = ieee80211_find_sta(vif, rsp->addr2);
2823 			if (sta) {
2824 				found = true;
2825 				ieee80211_report_low_ack(sta, 0);
2826 			}
2827 		}
2828 
2829 		rcu_read_unlock();
2830 		if (found)
2831 			return 0;
2832 	}
2833 
2834 	wcn36xx_warn("BSS or STA with addr %pM not found\n", rsp->addr2);
2835 	return -ENOENT;
2836 }
2837 
2838 static int wcn36xx_smd_print_reg_info_ind(struct wcn36xx *wcn,
2839 					  void *buf,
2840 					  size_t len)
2841 {
2842 	struct wcn36xx_hal_print_reg_info_ind *rsp = buf;
2843 	int i;
2844 
2845 	if (len < sizeof(*rsp)) {
2846 		wcn36xx_warn("Corrupted print reg info indication\n");
2847 		return -EIO;
2848 	}
2849 
2850 	wcn36xx_dbg(WCN36XX_DBG_HAL,
2851 		    "reginfo indication, scenario: 0x%x reason: 0x%x\n",
2852 		    rsp->scenario, rsp->reason);
2853 
2854 	for (i = 0; i < rsp->count; i++) {
2855 		wcn36xx_dbg(WCN36XX_DBG_HAL, "\t0x%x: 0x%x\n",
2856 			    rsp->regs[i].addr, rsp->regs[i].value);
2857 	}
2858 
2859 	return 0;
2860 }
2861 
2862 int wcn36xx_smd_update_cfg(struct wcn36xx *wcn, u32 cfg_id, u32 value)
2863 {
2864 	struct wcn36xx_hal_update_cfg_req_msg msg_body, *body;
2865 	size_t len;
2866 	int ret;
2867 
2868 	mutex_lock(&wcn->hal_mutex);
2869 	INIT_HAL_MSG(msg_body, WCN36XX_HAL_UPDATE_CFG_REQ);
2870 
2871 	PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
2872 
2873 	body = (struct wcn36xx_hal_update_cfg_req_msg *) wcn->hal_buf;
2874 	len = msg_body.header.len;
2875 
2876 	put_cfg_tlv_u32(wcn, &len, cfg_id, value);
2877 	body->header.len = len;
2878 	body->len = len - sizeof(*body);
2879 
2880 	ret = wcn36xx_smd_send_and_wait(wcn, body->header.len);
2881 	if (ret) {
2882 		wcn36xx_err("Sending hal_update_cfg failed\n");
2883 		goto out;
2884 	}
2885 	ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
2886 	if (ret) {
2887 		wcn36xx_err("hal_update_cfg response failed err=%d\n", ret);
2888 		goto out;
2889 	}
2890 out:
2891 	mutex_unlock(&wcn->hal_mutex);
2892 	return ret;
2893 }
2894 
2895 int wcn36xx_smd_set_mc_list(struct wcn36xx *wcn,
2896 			    struct ieee80211_vif *vif,
2897 			    struct wcn36xx_hal_rcv_flt_mc_addr_list_type *fp)
2898 {
2899 	struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
2900 	struct wcn36xx_hal_rcv_flt_pkt_set_mc_list_req_msg *msg_body = NULL;
2901 	int ret;
2902 
2903 	mutex_lock(&wcn->hal_mutex);
2904 
2905 	msg_body = (struct wcn36xx_hal_rcv_flt_pkt_set_mc_list_req_msg *)
2906 		   wcn->hal_buf;
2907 	INIT_HAL_MSG(*msg_body, WCN36XX_HAL_8023_MULTICAST_LIST_REQ);
2908 
2909 	/* An empty list means all mc traffic will be received */
2910 	if (fp)
2911 		memcpy(&msg_body->mc_addr_list, fp,
2912 		       sizeof(msg_body->mc_addr_list));
2913 	else
2914 		msg_body->mc_addr_list.mc_addr_count = 0;
2915 
2916 	msg_body->mc_addr_list.bss_index = vif_priv->bss_index;
2917 
2918 	ret = wcn36xx_smd_send_and_wait(wcn, msg_body->header.len);
2919 	if (ret) {
2920 		wcn36xx_err("Sending HAL_8023_MULTICAST_LIST failed\n");
2921 		goto out;
2922 	}
2923 	ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
2924 	if (ret) {
2925 		wcn36xx_err("HAL_8023_MULTICAST_LIST rsp failed err=%d\n", ret);
2926 		goto out;
2927 	}
2928 out:
2929 	mutex_unlock(&wcn->hal_mutex);
2930 	return ret;
2931 }
2932 
2933 int wcn36xx_smd_arp_offload(struct wcn36xx *wcn, struct ieee80211_vif *vif,
2934 			    bool enable)
2935 {
2936 	struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
2937 	struct wcn36xx_hal_host_offload_req_msg msg_body;
2938 	int ret;
2939 
2940 	mutex_lock(&wcn->hal_mutex);
2941 
2942 	INIT_HAL_MSG(msg_body, WCN36XX_HAL_HOST_OFFLOAD_REQ);
2943 	msg_body.host_offload_params.offload_type =
2944 		WCN36XX_HAL_IPV4_ARP_REPLY_OFFLOAD;
2945 	if (enable) {
2946 		msg_body.host_offload_params.enable =
2947 			WCN36XX_HAL_OFFLOAD_ARP_AND_BCAST_FILTER_ENABLE;
2948 		memcpy(&msg_body.host_offload_params.u,
2949 		       &vif->bss_conf.arp_addr_list[0], sizeof(__be32));
2950 	}
2951 	msg_body.ns_offload_params.bss_index = vif_priv->bss_index;
2952 
2953 	PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
2954 
2955 	ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
2956 	if (ret) {
2957 		wcn36xx_err("Sending host_offload_arp failed\n");
2958 		goto out;
2959 	}
2960 	ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
2961 	if (ret) {
2962 		wcn36xx_err("host_offload_arp failed err=%d\n", ret);
2963 		goto out;
2964 	}
2965 out:
2966 	mutex_unlock(&wcn->hal_mutex);
2967 	return ret;
2968 }
2969 
2970 #if IS_ENABLED(CONFIG_IPV6)
2971 int wcn36xx_smd_ipv6_ns_offload(struct wcn36xx *wcn, struct ieee80211_vif *vif,
2972 				bool enable)
2973 {
2974 	struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
2975 	struct wcn36xx_hal_host_offload_req_msg msg_body;
2976 	struct wcn36xx_hal_ns_offload_params *ns_params;
2977 	struct wcn36xx_hal_host_offload_req *ho_params;
2978 	int ret;
2979 
2980 	mutex_lock(&wcn->hal_mutex);
2981 
2982 	INIT_HAL_MSG(msg_body, WCN36XX_HAL_HOST_OFFLOAD_REQ);
2983 	ho_params = &msg_body.host_offload_params;
2984 	ns_params = &msg_body.ns_offload_params;
2985 
2986 	ho_params->offload_type = WCN36XX_HAL_IPV6_NS_OFFLOAD;
2987 	if (enable) {
2988 		ho_params->enable =
2989 			WCN36XX_HAL_OFFLOAD_NS_AND_MCAST_FILTER_ENABLE;
2990 		if (vif_priv->num_target_ipv6_addrs) {
2991 			memcpy(&ho_params->u,
2992 			       &vif_priv->target_ipv6_addrs[0].in6_u,
2993 			       sizeof(struct in6_addr));
2994 			memcpy(&ns_params->target_ipv6_addr1,
2995 			       &vif_priv->target_ipv6_addrs[0].in6_u,
2996 			       sizeof(struct in6_addr));
2997 			ns_params->target_ipv6_addr1_valid = 1;
2998 		}
2999 		if (vif_priv->num_target_ipv6_addrs > 1) {
3000 			memcpy(&ns_params->target_ipv6_addr2,
3001 			       &vif_priv->target_ipv6_addrs[1].in6_u,
3002 			       sizeof(struct in6_addr));
3003 			ns_params->target_ipv6_addr2_valid = 1;
3004 		}
3005 	}
3006 	memcpy(&ns_params->self_addr, vif->addr, ETH_ALEN);
3007 	ns_params->bss_index = vif_priv->bss_index;
3008 
3009 	PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
3010 
3011 	ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
3012 	if (ret) {
3013 		wcn36xx_err("Sending host_offload_arp failed\n");
3014 		goto out;
3015 	}
3016 	ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
3017 	if (ret) {
3018 		wcn36xx_err("host_offload_arp failed err=%d\n", ret);
3019 		goto out;
3020 	}
3021 out:
3022 	mutex_unlock(&wcn->hal_mutex);
3023 	return ret;
3024 }
3025 #else
3026 int wcn36xx_smd_ipv6_ns_offload(struct wcn36xx *wcn, struct ieee80211_vif *vif,
3027 				bool enable)
3028 {
3029 	return 0;
3030 }
3031 #endif
3032 
3033 int wcn36xx_smd_gtk_offload(struct wcn36xx *wcn, struct ieee80211_vif *vif,
3034 			    bool enable)
3035 {
3036 	struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
3037 	struct wcn36xx_hal_gtk_offload_req_msg msg_body;
3038 	int ret;
3039 
3040 	mutex_lock(&wcn->hal_mutex);
3041 
3042 	INIT_HAL_MSG(msg_body, WCN36XX_HAL_GTK_OFFLOAD_REQ);
3043 
3044 	if (enable) {
3045 		memcpy(&msg_body.kek, vif_priv->rekey_data.kek, NL80211_KEK_LEN);
3046 		memcpy(&msg_body.kck, vif_priv->rekey_data.kck, NL80211_KCK_LEN);
3047 		msg_body.key_replay_counter =
3048 			le64_to_cpu(vif_priv->rekey_data.replay_ctr);
3049 		msg_body.bss_index = vif_priv->bss_index;
3050 	} else {
3051 		msg_body.flags = WCN36XX_HAL_GTK_OFFLOAD_FLAGS_DISABLE;
3052 	}
3053 
3054 	PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
3055 
3056 	ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
3057 	if (ret) {
3058 		wcn36xx_err("Sending host_offload_arp failed\n");
3059 		goto out;
3060 	}
3061 	ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
3062 	if (ret) {
3063 		wcn36xx_err("host_offload_arp failed err=%d\n", ret);
3064 		goto out;
3065 	}
3066 out:
3067 	mutex_unlock(&wcn->hal_mutex);
3068 	return ret;
3069 }
3070 
3071 static int wcn36xx_smd_gtk_offload_get_info_rsp(struct wcn36xx *wcn,
3072 						struct ieee80211_vif *vif)
3073 {
3074 	struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
3075 	struct wcn36xx_hal_gtk_offload_get_info_rsp_msg *rsp;
3076 	__be64 replay_ctr;
3077 
3078 	if (wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len))
3079 		return -EIO;
3080 
3081 	rsp = (struct wcn36xx_hal_gtk_offload_get_info_rsp_msg *)wcn->hal_buf;
3082 
3083 	if (rsp->bss_index != vif_priv->bss_index) {
3084 		wcn36xx_err("gtk_offload_info invalid response bss index %d\n",
3085 			    rsp->bss_index);
3086 		return -ENOENT;
3087 	}
3088 
3089 	if (vif_priv->rekey_data.replay_ctr != cpu_to_le64(rsp->key_replay_counter)) {
3090 		replay_ctr = cpu_to_be64(rsp->key_replay_counter);
3091 		vif_priv->rekey_data.replay_ctr =
3092 			cpu_to_le64(rsp->key_replay_counter);
3093 		ieee80211_gtk_rekey_notify(vif, vif->bss_conf.bssid,
3094 					   (void *)&replay_ctr, GFP_KERNEL);
3095 		 wcn36xx_dbg(WCN36XX_DBG_HAL,
3096 			     "GTK replay counter increment %llu\n",
3097 			     rsp->key_replay_counter);
3098 	}
3099 
3100 	wcn36xx_dbg(WCN36XX_DBG_HAL,
3101 		    "gtk offload info status %d last_rekey_status %d "
3102 		    "replay_counter %llu total_rekey_count %d gtk_rekey_count %d "
3103 		    "igtk_rekey_count %d bss_index %d\n",
3104 		    rsp->status, rsp->last_rekey_status,
3105 		    rsp->key_replay_counter, rsp->total_rekey_count,
3106 		    rsp->gtk_rekey_count, rsp->igtk_rekey_count,
3107 		    rsp->bss_index);
3108 
3109 	return 0;
3110 }
3111 
3112 int wcn36xx_smd_gtk_offload_get_info(struct wcn36xx *wcn,
3113 				     struct ieee80211_vif *vif)
3114 {
3115 	struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
3116 	struct wcn36xx_hal_gtk_offload_get_info_req_msg msg_body;
3117 	int ret;
3118 
3119 	mutex_lock(&wcn->hal_mutex);
3120 
3121 	INIT_HAL_MSG(msg_body, WCN36XX_HAL_GTK_OFFLOAD_GETINFO_REQ);
3122 
3123 	msg_body.bss_index = vif_priv->bss_index;
3124 
3125 	PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
3126 
3127 	ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
3128 	if (ret) {
3129 		wcn36xx_err("Sending gtk_offload_get_info failed\n");
3130 		goto out;
3131 	}
3132 	ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
3133 	if (ret) {
3134 		wcn36xx_err("gtk_offload_get_info failed err=%d\n", ret);
3135 		goto out;
3136 	}
3137 	ret = wcn36xx_smd_gtk_offload_get_info_rsp(wcn, vif);
3138 out:
3139 	mutex_unlock(&wcn->hal_mutex);
3140 	return ret;
3141 }
3142 
3143 int wcn36xx_smd_wlan_host_suspend_ind(struct wcn36xx *wcn)
3144 {
3145 	struct wcn36xx_hal_wlan_host_suspend_ind_msg msg_body;
3146 	int ret;
3147 
3148 	mutex_lock(&wcn->hal_mutex);
3149 
3150 	INIT_HAL_MSG(msg_body, WCN36XX_HAL_HOST_SUSPEND_IND);
3151 	msg_body.configured_mcst_bcst_filter_setting = 0;
3152 	msg_body.active_session_count = 1;
3153 	PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
3154 
3155 	ret = rpmsg_send(wcn->smd_channel, wcn->hal_buf, msg_body.header.len);
3156 
3157 	mutex_unlock(&wcn->hal_mutex);
3158 
3159 	return ret;
3160 }
3161 
3162 int wcn36xx_smd_host_resume(struct wcn36xx *wcn)
3163 {
3164 	struct wcn36xx_hal_wlan_host_resume_req_msg msg_body;
3165 	struct wcn36xx_hal_host_resume_rsp_msg *rsp;
3166 	int ret;
3167 
3168 	mutex_lock(&wcn->hal_mutex);
3169 
3170 	INIT_HAL_MSG(msg_body, WCN36XX_HAL_HOST_RESUME_REQ);
3171 	msg_body.configured_mcst_bcst_filter_setting = 0;
3172 
3173 	PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
3174 
3175 	ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
3176 	if (ret) {
3177 		wcn36xx_err("Sending wlan_host_resume failed\n");
3178 		goto out;
3179 	}
3180 	ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
3181 	if (ret) {
3182 		wcn36xx_err("wlan_host_resume err=%d\n", ret);
3183 		goto out;
3184 	}
3185 
3186 	rsp = (struct wcn36xx_hal_host_resume_rsp_msg *)wcn->hal_buf;
3187 	if (rsp->status)
3188 		wcn36xx_warn("wlan_host_resume status=%d\n", rsp->status);
3189 
3190 out:
3191 	mutex_unlock(&wcn->hal_mutex);
3192 
3193 	return ret;
3194 }
3195 
3196 #define BEACON_FILTER(eid, presence, offs, val, mask, ref_val) \
3197 	{					\
3198 		.element_id = eid,		\
3199 		.check_ie_presence = presence,	\
3200 		.offset = offs,			\
3201 		.value = val,			\
3202 		.bitmask = mask,		\
3203 		.ref = ref_val,			\
3204 	}
3205 
3206 static const struct beacon_filter_ie bcn_filter_ies[] = {
3207 	BEACON_FILTER(WLAN_EID_DS_PARAMS, 0, 0, 0,
3208 		      WCN36XX_FILTER_IE_DS_CHANNEL_MASK, 0),
3209 	BEACON_FILTER(WLAN_EID_ERP_INFO, 0, 0, 0,
3210 		      WCN36XX_FILTER_IE_ERP_FILTER_MASK, 0),
3211 	BEACON_FILTER(WLAN_EID_EDCA_PARAM_SET, 0, 0, 0,
3212 		      WCN36XX_FILTER_IE_EDCA_FILTER_MASK, 0),
3213 	BEACON_FILTER(WLAN_EID_QOS_CAPA, 0, 0, 0,
3214 		      WCN36XX_FILTER_IE_QOS_FILTER_MASK, 0),
3215 	BEACON_FILTER(WLAN_EID_CHANNEL_SWITCH, 1, 0, 0,
3216 		      WCN36XX_FILTER_IE_CHANNEL_SWITCH_MASK, 0),
3217 	BEACON_FILTER(WLAN_EID_HT_OPERATION, 0, 0, 0,
3218 		      WCN36XX_FILTER_IE_HT_BYTE0_FILTER_MASK, 0),
3219 	BEACON_FILTER(WLAN_EID_HT_OPERATION, 0, 2, 0,
3220 		      WCN36XX_FILTER_IE_HT_BYTE2_FILTER_MASK, 0),
3221 	BEACON_FILTER(WLAN_EID_HT_OPERATION, 0, 5, 0,
3222 		      WCN36XX_FILTER_IE_HT_BYTE5_FILTER_MASK, 0),
3223 	BEACON_FILTER(WLAN_EID_PWR_CONSTRAINT, 0, 0, 0,
3224 		      WCN36XX_FILTER_IE_PWR_CONSTRAINT_MASK, 0),
3225 	BEACON_FILTER(WLAN_EID_OPMODE_NOTIF, 0, 0, 0,
3226 		      WCN36XX_FILTER_IE_OPMODE_NOTIF_MASK, 0),
3227 	BEACON_FILTER(WLAN_EID_VHT_OPERATION, 0, 0, 0,
3228 		      WCN36XX_FILTER_IE_VHTOP_CHWIDTH_MASK, 0),
3229 	BEACON_FILTER(WLAN_EID_RSN, 1, 0, 0,
3230 		      WCN36XX_FILTER_IE_RSN_MASK, 0),
3231 	BEACON_FILTER(WLAN_EID_VENDOR_SPECIFIC, 1, 0, 0,
3232 		      WCN36XX_FILTER_IE_VENDOR_MASK, 0),
3233 };
3234 
3235 int wcn36xx_smd_add_beacon_filter(struct wcn36xx *wcn,
3236 				  struct ieee80211_vif *vif)
3237 {
3238 	struct wcn36xx_hal_add_bcn_filter_req_msg msg_body, *body;
3239 	struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
3240 	u8 *payload;
3241 	size_t payload_size;
3242 	int ret;
3243 
3244 	if (!get_feat_caps(wcn->fw_feat_caps, BCN_FILTER))
3245 		return -EOPNOTSUPP;
3246 
3247 	mutex_lock(&wcn->hal_mutex);
3248 	INIT_HAL_MSG(msg_body, WCN36XX_HAL_ADD_BCN_FILTER_REQ);
3249 
3250 	PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
3251 
3252 	body = (struct wcn36xx_hal_add_bcn_filter_req_msg *)wcn->hal_buf;
3253 	body->capability_info = vif->bss_conf.assoc_capability;
3254 	body->capability_mask = WCN36XX_FILTER_CAPABILITY_MASK;
3255 	body->beacon_interval = vif->bss_conf.beacon_int;
3256 	body->ie_num = ARRAY_SIZE(bcn_filter_ies);
3257 	body->bss_index = vif_priv->bss_index;
3258 
3259 	payload = ((u8 *)body) + body->header.len;
3260 	payload_size = sizeof(bcn_filter_ies);
3261 	memcpy(payload, &bcn_filter_ies, payload_size);
3262 
3263 	body->header.len += payload_size;
3264 
3265 	ret = wcn36xx_smd_send_and_wait(wcn, body->header.len);
3266 	if (ret) {
3267 		wcn36xx_err("Sending add bcn_filter failed\n");
3268 		goto out;
3269 	}
3270 
3271 	ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
3272 	if (ret) {
3273 		wcn36xx_err("add bcn filter response failed err=%d\n", ret);
3274 		goto out;
3275 	}
3276 out:
3277 	mutex_unlock(&wcn->hal_mutex);
3278 	return ret;
3279 }
3280 
3281 int wcn36xx_smd_rsp_process(struct rpmsg_device *rpdev,
3282 			    void *buf, int len, void *priv, u32 addr)
3283 {
3284 	const struct wcn36xx_hal_msg_header *msg_header = buf;
3285 	struct ieee80211_hw *hw = priv;
3286 	struct wcn36xx *wcn = hw->priv;
3287 	struct wcn36xx_hal_ind_msg *msg_ind;
3288 	wcn36xx_dbg_dump(WCN36XX_DBG_SMD_DUMP, "SMD <<< ", buf, len);
3289 
3290 	switch (msg_header->msg_type) {
3291 	case WCN36XX_HAL_START_RSP:
3292 	case WCN36XX_HAL_CONFIG_STA_RSP:
3293 	case WCN36XX_HAL_CONFIG_BSS_RSP:
3294 	case WCN36XX_HAL_ADD_STA_SELF_RSP:
3295 	case WCN36XX_HAL_STOP_RSP:
3296 	case WCN36XX_HAL_DEL_STA_SELF_RSP:
3297 	case WCN36XX_HAL_DELETE_STA_RSP:
3298 	case WCN36XX_HAL_INIT_SCAN_RSP:
3299 	case WCN36XX_HAL_START_SCAN_RSP:
3300 	case WCN36XX_HAL_END_SCAN_RSP:
3301 	case WCN36XX_HAL_FINISH_SCAN_RSP:
3302 	case WCN36XX_HAL_DOWNLOAD_NV_RSP:
3303 	case WCN36XX_HAL_DELETE_BSS_RSP:
3304 	case WCN36XX_HAL_SEND_BEACON_RSP:
3305 	case WCN36XX_HAL_SET_LINK_ST_RSP:
3306 	case WCN36XX_HAL_UPDATE_PROBE_RSP_TEMPLATE_RSP:
3307 	case WCN36XX_HAL_SET_BSSKEY_RSP:
3308 	case WCN36XX_HAL_SET_STAKEY_RSP:
3309 	case WCN36XX_HAL_RMV_STAKEY_RSP:
3310 	case WCN36XX_HAL_RMV_BSSKEY_RSP:
3311 	case WCN36XX_HAL_ENTER_BMPS_RSP:
3312 	case WCN36XX_HAL_SET_POWER_PARAMS_RSP:
3313 	case WCN36XX_HAL_EXIT_BMPS_RSP:
3314 	case WCN36XX_HAL_KEEP_ALIVE_RSP:
3315 	case WCN36XX_HAL_DUMP_COMMAND_RSP:
3316 	case WCN36XX_HAL_ADD_BA_SESSION_RSP:
3317 	case WCN36XX_HAL_ADD_BA_RSP:
3318 	case WCN36XX_HAL_DEL_BA_RSP:
3319 	case WCN36XX_HAL_TRIGGER_BA_RSP:
3320 	case WCN36XX_HAL_UPDATE_CFG_RSP:
3321 	case WCN36XX_HAL_JOIN_RSP:
3322 	case WCN36XX_HAL_UPDATE_SCAN_PARAM_RSP:
3323 	case WCN36XX_HAL_CH_SWITCH_RSP:
3324 	case WCN36XX_HAL_PROCESS_PTT_RSP:
3325 	case WCN36XX_HAL_FEATURE_CAPS_EXCHANGE_RSP:
3326 	case WCN36XX_HAL_8023_MULTICAST_LIST_RSP:
3327 	case WCN36XX_HAL_START_SCAN_OFFLOAD_RSP:
3328 	case WCN36XX_HAL_STOP_SCAN_OFFLOAD_RSP:
3329 	case WCN36XX_HAL_HOST_OFFLOAD_RSP:
3330 	case WCN36XX_HAL_GTK_OFFLOAD_RSP:
3331 	case WCN36XX_HAL_GTK_OFFLOAD_GETINFO_RSP:
3332 	case WCN36XX_HAL_HOST_RESUME_RSP:
3333 	case WCN36XX_HAL_ENTER_IMPS_RSP:
3334 	case WCN36XX_HAL_EXIT_IMPS_RSP:
3335 	case WCN36XX_HAL_UPDATE_CHANNEL_LIST_RSP:
3336 	case WCN36XX_HAL_ADD_BCN_FILTER_RSP:
3337 		memcpy(wcn->hal_buf, buf, len);
3338 		wcn->hal_rsp_len = len;
3339 		complete(&wcn->hal_rsp_compl);
3340 		break;
3341 
3342 	case WCN36XX_HAL_COEX_IND:
3343 	case WCN36XX_HAL_AVOID_FREQ_RANGE_IND:
3344 	case WCN36XX_HAL_DEL_BA_IND:
3345 	case WCN36XX_HAL_OTA_TX_COMPL_IND:
3346 	case WCN36XX_HAL_MISSED_BEACON_IND:
3347 	case WCN36XX_HAL_DELETE_STA_CONTEXT_IND:
3348 	case WCN36XX_HAL_PRINT_REG_INFO_IND:
3349 	case WCN36XX_HAL_SCAN_OFFLOAD_IND:
3350 		msg_ind = kmalloc(sizeof(*msg_ind) + len, GFP_ATOMIC);
3351 		if (!msg_ind) {
3352 			wcn36xx_err("Run out of memory while handling SMD_EVENT (%d)\n",
3353 				    msg_header->msg_type);
3354 			return -ENOMEM;
3355 		}
3356 
3357 		msg_ind->msg_len = len;
3358 		memcpy(msg_ind->msg, buf, len);
3359 
3360 		spin_lock(&wcn->hal_ind_lock);
3361 		list_add_tail(&msg_ind->list, &wcn->hal_ind_queue);
3362 		queue_work(wcn->hal_ind_wq, &wcn->hal_ind_work);
3363 		spin_unlock(&wcn->hal_ind_lock);
3364 		wcn36xx_dbg(WCN36XX_DBG_HAL, "indication arrived\n");
3365 		break;
3366 	default:
3367 		wcn36xx_err("SMD_EVENT (%d) not supported\n",
3368 			      msg_header->msg_type);
3369 	}
3370 
3371 	return 0;
3372 }
3373 
3374 static void wcn36xx_ind_smd_work(struct work_struct *work)
3375 {
3376 	struct wcn36xx *wcn =
3377 		container_of(work, struct wcn36xx, hal_ind_work);
3378 
3379 	for (;;) {
3380 		struct wcn36xx_hal_msg_header *msg_header;
3381 		struct wcn36xx_hal_ind_msg *hal_ind_msg;
3382 		unsigned long flags;
3383 
3384 		spin_lock_irqsave(&wcn->hal_ind_lock, flags);
3385 
3386 		if (list_empty(&wcn->hal_ind_queue)) {
3387 			spin_unlock_irqrestore(&wcn->hal_ind_lock, flags);
3388 			return;
3389 		}
3390 
3391 		hal_ind_msg = list_first_entry(&wcn->hal_ind_queue,
3392 					       struct wcn36xx_hal_ind_msg,
3393 					       list);
3394 		list_del(&hal_ind_msg->list);
3395 		spin_unlock_irqrestore(&wcn->hal_ind_lock, flags);
3396 
3397 		msg_header = (struct wcn36xx_hal_msg_header *)hal_ind_msg->msg;
3398 
3399 		switch (msg_header->msg_type) {
3400 		case WCN36XX_HAL_COEX_IND:
3401 		case WCN36XX_HAL_DEL_BA_IND:
3402 		case WCN36XX_HAL_AVOID_FREQ_RANGE_IND:
3403 			break;
3404 		case WCN36XX_HAL_OTA_TX_COMPL_IND:
3405 			wcn36xx_smd_tx_compl_ind(wcn,
3406 						 hal_ind_msg->msg,
3407 						 hal_ind_msg->msg_len);
3408 			break;
3409 		case WCN36XX_HAL_MISSED_BEACON_IND:
3410 			wcn36xx_smd_missed_beacon_ind(wcn,
3411 						      hal_ind_msg->msg,
3412 						      hal_ind_msg->msg_len);
3413 			break;
3414 		case WCN36XX_HAL_DELETE_STA_CONTEXT_IND:
3415 			wcn36xx_smd_delete_sta_context_ind(wcn,
3416 							   hal_ind_msg->msg,
3417 							   hal_ind_msg->msg_len);
3418 			break;
3419 		case WCN36XX_HAL_PRINT_REG_INFO_IND:
3420 			wcn36xx_smd_print_reg_info_ind(wcn,
3421 						       hal_ind_msg->msg,
3422 						       hal_ind_msg->msg_len);
3423 			break;
3424 		case WCN36XX_HAL_SCAN_OFFLOAD_IND:
3425 			wcn36xx_smd_hw_scan_ind(wcn, hal_ind_msg->msg,
3426 						hal_ind_msg->msg_len);
3427 			break;
3428 		default:
3429 			wcn36xx_err("SMD_EVENT (%d) not supported\n",
3430 				    msg_header->msg_type);
3431 		}
3432 
3433 		kfree(hal_ind_msg);
3434 	}
3435 }
3436 
3437 int wcn36xx_smd_open(struct wcn36xx *wcn)
3438 {
3439 	wcn->hal_ind_wq = create_freezable_workqueue("wcn36xx_smd_ind");
3440 	if (!wcn->hal_ind_wq)
3441 		return -ENOMEM;
3442 
3443 	INIT_WORK(&wcn->hal_ind_work, wcn36xx_ind_smd_work);
3444 	INIT_LIST_HEAD(&wcn->hal_ind_queue);
3445 	spin_lock_init(&wcn->hal_ind_lock);
3446 
3447 	return 0;
3448 }
3449 
3450 void wcn36xx_smd_close(struct wcn36xx *wcn)
3451 {
3452 	struct wcn36xx_hal_ind_msg *msg, *tmp;
3453 
3454 	cancel_work_sync(&wcn->hal_ind_work);
3455 	destroy_workqueue(wcn->hal_ind_wq);
3456 
3457 	list_for_each_entry_safe(msg, tmp, &wcn->hal_ind_queue, list)
3458 		kfree(msg);
3459 }
3460