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*
wilc_alloc_work(struct wilc_vif * vif,void (* work_fun)(struct work_struct *),bool is_sync)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
wilc_enqueue_work(struct host_if_msg * msg)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 */
wilc_get_vif_idx(struct wilc_vif * vif)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 */
wilc_get_vif_from_idx(struct wilc * wilc,int idx)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
handle_scan_done(struct wilc_vif * vif,enum scan_event evt)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
wilc_scan(struct wilc_vif * vif,u8 scan_source,u8 scan_type,u8 * ch_freq_list,void (* scan_result_fn)(enum scan_event,struct wilc_rcvd_net_info *,struct wilc_priv *),struct cfg80211_scan_request * request)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
wilc_send_connect_wid(struct wilc_vif * vif)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
handle_connect_timeout(struct work_struct * work)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 *
wilc_parse_join_bss_param(struct cfg80211_bss * bss,struct cfg80211_crypto_settings * crypto)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(¶m->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(¶m->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
handle_rcvd_ntwrk_info(struct work_struct * work)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
host_int_get_assoc_res_info(struct wilc_vif * vif,u8 * assoc_resp_info,u32 max_assoc_resp_info_len,u32 * rcvd_assoc_resp_info_len)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
wilc_parse_assoc_resp_info(u8 * buffer,u32 buffer_len,struct wilc_conn_info * ret_conn_info)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
host_int_parse_assoc_resp_info(struct wilc_vif * vif,u8 mac_status)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
wilc_handle_disconnect(struct wilc_vif * vif)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
handle_rcvd_gnrl_async_info(struct work_struct * work)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
wilc_disconnect(struct wilc_vif * vif)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
wilc_get_statistics(struct wilc_vif * vif,struct rf_info * stats)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
handle_get_statistics(struct work_struct * work)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
wilc_hif_pack_sta_param(u8 * cur_byte,const u8 * mac,struct station_parameters * params)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
handle_remain_on_chan(struct wilc_vif * vif,struct wilc_remain_ch * hif_remain_ch)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
wilc_handle_roc_expired(struct wilc_vif * vif,u64 cookie)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
wilc_handle_listen_state_expired(struct work_struct * work)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
listen_timer_cb(struct timer_list * t)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
handle_set_mcast_filter(struct work_struct * work)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
wilc_set_wowlan_trigger(struct wilc_vif * vif,bool enabled)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
wilc_set_external_auth_param(struct wilc_vif * vif,struct cfg80211_external_auth_params * auth)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
handle_scan_timer(struct work_struct * work)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
handle_scan_complete(struct work_struct * work)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
timer_scan_cb(struct timer_list * t)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
timer_connect_cb(struct timer_list * t)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
wilc_add_ptk(struct wilc_vif * vif,const u8 * ptk,u8 ptk_key_len,const u8 * mac_addr,const u8 * rx_mic,const u8 * tx_mic,u8 mode,u8 cipher_mode,u8 index)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
wilc_add_igtk(struct wilc_vif * vif,const u8 * igtk,u8 igtk_key_len,const u8 * pn,u8 pn_len,const u8 * mac_addr,u8 mode,u8 index)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
wilc_add_rx_gtk(struct wilc_vif * vif,const u8 * rx_gtk,u8 gtk_key_len,u8 index,u32 key_rsc_len,const u8 * key_rsc,const u8 * rx_mic,const u8 * tx_mic,u8 mode,u8 cipher_mode)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(>k_key->key[0], rx_gtk, gtk_key_len);
1218
1219 if (rx_mic)
1220 memcpy(>k_key->key[gtk_key_len], rx_mic, WILC_RX_MIC_KEY_LEN);
1221
1222 if (tx_mic)
1223 memcpy(>k_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
wilc_set_pmkid_info(struct wilc_vif * vif,struct wilc_pmkid_attr * pmkid)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
wilc_get_mac_address(struct wilc_vif * vif,u8 * mac_addr)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
wilc_set_mac_address(struct wilc_vif * vif,u8 * mac_addr)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
wilc_set_join_req(struct wilc_vif * vif,u8 * bssid,const u8 * ies,size_t ies_len)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
wilc_set_mac_chnl_num(struct wilc_vif * vif,u8 channel)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
wilc_set_operation_mode(struct wilc_vif * vif,int index,u8 mode,u8 ifc_id)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
wilc_get_inactive_time(struct wilc_vif * vif,const u8 * mac,u32 * out_val)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
wilc_get_rssi(struct wilc_vif * vif,s8 * rssi_level)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
wilc_get_stats_async(struct wilc_vif * vif,struct rf_info * stats)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
wilc_hif_set_cfg(struct wilc_vif * vif,struct cfg_param_attr * param)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 *)¶m->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 *)¶m->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 *)¶m->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 *)¶m->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
get_periodic_rssi(struct timer_list * t)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
wilc_init(struct net_device * dev,struct host_if_drv ** hif_drv_handler)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
wilc_deinit(struct wilc_vif * vif)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
wilc_network_info_received(struct wilc * wilc,u8 * buffer,u32 length)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
wilc_gnrl_async_info_received(struct wilc * wilc,u8 * buffer,u32 length)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
wilc_scan_complete_received(struct wilc * wilc,u8 * buffer,u32 length)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
wilc_remain_on_channel(struct wilc_vif * vif,u64 cookie,u16 chan,void (* expired)(struct wilc_vif *,u64))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
wilc_listen_state_expired(struct wilc_vif * vif,u64 cookie)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
wilc_frame_register(struct wilc_vif * vif,u16 frame_type,bool reg)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 *)®_frame;
1715
1716 memset(®_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
wilc_add_beacon(struct wilc_vif * vif,u32 interval,u32 dtim_period,struct cfg80211_beacon_data * params)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
wilc_del_beacon(struct wilc_vif * vif)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
wilc_add_station(struct wilc_vif * vif,const u8 * mac,struct station_parameters * params)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
wilc_del_station(struct wilc_vif * vif,const u8 * mac_addr)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
wilc_del_allstation(struct wilc_vif * vif,u8 mac_addr[][ETH_ALEN])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
wilc_edit_station(struct wilc_vif * vif,const u8 * mac,struct station_parameters * params)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
wilc_set_power_mgmt(struct wilc_vif * vif,bool enabled,u32 timeout)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
wilc_setup_multicast_filter(struct wilc_vif * vif,u32 enabled,u32 count,u8 * mc_list)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
wilc_set_tx_power(struct wilc_vif * vif,u8 tx_power)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
wilc_get_tx_power(struct wilc_vif * vif,u8 * tx_power)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
wilc_set_default_mgmt_key_index(struct wilc_vif * vif,u8 index)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