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