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