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