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