1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (c) 2012 - 2018 Microchip Technology Inc., and its subsidiaries.
4  * All rights reserved.
5  */
6 
7 #include "cfg80211.h"
8 
9 #define GO_NEG_REQ			0x00
10 #define GO_NEG_RSP			0x01
11 #define GO_NEG_CONF			0x02
12 #define P2P_INV_REQ			0x03
13 #define P2P_INV_RSP			0x04
14 
15 #define WILC_INVALID_CHANNEL		0
16 
17 /* Operation at 2.4 GHz with channels 1-13 */
18 #define WILC_WLAN_OPERATING_CLASS_2_4GHZ		0x51
19 
20 static const struct ieee80211_txrx_stypes
21 	wilc_wfi_cfg80211_mgmt_types[NUM_NL80211_IFTYPES] = {
22 	[NL80211_IFTYPE_STATION] = {
23 		.tx = 0xffff,
24 		.rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
25 			BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
26 	},
27 	[NL80211_IFTYPE_AP] = {
28 		.tx = 0xffff,
29 		.rx = BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) |
30 			BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) |
31 			BIT(IEEE80211_STYPE_PROBE_REQ >> 4) |
32 			BIT(IEEE80211_STYPE_DISASSOC >> 4) |
33 			BIT(IEEE80211_STYPE_AUTH >> 4) |
34 			BIT(IEEE80211_STYPE_DEAUTH >> 4) |
35 			BIT(IEEE80211_STYPE_ACTION >> 4)
36 	},
37 	[NL80211_IFTYPE_P2P_CLIENT] = {
38 		.tx = 0xffff,
39 		.rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
40 			BIT(IEEE80211_STYPE_PROBE_REQ >> 4) |
41 			BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) |
42 			BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) |
43 			BIT(IEEE80211_STYPE_DISASSOC >> 4) |
44 			BIT(IEEE80211_STYPE_AUTH >> 4) |
45 			BIT(IEEE80211_STYPE_DEAUTH >> 4)
46 	}
47 };
48 
49 #ifdef CONFIG_PM
50 static const struct wiphy_wowlan_support wowlan_support = {
51 	.flags = WIPHY_WOWLAN_ANY
52 };
53 #endif
54 
55 struct wilc_p2p_mgmt_data {
56 	int size;
57 	u8 *buff;
58 };
59 
60 struct wilc_p2p_pub_act_frame {
61 	u8 category;
62 	u8 action;
63 	u8 oui[3];
64 	u8 oui_type;
65 	u8 oui_subtype;
66 	u8 dialog_token;
67 	u8 elem[];
68 } __packed;
69 
70 struct wilc_vendor_specific_ie {
71 	u8 tag_number;
72 	u8 tag_len;
73 	u8 oui[3];
74 	u8 oui_type;
75 	u8 attr[];
76 } __packed;
77 
78 struct wilc_attr_entry {
79 	u8  attr_type;
80 	__le16 attr_len;
81 	u8 val[];
82 } __packed;
83 
84 struct wilc_attr_oper_ch {
85 	u8 attr_type;
86 	__le16 attr_len;
87 	u8 country_code[IEEE80211_COUNTRY_STRING_LEN];
88 	u8 op_class;
89 	u8 op_channel;
90 } __packed;
91 
92 struct wilc_attr_ch_list {
93 	u8 attr_type;
94 	__le16 attr_len;
95 	u8 country_code[IEEE80211_COUNTRY_STRING_LEN];
96 	u8 elem[];
97 } __packed;
98 
99 struct wilc_ch_list_elem {
100 	u8 op_class;
101 	u8 no_of_channels;
102 	u8 ch_list[];
103 } __packed;
104 
105 static void cfg_scan_result(enum scan_event scan_event,
106 			    struct wilc_rcvd_net_info *info, void *user_void)
107 {
108 	struct wilc_priv *priv = user_void;
109 
110 	if (!priv->cfg_scanning)
111 		return;
112 
113 	if (scan_event == SCAN_EVENT_NETWORK_FOUND) {
114 		s32 freq;
115 		struct ieee80211_channel *channel;
116 		struct cfg80211_bss *bss;
117 		struct wiphy *wiphy = priv->dev->ieee80211_ptr->wiphy;
118 
119 		if (!wiphy || !info)
120 			return;
121 
122 		freq = ieee80211_channel_to_frequency((s32)info->ch,
123 						      NL80211_BAND_2GHZ);
124 		channel = ieee80211_get_channel(wiphy, freq);
125 		if (!channel)
126 			return;
127 
128 		bss = cfg80211_inform_bss_frame(wiphy, channel, info->mgmt,
129 						info->frame_len,
130 						(s32)info->rssi * 100,
131 						GFP_KERNEL);
132 		if (!bss)
133 			cfg80211_put_bss(wiphy, bss);
134 	} else if (scan_event == SCAN_EVENT_DONE) {
135 		mutex_lock(&priv->scan_req_lock);
136 
137 		if (priv->scan_req) {
138 			struct cfg80211_scan_info info = {
139 				.aborted = false,
140 			};
141 
142 			cfg80211_scan_done(priv->scan_req, &info);
143 			priv->cfg_scanning = false;
144 			priv->scan_req = NULL;
145 		}
146 		mutex_unlock(&priv->scan_req_lock);
147 	} else if (scan_event == SCAN_EVENT_ABORTED) {
148 		mutex_lock(&priv->scan_req_lock);
149 
150 		if (priv->scan_req) {
151 			struct cfg80211_scan_info info = {
152 				.aborted = false,
153 			};
154 
155 			cfg80211_scan_done(priv->scan_req, &info);
156 			priv->cfg_scanning = false;
157 			priv->scan_req = NULL;
158 		}
159 		mutex_unlock(&priv->scan_req_lock);
160 	}
161 }
162 
163 static void cfg_connect_result(enum conn_event conn_disconn_evt, u8 mac_status,
164 			       void *priv_data)
165 {
166 	struct wilc_priv *priv = priv_data;
167 	struct net_device *dev = priv->dev;
168 	struct wilc_vif *vif = netdev_priv(dev);
169 	struct wilc *wl = vif->wilc;
170 	struct host_if_drv *wfi_drv = priv->hif_drv;
171 	struct wilc_conn_info *conn_info = &wfi_drv->conn_info;
172 	struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
173 
174 	vif->connecting = false;
175 
176 	if (conn_disconn_evt == CONN_DISCONN_EVENT_CONN_RESP) {
177 		u16 connect_status = conn_info->status;
178 
179 		if (mac_status == WILC_MAC_STATUS_DISCONNECTED &&
180 		    connect_status == WLAN_STATUS_SUCCESS) {
181 			connect_status = WLAN_STATUS_UNSPECIFIED_FAILURE;
182 			wilc_wlan_set_bssid(priv->dev, NULL, WILC_STATION_MODE);
183 
184 			if (vif->iftype != WILC_CLIENT_MODE)
185 				wl->sta_ch = WILC_INVALID_CHANNEL;
186 
187 			netdev_err(dev, "Unspecified failure\n");
188 		}
189 
190 		if (connect_status == WLAN_STATUS_SUCCESS)
191 			memcpy(priv->associated_bss, conn_info->bssid,
192 			       ETH_ALEN);
193 
194 		cfg80211_ref_bss(wiphy, vif->bss);
195 		cfg80211_connect_bss(dev, conn_info->bssid, vif->bss,
196 				     conn_info->req_ies,
197 				     conn_info->req_ies_len,
198 				     conn_info->resp_ies,
199 				     conn_info->resp_ies_len,
200 				     connect_status, GFP_KERNEL,
201 				     NL80211_TIMEOUT_UNSPECIFIED);
202 
203 		vif->bss = NULL;
204 	} else if (conn_disconn_evt == CONN_DISCONN_EVENT_DISCONN_NOTIF) {
205 		u16 reason = 0;
206 
207 		eth_zero_addr(priv->associated_bss);
208 		wilc_wlan_set_bssid(priv->dev, NULL, WILC_STATION_MODE);
209 
210 		if (vif->iftype != WILC_CLIENT_MODE) {
211 			wl->sta_ch = WILC_INVALID_CHANNEL;
212 		} else {
213 			if (wfi_drv->ifc_up)
214 				reason = 3;
215 			else
216 				reason = 1;
217 		}
218 
219 		cfg80211_disconnected(dev, reason, NULL, 0, false, GFP_KERNEL);
220 	}
221 }
222 
223 struct wilc_vif *wilc_get_wl_to_vif(struct wilc *wl)
224 {
225 	struct wilc_vif *vif;
226 
227 	vif = list_first_or_null_rcu(&wl->vif_list, typeof(*vif), list);
228 	if (!vif)
229 		return ERR_PTR(-EINVAL);
230 
231 	return vif;
232 }
233 
234 static int set_channel(struct wiphy *wiphy,
235 		       struct cfg80211_chan_def *chandef)
236 {
237 	struct wilc *wl = wiphy_priv(wiphy);
238 	struct wilc_vif *vif;
239 	u32 channelnum;
240 	int result;
241 	int srcu_idx;
242 
243 	srcu_idx = srcu_read_lock(&wl->srcu);
244 	vif = wilc_get_wl_to_vif(wl);
245 	if (IS_ERR(vif)) {
246 		srcu_read_unlock(&wl->srcu, srcu_idx);
247 		return PTR_ERR(vif);
248 	}
249 
250 	channelnum = ieee80211_frequency_to_channel(chandef->chan->center_freq);
251 
252 	wl->op_ch = channelnum;
253 	result = wilc_set_mac_chnl_num(vif, channelnum);
254 	if (result)
255 		netdev_err(vif->ndev, "Error in setting channel\n");
256 
257 	srcu_read_unlock(&wl->srcu, srcu_idx);
258 	return result;
259 }
260 
261 static int scan(struct wiphy *wiphy, struct cfg80211_scan_request *request)
262 {
263 	struct wilc_vif *vif = netdev_priv(request->wdev->netdev);
264 	struct wilc_priv *priv = &vif->priv;
265 	u32 i;
266 	int ret = 0;
267 	u8 scan_ch_list[WILC_MAX_NUM_SCANNED_CH];
268 	u8 scan_type;
269 
270 	if (request->n_channels > WILC_MAX_NUM_SCANNED_CH) {
271 		netdev_err(vif->ndev, "Requested scanned channels over\n");
272 		return -EINVAL;
273 	}
274 
275 	priv->scan_req = request;
276 	priv->cfg_scanning = true;
277 	for (i = 0; i < request->n_channels; i++) {
278 		u16 freq = request->channels[i]->center_freq;
279 
280 		scan_ch_list[i] = ieee80211_frequency_to_channel(freq);
281 	}
282 
283 	if (request->n_ssids)
284 		scan_type = WILC_FW_ACTIVE_SCAN;
285 	else
286 		scan_type = WILC_FW_PASSIVE_SCAN;
287 
288 	ret = wilc_scan(vif, WILC_FW_USER_SCAN, scan_type, scan_ch_list,
289 			request->n_channels, cfg_scan_result, (void *)priv,
290 			request);
291 
292 	if (ret) {
293 		priv->scan_req = NULL;
294 		priv->cfg_scanning = false;
295 	}
296 
297 	return ret;
298 }
299 
300 static int connect(struct wiphy *wiphy, struct net_device *dev,
301 		   struct cfg80211_connect_params *sme)
302 {
303 	struct wilc_vif *vif = netdev_priv(dev);
304 	struct wilc_priv *priv = &vif->priv;
305 	struct host_if_drv *wfi_drv = priv->hif_drv;
306 	int ret;
307 	u32 i;
308 	u8 security = WILC_FW_SEC_NO;
309 	enum authtype auth_type = WILC_FW_AUTH_ANY;
310 	u32 cipher_group;
311 	struct cfg80211_bss *bss;
312 	void *join_params;
313 	u8 ch;
314 
315 	vif->connecting = true;
316 
317 	memset(priv->wep_key, 0, sizeof(priv->wep_key));
318 	memset(priv->wep_key_len, 0, sizeof(priv->wep_key_len));
319 
320 	cipher_group = sme->crypto.cipher_group;
321 	if (cipher_group != 0) {
322 		if (cipher_group == WLAN_CIPHER_SUITE_WEP40) {
323 			security = WILC_FW_SEC_WEP;
324 
325 			priv->wep_key_len[sme->key_idx] = sme->key_len;
326 			memcpy(priv->wep_key[sme->key_idx], sme->key,
327 			       sme->key_len);
328 
329 			wilc_set_wep_default_keyid(vif, sme->key_idx);
330 			wilc_add_wep_key_bss_sta(vif, sme->key, sme->key_len,
331 						 sme->key_idx);
332 		} else if (cipher_group == WLAN_CIPHER_SUITE_WEP104) {
333 			security = WILC_FW_SEC_WEP_EXTENDED;
334 
335 			priv->wep_key_len[sme->key_idx] = sme->key_len;
336 			memcpy(priv->wep_key[sme->key_idx], sme->key,
337 			       sme->key_len);
338 
339 			wilc_set_wep_default_keyid(vif, sme->key_idx);
340 			wilc_add_wep_key_bss_sta(vif, sme->key, sme->key_len,
341 						 sme->key_idx);
342 		} else if (sme->crypto.wpa_versions & NL80211_WPA_VERSION_2) {
343 			if (cipher_group == WLAN_CIPHER_SUITE_TKIP)
344 				security = WILC_FW_SEC_WPA2_TKIP;
345 			else
346 				security = WILC_FW_SEC_WPA2_AES;
347 		} else if (sme->crypto.wpa_versions & NL80211_WPA_VERSION_1) {
348 			if (cipher_group == WLAN_CIPHER_SUITE_TKIP)
349 				security = WILC_FW_SEC_WPA_TKIP;
350 			else
351 				security = WILC_FW_SEC_WPA_AES;
352 		} else {
353 			ret = -ENOTSUPP;
354 			netdev_err(dev, "%s: Unsupported cipher\n",
355 				   __func__);
356 			goto out_error;
357 		}
358 	}
359 
360 	if ((sme->crypto.wpa_versions & NL80211_WPA_VERSION_1) ||
361 	    (sme->crypto.wpa_versions & NL80211_WPA_VERSION_2)) {
362 		for (i = 0; i < sme->crypto.n_ciphers_pairwise; i++) {
363 			u32 ciphers_pairwise = sme->crypto.ciphers_pairwise[i];
364 
365 			if (ciphers_pairwise == WLAN_CIPHER_SUITE_TKIP)
366 				security |= WILC_FW_TKIP;
367 			else
368 				security |= WILC_FW_AES;
369 		}
370 	}
371 
372 	switch (sme->auth_type) {
373 	case NL80211_AUTHTYPE_OPEN_SYSTEM:
374 		auth_type = WILC_FW_AUTH_OPEN_SYSTEM;
375 		break;
376 
377 	case NL80211_AUTHTYPE_SHARED_KEY:
378 		auth_type = WILC_FW_AUTH_SHARED_KEY;
379 		break;
380 
381 	default:
382 		break;
383 	}
384 
385 	if (sme->crypto.n_akm_suites) {
386 		if (sme->crypto.akm_suites[0] == WLAN_AKM_SUITE_8021X)
387 			auth_type = WILC_FW_AUTH_IEEE8021;
388 	}
389 
390 	if (wfi_drv->usr_scan_req.scan_result) {
391 		netdev_err(vif->ndev, "%s: Scan in progress\n", __func__);
392 		ret = -EBUSY;
393 		goto out_error;
394 	}
395 
396 	bss = cfg80211_get_bss(wiphy, sme->channel, sme->bssid, sme->ssid,
397 			       sme->ssid_len, IEEE80211_BSS_TYPE_ANY,
398 			       IEEE80211_PRIVACY(sme->privacy));
399 	if (!bss) {
400 		ret = -EINVAL;
401 		goto out_error;
402 	}
403 
404 	if (ether_addr_equal_unaligned(vif->bssid, bss->bssid)) {
405 		ret = -EALREADY;
406 		goto out_put_bss;
407 	}
408 
409 	join_params = wilc_parse_join_bss_param(bss, &sme->crypto);
410 	if (!join_params) {
411 		netdev_err(dev, "%s: failed to construct join param\n",
412 			   __func__);
413 		ret = -EINVAL;
414 		goto out_put_bss;
415 	}
416 
417 	ch = ieee80211_frequency_to_channel(bss->channel->center_freq);
418 	vif->wilc->op_ch = ch;
419 	if (vif->iftype != WILC_CLIENT_MODE)
420 		vif->wilc->sta_ch = ch;
421 
422 	wilc_wlan_set_bssid(dev, bss->bssid, WILC_STATION_MODE);
423 
424 	wfi_drv->conn_info.security = security;
425 	wfi_drv->conn_info.auth_type = auth_type;
426 	wfi_drv->conn_info.ch = ch;
427 	wfi_drv->conn_info.conn_result = cfg_connect_result;
428 	wfi_drv->conn_info.arg = priv;
429 	wfi_drv->conn_info.param = join_params;
430 
431 	ret = wilc_set_join_req(vif, bss->bssid, sme->ie, sme->ie_len);
432 	if (ret) {
433 		netdev_err(dev, "wilc_set_join_req(): Error\n");
434 		ret = -ENOENT;
435 		if (vif->iftype != WILC_CLIENT_MODE)
436 			vif->wilc->sta_ch = WILC_INVALID_CHANNEL;
437 		wilc_wlan_set_bssid(dev, NULL, WILC_STATION_MODE);
438 		wfi_drv->conn_info.conn_result = NULL;
439 		kfree(join_params);
440 		goto out_put_bss;
441 	}
442 	kfree(join_params);
443 	vif->bss = bss;
444 	cfg80211_put_bss(wiphy, bss);
445 	return 0;
446 
447 out_put_bss:
448 	cfg80211_put_bss(wiphy, bss);
449 
450 out_error:
451 	vif->connecting = false;
452 	return ret;
453 }
454 
455 static int disconnect(struct wiphy *wiphy, struct net_device *dev,
456 		      u16 reason_code)
457 {
458 	struct wilc_vif *vif = netdev_priv(dev);
459 	struct wilc_priv *priv = &vif->priv;
460 	struct wilc *wilc = vif->wilc;
461 	int ret;
462 
463 	vif->connecting = false;
464 
465 	if (!wilc)
466 		return -EIO;
467 
468 	if (wilc->close) {
469 		/* already disconnected done */
470 		cfg80211_disconnected(dev, 0, NULL, 0, true, GFP_KERNEL);
471 		return 0;
472 	}
473 
474 	if (vif->iftype != WILC_CLIENT_MODE)
475 		wilc->sta_ch = WILC_INVALID_CHANNEL;
476 	wilc_wlan_set_bssid(priv->dev, NULL, WILC_STATION_MODE);
477 
478 	priv->hif_drv->p2p_timeout = 0;
479 
480 	ret = wilc_disconnect(vif);
481 	if (ret != 0) {
482 		netdev_err(priv->dev, "Error in disconnecting\n");
483 		ret = -EINVAL;
484 	}
485 
486 	vif->bss = NULL;
487 
488 	return ret;
489 }
490 
491 static inline void wilc_wfi_cfg_copy_wep_info(struct wilc_priv *priv,
492 					      u8 key_index,
493 					      struct key_params *params)
494 {
495 	priv->wep_key_len[key_index] = params->key_len;
496 	memcpy(priv->wep_key[key_index], params->key, params->key_len);
497 }
498 
499 static int wilc_wfi_cfg_allocate_wpa_entry(struct wilc_priv *priv, u8 idx)
500 {
501 	if (!priv->wilc_gtk[idx]) {
502 		priv->wilc_gtk[idx] = kzalloc(sizeof(*priv->wilc_gtk[idx]),
503 					      GFP_KERNEL);
504 		if (!priv->wilc_gtk[idx])
505 			return -ENOMEM;
506 	}
507 
508 	if (!priv->wilc_ptk[idx]) {
509 		priv->wilc_ptk[idx] = kzalloc(sizeof(*priv->wilc_ptk[idx]),
510 					      GFP_KERNEL);
511 		if (!priv->wilc_ptk[idx])
512 			return -ENOMEM;
513 	}
514 
515 	return 0;
516 }
517 
518 static int wilc_wfi_cfg_copy_wpa_info(struct wilc_wfi_key *key_info,
519 				      struct key_params *params)
520 {
521 	kfree(key_info->key);
522 
523 	key_info->key = kmemdup(params->key, params->key_len, GFP_KERNEL);
524 	if (!key_info->key)
525 		return -ENOMEM;
526 
527 	kfree(key_info->seq);
528 
529 	if (params->seq_len > 0) {
530 		key_info->seq = kmemdup(params->seq, params->seq_len,
531 					GFP_KERNEL);
532 		if (!key_info->seq)
533 			return -ENOMEM;
534 	}
535 
536 	key_info->cipher = params->cipher;
537 	key_info->key_len = params->key_len;
538 	key_info->seq_len = params->seq_len;
539 
540 	return 0;
541 }
542 
543 static int add_key(struct wiphy *wiphy, struct net_device *netdev, u8 key_index,
544 		   bool pairwise, const u8 *mac_addr, struct key_params *params)
545 
546 {
547 	int ret = 0, keylen = params->key_len;
548 	const u8 *rx_mic = NULL;
549 	const u8 *tx_mic = NULL;
550 	u8 mode = WILC_FW_SEC_NO;
551 	u8 op_mode;
552 	struct wilc_vif *vif = netdev_priv(netdev);
553 	struct wilc_priv *priv = &vif->priv;
554 
555 	switch (params->cipher) {
556 	case WLAN_CIPHER_SUITE_WEP40:
557 	case WLAN_CIPHER_SUITE_WEP104:
558 		if (priv->wdev.iftype == NL80211_IFTYPE_AP) {
559 			wilc_wfi_cfg_copy_wep_info(priv, key_index, params);
560 
561 			if (params->cipher == WLAN_CIPHER_SUITE_WEP40)
562 				mode = WILC_FW_SEC_WEP;
563 			else
564 				mode = WILC_FW_SEC_WEP_EXTENDED;
565 
566 			ret = wilc_add_wep_key_bss_ap(vif, params->key,
567 						      params->key_len,
568 						      key_index, mode,
569 						      WILC_FW_AUTH_OPEN_SYSTEM);
570 			break;
571 		}
572 		if (memcmp(params->key, priv->wep_key[key_index],
573 			   params->key_len)) {
574 			wilc_wfi_cfg_copy_wep_info(priv, key_index, params);
575 
576 			ret = wilc_add_wep_key_bss_sta(vif, params->key,
577 						       params->key_len,
578 						       key_index);
579 		}
580 
581 		break;
582 
583 	case WLAN_CIPHER_SUITE_TKIP:
584 	case WLAN_CIPHER_SUITE_CCMP:
585 		if (priv->wdev.iftype == NL80211_IFTYPE_AP ||
586 		    priv->wdev.iftype == NL80211_IFTYPE_P2P_GO) {
587 			struct wilc_wfi_key *key;
588 
589 			ret = wilc_wfi_cfg_allocate_wpa_entry(priv, key_index);
590 			if (ret)
591 				return -ENOMEM;
592 
593 			if (params->key_len > 16 &&
594 			    params->cipher == WLAN_CIPHER_SUITE_TKIP) {
595 				tx_mic = params->key + 24;
596 				rx_mic = params->key + 16;
597 				keylen = params->key_len - 16;
598 			}
599 
600 			if (!pairwise) {
601 				if (params->cipher == WLAN_CIPHER_SUITE_TKIP)
602 					mode = WILC_FW_SEC_WPA_TKIP;
603 				else
604 					mode = WILC_FW_SEC_WPA2_AES;
605 
606 				priv->wilc_groupkey = mode;
607 
608 				key = priv->wilc_gtk[key_index];
609 			} else {
610 				if (params->cipher == WLAN_CIPHER_SUITE_TKIP)
611 					mode = WILC_FW_SEC_WPA_TKIP;
612 				else
613 					mode = priv->wilc_groupkey | WILC_FW_AES;
614 
615 				key = priv->wilc_ptk[key_index];
616 			}
617 			ret = wilc_wfi_cfg_copy_wpa_info(key, params);
618 			if (ret)
619 				return -ENOMEM;
620 
621 			op_mode = WILC_AP_MODE;
622 		} else {
623 			if (params->key_len > 16 &&
624 			    params->cipher == WLAN_CIPHER_SUITE_TKIP) {
625 				rx_mic = params->key + 24;
626 				tx_mic = params->key + 16;
627 				keylen = params->key_len - 16;
628 			}
629 
630 			op_mode = WILC_STATION_MODE;
631 		}
632 
633 		if (!pairwise)
634 			ret = wilc_add_rx_gtk(vif, params->key, keylen,
635 					      key_index, params->seq_len,
636 					      params->seq, rx_mic, tx_mic,
637 					      op_mode, mode);
638 		else
639 			ret = wilc_add_ptk(vif, params->key, keylen, mac_addr,
640 					   rx_mic, tx_mic, op_mode, mode,
641 					   key_index);
642 
643 		break;
644 
645 	default:
646 		netdev_err(netdev, "%s: Unsupported cipher\n", __func__);
647 		ret = -ENOTSUPP;
648 	}
649 
650 	return ret;
651 }
652 
653 static int del_key(struct wiphy *wiphy, struct net_device *netdev,
654 		   u8 key_index,
655 		   bool pairwise,
656 		   const u8 *mac_addr)
657 {
658 	struct wilc_vif *vif = netdev_priv(netdev);
659 	struct wilc_priv *priv = &vif->priv;
660 
661 	if (priv->wilc_gtk[key_index]) {
662 		kfree(priv->wilc_gtk[key_index]->key);
663 		priv->wilc_gtk[key_index]->key = NULL;
664 		kfree(priv->wilc_gtk[key_index]->seq);
665 		priv->wilc_gtk[key_index]->seq = NULL;
666 
667 		kfree(priv->wilc_gtk[key_index]);
668 		priv->wilc_gtk[key_index] = NULL;
669 	}
670 
671 	if (priv->wilc_ptk[key_index]) {
672 		kfree(priv->wilc_ptk[key_index]->key);
673 		priv->wilc_ptk[key_index]->key = NULL;
674 		kfree(priv->wilc_ptk[key_index]->seq);
675 		priv->wilc_ptk[key_index]->seq = NULL;
676 		kfree(priv->wilc_ptk[key_index]);
677 		priv->wilc_ptk[key_index] = NULL;
678 	}
679 
680 	if (key_index <= 3 && priv->wep_key_len[key_index]) {
681 		memset(priv->wep_key[key_index], 0,
682 		       priv->wep_key_len[key_index]);
683 		priv->wep_key_len[key_index] = 0;
684 		wilc_remove_wep_key(vif, key_index);
685 	}
686 
687 	return 0;
688 }
689 
690 static int get_key(struct wiphy *wiphy, struct net_device *netdev, u8 key_index,
691 		   bool pairwise, const u8 *mac_addr, void *cookie,
692 		   void (*callback)(void *cookie, struct key_params *))
693 {
694 	struct wilc_vif *vif = netdev_priv(netdev);
695 	struct wilc_priv *priv = &vif->priv;
696 	struct  key_params key_params;
697 
698 	if (!pairwise) {
699 		key_params.key = priv->wilc_gtk[key_index]->key;
700 		key_params.cipher = priv->wilc_gtk[key_index]->cipher;
701 		key_params.key_len = priv->wilc_gtk[key_index]->key_len;
702 		key_params.seq = priv->wilc_gtk[key_index]->seq;
703 		key_params.seq_len = priv->wilc_gtk[key_index]->seq_len;
704 	} else {
705 		key_params.key = priv->wilc_ptk[key_index]->key;
706 		key_params.cipher = priv->wilc_ptk[key_index]->cipher;
707 		key_params.key_len = priv->wilc_ptk[key_index]->key_len;
708 		key_params.seq = priv->wilc_ptk[key_index]->seq;
709 		key_params.seq_len = priv->wilc_ptk[key_index]->seq_len;
710 	}
711 
712 	callback(cookie, &key_params);
713 
714 	return 0;
715 }
716 
717 static int set_default_key(struct wiphy *wiphy, struct net_device *netdev,
718 			   u8 key_index, bool unicast, bool multicast)
719 {
720 	struct wilc_vif *vif = netdev_priv(netdev);
721 
722 	wilc_set_wep_default_keyid(vif, key_index);
723 
724 	return 0;
725 }
726 
727 static int get_station(struct wiphy *wiphy, struct net_device *dev,
728 		       const u8 *mac, struct station_info *sinfo)
729 {
730 	struct wilc_vif *vif = netdev_priv(dev);
731 	struct wilc_priv *priv = &vif->priv;
732 	u32 i = 0;
733 	u32 associatedsta = ~0;
734 	u32 inactive_time = 0;
735 
736 	if (vif->iftype == WILC_AP_MODE || vif->iftype == WILC_GO_MODE) {
737 		for (i = 0; i < NUM_STA_ASSOCIATED; i++) {
738 			if (!(memcmp(mac,
739 				     priv->assoc_stainfo.sta_associated_bss[i],
740 				     ETH_ALEN))) {
741 				associatedsta = i;
742 				break;
743 			}
744 		}
745 
746 		if (associatedsta == ~0) {
747 			netdev_err(dev, "sta required is not associated\n");
748 			return -ENOENT;
749 		}
750 
751 		sinfo->filled |= BIT_ULL(NL80211_STA_INFO_INACTIVE_TIME);
752 
753 		wilc_get_inactive_time(vif, mac, &inactive_time);
754 		sinfo->inactive_time = 1000 * inactive_time;
755 	} else if (vif->iftype == WILC_STATION_MODE) {
756 		struct rf_info stats;
757 
758 		wilc_get_statistics(vif, &stats);
759 
760 		sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL) |
761 				 BIT_ULL(NL80211_STA_INFO_RX_PACKETS) |
762 				 BIT_ULL(NL80211_STA_INFO_TX_PACKETS) |
763 				 BIT_ULL(NL80211_STA_INFO_TX_FAILED) |
764 				 BIT_ULL(NL80211_STA_INFO_TX_BITRATE);
765 
766 		sinfo->signal = stats.rssi;
767 		sinfo->rx_packets = stats.rx_cnt;
768 		sinfo->tx_packets = stats.tx_cnt + stats.tx_fail_cnt;
769 		sinfo->tx_failed = stats.tx_fail_cnt;
770 		sinfo->txrate.legacy = stats.link_speed * 10;
771 
772 		if (stats.link_speed > TCP_ACK_FILTER_LINK_SPEED_THRESH &&
773 		    stats.link_speed != DEFAULT_LINK_SPEED)
774 			wilc_enable_tcp_ack_filter(vif, true);
775 		else if (stats.link_speed != DEFAULT_LINK_SPEED)
776 			wilc_enable_tcp_ack_filter(vif, false);
777 	}
778 	return 0;
779 }
780 
781 static int change_bss(struct wiphy *wiphy, struct net_device *dev,
782 		      struct bss_parameters *params)
783 {
784 	return 0;
785 }
786 
787 static int set_wiphy_params(struct wiphy *wiphy, u32 changed)
788 {
789 	int ret = -EINVAL;
790 	struct cfg_param_attr cfg_param_val;
791 	struct wilc *wl = wiphy_priv(wiphy);
792 	struct wilc_vif *vif;
793 	struct wilc_priv *priv;
794 	int srcu_idx;
795 
796 	srcu_idx = srcu_read_lock(&wl->srcu);
797 	vif = wilc_get_wl_to_vif(wl);
798 	if (IS_ERR(vif))
799 		goto out;
800 
801 	priv = &vif->priv;
802 	cfg_param_val.flag = 0;
803 
804 	if (changed & WIPHY_PARAM_RETRY_SHORT) {
805 		netdev_dbg(vif->ndev,
806 			   "Setting WIPHY_PARAM_RETRY_SHORT %d\n",
807 			   wiphy->retry_short);
808 		cfg_param_val.flag  |= WILC_CFG_PARAM_RETRY_SHORT;
809 		cfg_param_val.short_retry_limit = wiphy->retry_short;
810 	}
811 	if (changed & WIPHY_PARAM_RETRY_LONG) {
812 		netdev_dbg(vif->ndev,
813 			   "Setting WIPHY_PARAM_RETRY_LONG %d\n",
814 			   wiphy->retry_long);
815 		cfg_param_val.flag |= WILC_CFG_PARAM_RETRY_LONG;
816 		cfg_param_val.long_retry_limit = wiphy->retry_long;
817 	}
818 	if (changed & WIPHY_PARAM_FRAG_THRESHOLD) {
819 		if (wiphy->frag_threshold > 255 &&
820 		    wiphy->frag_threshold < 7937) {
821 			netdev_dbg(vif->ndev,
822 				   "Setting WIPHY_PARAM_FRAG_THRESHOLD %d\n",
823 				   wiphy->frag_threshold);
824 			cfg_param_val.flag |= WILC_CFG_PARAM_FRAG_THRESHOLD;
825 			cfg_param_val.frag_threshold = wiphy->frag_threshold;
826 		} else {
827 			netdev_err(vif->ndev,
828 				   "Fragmentation threshold out of range\n");
829 			goto out;
830 		}
831 	}
832 
833 	if (changed & WIPHY_PARAM_RTS_THRESHOLD) {
834 		if (wiphy->rts_threshold > 255) {
835 			netdev_dbg(vif->ndev,
836 				   "Setting WIPHY_PARAM_RTS_THRESHOLD %d\n",
837 				   wiphy->rts_threshold);
838 			cfg_param_val.flag |= WILC_CFG_PARAM_RTS_THRESHOLD;
839 			cfg_param_val.rts_threshold = wiphy->rts_threshold;
840 		} else {
841 			netdev_err(vif->ndev, "RTS threshold out of range\n");
842 			goto out;
843 		}
844 	}
845 
846 	ret = wilc_hif_set_cfg(vif, &cfg_param_val);
847 	if (ret)
848 		netdev_err(priv->dev, "Error in setting WIPHY PARAMS\n");
849 
850 out:
851 	srcu_read_unlock(&wl->srcu, srcu_idx);
852 	return ret;
853 }
854 
855 static int set_pmksa(struct wiphy *wiphy, struct net_device *netdev,
856 		     struct cfg80211_pmksa *pmksa)
857 {
858 	struct wilc_vif *vif = netdev_priv(netdev);
859 	struct wilc_priv *priv = &vif->priv;
860 	u32 i;
861 	int ret = 0;
862 	u8 flag = 0;
863 
864 	for (i = 0; i < priv->pmkid_list.numpmkid; i++)	{
865 		if (!memcmp(pmksa->bssid, priv->pmkid_list.pmkidlist[i].bssid,
866 			    ETH_ALEN)) {
867 			flag = PMKID_FOUND;
868 			break;
869 		}
870 	}
871 	if (i < WILC_MAX_NUM_PMKIDS) {
872 		memcpy(priv->pmkid_list.pmkidlist[i].bssid, pmksa->bssid,
873 		       ETH_ALEN);
874 		memcpy(priv->pmkid_list.pmkidlist[i].pmkid, pmksa->pmkid,
875 		       WLAN_PMKID_LEN);
876 		if (!(flag == PMKID_FOUND))
877 			priv->pmkid_list.numpmkid++;
878 	} else {
879 		netdev_err(netdev, "Invalid PMKID index\n");
880 		ret = -EINVAL;
881 	}
882 
883 	if (!ret)
884 		ret = wilc_set_pmkid_info(vif, &priv->pmkid_list);
885 
886 	return ret;
887 }
888 
889 static int del_pmksa(struct wiphy *wiphy, struct net_device *netdev,
890 		     struct cfg80211_pmksa *pmksa)
891 {
892 	u32 i;
893 	struct wilc_vif *vif = netdev_priv(netdev);
894 	struct wilc_priv *priv = &vif->priv;
895 
896 	for (i = 0; i < priv->pmkid_list.numpmkid; i++)	{
897 		if (!memcmp(pmksa->bssid, priv->pmkid_list.pmkidlist[i].bssid,
898 			    ETH_ALEN)) {
899 			memset(&priv->pmkid_list.pmkidlist[i], 0,
900 			       sizeof(struct wilc_pmkid));
901 			break;
902 		}
903 	}
904 
905 	if (i == priv->pmkid_list.numpmkid)
906 		return -EINVAL;
907 
908 	for (; i < (priv->pmkid_list.numpmkid - 1); i++) {
909 		memcpy(priv->pmkid_list.pmkidlist[i].bssid,
910 		       priv->pmkid_list.pmkidlist[i + 1].bssid,
911 		       ETH_ALEN);
912 		memcpy(priv->pmkid_list.pmkidlist[i].pmkid,
913 		       priv->pmkid_list.pmkidlist[i + 1].pmkid,
914 		       WLAN_PMKID_LEN);
915 	}
916 	priv->pmkid_list.numpmkid--;
917 
918 	return 0;
919 }
920 
921 static int flush_pmksa(struct wiphy *wiphy, struct net_device *netdev)
922 {
923 	struct wilc_vif *vif = netdev_priv(netdev);
924 
925 	memset(&vif->priv.pmkid_list, 0, sizeof(struct wilc_pmkid_attr));
926 
927 	return 0;
928 }
929 
930 static inline void wilc_wfi_cfg_parse_ch_attr(u8 *buf, u32 len, u8 sta_ch)
931 {
932 	struct wilc_attr_entry *e;
933 	struct wilc_attr_ch_list *ch_list;
934 	struct wilc_attr_oper_ch *op_ch;
935 	u32 index = 0;
936 	u8 ch_list_idx = 0;
937 	u8 op_ch_idx = 0;
938 
939 	if (sta_ch == WILC_INVALID_CHANNEL)
940 		return;
941 
942 	while (index + sizeof(*e) <= len) {
943 		e = (struct wilc_attr_entry *)&buf[index];
944 		if (e->attr_type == IEEE80211_P2P_ATTR_CHANNEL_LIST)
945 			ch_list_idx = index;
946 		else if (e->attr_type == IEEE80211_P2P_ATTR_OPER_CHANNEL)
947 			op_ch_idx = index;
948 		if (ch_list_idx && op_ch_idx)
949 			break;
950 		index += le16_to_cpu(e->attr_len) + sizeof(*e);
951 	}
952 
953 	if (ch_list_idx) {
954 		u16 attr_size;
955 		struct wilc_ch_list_elem *e;
956 		int i;
957 
958 		ch_list = (struct wilc_attr_ch_list *)&buf[ch_list_idx];
959 		attr_size = le16_to_cpu(ch_list->attr_len);
960 		for (i = 0; i < attr_size;) {
961 			e = (struct wilc_ch_list_elem *)(ch_list->elem + i);
962 			if (e->op_class == WILC_WLAN_OPERATING_CLASS_2_4GHZ) {
963 				memset(e->ch_list, sta_ch, e->no_of_channels);
964 				break;
965 			}
966 			i += e->no_of_channels;
967 		}
968 	}
969 
970 	if (op_ch_idx) {
971 		op_ch = (struct wilc_attr_oper_ch *)&buf[op_ch_idx];
972 		op_ch->op_class = WILC_WLAN_OPERATING_CLASS_2_4GHZ;
973 		op_ch->op_channel = sta_ch;
974 	}
975 }
976 
977 void wilc_wfi_p2p_rx(struct wilc_vif *vif, u8 *buff, u32 size)
978 {
979 	struct wilc *wl = vif->wilc;
980 	struct wilc_priv *priv = &vif->priv;
981 	struct host_if_drv *wfi_drv = priv->hif_drv;
982 	struct ieee80211_mgmt *mgmt;
983 	struct wilc_vendor_specific_ie *p;
984 	struct wilc_p2p_pub_act_frame *d;
985 	int ie_offset = offsetof(struct ieee80211_mgmt, u) + sizeof(*d);
986 	const u8 *vendor_ie;
987 	u32 header, pkt_offset;
988 	s32 freq;
989 
990 	header = get_unaligned_le32(buff - HOST_HDR_OFFSET);
991 	pkt_offset = FIELD_GET(WILC_PKT_HDR_OFFSET_FIELD, header);
992 
993 	if (pkt_offset & IS_MANAGMEMENT_CALLBACK) {
994 		bool ack = false;
995 		struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)buff;
996 
997 		if (ieee80211_is_probe_resp(hdr->frame_control) ||
998 		    pkt_offset & IS_MGMT_STATUS_SUCCES)
999 			ack = true;
1000 
1001 		cfg80211_mgmt_tx_status(&priv->wdev, priv->tx_cookie, buff,
1002 					size, ack, GFP_KERNEL);
1003 		return;
1004 	}
1005 
1006 	freq = ieee80211_channel_to_frequency(wl->op_ch, NL80211_BAND_2GHZ);
1007 
1008 	mgmt = (struct ieee80211_mgmt *)buff;
1009 	if (!ieee80211_is_action(mgmt->frame_control))
1010 		goto out_rx_mgmt;
1011 
1012 	if (priv->cfg_scanning &&
1013 	    time_after_eq(jiffies, (unsigned long)wfi_drv->p2p_timeout)) {
1014 		netdev_dbg(vif->ndev, "Receiving action wrong ch\n");
1015 		return;
1016 	}
1017 
1018 	if (!ieee80211_is_public_action((struct ieee80211_hdr *)buff, size))
1019 		goto out_rx_mgmt;
1020 
1021 	d = (struct wilc_p2p_pub_act_frame *)(&mgmt->u.action);
1022 	if (d->oui_subtype != GO_NEG_REQ && d->oui_subtype != GO_NEG_RSP &&
1023 	    d->oui_subtype != P2P_INV_REQ && d->oui_subtype != P2P_INV_RSP)
1024 		goto out_rx_mgmt;
1025 
1026 	vendor_ie = cfg80211_find_vendor_ie(WLAN_OUI_WFA, WLAN_OUI_TYPE_WFA_P2P,
1027 					    buff + ie_offset, size - ie_offset);
1028 	if (!vendor_ie)
1029 		goto out_rx_mgmt;
1030 
1031 	p = (struct wilc_vendor_specific_ie *)vendor_ie;
1032 	wilc_wfi_cfg_parse_ch_attr(p->attr, p->tag_len - 4, vif->wilc->sta_ch);
1033 
1034 out_rx_mgmt:
1035 	cfg80211_rx_mgmt(&priv->wdev, freq, 0, buff, size, 0);
1036 }
1037 
1038 static void wilc_wfi_mgmt_tx_complete(void *priv, int status)
1039 {
1040 	struct wilc_p2p_mgmt_data *pv_data = priv;
1041 
1042 	kfree(pv_data->buff);
1043 	kfree(pv_data);
1044 }
1045 
1046 static void wilc_wfi_remain_on_channel_expired(void *data, u64 cookie)
1047 {
1048 	struct wilc_vif *vif = data;
1049 	struct wilc_priv *priv = &vif->priv;
1050 	struct wilc_wfi_p2p_listen_params *params = &priv->remain_on_ch_params;
1051 
1052 	if (cookie != params->listen_cookie)
1053 		return;
1054 
1055 	priv->p2p_listen_state = false;
1056 
1057 	cfg80211_remain_on_channel_expired(&priv->wdev, params->listen_cookie,
1058 					   params->listen_ch, GFP_KERNEL);
1059 }
1060 
1061 static int remain_on_channel(struct wiphy *wiphy,
1062 			     struct wireless_dev *wdev,
1063 			     struct ieee80211_channel *chan,
1064 			     unsigned int duration, u64 *cookie)
1065 {
1066 	int ret = 0;
1067 	struct wilc_vif *vif = netdev_priv(wdev->netdev);
1068 	struct wilc_priv *priv = &vif->priv;
1069 	u64 id;
1070 
1071 	if (wdev->iftype == NL80211_IFTYPE_AP) {
1072 		netdev_dbg(vif->ndev, "Required while in AP mode\n");
1073 		return ret;
1074 	}
1075 
1076 	id = ++priv->inc_roc_cookie;
1077 	if (id == 0)
1078 		id = ++priv->inc_roc_cookie;
1079 
1080 	ret = wilc_remain_on_channel(vif, id, duration, chan->hw_value,
1081 				     wilc_wfi_remain_on_channel_expired,
1082 				     (void *)vif);
1083 	if (ret)
1084 		return ret;
1085 
1086 	vif->wilc->op_ch = chan->hw_value;
1087 
1088 	priv->remain_on_ch_params.listen_ch = chan;
1089 	priv->remain_on_ch_params.listen_cookie = id;
1090 	*cookie = id;
1091 	priv->p2p_listen_state = true;
1092 	priv->remain_on_ch_params.listen_duration = duration;
1093 
1094 	cfg80211_ready_on_channel(wdev, *cookie, chan, duration, GFP_KERNEL);
1095 	mod_timer(&vif->hif_drv->remain_on_ch_timer,
1096 		  jiffies + msecs_to_jiffies(duration + 1000));
1097 
1098 	return ret;
1099 }
1100 
1101 static int cancel_remain_on_channel(struct wiphy *wiphy,
1102 				    struct wireless_dev *wdev,
1103 				    u64 cookie)
1104 {
1105 	struct wilc_vif *vif = netdev_priv(wdev->netdev);
1106 	struct wilc_priv *priv = &vif->priv;
1107 
1108 	if (cookie != priv->remain_on_ch_params.listen_cookie)
1109 		return -ENOENT;
1110 
1111 	return wilc_listen_state_expired(vif, cookie);
1112 }
1113 
1114 static int mgmt_tx(struct wiphy *wiphy,
1115 		   struct wireless_dev *wdev,
1116 		   struct cfg80211_mgmt_tx_params *params,
1117 		   u64 *cookie)
1118 {
1119 	struct ieee80211_channel *chan = params->chan;
1120 	unsigned int wait = params->wait;
1121 	const u8 *buf = params->buf;
1122 	size_t len = params->len;
1123 	const struct ieee80211_mgmt *mgmt;
1124 	struct wilc_p2p_mgmt_data *mgmt_tx;
1125 	struct wilc_vif *vif = netdev_priv(wdev->netdev);
1126 	struct wilc_priv *priv = &vif->priv;
1127 	struct host_if_drv *wfi_drv = priv->hif_drv;
1128 	struct wilc_vendor_specific_ie *p;
1129 	struct wilc_p2p_pub_act_frame *d;
1130 	int ie_offset = offsetof(struct ieee80211_mgmt, u) + sizeof(*d);
1131 	const u8 *vendor_ie;
1132 	int ret = 0;
1133 
1134 	*cookie = prandom_u32();
1135 	priv->tx_cookie = *cookie;
1136 	mgmt = (const struct ieee80211_mgmt *)buf;
1137 
1138 	if (!ieee80211_is_mgmt(mgmt->frame_control))
1139 		goto out;
1140 
1141 	mgmt_tx = kmalloc(sizeof(*mgmt_tx), GFP_KERNEL);
1142 	if (!mgmt_tx) {
1143 		ret = -ENOMEM;
1144 		goto out;
1145 	}
1146 
1147 	mgmt_tx->buff = kmemdup(buf, len, GFP_KERNEL);
1148 	if (!mgmt_tx->buff) {
1149 		ret = -ENOMEM;
1150 		kfree(mgmt_tx);
1151 		goto out;
1152 	}
1153 
1154 	mgmt_tx->size = len;
1155 
1156 	if (ieee80211_is_probe_resp(mgmt->frame_control)) {
1157 		wilc_set_mac_chnl_num(vif, chan->hw_value);
1158 		vif->wilc->op_ch = chan->hw_value;
1159 		goto out_txq_add_pkt;
1160 	}
1161 
1162 	if (!ieee80211_is_public_action((struct ieee80211_hdr *)buf, len))
1163 		goto out_set_timeout;
1164 
1165 	d = (struct wilc_p2p_pub_act_frame *)(&mgmt->u.action);
1166 	if (d->oui_type != WLAN_OUI_TYPE_WFA_P2P ||
1167 	    d->oui_subtype != GO_NEG_CONF) {
1168 		wilc_set_mac_chnl_num(vif, chan->hw_value);
1169 		vif->wilc->op_ch = chan->hw_value;
1170 	}
1171 
1172 	if (d->oui_subtype != P2P_INV_REQ && d->oui_subtype != P2P_INV_RSP)
1173 		goto out_set_timeout;
1174 
1175 	vendor_ie = cfg80211_find_vendor_ie(WLAN_OUI_WFA, WLAN_OUI_TYPE_WFA_P2P,
1176 					    mgmt_tx->buff + ie_offset,
1177 					    len - ie_offset);
1178 	if (!vendor_ie)
1179 		goto out_set_timeout;
1180 
1181 	p = (struct wilc_vendor_specific_ie *)vendor_ie;
1182 	wilc_wfi_cfg_parse_ch_attr(p->attr, p->tag_len - 4, vif->wilc->sta_ch);
1183 
1184 out_set_timeout:
1185 	wfi_drv->p2p_timeout = (jiffies + msecs_to_jiffies(wait));
1186 
1187 out_txq_add_pkt:
1188 
1189 	wilc_wlan_txq_add_mgmt_pkt(wdev->netdev, mgmt_tx,
1190 				   mgmt_tx->buff, mgmt_tx->size,
1191 				   wilc_wfi_mgmt_tx_complete);
1192 
1193 out:
1194 
1195 	return ret;
1196 }
1197 
1198 static int mgmt_tx_cancel_wait(struct wiphy *wiphy,
1199 			       struct wireless_dev *wdev,
1200 			       u64 cookie)
1201 {
1202 	struct wilc_vif *vif = netdev_priv(wdev->netdev);
1203 	struct wilc_priv *priv = &vif->priv;
1204 	struct host_if_drv *wfi_drv = priv->hif_drv;
1205 
1206 	wfi_drv->p2p_timeout = jiffies;
1207 
1208 	if (!priv->p2p_listen_state) {
1209 		struct wilc_wfi_p2p_listen_params *params;
1210 
1211 		params = &priv->remain_on_ch_params;
1212 
1213 		cfg80211_remain_on_channel_expired(wdev,
1214 						   params->listen_cookie,
1215 						   params->listen_ch,
1216 						   GFP_KERNEL);
1217 	}
1218 
1219 	return 0;
1220 }
1221 
1222 void wilc_update_mgmt_frame_registrations(struct wiphy *wiphy,
1223 					  struct wireless_dev *wdev,
1224 					  struct mgmt_frame_regs *upd)
1225 {
1226 	struct wilc *wl = wiphy_priv(wiphy);
1227 	struct wilc_vif *vif = netdev_priv(wdev->netdev);
1228 	u32 presp_bit = BIT(IEEE80211_STYPE_PROBE_REQ >> 4);
1229 	u32 action_bit = BIT(IEEE80211_STYPE_ACTION >> 4);
1230 
1231 	if (wl->initialized) {
1232 		bool prev = vif->mgmt_reg_stypes & presp_bit;
1233 		bool now = upd->interface_stypes & presp_bit;
1234 
1235 		if (now != prev)
1236 			wilc_frame_register(vif, IEEE80211_STYPE_PROBE_REQ, now);
1237 
1238 		prev = vif->mgmt_reg_stypes & action_bit;
1239 		now = upd->interface_stypes & action_bit;
1240 
1241 		if (now != prev)
1242 			wilc_frame_register(vif, IEEE80211_STYPE_ACTION, now);
1243 	}
1244 
1245 	vif->mgmt_reg_stypes =
1246 		upd->interface_stypes & (presp_bit | action_bit);
1247 }
1248 
1249 static int set_cqm_rssi_config(struct wiphy *wiphy, struct net_device *dev,
1250 			       s32 rssi_thold, u32 rssi_hyst)
1251 {
1252 	return 0;
1253 }
1254 
1255 static int dump_station(struct wiphy *wiphy, struct net_device *dev,
1256 			int idx, u8 *mac, struct station_info *sinfo)
1257 {
1258 	struct wilc_vif *vif = netdev_priv(dev);
1259 	int ret;
1260 
1261 	if (idx != 0)
1262 		return -ENOENT;
1263 
1264 	sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL);
1265 
1266 	ret = wilc_get_rssi(vif, &sinfo->signal);
1267 	if (ret)
1268 		return ret;
1269 
1270 	memcpy(mac, vif->priv.associated_bss, ETH_ALEN);
1271 	return 0;
1272 }
1273 
1274 static int set_power_mgmt(struct wiphy *wiphy, struct net_device *dev,
1275 			  bool enabled, int timeout)
1276 {
1277 	struct wilc_vif *vif = netdev_priv(dev);
1278 	struct wilc_priv *priv = &vif->priv;
1279 
1280 	if (!priv->hif_drv)
1281 		return -EIO;
1282 
1283 	wilc_set_power_mgmt(vif, enabled, timeout);
1284 
1285 	return 0;
1286 }
1287 
1288 static int change_virtual_intf(struct wiphy *wiphy, struct net_device *dev,
1289 			       enum nl80211_iftype type,
1290 			       struct vif_params *params)
1291 {
1292 	struct wilc *wl = wiphy_priv(wiphy);
1293 	struct wilc_vif *vif = netdev_priv(dev);
1294 	struct wilc_priv *priv = &vif->priv;
1295 
1296 	switch (type) {
1297 	case NL80211_IFTYPE_STATION:
1298 		vif->connecting = false;
1299 		dev->ieee80211_ptr->iftype = type;
1300 		priv->wdev.iftype = type;
1301 		vif->monitor_flag = 0;
1302 		if (vif->iftype == WILC_AP_MODE || vif->iftype == WILC_GO_MODE)
1303 			wilc_wfi_deinit_mon_interface(wl, true);
1304 		vif->iftype = WILC_STATION_MODE;
1305 
1306 		if (wl->initialized)
1307 			wilc_set_operation_mode(vif, wilc_get_vif_idx(vif),
1308 						WILC_STATION_MODE, vif->idx);
1309 
1310 		memset(priv->assoc_stainfo.sta_associated_bss, 0,
1311 		       WILC_MAX_NUM_STA * ETH_ALEN);
1312 		break;
1313 
1314 	case NL80211_IFTYPE_P2P_CLIENT:
1315 		vif->connecting = false;
1316 		dev->ieee80211_ptr->iftype = type;
1317 		priv->wdev.iftype = type;
1318 		vif->monitor_flag = 0;
1319 		vif->iftype = WILC_CLIENT_MODE;
1320 
1321 		if (wl->initialized)
1322 			wilc_set_operation_mode(vif, wilc_get_vif_idx(vif),
1323 						WILC_STATION_MODE, vif->idx);
1324 		break;
1325 
1326 	case NL80211_IFTYPE_AP:
1327 		dev->ieee80211_ptr->iftype = type;
1328 		priv->wdev.iftype = type;
1329 		vif->iftype = WILC_AP_MODE;
1330 
1331 		if (wl->initialized)
1332 			wilc_set_operation_mode(vif, wilc_get_vif_idx(vif),
1333 						WILC_AP_MODE, vif->idx);
1334 		break;
1335 
1336 	case NL80211_IFTYPE_P2P_GO:
1337 		dev->ieee80211_ptr->iftype = type;
1338 		priv->wdev.iftype = type;
1339 		vif->iftype = WILC_GO_MODE;
1340 
1341 		if (wl->initialized)
1342 			wilc_set_operation_mode(vif, wilc_get_vif_idx(vif),
1343 						WILC_AP_MODE, vif->idx);
1344 		break;
1345 
1346 	default:
1347 		netdev_err(dev, "Unknown interface type= %d\n", type);
1348 		return -EINVAL;
1349 	}
1350 
1351 	return 0;
1352 }
1353 
1354 static int start_ap(struct wiphy *wiphy, struct net_device *dev,
1355 		    struct cfg80211_ap_settings *settings)
1356 {
1357 	struct wilc_vif *vif = netdev_priv(dev);
1358 	int ret;
1359 
1360 	ret = set_channel(wiphy, &settings->chandef);
1361 	if (ret != 0)
1362 		netdev_err(dev, "Error in setting channel\n");
1363 
1364 	wilc_wlan_set_bssid(dev, dev->dev_addr, WILC_AP_MODE);
1365 
1366 	return wilc_add_beacon(vif, settings->beacon_interval,
1367 				   settings->dtim_period, &settings->beacon);
1368 }
1369 
1370 static int change_beacon(struct wiphy *wiphy, struct net_device *dev,
1371 			 struct cfg80211_beacon_data *beacon)
1372 {
1373 	struct wilc_vif *vif = netdev_priv(dev);
1374 
1375 	return wilc_add_beacon(vif, 0, 0, beacon);
1376 }
1377 
1378 static int stop_ap(struct wiphy *wiphy, struct net_device *dev)
1379 {
1380 	int ret;
1381 	struct wilc_vif *vif = netdev_priv(dev);
1382 
1383 	wilc_wlan_set_bssid(dev, NULL, WILC_AP_MODE);
1384 
1385 	ret = wilc_del_beacon(vif);
1386 
1387 	if (ret)
1388 		netdev_err(dev, "Host delete beacon fail\n");
1389 
1390 	return ret;
1391 }
1392 
1393 static int add_station(struct wiphy *wiphy, struct net_device *dev,
1394 		       const u8 *mac, struct station_parameters *params)
1395 {
1396 	int ret = 0;
1397 	struct wilc_vif *vif = netdev_priv(dev);
1398 	struct wilc_priv *priv = &vif->priv;
1399 
1400 	if (vif->iftype == WILC_AP_MODE || vif->iftype == WILC_GO_MODE) {
1401 		memcpy(priv->assoc_stainfo.sta_associated_bss[params->aid], mac,
1402 		       ETH_ALEN);
1403 
1404 		ret = wilc_add_station(vif, mac, params);
1405 		if (ret)
1406 			netdev_err(dev, "Host add station fail\n");
1407 	}
1408 
1409 	return ret;
1410 }
1411 
1412 static int del_station(struct wiphy *wiphy, struct net_device *dev,
1413 		       struct station_del_parameters *params)
1414 {
1415 	const u8 *mac = params->mac;
1416 	int ret = 0;
1417 	struct wilc_vif *vif = netdev_priv(dev);
1418 	struct wilc_priv *priv = &vif->priv;
1419 	struct sta_info *info;
1420 
1421 	if (!(vif->iftype == WILC_AP_MODE || vif->iftype == WILC_GO_MODE))
1422 		return ret;
1423 
1424 	info = &priv->assoc_stainfo;
1425 
1426 	if (!mac)
1427 		ret = wilc_del_allstation(vif, info->sta_associated_bss);
1428 
1429 	ret = wilc_del_station(vif, mac);
1430 	if (ret)
1431 		netdev_err(dev, "Host delete station fail\n");
1432 	return ret;
1433 }
1434 
1435 static int change_station(struct wiphy *wiphy, struct net_device *dev,
1436 			  const u8 *mac, struct station_parameters *params)
1437 {
1438 	int ret = 0;
1439 	struct wilc_vif *vif = netdev_priv(dev);
1440 
1441 	if (vif->iftype == WILC_AP_MODE || vif->iftype == WILC_GO_MODE) {
1442 		ret = wilc_edit_station(vif, mac, params);
1443 		if (ret)
1444 			netdev_err(dev, "Host edit station fail\n");
1445 	}
1446 	return ret;
1447 }
1448 
1449 static struct wilc_vif *wilc_get_vif_from_type(struct wilc *wl, int type)
1450 {
1451 	struct wilc_vif *vif;
1452 
1453 	list_for_each_entry_rcu(vif, &wl->vif_list, list) {
1454 		if (vif->iftype == type)
1455 			return vif;
1456 	}
1457 
1458 	return NULL;
1459 }
1460 
1461 static struct wireless_dev *add_virtual_intf(struct wiphy *wiphy,
1462 					     const char *name,
1463 					     unsigned char name_assign_type,
1464 					     enum nl80211_iftype type,
1465 					     struct vif_params *params)
1466 {
1467 	struct wilc *wl = wiphy_priv(wiphy);
1468 	struct wilc_vif *vif;
1469 	struct wireless_dev *wdev;
1470 	int iftype;
1471 
1472 	if (type == NL80211_IFTYPE_MONITOR) {
1473 		struct net_device *ndev;
1474 		int srcu_idx;
1475 
1476 		srcu_idx = srcu_read_lock(&wl->srcu);
1477 		vif = wilc_get_vif_from_type(wl, WILC_AP_MODE);
1478 		if (!vif) {
1479 			vif = wilc_get_vif_from_type(wl, WILC_GO_MODE);
1480 			if (!vif) {
1481 				srcu_read_unlock(&wl->srcu, srcu_idx);
1482 				goto validate_interface;
1483 			}
1484 		}
1485 
1486 		if (vif->monitor_flag) {
1487 			srcu_read_unlock(&wl->srcu, srcu_idx);
1488 			goto validate_interface;
1489 		}
1490 
1491 		ndev = wilc_wfi_init_mon_interface(wl, name, vif->ndev);
1492 		if (ndev) {
1493 			vif->monitor_flag = 1;
1494 		} else {
1495 			srcu_read_unlock(&wl->srcu, srcu_idx);
1496 			return ERR_PTR(-EINVAL);
1497 		}
1498 
1499 		wdev = &vif->priv.wdev;
1500 		srcu_read_unlock(&wl->srcu, srcu_idx);
1501 		return wdev;
1502 	}
1503 
1504 validate_interface:
1505 	mutex_lock(&wl->vif_mutex);
1506 	if (wl->vif_num == WILC_NUM_CONCURRENT_IFC) {
1507 		pr_err("Reached maximum number of interface\n");
1508 		mutex_unlock(&wl->vif_mutex);
1509 		return ERR_PTR(-EINVAL);
1510 	}
1511 	mutex_unlock(&wl->vif_mutex);
1512 
1513 	switch (type) {
1514 	case NL80211_IFTYPE_STATION:
1515 		iftype = WILC_STATION_MODE;
1516 		break;
1517 	case NL80211_IFTYPE_AP:
1518 		iftype = WILC_AP_MODE;
1519 		break;
1520 	default:
1521 		return ERR_PTR(-EOPNOTSUPP);
1522 	}
1523 
1524 	vif = wilc_netdev_ifc_init(wl, name, iftype, type, true);
1525 	if (IS_ERR(vif))
1526 		return ERR_CAST(vif);
1527 
1528 	return &vif->priv.wdev;
1529 }
1530 
1531 static int del_virtual_intf(struct wiphy *wiphy, struct wireless_dev *wdev)
1532 {
1533 	struct wilc *wl = wiphy_priv(wiphy);
1534 	struct wilc_vif *vif;
1535 
1536 	if (wdev->iftype == NL80211_IFTYPE_AP ||
1537 	    wdev->iftype == NL80211_IFTYPE_P2P_GO)
1538 		wilc_wfi_deinit_mon_interface(wl, true);
1539 	vif = netdev_priv(wdev->netdev);
1540 	cfg80211_stop_iface(wiphy, wdev, GFP_KERNEL);
1541 	cfg80211_unregister_netdevice(vif->ndev);
1542 	vif->monitor_flag = 0;
1543 
1544 	wilc_set_operation_mode(vif, 0, 0, 0);
1545 	mutex_lock(&wl->vif_mutex);
1546 	list_del_rcu(&vif->list);
1547 	wl->vif_num--;
1548 	mutex_unlock(&wl->vif_mutex);
1549 	synchronize_srcu(&wl->srcu);
1550 	return 0;
1551 }
1552 
1553 static int wilc_suspend(struct wiphy *wiphy, struct cfg80211_wowlan *wow)
1554 {
1555 	struct wilc *wl = wiphy_priv(wiphy);
1556 
1557 	if (!wow && wilc_wlan_get_num_conn_ifcs(wl))
1558 		wl->suspend_event = true;
1559 	else
1560 		wl->suspend_event = false;
1561 
1562 	return 0;
1563 }
1564 
1565 static int wilc_resume(struct wiphy *wiphy)
1566 {
1567 	return 0;
1568 }
1569 
1570 static void wilc_set_wakeup(struct wiphy *wiphy, bool enabled)
1571 {
1572 	struct wilc *wl = wiphy_priv(wiphy);
1573 	struct wilc_vif *vif;
1574 	int srcu_idx;
1575 
1576 	srcu_idx = srcu_read_lock(&wl->srcu);
1577 	vif = wilc_get_wl_to_vif(wl);
1578 	if (IS_ERR(vif)) {
1579 		srcu_read_unlock(&wl->srcu, srcu_idx);
1580 		return;
1581 	}
1582 
1583 	netdev_info(vif->ndev, "cfg set wake up = %d\n", enabled);
1584 	srcu_read_unlock(&wl->srcu, srcu_idx);
1585 }
1586 
1587 static int set_tx_power(struct wiphy *wiphy, struct wireless_dev *wdev,
1588 			enum nl80211_tx_power_setting type, int mbm)
1589 {
1590 	int ret;
1591 	int srcu_idx;
1592 	s32 tx_power = MBM_TO_DBM(mbm);
1593 	struct wilc *wl = wiphy_priv(wiphy);
1594 	struct wilc_vif *vif;
1595 
1596 	if (!wl->initialized)
1597 		return -EIO;
1598 
1599 	srcu_idx = srcu_read_lock(&wl->srcu);
1600 	vif = wilc_get_wl_to_vif(wl);
1601 	if (IS_ERR(vif)) {
1602 		srcu_read_unlock(&wl->srcu, srcu_idx);
1603 		return -EINVAL;
1604 	}
1605 
1606 	netdev_info(vif->ndev, "Setting tx power %d\n", tx_power);
1607 	if (tx_power < 0)
1608 		tx_power = 0;
1609 	else if (tx_power > 18)
1610 		tx_power = 18;
1611 	ret = wilc_set_tx_power(vif, tx_power);
1612 	if (ret)
1613 		netdev_err(vif->ndev, "Failed to set tx power\n");
1614 	srcu_read_unlock(&wl->srcu, srcu_idx);
1615 
1616 	return ret;
1617 }
1618 
1619 static int get_tx_power(struct wiphy *wiphy, struct wireless_dev *wdev,
1620 			int *dbm)
1621 {
1622 	int ret;
1623 	struct wilc_vif *vif = netdev_priv(wdev->netdev);
1624 	struct wilc *wl = vif->wilc;
1625 
1626 	/* If firmware is not started, return. */
1627 	if (!wl->initialized)
1628 		return -EIO;
1629 
1630 	ret = wilc_get_tx_power(vif, (u8 *)dbm);
1631 	if (ret)
1632 		netdev_err(vif->ndev, "Failed to get tx power\n");
1633 
1634 	return ret;
1635 }
1636 
1637 static const struct cfg80211_ops wilc_cfg80211_ops = {
1638 	.set_monitor_channel = set_channel,
1639 	.scan = scan,
1640 	.connect = connect,
1641 	.disconnect = disconnect,
1642 	.add_key = add_key,
1643 	.del_key = del_key,
1644 	.get_key = get_key,
1645 	.set_default_key = set_default_key,
1646 	.add_virtual_intf = add_virtual_intf,
1647 	.del_virtual_intf = del_virtual_intf,
1648 	.change_virtual_intf = change_virtual_intf,
1649 
1650 	.start_ap = start_ap,
1651 	.change_beacon = change_beacon,
1652 	.stop_ap = stop_ap,
1653 	.add_station = add_station,
1654 	.del_station = del_station,
1655 	.change_station = change_station,
1656 	.get_station = get_station,
1657 	.dump_station = dump_station,
1658 	.change_bss = change_bss,
1659 	.set_wiphy_params = set_wiphy_params,
1660 
1661 	.set_pmksa = set_pmksa,
1662 	.del_pmksa = del_pmksa,
1663 	.flush_pmksa = flush_pmksa,
1664 	.remain_on_channel = remain_on_channel,
1665 	.cancel_remain_on_channel = cancel_remain_on_channel,
1666 	.mgmt_tx_cancel_wait = mgmt_tx_cancel_wait,
1667 	.mgmt_tx = mgmt_tx,
1668 	.update_mgmt_frame_registrations = wilc_update_mgmt_frame_registrations,
1669 	.set_power_mgmt = set_power_mgmt,
1670 	.set_cqm_rssi_config = set_cqm_rssi_config,
1671 
1672 	.suspend = wilc_suspend,
1673 	.resume = wilc_resume,
1674 	.set_wakeup = wilc_set_wakeup,
1675 	.set_tx_power = set_tx_power,
1676 	.get_tx_power = get_tx_power,
1677 
1678 };
1679 
1680 static void wlan_init_locks(struct wilc *wl)
1681 {
1682 	mutex_init(&wl->hif_cs);
1683 	mutex_init(&wl->rxq_cs);
1684 	mutex_init(&wl->cfg_cmd_lock);
1685 	mutex_init(&wl->vif_mutex);
1686 
1687 	spin_lock_init(&wl->txq_spinlock);
1688 	mutex_init(&wl->txq_add_to_head_cs);
1689 
1690 	init_completion(&wl->txq_event);
1691 	init_completion(&wl->cfg_event);
1692 	init_completion(&wl->sync_event);
1693 	init_completion(&wl->txq_thread_started);
1694 	init_srcu_struct(&wl->srcu);
1695 }
1696 
1697 void wlan_deinit_locks(struct wilc *wilc)
1698 {
1699 	mutex_destroy(&wilc->hif_cs);
1700 	mutex_destroy(&wilc->rxq_cs);
1701 	mutex_destroy(&wilc->cfg_cmd_lock);
1702 	mutex_destroy(&wilc->txq_add_to_head_cs);
1703 	mutex_destroy(&wilc->vif_mutex);
1704 	cleanup_srcu_struct(&wilc->srcu);
1705 }
1706 
1707 int wilc_cfg80211_init(struct wilc **wilc, struct device *dev, int io_type,
1708 		       const struct wilc_hif_func *ops)
1709 {
1710 	struct wilc *wl;
1711 	struct wilc_vif *vif;
1712 	int ret, i;
1713 
1714 	wl = wilc_create_wiphy(dev);
1715 	if (!wl)
1716 		return -EINVAL;
1717 
1718 	wlan_init_locks(wl);
1719 
1720 	ret = wilc_wlan_cfg_init(wl);
1721 	if (ret)
1722 		goto free_wl;
1723 
1724 	*wilc = wl;
1725 	wl->io_type = io_type;
1726 	wl->hif_func = ops;
1727 	wl->chip_ps_state = WILC_CHIP_WAKEDUP;
1728 
1729 	for (i = 0; i < NQUEUES; i++)
1730 		INIT_LIST_HEAD(&wl->txq[i].txq_head.list);
1731 
1732 	INIT_LIST_HEAD(&wl->rxq_head.list);
1733 	INIT_LIST_HEAD(&wl->vif_list);
1734 
1735 	wl->hif_workqueue = create_singlethread_workqueue("WILC_wq");
1736 	if (!wl->hif_workqueue) {
1737 		ret = -ENOMEM;
1738 		goto free_cfg;
1739 	}
1740 	vif = wilc_netdev_ifc_init(wl, "wlan%d", WILC_STATION_MODE,
1741 				   NL80211_IFTYPE_STATION, false);
1742 	if (IS_ERR(vif)) {
1743 		ret = PTR_ERR(vif);
1744 		goto free_hq;
1745 	}
1746 
1747 	return 0;
1748 
1749 free_hq:
1750 	destroy_workqueue(wl->hif_workqueue);
1751 
1752 free_cfg:
1753 	wilc_wlan_cfg_deinit(wl);
1754 
1755 free_wl:
1756 	wlan_deinit_locks(wl);
1757 	wiphy_unregister(wl->wiphy);
1758 	wiphy_free(wl->wiphy);
1759 	return ret;
1760 }
1761 EXPORT_SYMBOL_GPL(wilc_cfg80211_init);
1762 
1763 struct wilc *wilc_create_wiphy(struct device *dev)
1764 {
1765 	struct wiphy *wiphy;
1766 	struct wilc *wl;
1767 	int ret;
1768 
1769 	wiphy = wiphy_new(&wilc_cfg80211_ops, sizeof(*wl));
1770 	if (!wiphy)
1771 		return NULL;
1772 
1773 	wl = wiphy_priv(wiphy);
1774 
1775 	memcpy(wl->bitrates, wilc_bitrates, sizeof(wilc_bitrates));
1776 	memcpy(wl->channels, wilc_2ghz_channels, sizeof(wilc_2ghz_channels));
1777 	wl->band.bitrates = wl->bitrates;
1778 	wl->band.n_bitrates = ARRAY_SIZE(wl->bitrates);
1779 	wl->band.channels = wl->channels;
1780 	wl->band.n_channels = ARRAY_SIZE(wilc_2ghz_channels);
1781 
1782 	wl->band.ht_cap.ht_supported = 1;
1783 	wl->band.ht_cap.cap |= (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT);
1784 	wl->band.ht_cap.mcs.rx_mask[0] = 0xff;
1785 	wl->band.ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K;
1786 	wl->band.ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_NONE;
1787 
1788 	wiphy->bands[NL80211_BAND_2GHZ] = &wl->band;
1789 
1790 	wiphy->max_scan_ssids = WILC_MAX_NUM_PROBED_SSID;
1791 #ifdef CONFIG_PM
1792 	wiphy->wowlan = &wowlan_support;
1793 #endif
1794 	wiphy->max_num_pmkids = WILC_MAX_NUM_PMKIDS;
1795 	wiphy->max_scan_ie_len = 1000;
1796 	wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
1797 	memcpy(wl->cipher_suites, wilc_cipher_suites,
1798 	       sizeof(wilc_cipher_suites));
1799 	wiphy->cipher_suites = wl->cipher_suites;
1800 	wiphy->n_cipher_suites = ARRAY_SIZE(wilc_cipher_suites);
1801 	wiphy->mgmt_stypes = wilc_wfi_cfg80211_mgmt_types;
1802 
1803 	wiphy->max_remain_on_channel_duration = 500;
1804 	wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
1805 				BIT(NL80211_IFTYPE_AP) |
1806 				BIT(NL80211_IFTYPE_MONITOR) |
1807 				BIT(NL80211_IFTYPE_P2P_GO) |
1808 				BIT(NL80211_IFTYPE_P2P_CLIENT);
1809 	wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
1810 
1811 	set_wiphy_dev(wiphy, dev);
1812 	wl->wiphy = wiphy;
1813 	ret = wiphy_register(wiphy);
1814 	if (ret) {
1815 		wiphy_free(wiphy);
1816 		return NULL;
1817 	}
1818 	return wl;
1819 }
1820 
1821 int wilc_init_host_int(struct net_device *net)
1822 {
1823 	int ret;
1824 	struct wilc_vif *vif = netdev_priv(net);
1825 	struct wilc_priv *priv = &vif->priv;
1826 
1827 	priv->p2p_listen_state = false;
1828 
1829 	mutex_init(&priv->scan_req_lock);
1830 	ret = wilc_init(net, &priv->hif_drv);
1831 	if (ret)
1832 		netdev_err(net, "Error while initializing hostinterface\n");
1833 
1834 	return ret;
1835 }
1836 
1837 void wilc_deinit_host_int(struct net_device *net)
1838 {
1839 	int ret;
1840 	struct wilc_vif *vif = netdev_priv(net);
1841 	struct wilc_priv *priv = &vif->priv;
1842 
1843 	priv->p2p_listen_state = false;
1844 
1845 	flush_workqueue(vif->wilc->hif_workqueue);
1846 	mutex_destroy(&priv->scan_req_lock);
1847 	ret = wilc_deinit(vif);
1848 
1849 	if (ret)
1850 		netdev_err(net, "Error while deinitializing host interface\n");
1851 }
1852 
1853