root/drivers/net/wireless/ath/wil6210/netdev.c

DEFINITIONS

1. wil_has_other_active_ifaces
2. wil_has_active_ifaces
3. wil_open
4. wil_stop
5. wil6210_netdev_poll_rx
6. wil6210_netdev_poll_rx_edma
7. wil6210_netdev_poll_tx
8. wil6210_netdev_poll_tx_edma
9. wil_dev_setup
10. wil_vif_deinit
11. wil_vif_free
12. wil_ndev_destructor
13. wil_connect_timer_fn
14. wil_scan_timer_fn
15. wil_p2p_discovery_timer_fn
16. wil_vif_init
17. wil_vif_find_free_mid
18. wil_vif_alloc
19. wil_if_alloc
20. wil_if_free
21. wil_vif_add
22. wil_if_add
23. wil_vif_remove
24. wil_if_remove

   1 /*
   2  * Copyright (c) 2012-2017 Qualcomm Atheros, Inc.
   3  * Copyright (c) 2018-2019, The Linux Foundation. All rights reserved.
   4  *
   5  * Permission to use, copy, modify, and/or distribute this software for any
   6  * purpose with or without fee is hereby granted, provided that the above
   7  * copyright notice and this permission notice appear in all copies.
   8  *
   9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  10  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  11  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  12  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  13  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  14  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  15  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  16  */
  17 
  18 #include <linux/etherdevice.h>
  19 #include <linux/rtnetlink.h>
  20 #include "wil6210.h"
  21 #include "txrx.h"
  22 
  23 bool wil_has_other_active_ifaces(struct wil6210_priv *wil,
  24                                  struct net_device *ndev, bool up, bool ok)
  25 {
  26         int i;
  27         struct wil6210_vif *vif;
  28         struct net_device *ndev_i;
  29 
  30         for (i = 0; i < GET_MAX_VIFS(wil); i++) {
  31                 vif = wil->vifs[i];
  32                 if (vif) {
  33                         ndev_i = vif_to_ndev(vif);
  34                         if (ndev_i != ndev)
  35                                 if ((up && (ndev_i->flags & IFF_UP)) ||
  36                                     (ok && netif_carrier_ok(ndev_i)))
  37                                         return true;
  38                 }
  39         }
  40 
  41         return false;
  42 }
  43 
  44 bool wil_has_active_ifaces(struct wil6210_priv *wil, bool up, bool ok)
  45 {
  46         /* use NULL ndev argument to check all interfaces */
  47         return wil_has_other_active_ifaces(wil, NULL, up, ok);
  48 }
  49 
  50 static int wil_open(struct net_device *ndev)
  51 {
  52         struct wil6210_priv *wil = ndev_to_wil(ndev);
  53         int rc = 0;
  54 
  55         wil_dbg_misc(wil, "open\n");
  56 
  57         if (debug_fw ||
  58             test_bit(WMI_FW_CAPABILITY_WMI_ONLY, wil->fw_capabilities)) {
  59                 wil_err(wil, "while in debug_fw or wmi_only mode\n");
  60                 return -EINVAL;
  61         }
  62 
  63         if (!wil_has_other_active_ifaces(wil, ndev, true, false)) {
  64                 wil_dbg_misc(wil, "open, first iface\n");
  65                 rc = wil_pm_runtime_get(wil);
  66                 if (rc < 0)
  67                         return rc;
  68 
  69                 rc = wil_up(wil);
  70                 if (rc)
  71                         wil_pm_runtime_put(wil);
  72         }
  73 
  74         return rc;
  75 }
  76 
  77 static int wil_stop(struct net_device *ndev)
  78 {
  79         struct wil6210_priv *wil = ndev_to_wil(ndev);
  80         int rc = 0;
  81 
  82         wil_dbg_misc(wil, "stop\n");
  83 
  84         if (!wil_has_other_active_ifaces(wil, ndev, true, false)) {
  85                 wil_dbg_misc(wil, "stop, last iface\n");
  86                 rc = wil_down(wil);
  87                 if (!rc)
  88                         wil_pm_runtime_put(wil);
  89         }
  90 
  91         return rc;
  92 }
  93 
  94 static const struct net_device_ops wil_netdev_ops = {
  95         .ndo_open               = wil_open,
  96         .ndo_stop               = wil_stop,
  97         .ndo_start_xmit         = wil_start_xmit,
  98         .ndo_set_mac_address    = eth_mac_addr,
  99         .ndo_validate_addr      = eth_validate_addr,
 100 };
 101 
 102 static int wil6210_netdev_poll_rx(struct napi_struct *napi, int budget)
 103 {
 104         struct wil6210_priv *wil = container_of(napi, struct wil6210_priv,
 105                                                 napi_rx);
 106         int quota = budget;
 107         int done;
 108 
 109         wil_rx_handle(wil, &quota);
 110         done = budget - quota;
 111 
 112         if (done < budget) {
 113                 napi_complete_done(napi, done);
 114                 wil6210_unmask_irq_rx(wil);
 115                 wil_dbg_txrx(wil, "NAPI RX complete\n");
 116         }
 117 
 118         wil_dbg_txrx(wil, "NAPI RX poll(%d) done %d\n", budget, done);
 119 
 120         return done;
 121 }
 122 
 123 static int wil6210_netdev_poll_rx_edma(struct napi_struct *napi, int budget)
 124 {
 125         struct wil6210_priv *wil = container_of(napi, struct wil6210_priv,
 126                                                 napi_rx);
 127         int quota = budget;
 128         int done;
 129 
 130         wil_rx_handle_edma(wil, &quota);
 131         done = budget - quota;
 132 
 133         if (done < budget) {
 134                 napi_complete_done(napi, done);
 135                 wil6210_unmask_irq_rx_edma(wil);
 136                 wil_dbg_txrx(wil, "NAPI RX complete\n");
 137         }
 138 
 139         wil_dbg_txrx(wil, "NAPI RX poll(%d) done %d\n", budget, done);
 140 
 141         return done;
 142 }
 143 
 144 static int wil6210_netdev_poll_tx(struct napi_struct *napi, int budget)
 145 {
 146         struct wil6210_priv *wil = container_of(napi, struct wil6210_priv,
 147                                                 napi_tx);
 148         int tx_done = 0;
 149         uint i;
 150 
 151         /* always process ALL Tx complete, regardless budget - it is fast */
 152         for (i = 0; i < WIL6210_MAX_TX_RINGS; i++) {
 153                 struct wil_ring *ring = &wil->ring_tx[i];
 154                 struct wil_ring_tx_data *txdata = &wil->ring_tx_data[i];
 155                 struct wil6210_vif *vif;
 156 
 157                 if (!ring->va || !txdata->enabled ||
 158                     txdata->mid >= GET_MAX_VIFS(wil))
 159                         continue;
 160 
 161                 vif = wil->vifs[txdata->mid];
 162                 if (unlikely(!vif)) {
 163                         wil_dbg_txrx(wil, "Invalid MID %d\n", txdata->mid);
 164                         continue;
 165                 }
 166 
 167                 tx_done += wil_tx_complete(vif, i);
 168         }
 169 
 170         if (tx_done < budget) {
 171                 napi_complete(napi);
 172                 wil6210_unmask_irq_tx(wil);
 173                 wil_dbg_txrx(wil, "NAPI TX complete\n");
 174         }
 175 
 176         wil_dbg_txrx(wil, "NAPI TX poll(%d) done %d\n", budget, tx_done);
 177 
 178         return min(tx_done, budget);
 179 }
 180 
 181 static int wil6210_netdev_poll_tx_edma(struct napi_struct *napi, int budget)
 182 {
 183         struct wil6210_priv *wil = container_of(napi, struct wil6210_priv,
 184                                                 napi_tx);
 185         int tx_done;
 186         /* There is only one status TX ring */
 187         struct wil_status_ring *sring = &wil->srings[wil->tx_sring_idx];
 188 
 189         if (!sring->va)
 190                 return 0;
 191 
 192         tx_done = wil_tx_sring_handler(wil, sring);
 193 
 194         if (tx_done < budget) {
 195                 napi_complete(napi);
 196                 wil6210_unmask_irq_tx_edma(wil);
 197                 wil_dbg_txrx(wil, "NAPI TX complete\n");
 198         }
 199 
 200         wil_dbg_txrx(wil, "NAPI TX poll(%d) done %d\n", budget, tx_done);
 201 
 202         return min(tx_done, budget);
 203 }
 204 
 205 static void wil_dev_setup(struct net_device *dev)
 206 {
 207         ether_setup(dev);
 208         dev->max_mtu = mtu_max;
 209         dev->tx_queue_len = WIL_TX_Q_LEN_DEFAULT;
 210 }
 211 
 212 static void wil_vif_deinit(struct wil6210_vif *vif)
 213 {
 214         del_timer_sync(&vif->scan_timer);
 215         del_timer_sync(&vif->p2p.discovery_timer);
 216         cancel_work_sync(&vif->disconnect_worker);
 217         cancel_work_sync(&vif->p2p.discovery_expired_work);
 218         cancel_work_sync(&vif->p2p.delayed_listen_work);
 219         wil_probe_client_flush(vif);
 220         cancel_work_sync(&vif->probe_client_worker);
 221         cancel_work_sync(&vif->enable_tx_key_worker);
 222 }
 223 
 224 void wil_vif_free(struct wil6210_vif *vif)
 225 {
 226         struct net_device *ndev = vif_to_ndev(vif);
 227 
 228         wil_vif_deinit(vif);
 229         free_netdev(ndev);
 230 }
 231 
 232 static void wil_ndev_destructor(struct net_device *ndev)
 233 {
 234         struct wil6210_vif *vif = ndev_to_vif(ndev);
 235 
 236         wil_vif_deinit(vif);
 237 }
 238 
 239 static void wil_connect_timer_fn(struct timer_list *t)
 240 {
 241         struct wil6210_vif *vif = from_timer(vif, t, connect_timer);
 242         struct wil6210_priv *wil = vif_to_wil(vif);
 243         bool q;
 244 
 245         wil_err(wil, "Connect timeout detected, disconnect station\n");
 246 
 247         /* reschedule to thread context - disconnect won't
 248          * run from atomic context.
 249          * queue on wmi_wq to prevent race with connect event.
 250          */
 251         q = queue_work(wil->wmi_wq, &vif->disconnect_worker);
 252         wil_dbg_wmi(wil, "queue_work of disconnect_worker -> %d\n", q);
 253 }
 254 
 255 static void wil_scan_timer_fn(struct timer_list *t)
 256 {
 257         struct wil6210_vif *vif = from_timer(vif, t, scan_timer);
 258         struct wil6210_priv *wil = vif_to_wil(vif);
 259 
 260         clear_bit(wil_status_fwready, wil->status);
 261         wil_err(wil, "Scan timeout detected, start fw error recovery\n");
 262         wil_fw_error_recovery(wil);
 263 }
 264 
 265 static void wil_p2p_discovery_timer_fn(struct timer_list *t)
 266 {
 267         struct wil6210_vif *vif = from_timer(vif, t, p2p.discovery_timer);
 268         struct wil6210_priv *wil = vif_to_wil(vif);
 269 
 270         wil_dbg_misc(wil, "p2p_discovery_timer_fn\n");
 271 
 272         schedule_work(&vif->p2p.discovery_expired_work);
 273 }
 274 
 275 static void wil_vif_init(struct wil6210_vif *vif)
 276 {
 277         vif->bcast_ring = -1;
 278 
 279         mutex_init(&vif->probe_client_mutex);
 280 
 281         timer_setup(&vif->connect_timer, wil_connect_timer_fn, 0);
 282         timer_setup(&vif->scan_timer, wil_scan_timer_fn, 0);
 283         timer_setup(&vif->p2p.discovery_timer, wil_p2p_discovery_timer_fn, 0);
 284 
 285         INIT_WORK(&vif->probe_client_worker, wil_probe_client_worker);
 286         INIT_WORK(&vif->disconnect_worker, wil_disconnect_worker);
 287         INIT_WORK(&vif->p2p.discovery_expired_work, wil_p2p_listen_expired);
 288         INIT_WORK(&vif->p2p.delayed_listen_work, wil_p2p_delayed_listen_work);
 289         INIT_WORK(&vif->enable_tx_key_worker, wil_enable_tx_key_worker);
 290 
 291         INIT_LIST_HEAD(&vif->probe_client_pending);
 292 
 293         vif->net_queue_stopped = 1;
 294 }
 295 
 296 static u8 wil_vif_find_free_mid(struct wil6210_priv *wil)
 297 {
 298         u8 i;
 299 
 300         for (i = 0; i < GET_MAX_VIFS(wil); i++) {
 301                 if (!wil->vifs[i])
 302                         return i;
 303         }
 304 
 305         return U8_MAX;
 306 }
 307 
 308 struct wil6210_vif *
 309 wil_vif_alloc(struct wil6210_priv *wil, const char *name,
 310               unsigned char name_assign_type, enum nl80211_iftype iftype)
 311 {
 312         struct net_device *ndev;
 313         struct wireless_dev *wdev;
 314         struct wil6210_vif *vif;
 315         u8 mid;
 316 
 317         mid = wil_vif_find_free_mid(wil);
 318         if (mid == U8_MAX) {
 319                 wil_err(wil, "no available virtual interface\n");
 320                 return ERR_PTR(-EINVAL);
 321         }
 322 
 323         ndev = alloc_netdev(sizeof(*vif), name, name_assign_type,
 324                             wil_dev_setup);
 325         if (!ndev) {
 326                 dev_err(wil_to_dev(wil), "alloc_netdev failed\n");
 327                 return ERR_PTR(-ENOMEM);
 328         }
 329         if (mid == 0) {
 330                 wil->main_ndev = ndev;
 331         } else {
 332                 ndev->priv_destructor = wil_ndev_destructor;
 333                 ndev->needs_free_netdev = true;
 334         }
 335 
 336         vif = ndev_to_vif(ndev);
 337         vif->ndev = ndev;
 338         vif->wil = wil;
 339         vif->mid = mid;
 340         wil_vif_init(vif);
 341 
 342         wdev = &vif->wdev;
 343         wdev->wiphy = wil->wiphy;
 344         wdev->iftype = iftype;
 345 
 346         ndev->netdev_ops = &wil_netdev_ops;
 347         wil_set_ethtoolops(ndev);
 348         ndev->ieee80211_ptr = wdev;
 349         ndev->hw_features = NETIF_F_HW_CSUM | NETIF_F_RXCSUM |
 350                             NETIF_F_SG | NETIF_F_GRO |
 351                             NETIF_F_TSO | NETIF_F_TSO6;
 352 
 353         ndev->features |= ndev->hw_features;
 354         SET_NETDEV_DEV(ndev, wiphy_dev(wdev->wiphy));
 355         wdev->netdev = ndev;
 356         return vif;
 357 }
 358 
 359 void *wil_if_alloc(struct device *dev)
 360 {
 361         struct wil6210_priv *wil;
 362         struct wil6210_vif *vif;
 363         int rc = 0;
 364 
 365         wil = wil_cfg80211_init(dev);
 366         if (IS_ERR(wil)) {
 367                 dev_err(dev, "wil_cfg80211_init failed\n");
 368                 return wil;
 369         }
 370 
 371         rc = wil_priv_init(wil);
 372         if (rc) {
 373                 dev_err(dev, "wil_priv_init failed\n");
 374                 goto out_cfg;
 375         }
 376 
 377         wil_dbg_misc(wil, "if_alloc\n");
 378 
 379         vif = wil_vif_alloc(wil, "wlan%d", NET_NAME_UNKNOWN,
 380                             NL80211_IFTYPE_STATION);
 381         if (IS_ERR(vif)) {
 382                 dev_err(dev, "wil_vif_alloc failed\n");
 383                 rc = -ENOMEM;
 384                 goto out_priv;
 385         }
 386 
 387         wil->radio_wdev = vif_to_wdev(vif);
 388 
 389         return wil;
 390 
 391 out_priv:
 392         wil_priv_deinit(wil);
 393 
 394 out_cfg:
 395         wil_cfg80211_deinit(wil);
 396 
 397         return ERR_PTR(rc);
 398 }
 399 
 400 void wil_if_free(struct wil6210_priv *wil)
 401 {
 402         struct net_device *ndev = wil->main_ndev;
 403 
 404         wil_dbg_misc(wil, "if_free\n");
 405 
 406         if (!ndev)
 407                 return;
 408 
 409         wil_priv_deinit(wil);
 410 
 411         wil->main_ndev = NULL;
 412         wil_ndev_destructor(ndev);
 413         free_netdev(ndev);
 414 
 415         wil_cfg80211_deinit(wil);
 416 }
 417 
 418 int wil_vif_add(struct wil6210_priv *wil, struct wil6210_vif *vif)
 419 {
 420         struct net_device *ndev = vif_to_ndev(vif);
 421         struct wireless_dev *wdev = vif_to_wdev(vif);
 422         bool any_active = wil_has_active_ifaces(wil, true, false);
 423         int rc;
 424 
 425         ASSERT_RTNL();
 426 
 427         if (wil->vifs[vif->mid]) {
 428                 dev_err(&ndev->dev, "VIF with mid %d already in use\n",
 429                         vif->mid);
 430                 return -EEXIST;
 431         }
 432         if (any_active && vif->mid != 0) {
 433                 rc = wmi_port_allocate(wil, vif->mid, ndev->dev_addr,
 434                                        wdev->iftype);
 435                 if (rc)
 436                         return rc;
 437         }
 438         rc = register_netdevice(ndev);
 439         if (rc < 0) {
 440                 dev_err(&ndev->dev, "Failed to register netdev: %d\n", rc);
 441                 if (any_active && vif->mid != 0)
 442                         wmi_port_delete(wil, vif->mid);
 443                 return rc;
 444         }
 445 
 446         wil->vifs[vif->mid] = vif;
 447         return 0;
 448 }
 449 
 450 int wil_if_add(struct wil6210_priv *wil)
 451 {
 452         struct wiphy *wiphy = wil->wiphy;
 453         struct net_device *ndev = wil->main_ndev;
 454         struct wil6210_vif *vif = ndev_to_vif(ndev);
 455         int rc;
 456 
 457         wil_dbg_misc(wil, "entered");
 458 
 459         strlcpy(wiphy->fw_version, wil->fw_version, sizeof(wiphy->fw_version));
 460 
 461         rc = wiphy_register(wiphy);
 462         if (rc < 0) {
 463                 wil_err(wil, "failed to register wiphy, err %d\n", rc);
 464                 return rc;
 465         }
 466 
 467         init_dummy_netdev(&wil->napi_ndev);
 468         if (wil->use_enhanced_dma_hw) {
 469                 netif_napi_add(&wil->napi_ndev, &wil->napi_rx,
 470                                wil6210_netdev_poll_rx_edma,
 471                                WIL6210_NAPI_BUDGET);
 472                 netif_tx_napi_add(&wil->napi_ndev,
 473                                   &wil->napi_tx, wil6210_netdev_poll_tx_edma,
 474                                   WIL6210_NAPI_BUDGET);
 475         } else {
 476                 netif_napi_add(&wil->napi_ndev, &wil->napi_rx,
 477                                wil6210_netdev_poll_rx,
 478                                WIL6210_NAPI_BUDGET);
 479                 netif_tx_napi_add(&wil->napi_ndev,
 480                                   &wil->napi_tx, wil6210_netdev_poll_tx,
 481                                   WIL6210_NAPI_BUDGET);
 482         }
 483 
 484         wil_update_net_queues_bh(wil, vif, NULL, true);
 485 
 486         rtnl_lock();
 487         rc = wil_vif_add(wil, vif);
 488         rtnl_unlock();
 489         if (rc < 0)
 490                 goto out_wiphy;
 491 
 492         return 0;
 493 
 494 out_wiphy:
 495         wiphy_unregister(wiphy);
 496         return rc;
 497 }
 498 
 499 void wil_vif_remove(struct wil6210_priv *wil, u8 mid)
 500 {
 501         struct wil6210_vif *vif;
 502         struct net_device *ndev;
 503         bool any_active = wil_has_active_ifaces(wil, true, false);
 504 
 505         ASSERT_RTNL();
 506         if (mid >= GET_MAX_VIFS(wil)) {
 507                 wil_err(wil, "invalid MID: %d\n", mid);
 508                 return;
 509         }
 510 
 511         vif = wil->vifs[mid];
 512         if (!vif) {
 513                 wil_err(wil, "MID %d not registered\n", mid);
 514                 return;
 515         }
 516 
 517         mutex_lock(&wil->mutex);
 518         wil6210_disconnect(vif, NULL, WLAN_REASON_DEAUTH_LEAVING);
 519         mutex_unlock(&wil->mutex);
 520 
 521         ndev = vif_to_ndev(vif);
 522         /* during unregister_netdevice cfg80211_leave may perform operations
 523          * such as stop AP, disconnect, so we only clear the VIF afterwards
 524          */
 525         unregister_netdevice(ndev);
 526 
 527         if (any_active && vif->mid != 0)
 528                 wmi_port_delete(wil, vif->mid);
 529 
 530         /* make sure no one is accessing the VIF before removing */
 531         mutex_lock(&wil->vif_mutex);
 532         wil->vifs[mid] = NULL;
 533         /* ensure NAPI code will see the NULL VIF */
 534         wmb();
 535         if (test_bit(wil_status_napi_en, wil->status)) {
 536                 napi_synchronize(&wil->napi_rx);
 537                 napi_synchronize(&wil->napi_tx);
 538         }
 539         mutex_unlock(&wil->vif_mutex);
 540 
 541         flush_work(&wil->wmi_event_worker);
 542         del_timer_sync(&vif->connect_timer);
 543         cancel_work_sync(&vif->disconnect_worker);
 544         wil_probe_client_flush(vif);
 545         cancel_work_sync(&vif->probe_client_worker);
 546         cancel_work_sync(&vif->enable_tx_key_worker);
 547         /* for VIFs, ndev will be freed by destructor after RTNL is unlocked.
 548          * the main interface will be freed in wil_if_free, we need to keep it
 549          * a bit longer so logging macros will work.
 550          */
 551 }
 552 
 553 void wil_if_remove(struct wil6210_priv *wil)
 554 {
 555         struct net_device *ndev = wil->main_ndev;
 556         struct wireless_dev *wdev = ndev->ieee80211_ptr;
 557 
 558         wil_dbg_misc(wil, "if_remove\n");
 559 
 560         rtnl_lock();
 561         wil_vif_remove(wil, 0);
 562         rtnl_unlock();
 563 
 564         netif_napi_del(&wil->napi_tx);
 565         netif_napi_del(&wil->napi_rx);
 566 
 567         wiphy_unregister(wdev->wiphy);
 568 }