netdev.c

  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
 12bool 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
 33bool 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
 39static 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
 66static 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
 83static 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
 91static 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
112static 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
133static 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
170static 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
194static 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
201static 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
213void 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
221static 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
228static 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
244static 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
254static 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
265static 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
286static 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
298struct wil6210_vif *
299wil_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
349void *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
381out_priv:
382	wil_priv_deinit(wil);
383
384out_cfg:
385	wil_cfg80211_deinit(wil);
386
387	return ERR_PTR(rc);
388}
389
390void 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
408int 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
440int 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
487free_dummy:
488	free_netdev(wil->napi_ndev);
489out_wiphy:
490	wiphy_unregister(wiphy);
491	return rc;
492}
493
494void 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
548void 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}