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
wil_has_other_active_ifaces(struct wil6210_priv * wil,struct net_device * ndev,bool up,bool ok)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
wil_has_active_ifaces(struct wil6210_priv * wil,bool up,bool ok)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
wil_open(struct net_device * ndev)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
wil_stop(struct net_device * ndev)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
wil6210_netdev_poll_rx(struct napi_struct * napi,int budget)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
wil6210_netdev_poll_rx_edma(struct napi_struct * napi,int budget)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
wil6210_netdev_poll_tx(struct napi_struct * napi,int budget)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
wil6210_netdev_poll_tx_edma(struct napi_struct * napi,int budget)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
wil_dev_setup(struct net_device * dev)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
wil_vif_deinit(struct wil6210_vif * vif)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
wil_vif_free(struct wil6210_vif * vif)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
wil_ndev_destructor(struct net_device * ndev)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
wil_connect_timer_fn(struct timer_list * t)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
wil_scan_timer_fn(struct timer_list * t)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
wil_p2p_discovery_timer_fn(struct timer_list * t)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
wil_vif_init(struct wil6210_vif * vif)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
wil_vif_find_free_mid(struct wil6210_priv * wil)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 *
wil_vif_alloc(struct wil6210_priv * wil,const char * name,unsigned char name_assign_type,enum nl80211_iftype iftype)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
wil_if_alloc(struct device * dev)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
wil_if_free(struct wil6210_priv * wil)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
wil_vif_add(struct wil6210_priv * wil,struct wil6210_vif * vif)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
wil_if_add(struct wil6210_priv * wil)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
wil_vif_remove(struct wil6210_priv * wil,u8 mid)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
wil_if_remove(struct wil6210_priv * wil)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