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

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