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