1 /*
2  * Copyright (c) 2012-2017 Qualcomm Atheros, Inc.
3  * Copyright (c) 2018-2019, 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 < GET_MAX_VIFS(wil); 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, &quota);
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, &quota);
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 >= GET_MAX_VIFS(wil))
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 < GET_MAX_VIFS(wil); 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 
350 	ndev->features |= ndev->hw_features;
351 	SET_NETDEV_DEV(ndev, wiphy_dev(wdev->wiphy));
352 	wdev->netdev = ndev;
353 	return vif;
354 }
355 
356 void *wil_if_alloc(struct device *dev)
357 {
358 	struct wil6210_priv *wil;
359 	struct wil6210_vif *vif;
360 	int rc = 0;
361 
362 	wil = wil_cfg80211_init(dev);
363 	if (IS_ERR(wil)) {
364 		dev_err(dev, "wil_cfg80211_init failed\n");
365 		return wil;
366 	}
367 
368 	rc = wil_priv_init(wil);
369 	if (rc) {
370 		dev_err(dev, "wil_priv_init failed\n");
371 		goto out_cfg;
372 	}
373 
374 	wil_dbg_misc(wil, "if_alloc\n");
375 
376 	vif = wil_vif_alloc(wil, "wlan%d", NET_NAME_UNKNOWN,
377 			    NL80211_IFTYPE_STATION);
378 	if (IS_ERR(vif)) {
379 		dev_err(dev, "wil_vif_alloc failed\n");
380 		rc = -ENOMEM;
381 		goto out_priv;
382 	}
383 
384 	wil->radio_wdev = vif_to_wdev(vif);
385 
386 	return wil;
387 
388 out_priv:
389 	wil_priv_deinit(wil);
390 
391 out_cfg:
392 	wil_cfg80211_deinit(wil);
393 
394 	return ERR_PTR(rc);
395 }
396 
397 void wil_if_free(struct wil6210_priv *wil)
398 {
399 	struct net_device *ndev = wil->main_ndev;
400 
401 	wil_dbg_misc(wil, "if_free\n");
402 
403 	if (!ndev)
404 		return;
405 
406 	wil_priv_deinit(wil);
407 
408 	wil->main_ndev = NULL;
409 	wil_ndev_destructor(ndev);
410 	free_netdev(ndev);
411 
412 	wil_cfg80211_deinit(wil);
413 }
414 
415 int wil_vif_add(struct wil6210_priv *wil, struct wil6210_vif *vif)
416 {
417 	struct net_device *ndev = vif_to_ndev(vif);
418 	struct wireless_dev *wdev = vif_to_wdev(vif);
419 	bool any_active = wil_has_active_ifaces(wil, true, false);
420 	int rc;
421 
422 	ASSERT_RTNL();
423 
424 	if (wil->vifs[vif->mid]) {
425 		dev_err(&ndev->dev, "VIF with mid %d already in use\n",
426 			vif->mid);
427 		return -EEXIST;
428 	}
429 	if (any_active && vif->mid != 0) {
430 		rc = wmi_port_allocate(wil, vif->mid, ndev->dev_addr,
431 				       wdev->iftype);
432 		if (rc)
433 			return rc;
434 	}
435 	rc = register_netdevice(ndev);
436 	if (rc < 0) {
437 		dev_err(&ndev->dev, "Failed to register netdev: %d\n", rc);
438 		if (any_active && vif->mid != 0)
439 			wmi_port_delete(wil, vif->mid);
440 		return rc;
441 	}
442 
443 	wil->vifs[vif->mid] = vif;
444 	return 0;
445 }
446 
447 int wil_if_add(struct wil6210_priv *wil)
448 {
449 	struct wiphy *wiphy = wil->wiphy;
450 	struct net_device *ndev = wil->main_ndev;
451 	struct wil6210_vif *vif = ndev_to_vif(ndev);
452 	int rc;
453 
454 	wil_dbg_misc(wil, "entered");
455 
456 	strlcpy(wiphy->fw_version, wil->fw_version, sizeof(wiphy->fw_version));
457 
458 	rc = wiphy_register(wiphy);
459 	if (rc < 0) {
460 		wil_err(wil, "failed to register wiphy, err %d\n", rc);
461 		return rc;
462 	}
463 
464 	init_dummy_netdev(&wil->napi_ndev);
465 	if (wil->use_enhanced_dma_hw) {
466 		netif_napi_add(&wil->napi_ndev, &wil->napi_rx,
467 			       wil6210_netdev_poll_rx_edma,
468 			       WIL6210_NAPI_BUDGET);
469 		netif_tx_napi_add(&wil->napi_ndev,
470 				  &wil->napi_tx, wil6210_netdev_poll_tx_edma,
471 				  WIL6210_NAPI_BUDGET);
472 	} else {
473 		netif_napi_add(&wil->napi_ndev, &wil->napi_rx,
474 			       wil6210_netdev_poll_rx,
475 			       WIL6210_NAPI_BUDGET);
476 		netif_tx_napi_add(&wil->napi_ndev,
477 				  &wil->napi_tx, wil6210_netdev_poll_tx,
478 				  WIL6210_NAPI_BUDGET);
479 	}
480 
481 	wil_update_net_queues_bh(wil, vif, NULL, true);
482 
483 	rtnl_lock();
484 	rc = wil_vif_add(wil, vif);
485 	rtnl_unlock();
486 	if (rc < 0)
487 		goto out_wiphy;
488 
489 	return 0;
490 
491 out_wiphy:
492 	wiphy_unregister(wiphy);
493 	return rc;
494 }
495 
496 void wil_vif_remove(struct wil6210_priv *wil, u8 mid)
497 {
498 	struct wil6210_vif *vif;
499 	struct net_device *ndev;
500 	bool any_active = wil_has_active_ifaces(wil, true, false);
501 
502 	ASSERT_RTNL();
503 	if (mid >= GET_MAX_VIFS(wil)) {
504 		wil_err(wil, "invalid MID: %d\n", mid);
505 		return;
506 	}
507 
508 	vif = wil->vifs[mid];
509 	if (!vif) {
510 		wil_err(wil, "MID %d not registered\n", mid);
511 		return;
512 	}
513 
514 	mutex_lock(&wil->mutex);
515 	wil6210_disconnect(vif, NULL, WLAN_REASON_DEAUTH_LEAVING);
516 	mutex_unlock(&wil->mutex);
517 
518 	ndev = vif_to_ndev(vif);
519 	/* during unregister_netdevice cfg80211_leave may perform operations
520 	 * such as stop AP, disconnect, so we only clear the VIF afterwards
521 	 */
522 	unregister_netdevice(ndev);
523 
524 	if (any_active && vif->mid != 0)
525 		wmi_port_delete(wil, vif->mid);
526 
527 	/* make sure no one is accessing the VIF before removing */
528 	mutex_lock(&wil->vif_mutex);
529 	wil->vifs[mid] = NULL;
530 	/* ensure NAPI code will see the NULL VIF */
531 	wmb();
532 	if (test_bit(wil_status_napi_en, wil->status)) {
533 		napi_synchronize(&wil->napi_rx);
534 		napi_synchronize(&wil->napi_tx);
535 	}
536 	mutex_unlock(&wil->vif_mutex);
537 
538 	flush_work(&wil->wmi_event_worker);
539 	del_timer_sync(&vif->connect_timer);
540 	cancel_work_sync(&vif->disconnect_worker);
541 	wil_probe_client_flush(vif);
542 	cancel_work_sync(&vif->probe_client_worker);
543 	/* for VIFs, ndev will be freed by destructor after RTNL is unlocked.
544 	 * the main interface will be freed in wil_if_free, we need to keep it
545 	 * a bit longer so logging macros will work.
546 	 */
547 }
548 
549 void wil_if_remove(struct wil6210_priv *wil)
550 {
551 	struct net_device *ndev = wil->main_ndev;
552 	struct wireless_dev *wdev = ndev->ieee80211_ptr;
553 
554 	wil_dbg_misc(wil, "if_remove\n");
555 
556 	rtnl_lock();
557 	wil_vif_remove(wil, 0);
558 	rtnl_unlock();
559 
560 	netif_napi_del(&wil->napi_tx);
561 	netif_napi_del(&wil->napi_rx);
562 
563 	wiphy_unregister(wdev->wiphy);
564 }
565