1 /* 2 * Copyright (c) 2012-2017 Qualcomm Atheros, Inc. 3 * Copyright (c) 2018, 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 < wil->max_vifs; 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, "a); 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, "a); 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 >= wil->max_vifs) 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 } 222 223 void wil_vif_free(struct wil6210_vif *vif) 224 { 225 struct net_device *ndev = vif_to_ndev(vif); 226 227 wil_vif_deinit(vif); 228 free_netdev(ndev); 229 } 230 231 static void wil_ndev_destructor(struct net_device *ndev) 232 { 233 struct wil6210_vif *vif = ndev_to_vif(ndev); 234 235 wil_vif_deinit(vif); 236 } 237 238 static void wil_connect_timer_fn(struct timer_list *t) 239 { 240 struct wil6210_vif *vif = from_timer(vif, t, connect_timer); 241 struct wil6210_priv *wil = vif_to_wil(vif); 242 bool q; 243 244 wil_err(wil, "Connect timeout detected, disconnect station\n"); 245 246 /* reschedule to thread context - disconnect won't 247 * run from atomic context. 248 * queue on wmi_wq to prevent race with connect event. 249 */ 250 q = queue_work(wil->wmi_wq, &vif->disconnect_worker); 251 wil_dbg_wmi(wil, "queue_work of disconnect_worker -> %d\n", q); 252 } 253 254 static void wil_scan_timer_fn(struct timer_list *t) 255 { 256 struct wil6210_vif *vif = from_timer(vif, t, scan_timer); 257 struct wil6210_priv *wil = vif_to_wil(vif); 258 259 clear_bit(wil_status_fwready, wil->status); 260 wil_err(wil, "Scan timeout detected, start fw error recovery\n"); 261 wil_fw_error_recovery(wil); 262 } 263 264 static void wil_p2p_discovery_timer_fn(struct timer_list *t) 265 { 266 struct wil6210_vif *vif = from_timer(vif, t, p2p.discovery_timer); 267 struct wil6210_priv *wil = vif_to_wil(vif); 268 269 wil_dbg_misc(wil, "p2p_discovery_timer_fn\n"); 270 271 schedule_work(&vif->p2p.discovery_expired_work); 272 } 273 274 static void wil_vif_init(struct wil6210_vif *vif) 275 { 276 vif->bcast_ring = -1; 277 278 mutex_init(&vif->probe_client_mutex); 279 280 timer_setup(&vif->connect_timer, wil_connect_timer_fn, 0); 281 timer_setup(&vif->scan_timer, wil_scan_timer_fn, 0); 282 timer_setup(&vif->p2p.discovery_timer, wil_p2p_discovery_timer_fn, 0); 283 284 INIT_WORK(&vif->probe_client_worker, wil_probe_client_worker); 285 INIT_WORK(&vif->disconnect_worker, wil_disconnect_worker); 286 INIT_WORK(&vif->p2p.delayed_listen_work, wil_p2p_delayed_listen_work); 287 288 INIT_LIST_HEAD(&vif->probe_client_pending); 289 290 vif->net_queue_stopped = 1; 291 } 292 293 static u8 wil_vif_find_free_mid(struct wil6210_priv *wil) 294 { 295 u8 i; 296 297 for (i = 0; i < wil->max_vifs; i++) { 298 if (!wil->vifs[i]) 299 return i; 300 } 301 302 return U8_MAX; 303 } 304 305 struct wil6210_vif * 306 wil_vif_alloc(struct wil6210_priv *wil, const char *name, 307 unsigned char name_assign_type, enum nl80211_iftype iftype) 308 { 309 struct net_device *ndev; 310 struct wireless_dev *wdev; 311 struct wil6210_vif *vif; 312 u8 mid; 313 314 mid = wil_vif_find_free_mid(wil); 315 if (mid == U8_MAX) { 316 wil_err(wil, "no available virtual interface\n"); 317 return ERR_PTR(-EINVAL); 318 } 319 320 ndev = alloc_netdev(sizeof(*vif), name, name_assign_type, 321 wil_dev_setup); 322 if (!ndev) { 323 dev_err(wil_to_dev(wil), "alloc_netdev failed\n"); 324 return ERR_PTR(-ENOMEM); 325 } 326 if (mid == 0) { 327 wil->main_ndev = ndev; 328 } else { 329 ndev->priv_destructor = wil_ndev_destructor; 330 ndev->needs_free_netdev = true; 331 } 332 333 vif = ndev_to_vif(ndev); 334 vif->ndev = ndev; 335 vif->wil = wil; 336 vif->mid = mid; 337 wil_vif_init(vif); 338 339 wdev = &vif->wdev; 340 wdev->wiphy = wil->wiphy; 341 wdev->iftype = iftype; 342 343 ndev->netdev_ops = &wil_netdev_ops; 344 wil_set_ethtoolops(ndev); 345 ndev->ieee80211_ptr = wdev; 346 ndev->hw_features = NETIF_F_HW_CSUM | NETIF_F_RXCSUM | 347 NETIF_F_SG | NETIF_F_GRO | 348 NETIF_F_TSO | NETIF_F_TSO6 | 349 NETIF_F_RXHASH; 350 351 ndev->features |= ndev->hw_features; 352 SET_NETDEV_DEV(ndev, wiphy_dev(wdev->wiphy)); 353 wdev->netdev = ndev; 354 return vif; 355 } 356 357 void *wil_if_alloc(struct device *dev) 358 { 359 struct wil6210_priv *wil; 360 struct wil6210_vif *vif; 361 int rc = 0; 362 363 wil = wil_cfg80211_init(dev); 364 if (IS_ERR(wil)) { 365 dev_err(dev, "wil_cfg80211_init failed\n"); 366 return wil; 367 } 368 369 rc = wil_priv_init(wil); 370 if (rc) { 371 dev_err(dev, "wil_priv_init failed\n"); 372 goto out_cfg; 373 } 374 375 wil_dbg_misc(wil, "if_alloc\n"); 376 377 vif = wil_vif_alloc(wil, "wlan%d", NET_NAME_UNKNOWN, 378 NL80211_IFTYPE_STATION); 379 if (IS_ERR(vif)) { 380 dev_err(dev, "wil_vif_alloc failed\n"); 381 rc = -ENOMEM; 382 goto out_priv; 383 } 384 385 wil->radio_wdev = vif_to_wdev(vif); 386 387 return wil; 388 389 out_priv: 390 wil_priv_deinit(wil); 391 392 out_cfg: 393 wil_cfg80211_deinit(wil); 394 395 return ERR_PTR(rc); 396 } 397 398 void wil_if_free(struct wil6210_priv *wil) 399 { 400 struct net_device *ndev = wil->main_ndev; 401 402 wil_dbg_misc(wil, "if_free\n"); 403 404 if (!ndev) 405 return; 406 407 wil_priv_deinit(wil); 408 409 wil->main_ndev = NULL; 410 wil_ndev_destructor(ndev); 411 free_netdev(ndev); 412 413 wil_cfg80211_deinit(wil); 414 } 415 416 int wil_vif_add(struct wil6210_priv *wil, struct wil6210_vif *vif) 417 { 418 struct net_device *ndev = vif_to_ndev(vif); 419 struct wireless_dev *wdev = vif_to_wdev(vif); 420 bool any_active = wil_has_active_ifaces(wil, true, false); 421 int rc; 422 423 ASSERT_RTNL(); 424 425 if (wil->vifs[vif->mid]) { 426 dev_err(&ndev->dev, "VIF with mid %d already in use\n", 427 vif->mid); 428 return -EEXIST; 429 } 430 if (any_active && vif->mid != 0) { 431 rc = wmi_port_allocate(wil, vif->mid, ndev->dev_addr, 432 wdev->iftype); 433 if (rc) 434 return rc; 435 } 436 rc = register_netdevice(ndev); 437 if (rc < 0) { 438 dev_err(&ndev->dev, "Failed to register netdev: %d\n", rc); 439 if (any_active && vif->mid != 0) 440 wmi_port_delete(wil, vif->mid); 441 return rc; 442 } 443 444 wil->vifs[vif->mid] = vif; 445 return 0; 446 } 447 448 int wil_if_add(struct wil6210_priv *wil) 449 { 450 struct wiphy *wiphy = wil->wiphy; 451 struct net_device *ndev = wil->main_ndev; 452 struct wil6210_vif *vif = ndev_to_vif(ndev); 453 int rc; 454 455 wil_dbg_misc(wil, "entered"); 456 457 strlcpy(wiphy->fw_version, wil->fw_version, sizeof(wiphy->fw_version)); 458 459 rc = wiphy_register(wiphy); 460 if (rc < 0) { 461 wil_err(wil, "failed to register wiphy, err %d\n", rc); 462 return rc; 463 } 464 465 init_dummy_netdev(&wil->napi_ndev); 466 if (wil->use_enhanced_dma_hw) { 467 netif_napi_add(&wil->napi_ndev, &wil->napi_rx, 468 wil6210_netdev_poll_rx_edma, 469 WIL6210_NAPI_BUDGET); 470 netif_tx_napi_add(&wil->napi_ndev, 471 &wil->napi_tx, wil6210_netdev_poll_tx_edma, 472 WIL6210_NAPI_BUDGET); 473 } else { 474 netif_napi_add(&wil->napi_ndev, &wil->napi_rx, 475 wil6210_netdev_poll_rx, 476 WIL6210_NAPI_BUDGET); 477 netif_tx_napi_add(&wil->napi_ndev, 478 &wil->napi_tx, wil6210_netdev_poll_tx, 479 WIL6210_NAPI_BUDGET); 480 } 481 482 wil_update_net_queues_bh(wil, vif, NULL, true); 483 484 rtnl_lock(); 485 rc = wil_vif_add(wil, vif); 486 rtnl_unlock(); 487 if (rc < 0) 488 goto out_wiphy; 489 490 return 0; 491 492 out_wiphy: 493 wiphy_unregister(wiphy); 494 return rc; 495 } 496 497 void wil_vif_remove(struct wil6210_priv *wil, u8 mid) 498 { 499 struct wil6210_vif *vif; 500 struct net_device *ndev; 501 bool any_active = wil_has_active_ifaces(wil, true, false); 502 503 ASSERT_RTNL(); 504 if (mid >= wil->max_vifs) { 505 wil_err(wil, "invalid MID: %d\n", mid); 506 return; 507 } 508 509 vif = wil->vifs[mid]; 510 if (!vif) { 511 wil_err(wil, "MID %d not registered\n", mid); 512 return; 513 } 514 515 mutex_lock(&wil->mutex); 516 wil6210_disconnect(vif, NULL, WLAN_REASON_DEAUTH_LEAVING, false); 517 mutex_unlock(&wil->mutex); 518 519 ndev = vif_to_ndev(vif); 520 /* during unregister_netdevice cfg80211_leave may perform operations 521 * such as stop AP, disconnect, so we only clear the VIF afterwards 522 */ 523 unregister_netdevice(ndev); 524 525 if (any_active && vif->mid != 0) 526 wmi_port_delete(wil, vif->mid); 527 528 /* make sure no one is accessing the VIF before removing */ 529 mutex_lock(&wil->vif_mutex); 530 wil->vifs[mid] = NULL; 531 /* ensure NAPI code will see the NULL VIF */ 532 wmb(); 533 if (test_bit(wil_status_napi_en, wil->status)) { 534 napi_synchronize(&wil->napi_rx); 535 napi_synchronize(&wil->napi_tx); 536 } 537 mutex_unlock(&wil->vif_mutex); 538 539 flush_work(&wil->wmi_event_worker); 540 del_timer_sync(&vif->connect_timer); 541 cancel_work_sync(&vif->disconnect_worker); 542 wil_probe_client_flush(vif); 543 cancel_work_sync(&vif->probe_client_worker); 544 /* for VIFs, ndev will be freed by destructor after RTNL is unlocked. 545 * the main interface will be freed in wil_if_free, we need to keep it 546 * a bit longer so logging macros will work. 547 */ 548 } 549 550 void wil_if_remove(struct wil6210_priv *wil) 551 { 552 struct net_device *ndev = wil->main_ndev; 553 struct wireless_dev *wdev = ndev->ieee80211_ptr; 554 555 wil_dbg_misc(wil, "if_remove\n"); 556 557 rtnl_lock(); 558 wil_vif_remove(wil, 0); 559 rtnl_unlock(); 560 561 netif_napi_del(&wil->napi_tx); 562 netif_napi_del(&wil->napi_rx); 563 564 wiphy_unregister(wdev->wiphy); 565 } 566