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 e = (struct wilc_attr_entry *)&buf[index]; 963 if (e->attr_type == IEEE80211_P2P_ATTR_CHANNEL_LIST) 964 ch_list_idx = index; 965 else if (e->attr_type == IEEE80211_P2P_ATTR_OPER_CHANNEL) 966 op_ch_idx = index; 967 if (ch_list_idx && op_ch_idx) 968 break; 969 index += le16_to_cpu(e->attr_len) + sizeof(*e); 970 } 971 972 if (ch_list_idx) { 973 u16 attr_size; 974 struct wilc_ch_list_elem *e; 975 int i; 976 977 ch_list = (struct wilc_attr_ch_list *)&buf[ch_list_idx]; 978 attr_size = le16_to_cpu(ch_list->attr_len); 979 for (i = 0; i < attr_size;) { 980 e = (struct wilc_ch_list_elem *)(ch_list->elem + i); 981 if (e->op_class == WILC_WLAN_OPERATING_CLASS_2_4GHZ) { 982 memset(e->ch_list, sta_ch, e->no_of_channels); 983 break; 984 } 985 i += e->no_of_channels; 986 } 987 } 988 989 if (op_ch_idx) { 990 op_ch = (struct wilc_attr_oper_ch *)&buf[op_ch_idx]; 991 op_ch->op_class = WILC_WLAN_OPERATING_CLASS_2_4GHZ; 992 op_ch->op_channel = sta_ch; 993 } 994 } 995 996 bool wilc_wfi_mgmt_frame_rx(struct wilc_vif *vif, u8 *buff, u32 size) 997 { 998 struct wilc *wl = vif->wilc; 999 struct wilc_priv *priv = &vif->priv; 1000 int freq, ret; 1001 1002 freq = ieee80211_channel_to_frequency(wl->op_ch, NL80211_BAND_2GHZ); 1003 ret = cfg80211_rx_mgmt(&priv->wdev, freq, 0, buff, size, 0); 1004 1005 return ret; 1006 } 1007 1008 void wilc_wfi_p2p_rx(struct wilc_vif *vif, u8 *buff, u32 size) 1009 { 1010 struct wilc *wl = vif->wilc; 1011 struct wilc_priv *priv = &vif->priv; 1012 struct host_if_drv *wfi_drv = priv->hif_drv; 1013 struct ieee80211_mgmt *mgmt; 1014 struct wilc_vendor_specific_ie *p; 1015 struct wilc_p2p_pub_act_frame *d; 1016 int ie_offset = offsetof(struct ieee80211_mgmt, u) + sizeof(*d); 1017 const u8 *vendor_ie; 1018 u32 header, pkt_offset; 1019 s32 freq; 1020 1021 header = get_unaligned_le32(buff - HOST_HDR_OFFSET); 1022 pkt_offset = FIELD_GET(WILC_PKT_HDR_OFFSET_FIELD, header); 1023 1024 if (pkt_offset & IS_MANAGMEMENT_CALLBACK) { 1025 bool ack = false; 1026 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)buff; 1027 1028 if (ieee80211_is_probe_resp(hdr->frame_control) || 1029 pkt_offset & IS_MGMT_STATUS_SUCCES) 1030 ack = true; 1031 1032 cfg80211_mgmt_tx_status(&priv->wdev, priv->tx_cookie, buff, 1033 size, ack, GFP_KERNEL); 1034 return; 1035 } 1036 1037 freq = ieee80211_channel_to_frequency(wl->op_ch, NL80211_BAND_2GHZ); 1038 1039 mgmt = (struct ieee80211_mgmt *)buff; 1040 if (!ieee80211_is_action(mgmt->frame_control)) 1041 goto out_rx_mgmt; 1042 1043 if (priv->cfg_scanning && 1044 time_after_eq(jiffies, (unsigned long)wfi_drv->p2p_timeout)) { 1045 netdev_dbg(vif->ndev, "Receiving action wrong ch\n"); 1046 return; 1047 } 1048 1049 if (!ieee80211_is_public_action((struct ieee80211_hdr *)buff, size)) 1050 goto out_rx_mgmt; 1051 1052 d = (struct wilc_p2p_pub_act_frame *)(&mgmt->u.action); 1053 if (d->oui_subtype != GO_NEG_REQ && d->oui_subtype != GO_NEG_RSP && 1054 d->oui_subtype != P2P_INV_REQ && d->oui_subtype != P2P_INV_RSP) 1055 goto out_rx_mgmt; 1056 1057 vendor_ie = cfg80211_find_vendor_ie(WLAN_OUI_WFA, WLAN_OUI_TYPE_WFA_P2P, 1058 buff + ie_offset, size - ie_offset); 1059 if (!vendor_ie) 1060 goto out_rx_mgmt; 1061 1062 p = (struct wilc_vendor_specific_ie *)vendor_ie; 1063 wilc_wfi_cfg_parse_ch_attr(p->attr, p->tag_len - 4, vif->wilc->sta_ch); 1064 1065 out_rx_mgmt: 1066 cfg80211_rx_mgmt(&priv->wdev, freq, 0, buff, size, 0); 1067 } 1068 1069 static void wilc_wfi_mgmt_tx_complete(void *priv, int status) 1070 { 1071 struct wilc_p2p_mgmt_data *pv_data = priv; 1072 1073 kfree(pv_data->buff); 1074 kfree(pv_data); 1075 } 1076 1077 static void wilc_wfi_remain_on_channel_expired(void *data, u64 cookie) 1078 { 1079 struct wilc_vif *vif = data; 1080 struct wilc_priv *priv = &vif->priv; 1081 struct wilc_wfi_p2p_listen_params *params = &priv->remain_on_ch_params; 1082 1083 if (cookie != params->listen_cookie) 1084 return; 1085 1086 priv->p2p_listen_state = false; 1087 1088 cfg80211_remain_on_channel_expired(&priv->wdev, params->listen_cookie, 1089 params->listen_ch, GFP_KERNEL); 1090 } 1091 1092 static int remain_on_channel(struct wiphy *wiphy, 1093 struct wireless_dev *wdev, 1094 struct ieee80211_channel *chan, 1095 unsigned int duration, u64 *cookie) 1096 { 1097 int ret = 0; 1098 struct wilc_vif *vif = netdev_priv(wdev->netdev); 1099 struct wilc_priv *priv = &vif->priv; 1100 u64 id; 1101 1102 if (wdev->iftype == NL80211_IFTYPE_AP) { 1103 netdev_dbg(vif->ndev, "Required while in AP mode\n"); 1104 return ret; 1105 } 1106 1107 id = ++priv->inc_roc_cookie; 1108 if (id == 0) 1109 id = ++priv->inc_roc_cookie; 1110 1111 ret = wilc_remain_on_channel(vif, id, duration, chan->hw_value, 1112 wilc_wfi_remain_on_channel_expired, 1113 (void *)vif); 1114 if (ret) 1115 return ret; 1116 1117 vif->wilc->op_ch = chan->hw_value; 1118 1119 priv->remain_on_ch_params.listen_ch = chan; 1120 priv->remain_on_ch_params.listen_cookie = id; 1121 *cookie = id; 1122 priv->p2p_listen_state = true; 1123 priv->remain_on_ch_params.listen_duration = duration; 1124 1125 cfg80211_ready_on_channel(wdev, *cookie, chan, duration, GFP_KERNEL); 1126 mod_timer(&vif->hif_drv->remain_on_ch_timer, 1127 jiffies + msecs_to_jiffies(duration + 1000)); 1128 1129 return ret; 1130 } 1131 1132 static int cancel_remain_on_channel(struct wiphy *wiphy, 1133 struct wireless_dev *wdev, 1134 u64 cookie) 1135 { 1136 struct wilc_vif *vif = netdev_priv(wdev->netdev); 1137 struct wilc_priv *priv = &vif->priv; 1138 1139 if (cookie != priv->remain_on_ch_params.listen_cookie) 1140 return -ENOENT; 1141 1142 return wilc_listen_state_expired(vif, cookie); 1143 } 1144 1145 static int mgmt_tx(struct wiphy *wiphy, 1146 struct wireless_dev *wdev, 1147 struct cfg80211_mgmt_tx_params *params, 1148 u64 *cookie) 1149 { 1150 struct ieee80211_channel *chan = params->chan; 1151 unsigned int wait = params->wait; 1152 const u8 *buf = params->buf; 1153 size_t len = params->len; 1154 const struct ieee80211_mgmt *mgmt; 1155 struct wilc_p2p_mgmt_data *mgmt_tx; 1156 struct wilc_vif *vif = netdev_priv(wdev->netdev); 1157 struct wilc_priv *priv = &vif->priv; 1158 struct host_if_drv *wfi_drv = priv->hif_drv; 1159 struct wilc_vendor_specific_ie *p; 1160 struct wilc_p2p_pub_act_frame *d; 1161 int ie_offset = offsetof(struct ieee80211_mgmt, u) + sizeof(*d); 1162 const u8 *vendor_ie; 1163 int ret = 0; 1164 1165 *cookie = prandom_u32(); 1166 priv->tx_cookie = *cookie; 1167 mgmt = (const struct ieee80211_mgmt *)buf; 1168 1169 if (!ieee80211_is_mgmt(mgmt->frame_control)) 1170 goto out; 1171 1172 mgmt_tx = kmalloc(sizeof(*mgmt_tx), GFP_KERNEL); 1173 if (!mgmt_tx) { 1174 ret = -ENOMEM; 1175 goto out; 1176 } 1177 1178 mgmt_tx->buff = kmemdup(buf, len, GFP_KERNEL); 1179 if (!mgmt_tx->buff) { 1180 ret = -ENOMEM; 1181 kfree(mgmt_tx); 1182 goto out; 1183 } 1184 1185 mgmt_tx->size = len; 1186 1187 if (ieee80211_is_probe_resp(mgmt->frame_control)) { 1188 wilc_set_mac_chnl_num(vif, chan->hw_value); 1189 vif->wilc->op_ch = chan->hw_value; 1190 goto out_txq_add_pkt; 1191 } 1192 1193 if (!ieee80211_is_public_action((struct ieee80211_hdr *)buf, len)) { 1194 if (chan) 1195 wilc_set_mac_chnl_num(vif, chan->hw_value); 1196 else 1197 wilc_set_mac_chnl_num(vif, vif->wilc->op_ch); 1198 1199 goto out_set_timeout; 1200 } 1201 1202 d = (struct wilc_p2p_pub_act_frame *)(&mgmt->u.action); 1203 if (d->oui_type != WLAN_OUI_TYPE_WFA_P2P || 1204 d->oui_subtype != GO_NEG_CONF) { 1205 wilc_set_mac_chnl_num(vif, chan->hw_value); 1206 vif->wilc->op_ch = chan->hw_value; 1207 } 1208 1209 if (d->oui_subtype != P2P_INV_REQ && d->oui_subtype != P2P_INV_RSP) 1210 goto out_set_timeout; 1211 1212 vendor_ie = cfg80211_find_vendor_ie(WLAN_OUI_WFA, WLAN_OUI_TYPE_WFA_P2P, 1213 mgmt_tx->buff + ie_offset, 1214 len - ie_offset); 1215 if (!vendor_ie) 1216 goto out_set_timeout; 1217 1218 p = (struct wilc_vendor_specific_ie *)vendor_ie; 1219 wilc_wfi_cfg_parse_ch_attr(p->attr, p->tag_len - 4, vif->wilc->sta_ch); 1220 1221 out_set_timeout: 1222 wfi_drv->p2p_timeout = (jiffies + msecs_to_jiffies(wait)); 1223 1224 out_txq_add_pkt: 1225 1226 wilc_wlan_txq_add_mgmt_pkt(wdev->netdev, mgmt_tx, 1227 mgmt_tx->buff, mgmt_tx->size, 1228 wilc_wfi_mgmt_tx_complete); 1229 1230 out: 1231 1232 return ret; 1233 } 1234 1235 static int mgmt_tx_cancel_wait(struct wiphy *wiphy, 1236 struct wireless_dev *wdev, 1237 u64 cookie) 1238 { 1239 struct wilc_vif *vif = netdev_priv(wdev->netdev); 1240 struct wilc_priv *priv = &vif->priv; 1241 struct host_if_drv *wfi_drv = priv->hif_drv; 1242 1243 wfi_drv->p2p_timeout = jiffies; 1244 1245 if (!priv->p2p_listen_state) { 1246 struct wilc_wfi_p2p_listen_params *params; 1247 1248 params = &priv->remain_on_ch_params; 1249 1250 cfg80211_remain_on_channel_expired(wdev, 1251 params->listen_cookie, 1252 params->listen_ch, 1253 GFP_KERNEL); 1254 } 1255 1256 return 0; 1257 } 1258 1259 void wilc_update_mgmt_frame_registrations(struct wiphy *wiphy, 1260 struct wireless_dev *wdev, 1261 struct mgmt_frame_regs *upd) 1262 { 1263 struct wilc *wl = wiphy_priv(wiphy); 1264 struct wilc_vif *vif = netdev_priv(wdev->netdev); 1265 u32 presp_bit = BIT(IEEE80211_STYPE_PROBE_REQ >> 4); 1266 u32 action_bit = BIT(IEEE80211_STYPE_ACTION >> 4); 1267 u32 pauth_bit = BIT(IEEE80211_STYPE_AUTH >> 4); 1268 1269 if (wl->initialized) { 1270 bool prev = vif->mgmt_reg_stypes & presp_bit; 1271 bool now = upd->interface_stypes & presp_bit; 1272 1273 if (now != prev) 1274 wilc_frame_register(vif, IEEE80211_STYPE_PROBE_REQ, now); 1275 1276 prev = vif->mgmt_reg_stypes & action_bit; 1277 now = upd->interface_stypes & action_bit; 1278 1279 if (now != prev) 1280 wilc_frame_register(vif, IEEE80211_STYPE_ACTION, now); 1281 1282 prev = vif->mgmt_reg_stypes & pauth_bit; 1283 now = upd->interface_stypes & pauth_bit; 1284 if (now != prev) 1285 wilc_frame_register(vif, IEEE80211_STYPE_AUTH, now); 1286 } 1287 1288 vif->mgmt_reg_stypes = 1289 upd->interface_stypes & (presp_bit | action_bit | pauth_bit); 1290 } 1291 1292 static int external_auth(struct wiphy *wiphy, struct net_device *dev, 1293 struct cfg80211_external_auth_params *auth) 1294 { 1295 struct wilc_vif *vif = netdev_priv(dev); 1296 1297 if (auth->status == WLAN_STATUS_SUCCESS) 1298 wilc_set_external_auth_param(vif, auth); 1299 1300 return 0; 1301 } 1302 1303 static int set_cqm_rssi_config(struct wiphy *wiphy, struct net_device *dev, 1304 s32 rssi_thold, u32 rssi_hyst) 1305 { 1306 return 0; 1307 } 1308 1309 static int dump_station(struct wiphy *wiphy, struct net_device *dev, 1310 int idx, u8 *mac, struct station_info *sinfo) 1311 { 1312 struct wilc_vif *vif = netdev_priv(dev); 1313 int ret; 1314 1315 if (idx != 0) 1316 return -ENOENT; 1317 1318 ret = wilc_get_rssi(vif, &sinfo->signal); 1319 if (ret) 1320 return ret; 1321 1322 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL); 1323 memcpy(mac, vif->priv.associated_bss, ETH_ALEN); 1324 return 0; 1325 } 1326 1327 static int set_power_mgmt(struct wiphy *wiphy, struct net_device *dev, 1328 bool enabled, int timeout) 1329 { 1330 struct wilc_vif *vif = netdev_priv(dev); 1331 struct wilc_priv *priv = &vif->priv; 1332 1333 if (!priv->hif_drv) 1334 return -EIO; 1335 1336 wilc_set_power_mgmt(vif, enabled, timeout); 1337 1338 return 0; 1339 } 1340 1341 static int change_virtual_intf(struct wiphy *wiphy, struct net_device *dev, 1342 enum nl80211_iftype type, 1343 struct vif_params *params) 1344 { 1345 struct wilc *wl = wiphy_priv(wiphy); 1346 struct wilc_vif *vif = netdev_priv(dev); 1347 struct wilc_priv *priv = &vif->priv; 1348 1349 switch (type) { 1350 case NL80211_IFTYPE_STATION: 1351 vif->connecting = false; 1352 dev->ieee80211_ptr->iftype = type; 1353 priv->wdev.iftype = type; 1354 vif->monitor_flag = 0; 1355 if (vif->iftype == WILC_AP_MODE || vif->iftype == WILC_GO_MODE) 1356 wilc_wfi_deinit_mon_interface(wl, true); 1357 vif->iftype = WILC_STATION_MODE; 1358 1359 if (wl->initialized) 1360 wilc_set_operation_mode(vif, wilc_get_vif_idx(vif), 1361 WILC_STATION_MODE, vif->idx); 1362 1363 memset(priv->assoc_stainfo.sta_associated_bss, 0, 1364 WILC_MAX_NUM_STA * ETH_ALEN); 1365 break; 1366 1367 case NL80211_IFTYPE_P2P_CLIENT: 1368 vif->connecting = false; 1369 dev->ieee80211_ptr->iftype = type; 1370 priv->wdev.iftype = type; 1371 vif->monitor_flag = 0; 1372 vif->iftype = WILC_CLIENT_MODE; 1373 1374 if (wl->initialized) 1375 wilc_set_operation_mode(vif, wilc_get_vif_idx(vif), 1376 WILC_STATION_MODE, vif->idx); 1377 break; 1378 1379 case NL80211_IFTYPE_AP: 1380 dev->ieee80211_ptr->iftype = type; 1381 priv->wdev.iftype = type; 1382 vif->iftype = WILC_AP_MODE; 1383 1384 if (wl->initialized) 1385 wilc_set_operation_mode(vif, wilc_get_vif_idx(vif), 1386 WILC_AP_MODE, vif->idx); 1387 break; 1388 1389 case NL80211_IFTYPE_P2P_GO: 1390 dev->ieee80211_ptr->iftype = type; 1391 priv->wdev.iftype = type; 1392 vif->iftype = WILC_GO_MODE; 1393 1394 if (wl->initialized) 1395 wilc_set_operation_mode(vif, wilc_get_vif_idx(vif), 1396 WILC_AP_MODE, vif->idx); 1397 break; 1398 1399 default: 1400 netdev_err(dev, "Unknown interface type= %d\n", type); 1401 return -EINVAL; 1402 } 1403 1404 return 0; 1405 } 1406 1407 static int start_ap(struct wiphy *wiphy, struct net_device *dev, 1408 struct cfg80211_ap_settings *settings) 1409 { 1410 struct wilc_vif *vif = netdev_priv(dev); 1411 int ret; 1412 1413 ret = set_channel(wiphy, &settings->chandef); 1414 if (ret != 0) 1415 netdev_err(dev, "Error in setting channel\n"); 1416 1417 wilc_wlan_set_bssid(dev, dev->dev_addr, WILC_AP_MODE); 1418 1419 return wilc_add_beacon(vif, settings->beacon_interval, 1420 settings->dtim_period, &settings->beacon); 1421 } 1422 1423 static int change_beacon(struct wiphy *wiphy, struct net_device *dev, 1424 struct cfg80211_beacon_data *beacon) 1425 { 1426 struct wilc_vif *vif = netdev_priv(dev); 1427 1428 return wilc_add_beacon(vif, 0, 0, beacon); 1429 } 1430 1431 static int stop_ap(struct wiphy *wiphy, struct net_device *dev, 1432 unsigned int link_id) 1433 { 1434 int ret; 1435 struct wilc_vif *vif = netdev_priv(dev); 1436 1437 wilc_wlan_set_bssid(dev, NULL, WILC_AP_MODE); 1438 1439 ret = wilc_del_beacon(vif); 1440 1441 if (ret) 1442 netdev_err(dev, "Host delete beacon fail\n"); 1443 1444 return ret; 1445 } 1446 1447 static int add_station(struct wiphy *wiphy, struct net_device *dev, 1448 const u8 *mac, struct station_parameters *params) 1449 { 1450 int ret = 0; 1451 struct wilc_vif *vif = netdev_priv(dev); 1452 struct wilc_priv *priv = &vif->priv; 1453 1454 if (vif->iftype == WILC_AP_MODE || vif->iftype == WILC_GO_MODE) { 1455 memcpy(priv->assoc_stainfo.sta_associated_bss[params->aid], mac, 1456 ETH_ALEN); 1457 1458 ret = wilc_add_station(vif, mac, params); 1459 if (ret) 1460 netdev_err(dev, "Host add station fail\n"); 1461 } 1462 1463 return ret; 1464 } 1465 1466 static int del_station(struct wiphy *wiphy, struct net_device *dev, 1467 struct station_del_parameters *params) 1468 { 1469 const u8 *mac = params->mac; 1470 int ret = 0; 1471 struct wilc_vif *vif = netdev_priv(dev); 1472 struct wilc_priv *priv = &vif->priv; 1473 struct sta_info *info; 1474 1475 if (!(vif->iftype == WILC_AP_MODE || vif->iftype == WILC_GO_MODE)) 1476 return ret; 1477 1478 info = &priv->assoc_stainfo; 1479 1480 if (!mac) 1481 ret = wilc_del_allstation(vif, info->sta_associated_bss); 1482 1483 ret = wilc_del_station(vif, mac); 1484 if (ret) 1485 netdev_err(dev, "Host delete station fail\n"); 1486 return ret; 1487 } 1488 1489 static int change_station(struct wiphy *wiphy, struct net_device *dev, 1490 const u8 *mac, struct station_parameters *params) 1491 { 1492 int ret = 0; 1493 struct wilc_vif *vif = netdev_priv(dev); 1494 1495 if (vif->iftype == WILC_AP_MODE || vif->iftype == WILC_GO_MODE) { 1496 ret = wilc_edit_station(vif, mac, params); 1497 if (ret) 1498 netdev_err(dev, "Host edit station fail\n"); 1499 } 1500 return ret; 1501 } 1502 1503 static struct wilc_vif *wilc_get_vif_from_type(struct wilc *wl, int type) 1504 { 1505 struct wilc_vif *vif; 1506 1507 list_for_each_entry_rcu(vif, &wl->vif_list, list) { 1508 if (vif->iftype == type) 1509 return vif; 1510 } 1511 1512 return NULL; 1513 } 1514 1515 static struct wireless_dev *add_virtual_intf(struct wiphy *wiphy, 1516 const char *name, 1517 unsigned char name_assign_type, 1518 enum nl80211_iftype type, 1519 struct vif_params *params) 1520 { 1521 struct wilc *wl = wiphy_priv(wiphy); 1522 struct wilc_vif *vif; 1523 struct wireless_dev *wdev; 1524 int iftype; 1525 1526 if (type == NL80211_IFTYPE_MONITOR) { 1527 struct net_device *ndev; 1528 int srcu_idx; 1529 1530 srcu_idx = srcu_read_lock(&wl->srcu); 1531 vif = wilc_get_vif_from_type(wl, WILC_AP_MODE); 1532 if (!vif) { 1533 vif = wilc_get_vif_from_type(wl, WILC_GO_MODE); 1534 if (!vif) { 1535 srcu_read_unlock(&wl->srcu, srcu_idx); 1536 goto validate_interface; 1537 } 1538 } 1539 1540 if (vif->monitor_flag) { 1541 srcu_read_unlock(&wl->srcu, srcu_idx); 1542 goto validate_interface; 1543 } 1544 1545 ndev = wilc_wfi_init_mon_interface(wl, name, vif->ndev); 1546 if (ndev) { 1547 vif->monitor_flag = 1; 1548 } else { 1549 srcu_read_unlock(&wl->srcu, srcu_idx); 1550 return ERR_PTR(-EINVAL); 1551 } 1552 1553 wdev = &vif->priv.wdev; 1554 srcu_read_unlock(&wl->srcu, srcu_idx); 1555 return wdev; 1556 } 1557 1558 validate_interface: 1559 mutex_lock(&wl->vif_mutex); 1560 if (wl->vif_num == WILC_NUM_CONCURRENT_IFC) { 1561 pr_err("Reached maximum number of interface\n"); 1562 mutex_unlock(&wl->vif_mutex); 1563 return ERR_PTR(-EINVAL); 1564 } 1565 mutex_unlock(&wl->vif_mutex); 1566 1567 switch (type) { 1568 case NL80211_IFTYPE_STATION: 1569 iftype = WILC_STATION_MODE; 1570 break; 1571 case NL80211_IFTYPE_AP: 1572 iftype = WILC_AP_MODE; 1573 break; 1574 default: 1575 return ERR_PTR(-EOPNOTSUPP); 1576 } 1577 1578 vif = wilc_netdev_ifc_init(wl, name, iftype, type, true); 1579 if (IS_ERR(vif)) 1580 return ERR_CAST(vif); 1581 1582 return &vif->priv.wdev; 1583 } 1584 1585 static int del_virtual_intf(struct wiphy *wiphy, struct wireless_dev *wdev) 1586 { 1587 struct wilc *wl = wiphy_priv(wiphy); 1588 struct wilc_vif *vif; 1589 1590 if (wdev->iftype == NL80211_IFTYPE_AP || 1591 wdev->iftype == NL80211_IFTYPE_P2P_GO) 1592 wilc_wfi_deinit_mon_interface(wl, true); 1593 vif = netdev_priv(wdev->netdev); 1594 cfg80211_stop_iface(wiphy, wdev, GFP_KERNEL); 1595 cfg80211_unregister_netdevice(vif->ndev); 1596 vif->monitor_flag = 0; 1597 1598 wilc_set_operation_mode(vif, 0, 0, 0); 1599 mutex_lock(&wl->vif_mutex); 1600 list_del_rcu(&vif->list); 1601 wl->vif_num--; 1602 mutex_unlock(&wl->vif_mutex); 1603 synchronize_srcu(&wl->srcu); 1604 return 0; 1605 } 1606 1607 static int wilc_suspend(struct wiphy *wiphy, struct cfg80211_wowlan *wow) 1608 { 1609 struct wilc *wl = wiphy_priv(wiphy); 1610 1611 if (!wow && wilc_wlan_get_num_conn_ifcs(wl)) 1612 wl->suspend_event = true; 1613 else 1614 wl->suspend_event = false; 1615 1616 return 0; 1617 } 1618 1619 static int wilc_resume(struct wiphy *wiphy) 1620 { 1621 return 0; 1622 } 1623 1624 static void wilc_set_wakeup(struct wiphy *wiphy, bool enabled) 1625 { 1626 struct wilc *wl = wiphy_priv(wiphy); 1627 struct wilc_vif *vif; 1628 int srcu_idx; 1629 1630 srcu_idx = srcu_read_lock(&wl->srcu); 1631 vif = wilc_get_wl_to_vif(wl); 1632 if (IS_ERR(vif)) { 1633 srcu_read_unlock(&wl->srcu, srcu_idx); 1634 return; 1635 } 1636 1637 netdev_info(vif->ndev, "cfg set wake up = %d\n", enabled); 1638 wilc_set_wowlan_trigger(vif, enabled); 1639 srcu_read_unlock(&wl->srcu, srcu_idx); 1640 } 1641 1642 static int set_tx_power(struct wiphy *wiphy, struct wireless_dev *wdev, 1643 enum nl80211_tx_power_setting type, int mbm) 1644 { 1645 int ret; 1646 int srcu_idx; 1647 s32 tx_power = MBM_TO_DBM(mbm); 1648 struct wilc *wl = wiphy_priv(wiphy); 1649 struct wilc_vif *vif; 1650 1651 if (!wl->initialized) 1652 return -EIO; 1653 1654 srcu_idx = srcu_read_lock(&wl->srcu); 1655 vif = wilc_get_wl_to_vif(wl); 1656 if (IS_ERR(vif)) { 1657 srcu_read_unlock(&wl->srcu, srcu_idx); 1658 return -EINVAL; 1659 } 1660 1661 netdev_info(vif->ndev, "Setting tx power %d\n", tx_power); 1662 if (tx_power < 0) 1663 tx_power = 0; 1664 else if (tx_power > 18) 1665 tx_power = 18; 1666 ret = wilc_set_tx_power(vif, tx_power); 1667 if (ret) 1668 netdev_err(vif->ndev, "Failed to set tx power\n"); 1669 srcu_read_unlock(&wl->srcu, srcu_idx); 1670 1671 return ret; 1672 } 1673 1674 static int get_tx_power(struct wiphy *wiphy, struct wireless_dev *wdev, 1675 int *dbm) 1676 { 1677 int ret; 1678 struct wilc_vif *vif = netdev_priv(wdev->netdev); 1679 struct wilc *wl = vif->wilc; 1680 1681 /* If firmware is not started, return. */ 1682 if (!wl->initialized) 1683 return -EIO; 1684 1685 ret = wilc_get_tx_power(vif, (u8 *)dbm); 1686 if (ret) 1687 netdev_err(vif->ndev, "Failed to get tx power\n"); 1688 1689 return ret; 1690 } 1691 1692 static const struct cfg80211_ops wilc_cfg80211_ops = { 1693 .set_monitor_channel = set_channel, 1694 .scan = scan, 1695 .connect = connect, 1696 .disconnect = disconnect, 1697 .add_key = add_key, 1698 .del_key = del_key, 1699 .get_key = get_key, 1700 .set_default_key = set_default_key, 1701 .set_default_mgmt_key = set_default_mgmt_key, 1702 .add_virtual_intf = add_virtual_intf, 1703 .del_virtual_intf = del_virtual_intf, 1704 .change_virtual_intf = change_virtual_intf, 1705 1706 .start_ap = start_ap, 1707 .change_beacon = change_beacon, 1708 .stop_ap = stop_ap, 1709 .add_station = add_station, 1710 .del_station = del_station, 1711 .change_station = change_station, 1712 .get_station = get_station, 1713 .dump_station = dump_station, 1714 .change_bss = change_bss, 1715 .set_wiphy_params = set_wiphy_params, 1716 1717 .external_auth = external_auth, 1718 .set_pmksa = set_pmksa, 1719 .del_pmksa = del_pmksa, 1720 .flush_pmksa = flush_pmksa, 1721 .remain_on_channel = remain_on_channel, 1722 .cancel_remain_on_channel = cancel_remain_on_channel, 1723 .mgmt_tx_cancel_wait = mgmt_tx_cancel_wait, 1724 .mgmt_tx = mgmt_tx, 1725 .update_mgmt_frame_registrations = wilc_update_mgmt_frame_registrations, 1726 .set_power_mgmt = set_power_mgmt, 1727 .set_cqm_rssi_config = set_cqm_rssi_config, 1728 1729 .suspend = wilc_suspend, 1730 .resume = wilc_resume, 1731 .set_wakeup = wilc_set_wakeup, 1732 .set_tx_power = set_tx_power, 1733 .get_tx_power = get_tx_power, 1734 1735 }; 1736 1737 static void wlan_init_locks(struct wilc *wl) 1738 { 1739 mutex_init(&wl->hif_cs); 1740 mutex_init(&wl->rxq_cs); 1741 mutex_init(&wl->cfg_cmd_lock); 1742 mutex_init(&wl->vif_mutex); 1743 mutex_init(&wl->deinit_lock); 1744 1745 spin_lock_init(&wl->txq_spinlock); 1746 mutex_init(&wl->txq_add_to_head_cs); 1747 1748 init_completion(&wl->txq_event); 1749 init_completion(&wl->cfg_event); 1750 init_completion(&wl->sync_event); 1751 init_completion(&wl->txq_thread_started); 1752 init_srcu_struct(&wl->srcu); 1753 } 1754 1755 void wlan_deinit_locks(struct wilc *wilc) 1756 { 1757 mutex_destroy(&wilc->hif_cs); 1758 mutex_destroy(&wilc->rxq_cs); 1759 mutex_destroy(&wilc->cfg_cmd_lock); 1760 mutex_destroy(&wilc->txq_add_to_head_cs); 1761 mutex_destroy(&wilc->vif_mutex); 1762 mutex_destroy(&wilc->deinit_lock); 1763 cleanup_srcu_struct(&wilc->srcu); 1764 } 1765 1766 int wilc_cfg80211_init(struct wilc **wilc, struct device *dev, int io_type, 1767 const struct wilc_hif_func *ops) 1768 { 1769 struct wilc *wl; 1770 struct wilc_vif *vif; 1771 int ret, i; 1772 1773 wl = wilc_create_wiphy(dev); 1774 if (!wl) 1775 return -EINVAL; 1776 1777 wlan_init_locks(wl); 1778 1779 ret = wilc_wlan_cfg_init(wl); 1780 if (ret) 1781 goto free_wl; 1782 1783 *wilc = wl; 1784 wl->io_type = io_type; 1785 wl->hif_func = ops; 1786 1787 for (i = 0; i < NQUEUES; i++) 1788 INIT_LIST_HEAD(&wl->txq[i].txq_head.list); 1789 1790 INIT_LIST_HEAD(&wl->rxq_head.list); 1791 INIT_LIST_HEAD(&wl->vif_list); 1792 1793 vif = wilc_netdev_ifc_init(wl, "wlan%d", WILC_STATION_MODE, 1794 NL80211_IFTYPE_STATION, false); 1795 if (IS_ERR(vif)) { 1796 ret = PTR_ERR(vif); 1797 goto free_cfg; 1798 } 1799 1800 return 0; 1801 1802 free_cfg: 1803 wilc_wlan_cfg_deinit(wl); 1804 1805 free_wl: 1806 wlan_deinit_locks(wl); 1807 wiphy_unregister(wl->wiphy); 1808 wiphy_free(wl->wiphy); 1809 return ret; 1810 } 1811 EXPORT_SYMBOL_GPL(wilc_cfg80211_init); 1812 1813 struct wilc *wilc_create_wiphy(struct device *dev) 1814 { 1815 struct wiphy *wiphy; 1816 struct wilc *wl; 1817 int ret; 1818 1819 wiphy = wiphy_new(&wilc_cfg80211_ops, sizeof(*wl)); 1820 if (!wiphy) 1821 return NULL; 1822 1823 wl = wiphy_priv(wiphy); 1824 1825 memcpy(wl->bitrates, wilc_bitrates, sizeof(wilc_bitrates)); 1826 memcpy(wl->channels, wilc_2ghz_channels, sizeof(wilc_2ghz_channels)); 1827 wl->band.bitrates = wl->bitrates; 1828 wl->band.n_bitrates = ARRAY_SIZE(wl->bitrates); 1829 wl->band.channels = wl->channels; 1830 wl->band.n_channels = ARRAY_SIZE(wilc_2ghz_channels); 1831 1832 wl->band.ht_cap.ht_supported = 1; 1833 wl->band.ht_cap.cap |= (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT); 1834 wl->band.ht_cap.mcs.rx_mask[0] = 0xff; 1835 wl->band.ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K; 1836 wl->band.ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_NONE; 1837 1838 wiphy->bands[NL80211_BAND_2GHZ] = &wl->band; 1839 1840 wiphy->max_scan_ssids = WILC_MAX_NUM_PROBED_SSID; 1841 #ifdef CONFIG_PM 1842 wiphy->wowlan = &wowlan_support; 1843 #endif 1844 wiphy->max_num_pmkids = WILC_MAX_NUM_PMKIDS; 1845 wiphy->max_scan_ie_len = 1000; 1846 wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM; 1847 memcpy(wl->cipher_suites, wilc_cipher_suites, 1848 sizeof(wilc_cipher_suites)); 1849 wiphy->cipher_suites = wl->cipher_suites; 1850 wiphy->n_cipher_suites = ARRAY_SIZE(wilc_cipher_suites); 1851 wiphy->mgmt_stypes = wilc_wfi_cfg80211_mgmt_types; 1852 1853 wiphy->max_remain_on_channel_duration = 500; 1854 wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) | 1855 BIT(NL80211_IFTYPE_AP) | 1856 BIT(NL80211_IFTYPE_MONITOR) | 1857 BIT(NL80211_IFTYPE_P2P_GO) | 1858 BIT(NL80211_IFTYPE_P2P_CLIENT); 1859 wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL; 1860 wiphy->features |= NL80211_FEATURE_SAE; 1861 set_wiphy_dev(wiphy, dev); 1862 wl->wiphy = wiphy; 1863 ret = wiphy_register(wiphy); 1864 if (ret) { 1865 wiphy_free(wiphy); 1866 return NULL; 1867 } 1868 return wl; 1869 } 1870 1871 int wilc_init_host_int(struct net_device *net) 1872 { 1873 int ret; 1874 struct wilc_vif *vif = netdev_priv(net); 1875 struct wilc_priv *priv = &vif->priv; 1876 1877 priv->p2p_listen_state = false; 1878 1879 mutex_init(&priv->scan_req_lock); 1880 ret = wilc_init(net, &priv->hif_drv); 1881 if (ret) 1882 netdev_err(net, "Error while initializing hostinterface\n"); 1883 1884 return ret; 1885 } 1886 1887 void wilc_deinit_host_int(struct net_device *net) 1888 { 1889 int ret; 1890 struct wilc_vif *vif = netdev_priv(net); 1891 struct wilc_priv *priv = &vif->priv; 1892 1893 priv->p2p_listen_state = false; 1894 1895 flush_workqueue(vif->wilc->hif_workqueue); 1896 mutex_destroy(&priv->scan_req_lock); 1897 ret = wilc_deinit(vif); 1898 1899 if (ret) 1900 netdev_err(net, "Error while deinitializing host interface\n"); 1901 } 1902 1903