drivers/net/wireless/quantenna/qtnfmac/core.c

   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 wiphy *wiphy;
 387         struct qtnf_wmac *mac;
 388         unsigned int i;
 389
 390         wiphy = qtnf_wiphy_allocate(bus);
 391         if (!wiphy)
 392                 return ERR_PTR(-ENOMEM);
 393
 394         mac = wiphy_priv(wiphy);
 395
 396         mac->macid = macid;
 397         mac->bus = bus;
 398
 399         for (i = 0; i < QTNF_MAX_INTF; i++) {
 400                 memset(&mac->iflist[i], 0, sizeof(struct qtnf_vif));
 401                 mac->iflist[i].wdev.iftype = NL80211_IFTYPE_UNSPECIFIED;
 402                 mac->iflist[i].mac = mac;
 403                 mac->iflist[i].vifid = i;
 404                 qtnf_sta_list_init(&mac->iflist[i].sta_list);
 405                 mutex_init(&mac->mac_lock);
 406                 INIT_DELAYED_WORK(&mac->scan_timeout, qtnf_mac_scan_timeout);
 407                 mac->iflist[i].stats64 =
 408                         netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
 409                 if (!mac->iflist[i].stats64)
 410                         pr_warn("VIF%u.%u: per cpu stats allocation failed\n",
 411                                 macid, i);
 412         }
 413
 414         qtnf_mac_init_primary_intf(mac);
 415         bus->mac[macid] = mac;
 416
 417         return mac;
 418 }
 419
 420 static const struct ethtool_ops qtnf_ethtool_ops = {
 421         .get_drvinfo = cfg80211_get_drvinfo,
 422 };
 423
 424 int qtnf_core_net_attach(struct qtnf_wmac *mac, struct qtnf_vif *vif,
 425                          const char *name, unsigned char name_assign_type)
 426 {
 427         struct wiphy *wiphy = priv_to_wiphy(mac);
 428         struct net_device *dev;
 429         void *qdev_vif;
 430         int ret;
 431
 432         dev = alloc_netdev_mqs(sizeof(struct qtnf_vif *), name,
 433                                name_assign_type, ether_setup, 1, 1);
 434         if (!dev) {
 435                 vif->wdev.iftype = NL80211_IFTYPE_UNSPECIFIED;
 436                 return -ENOMEM;
 437         }
 438
 439         vif->netdev = dev;
 440
 441         dev->netdev_ops = &qtnf_netdev_ops;
 442         dev->needs_free_netdev = true;
 443         dev_net_set(dev, wiphy_net(wiphy));
 444         dev->ieee80211_ptr = &vif->wdev;
 445         ether_addr_copy(dev->dev_addr, vif->mac_addr);
 446         SET_NETDEV_DEV(dev, wiphy_dev(wiphy));
 447         dev->flags |= IFF_BROADCAST | IFF_MULTICAST;
 448         dev->watchdog_timeo = QTNF_DEF_WDOG_TIMEOUT;
 449         dev->tx_queue_len = 100;
 450         dev->ethtool_ops = &qtnf_ethtool_ops;
 451
 452         qdev_vif = netdev_priv(dev);
 453         *((void **)qdev_vif) = vif;
 454
 455         SET_NETDEV_DEV(dev, mac->bus->dev);
 456
 457         ret = register_netdevice(dev);
 458         if (ret) {
 459                 free_netdev(dev);
 460                 vif->wdev.iftype = NL80211_IFTYPE_UNSPECIFIED;
 461         }
 462
 463         return ret;
 464 }
 465
 466 static void qtnf_core_mac_detach(struct qtnf_bus *bus, unsigned int macid)
 467 {
 468         struct qtnf_wmac *mac;
 469         struct wiphy *wiphy;
 470         struct qtnf_vif *vif;
 471         unsigned int i;
 472         enum nl80211_band band;
 473
 474         mac = bus->mac[macid];
 475
 476         if (!mac)
 477                 return;
 478
 479         wiphy = priv_to_wiphy(mac);
 480
 481         for (i = 0; i < QTNF_MAX_INTF; i++) {
 482                 vif = &mac->iflist[i];
 483                 rtnl_lock();
 484                 if (vif->netdev &&
 485                     vif->wdev.iftype != NL80211_IFTYPE_UNSPECIFIED) {
 486                         qtnf_virtual_intf_cleanup(vif->netdev);
 487                         qtnf_del_virtual_intf(wiphy, &vif->wdev);
 488                 }
 489                 rtnl_unlock();
 490                 qtnf_sta_list_free(&vif->sta_list);
 491                 free_percpu(vif->stats64);
 492         }
 493
 494         if (mac->wiphy_registered)
 495                 wiphy_unregister(wiphy);
 496
 497         for (band = NL80211_BAND_2GHZ; band < NUM_NL80211_BANDS; ++band) {
 498                 if (!wiphy->bands[band])
 499                         continue;
 500
 501                 kfree(wiphy->bands[band]->channels);
 502                 wiphy->bands[band]->n_channels = 0;
 503
 504                 kfree(wiphy->bands[band]);
 505                 wiphy->bands[band] = NULL;
 506         }
 507
 508         qtnf_mac_iface_comb_free(mac);
 509         qtnf_mac_ext_caps_free(mac);
 510         kfree(mac->macinfo.wowlan);
 511         wiphy_free(wiphy);
 512         bus->mac[macid] = NULL;
 513 }
 514
 515 static int qtnf_core_mac_attach(struct qtnf_bus *bus, unsigned int macid)
 516 {
 517         struct qtnf_wmac *mac;
 518         struct qtnf_vif *vif;
 519         int ret;
 520
 521         if (!(bus->hw_info.mac_bitmap & BIT(macid))) {
 522                 pr_info("MAC%u is not active in FW\n", macid);
 523                 return 0;
 524         }
 525
 526         mac = qtnf_core_mac_alloc(bus, macid);
 527         if (IS_ERR(mac)) {
 528                 pr_err("MAC%u allocation failed\n", macid);
 529                 return PTR_ERR(mac);
 530         }
 531
 532         ret = qtnf_cmd_get_mac_info(mac);
 533         if (ret) {
 534                 pr_err("MAC%u: failed to get info\n", macid);
 535                 goto error;
 536         }
 537
 538         vif = qtnf_mac_get_base_vif(mac);
 539         if (!vif) {
 540                 pr_err("MAC%u: primary VIF is not ready\n", macid);
 541                 ret = -EFAULT;
 542                 goto error;
 543         }
 544
 545         ret = qtnf_cmd_send_add_intf(vif, vif->wdev.iftype, vif->mac_addr);
 546         if (ret) {
 547                 pr_err("MAC%u: failed to add VIF\n", macid);
 548                 goto error;
 549         }
 550
 551         ret = qtnf_cmd_send_get_phy_params(mac);
 552         if (ret) {
 553                 pr_err("MAC%u: failed to get PHY settings\n", macid);
 554                 goto error;
 555         }
 556
 557         ret = qtnf_mac_init_bands(mac);
 558         if (ret) {
 559                 pr_err("MAC%u: failed to init bands\n", macid);
 560                 goto error;
 561         }
 562
 563         ret = qtnf_wiphy_register(&bus->hw_info, mac);
 564         if (ret) {
 565                 pr_err("MAC%u: wiphy registration failed\n", macid);
 566                 goto error;
 567         }
 568
 569         mac->wiphy_registered = 1;
 570
 571         rtnl_lock();
 572
 573         ret = qtnf_core_net_attach(mac, vif, "wlan%d", NET_NAME_ENUM);
 574         rtnl_unlock();
 575
 576         if (ret) {
 577                 pr_err("MAC%u: failed to attach netdev\n", macid);
 578                 vif->wdev.iftype = NL80211_IFTYPE_UNSPECIFIED;
 579                 vif->netdev = NULL;
 580                 goto error;
 581         }
 582
 583         pr_debug("MAC%u initialized\n", macid);
 584
 585         return 0;
 586
 587 error:
 588         qtnf_core_mac_detach(bus, macid);
 589         return ret;
 590 }
 591
 592 int qtnf_core_attach(struct qtnf_bus *bus)
 593 {
 594         unsigned int i;
 595         int ret;
 596
 597         qtnf_trans_init(bus);
 598
 599         bus->fw_state = QTNF_FW_STATE_BOOT_DONE;
 600         qtnf_bus_data_rx_start(bus);
 601
 602         bus->workqueue = alloc_ordered_workqueue("QTNF_BUS", 0);
 603         if (!bus->workqueue) {
 604                 pr_err("failed to alloc main workqueue\n");
 605                 ret = -ENOMEM;
 606                 goto error;
 607         }
 608
 609         INIT_WORK(&bus->event_work, qtnf_event_work_handler);
 610
 611         ret = qtnf_cmd_send_init_fw(bus);
 612         if (ret) {
 613                 pr_err("failed to init FW: %d\n", ret);
 614                 goto error;
 615         }
 616
 617         bus->fw_state = QTNF_FW_STATE_ACTIVE;
 618
 619         ret = qtnf_cmd_get_hw_info(bus);
 620         if (ret) {
 621                 pr_err("failed to get HW info: %d\n", ret);
 622                 goto error;
 623         }
 624
 625         if (bus->hw_info.ql_proto_ver != QLINK_PROTO_VER) {
 626                 pr_err("qlink version mismatch %u != %u\n",
 627                        QLINK_PROTO_VER, bus->hw_info.ql_proto_ver);
 628                 ret = -EPROTONOSUPPORT;
 629                 goto error;
 630         }
 631
 632         if (bus->hw_info.num_mac > QTNF_MAX_MAC) {
 633                 pr_err("no support for number of MACs=%u\n",
 634                        bus->hw_info.num_mac);
 635                 ret = -ERANGE;
 636                 goto error;
 637         }
 638
 639         for (i = 0; i < bus->hw_info.num_mac; i++) {
 640                 ret = qtnf_core_mac_attach(bus, i);
 641
 642                 if (ret) {
 643                         pr_err("MAC%u: attach failed: %d\n", i, ret);
 644                         goto error;
 645                 }
 646         }
 647
 648         return 0;
 649
 650 error:
 651         qtnf_core_detach(bus);
 652
 653         return ret;
 654 }
 655 EXPORT_SYMBOL_GPL(qtnf_core_attach);
 656
 657 void qtnf_core_detach(struct qtnf_bus *bus)
 658 {
 659         unsigned int macid;
 660
 661         qtnf_bus_data_rx_stop(bus);
 662
 663         for (macid = 0; macid < QTNF_MAX_MAC; macid++)
 664                 qtnf_core_mac_detach(bus, macid);
 665
 666         if (bus->fw_state == QTNF_FW_STATE_ACTIVE)
 667                 qtnf_cmd_send_deinit_fw(bus);
 668
 669         bus->fw_state = QTNF_FW_STATE_DETACHED;
 670
 671         if (bus->workqueue) {
 672                 flush_workqueue(bus->workqueue);
 673                 destroy_workqueue(bus->workqueue);
 674         }
 675
 676         kfree(bus->hw_info.rd);
 677         bus->hw_info.rd = NULL;
 678
 679         qtnf_trans_free(bus);
 680 }
 681 EXPORT_SYMBOL_GPL(qtnf_core_detach);
 682
 683 static inline int qtnf_is_frame_meta_magic_valid(struct qtnf_frame_meta_info *m)
 684 {
 685         return m->magic_s == 0xAB && m->magic_e == 0xBA;
 686 }
 687
 688 struct net_device *qtnf_classify_skb(struct qtnf_bus *bus, struct sk_buff *skb)
 689 {
 690         struct qtnf_frame_meta_info *meta;
 691         struct net_device *ndev = NULL;
 692         struct qtnf_wmac *mac;
 693         struct qtnf_vif *vif;
 694
 695         meta = (struct qtnf_frame_meta_info *)
 696                 (skb_tail_pointer(skb) - sizeof(*meta));
 697
 698         if (unlikely(!qtnf_is_frame_meta_magic_valid(meta))) {
 699                 pr_err_ratelimited("invalid magic 0x%x:0x%x\n",
 700                                    meta->magic_s, meta->magic_e);
 701                 goto out;
 702         }
 703
 704         if (unlikely(meta->macid >= QTNF_MAX_MAC)) {
 705                 pr_err_ratelimited("invalid mac(%u)\n", meta->macid);
 706                 goto out;
 707         }
 708
 709         if (unlikely(meta->ifidx >= QTNF_MAX_INTF)) {
 710                 pr_err_ratelimited("invalid vif(%u)\n", meta->ifidx);
 711                 goto out;
 712         }
 713
 714         mac = bus->mac[meta->macid];
 715
 716         if (unlikely(!mac)) {
 717                 pr_err_ratelimited("mac(%d) does not exist\n", meta->macid);
 718                 goto out;
 719         }
 720
 721         vif = &mac->iflist[meta->ifidx];
 722
 723         if (unlikely(vif->wdev.iftype == NL80211_IFTYPE_UNSPECIFIED)) {
 724                 pr_err_ratelimited("vif(%u) does not exists\n", meta->ifidx);
 725                 goto out;
 726         }
 727
 728         ndev = vif->netdev;
 729
 730         if (unlikely(!ndev)) {
 731                 pr_err_ratelimited("netdev for wlan%u.%u does not exists\n",
 732                                    meta->macid, meta->ifidx);
 733                 goto out;
 734         }
 735
 736         __skb_trim(skb, skb->len - sizeof(*meta));
 737
 738 out:
 739         return ndev;
 740 }
 741 EXPORT_SYMBOL_GPL(qtnf_classify_skb);
 742
 743 void qtnf_wake_all_queues(struct net_device *ndev)
 744 {
 745         struct qtnf_vif *vif = qtnf_netdev_get_priv(ndev);
 746         struct qtnf_wmac *mac;
 747         struct qtnf_bus *bus;
 748         int macid;
 749         int i;
 750
 751         if (unlikely(!vif || !vif->mac || !vif->mac->bus))
 752                 return;
 753
 754         bus = vif->mac->bus;
 755
 756         for (macid = 0; macid < QTNF_MAX_MAC; macid++) {
 757                 if (!(bus->hw_info.mac_bitmap & BIT(macid)))
 758                         continue;
 759
 760                 mac = bus->mac[macid];
 761                 for (i = 0; i < QTNF_MAX_INTF; i++) {
 762                         vif = &mac->iflist[i];
 763                         if (vif->netdev && netif_queue_stopped(vif->netdev))
 764                                 netif_tx_wake_all_queues(vif->netdev);
 765                 }
 766         }
 767 }
 768 EXPORT_SYMBOL_GPL(qtnf_wake_all_queues);
 769
 770 void qtnf_update_rx_stats(struct net_device *ndev, const struct sk_buff *skb)
 771 {
 772         struct qtnf_vif *vif = qtnf_netdev_get_priv(ndev);
 773         struct pcpu_sw_netstats *stats64;
 774
 775         if (unlikely(!vif || !vif->stats64)) {
 776                 ndev->stats.rx_packets++;
 777                 ndev->stats.rx_bytes += skb->len;
 778                 return;
 779         }
 780
 781         stats64 = this_cpu_ptr(vif->stats64);
 782
 783         u64_stats_update_begin(&stats64->syncp);
 784         stats64->rx_packets++;
 785         stats64->rx_bytes += skb->len;
 786         u64_stats_update_end(&stats64->syncp);
 787 }
 788 EXPORT_SYMBOL_GPL(qtnf_update_rx_stats);
 789
 790 void qtnf_update_tx_stats(struct net_device *ndev, const struct sk_buff *skb)
 791 {
 792         struct qtnf_vif *vif = qtnf_netdev_get_priv(ndev);
 793         struct pcpu_sw_netstats *stats64;
 794
 795         if (unlikely(!vif || !vif->stats64)) {
 796                 ndev->stats.tx_packets++;
 797                 ndev->stats.tx_bytes += skb->len;
 798                 return;
 799         }
 800
 801         stats64 = this_cpu_ptr(vif->stats64);
 802
 803         u64_stats_update_begin(&stats64->syncp);
 804         stats64->tx_packets++;
 805         stats64->tx_bytes += skb->len;
 806         u64_stats_update_end(&stats64->syncp);
 807 }
 808 EXPORT_SYMBOL_GPL(qtnf_update_tx_stats);
 809
 810 MODULE_AUTHOR("Quantenna Communications");
 811 MODULE_DESCRIPTION("Quantenna 802.11 wireless LAN FullMAC driver.");
 812 MODULE_LICENSE("GPL");