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