xref: /linux/drivers/net/wireless/microchip/wilc1000/hif.c (revision 24b10e5f8e0d2bee1a10fc67011ea5d936c1a389)
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 "netdev.h"
8 
9 #define WILC_HIF_SCAN_TIMEOUT_MS                5000
10 #define WILC_HIF_CONNECT_TIMEOUT_MS             9500
11 
12 #define WILC_FALSE_FRMWR_CHANNEL		100
13 
14 #define WILC_SCAN_WID_LIST_SIZE		6
15 
16 struct wilc_rcvd_mac_info {
17 	u8 status;
18 };
19 
20 struct wilc_set_multicast {
21 	u32 enabled;
22 	u32 cnt;
23 	u8 *mc_list;
24 };
25 
26 struct host_if_wowlan_trigger {
27 	u8 wowlan_trigger;
28 };
29 
30 struct wilc_del_all_sta {
31 	u8 assoc_sta;
32 	u8 mac[WILC_MAX_NUM_STA][ETH_ALEN];
33 };
34 
35 union wilc_message_body {
36 	struct wilc_rcvd_net_info net_info;
37 	struct wilc_rcvd_mac_info mac_info;
38 	struct wilc_set_multicast mc_info;
39 	struct wilc_remain_ch remain_on_ch;
40 	char *data;
41 	struct host_if_wowlan_trigger wow_trigger;
42 };
43 
44 struct host_if_msg {
45 	union wilc_message_body body;
46 	struct wilc_vif *vif;
47 	struct work_struct work;
48 	void (*fn)(struct work_struct *ws);
49 	struct completion work_comp;
50 	bool is_sync;
51 };
52 
53 /* 'msg' should be free by the caller for syc */
54 static struct host_if_msg*
55 wilc_alloc_work(struct wilc_vif *vif, void (*work_fun)(struct work_struct *),
56 		bool is_sync)
57 {
58 	struct host_if_msg *msg;
59 
60 	if (!work_fun)
61 		return ERR_PTR(-EINVAL);
62 
63 	msg = kzalloc(sizeof(*msg), GFP_ATOMIC);
64 	if (!msg)
65 		return ERR_PTR(-ENOMEM);
66 	msg->fn = work_fun;
67 	msg->vif = vif;
68 	msg->is_sync = is_sync;
69 	if (is_sync)
70 		init_completion(&msg->work_comp);
71 
72 	return msg;
73 }
74 
75 static int wilc_enqueue_work(struct host_if_msg *msg)
76 {
77 	INIT_WORK(&msg->work, msg->fn);
78 
79 	if (!msg->vif || !msg->vif->wilc || !msg->vif->wilc->hif_workqueue)
80 		return -EINVAL;
81 
82 	if (!queue_work(msg->vif->wilc->hif_workqueue, &msg->work))
83 		return -EINVAL;
84 
85 	return 0;
86 }
87 
88 /* The idx starts from 0 to (NUM_CONCURRENT_IFC - 1), but 0 index used as
89  * special purpose in wilc device, so we add 1 to the index to starts from 1.
90  * As a result, the returned index will be 1 to NUM_CONCURRENT_IFC.
91  */
92 int wilc_get_vif_idx(struct wilc_vif *vif)
93 {
94 	return vif->idx + 1;
95 }
96 
97 /* We need to minus 1 from idx which is from wilc device to get real index
98  * of wilc->vif[], because we add 1 when pass to wilc device in the function
99  * wilc_get_vif_idx.
100  * As a result, the index should be between 0 and (NUM_CONCURRENT_IFC - 1).
101  */
102 static struct wilc_vif *wilc_get_vif_from_idx(struct wilc *wilc, int idx)
103 {
104 	int index = idx - 1;
105 	struct wilc_vif *vif;
106 
107 	if (index < 0 || index >= WILC_NUM_CONCURRENT_IFC)
108 		return NULL;
109 
110 	list_for_each_entry_rcu(vif, &wilc->vif_list, list) {
111 		if (vif->idx == index)
112 			return vif;
113 	}
114 
115 	return NULL;
116 }
117 
118 static int handle_scan_done(struct wilc_vif *vif, enum scan_event evt)
119 {
120 	int result = 0;
121 	u8 abort_running_scan;
122 	struct wid wid;
123 	struct host_if_drv *hif_drv = vif->hif_drv;
124 	struct wilc_user_scan_req *scan_req;
125 
126 	if (evt == SCAN_EVENT_ABORTED) {
127 		abort_running_scan = 1;
128 		wid.id = WID_ABORT_RUNNING_SCAN;
129 		wid.type = WID_CHAR;
130 		wid.val = (s8 *)&abort_running_scan;
131 		wid.size = sizeof(char);
132 
133 		result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1);
134 		if (result) {
135 			netdev_err(vif->ndev, "Failed to set abort running\n");
136 			result = -EFAULT;
137 		}
138 	}
139 
140 	if (!hif_drv) {
141 		netdev_err(vif->ndev, "%s: hif driver is NULL\n", __func__);
142 		return result;
143 	}
144 
145 	scan_req = &hif_drv->usr_scan_req;
146 	if (scan_req->scan_result) {
147 		scan_req->scan_result(evt, NULL, scan_req->priv);
148 		scan_req->scan_result = NULL;
149 	}
150 
151 	return result;
152 }
153 
154 int wilc_scan(struct wilc_vif *vif, u8 scan_source,
155 	      u8 scan_type, u8 *ch_freq_list,
156 	      void (*scan_result_fn)(enum scan_event,
157 				     struct wilc_rcvd_net_info *,
158 				     struct wilc_priv *),
159 	      struct cfg80211_scan_request *request)
160 {
161 	int result = 0;
162 	struct wid wid_list[WILC_SCAN_WID_LIST_SIZE];
163 	u32 index = 0;
164 	u32 i, scan_timeout;
165 	u8 *buffer;
166 	u8 valuesize = 0;
167 	u8 *search_ssid_vals = NULL;
168 	const u8 ch_list_len = request->n_channels;
169 	struct host_if_drv *hif_drv = vif->hif_drv;
170 
171 	if (hif_drv->hif_state >= HOST_IF_SCANNING &&
172 	    hif_drv->hif_state < HOST_IF_CONNECTED) {
173 		netdev_err(vif->ndev, "Already scan\n");
174 		result = -EBUSY;
175 		goto error;
176 	}
177 
178 	if (vif->connecting) {
179 		netdev_err(vif->ndev, "Don't do obss scan\n");
180 		result = -EBUSY;
181 		goto error;
182 	}
183 
184 	hif_drv->usr_scan_req.ch_cnt = 0;
185 
186 	if (request->n_ssids) {
187 		for (i = 0; i < request->n_ssids; i++)
188 			valuesize += ((request->ssids[i].ssid_len) + 1);
189 		search_ssid_vals = kmalloc(valuesize + 1, GFP_KERNEL);
190 		if (search_ssid_vals) {
191 			wid_list[index].id = WID_SSID_PROBE_REQ;
192 			wid_list[index].type = WID_STR;
193 			wid_list[index].val = search_ssid_vals;
194 			buffer = wid_list[index].val;
195 
196 			*buffer++ = request->n_ssids;
197 
198 			for (i = 0; i < request->n_ssids; i++) {
199 				*buffer++ = request->ssids[i].ssid_len;
200 				memcpy(buffer, request->ssids[i].ssid,
201 				       request->ssids[i].ssid_len);
202 				buffer += request->ssids[i].ssid_len;
203 			}
204 			wid_list[index].size = (s32)(valuesize + 1);
205 			index++;
206 		}
207 	}
208 
209 	wid_list[index].id = WID_INFO_ELEMENT_PROBE;
210 	wid_list[index].type = WID_BIN_DATA;
211 	wid_list[index].val = (s8 *)request->ie;
212 	wid_list[index].size = request->ie_len;
213 	index++;
214 
215 	wid_list[index].id = WID_SCAN_TYPE;
216 	wid_list[index].type = WID_CHAR;
217 	wid_list[index].size = sizeof(char);
218 	wid_list[index].val = (s8 *)&scan_type;
219 	index++;
220 
221 	if (scan_type == WILC_FW_PASSIVE_SCAN && request->duration) {
222 		wid_list[index].id = WID_PASSIVE_SCAN_TIME;
223 		wid_list[index].type = WID_SHORT;
224 		wid_list[index].size = sizeof(u16);
225 		wid_list[index].val = (s8 *)&request->duration;
226 		index++;
227 
228 		scan_timeout = (request->duration * ch_list_len) + 500;
229 	} else {
230 		scan_timeout = WILC_HIF_SCAN_TIMEOUT_MS;
231 	}
232 
233 	wid_list[index].id = WID_SCAN_CHANNEL_LIST;
234 	wid_list[index].type = WID_BIN_DATA;
235 
236 	if (ch_freq_list && ch_list_len > 0) {
237 		for (i = 0; i < ch_list_len; i++) {
238 			if (ch_freq_list[i] > 0)
239 				ch_freq_list[i] -= 1;
240 		}
241 	}
242 
243 	wid_list[index].val = ch_freq_list;
244 	wid_list[index].size = ch_list_len;
245 	index++;
246 
247 	wid_list[index].id = WID_START_SCAN_REQ;
248 	wid_list[index].type = WID_CHAR;
249 	wid_list[index].size = sizeof(char);
250 	wid_list[index].val = (s8 *)&scan_source;
251 	index++;
252 
253 	hif_drv->usr_scan_req.scan_result = scan_result_fn;
254 	hif_drv->usr_scan_req.priv = &vif->priv;
255 
256 	result = wilc_send_config_pkt(vif, WILC_SET_CFG, wid_list, index);
257 	if (result) {
258 		netdev_err(vif->ndev, "Failed to send scan parameters\n");
259 		goto error;
260 	}
261 
262 	hif_drv->scan_timer_vif = vif;
263 	mod_timer(&hif_drv->scan_timer,
264 		  jiffies + msecs_to_jiffies(scan_timeout));
265 
266 error:
267 
268 	kfree(search_ssid_vals);
269 
270 	return result;
271 }
272 
273 static int wilc_send_connect_wid(struct wilc_vif *vif)
274 {
275 	int result = 0;
276 	struct wid wid_list[5];
277 	u32 wid_cnt = 0;
278 	struct host_if_drv *hif_drv = vif->hif_drv;
279 	struct wilc_conn_info *conn_attr = &hif_drv->conn_info;
280 	struct wilc_join_bss_param *bss_param = conn_attr->param;
281 
282 
283         wid_list[wid_cnt].id = WID_SET_MFP;
284         wid_list[wid_cnt].type = WID_CHAR;
285         wid_list[wid_cnt].size = sizeof(char);
286         wid_list[wid_cnt].val = (s8 *)&conn_attr->mfp_type;
287         wid_cnt++;
288 
289 	wid_list[wid_cnt].id = WID_INFO_ELEMENT_ASSOCIATE;
290 	wid_list[wid_cnt].type = WID_BIN_DATA;
291 	wid_list[wid_cnt].val = conn_attr->req_ies;
292 	wid_list[wid_cnt].size = conn_attr->req_ies_len;
293 	wid_cnt++;
294 
295 	wid_list[wid_cnt].id = WID_11I_MODE;
296 	wid_list[wid_cnt].type = WID_CHAR;
297 	wid_list[wid_cnt].size = sizeof(char);
298 	wid_list[wid_cnt].val = (s8 *)&conn_attr->security;
299 	wid_cnt++;
300 
301 	wid_list[wid_cnt].id = WID_AUTH_TYPE;
302 	wid_list[wid_cnt].type = WID_CHAR;
303 	wid_list[wid_cnt].size = sizeof(char);
304 	wid_list[wid_cnt].val = (s8 *)&conn_attr->auth_type;
305 	wid_cnt++;
306 
307 	wid_list[wid_cnt].id = WID_JOIN_REQ_EXTENDED;
308 	wid_list[wid_cnt].type = WID_STR;
309 	wid_list[wid_cnt].size = sizeof(*bss_param);
310 	wid_list[wid_cnt].val = (u8 *)bss_param;
311 	wid_cnt++;
312 
313 	result = wilc_send_config_pkt(vif, WILC_SET_CFG, wid_list, wid_cnt);
314 	if (result) {
315 		netdev_err(vif->ndev, "failed to send config packet\n");
316 		goto error;
317 	} else {
318                 if (conn_attr->auth_type == WILC_FW_AUTH_SAE)
319                         hif_drv->hif_state = HOST_IF_EXTERNAL_AUTH;
320                 else
321                         hif_drv->hif_state = HOST_IF_WAITING_CONN_RESP;
322 	}
323 
324 	return 0;
325 
326 error:
327 
328 	kfree(conn_attr->req_ies);
329 	conn_attr->req_ies = NULL;
330 
331 	return result;
332 }
333 
334 static void handle_connect_timeout(struct work_struct *work)
335 {
336 	struct host_if_msg *msg = container_of(work, struct host_if_msg, work);
337 	struct wilc_vif *vif = msg->vif;
338 	int result;
339 	struct wid wid;
340 	u16 dummy_reason_code = 0;
341 	struct host_if_drv *hif_drv = vif->hif_drv;
342 
343 	if (!hif_drv) {
344 		netdev_err(vif->ndev, "%s: hif driver is NULL\n", __func__);
345 		goto out;
346 	}
347 
348 	hif_drv->hif_state = HOST_IF_IDLE;
349 
350 	if (hif_drv->conn_info.conn_result) {
351 		hif_drv->conn_info.conn_result(CONN_DISCONN_EVENT_CONN_RESP,
352 					       WILC_MAC_STATUS_DISCONNECTED,
353 					       hif_drv->conn_info.priv);
354 
355 	} else {
356 		netdev_err(vif->ndev, "%s: conn_result is NULL\n", __func__);
357 	}
358 
359 	wid.id = WID_DISCONNECT;
360 	wid.type = WID_CHAR;
361 	wid.val = (s8 *)&dummy_reason_code;
362 	wid.size = sizeof(char);
363 
364 	result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1);
365 	if (result)
366 		netdev_err(vif->ndev, "Failed to send disconnect\n");
367 
368 	hif_drv->conn_info.req_ies_len = 0;
369 	kfree(hif_drv->conn_info.req_ies);
370 	hif_drv->conn_info.req_ies = NULL;
371 
372 out:
373 	kfree(msg);
374 }
375 
376 struct wilc_join_bss_param *
377 wilc_parse_join_bss_param(struct cfg80211_bss *bss,
378 			  struct cfg80211_crypto_settings *crypto)
379 {
380 	struct wilc_join_bss_param *param;
381 	struct ieee80211_p2p_noa_attr noa_attr;
382 	u8 rates_len = 0;
383 	const u8 *tim_elm, *ssid_elm, *rates_ie, *supp_rates_ie;
384 	const u8 *ht_ie, *wpa_ie, *wmm_ie, *rsn_ie;
385 	int ret;
386 	const struct cfg80211_bss_ies *ies = rcu_dereference(bss->ies);
387 
388 	param = kzalloc(sizeof(*param), GFP_KERNEL);
389 	if (!param)
390 		return NULL;
391 
392 	param->beacon_period = cpu_to_le16(bss->beacon_interval);
393 	param->cap_info = cpu_to_le16(bss->capability);
394 	param->bss_type = WILC_FW_BSS_TYPE_INFRA;
395 	param->ch = ieee80211_frequency_to_channel(bss->channel->center_freq);
396 	ether_addr_copy(param->bssid, bss->bssid);
397 
398 	ssid_elm = cfg80211_find_ie(WLAN_EID_SSID, ies->data, ies->len);
399 	if (ssid_elm) {
400 		if (ssid_elm[1] <= IEEE80211_MAX_SSID_LEN)
401 			memcpy(param->ssid, ssid_elm + 2, ssid_elm[1]);
402 	}
403 
404 	tim_elm = cfg80211_find_ie(WLAN_EID_TIM, ies->data, ies->len);
405 	if (tim_elm && tim_elm[1] >= 2)
406 		param->dtim_period = tim_elm[3];
407 
408 	memset(param->p_suites, 0xFF, 3);
409 	memset(param->akm_suites, 0xFF, 3);
410 
411 	rates_ie = cfg80211_find_ie(WLAN_EID_SUPP_RATES, ies->data, ies->len);
412 	if (rates_ie) {
413 		rates_len = rates_ie[1];
414 		if (rates_len > WILC_MAX_RATES_SUPPORTED)
415 			rates_len = WILC_MAX_RATES_SUPPORTED;
416 		param->supp_rates[0] = rates_len;
417 		memcpy(&param->supp_rates[1], rates_ie + 2, rates_len);
418 	}
419 
420 	if (rates_len < WILC_MAX_RATES_SUPPORTED) {
421 		supp_rates_ie = cfg80211_find_ie(WLAN_EID_EXT_SUPP_RATES,
422 						 ies->data, ies->len);
423 		if (supp_rates_ie) {
424 			u8 ext_rates = supp_rates_ie[1];
425 
426 			if (ext_rates > (WILC_MAX_RATES_SUPPORTED - rates_len))
427 				param->supp_rates[0] = WILC_MAX_RATES_SUPPORTED;
428 			else
429 				param->supp_rates[0] += ext_rates;
430 
431 			memcpy(&param->supp_rates[rates_len + 1],
432 			       supp_rates_ie + 2,
433 			       (param->supp_rates[0] - rates_len));
434 		}
435 	}
436 
437 	ht_ie = cfg80211_find_ie(WLAN_EID_HT_CAPABILITY, ies->data, ies->len);
438 	if (ht_ie)
439 		param->ht_capable = true;
440 
441 	ret = cfg80211_get_p2p_attr(ies->data, ies->len,
442 				    IEEE80211_P2P_ATTR_ABSENCE_NOTICE,
443 				    (u8 *)&noa_attr, sizeof(noa_attr));
444 	if (ret > 0) {
445 		param->tsf_lo = cpu_to_le32(ies->tsf);
446 		param->noa_enabled = 1;
447 		param->idx = noa_attr.index;
448 		if (noa_attr.oppps_ctwindow & IEEE80211_P2P_OPPPS_ENABLE_BIT) {
449 			param->opp_enabled = 1;
450 			param->opp_en.ct_window = noa_attr.oppps_ctwindow;
451 			param->opp_en.cnt = noa_attr.desc[0].count;
452 			param->opp_en.duration = noa_attr.desc[0].duration;
453 			param->opp_en.interval = noa_attr.desc[0].interval;
454 			param->opp_en.start_time = noa_attr.desc[0].start_time;
455 		} else {
456 			param->opp_enabled = 0;
457 			param->opp_dis.cnt = noa_attr.desc[0].count;
458 			param->opp_dis.duration = noa_attr.desc[0].duration;
459 			param->opp_dis.interval = noa_attr.desc[0].interval;
460 			param->opp_dis.start_time = noa_attr.desc[0].start_time;
461 		}
462 	}
463 	wmm_ie = cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT,
464 					 WLAN_OUI_TYPE_MICROSOFT_WMM,
465 					 ies->data, ies->len);
466 	if (wmm_ie) {
467 		struct ieee80211_wmm_param_ie *ie;
468 
469 		ie = (struct ieee80211_wmm_param_ie *)wmm_ie;
470 		if ((ie->oui_subtype == 0 || ie->oui_subtype == 1) &&
471 		    ie->version == 1) {
472 			param->wmm_cap = true;
473 			if (ie->qos_info & BIT(7))
474 				param->uapsd_cap = true;
475 		}
476 	}
477 
478 	wpa_ie = cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT,
479 					 WLAN_OUI_TYPE_MICROSOFT_WPA,
480 					 ies->data, ies->len);
481 	if (wpa_ie) {
482 		param->mode_802_11i = 1;
483 		param->rsn_found = true;
484 	}
485 
486 	rsn_ie = cfg80211_find_ie(WLAN_EID_RSN, ies->data, ies->len);
487 	if (rsn_ie) {
488 		int rsn_ie_len = sizeof(struct element) + rsn_ie[1];
489 		int offset = 8;
490 
491 		param->mode_802_11i = 2;
492 		param->rsn_found = true;
493 
494 		/* extract RSN capabilities */
495 		if (offset < rsn_ie_len) {
496 			/* skip over pairwise suites */
497 			offset += (rsn_ie[offset] * 4) + 2;
498 
499 			if (offset < rsn_ie_len) {
500 				/* skip over authentication suites */
501 				offset += (rsn_ie[offset] * 4) + 2;
502 
503 				if (offset + 1 < rsn_ie_len)
504 					memcpy(param->rsn_cap, &rsn_ie[offset], 2);
505 			}
506 		}
507 	}
508 
509 	if (param->rsn_found) {
510 		int i;
511 
512 		param->rsn_grp_policy = crypto->cipher_group & 0xFF;
513 		for (i = 0; i < crypto->n_ciphers_pairwise && i < 3; i++)
514 			param->p_suites[i] = crypto->ciphers_pairwise[i] & 0xFF;
515 
516 		for (i = 0; i < crypto->n_akm_suites && i < 3; i++)
517 			param->akm_suites[i] = crypto->akm_suites[i] & 0xFF;
518 	}
519 
520 	return (void *)param;
521 }
522 
523 static void handle_rcvd_ntwrk_info(struct work_struct *work)
524 {
525 	struct host_if_msg *msg = container_of(work, struct host_if_msg, work);
526 	struct wilc_rcvd_net_info *rcvd_info = &msg->body.net_info;
527 	struct wilc_user_scan_req *scan_req = &msg->vif->hif_drv->usr_scan_req;
528 	const u8 *ch_elm;
529 	u8 *ies;
530 	int ies_len;
531 	size_t offset;
532 
533 	if (ieee80211_is_probe_resp(rcvd_info->mgmt->frame_control))
534 		offset = offsetof(struct ieee80211_mgmt, u.probe_resp.variable);
535 	else if (ieee80211_is_beacon(rcvd_info->mgmt->frame_control))
536 		offset = offsetof(struct ieee80211_mgmt, u.beacon.variable);
537 	else
538 		goto done;
539 
540 	ies = rcvd_info->mgmt->u.beacon.variable;
541 	ies_len = rcvd_info->frame_len - offset;
542 	if (ies_len <= 0)
543 		goto done;
544 
545 	ch_elm = cfg80211_find_ie(WLAN_EID_DS_PARAMS, ies, ies_len);
546 	if (ch_elm && ch_elm[1] > 0)
547 		rcvd_info->ch = ch_elm[2];
548 
549 	if (scan_req->scan_result)
550 		scan_req->scan_result(SCAN_EVENT_NETWORK_FOUND, rcvd_info,
551 				      scan_req->priv);
552 
553 done:
554 	kfree(rcvd_info->mgmt);
555 	kfree(msg);
556 }
557 
558 static void host_int_get_assoc_res_info(struct wilc_vif *vif,
559 					u8 *assoc_resp_info,
560 					u32 max_assoc_resp_info_len,
561 					u32 *rcvd_assoc_resp_info_len)
562 {
563 	int result;
564 	struct wid wid;
565 
566 	wid.id = WID_ASSOC_RES_INFO;
567 	wid.type = WID_STR;
568 	wid.val = assoc_resp_info;
569 	wid.size = max_assoc_resp_info_len;
570 
571 	result = wilc_send_config_pkt(vif, WILC_GET_CFG, &wid, 1);
572 	if (result) {
573 		*rcvd_assoc_resp_info_len = 0;
574 		netdev_err(vif->ndev, "Failed to send association response\n");
575 		return;
576 	}
577 
578 	*rcvd_assoc_resp_info_len = wid.size;
579 }
580 
581 static s32 wilc_parse_assoc_resp_info(u8 *buffer, u32 buffer_len,
582 				      struct wilc_conn_info *ret_conn_info)
583 {
584 	u8 *ies;
585 	u16 ies_len;
586 	struct wilc_assoc_resp *res = (struct wilc_assoc_resp *)buffer;
587 
588 	ret_conn_info->status = le16_to_cpu(res->status_code);
589 	if (ret_conn_info->status == WLAN_STATUS_SUCCESS) {
590 		ies = &buffer[sizeof(*res)];
591 		ies_len = buffer_len - sizeof(*res);
592 
593 		ret_conn_info->resp_ies = kmemdup(ies, ies_len, GFP_KERNEL);
594 		if (!ret_conn_info->resp_ies)
595 			return -ENOMEM;
596 
597 		ret_conn_info->resp_ies_len = ies_len;
598 	}
599 
600 	return 0;
601 }
602 
603 static inline void host_int_parse_assoc_resp_info(struct wilc_vif *vif,
604 						  u8 mac_status)
605 {
606 	struct host_if_drv *hif_drv = vif->hif_drv;
607 	struct wilc_conn_info *conn_info = &hif_drv->conn_info;
608 
609 	if (mac_status == WILC_MAC_STATUS_CONNECTED) {
610 		u32 assoc_resp_info_len;
611 
612 		memset(hif_drv->assoc_resp, 0, WILC_MAX_ASSOC_RESP_FRAME_SIZE);
613 
614 		host_int_get_assoc_res_info(vif, hif_drv->assoc_resp,
615 					    WILC_MAX_ASSOC_RESP_FRAME_SIZE,
616 					    &assoc_resp_info_len);
617 
618 		if (assoc_resp_info_len != 0) {
619 			s32 err = 0;
620 
621 			err = wilc_parse_assoc_resp_info(hif_drv->assoc_resp,
622 							 assoc_resp_info_len,
623 							 conn_info);
624 			if (err)
625 				netdev_err(vif->ndev,
626 					   "wilc_parse_assoc_resp_info() returned error %d\n",
627 					   err);
628 		}
629 	}
630 
631 	del_timer(&hif_drv->connect_timer);
632 	conn_info->conn_result(CONN_DISCONN_EVENT_CONN_RESP, mac_status,
633 			       hif_drv->conn_info.priv);
634 
635 	if (mac_status == WILC_MAC_STATUS_CONNECTED &&
636 	    conn_info->status == WLAN_STATUS_SUCCESS) {
637 		ether_addr_copy(hif_drv->assoc_bssid, conn_info->bssid);
638 		hif_drv->hif_state = HOST_IF_CONNECTED;
639 	} else {
640 		hif_drv->hif_state = HOST_IF_IDLE;
641 	}
642 
643 	kfree(conn_info->resp_ies);
644 	conn_info->resp_ies = NULL;
645 	conn_info->resp_ies_len = 0;
646 
647 	kfree(conn_info->req_ies);
648 	conn_info->req_ies = NULL;
649 	conn_info->req_ies_len = 0;
650 }
651 
652 void wilc_handle_disconnect(struct wilc_vif *vif)
653 {
654 	struct host_if_drv *hif_drv = vif->hif_drv;
655 
656 	if (hif_drv->usr_scan_req.scan_result) {
657 		del_timer(&hif_drv->scan_timer);
658 		handle_scan_done(vif, SCAN_EVENT_ABORTED);
659 	}
660 
661 	if (hif_drv->conn_info.conn_result)
662 		hif_drv->conn_info.conn_result(CONN_DISCONN_EVENT_DISCONN_NOTIF,
663 					       0, hif_drv->conn_info.priv);
664 
665 	eth_zero_addr(hif_drv->assoc_bssid);
666 
667 	hif_drv->conn_info.req_ies_len = 0;
668 	kfree(hif_drv->conn_info.req_ies);
669 	hif_drv->conn_info.req_ies = NULL;
670 	hif_drv->hif_state = HOST_IF_IDLE;
671 }
672 
673 static void handle_rcvd_gnrl_async_info(struct work_struct *work)
674 {
675 	struct host_if_msg *msg = container_of(work, struct host_if_msg, work);
676 	struct wilc_vif *vif = msg->vif;
677 	struct wilc_rcvd_mac_info *mac_info = &msg->body.mac_info;
678 	struct host_if_drv *hif_drv = vif->hif_drv;
679 
680 	if (!hif_drv) {
681 		netdev_err(vif->ndev, "%s: hif driver is NULL\n", __func__);
682 		goto free_msg;
683 	}
684 
685 	if (!hif_drv->conn_info.conn_result) {
686 		netdev_err(vif->ndev, "%s: conn_result is NULL\n", __func__);
687 		goto free_msg;
688 	}
689 
690 
691         if (hif_drv->hif_state == HOST_IF_EXTERNAL_AUTH) {
692                 cfg80211_external_auth_request(vif->ndev, &vif->auth,
693 					       GFP_KERNEL);
694                 hif_drv->hif_state = HOST_IF_WAITING_CONN_RESP;
695         } else if (hif_drv->hif_state == HOST_IF_WAITING_CONN_RESP) {
696 		host_int_parse_assoc_resp_info(vif, mac_info->status);
697 	} else if (mac_info->status == WILC_MAC_STATUS_DISCONNECTED) {
698 		if (hif_drv->hif_state == HOST_IF_CONNECTED) {
699 			wilc_handle_disconnect(vif);
700 		} else if (hif_drv->usr_scan_req.scan_result) {
701 			del_timer(&hif_drv->scan_timer);
702 			handle_scan_done(vif, SCAN_EVENT_ABORTED);
703 		}
704 	}
705 
706 free_msg:
707 	kfree(msg);
708 }
709 
710 int wilc_disconnect(struct wilc_vif *vif)
711 {
712 	struct wid wid;
713 	struct host_if_drv *hif_drv = vif->hif_drv;
714 	struct wilc_user_scan_req *scan_req;
715 	struct wilc_conn_info *conn_info;
716 	int result;
717 	u16 dummy_reason_code = 0;
718 
719 	wid.id = WID_DISCONNECT;
720 	wid.type = WID_CHAR;
721 	wid.val = (s8 *)&dummy_reason_code;
722 	wid.size = sizeof(char);
723 
724 	result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1);
725 	if (result) {
726 		netdev_err(vif->ndev, "Failed to send disconnect\n");
727 		return result;
728 	}
729 
730 	scan_req = &hif_drv->usr_scan_req;
731 	conn_info = &hif_drv->conn_info;
732 
733 	if (scan_req->scan_result) {
734 		del_timer(&hif_drv->scan_timer);
735 		scan_req->scan_result(SCAN_EVENT_ABORTED, NULL, scan_req->priv);
736 		scan_req->scan_result = NULL;
737 	}
738 
739 	if (conn_info->conn_result) {
740 		if (hif_drv->hif_state == HOST_IF_WAITING_CONN_RESP ||
741 		    hif_drv->hif_state == HOST_IF_EXTERNAL_AUTH)
742 			del_timer(&hif_drv->connect_timer);
743 
744 		conn_info->conn_result(CONN_DISCONN_EVENT_DISCONN_NOTIF, 0,
745 				       conn_info->priv);
746 	} else {
747 		netdev_err(vif->ndev, "%s: conn_result is NULL\n", __func__);
748 	}
749 
750 	hif_drv->hif_state = HOST_IF_IDLE;
751 
752 	eth_zero_addr(hif_drv->assoc_bssid);
753 
754 	conn_info->req_ies_len = 0;
755 	kfree(conn_info->req_ies);
756 	conn_info->req_ies = NULL;
757 
758 	return 0;
759 }
760 
761 int wilc_get_statistics(struct wilc_vif *vif, struct rf_info *stats)
762 {
763 	struct wid wid_list[5];
764 	u32 wid_cnt = 0, result;
765 
766 	wid_list[wid_cnt].id = WID_LINKSPEED;
767 	wid_list[wid_cnt].type = WID_CHAR;
768 	wid_list[wid_cnt].size = sizeof(char);
769 	wid_list[wid_cnt].val = (s8 *)&stats->link_speed;
770 	wid_cnt++;
771 
772 	wid_list[wid_cnt].id = WID_RSSI;
773 	wid_list[wid_cnt].type = WID_CHAR;
774 	wid_list[wid_cnt].size = sizeof(char);
775 	wid_list[wid_cnt].val = (s8 *)&stats->rssi;
776 	wid_cnt++;
777 
778 	wid_list[wid_cnt].id = WID_SUCCESS_FRAME_COUNT;
779 	wid_list[wid_cnt].type = WID_INT;
780 	wid_list[wid_cnt].size = sizeof(u32);
781 	wid_list[wid_cnt].val = (s8 *)&stats->tx_cnt;
782 	wid_cnt++;
783 
784 	wid_list[wid_cnt].id = WID_RECEIVED_FRAGMENT_COUNT;
785 	wid_list[wid_cnt].type = WID_INT;
786 	wid_list[wid_cnt].size = sizeof(u32);
787 	wid_list[wid_cnt].val = (s8 *)&stats->rx_cnt;
788 	wid_cnt++;
789 
790 	wid_list[wid_cnt].id = WID_FAILED_COUNT;
791 	wid_list[wid_cnt].type = WID_INT;
792 	wid_list[wid_cnt].size = sizeof(u32);
793 	wid_list[wid_cnt].val = (s8 *)&stats->tx_fail_cnt;
794 	wid_cnt++;
795 
796 	result = wilc_send_config_pkt(vif, WILC_GET_CFG, wid_list, wid_cnt);
797 	if (result) {
798 		netdev_err(vif->ndev, "Failed to send scan parameters\n");
799 		return result;
800 	}
801 
802 	if (stats->link_speed > TCP_ACK_FILTER_LINK_SPEED_THRESH &&
803 	    stats->link_speed != DEFAULT_LINK_SPEED)
804 		wilc_enable_tcp_ack_filter(vif, true);
805 	else if (stats->link_speed != DEFAULT_LINK_SPEED)
806 		wilc_enable_tcp_ack_filter(vif, false);
807 
808 	return result;
809 }
810 
811 static void handle_get_statistics(struct work_struct *work)
812 {
813 	struct host_if_msg *msg = container_of(work, struct host_if_msg, work);
814 	struct wilc_vif *vif = msg->vif;
815 	struct rf_info *stats = (struct rf_info *)msg->body.data;
816 
817 	wilc_get_statistics(vif, stats);
818 
819 	kfree(msg);
820 }
821 
822 static void wilc_hif_pack_sta_param(u8 *cur_byte, const u8 *mac,
823 				    struct station_parameters *params)
824 {
825 	ether_addr_copy(cur_byte, mac);
826 	cur_byte += ETH_ALEN;
827 
828 	put_unaligned_le16(params->aid, cur_byte);
829 	cur_byte += 2;
830 
831 	*cur_byte++ = params->link_sta_params.supported_rates_len;
832 	if (params->link_sta_params.supported_rates_len > 0)
833 		memcpy(cur_byte, params->link_sta_params.supported_rates,
834 		       params->link_sta_params.supported_rates_len);
835 	cur_byte += params->link_sta_params.supported_rates_len;
836 
837 	if (params->link_sta_params.ht_capa) {
838 		*cur_byte++ = true;
839 		memcpy(cur_byte, params->link_sta_params.ht_capa,
840 		       sizeof(struct ieee80211_ht_cap));
841 	} else {
842 		*cur_byte++ = false;
843 	}
844 	cur_byte += sizeof(struct ieee80211_ht_cap);
845 
846 	put_unaligned_le16(params->sta_flags_mask, cur_byte);
847 	cur_byte += 2;
848 	put_unaligned_le16(params->sta_flags_set, cur_byte);
849 }
850 
851 static int handle_remain_on_chan(struct wilc_vif *vif,
852 				 struct wilc_remain_ch *hif_remain_ch)
853 {
854 	int result;
855 	u8 remain_on_chan_flag;
856 	struct wid wid;
857 	struct host_if_drv *hif_drv = vif->hif_drv;
858 
859 	if (hif_drv->usr_scan_req.scan_result)
860 		return -EBUSY;
861 
862 	if (hif_drv->hif_state == HOST_IF_WAITING_CONN_RESP)
863 		return -EBUSY;
864 
865 	if (vif->connecting)
866 		return -EBUSY;
867 
868 	remain_on_chan_flag = true;
869 	wid.id = WID_REMAIN_ON_CHAN;
870 	wid.type = WID_STR;
871 	wid.size = 2;
872 	wid.val = kmalloc(wid.size, GFP_KERNEL);
873 	if (!wid.val)
874 		return -ENOMEM;
875 
876 	wid.val[0] = remain_on_chan_flag;
877 	wid.val[1] = (s8)hif_remain_ch->ch;
878 
879 	result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1);
880 	kfree(wid.val);
881 	if (result)
882 		return -EBUSY;
883 
884 	hif_drv->remain_on_ch.vif = hif_remain_ch->vif;
885 	hif_drv->remain_on_ch.expired = hif_remain_ch->expired;
886 	hif_drv->remain_on_ch.ch = hif_remain_ch->ch;
887 	hif_drv->remain_on_ch.cookie = hif_remain_ch->cookie;
888 	hif_drv->remain_on_ch_timer_vif = vif;
889 
890 	return 0;
891 }
892 
893 static int wilc_handle_roc_expired(struct wilc_vif *vif, u64 cookie)
894 {
895 	u8 remain_on_chan_flag;
896 	struct wid wid;
897 	int result;
898 	struct host_if_drv *hif_drv = vif->hif_drv;
899 
900 	if (vif->priv.p2p_listen_state) {
901 		remain_on_chan_flag = false;
902 		wid.id = WID_REMAIN_ON_CHAN;
903 		wid.type = WID_STR;
904 		wid.size = 2;
905 
906 		wid.val = kmalloc(wid.size, GFP_KERNEL);
907 		if (!wid.val)
908 			return -ENOMEM;
909 
910 		wid.val[0] = remain_on_chan_flag;
911 		wid.val[1] = WILC_FALSE_FRMWR_CHANNEL;
912 
913 		result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1);
914 		kfree(wid.val);
915 		if (result != 0) {
916 			netdev_err(vif->ndev, "Failed to set remain channel\n");
917 			return -EINVAL;
918 		}
919 
920 		if (hif_drv->remain_on_ch.expired) {
921 			hif_drv->remain_on_ch.expired(hif_drv->remain_on_ch.vif,
922 						      cookie);
923 		}
924 	} else {
925 		netdev_dbg(vif->ndev, "Not in listen state\n");
926 	}
927 
928 	return 0;
929 }
930 
931 static void wilc_handle_listen_state_expired(struct work_struct *work)
932 {
933 	struct host_if_msg *msg = container_of(work, struct host_if_msg, work);
934 
935 	wilc_handle_roc_expired(msg->vif, msg->body.remain_on_ch.cookie);
936 	kfree(msg);
937 }
938 
939 static void listen_timer_cb(struct timer_list *t)
940 {
941 	struct host_if_drv *hif_drv = from_timer(hif_drv, t,
942 						      remain_on_ch_timer);
943 	struct wilc_vif *vif = hif_drv->remain_on_ch_timer_vif;
944 	int result;
945 	struct host_if_msg *msg;
946 
947 	del_timer(&vif->hif_drv->remain_on_ch_timer);
948 
949 	msg = wilc_alloc_work(vif, wilc_handle_listen_state_expired, false);
950 	if (IS_ERR(msg))
951 		return;
952 
953 	msg->body.remain_on_ch.cookie = vif->hif_drv->remain_on_ch.cookie;
954 
955 	result = wilc_enqueue_work(msg);
956 	if (result) {
957 		netdev_err(vif->ndev, "%s: enqueue work failed\n", __func__);
958 		kfree(msg);
959 	}
960 }
961 
962 static void handle_set_mcast_filter(struct work_struct *work)
963 {
964 	struct host_if_msg *msg = container_of(work, struct host_if_msg, work);
965 	struct wilc_vif *vif = msg->vif;
966 	struct wilc_set_multicast *set_mc = &msg->body.mc_info;
967 	int result;
968 	struct wid wid;
969 	u8 *cur_byte;
970 
971 	wid.id = WID_SETUP_MULTICAST_FILTER;
972 	wid.type = WID_BIN;
973 	wid.size = sizeof(struct wilc_set_multicast) + (set_mc->cnt * ETH_ALEN);
974 	wid.val = kmalloc(wid.size, GFP_KERNEL);
975 	if (!wid.val)
976 		goto error;
977 
978 	cur_byte = wid.val;
979 	put_unaligned_le32(set_mc->enabled, cur_byte);
980 	cur_byte += 4;
981 
982 	put_unaligned_le32(set_mc->cnt, cur_byte);
983 	cur_byte += 4;
984 
985 	if (set_mc->cnt > 0 && set_mc->mc_list)
986 		memcpy(cur_byte, set_mc->mc_list, set_mc->cnt * ETH_ALEN);
987 
988 	result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1);
989 	if (result)
990 		netdev_err(vif->ndev, "Failed to send setup multicast\n");
991 
992 error:
993 	kfree(set_mc->mc_list);
994 	kfree(wid.val);
995 	kfree(msg);
996 }
997 
998 void wilc_set_wowlan_trigger(struct wilc_vif *vif, bool enabled)
999 {
1000 	int ret;
1001 	struct wid wid;
1002 	u8 wowlan_trigger = 0;
1003 
1004 	if (enabled)
1005 		wowlan_trigger = 1;
1006 
1007 	wid.id = WID_WOWLAN_TRIGGER;
1008 	wid.type = WID_CHAR;
1009 	wid.val = &wowlan_trigger;
1010 	wid.size = sizeof(char);
1011 
1012 	ret = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1);
1013 	if (ret)
1014 		pr_err("Failed to send wowlan trigger config packet\n");
1015 }
1016 
1017 int wilc_set_external_auth_param(struct wilc_vif *vif,
1018 				 struct cfg80211_external_auth_params *auth)
1019 {
1020 	int ret;
1021 	struct wid wid;
1022 	struct wilc_external_auth_param *param;
1023 
1024 	wid.id = WID_EXTERNAL_AUTH_PARAM;
1025 	wid.type = WID_BIN_DATA;
1026 	wid.size = sizeof(*param);
1027 	param = kzalloc(sizeof(*param), GFP_KERNEL);
1028 	if (!param)
1029 		return -EINVAL;
1030 
1031 	wid.val = (u8 *)param;
1032 	param->action = auth->action;
1033 	ether_addr_copy(param->bssid, auth->bssid);
1034 	memcpy(param->ssid, auth->ssid.ssid, auth->ssid.ssid_len);
1035 	param->ssid_len = auth->ssid.ssid_len;
1036 	ret = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1);
1037 
1038 	kfree(param);
1039 	return ret;
1040 }
1041 
1042 static void handle_scan_timer(struct work_struct *work)
1043 {
1044 	struct host_if_msg *msg = container_of(work, struct host_if_msg, work);
1045 
1046 	handle_scan_done(msg->vif, SCAN_EVENT_ABORTED);
1047 	kfree(msg);
1048 }
1049 
1050 static void handle_scan_complete(struct work_struct *work)
1051 {
1052 	struct host_if_msg *msg = container_of(work, struct host_if_msg, work);
1053 
1054 	del_timer(&msg->vif->hif_drv->scan_timer);
1055 
1056 	handle_scan_done(msg->vif, SCAN_EVENT_DONE);
1057 
1058 	kfree(msg);
1059 }
1060 
1061 static void timer_scan_cb(struct timer_list *t)
1062 {
1063 	struct host_if_drv *hif_drv = from_timer(hif_drv, t, scan_timer);
1064 	struct wilc_vif *vif = hif_drv->scan_timer_vif;
1065 	struct host_if_msg *msg;
1066 	int result;
1067 
1068 	msg = wilc_alloc_work(vif, handle_scan_timer, false);
1069 	if (IS_ERR(msg))
1070 		return;
1071 
1072 	result = wilc_enqueue_work(msg);
1073 	if (result)
1074 		kfree(msg);
1075 }
1076 
1077 static void timer_connect_cb(struct timer_list *t)
1078 {
1079 	struct host_if_drv *hif_drv = from_timer(hif_drv, t,
1080 						      connect_timer);
1081 	struct wilc_vif *vif = hif_drv->connect_timer_vif;
1082 	struct host_if_msg *msg;
1083 	int result;
1084 
1085 	msg = wilc_alloc_work(vif, handle_connect_timeout, false);
1086 	if (IS_ERR(msg))
1087 		return;
1088 
1089 	result = wilc_enqueue_work(msg);
1090 	if (result)
1091 		kfree(msg);
1092 }
1093 
1094 int wilc_add_ptk(struct wilc_vif *vif, const u8 *ptk, u8 ptk_key_len,
1095 		 const u8 *mac_addr, const u8 *rx_mic, const u8 *tx_mic,
1096 		 u8 mode, u8 cipher_mode, u8 index)
1097 {
1098 	int result = 0;
1099 	u8 t_key_len  = ptk_key_len + WILC_RX_MIC_KEY_LEN + WILC_TX_MIC_KEY_LEN;
1100 
1101 	if (mode == WILC_AP_MODE) {
1102 		struct wid wid_list[2];
1103 		struct wilc_ap_wpa_ptk *key_buf;
1104 
1105 		wid_list[0].id = WID_11I_MODE;
1106 		wid_list[0].type = WID_CHAR;
1107 		wid_list[0].size = sizeof(char);
1108 		wid_list[0].val = (s8 *)&cipher_mode;
1109 
1110 		key_buf = kzalloc(sizeof(*key_buf) + t_key_len, GFP_KERNEL);
1111 		if (!key_buf)
1112 			return -ENOMEM;
1113 
1114 		ether_addr_copy(key_buf->mac_addr, mac_addr);
1115 		key_buf->index = index;
1116 		key_buf->key_len = t_key_len;
1117 		memcpy(&key_buf->key[0], ptk, ptk_key_len);
1118 
1119 		if (rx_mic)
1120 			memcpy(&key_buf->key[ptk_key_len], rx_mic,
1121 			       WILC_RX_MIC_KEY_LEN);
1122 
1123 		if (tx_mic)
1124 			memcpy(&key_buf->key[ptk_key_len + WILC_RX_MIC_KEY_LEN],
1125 			       tx_mic, WILC_TX_MIC_KEY_LEN);
1126 
1127 		wid_list[1].id = WID_ADD_PTK;
1128 		wid_list[1].type = WID_STR;
1129 		wid_list[1].size = sizeof(*key_buf) + t_key_len;
1130 		wid_list[1].val = (u8 *)key_buf;
1131 		result = wilc_send_config_pkt(vif, WILC_SET_CFG, wid_list,
1132 					      ARRAY_SIZE(wid_list));
1133 		kfree(key_buf);
1134 	} else if (mode == WILC_STATION_MODE) {
1135 		struct wid wid;
1136 		struct wilc_sta_wpa_ptk *key_buf;
1137 
1138 		key_buf = kzalloc(sizeof(*key_buf) + t_key_len, GFP_KERNEL);
1139 		if (!key_buf)
1140 			return -ENOMEM;
1141 
1142 		ether_addr_copy(key_buf->mac_addr, mac_addr);
1143 		key_buf->key_len = t_key_len;
1144 		memcpy(&key_buf->key[0], ptk, ptk_key_len);
1145 
1146 		if (rx_mic)
1147 			memcpy(&key_buf->key[ptk_key_len], rx_mic,
1148 			       WILC_RX_MIC_KEY_LEN);
1149 
1150 		if (tx_mic)
1151 			memcpy(&key_buf->key[ptk_key_len + WILC_RX_MIC_KEY_LEN],
1152 			       tx_mic, WILC_TX_MIC_KEY_LEN);
1153 
1154 		wid.id = WID_ADD_PTK;
1155 		wid.type = WID_STR;
1156 		wid.size = sizeof(*key_buf) + t_key_len;
1157 		wid.val = (s8 *)key_buf;
1158 		result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1);
1159 		kfree(key_buf);
1160 	}
1161 
1162 	return result;
1163 }
1164 
1165 int wilc_add_igtk(struct wilc_vif *vif, const u8 *igtk, u8 igtk_key_len,
1166 		  const u8 *pn, u8 pn_len, const u8 *mac_addr, u8 mode, u8 index)
1167 {
1168 	int result = 0;
1169 	u8 t_key_len = igtk_key_len;
1170 	struct wid wid;
1171 	struct wilc_wpa_igtk *key_buf;
1172 
1173 	key_buf = kzalloc(sizeof(*key_buf) + t_key_len, GFP_KERNEL);
1174 	if (!key_buf)
1175 		return -ENOMEM;
1176 
1177 	key_buf->index = index;
1178 
1179 	memcpy(&key_buf->pn[0], pn, pn_len);
1180 	key_buf->pn_len = pn_len;
1181 
1182 	memcpy(&key_buf->key[0], igtk, igtk_key_len);
1183 	key_buf->key_len = t_key_len;
1184 
1185 	wid.id = WID_ADD_IGTK;
1186 	wid.type = WID_STR;
1187 	wid.size = sizeof(*key_buf) + t_key_len;
1188 	wid.val = (s8 *)key_buf;
1189 	result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1);
1190 	kfree(key_buf);
1191 
1192 	return result;
1193 }
1194 
1195 int wilc_add_rx_gtk(struct wilc_vif *vif, const u8 *rx_gtk, u8 gtk_key_len,
1196 		    u8 index, u32 key_rsc_len, const u8 *key_rsc,
1197 		    const u8 *rx_mic, const u8 *tx_mic, u8 mode,
1198 		    u8 cipher_mode)
1199 {
1200 	int result = 0;
1201 	struct wilc_gtk_key *gtk_key;
1202 	int t_key_len = gtk_key_len + WILC_RX_MIC_KEY_LEN + WILC_TX_MIC_KEY_LEN;
1203 
1204 	gtk_key = kzalloc(sizeof(*gtk_key) + t_key_len, GFP_KERNEL);
1205 	if (!gtk_key)
1206 		return -ENOMEM;
1207 
1208 	/* fill bssid value only in station mode */
1209 	if (mode == WILC_STATION_MODE &&
1210 	    vif->hif_drv->hif_state == HOST_IF_CONNECTED)
1211 		memcpy(gtk_key->mac_addr, vif->hif_drv->assoc_bssid, ETH_ALEN);
1212 
1213 	if (key_rsc)
1214 		memcpy(gtk_key->rsc, key_rsc, 8);
1215 	gtk_key->index = index;
1216 	gtk_key->key_len = t_key_len;
1217 	memcpy(&gtk_key->key[0], rx_gtk, gtk_key_len);
1218 
1219 	if (rx_mic)
1220 		memcpy(&gtk_key->key[gtk_key_len], rx_mic, WILC_RX_MIC_KEY_LEN);
1221 
1222 	if (tx_mic)
1223 		memcpy(&gtk_key->key[gtk_key_len + WILC_RX_MIC_KEY_LEN],
1224 		       tx_mic, WILC_TX_MIC_KEY_LEN);
1225 
1226 	if (mode == WILC_AP_MODE) {
1227 		struct wid wid_list[2];
1228 
1229 		wid_list[0].id = WID_11I_MODE;
1230 		wid_list[0].type = WID_CHAR;
1231 		wid_list[0].size = sizeof(char);
1232 		wid_list[0].val = (s8 *)&cipher_mode;
1233 
1234 		wid_list[1].id = WID_ADD_RX_GTK;
1235 		wid_list[1].type = WID_STR;
1236 		wid_list[1].size = sizeof(*gtk_key) + t_key_len;
1237 		wid_list[1].val = (u8 *)gtk_key;
1238 
1239 		result = wilc_send_config_pkt(vif, WILC_SET_CFG, wid_list,
1240 					      ARRAY_SIZE(wid_list));
1241 	} else if (mode == WILC_STATION_MODE) {
1242 		struct wid wid;
1243 
1244 		wid.id = WID_ADD_RX_GTK;
1245 		wid.type = WID_STR;
1246 		wid.size = sizeof(*gtk_key) + t_key_len;
1247 		wid.val = (u8 *)gtk_key;
1248 		result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1);
1249 	}
1250 
1251 	kfree(gtk_key);
1252 	return result;
1253 }
1254 
1255 int wilc_set_pmkid_info(struct wilc_vif *vif, struct wilc_pmkid_attr *pmkid)
1256 {
1257 	struct wid wid;
1258 
1259 	wid.id = WID_PMKID_INFO;
1260 	wid.type = WID_STR;
1261 	wid.size = (pmkid->numpmkid * sizeof(struct wilc_pmkid)) + 1;
1262 	wid.val = (u8 *)pmkid;
1263 
1264 	return wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1);
1265 }
1266 
1267 int wilc_get_mac_address(struct wilc_vif *vif, u8 *mac_addr)
1268 {
1269 	int result;
1270 	struct wid wid;
1271 
1272 	wid.id = WID_MAC_ADDR;
1273 	wid.type = WID_STR;
1274 	wid.size = ETH_ALEN;
1275 	wid.val = mac_addr;
1276 
1277 	result = wilc_send_config_pkt(vif, WILC_GET_CFG, &wid, 1);
1278 	if (result)
1279 		netdev_err(vif->ndev, "Failed to get mac address\n");
1280 
1281 	return result;
1282 }
1283 
1284 int wilc_set_mac_address(struct wilc_vif *vif, u8 *mac_addr)
1285 {
1286 	struct wid wid;
1287 	int result;
1288 
1289 	wid.id = WID_MAC_ADDR;
1290 	wid.type = WID_STR;
1291 	wid.size = ETH_ALEN;
1292 	wid.val = mac_addr;
1293 
1294 	result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1);
1295 	if (result)
1296 		netdev_err(vif->ndev, "Failed to set mac address\n");
1297 
1298 	return result;
1299 }
1300 
1301 int wilc_set_join_req(struct wilc_vif *vif, u8 *bssid, const u8 *ies,
1302 		      size_t ies_len)
1303 {
1304 	int result;
1305 	struct host_if_drv *hif_drv = vif->hif_drv;
1306 	struct wilc_conn_info *conn_info = &hif_drv->conn_info;
1307 
1308 	if (bssid)
1309 		ether_addr_copy(conn_info->bssid, bssid);
1310 
1311 	if (ies) {
1312 		conn_info->req_ies_len = ies_len;
1313 		conn_info->req_ies = kmemdup(ies, ies_len, GFP_KERNEL);
1314 		if (!conn_info->req_ies)
1315 			return -ENOMEM;
1316 	}
1317 
1318 	result = wilc_send_connect_wid(vif);
1319 	if (result)
1320 		goto free_ies;
1321 
1322 	hif_drv->connect_timer_vif = vif;
1323 	mod_timer(&hif_drv->connect_timer,
1324 		  jiffies + msecs_to_jiffies(WILC_HIF_CONNECT_TIMEOUT_MS));
1325 
1326 	return 0;
1327 
1328 free_ies:
1329 	kfree(conn_info->req_ies);
1330 
1331 	return result;
1332 }
1333 
1334 int wilc_set_mac_chnl_num(struct wilc_vif *vif, u8 channel)
1335 {
1336 	struct wid wid;
1337 	int result;
1338 
1339 	wid.id = WID_CURRENT_CHANNEL;
1340 	wid.type = WID_CHAR;
1341 	wid.size = sizeof(char);
1342 	wid.val = &channel;
1343 
1344 	result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1);
1345 	if (result)
1346 		netdev_err(vif->ndev, "Failed to set channel\n");
1347 
1348 	return result;
1349 }
1350 
1351 int wilc_set_operation_mode(struct wilc_vif *vif, int index, u8 mode,
1352 			    u8 ifc_id)
1353 {
1354 	struct wid wid;
1355 	int result;
1356 	struct wilc_drv_handler drv;
1357 
1358 	wid.id = WID_SET_OPERATION_MODE;
1359 	wid.type = WID_STR;
1360 	wid.size = sizeof(drv);
1361 	wid.val = (u8 *)&drv;
1362 
1363 	drv.handler = cpu_to_le32(index);
1364 	drv.mode = (ifc_id | (mode << 1));
1365 
1366 	result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1);
1367 	if (result)
1368 		netdev_err(vif->ndev, "Failed to set driver handler\n");
1369 
1370 	return result;
1371 }
1372 
1373 s32 wilc_get_inactive_time(struct wilc_vif *vif, const u8 *mac, u32 *out_val)
1374 {
1375 	struct wid wid;
1376 	s32 result;
1377 
1378 	wid.id = WID_SET_STA_MAC_INACTIVE_TIME;
1379 	wid.type = WID_STR;
1380 	wid.size = ETH_ALEN;
1381 	wid.val = kzalloc(wid.size, GFP_KERNEL);
1382 	if (!wid.val)
1383 		return -ENOMEM;
1384 
1385 	ether_addr_copy(wid.val, mac);
1386 	result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1);
1387 	kfree(wid.val);
1388 	if (result) {
1389 		netdev_err(vif->ndev, "Failed to set inactive mac\n");
1390 		return result;
1391 	}
1392 
1393 	wid.id = WID_GET_INACTIVE_TIME;
1394 	wid.type = WID_INT;
1395 	wid.val = (s8 *)out_val;
1396 	wid.size = sizeof(u32);
1397 	result = wilc_send_config_pkt(vif, WILC_GET_CFG, &wid, 1);
1398 	if (result)
1399 		netdev_err(vif->ndev, "Failed to get inactive time\n");
1400 
1401 	return result;
1402 }
1403 
1404 int wilc_get_rssi(struct wilc_vif *vif, s8 *rssi_level)
1405 {
1406 	struct wid wid;
1407 	int result;
1408 
1409 	if (!rssi_level) {
1410 		netdev_err(vif->ndev, "%s: RSSI level is NULL\n", __func__);
1411 		return -EFAULT;
1412 	}
1413 
1414 	wid.id = WID_RSSI;
1415 	wid.type = WID_CHAR;
1416 	wid.size = sizeof(char);
1417 	wid.val = rssi_level;
1418 	result = wilc_send_config_pkt(vif, WILC_GET_CFG, &wid, 1);
1419 	if (result)
1420 		netdev_err(vif->ndev, "Failed to get RSSI value\n");
1421 
1422 	return result;
1423 }
1424 
1425 static int wilc_get_stats_async(struct wilc_vif *vif, struct rf_info *stats)
1426 {
1427 	int result;
1428 	struct host_if_msg *msg;
1429 
1430 	msg = wilc_alloc_work(vif, handle_get_statistics, false);
1431 	if (IS_ERR(msg))
1432 		return PTR_ERR(msg);
1433 
1434 	msg->body.data = (char *)stats;
1435 
1436 	result = wilc_enqueue_work(msg);
1437 	if (result) {
1438 		netdev_err(vif->ndev, "%s: enqueue work failed\n", __func__);
1439 		kfree(msg);
1440 		return result;
1441 	}
1442 
1443 	return result;
1444 }
1445 
1446 int wilc_hif_set_cfg(struct wilc_vif *vif, struct cfg_param_attr *param)
1447 {
1448 	struct wid wid_list[4];
1449 	int i = 0;
1450 
1451 	if (param->flag & WILC_CFG_PARAM_RETRY_SHORT) {
1452 		wid_list[i].id = WID_SHORT_RETRY_LIMIT;
1453 		wid_list[i].val = (s8 *)&param->short_retry_limit;
1454 		wid_list[i].type = WID_SHORT;
1455 		wid_list[i].size = sizeof(u16);
1456 		i++;
1457 	}
1458 	if (param->flag & WILC_CFG_PARAM_RETRY_LONG) {
1459 		wid_list[i].id = WID_LONG_RETRY_LIMIT;
1460 		wid_list[i].val = (s8 *)&param->long_retry_limit;
1461 		wid_list[i].type = WID_SHORT;
1462 		wid_list[i].size = sizeof(u16);
1463 		i++;
1464 	}
1465 	if (param->flag & WILC_CFG_PARAM_FRAG_THRESHOLD) {
1466 		wid_list[i].id = WID_FRAG_THRESHOLD;
1467 		wid_list[i].val = (s8 *)&param->frag_threshold;
1468 		wid_list[i].type = WID_SHORT;
1469 		wid_list[i].size = sizeof(u16);
1470 		i++;
1471 	}
1472 	if (param->flag & WILC_CFG_PARAM_RTS_THRESHOLD) {
1473 		wid_list[i].id = WID_RTS_THRESHOLD;
1474 		wid_list[i].val = (s8 *)&param->rts_threshold;
1475 		wid_list[i].type = WID_SHORT;
1476 		wid_list[i].size = sizeof(u16);
1477 		i++;
1478 	}
1479 
1480 	return wilc_send_config_pkt(vif, WILC_SET_CFG, wid_list, i);
1481 }
1482 
1483 static void get_periodic_rssi(struct timer_list *t)
1484 {
1485 	struct wilc_vif *vif = from_timer(vif, t, periodic_rssi);
1486 
1487 	if (!vif->hif_drv) {
1488 		netdev_err(vif->ndev, "%s: hif driver is NULL", __func__);
1489 		return;
1490 	}
1491 
1492 	if (vif->hif_drv->hif_state == HOST_IF_CONNECTED)
1493 		wilc_get_stats_async(vif, &vif->periodic_stat);
1494 
1495 	mod_timer(&vif->periodic_rssi, jiffies + msecs_to_jiffies(5000));
1496 }
1497 
1498 int wilc_init(struct net_device *dev, struct host_if_drv **hif_drv_handler)
1499 {
1500 	struct host_if_drv *hif_drv;
1501 	struct wilc_vif *vif = netdev_priv(dev);
1502 
1503 	hif_drv  = kzalloc(sizeof(*hif_drv), GFP_KERNEL);
1504 	if (!hif_drv)
1505 		return -ENOMEM;
1506 
1507 	*hif_drv_handler = hif_drv;
1508 
1509 	vif->hif_drv = hif_drv;
1510 
1511 	timer_setup(&vif->periodic_rssi, get_periodic_rssi, 0);
1512 	mod_timer(&vif->periodic_rssi, jiffies + msecs_to_jiffies(5000));
1513 
1514 	timer_setup(&hif_drv->scan_timer, timer_scan_cb, 0);
1515 	timer_setup(&hif_drv->connect_timer, timer_connect_cb, 0);
1516 	timer_setup(&hif_drv->remain_on_ch_timer, listen_timer_cb, 0);
1517 
1518 	hif_drv->hif_state = HOST_IF_IDLE;
1519 
1520 	hif_drv->p2p_timeout = 0;
1521 
1522 	return 0;
1523 }
1524 
1525 int wilc_deinit(struct wilc_vif *vif)
1526 {
1527 	int result = 0;
1528 	struct host_if_drv *hif_drv = vif->hif_drv;
1529 
1530 	if (!hif_drv) {
1531 		netdev_err(vif->ndev, "%s: hif driver is NULL", __func__);
1532 		return -EFAULT;
1533 	}
1534 
1535 	mutex_lock(&vif->wilc->deinit_lock);
1536 
1537 	timer_shutdown_sync(&hif_drv->scan_timer);
1538 	timer_shutdown_sync(&hif_drv->connect_timer);
1539 	del_timer_sync(&vif->periodic_rssi);
1540 	timer_shutdown_sync(&hif_drv->remain_on_ch_timer);
1541 
1542 	if (hif_drv->usr_scan_req.scan_result) {
1543 		hif_drv->usr_scan_req.scan_result(SCAN_EVENT_ABORTED, NULL,
1544 						  hif_drv->usr_scan_req.priv);
1545 		hif_drv->usr_scan_req.scan_result = NULL;
1546 	}
1547 
1548 	hif_drv->hif_state = HOST_IF_IDLE;
1549 
1550 	kfree(hif_drv);
1551 	vif->hif_drv = NULL;
1552 	mutex_unlock(&vif->wilc->deinit_lock);
1553 	return result;
1554 }
1555 
1556 void wilc_network_info_received(struct wilc *wilc, u8 *buffer, u32 length)
1557 {
1558 	int result;
1559 	struct host_if_msg *msg;
1560 	int id;
1561 	struct host_if_drv *hif_drv;
1562 	struct wilc_vif *vif;
1563 
1564 	id = get_unaligned_le32(&buffer[length - 4]);
1565 	vif = wilc_get_vif_from_idx(wilc, id);
1566 	if (!vif)
1567 		return;
1568 	hif_drv = vif->hif_drv;
1569 
1570 	if (!hif_drv) {
1571 		netdev_err(vif->ndev, "driver not init[%p]\n", hif_drv);
1572 		return;
1573 	}
1574 
1575 	msg = wilc_alloc_work(vif, handle_rcvd_ntwrk_info, false);
1576 	if (IS_ERR(msg))
1577 		return;
1578 
1579 	msg->body.net_info.frame_len = get_unaligned_le16(&buffer[6]) - 1;
1580 	msg->body.net_info.rssi = buffer[8];
1581 	msg->body.net_info.mgmt = kmemdup(&buffer[9],
1582 					  msg->body.net_info.frame_len,
1583 					  GFP_KERNEL);
1584 	if (!msg->body.net_info.mgmt) {
1585 		kfree(msg);
1586 		return;
1587 	}
1588 
1589 	result = wilc_enqueue_work(msg);
1590 	if (result) {
1591 		netdev_err(vif->ndev, "%s: enqueue work failed\n", __func__);
1592 		kfree(msg->body.net_info.mgmt);
1593 		kfree(msg);
1594 	}
1595 }
1596 
1597 void wilc_gnrl_async_info_received(struct wilc *wilc, u8 *buffer, u32 length)
1598 {
1599 	int result;
1600 	struct host_if_msg *msg;
1601 	int id;
1602 	struct host_if_drv *hif_drv;
1603 	struct wilc_vif *vif;
1604 
1605 	mutex_lock(&wilc->deinit_lock);
1606 
1607 	id = get_unaligned_le32(&buffer[length - 4]);
1608 	vif = wilc_get_vif_from_idx(wilc, id);
1609 	if (!vif) {
1610 		mutex_unlock(&wilc->deinit_lock);
1611 		return;
1612 	}
1613 
1614 	hif_drv = vif->hif_drv;
1615 
1616 	if (!hif_drv) {
1617 		mutex_unlock(&wilc->deinit_lock);
1618 		return;
1619 	}
1620 
1621 	if (!hif_drv->conn_info.conn_result) {
1622 		netdev_err(vif->ndev, "%s: conn_result is NULL\n", __func__);
1623 		mutex_unlock(&wilc->deinit_lock);
1624 		return;
1625 	}
1626 
1627 	msg = wilc_alloc_work(vif, handle_rcvd_gnrl_async_info, false);
1628 	if (IS_ERR(msg)) {
1629 		mutex_unlock(&wilc->deinit_lock);
1630 		return;
1631 	}
1632 
1633 	msg->body.mac_info.status = buffer[7];
1634 	result = wilc_enqueue_work(msg);
1635 	if (result) {
1636 		netdev_err(vif->ndev, "%s: enqueue work failed\n", __func__);
1637 		kfree(msg);
1638 	}
1639 
1640 	mutex_unlock(&wilc->deinit_lock);
1641 }
1642 
1643 void wilc_scan_complete_received(struct wilc *wilc, u8 *buffer, u32 length)
1644 {
1645 	int result;
1646 	int id;
1647 	struct host_if_drv *hif_drv;
1648 	struct wilc_vif *vif;
1649 
1650 	id = get_unaligned_le32(&buffer[length - 4]);
1651 	vif = wilc_get_vif_from_idx(wilc, id);
1652 	if (!vif)
1653 		return;
1654 	hif_drv = vif->hif_drv;
1655 
1656 	if (!hif_drv)
1657 		return;
1658 
1659 	if (hif_drv->usr_scan_req.scan_result) {
1660 		struct host_if_msg *msg;
1661 
1662 		msg = wilc_alloc_work(vif, handle_scan_complete, false);
1663 		if (IS_ERR(msg))
1664 			return;
1665 
1666 		result = wilc_enqueue_work(msg);
1667 		if (result) {
1668 			netdev_err(vif->ndev, "%s: enqueue work failed\n",
1669 				   __func__);
1670 			kfree(msg);
1671 		}
1672 	}
1673 }
1674 
1675 int wilc_remain_on_channel(struct wilc_vif *vif, u64 cookie, u16 chan,
1676 			   void (*expired)(struct wilc_vif *, u64))
1677 {
1678 	struct wilc_remain_ch roc;
1679 	int result;
1680 
1681 	roc.ch = chan;
1682 	roc.expired = expired;
1683 	roc.vif = vif;
1684 	roc.cookie = cookie;
1685 	result = handle_remain_on_chan(vif, &roc);
1686 	if (result)
1687 		netdev_err(vif->ndev, "%s: failed to set remain on channel\n",
1688 			   __func__);
1689 
1690 	return result;
1691 }
1692 
1693 int wilc_listen_state_expired(struct wilc_vif *vif, u64 cookie)
1694 {
1695 	if (!vif->hif_drv) {
1696 		netdev_err(vif->ndev, "%s: hif driver is NULL", __func__);
1697 		return -EFAULT;
1698 	}
1699 
1700 	del_timer(&vif->hif_drv->remain_on_ch_timer);
1701 
1702 	return wilc_handle_roc_expired(vif, cookie);
1703 }
1704 
1705 void wilc_frame_register(struct wilc_vif *vif, u16 frame_type, bool reg)
1706 {
1707 	struct wid wid;
1708 	int result;
1709 	struct wilc_reg_frame reg_frame;
1710 
1711 	wid.id = WID_REGISTER_FRAME;
1712 	wid.type = WID_STR;
1713 	wid.size = sizeof(reg_frame);
1714 	wid.val = (u8 *)&reg_frame;
1715 
1716 	memset(&reg_frame, 0x0, sizeof(reg_frame));
1717 
1718 	if (reg)
1719 		reg_frame.reg = 1;
1720 
1721 	switch (frame_type) {
1722 	case IEEE80211_STYPE_ACTION:
1723 		reg_frame.reg_id = WILC_FW_ACTION_FRM_IDX;
1724 		break;
1725 
1726 	case IEEE80211_STYPE_PROBE_REQ:
1727 		reg_frame.reg_id = WILC_FW_PROBE_REQ_IDX;
1728 		break;
1729 
1730         case IEEE80211_STYPE_AUTH:
1731                 reg_frame.reg_id = WILC_FW_AUTH_REQ_IDX;
1732                 break;
1733 
1734 	default:
1735 		break;
1736 	}
1737 	reg_frame.frame_type = cpu_to_le16(frame_type);
1738 	result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1);
1739 	if (result)
1740 		netdev_err(vif->ndev, "Failed to frame register\n");
1741 }
1742 
1743 int wilc_add_beacon(struct wilc_vif *vif, u32 interval, u32 dtim_period,
1744 		    struct cfg80211_beacon_data *params)
1745 {
1746 	struct wid wid;
1747 	int result;
1748 	u8 *cur_byte;
1749 
1750 	wid.id = WID_ADD_BEACON;
1751 	wid.type = WID_BIN;
1752 	wid.size = params->head_len + params->tail_len + 16;
1753 	wid.val = kzalloc(wid.size, GFP_KERNEL);
1754 	if (!wid.val)
1755 		return -ENOMEM;
1756 
1757 	cur_byte = wid.val;
1758 	put_unaligned_le32(interval, cur_byte);
1759 	cur_byte += 4;
1760 	put_unaligned_le32(dtim_period, cur_byte);
1761 	cur_byte += 4;
1762 	put_unaligned_le32(params->head_len, cur_byte);
1763 	cur_byte += 4;
1764 
1765 	if (params->head_len > 0)
1766 		memcpy(cur_byte, params->head, params->head_len);
1767 	cur_byte += params->head_len;
1768 
1769 	put_unaligned_le32(params->tail_len, cur_byte);
1770 	cur_byte += 4;
1771 
1772 	if (params->tail_len > 0)
1773 		memcpy(cur_byte, params->tail, params->tail_len);
1774 
1775 	result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1);
1776 	if (result)
1777 		netdev_err(vif->ndev, "Failed to send add beacon\n");
1778 
1779 	kfree(wid.val);
1780 
1781 	return result;
1782 }
1783 
1784 int wilc_del_beacon(struct wilc_vif *vif)
1785 {
1786 	int result;
1787 	struct wid wid;
1788 	u8 del_beacon = 0;
1789 
1790 	wid.id = WID_DEL_BEACON;
1791 	wid.type = WID_CHAR;
1792 	wid.size = sizeof(char);
1793 	wid.val = &del_beacon;
1794 
1795 	result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1);
1796 	if (result)
1797 		netdev_err(vif->ndev, "Failed to send delete beacon\n");
1798 
1799 	return result;
1800 }
1801 
1802 int wilc_add_station(struct wilc_vif *vif, const u8 *mac,
1803 		     struct station_parameters *params)
1804 {
1805 	struct wid wid;
1806 	int result;
1807 	u8 *cur_byte;
1808 
1809 	wid.id = WID_ADD_STA;
1810 	wid.type = WID_BIN;
1811 	wid.size = WILC_ADD_STA_LENGTH +
1812 		   params->link_sta_params.supported_rates_len;
1813 	wid.val = kmalloc(wid.size, GFP_KERNEL);
1814 	if (!wid.val)
1815 		return -ENOMEM;
1816 
1817 	cur_byte = wid.val;
1818 	wilc_hif_pack_sta_param(cur_byte, mac, params);
1819 
1820 	result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1);
1821 	if (result != 0)
1822 		netdev_err(vif->ndev, "Failed to send add station\n");
1823 
1824 	kfree(wid.val);
1825 
1826 	return result;
1827 }
1828 
1829 int wilc_del_station(struct wilc_vif *vif, const u8 *mac_addr)
1830 {
1831 	struct wid wid;
1832 	int result;
1833 
1834 	wid.id = WID_REMOVE_STA;
1835 	wid.type = WID_BIN;
1836 	wid.size = ETH_ALEN;
1837 	wid.val = kzalloc(wid.size, GFP_KERNEL);
1838 	if (!wid.val)
1839 		return -ENOMEM;
1840 
1841 	if (!mac_addr)
1842 		eth_broadcast_addr(wid.val);
1843 	else
1844 		ether_addr_copy(wid.val, mac_addr);
1845 
1846 	result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1);
1847 	if (result)
1848 		netdev_err(vif->ndev, "Failed to del station\n");
1849 
1850 	kfree(wid.val);
1851 
1852 	return result;
1853 }
1854 
1855 int wilc_del_allstation(struct wilc_vif *vif, u8 mac_addr[][ETH_ALEN])
1856 {
1857 	struct wid wid;
1858 	int result;
1859 	int i;
1860 	u8 assoc_sta = 0;
1861 	struct wilc_del_all_sta del_sta;
1862 
1863 	memset(&del_sta, 0x0, sizeof(del_sta));
1864 	for (i = 0; i < WILC_MAX_NUM_STA; i++) {
1865 		if (!is_zero_ether_addr(mac_addr[i])) {
1866 			assoc_sta++;
1867 			ether_addr_copy(del_sta.mac[i], mac_addr[i]);
1868 		}
1869 	}
1870 
1871 	if (!assoc_sta)
1872 		return 0;
1873 
1874 	del_sta.assoc_sta = assoc_sta;
1875 
1876 	wid.id = WID_DEL_ALL_STA;
1877 	wid.type = WID_STR;
1878 	wid.size = (assoc_sta * ETH_ALEN) + 1;
1879 	wid.val = (u8 *)&del_sta;
1880 
1881 	result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1);
1882 	if (result)
1883 		netdev_err(vif->ndev, "Failed to send delete all station\n");
1884 
1885 	return result;
1886 }
1887 
1888 int wilc_edit_station(struct wilc_vif *vif, const u8 *mac,
1889 		      struct station_parameters *params)
1890 {
1891 	struct wid wid;
1892 	int result;
1893 	u8 *cur_byte;
1894 
1895 	wid.id = WID_EDIT_STA;
1896 	wid.type = WID_BIN;
1897 	wid.size = WILC_ADD_STA_LENGTH +
1898 		   params->link_sta_params.supported_rates_len;
1899 	wid.val = kmalloc(wid.size, GFP_KERNEL);
1900 	if (!wid.val)
1901 		return -ENOMEM;
1902 
1903 	cur_byte = wid.val;
1904 	wilc_hif_pack_sta_param(cur_byte, mac, params);
1905 
1906 	result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1);
1907 	if (result)
1908 		netdev_err(vif->ndev, "Failed to send edit station\n");
1909 
1910 	kfree(wid.val);
1911 	return result;
1912 }
1913 
1914 int wilc_set_power_mgmt(struct wilc_vif *vif, bool enabled, u32 timeout)
1915 {
1916 	struct wilc *wilc = vif->wilc;
1917 	struct wid wid;
1918 	int result;
1919 	s8 power_mode;
1920 
1921 	if (enabled)
1922 		power_mode = WILC_FW_MIN_FAST_PS;
1923 	else
1924 		power_mode = WILC_FW_NO_POWERSAVE;
1925 
1926 	wid.id = WID_POWER_MANAGEMENT;
1927 	wid.val = &power_mode;
1928 	wid.size = sizeof(char);
1929 	result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1);
1930 	if (result)
1931 		netdev_err(vif->ndev, "Failed to send power management\n");
1932 	else
1933 		wilc->power_save_mode = enabled;
1934 
1935 	return result;
1936 }
1937 
1938 int wilc_setup_multicast_filter(struct wilc_vif *vif, u32 enabled, u32 count,
1939 				u8 *mc_list)
1940 {
1941 	int result;
1942 	struct host_if_msg *msg;
1943 
1944 	msg = wilc_alloc_work(vif, handle_set_mcast_filter, false);
1945 	if (IS_ERR(msg))
1946 		return PTR_ERR(msg);
1947 
1948 	msg->body.mc_info.enabled = enabled;
1949 	msg->body.mc_info.cnt = count;
1950 	msg->body.mc_info.mc_list = mc_list;
1951 
1952 	result = wilc_enqueue_work(msg);
1953 	if (result) {
1954 		netdev_err(vif->ndev, "%s: enqueue work failed\n", __func__);
1955 		kfree(msg);
1956 	}
1957 	return result;
1958 }
1959 
1960 int wilc_set_tx_power(struct wilc_vif *vif, u8 tx_power)
1961 {
1962 	struct wid wid;
1963 
1964 	wid.id = WID_TX_POWER;
1965 	wid.type = WID_CHAR;
1966 	wid.val = &tx_power;
1967 	wid.size = sizeof(char);
1968 
1969 	return wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1);
1970 }
1971 
1972 int wilc_get_tx_power(struct wilc_vif *vif, u8 *tx_power)
1973 {
1974 	struct wid wid;
1975 
1976 	wid.id = WID_TX_POWER;
1977 	wid.type = WID_CHAR;
1978 	wid.val = tx_power;
1979 	wid.size = sizeof(char);
1980 
1981 	return wilc_send_config_pkt(vif, WILC_GET_CFG, &wid, 1);
1982 }
1983 
1984 int wilc_set_default_mgmt_key_index(struct wilc_vif *vif, u8 index)
1985 {
1986         struct wid wid;
1987         int result;
1988 
1989         wid.id = WID_DEFAULT_MGMT_KEY_ID;
1990         wid.type = WID_CHAR;
1991         wid.size = sizeof(char);
1992         wid.val = &index;
1993         result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1);
1994         if (result)
1995                 netdev_err(vif->ndev,
1996                            "Failed to send default mgmt key index\n");
1997 
1998         return result;
1999 }
2000