1 /* 2 * Copyright (c) 2012-2012 Quantenna Communications, Inc. 3 * All rights reserved. 4 * 5 * This program is free software; you can redistribute it and/or 6 * modify it under the terms of the GNU General Public License 7 * as published by the Free Software Foundation; either version 2 8 * of the License, or (at your option) any later version. 9 * 10 * This program is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU General Public License for more details. 14 * 15 */ 16 17 #include <linux/kernel.h> 18 #include <linux/etherdevice.h> 19 #include <linux/vmalloc.h> 20 #include <linux/ieee80211.h> 21 #include <net/cfg80211.h> 22 #include <net/netlink.h> 23 24 #include "cfg80211.h" 25 #include "commands.h" 26 #include "core.h" 27 #include "util.h" 28 #include "bus.h" 29 30 /* Supported rates to be advertised to the cfg80211 */ 31 static struct ieee80211_rate qtnf_rates_2g[] = { 32 {.bitrate = 10, .hw_value = 2, }, 33 {.bitrate = 20, .hw_value = 4, }, 34 {.bitrate = 55, .hw_value = 11, }, 35 {.bitrate = 110, .hw_value = 22, }, 36 {.bitrate = 60, .hw_value = 12, }, 37 {.bitrate = 90, .hw_value = 18, }, 38 {.bitrate = 120, .hw_value = 24, }, 39 {.bitrate = 180, .hw_value = 36, }, 40 {.bitrate = 240, .hw_value = 48, }, 41 {.bitrate = 360, .hw_value = 72, }, 42 {.bitrate = 480, .hw_value = 96, }, 43 {.bitrate = 540, .hw_value = 108, }, 44 }; 45 46 /* Supported rates to be advertised to the cfg80211 */ 47 static struct ieee80211_rate qtnf_rates_5g[] = { 48 {.bitrate = 60, .hw_value = 12, }, 49 {.bitrate = 90, .hw_value = 18, }, 50 {.bitrate = 120, .hw_value = 24, }, 51 {.bitrate = 180, .hw_value = 36, }, 52 {.bitrate = 240, .hw_value = 48, }, 53 {.bitrate = 360, .hw_value = 72, }, 54 {.bitrate = 480, .hw_value = 96, }, 55 {.bitrate = 540, .hw_value = 108, }, 56 }; 57 58 /* Supported crypto cipher suits to be advertised to cfg80211 */ 59 static const u32 qtnf_cipher_suites[] = { 60 WLAN_CIPHER_SUITE_TKIP, 61 WLAN_CIPHER_SUITE_CCMP, 62 WLAN_CIPHER_SUITE_AES_CMAC, 63 }; 64 65 /* Supported mgmt frame types to be advertised to cfg80211 */ 66 static const struct ieee80211_txrx_stypes 67 qtnf_mgmt_stypes[NUM_NL80211_IFTYPES] = { 68 [NL80211_IFTYPE_STATION] = { 69 .tx = BIT(IEEE80211_STYPE_ACTION >> 4), 70 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) | 71 BIT(IEEE80211_STYPE_PROBE_REQ >> 4), 72 }, 73 [NL80211_IFTYPE_AP] = { 74 .tx = BIT(IEEE80211_STYPE_ACTION >> 4), 75 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) | 76 BIT(IEEE80211_STYPE_PROBE_REQ >> 4), 77 }, 78 }; 79 80 static int 81 qtnf_change_virtual_intf(struct wiphy *wiphy, 82 struct net_device *dev, 83 enum nl80211_iftype type, 84 struct vif_params *params) 85 { 86 struct qtnf_vif *vif = qtnf_netdev_get_priv(dev); 87 u8 *mac_addr; 88 int ret; 89 90 if (params) 91 mac_addr = params->macaddr; 92 else 93 mac_addr = NULL; 94 95 qtnf_scan_done(vif->mac, true); 96 97 ret = qtnf_cmd_send_change_intf_type(vif, type, mac_addr); 98 if (ret) { 99 pr_err("VIF%u.%u: failed to change VIF type: %d\n", 100 vif->mac->macid, vif->vifid, ret); 101 return ret; 102 } 103 104 vif->wdev.iftype = type; 105 return 0; 106 } 107 108 int qtnf_del_virtual_intf(struct wiphy *wiphy, struct wireless_dev *wdev) 109 { 110 struct net_device *netdev = wdev->netdev; 111 struct qtnf_vif *vif; 112 113 if (WARN_ON(!netdev)) 114 return -EFAULT; 115 116 vif = qtnf_netdev_get_priv(wdev->netdev); 117 118 qtnf_scan_done(vif->mac, true); 119 120 if (qtnf_cmd_send_del_intf(vif)) 121 pr_err("VIF%u.%u: failed to delete VIF\n", vif->mac->macid, 122 vif->vifid); 123 124 /* Stop data */ 125 netif_tx_stop_all_queues(netdev); 126 if (netif_carrier_ok(netdev)) 127 netif_carrier_off(netdev); 128 129 if (netdev->reg_state == NETREG_REGISTERED) 130 unregister_netdevice(netdev); 131 132 vif->netdev->ieee80211_ptr = NULL; 133 vif->netdev = NULL; 134 vif->wdev.iftype = NL80211_IFTYPE_UNSPECIFIED; 135 eth_zero_addr(vif->mac_addr); 136 137 return 0; 138 } 139 140 static struct wireless_dev *qtnf_add_virtual_intf(struct wiphy *wiphy, 141 const char *name, 142 unsigned char name_assign_t, 143 enum nl80211_iftype type, 144 struct vif_params *params) 145 { 146 struct qtnf_wmac *mac; 147 struct qtnf_vif *vif; 148 u8 *mac_addr = NULL; 149 150 mac = wiphy_priv(wiphy); 151 152 if (!mac) 153 return ERR_PTR(-EFAULT); 154 155 switch (type) { 156 case NL80211_IFTYPE_STATION: 157 case NL80211_IFTYPE_AP: 158 vif = qtnf_mac_get_free_vif(mac); 159 if (!vif) { 160 pr_err("MAC%u: no free VIF available\n", mac->macid); 161 return ERR_PTR(-EFAULT); 162 } 163 164 eth_zero_addr(vif->mac_addr); 165 vif->bss_priority = QTNF_DEF_BSS_PRIORITY; 166 vif->wdev.wiphy = wiphy; 167 vif->wdev.iftype = type; 168 vif->sta_state = QTNF_STA_DISCONNECTED; 169 break; 170 default: 171 pr_err("MAC%u: unsupported IF type %d\n", mac->macid, type); 172 return ERR_PTR(-ENOTSUPP); 173 } 174 175 if (params) 176 mac_addr = params->macaddr; 177 178 if (qtnf_cmd_send_add_intf(vif, type, mac_addr)) { 179 pr_err("VIF%u.%u: failed to add VIF\n", mac->macid, vif->vifid); 180 goto err_cmd; 181 } 182 183 if (!is_valid_ether_addr(vif->mac_addr)) { 184 pr_err("VIF%u.%u: FW reported bad MAC: %pM\n", 185 mac->macid, vif->vifid, vif->mac_addr); 186 goto err_mac; 187 } 188 189 if (qtnf_core_net_attach(mac, vif, name, name_assign_t, type)) { 190 pr_err("VIF%u.%u: failed to attach netdev\n", mac->macid, 191 vif->vifid); 192 goto err_net; 193 } 194 195 vif->wdev.netdev = vif->netdev; 196 return &vif->wdev; 197 198 err_net: 199 vif->netdev = NULL; 200 err_mac: 201 qtnf_cmd_send_del_intf(vif); 202 err_cmd: 203 vif->wdev.iftype = NL80211_IFTYPE_UNSPECIFIED; 204 205 return ERR_PTR(-EFAULT); 206 } 207 208 static int qtnf_mgmt_set_appie(struct qtnf_vif *vif, 209 const struct cfg80211_beacon_data *info) 210 { 211 int ret = 0; 212 213 if (!info->beacon_ies || !info->beacon_ies_len) { 214 ret = qtnf_cmd_send_mgmt_set_appie(vif, QLINK_MGMT_FRAME_BEACON, 215 NULL, 0); 216 } else { 217 ret = qtnf_cmd_send_mgmt_set_appie(vif, QLINK_MGMT_FRAME_BEACON, 218 info->beacon_ies, 219 info->beacon_ies_len); 220 } 221 222 if (ret) 223 goto out; 224 225 if (!info->proberesp_ies || !info->proberesp_ies_len) { 226 ret = qtnf_cmd_send_mgmt_set_appie(vif, 227 QLINK_MGMT_FRAME_PROBE_RESP, 228 NULL, 0); 229 } else { 230 ret = qtnf_cmd_send_mgmt_set_appie(vif, 231 QLINK_MGMT_FRAME_PROBE_RESP, 232 info->proberesp_ies, 233 info->proberesp_ies_len); 234 } 235 236 if (ret) 237 goto out; 238 239 if (!info->assocresp_ies || !info->assocresp_ies_len) { 240 ret = qtnf_cmd_send_mgmt_set_appie(vif, 241 QLINK_MGMT_FRAME_ASSOC_RESP, 242 NULL, 0); 243 } else { 244 ret = qtnf_cmd_send_mgmt_set_appie(vif, 245 QLINK_MGMT_FRAME_ASSOC_RESP, 246 info->assocresp_ies, 247 info->assocresp_ies_len); 248 } 249 250 out: 251 return ret; 252 } 253 254 static int qtnf_change_beacon(struct wiphy *wiphy, struct net_device *dev, 255 struct cfg80211_beacon_data *info) 256 { 257 struct qtnf_vif *vif = qtnf_netdev_get_priv(dev); 258 259 if (!(vif->bss_status & QTNF_STATE_AP_START)) { 260 pr_err("VIF%u.%u: not started\n", vif->mac->macid, vif->vifid); 261 return -EFAULT; 262 } 263 264 return qtnf_mgmt_set_appie(vif, info); 265 } 266 267 static int qtnf_start_ap(struct wiphy *wiphy, struct net_device *dev, 268 struct cfg80211_ap_settings *settings) 269 { 270 struct qtnf_vif *vif = qtnf_netdev_get_priv(dev); 271 struct qtnf_wmac *mac = wiphy_priv(wiphy); 272 struct qtnf_bss_config *bss_cfg; 273 int ret; 274 275 if (!cfg80211_chandef_identical(&mac->chandef, &settings->chandef)) { 276 memcpy(&mac->chandef, &settings->chandef, sizeof(mac->chandef)); 277 if (vif->vifid != 0) 278 pr_warn("%s: unexpected chan %u (%u MHz)\n", dev->name, 279 settings->chandef.chan->hw_value, 280 settings->chandef.chan->center_freq); 281 } 282 283 bss_cfg = &vif->bss_cfg; 284 memset(bss_cfg, 0, sizeof(*bss_cfg)); 285 286 bss_cfg->bcn_period = settings->beacon_interval; 287 bss_cfg->dtim = settings->dtim_period; 288 bss_cfg->auth_type = settings->auth_type; 289 bss_cfg->privacy = settings->privacy; 290 291 bss_cfg->ssid_len = settings->ssid_len; 292 memcpy(&bss_cfg->ssid, settings->ssid, bss_cfg->ssid_len); 293 294 memcpy(&bss_cfg->crypto, &settings->crypto, 295 sizeof(struct cfg80211_crypto_settings)); 296 297 ret = qtnf_cmd_send_config_ap(vif); 298 if (ret) { 299 pr_err("VIF%u.%u: failed to push config to FW\n", 300 vif->mac->macid, vif->vifid); 301 goto out; 302 } 303 304 if (!(vif->bss_status & QTNF_STATE_AP_CONFIG)) { 305 pr_err("VIF%u.%u: AP config failed in FW\n", vif->mac->macid, 306 vif->vifid); 307 ret = -EFAULT; 308 goto out; 309 } 310 311 ret = qtnf_mgmt_set_appie(vif, &settings->beacon); 312 if (ret) { 313 pr_err("VIF%u.%u: failed to add IEs to beacon\n", 314 vif->mac->macid, vif->vifid); 315 goto out; 316 } 317 318 ret = qtnf_cmd_send_start_ap(vif); 319 if (ret) { 320 pr_err("VIF%u.%u: failed to start AP\n", vif->mac->macid, 321 vif->vifid); 322 goto out; 323 } 324 325 if (!(vif->bss_status & QTNF_STATE_AP_START)) { 326 pr_err("VIF%u.%u: FW failed to start AP operation\n", 327 vif->mac->macid, vif->vifid); 328 ret = -EFAULT; 329 } 330 331 out: 332 return ret; 333 } 334 335 static int qtnf_stop_ap(struct wiphy *wiphy, struct net_device *dev) 336 { 337 struct qtnf_vif *vif = qtnf_netdev_get_priv(dev); 338 int ret; 339 340 qtnf_scan_done(vif->mac, true); 341 342 ret = qtnf_cmd_send_stop_ap(vif); 343 if (ret) { 344 pr_err("VIF%u.%u: failed to stop AP operation in FW\n", 345 vif->mac->macid, vif->vifid); 346 vif->bss_status &= ~QTNF_STATE_AP_START; 347 vif->bss_status &= ~QTNF_STATE_AP_CONFIG; 348 349 netif_carrier_off(vif->netdev); 350 } 351 352 return ret; 353 } 354 355 static int qtnf_set_wiphy_params(struct wiphy *wiphy, u32 changed) 356 { 357 struct qtnf_wmac *mac = wiphy_priv(wiphy); 358 struct qtnf_vif *vif; 359 int ret; 360 361 vif = qtnf_mac_get_base_vif(mac); 362 if (!vif) { 363 pr_err("MAC%u: primary VIF is not configured\n", mac->macid); 364 return -EFAULT; 365 } 366 367 if (changed & (WIPHY_PARAM_RETRY_LONG | WIPHY_PARAM_RETRY_SHORT)) { 368 pr_err("MAC%u: can't modify retry params\n", mac->macid); 369 return -EOPNOTSUPP; 370 } 371 372 ret = qtnf_cmd_send_update_phy_params(mac, changed); 373 if (ret) 374 pr_err("MAC%u: failed to update PHY params\n", mac->macid); 375 376 return ret; 377 } 378 379 static void 380 qtnf_mgmt_frame_register(struct wiphy *wiphy, struct wireless_dev *wdev, 381 u16 frame_type, bool reg) 382 { 383 struct qtnf_vif *vif = qtnf_netdev_get_priv(wdev->netdev); 384 u16 mgmt_type; 385 u16 new_mask; 386 u16 qlink_frame_type = 0; 387 388 mgmt_type = (frame_type & IEEE80211_FCTL_STYPE) >> 4; 389 390 if (reg) 391 new_mask = vif->mgmt_frames_bitmask | BIT(mgmt_type); 392 else 393 new_mask = vif->mgmt_frames_bitmask & ~BIT(mgmt_type); 394 395 if (new_mask == vif->mgmt_frames_bitmask) 396 return; 397 398 switch (frame_type & IEEE80211_FCTL_STYPE) { 399 case IEEE80211_STYPE_PROBE_REQ: 400 qlink_frame_type = QLINK_MGMT_FRAME_PROBE_REQ; 401 break; 402 case IEEE80211_STYPE_ACTION: 403 qlink_frame_type = QLINK_MGMT_FRAME_ACTION; 404 break; 405 default: 406 pr_warn("VIF%u.%u: unsupported frame type: %X\n", 407 vif->mac->macid, vif->vifid, 408 (frame_type & IEEE80211_FCTL_STYPE) >> 4); 409 return; 410 } 411 412 if (qtnf_cmd_send_register_mgmt(vif, qlink_frame_type, reg)) { 413 pr_warn("VIF%u.%u: failed to %sregister mgmt frame type 0x%x\n", 414 vif->mac->macid, vif->vifid, reg ? "" : "un", 415 frame_type); 416 return; 417 } 418 419 vif->mgmt_frames_bitmask = new_mask; 420 pr_debug("VIF%u.%u: %sregistered mgmt frame type 0x%x\n", 421 vif->mac->macid, vif->vifid, reg ? "" : "un", frame_type); 422 } 423 424 static int 425 qtnf_mgmt_tx(struct wiphy *wiphy, struct wireless_dev *wdev, 426 struct cfg80211_mgmt_tx_params *params, u64 *cookie) 427 { 428 struct qtnf_vif *vif = qtnf_netdev_get_priv(wdev->netdev); 429 const struct ieee80211_mgmt *mgmt_frame = (void *)params->buf; 430 u32 short_cookie = prandom_u32(); 431 u16 flags = 0; 432 433 *cookie = short_cookie; 434 435 if (params->offchan) 436 flags |= QLINK_MGMT_FRAME_TX_FLAG_OFFCHAN; 437 438 if (params->no_cck) 439 flags |= QLINK_MGMT_FRAME_TX_FLAG_NO_CCK; 440 441 if (params->dont_wait_for_ack) 442 flags |= QLINK_MGMT_FRAME_TX_FLAG_ACK_NOWAIT; 443 444 pr_debug("%s freq:%u; FC:%.4X; DA:%pM; len:%zu; C:%.8X; FL:%.4X\n", 445 wdev->netdev->name, params->chan->center_freq, 446 le16_to_cpu(mgmt_frame->frame_control), mgmt_frame->da, 447 params->len, short_cookie, flags); 448 449 return qtnf_cmd_send_mgmt_frame(vif, short_cookie, flags, 450 params->chan->center_freq, 451 params->buf, params->len); 452 } 453 454 static int 455 qtnf_get_station(struct wiphy *wiphy, struct net_device *dev, 456 const u8 *mac, struct station_info *sinfo) 457 { 458 struct qtnf_vif *vif = qtnf_netdev_get_priv(dev); 459 460 return qtnf_cmd_get_sta_info(vif, mac, sinfo); 461 } 462 463 static int 464 qtnf_dump_station(struct wiphy *wiphy, struct net_device *dev, 465 int idx, u8 *mac, struct station_info *sinfo) 466 { 467 struct qtnf_vif *vif = qtnf_netdev_get_priv(dev); 468 const struct qtnf_sta_node *sta_node; 469 int ret; 470 471 sta_node = qtnf_sta_list_lookup_index(&vif->sta_list, idx); 472 473 if (unlikely(!sta_node)) 474 return -ENOENT; 475 476 ether_addr_copy(mac, sta_node->mac_addr); 477 478 ret = qtnf_cmd_get_sta_info(vif, sta_node->mac_addr, sinfo); 479 480 if (unlikely(ret == -ENOENT)) { 481 qtnf_sta_list_del(&vif->sta_list, mac); 482 cfg80211_del_sta(vif->netdev, mac, GFP_KERNEL); 483 sinfo->filled = 0; 484 } 485 486 return ret; 487 } 488 489 static int qtnf_add_key(struct wiphy *wiphy, struct net_device *dev, 490 u8 key_index, bool pairwise, const u8 *mac_addr, 491 struct key_params *params) 492 { 493 struct qtnf_vif *vif = qtnf_netdev_get_priv(dev); 494 int ret; 495 496 ret = qtnf_cmd_send_add_key(vif, key_index, pairwise, mac_addr, params); 497 if (ret) 498 pr_err("VIF%u.%u: failed to add key: cipher=%x idx=%u pw=%u\n", 499 vif->mac->macid, vif->vifid, params->cipher, key_index, 500 pairwise); 501 502 return ret; 503 } 504 505 static int qtnf_del_key(struct wiphy *wiphy, struct net_device *dev, 506 u8 key_index, bool pairwise, const u8 *mac_addr) 507 { 508 struct qtnf_vif *vif = qtnf_netdev_get_priv(dev); 509 int ret; 510 511 ret = qtnf_cmd_send_del_key(vif, key_index, pairwise, mac_addr); 512 if (ret) 513 pr_err("VIF%u.%u: failed to delete key: idx=%u pw=%u\n", 514 vif->mac->macid, vif->vifid, key_index, pairwise); 515 516 return ret; 517 } 518 519 static int qtnf_set_default_key(struct wiphy *wiphy, struct net_device *dev, 520 u8 key_index, bool unicast, bool multicast) 521 { 522 struct qtnf_vif *vif = qtnf_netdev_get_priv(dev); 523 int ret; 524 525 ret = qtnf_cmd_send_set_default_key(vif, key_index, unicast, multicast); 526 if (ret) 527 pr_err("VIF%u.%u: failed to set dflt key: idx=%u uc=%u mc=%u\n", 528 vif->mac->macid, vif->vifid, key_index, unicast, 529 multicast); 530 531 return ret; 532 } 533 534 static int 535 qtnf_set_default_mgmt_key(struct wiphy *wiphy, struct net_device *dev, 536 u8 key_index) 537 { 538 struct qtnf_vif *vif = qtnf_netdev_get_priv(dev); 539 int ret; 540 541 ret = qtnf_cmd_send_set_default_mgmt_key(vif, key_index); 542 if (ret) 543 pr_err("VIF%u.%u: failed to set default MGMT key: idx=%u\n", 544 vif->mac->macid, vif->vifid, key_index); 545 546 return ret; 547 } 548 549 static int 550 qtnf_change_station(struct wiphy *wiphy, struct net_device *dev, 551 const u8 *mac, struct station_parameters *params) 552 { 553 struct qtnf_vif *vif = qtnf_netdev_get_priv(dev); 554 int ret; 555 556 ret = qtnf_cmd_send_change_sta(vif, mac, params); 557 if (ret) 558 pr_err("VIF%u.%u: failed to change STA %pM\n", 559 vif->mac->macid, vif->vifid, mac); 560 561 return ret; 562 } 563 564 static int 565 qtnf_del_station(struct wiphy *wiphy, struct net_device *dev, 566 struct station_del_parameters *params) 567 { 568 struct qtnf_vif *vif = qtnf_netdev_get_priv(dev); 569 int ret; 570 571 if (params->mac && 572 (vif->wdev.iftype == NL80211_IFTYPE_AP) && 573 !is_broadcast_ether_addr(params->mac) && 574 !qtnf_sta_list_lookup(&vif->sta_list, params->mac)) 575 return 0; 576 577 ret = qtnf_cmd_send_del_sta(vif, params); 578 if (ret) 579 pr_err("VIF%u.%u: failed to delete STA %pM\n", 580 vif->mac->macid, vif->vifid, params->mac); 581 return ret; 582 } 583 584 static void qtnf_scan_timeout(unsigned long data) 585 { 586 struct qtnf_wmac *mac = (struct qtnf_wmac *)data; 587 588 pr_warn("mac%d scan timed out\n", mac->macid); 589 qtnf_scan_done(mac, true); 590 } 591 592 static int 593 qtnf_scan(struct wiphy *wiphy, struct cfg80211_scan_request *request) 594 { 595 struct qtnf_wmac *mac = wiphy_priv(wiphy); 596 597 mac->scan_req = request; 598 599 if (qtnf_cmd_send_scan(mac)) { 600 pr_err("MAC%u: failed to start scan\n", mac->macid); 601 mac->scan_req = NULL; 602 return -EFAULT; 603 } 604 605 mac->scan_timeout.data = (unsigned long)mac; 606 mac->scan_timeout.function = qtnf_scan_timeout; 607 mod_timer(&mac->scan_timeout, 608 jiffies + QTNF_SCAN_TIMEOUT_SEC * HZ); 609 610 return 0; 611 } 612 613 static int 614 qtnf_connect(struct wiphy *wiphy, struct net_device *dev, 615 struct cfg80211_connect_params *sme) 616 { 617 struct qtnf_vif *vif = qtnf_netdev_get_priv(dev); 618 struct qtnf_wmac *mac = wiphy_priv(wiphy); 619 struct cfg80211_chan_def chandef; 620 struct qtnf_bss_config *bss_cfg; 621 int ret; 622 623 if (vif->wdev.iftype != NL80211_IFTYPE_STATION) 624 return -EOPNOTSUPP; 625 626 if (vif->sta_state != QTNF_STA_DISCONNECTED) 627 return -EBUSY; 628 629 bss_cfg = &vif->bss_cfg; 630 memset(bss_cfg, 0, sizeof(*bss_cfg)); 631 632 if (sme->channel) { 633 /* FIXME: need to set proper nl80211_channel_type value */ 634 cfg80211_chandef_create(&chandef, sme->channel, 635 NL80211_CHAN_HT20); 636 /* fall-back to minimal safe chandef description */ 637 if (!cfg80211_chandef_valid(&chandef)) 638 cfg80211_chandef_create(&chandef, sme->channel, 639 NL80211_CHAN_HT20); 640 641 memcpy(&mac->chandef, &chandef, sizeof(mac->chandef)); 642 } 643 644 bss_cfg->ssid_len = sme->ssid_len; 645 memcpy(&bss_cfg->ssid, sme->ssid, bss_cfg->ssid_len); 646 bss_cfg->auth_type = sme->auth_type; 647 bss_cfg->privacy = sme->privacy; 648 bss_cfg->mfp = sme->mfp; 649 650 if ((sme->bg_scan_period > 0) && 651 (sme->bg_scan_period <= QTNF_MAX_BG_SCAN_PERIOD)) 652 bss_cfg->bg_scan_period = sme->bg_scan_period; 653 else if (sme->bg_scan_period == -1) 654 bss_cfg->bg_scan_period = QTNF_DEFAULT_BG_SCAN_PERIOD; 655 else 656 bss_cfg->bg_scan_period = 0; /* disabled */ 657 658 bss_cfg->connect_flags = 0; 659 660 if (sme->flags & ASSOC_REQ_DISABLE_HT) 661 bss_cfg->connect_flags |= QLINK_STA_CONNECT_DISABLE_HT; 662 if (sme->flags & ASSOC_REQ_DISABLE_VHT) 663 bss_cfg->connect_flags |= QLINK_STA_CONNECT_DISABLE_VHT; 664 if (sme->flags & ASSOC_REQ_USE_RRM) 665 bss_cfg->connect_flags |= QLINK_STA_CONNECT_USE_RRM; 666 667 memcpy(&bss_cfg->crypto, &sme->crypto, sizeof(bss_cfg->crypto)); 668 if (sme->bssid) 669 ether_addr_copy(bss_cfg->bssid, sme->bssid); 670 else 671 eth_zero_addr(bss_cfg->bssid); 672 673 ret = qtnf_cmd_send_connect(vif, sme); 674 if (ret) { 675 pr_err("VIF%u.%u: failed to connect\n", vif->mac->macid, 676 vif->vifid); 677 return ret; 678 } 679 680 vif->sta_state = QTNF_STA_CONNECTING; 681 return 0; 682 } 683 684 static int 685 qtnf_disconnect(struct wiphy *wiphy, struct net_device *dev, 686 u16 reason_code) 687 { 688 struct qtnf_wmac *mac = wiphy_priv(wiphy); 689 struct qtnf_vif *vif; 690 int ret; 691 692 vif = qtnf_mac_get_base_vif(mac); 693 if (!vif) { 694 pr_err("MAC%u: primary VIF is not configured\n", mac->macid); 695 return -EFAULT; 696 } 697 698 if (vif->wdev.iftype != NL80211_IFTYPE_STATION) 699 return -EOPNOTSUPP; 700 701 if (vif->sta_state == QTNF_STA_DISCONNECTED) 702 return 0; 703 704 ret = qtnf_cmd_send_disconnect(vif, reason_code); 705 if (ret) { 706 pr_err("VIF%u.%u: failed to disconnect\n", mac->macid, 707 vif->vifid); 708 return ret; 709 } 710 711 vif->sta_state = QTNF_STA_DISCONNECTED; 712 return 0; 713 } 714 715 static int 716 qtnf_dump_survey(struct wiphy *wiphy, struct net_device *dev, 717 int idx, struct survey_info *survey) 718 { 719 struct qtnf_wmac *mac = wiphy_priv(wiphy); 720 struct ieee80211_supported_band *sband; 721 struct cfg80211_chan_def *chandef; 722 struct ieee80211_channel *chan; 723 struct qtnf_chan_stats stats; 724 struct qtnf_vif *vif; 725 int ret; 726 727 vif = qtnf_netdev_get_priv(dev); 728 chandef = &mac->chandef; 729 730 sband = wiphy->bands[NL80211_BAND_2GHZ]; 731 if (sband && idx >= sband->n_channels) { 732 idx -= sband->n_channels; 733 sband = NULL; 734 } 735 736 if (!sband) 737 sband = wiphy->bands[NL80211_BAND_5GHZ]; 738 739 if (!sband || idx >= sband->n_channels) 740 return -ENOENT; 741 742 chan = &sband->channels[idx]; 743 memset(&stats, 0, sizeof(stats)); 744 745 survey->channel = chan; 746 survey->filled = 0x0; 747 748 if (chandef->chan) { 749 if (chan->hw_value == chandef->chan->hw_value) 750 survey->filled = SURVEY_INFO_IN_USE; 751 } 752 753 ret = qtnf_cmd_get_chan_stats(mac, chan->hw_value, &stats); 754 switch (ret) { 755 case 0: 756 if (unlikely(stats.chan_num != chan->hw_value)) { 757 pr_err("received stats for channel %d instead of %d\n", 758 stats.chan_num, chan->hw_value); 759 ret = -EINVAL; 760 break; 761 } 762 763 survey->filled |= SURVEY_INFO_TIME | 764 SURVEY_INFO_TIME_SCAN | 765 SURVEY_INFO_TIME_BUSY | 766 SURVEY_INFO_TIME_RX | 767 SURVEY_INFO_TIME_TX | 768 SURVEY_INFO_NOISE_DBM; 769 770 survey->time_scan = stats.cca_try; 771 survey->time = stats.cca_try; 772 survey->time_tx = stats.cca_tx; 773 survey->time_rx = stats.cca_rx; 774 survey->time_busy = stats.cca_busy; 775 survey->noise = stats.chan_noise; 776 break; 777 case -ENOENT: 778 pr_debug("no stats for channel %u\n", chan->hw_value); 779 ret = 0; 780 break; 781 default: 782 pr_debug("failed to get chan(%d) stats from card\n", 783 chan->hw_value); 784 ret = -EINVAL; 785 break; 786 } 787 788 return ret; 789 } 790 791 static int 792 qtnf_get_channel(struct wiphy *wiphy, struct wireless_dev *wdev, 793 struct cfg80211_chan_def *chandef) 794 { 795 struct qtnf_wmac *mac = wiphy_priv(wiphy); 796 struct net_device *ndev = wdev->netdev; 797 struct qtnf_vif *vif; 798 799 if (!ndev) 800 return -ENODEV; 801 802 vif = qtnf_netdev_get_priv(wdev->netdev); 803 804 switch (vif->wdev.iftype) { 805 case NL80211_IFTYPE_STATION: 806 if (vif->sta_state == QTNF_STA_DISCONNECTED) { 807 pr_warn("%s: STA disconnected\n", ndev->name); 808 return -ENODATA; 809 } 810 break; 811 case NL80211_IFTYPE_AP: 812 if (!(vif->bss_status & QTNF_STATE_AP_START)) { 813 pr_warn("%s: AP not started\n", ndev->name); 814 return -ENODATA; 815 } 816 break; 817 default: 818 pr_err("unsupported vif type (%d)\n", vif->wdev.iftype); 819 return -ENODATA; 820 } 821 822 if (!cfg80211_chandef_valid(&mac->chandef)) { 823 pr_err("invalid channel settings on %s\n", ndev->name); 824 return -ENODATA; 825 } 826 827 memcpy(chandef, &mac->chandef, sizeof(*chandef)); 828 return 0; 829 } 830 831 static int qtnf_channel_switch(struct wiphy *wiphy, struct net_device *dev, 832 struct cfg80211_csa_settings *params) 833 { 834 struct qtnf_wmac *mac = wiphy_priv(wiphy); 835 struct qtnf_vif *vif = qtnf_netdev_get_priv(dev); 836 int ret; 837 838 pr_debug("%s: chan(%u) count(%u) radar(%u) block_tx(%u)\n", dev->name, 839 params->chandef.chan->hw_value, params->count, 840 params->radar_required, params->block_tx); 841 842 switch (vif->wdev.iftype) { 843 case NL80211_IFTYPE_AP: 844 if (!(vif->bss_status & QTNF_STATE_AP_START)) { 845 pr_warn("AP not started on %s\n", dev->name); 846 return -ENOTCONN; 847 } 848 break; 849 default: 850 pr_err("unsupported vif type (%d) on %s\n", 851 vif->wdev.iftype, dev->name); 852 return -EOPNOTSUPP; 853 } 854 855 if (vif->vifid != 0) { 856 if (!(mac->status & QTNF_MAC_CSA_ACTIVE)) 857 return -EOPNOTSUPP; 858 859 if (!cfg80211_chandef_identical(¶ms->chandef, 860 &mac->csa_chandef)) 861 return -EINVAL; 862 863 return 0; 864 } 865 866 if (!cfg80211_chandef_valid(¶ms->chandef)) { 867 pr_err("%s: invalid channel\n", dev->name); 868 return -EINVAL; 869 } 870 871 if (cfg80211_chandef_identical(¶ms->chandef, &mac->chandef)) { 872 pr_err("%s: switch request to the same channel\n", dev->name); 873 return -EALREADY; 874 } 875 876 ret = qtnf_cmd_send_chan_switch(mac, params); 877 if (ret) 878 pr_warn("%s: failed to switch to channel (%u)\n", 879 dev->name, params->chandef.chan->hw_value); 880 881 return ret; 882 } 883 884 static struct cfg80211_ops qtn_cfg80211_ops = { 885 .add_virtual_intf = qtnf_add_virtual_intf, 886 .change_virtual_intf = qtnf_change_virtual_intf, 887 .del_virtual_intf = qtnf_del_virtual_intf, 888 .start_ap = qtnf_start_ap, 889 .change_beacon = qtnf_change_beacon, 890 .stop_ap = qtnf_stop_ap, 891 .set_wiphy_params = qtnf_set_wiphy_params, 892 .mgmt_frame_register = qtnf_mgmt_frame_register, 893 .mgmt_tx = qtnf_mgmt_tx, 894 .change_station = qtnf_change_station, 895 .del_station = qtnf_del_station, 896 .get_station = qtnf_get_station, 897 .dump_station = qtnf_dump_station, 898 .add_key = qtnf_add_key, 899 .del_key = qtnf_del_key, 900 .set_default_key = qtnf_set_default_key, 901 .set_default_mgmt_key = qtnf_set_default_mgmt_key, 902 .scan = qtnf_scan, 903 .connect = qtnf_connect, 904 .disconnect = qtnf_disconnect, 905 .dump_survey = qtnf_dump_survey, 906 .get_channel = qtnf_get_channel, 907 .channel_switch = qtnf_channel_switch 908 }; 909 910 static void qtnf_cfg80211_reg_notifier(struct wiphy *wiphy_in, 911 struct regulatory_request *req) 912 { 913 struct qtnf_wmac *mac = wiphy_priv(wiphy_in); 914 struct qtnf_bus *bus = mac->bus; 915 struct wiphy *wiphy; 916 unsigned int mac_idx; 917 enum nl80211_band band; 918 int ret; 919 920 pr_debug("MAC%u: initiator=%d alpha=%c%c\n", mac->macid, req->initiator, 921 req->alpha2[0], req->alpha2[1]); 922 923 ret = qtnf_cmd_reg_notify(bus, req); 924 if (ret) { 925 if (ret != -EOPNOTSUPP && ret != -EALREADY) 926 pr_err("failed to update reg domain to %c%c\n", 927 req->alpha2[0], req->alpha2[1]); 928 return; 929 } 930 931 for (mac_idx = 0; mac_idx < QTNF_MAX_MAC; ++mac_idx) { 932 if (!(bus->hw_info.mac_bitmap & (1 << mac_idx))) 933 continue; 934 935 mac = bus->mac[mac_idx]; 936 wiphy = priv_to_wiphy(mac); 937 938 for (band = 0; band < NUM_NL80211_BANDS; ++band) { 939 if (!wiphy->bands[band]) 940 continue; 941 942 ret = qtnf_cmd_get_mac_chan_info(mac, 943 wiphy->bands[band]); 944 if (ret) 945 pr_err("failed to get chan info for mac %u band %u\n", 946 mac_idx, band); 947 } 948 } 949 } 950 951 void qtnf_band_setup_htvht_caps(struct qtnf_mac_info *macinfo, 952 struct ieee80211_supported_band *band) 953 { 954 struct ieee80211_sta_ht_cap *ht_cap; 955 struct ieee80211_sta_vht_cap *vht_cap; 956 957 ht_cap = &band->ht_cap; 958 ht_cap->ht_supported = true; 959 memcpy(&ht_cap->cap, &macinfo->ht_cap.cap_info, 960 sizeof(u16)); 961 ht_cap->ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K; 962 ht_cap->ampdu_density = IEEE80211_HT_MPDU_DENSITY_NONE; 963 memcpy(&ht_cap->mcs, &macinfo->ht_cap.mcs, 964 sizeof(ht_cap->mcs)); 965 966 if (macinfo->phymode_cap & QLINK_PHYMODE_AC) { 967 vht_cap = &band->vht_cap; 968 vht_cap->vht_supported = true; 969 memcpy(&vht_cap->cap, 970 &macinfo->vht_cap.vht_cap_info, sizeof(u32)); 971 /* Update MCS support for VHT */ 972 memcpy(&vht_cap->vht_mcs, 973 &macinfo->vht_cap.supp_mcs, 974 sizeof(struct ieee80211_vht_mcs_info)); 975 } 976 } 977 978 struct wiphy *qtnf_wiphy_allocate(struct qtnf_bus *bus) 979 { 980 struct wiphy *wiphy; 981 982 wiphy = wiphy_new(&qtn_cfg80211_ops, sizeof(struct qtnf_wmac)); 983 if (!wiphy) 984 return NULL; 985 986 set_wiphy_dev(wiphy, bus->dev); 987 988 return wiphy; 989 } 990 991 static int qtnf_wiphy_setup_if_comb(struct wiphy *wiphy, 992 struct ieee80211_iface_combination *if_comb, 993 const struct qtnf_mac_info *mac_info) 994 { 995 size_t max_interfaces = 0; 996 u16 interface_modes = 0; 997 size_t i; 998 999 if (unlikely(!mac_info->limits || !mac_info->n_limits)) 1000 return -ENOENT; 1001 1002 if_comb->limits = mac_info->limits; 1003 if_comb->n_limits = mac_info->n_limits; 1004 1005 for (i = 0; i < mac_info->n_limits; i++) { 1006 max_interfaces += mac_info->limits[i].max; 1007 interface_modes |= mac_info->limits[i].types; 1008 } 1009 1010 if_comb->num_different_channels = 1; 1011 if_comb->beacon_int_infra_match = true; 1012 if_comb->max_interfaces = max_interfaces; 1013 if_comb->radar_detect_widths = mac_info->radar_detect_widths; 1014 wiphy->interface_modes = interface_modes; 1015 1016 return 0; 1017 } 1018 1019 int qtnf_wiphy_register(struct qtnf_hw_info *hw_info, struct qtnf_wmac *mac) 1020 { 1021 struct wiphy *wiphy = priv_to_wiphy(mac); 1022 struct ieee80211_iface_combination *iface_comb = NULL; 1023 int ret; 1024 1025 if (!wiphy) { 1026 pr_err("invalid wiphy pointer\n"); 1027 return -EFAULT; 1028 } 1029 1030 iface_comb = kzalloc(sizeof(*iface_comb), GFP_KERNEL); 1031 if (!iface_comb) 1032 return -ENOMEM; 1033 1034 ret = qtnf_wiphy_setup_if_comb(wiphy, iface_comb, &mac->macinfo); 1035 if (ret) 1036 goto out; 1037 1038 pr_info("MAC%u: phymode=%#x radar=%#x\n", mac->macid, 1039 mac->macinfo.phymode_cap, mac->macinfo.radar_detect_widths); 1040 1041 wiphy->frag_threshold = mac->macinfo.frag_thr; 1042 wiphy->rts_threshold = mac->macinfo.rts_thr; 1043 wiphy->retry_short = mac->macinfo.sretry_limit; 1044 wiphy->retry_long = mac->macinfo.lretry_limit; 1045 wiphy->coverage_class = mac->macinfo.coverage_class; 1046 1047 wiphy->max_scan_ssids = QTNF_MAX_SSID_LIST_LENGTH; 1048 wiphy->max_scan_ie_len = QTNF_MAX_VSIE_LEN; 1049 wiphy->mgmt_stypes = qtnf_mgmt_stypes; 1050 wiphy->max_remain_on_channel_duration = 5000; 1051 1052 wiphy->iface_combinations = iface_comb; 1053 wiphy->n_iface_combinations = 1; 1054 wiphy->max_num_csa_counters = 2; 1055 1056 /* Initialize cipher suits */ 1057 wiphy->cipher_suites = qtnf_cipher_suites; 1058 wiphy->n_cipher_suites = ARRAY_SIZE(qtnf_cipher_suites); 1059 wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM; 1060 wiphy->flags |= WIPHY_FLAG_HAVE_AP_SME | 1061 WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD | 1062 WIPHY_FLAG_AP_UAPSD | 1063 WIPHY_FLAG_HAS_CHANNEL_SWITCH; 1064 1065 wiphy->probe_resp_offload = NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS | 1066 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2; 1067 1068 wiphy->available_antennas_tx = mac->macinfo.num_tx_chain; 1069 wiphy->available_antennas_rx = mac->macinfo.num_rx_chain; 1070 1071 wiphy->max_ap_assoc_sta = mac->macinfo.max_ap_assoc_sta; 1072 1073 ether_addr_copy(wiphy->perm_addr, mac->macaddr); 1074 1075 if (hw_info->hw_capab & QLINK_HW_SUPPORTS_REG_UPDATE) { 1076 wiphy->regulatory_flags |= REGULATORY_STRICT_REG | 1077 REGULATORY_CUSTOM_REG; 1078 wiphy->reg_notifier = qtnf_cfg80211_reg_notifier; 1079 wiphy_apply_custom_regulatory(wiphy, hw_info->rd); 1080 } else { 1081 wiphy->regulatory_flags |= REGULATORY_WIPHY_SELF_MANAGED; 1082 } 1083 1084 ret = wiphy_register(wiphy); 1085 if (ret < 0) 1086 goto out; 1087 1088 if (wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED) 1089 ret = regulatory_set_wiphy_regd(wiphy, hw_info->rd); 1090 else if (isalpha(hw_info->rd->alpha2[0]) && 1091 isalpha(hw_info->rd->alpha2[1])) 1092 ret = regulatory_hint(wiphy, hw_info->rd->alpha2); 1093 1094 out: 1095 if (ret) { 1096 kfree(iface_comb); 1097 return ret; 1098 } 1099 1100 return 0; 1101 } 1102 1103 void qtnf_netdev_updown(struct net_device *ndev, bool up) 1104 { 1105 struct qtnf_vif *vif = qtnf_netdev_get_priv(ndev); 1106 1107 if (qtnf_cmd_send_updown_intf(vif, up)) 1108 pr_err("failed to send up/down command to FW\n"); 1109 } 1110 1111 void qtnf_virtual_intf_cleanup(struct net_device *ndev) 1112 { 1113 struct qtnf_vif *vif = qtnf_netdev_get_priv(ndev); 1114 struct qtnf_wmac *mac = wiphy_priv(vif->wdev.wiphy); 1115 1116 if (vif->wdev.iftype == NL80211_IFTYPE_STATION) { 1117 switch (vif->sta_state) { 1118 case QTNF_STA_DISCONNECTED: 1119 break; 1120 case QTNF_STA_CONNECTING: 1121 cfg80211_connect_result(vif->netdev, 1122 vif->bss_cfg.bssid, NULL, 0, 1123 NULL, 0, 1124 WLAN_STATUS_UNSPECIFIED_FAILURE, 1125 GFP_KERNEL); 1126 qtnf_disconnect(vif->wdev.wiphy, ndev, 1127 WLAN_REASON_DEAUTH_LEAVING); 1128 break; 1129 case QTNF_STA_CONNECTED: 1130 cfg80211_disconnected(vif->netdev, 1131 WLAN_REASON_DEAUTH_LEAVING, 1132 NULL, 0, 1, GFP_KERNEL); 1133 qtnf_disconnect(vif->wdev.wiphy, ndev, 1134 WLAN_REASON_DEAUTH_LEAVING); 1135 break; 1136 } 1137 1138 vif->sta_state = QTNF_STA_DISCONNECTED; 1139 } 1140 1141 qtnf_scan_done(mac, true); 1142 } 1143 1144 void qtnf_cfg80211_vif_reset(struct qtnf_vif *vif) 1145 { 1146 if (vif->wdev.iftype == NL80211_IFTYPE_STATION) { 1147 switch (vif->sta_state) { 1148 case QTNF_STA_CONNECTING: 1149 cfg80211_connect_result(vif->netdev, 1150 vif->bss_cfg.bssid, NULL, 0, 1151 NULL, 0, 1152 WLAN_STATUS_UNSPECIFIED_FAILURE, 1153 GFP_KERNEL); 1154 break; 1155 case QTNF_STA_CONNECTED: 1156 cfg80211_disconnected(vif->netdev, 1157 WLAN_REASON_DEAUTH_LEAVING, 1158 NULL, 0, 1, GFP_KERNEL); 1159 break; 1160 case QTNF_STA_DISCONNECTED: 1161 break; 1162 } 1163 } 1164 1165 cfg80211_shutdown_all_interfaces(vif->wdev.wiphy); 1166 vif->sta_state = QTNF_STA_DISCONNECTED; 1167 } 1168 1169 void qtnf_band_init_rates(struct ieee80211_supported_band *band) 1170 { 1171 switch (band->band) { 1172 case NL80211_BAND_2GHZ: 1173 band->bitrates = qtnf_rates_2g; 1174 band->n_bitrates = ARRAY_SIZE(qtnf_rates_2g); 1175 break; 1176 case NL80211_BAND_5GHZ: 1177 band->bitrates = qtnf_rates_5g; 1178 band->n_bitrates = ARRAY_SIZE(qtnf_rates_5g); 1179 break; 1180 default: 1181 band->bitrates = NULL; 1182 band->n_bitrates = 0; 1183 break; 1184 } 1185 } 1186