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