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