1 // SPDX-License-Identifier: GPL-2.0+ 2 /* Copyright (c) 2015-2016 Quantenna Communications. All rights reserved. */ 3 4 #include <linux/kernel.h> 5 #include <linux/module.h> 6 #include <linux/if_ether.h> 7 8 #include "core.h" 9 #include "bus.h" 10 #include "trans.h" 11 #include "commands.h" 12 #include "cfg80211.h" 13 #include "event.h" 14 #include "util.h" 15 16 #define QTNF_DMP_MAX_LEN 48 17 #define QTNF_PRIMARY_VIF_IDX 0 18 19 static bool slave_radar = true; 20 module_param(slave_radar, bool, 0644); 21 MODULE_PARM_DESC(slave_radar, "set 0 to disable radar detection in slave mode"); 22 23 static struct dentry *qtnf_debugfs_dir; 24 25 struct qtnf_frame_meta_info { 26 u8 magic_s; 27 u8 ifidx; 28 u8 macid; 29 u8 magic_e; 30 } __packed; 31 32 struct qtnf_wmac *qtnf_core_get_mac(const struct qtnf_bus *bus, u8 macid) 33 { 34 struct qtnf_wmac *mac = NULL; 35 36 if (unlikely(macid >= QTNF_MAX_MAC)) { 37 pr_err("invalid MAC index %u\n", macid); 38 return NULL; 39 } 40 41 mac = bus->mac[macid]; 42 43 if (unlikely(!mac)) { 44 pr_err("MAC%u: not initialized\n", macid); 45 return NULL; 46 } 47 48 return mac; 49 } 50 51 /* Netdev handler for open. 52 */ 53 static int qtnf_netdev_open(struct net_device *ndev) 54 { 55 netif_carrier_off(ndev); 56 qtnf_netdev_updown(ndev, 1); 57 return 0; 58 } 59 60 /* Netdev handler for close. 61 */ 62 static int qtnf_netdev_close(struct net_device *ndev) 63 { 64 netif_carrier_off(ndev); 65 qtnf_virtual_intf_cleanup(ndev); 66 qtnf_netdev_updown(ndev, 0); 67 return 0; 68 } 69 70 /* Netdev handler for data transmission. 71 */ 72 static netdev_tx_t 73 qtnf_netdev_hard_start_xmit(struct sk_buff *skb, struct net_device *ndev) 74 { 75 struct qtnf_vif *vif; 76 struct qtnf_wmac *mac; 77 78 vif = qtnf_netdev_get_priv(ndev); 79 80 if (unlikely(skb->dev != ndev)) { 81 pr_err_ratelimited("invalid skb->dev"); 82 dev_kfree_skb_any(skb); 83 return 0; 84 } 85 86 if (unlikely(vif->wdev.iftype == NL80211_IFTYPE_UNSPECIFIED)) { 87 pr_err_ratelimited("%s: VIF not initialized\n", ndev->name); 88 dev_kfree_skb_any(skb); 89 return 0; 90 } 91 92 mac = vif->mac; 93 if (unlikely(!mac)) { 94 pr_err_ratelimited("%s: NULL mac pointer", ndev->name); 95 dev_kfree_skb_any(skb); 96 return 0; 97 } 98 99 if (!skb->len || (skb->len > ETH_FRAME_LEN)) { 100 pr_err_ratelimited("%s: invalid skb len %d\n", ndev->name, 101 skb->len); 102 dev_kfree_skb_any(skb); 103 ndev->stats.tx_dropped++; 104 return 0; 105 } 106 107 /* tx path is enabled: reset vif timeout */ 108 vif->cons_tx_timeout_cnt = 0; 109 110 return qtnf_bus_data_tx(mac->bus, skb); 111 } 112 113 /* Netdev handler for getting stats. 114 */ 115 static void qtnf_netdev_get_stats64(struct net_device *ndev, 116 struct rtnl_link_stats64 *stats) 117 { 118 struct qtnf_vif *vif = qtnf_netdev_get_priv(ndev); 119 unsigned int start; 120 int cpu; 121 122 netdev_stats_to_stats64(stats, &ndev->stats); 123 124 if (!vif->stats64) 125 return; 126 127 for_each_possible_cpu(cpu) { 128 struct pcpu_sw_netstats *stats64; 129 u64 rx_packets, rx_bytes; 130 u64 tx_packets, tx_bytes; 131 132 stats64 = per_cpu_ptr(vif->stats64, cpu); 133 134 do { 135 start = u64_stats_fetch_begin_irq(&stats64->syncp); 136 rx_packets = stats64->rx_packets; 137 rx_bytes = stats64->rx_bytes; 138 tx_packets = stats64->tx_packets; 139 tx_bytes = stats64->tx_bytes; 140 } while (u64_stats_fetch_retry_irq(&stats64->syncp, start)); 141 142 stats->rx_packets += rx_packets; 143 stats->rx_bytes += rx_bytes; 144 stats->tx_packets += tx_packets; 145 stats->tx_bytes += tx_bytes; 146 } 147 } 148 149 /* Netdev handler for transmission timeout. 150 */ 151 static void qtnf_netdev_tx_timeout(struct net_device *ndev) 152 { 153 struct qtnf_vif *vif = qtnf_netdev_get_priv(ndev); 154 struct qtnf_wmac *mac; 155 struct qtnf_bus *bus; 156 157 if (unlikely(!vif || !vif->mac || !vif->mac->bus)) 158 return; 159 160 mac = vif->mac; 161 bus = mac->bus; 162 163 pr_warn("VIF%u.%u: Tx timeout- %lu\n", mac->macid, vif->vifid, jiffies); 164 165 qtnf_bus_data_tx_timeout(bus, ndev); 166 ndev->stats.tx_errors++; 167 168 if (++vif->cons_tx_timeout_cnt > QTNF_TX_TIMEOUT_TRSHLD) { 169 pr_err("Tx timeout threshold exceeded !\n"); 170 pr_err("schedule interface %s reset !\n", netdev_name(ndev)); 171 queue_work(bus->workqueue, &vif->reset_work); 172 } 173 } 174 175 static int qtnf_netdev_set_mac_address(struct net_device *ndev, void *addr) 176 { 177 struct qtnf_vif *vif = qtnf_netdev_get_priv(ndev); 178 struct sockaddr *sa = addr; 179 int ret; 180 unsigned char old_addr[ETH_ALEN]; 181 182 memcpy(old_addr, sa->sa_data, sizeof(old_addr)); 183 184 ret = eth_mac_addr(ndev, sa); 185 if (ret) 186 return ret; 187 188 qtnf_scan_done(vif->mac, true); 189 190 ret = qtnf_cmd_send_change_intf_type(vif, vif->wdev.iftype, 191 vif->wdev.use_4addr, 192 sa->sa_data); 193 194 if (ret) 195 memcpy(ndev->dev_addr, old_addr, ETH_ALEN); 196 197 return ret; 198 } 199 200 /* Network device ops handlers */ 201 const struct net_device_ops qtnf_netdev_ops = { 202 .ndo_open = qtnf_netdev_open, 203 .ndo_stop = qtnf_netdev_close, 204 .ndo_start_xmit = qtnf_netdev_hard_start_xmit, 205 .ndo_tx_timeout = qtnf_netdev_tx_timeout, 206 .ndo_get_stats64 = qtnf_netdev_get_stats64, 207 .ndo_set_mac_address = qtnf_netdev_set_mac_address, 208 }; 209 210 static int qtnf_mac_init_single_band(struct wiphy *wiphy, 211 struct qtnf_wmac *mac, 212 enum nl80211_band band) 213 { 214 int ret; 215 216 wiphy->bands[band] = kzalloc(sizeof(*wiphy->bands[band]), GFP_KERNEL); 217 if (!wiphy->bands[band]) 218 return -ENOMEM; 219 220 wiphy->bands[band]->band = band; 221 222 ret = qtnf_cmd_band_info_get(mac, wiphy->bands[band]); 223 if (ret) { 224 pr_err("MAC%u: band %u: failed to get chans info: %d\n", 225 mac->macid, band, ret); 226 return ret; 227 } 228 229 qtnf_band_init_rates(wiphy->bands[band]); 230 231 return 0; 232 } 233 234 static int qtnf_mac_init_bands(struct qtnf_wmac *mac) 235 { 236 struct wiphy *wiphy = priv_to_wiphy(mac); 237 int ret = 0; 238 239 if (mac->macinfo.bands_cap & QLINK_BAND_2GHZ) { 240 ret = qtnf_mac_init_single_band(wiphy, mac, NL80211_BAND_2GHZ); 241 if (ret) 242 goto out; 243 } 244 245 if (mac->macinfo.bands_cap & QLINK_BAND_5GHZ) { 246 ret = qtnf_mac_init_single_band(wiphy, mac, NL80211_BAND_5GHZ); 247 if (ret) 248 goto out; 249 } 250 251 if (mac->macinfo.bands_cap & QLINK_BAND_60GHZ) 252 ret = qtnf_mac_init_single_band(wiphy, mac, NL80211_BAND_60GHZ); 253 254 out: 255 return ret; 256 } 257 258 struct qtnf_vif *qtnf_mac_get_free_vif(struct qtnf_wmac *mac) 259 { 260 struct qtnf_vif *vif; 261 int i; 262 263 for (i = 0; i < QTNF_MAX_INTF; i++) { 264 vif = &mac->iflist[i]; 265 if (vif->wdev.iftype == NL80211_IFTYPE_UNSPECIFIED) 266 return vif; 267 } 268 269 return NULL; 270 } 271 272 struct qtnf_vif *qtnf_mac_get_base_vif(struct qtnf_wmac *mac) 273 { 274 struct qtnf_vif *vif; 275 276 vif = &mac->iflist[QTNF_PRIMARY_VIF_IDX]; 277 278 if (vif->wdev.iftype == NL80211_IFTYPE_UNSPECIFIED) 279 return NULL; 280 281 return vif; 282 } 283 284 void qtnf_mac_iface_comb_free(struct qtnf_wmac *mac) 285 { 286 struct ieee80211_iface_combination *comb; 287 int i; 288 289 if (mac->macinfo.if_comb) { 290 for (i = 0; i < mac->macinfo.n_if_comb; i++) { 291 comb = &mac->macinfo.if_comb[i]; 292 kfree(comb->limits); 293 comb->limits = NULL; 294 } 295 296 kfree(mac->macinfo.if_comb); 297 mac->macinfo.if_comb = NULL; 298 } 299 } 300 301 void qtnf_mac_ext_caps_free(struct qtnf_wmac *mac) 302 { 303 if (mac->macinfo.extended_capabilities_len) { 304 kfree(mac->macinfo.extended_capabilities); 305 mac->macinfo.extended_capabilities = NULL; 306 307 kfree(mac->macinfo.extended_capabilities_mask); 308 mac->macinfo.extended_capabilities_mask = NULL; 309 310 mac->macinfo.extended_capabilities_len = 0; 311 } 312 } 313 314 static void qtnf_vif_reset_handler(struct work_struct *work) 315 { 316 struct qtnf_vif *vif = container_of(work, struct qtnf_vif, reset_work); 317 318 rtnl_lock(); 319 320 if (vif->wdev.iftype == NL80211_IFTYPE_UNSPECIFIED) { 321 rtnl_unlock(); 322 return; 323 } 324 325 /* stop tx completely */ 326 netif_tx_stop_all_queues(vif->netdev); 327 if (netif_carrier_ok(vif->netdev)) 328 netif_carrier_off(vif->netdev); 329 330 qtnf_cfg80211_vif_reset(vif); 331 332 rtnl_unlock(); 333 } 334 335 static void qtnf_mac_init_primary_intf(struct qtnf_wmac *mac) 336 { 337 struct qtnf_vif *vif = &mac->iflist[QTNF_PRIMARY_VIF_IDX]; 338 339 vif->wdev.iftype = NL80211_IFTYPE_STATION; 340 vif->bss_priority = QTNF_DEF_BSS_PRIORITY; 341 vif->wdev.wiphy = priv_to_wiphy(mac); 342 INIT_WORK(&vif->reset_work, qtnf_vif_reset_handler); 343 vif->cons_tx_timeout_cnt = 0; 344 } 345 346 static void qtnf_mac_scan_finish(struct qtnf_wmac *mac, bool aborted) 347 { 348 struct cfg80211_scan_info info = { 349 .aborted = aborted, 350 }; 351 352 mutex_lock(&mac->mac_lock); 353 354 if (mac->scan_req) { 355 cfg80211_scan_done(mac->scan_req, &info); 356 mac->scan_req = NULL; 357 } 358 359 mutex_unlock(&mac->mac_lock); 360 } 361 362 void qtnf_scan_done(struct qtnf_wmac *mac, bool aborted) 363 { 364 cancel_delayed_work_sync(&mac->scan_timeout); 365 qtnf_mac_scan_finish(mac, aborted); 366 } 367 368 static void qtnf_mac_scan_timeout(struct work_struct *work) 369 { 370 struct qtnf_wmac *mac = 371 container_of(work, struct qtnf_wmac, scan_timeout.work); 372 373 pr_warn("MAC%d: scan timed out\n", mac->macid); 374 qtnf_mac_scan_finish(mac, true); 375 } 376 377 static void qtnf_vif_send_data_high_pri(struct work_struct *work) 378 { 379 struct qtnf_vif *vif = 380 container_of(work, struct qtnf_vif, high_pri_tx_work); 381 struct sk_buff *skb; 382 383 if (!vif->netdev || 384 vif->wdev.iftype == NL80211_IFTYPE_UNSPECIFIED) 385 return; 386 387 while ((skb = skb_dequeue(&vif->high_pri_tx_queue))) { 388 qtnf_cmd_send_frame(vif, 0, QLINK_FRAME_TX_FLAG_8023, 389 0, skb->data, skb->len); 390 dev_kfree_skb_any(skb); 391 } 392 } 393 394 static struct qtnf_wmac *qtnf_core_mac_alloc(struct qtnf_bus *bus, 395 unsigned int macid) 396 { 397 struct qtnf_vif *vif; 398 struct wiphy *wiphy; 399 struct qtnf_wmac *mac; 400 unsigned int i; 401 402 wiphy = qtnf_wiphy_allocate(bus); 403 if (!wiphy) 404 return ERR_PTR(-ENOMEM); 405 406 mac = wiphy_priv(wiphy); 407 408 mac->macid = macid; 409 mac->bus = bus; 410 mutex_init(&mac->mac_lock); 411 INIT_DELAYED_WORK(&mac->scan_timeout, qtnf_mac_scan_timeout); 412 413 for (i = 0; i < QTNF_MAX_INTF; i++) { 414 vif = &mac->iflist[i]; 415 416 memset(vif, 0, sizeof(*vif)); 417 vif->wdev.iftype = NL80211_IFTYPE_UNSPECIFIED; 418 vif->mac = mac; 419 vif->vifid = i; 420 qtnf_sta_list_init(&vif->sta_list); 421 INIT_WORK(&vif->high_pri_tx_work, qtnf_vif_send_data_high_pri); 422 skb_queue_head_init(&vif->high_pri_tx_queue); 423 vif->stats64 = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats); 424 if (!vif->stats64) 425 pr_warn("VIF%u.%u: per cpu stats allocation failed\n", 426 macid, i); 427 } 428 429 qtnf_mac_init_primary_intf(mac); 430 bus->mac[macid] = mac; 431 432 return mac; 433 } 434 435 bool qtnf_mac_slave_radar_get(struct wiphy *wiphy) 436 { 437 return slave_radar; 438 } 439 440 static const struct ethtool_ops qtnf_ethtool_ops = { 441 .get_drvinfo = cfg80211_get_drvinfo, 442 }; 443 444 int qtnf_core_net_attach(struct qtnf_wmac *mac, struct qtnf_vif *vif, 445 const char *name, unsigned char name_assign_type) 446 { 447 struct wiphy *wiphy = priv_to_wiphy(mac); 448 struct net_device *dev; 449 void *qdev_vif; 450 int ret; 451 452 dev = alloc_netdev_mqs(sizeof(struct qtnf_vif *), name, 453 name_assign_type, ether_setup, 1, 1); 454 if (!dev) { 455 vif->wdev.iftype = NL80211_IFTYPE_UNSPECIFIED; 456 return -ENOMEM; 457 } 458 459 vif->netdev = dev; 460 461 dev->netdev_ops = &qtnf_netdev_ops; 462 dev->needs_free_netdev = true; 463 dev_net_set(dev, wiphy_net(wiphy)); 464 dev->ieee80211_ptr = &vif->wdev; 465 ether_addr_copy(dev->dev_addr, vif->mac_addr); 466 SET_NETDEV_DEV(dev, wiphy_dev(wiphy)); 467 dev->flags |= IFF_BROADCAST | IFF_MULTICAST; 468 dev->watchdog_timeo = QTNF_DEF_WDOG_TIMEOUT; 469 dev->tx_queue_len = 100; 470 dev->ethtool_ops = &qtnf_ethtool_ops; 471 472 qdev_vif = netdev_priv(dev); 473 *((void **)qdev_vif) = vif; 474 475 SET_NETDEV_DEV(dev, mac->bus->dev); 476 477 ret = register_netdevice(dev); 478 if (ret) { 479 free_netdev(dev); 480 vif->wdev.iftype = NL80211_IFTYPE_UNSPECIFIED; 481 } 482 483 return ret; 484 } 485 486 static void qtnf_core_mac_detach(struct qtnf_bus *bus, unsigned int macid) 487 { 488 struct qtnf_wmac *mac; 489 struct wiphy *wiphy; 490 struct qtnf_vif *vif; 491 unsigned int i; 492 enum nl80211_band band; 493 494 mac = bus->mac[macid]; 495 496 if (!mac) 497 return; 498 499 wiphy = priv_to_wiphy(mac); 500 501 for (i = 0; i < QTNF_MAX_INTF; i++) { 502 vif = &mac->iflist[i]; 503 rtnl_lock(); 504 if (vif->netdev && 505 vif->wdev.iftype != NL80211_IFTYPE_UNSPECIFIED) { 506 qtnf_virtual_intf_cleanup(vif->netdev); 507 qtnf_del_virtual_intf(wiphy, &vif->wdev); 508 } 509 rtnl_unlock(); 510 qtnf_sta_list_free(&vif->sta_list); 511 free_percpu(vif->stats64); 512 } 513 514 if (mac->wiphy_registered) 515 wiphy_unregister(wiphy); 516 517 for (band = NL80211_BAND_2GHZ; band < NUM_NL80211_BANDS; ++band) { 518 if (!wiphy->bands[band]) 519 continue; 520 521 kfree(wiphy->bands[band]->channels); 522 wiphy->bands[band]->n_channels = 0; 523 524 kfree(wiphy->bands[band]); 525 wiphy->bands[band] = NULL; 526 } 527 528 qtnf_mac_iface_comb_free(mac); 529 qtnf_mac_ext_caps_free(mac); 530 kfree(mac->macinfo.wowlan); 531 kfree(mac->rd); 532 mac->rd = NULL; 533 wiphy_free(wiphy); 534 bus->mac[macid] = NULL; 535 } 536 537 static int qtnf_core_mac_attach(struct qtnf_bus *bus, unsigned int macid) 538 { 539 struct qtnf_wmac *mac; 540 struct qtnf_vif *vif; 541 int ret; 542 543 if (!(bus->hw_info.mac_bitmap & BIT(macid))) { 544 pr_info("MAC%u is not active in FW\n", macid); 545 return 0; 546 } 547 548 mac = qtnf_core_mac_alloc(bus, macid); 549 if (IS_ERR(mac)) { 550 pr_err("MAC%u allocation failed\n", macid); 551 return PTR_ERR(mac); 552 } 553 554 ret = qtnf_cmd_get_mac_info(mac); 555 if (ret) { 556 pr_err("MAC%u: failed to get info\n", macid); 557 goto error; 558 } 559 560 vif = qtnf_mac_get_base_vif(mac); 561 if (!vif) { 562 pr_err("MAC%u: primary VIF is not ready\n", macid); 563 ret = -EFAULT; 564 goto error; 565 } 566 567 ret = qtnf_cmd_send_add_intf(vif, vif->wdev.iftype, 568 vif->wdev.use_4addr, vif->mac_addr); 569 if (ret) { 570 pr_err("MAC%u: failed to add VIF\n", macid); 571 goto error; 572 } 573 574 ret = qtnf_cmd_send_get_phy_params(mac); 575 if (ret) { 576 pr_err("MAC%u: failed to get PHY settings\n", macid); 577 goto error; 578 } 579 580 ret = qtnf_mac_init_bands(mac); 581 if (ret) { 582 pr_err("MAC%u: failed to init bands\n", macid); 583 goto error; 584 } 585 586 ret = qtnf_wiphy_register(&bus->hw_info, mac); 587 if (ret) { 588 pr_err("MAC%u: wiphy registration failed\n", macid); 589 goto error; 590 } 591 592 mac->wiphy_registered = 1; 593 594 rtnl_lock(); 595 596 ret = qtnf_core_net_attach(mac, vif, "wlan%d", NET_NAME_ENUM); 597 rtnl_unlock(); 598 599 if (ret) { 600 pr_err("MAC%u: failed to attach netdev\n", macid); 601 vif->wdev.iftype = NL80211_IFTYPE_UNSPECIFIED; 602 vif->netdev = NULL; 603 goto error; 604 } 605 606 pr_debug("MAC%u initialized\n", macid); 607 608 return 0; 609 610 error: 611 qtnf_core_mac_detach(bus, macid); 612 return ret; 613 } 614 615 int qtnf_core_attach(struct qtnf_bus *bus) 616 { 617 unsigned int i; 618 int ret; 619 620 qtnf_trans_init(bus); 621 qtnf_bus_data_rx_start(bus); 622 623 bus->workqueue = alloc_ordered_workqueue("QTNF_BUS", 0); 624 if (!bus->workqueue) { 625 pr_err("failed to alloc main workqueue\n"); 626 ret = -ENOMEM; 627 goto error; 628 } 629 630 bus->hprio_workqueue = alloc_workqueue("QTNF_HPRI", WQ_HIGHPRI, 0); 631 if (!bus->hprio_workqueue) { 632 pr_err("failed to alloc high prio workqueue\n"); 633 ret = -ENOMEM; 634 goto error; 635 } 636 637 INIT_WORK(&bus->event_work, qtnf_event_work_handler); 638 639 ret = qtnf_cmd_send_init_fw(bus); 640 if (ret) { 641 pr_err("failed to init FW: %d\n", ret); 642 goto error; 643 } 644 645 bus->fw_state = QTNF_FW_STATE_ACTIVE; 646 ret = qtnf_cmd_get_hw_info(bus); 647 if (ret) { 648 pr_err("failed to get HW info: %d\n", ret); 649 goto error; 650 } 651 652 if (bus->hw_info.ql_proto_ver != QLINK_PROTO_VER) { 653 pr_err("qlink version mismatch %u != %u\n", 654 QLINK_PROTO_VER, bus->hw_info.ql_proto_ver); 655 ret = -EPROTONOSUPPORT; 656 goto error; 657 } 658 659 if (bus->hw_info.num_mac > QTNF_MAX_MAC) { 660 pr_err("no support for number of MACs=%u\n", 661 bus->hw_info.num_mac); 662 ret = -ERANGE; 663 goto error; 664 } 665 666 for (i = 0; i < bus->hw_info.num_mac; i++) { 667 ret = qtnf_core_mac_attach(bus, i); 668 669 if (ret) { 670 pr_err("MAC%u: attach failed: %d\n", i, ret); 671 goto error; 672 } 673 } 674 675 bus->fw_state = QTNF_FW_STATE_RUNNING; 676 return 0; 677 678 error: 679 qtnf_core_detach(bus); 680 return ret; 681 } 682 EXPORT_SYMBOL_GPL(qtnf_core_attach); 683 684 void qtnf_core_detach(struct qtnf_bus *bus) 685 { 686 unsigned int macid; 687 688 qtnf_bus_data_rx_stop(bus); 689 690 for (macid = 0; macid < QTNF_MAX_MAC; macid++) 691 qtnf_core_mac_detach(bus, macid); 692 693 if (qtnf_fw_is_up(bus)) 694 qtnf_cmd_send_deinit_fw(bus); 695 696 bus->fw_state = QTNF_FW_STATE_DETACHED; 697 698 if (bus->workqueue) { 699 flush_workqueue(bus->workqueue); 700 destroy_workqueue(bus->workqueue); 701 bus->workqueue = NULL; 702 } 703 704 if (bus->hprio_workqueue) { 705 flush_workqueue(bus->hprio_workqueue); 706 destroy_workqueue(bus->hprio_workqueue); 707 bus->hprio_workqueue = NULL; 708 } 709 710 qtnf_trans_free(bus); 711 } 712 EXPORT_SYMBOL_GPL(qtnf_core_detach); 713 714 static inline int qtnf_is_frame_meta_magic_valid(struct qtnf_frame_meta_info *m) 715 { 716 return m->magic_s == 0xAB && m->magic_e == 0xBA; 717 } 718 719 struct net_device *qtnf_classify_skb(struct qtnf_bus *bus, struct sk_buff *skb) 720 { 721 struct qtnf_frame_meta_info *meta; 722 struct net_device *ndev = NULL; 723 struct qtnf_wmac *mac; 724 struct qtnf_vif *vif; 725 726 if (unlikely(bus->fw_state != QTNF_FW_STATE_RUNNING)) 727 return NULL; 728 729 meta = (struct qtnf_frame_meta_info *) 730 (skb_tail_pointer(skb) - sizeof(*meta)); 731 732 if (unlikely(!qtnf_is_frame_meta_magic_valid(meta))) { 733 pr_err_ratelimited("invalid magic 0x%x:0x%x\n", 734 meta->magic_s, meta->magic_e); 735 goto out; 736 } 737 738 if (unlikely(meta->macid >= QTNF_MAX_MAC)) { 739 pr_err_ratelimited("invalid mac(%u)\n", meta->macid); 740 goto out; 741 } 742 743 if (unlikely(meta->ifidx >= QTNF_MAX_INTF)) { 744 pr_err_ratelimited("invalid vif(%u)\n", meta->ifidx); 745 goto out; 746 } 747 748 mac = bus->mac[meta->macid]; 749 750 if (unlikely(!mac)) { 751 pr_err_ratelimited("mac(%d) does not exist\n", meta->macid); 752 goto out; 753 } 754 755 vif = &mac->iflist[meta->ifidx]; 756 757 if (unlikely(vif->wdev.iftype == NL80211_IFTYPE_UNSPECIFIED)) { 758 pr_err_ratelimited("vif(%u) does not exists\n", meta->ifidx); 759 goto out; 760 } 761 762 ndev = vif->netdev; 763 764 if (unlikely(!ndev)) { 765 pr_err_ratelimited("netdev for wlan%u.%u does not exists\n", 766 meta->macid, meta->ifidx); 767 goto out; 768 } 769 770 __skb_trim(skb, skb->len - sizeof(*meta)); 771 772 out: 773 return ndev; 774 } 775 EXPORT_SYMBOL_GPL(qtnf_classify_skb); 776 777 void qtnf_wake_all_queues(struct net_device *ndev) 778 { 779 struct qtnf_vif *vif = qtnf_netdev_get_priv(ndev); 780 struct qtnf_wmac *mac; 781 struct qtnf_bus *bus; 782 int macid; 783 int i; 784 785 if (unlikely(!vif || !vif->mac || !vif->mac->bus)) 786 return; 787 788 bus = vif->mac->bus; 789 790 for (macid = 0; macid < QTNF_MAX_MAC; macid++) { 791 if (!(bus->hw_info.mac_bitmap & BIT(macid))) 792 continue; 793 794 mac = bus->mac[macid]; 795 for (i = 0; i < QTNF_MAX_INTF; i++) { 796 vif = &mac->iflist[i]; 797 if (vif->netdev && netif_queue_stopped(vif->netdev)) 798 netif_tx_wake_all_queues(vif->netdev); 799 } 800 } 801 } 802 EXPORT_SYMBOL_GPL(qtnf_wake_all_queues); 803 804 void qtnf_update_rx_stats(struct net_device *ndev, const struct sk_buff *skb) 805 { 806 struct qtnf_vif *vif = qtnf_netdev_get_priv(ndev); 807 struct pcpu_sw_netstats *stats64; 808 809 if (unlikely(!vif || !vif->stats64)) { 810 ndev->stats.rx_packets++; 811 ndev->stats.rx_bytes += skb->len; 812 return; 813 } 814 815 stats64 = this_cpu_ptr(vif->stats64); 816 817 u64_stats_update_begin(&stats64->syncp); 818 stats64->rx_packets++; 819 stats64->rx_bytes += skb->len; 820 u64_stats_update_end(&stats64->syncp); 821 } 822 EXPORT_SYMBOL_GPL(qtnf_update_rx_stats); 823 824 void qtnf_update_tx_stats(struct net_device *ndev, const struct sk_buff *skb) 825 { 826 struct qtnf_vif *vif = qtnf_netdev_get_priv(ndev); 827 struct pcpu_sw_netstats *stats64; 828 829 if (unlikely(!vif || !vif->stats64)) { 830 ndev->stats.tx_packets++; 831 ndev->stats.tx_bytes += skb->len; 832 return; 833 } 834 835 stats64 = this_cpu_ptr(vif->stats64); 836 837 u64_stats_update_begin(&stats64->syncp); 838 stats64->tx_packets++; 839 stats64->tx_bytes += skb->len; 840 u64_stats_update_end(&stats64->syncp); 841 } 842 EXPORT_SYMBOL_GPL(qtnf_update_tx_stats); 843 844 void qtnf_packet_send_hi_pri(struct sk_buff *skb) 845 { 846 struct qtnf_vif *vif = qtnf_netdev_get_priv(skb->dev); 847 848 skb_queue_tail(&vif->high_pri_tx_queue, skb); 849 queue_work(vif->mac->bus->hprio_workqueue, &vif->high_pri_tx_work); 850 } 851 EXPORT_SYMBOL_GPL(qtnf_packet_send_hi_pri); 852 853 struct dentry *qtnf_get_debugfs_dir(void) 854 { 855 return qtnf_debugfs_dir; 856 } 857 EXPORT_SYMBOL_GPL(qtnf_get_debugfs_dir); 858 859 static int __init qtnf_core_register(void) 860 { 861 qtnf_debugfs_dir = debugfs_create_dir(KBUILD_MODNAME, NULL); 862 863 if (IS_ERR(qtnf_debugfs_dir)) 864 qtnf_debugfs_dir = NULL; 865 866 return 0; 867 } 868 869 static void __exit qtnf_core_exit(void) 870 { 871 debugfs_remove(qtnf_debugfs_dir); 872 } 873 874 module_init(qtnf_core_register); 875 module_exit(qtnf_core_exit); 876 877 MODULE_AUTHOR("Quantenna Communications"); 878 MODULE_DESCRIPTION("Quantenna 802.11 wireless LAN FullMAC driver."); 879 MODULE_LICENSE("GPL"); 880