1
2
3
4#include <linux/kernel.h>
5#include <linux/module.h>
6#include <linux/if_ether.h>
7#include <linux/nospec.h>
8
9#include "core.h"
10#include "bus.h"
11#include "trans.h"
12#include "commands.h"
13#include "cfg80211.h"
14#include "event.h"
15#include "util.h"
16#include "switchdev.h"
17
18#define QTNF_DMP_MAX_LEN 48
19#define QTNF_PRIMARY_VIF_IDX 0
20
21static bool slave_radar = true;
22module_param(slave_radar, bool, 0644);
23MODULE_PARM_DESC(slave_radar, "set 0 to disable radar detection in slave mode");
24
25static bool dfs_offload;
26module_param(dfs_offload, bool, 0644);
27MODULE_PARM_DESC(dfs_offload, "set 1 to enable DFS offload to firmware");
28
29static struct dentry *qtnf_debugfs_dir;
30
31bool qtnf_slave_radar_get(void)
32{
33 return slave_radar;
34}
35
36bool qtnf_dfs_offload_get(void)
37{
38 return dfs_offload;
39}
40
41struct qtnf_wmac *qtnf_core_get_mac(const struct qtnf_bus *bus, u8 macid)
42{
43 struct qtnf_wmac *mac = NULL;
44
45 if (macid >= QTNF_MAX_MAC) {
46 pr_err("invalid MAC index %u\n", macid);
47 return NULL;
48 }
49
50 macid = array_index_nospec(macid, QTNF_MAX_MAC);
51 mac = bus->mac[macid];
52
53 if (unlikely(!mac)) {
54 pr_err("MAC%u: not initialized\n", macid);
55 return NULL;
56 }
57
58 return mac;
59}
60
61
62
63static int qtnf_netdev_open(struct net_device *ndev)
64{
65 netif_carrier_off(ndev);
66 qtnf_netdev_updown(ndev, 1);
67 return 0;
68}
69
70
71
72static int qtnf_netdev_close(struct net_device *ndev)
73{
74 netif_carrier_off(ndev);
75 qtnf_virtual_intf_cleanup(ndev);
76 qtnf_netdev_updown(ndev, 0);
77 return 0;
78}
79
80static void qtnf_packet_send_hi_pri(struct sk_buff *skb)
81{
82 struct qtnf_vif *vif = qtnf_netdev_get_priv(skb->dev);
83
84 skb_queue_tail(&vif->high_pri_tx_queue, skb);
85 queue_work(vif->mac->bus->hprio_workqueue, &vif->high_pri_tx_work);
86}
87
88
89
90static netdev_tx_t
91qtnf_netdev_hard_start_xmit(struct sk_buff *skb, struct net_device *ndev)
92{
93 struct qtnf_vif *vif;
94 struct qtnf_wmac *mac;
95
96 vif = qtnf_netdev_get_priv(ndev);
97
98 if (unlikely(skb->dev != ndev)) {
99 pr_err_ratelimited("invalid skb->dev");
100 dev_kfree_skb_any(skb);
101 return 0;
102 }
103
104 if (unlikely(vif->wdev.iftype == NL80211_IFTYPE_UNSPECIFIED)) {
105 pr_err_ratelimited("%s: VIF not initialized\n", ndev->name);
106 dev_kfree_skb_any(skb);
107 return 0;
108 }
109
110 mac = vif->mac;
111 if (unlikely(!mac)) {
112 pr_err_ratelimited("%s: NULL mac pointer", ndev->name);
113 dev_kfree_skb_any(skb);
114 return 0;
115 }
116
117 if (!skb->len || (skb->len > ETH_FRAME_LEN)) {
118 pr_err_ratelimited("%s: invalid skb len %d\n", ndev->name,
119 skb->len);
120 dev_kfree_skb_any(skb);
121 ndev->stats.tx_dropped++;
122 return 0;
123 }
124
125
126 vif->cons_tx_timeout_cnt = 0;
127
128 if (unlikely(skb->protocol == htons(ETH_P_PAE))) {
129 qtnf_packet_send_hi_pri(skb);
130 qtnf_update_tx_stats(ndev, skb);
131 return NETDEV_TX_OK;
132 }
133
134 return qtnf_bus_data_tx(mac->bus, skb, mac->macid, vif->vifid);
135}
136
137
138
139static void qtnf_netdev_get_stats64(struct net_device *ndev,
140 struct rtnl_link_stats64 *stats)
141{
142 struct qtnf_vif *vif = qtnf_netdev_get_priv(ndev);
143 unsigned int start;
144 int cpu;
145
146 netdev_stats_to_stats64(stats, &ndev->stats);
147
148 if (!vif->stats64)
149 return;
150
151 for_each_possible_cpu(cpu) {
152 struct pcpu_sw_netstats *stats64;
153 u64 rx_packets, rx_bytes;
154 u64 tx_packets, tx_bytes;
155
156 stats64 = per_cpu_ptr(vif->stats64, cpu);
157
158 do {
159 start = u64_stats_fetch_begin_irq(&stats64->syncp);
160 rx_packets = stats64->rx_packets;
161 rx_bytes = stats64->rx_bytes;
162 tx_packets = stats64->tx_packets;
163 tx_bytes = stats64->tx_bytes;
164 } while (u64_stats_fetch_retry_irq(&stats64->syncp, start));
165
166 stats->rx_packets += rx_packets;
167 stats->rx_bytes += rx_bytes;
168 stats->tx_packets += tx_packets;
169 stats->tx_bytes += tx_bytes;
170 }
171}
172
173
174
175static void qtnf_netdev_tx_timeout(struct net_device *ndev, unsigned int txqueue)
176{
177 struct qtnf_vif *vif = qtnf_netdev_get_priv(ndev);
178 struct qtnf_wmac *mac;
179 struct qtnf_bus *bus;
180
181 if (unlikely(!vif || !vif->mac || !vif->mac->bus))
182 return;
183
184 mac = vif->mac;
185 bus = mac->bus;
186
187 pr_warn("VIF%u.%u: Tx timeout- %lu\n", mac->macid, vif->vifid, jiffies);
188
189 qtnf_bus_data_tx_timeout(bus, ndev);
190 ndev->stats.tx_errors++;
191
192 if (++vif->cons_tx_timeout_cnt > QTNF_TX_TIMEOUT_TRSHLD) {
193 pr_err("Tx timeout threshold exceeded !\n");
194 pr_err("schedule interface %s reset !\n", netdev_name(ndev));
195 queue_work(bus->workqueue, &vif->reset_work);
196 }
197}
198
199static int qtnf_netdev_set_mac_address(struct net_device *ndev, void *addr)
200{
201 struct qtnf_vif *vif = qtnf_netdev_get_priv(ndev);
202 struct sockaddr *sa = addr;
203 int ret;
204 unsigned char old_addr[ETH_ALEN];
205
206 memcpy(old_addr, sa->sa_data, sizeof(old_addr));
207
208 ret = eth_mac_addr(ndev, sa);
209 if (ret)
210 return ret;
211
212 qtnf_scan_done(vif->mac, true);
213
214 ret = qtnf_cmd_send_change_intf_type(vif, vif->wdev.iftype,
215 vif->wdev.use_4addr,
216 sa->sa_data);
217
218 if (ret)
219 memcpy(ndev->dev_addr, old_addr, ETH_ALEN);
220
221 return ret;
222}
223
224static int qtnf_netdev_port_parent_id(struct net_device *ndev,
225 struct netdev_phys_item_id *ppid)
226{
227 const struct qtnf_vif *vif = qtnf_netdev_get_priv(ndev);
228 const struct qtnf_bus *bus = vif->mac->bus;
229
230 ppid->id_len = sizeof(bus->hw_id);
231 memcpy(&ppid->id, bus->hw_id, ppid->id_len);
232
233 return 0;
234}
235
236
237const struct net_device_ops qtnf_netdev_ops = {
238 .ndo_open = qtnf_netdev_open,
239 .ndo_stop = qtnf_netdev_close,
240 .ndo_start_xmit = qtnf_netdev_hard_start_xmit,
241 .ndo_tx_timeout = qtnf_netdev_tx_timeout,
242 .ndo_get_stats64 = qtnf_netdev_get_stats64,
243 .ndo_set_mac_address = qtnf_netdev_set_mac_address,
244 .ndo_get_port_parent_id = qtnf_netdev_port_parent_id,
245};
246
247static int qtnf_mac_init_single_band(struct wiphy *wiphy,
248 struct qtnf_wmac *mac,
249 enum nl80211_band band)
250{
251 int ret;
252
253 wiphy->bands[band] = kzalloc(sizeof(*wiphy->bands[band]), GFP_KERNEL);
254 if (!wiphy->bands[band])
255 return -ENOMEM;
256
257 wiphy->bands[band]->band = band;
258
259 ret = qtnf_cmd_band_info_get(mac, wiphy->bands[band]);
260 if (ret) {
261 pr_err("MAC%u: band %u: failed to get chans info: %d\n",
262 mac->macid, band, ret);
263 return ret;
264 }
265
266 qtnf_band_init_rates(wiphy->bands[band]);
267
268 return 0;
269}
270
271static int qtnf_mac_init_bands(struct qtnf_wmac *mac)
272{
273 struct wiphy *wiphy = priv_to_wiphy(mac);
274 int ret = 0;
275
276 if (mac->macinfo.bands_cap & QLINK_BAND_2GHZ) {
277 ret = qtnf_mac_init_single_band(wiphy, mac, NL80211_BAND_2GHZ);
278 if (ret)
279 goto out;
280 }
281
282 if (mac->macinfo.bands_cap & QLINK_BAND_5GHZ) {
283 ret = qtnf_mac_init_single_band(wiphy, mac, NL80211_BAND_5GHZ);
284 if (ret)
285 goto out;
286 }
287
288 if (mac->macinfo.bands_cap & QLINK_BAND_60GHZ)
289 ret = qtnf_mac_init_single_band(wiphy, mac, NL80211_BAND_60GHZ);
290
291out:
292 return ret;
293}
294
295struct qtnf_vif *qtnf_mac_get_free_vif(struct qtnf_wmac *mac)
296{
297 struct qtnf_vif *vif;
298 int i;
299
300 for (i = 0; i < QTNF_MAX_INTF; i++) {
301 vif = &mac->iflist[i];
302 if (vif->wdev.iftype == NL80211_IFTYPE_UNSPECIFIED)
303 return vif;
304 }
305
306 return NULL;
307}
308
309struct qtnf_vif *qtnf_mac_get_base_vif(struct qtnf_wmac *mac)
310{
311 struct qtnf_vif *vif;
312
313 vif = &mac->iflist[QTNF_PRIMARY_VIF_IDX];
314
315 if (vif->wdev.iftype == NL80211_IFTYPE_UNSPECIFIED)
316 return NULL;
317
318 return vif;
319}
320
321void qtnf_mac_iface_comb_free(struct qtnf_wmac *mac)
322{
323 struct ieee80211_iface_combination *comb;
324 int i;
325
326 if (mac->macinfo.if_comb) {
327 for (i = 0; i < mac->macinfo.n_if_comb; i++) {
328 comb = &mac->macinfo.if_comb[i];
329 kfree(comb->limits);
330 comb->limits = NULL;
331 }
332
333 kfree(mac->macinfo.if_comb);
334 mac->macinfo.if_comb = NULL;
335 }
336}
337
338void qtnf_mac_ext_caps_free(struct qtnf_wmac *mac)
339{
340 if (mac->macinfo.extended_capabilities_len) {
341 kfree(mac->macinfo.extended_capabilities);
342 mac->macinfo.extended_capabilities = NULL;
343
344 kfree(mac->macinfo.extended_capabilities_mask);
345 mac->macinfo.extended_capabilities_mask = NULL;
346
347 mac->macinfo.extended_capabilities_len = 0;
348 }
349}
350
351static void qtnf_vif_reset_handler(struct work_struct *work)
352{
353 struct qtnf_vif *vif = container_of(work, struct qtnf_vif, reset_work);
354
355 rtnl_lock();
356
357 if (vif->wdev.iftype == NL80211_IFTYPE_UNSPECIFIED) {
358 rtnl_unlock();
359 return;
360 }
361
362
363 netif_tx_stop_all_queues(vif->netdev);
364 if (netif_carrier_ok(vif->netdev))
365 netif_carrier_off(vif->netdev);
366
367 qtnf_cfg80211_vif_reset(vif);
368
369 rtnl_unlock();
370}
371
372static void qtnf_mac_init_primary_intf(struct qtnf_wmac *mac)
373{
374 struct qtnf_vif *vif = &mac->iflist[QTNF_PRIMARY_VIF_IDX];
375
376 vif->wdev.iftype = NL80211_IFTYPE_STATION;
377 vif->bss_priority = QTNF_DEF_BSS_PRIORITY;
378 vif->wdev.wiphy = priv_to_wiphy(mac);
379 INIT_WORK(&vif->reset_work, qtnf_vif_reset_handler);
380 vif->cons_tx_timeout_cnt = 0;
381}
382
383static void qtnf_mac_scan_finish(struct qtnf_wmac *mac, bool aborted)
384{
385 struct cfg80211_scan_info info = {
386 .aborted = aborted,
387 };
388
389 mutex_lock(&mac->mac_lock);
390
391 if (mac->scan_req) {
392 cfg80211_scan_done(mac->scan_req, &info);
393 mac->scan_req = NULL;
394 }
395
396 mutex_unlock(&mac->mac_lock);
397}
398
399void qtnf_scan_done(struct qtnf_wmac *mac, bool aborted)
400{
401 cancel_delayed_work_sync(&mac->scan_timeout);
402 qtnf_mac_scan_finish(mac, aborted);
403}
404
405static void qtnf_mac_scan_timeout(struct work_struct *work)
406{
407 struct qtnf_wmac *mac =
408 container_of(work, struct qtnf_wmac, scan_timeout.work);
409
410 pr_warn("MAC%d: scan timed out\n", mac->macid);
411 qtnf_mac_scan_finish(mac, true);
412}
413
414static void qtnf_vif_send_data_high_pri(struct work_struct *work)
415{
416 struct qtnf_vif *vif =
417 container_of(work, struct qtnf_vif, high_pri_tx_work);
418 struct sk_buff *skb;
419
420 if (!vif->netdev ||
421 vif->wdev.iftype == NL80211_IFTYPE_UNSPECIFIED)
422 return;
423
424 while ((skb = skb_dequeue(&vif->high_pri_tx_queue))) {
425 qtnf_cmd_send_frame(vif, 0, QLINK_FRAME_TX_FLAG_8023,
426 0, skb->data, skb->len);
427 dev_kfree_skb_any(skb);
428 }
429}
430
431static struct qtnf_wmac *qtnf_core_mac_alloc(struct qtnf_bus *bus,
432 unsigned int macid)
433{
434 struct platform_device *pdev = NULL;
435 struct qtnf_wmac *mac;
436 struct qtnf_vif *vif;
437 struct wiphy *wiphy;
438 unsigned int i;
439
440 if (bus->hw_info.num_mac > 1) {
441 pdev = platform_device_register_data(bus->dev,
442 dev_name(bus->dev),
443 macid, NULL, 0);
444 if (IS_ERR(pdev))
445 return ERR_PTR(-EINVAL);
446 }
447
448 wiphy = qtnf_wiphy_allocate(bus, pdev);
449 if (!wiphy) {
450 if (pdev)
451 platform_device_unregister(pdev);
452 return ERR_PTR(-ENOMEM);
453 }
454
455 mac = wiphy_priv(wiphy);
456
457 mac->macid = macid;
458 mac->pdev = pdev;
459 mac->bus = bus;
460 mutex_init(&mac->mac_lock);
461 INIT_DELAYED_WORK(&mac->scan_timeout, qtnf_mac_scan_timeout);
462
463 for (i = 0; i < QTNF_MAX_INTF; i++) {
464 vif = &mac->iflist[i];
465
466 memset(vif, 0, sizeof(*vif));
467 vif->wdev.iftype = NL80211_IFTYPE_UNSPECIFIED;
468 vif->mac = mac;
469 vif->vifid = i;
470 qtnf_sta_list_init(&vif->sta_list);
471 INIT_WORK(&vif->high_pri_tx_work, qtnf_vif_send_data_high_pri);
472 skb_queue_head_init(&vif->high_pri_tx_queue);
473 vif->stats64 = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
474 if (!vif->stats64)
475 pr_warn("VIF%u.%u: per cpu stats allocation failed\n",
476 macid, i);
477 }
478
479 qtnf_mac_init_primary_intf(mac);
480 bus->mac[macid] = mac;
481
482 return mac;
483}
484
485static const struct ethtool_ops qtnf_ethtool_ops = {
486 .get_drvinfo = cfg80211_get_drvinfo,
487};
488
489int qtnf_core_net_attach(struct qtnf_wmac *mac, struct qtnf_vif *vif,
490 const char *name, unsigned char name_assign_type)
491{
492 struct wiphy *wiphy = priv_to_wiphy(mac);
493 struct net_device *dev;
494 void *qdev_vif;
495 int ret;
496
497 dev = alloc_netdev_mqs(sizeof(struct qtnf_vif *), name,
498 name_assign_type, ether_setup, 1, 1);
499 if (!dev)
500 return -ENOMEM;
501
502 vif->netdev = dev;
503
504 dev->netdev_ops = &qtnf_netdev_ops;
505 dev->needs_free_netdev = true;
506 dev_net_set(dev, wiphy_net(wiphy));
507 dev->ieee80211_ptr = &vif->wdev;
508 ether_addr_copy(dev->dev_addr, vif->mac_addr);
509 dev->flags |= IFF_BROADCAST | IFF_MULTICAST;
510 dev->watchdog_timeo = QTNF_DEF_WDOG_TIMEOUT;
511 dev->tx_queue_len = 100;
512 dev->ethtool_ops = &qtnf_ethtool_ops;
513
514 if (qtnf_hwcap_is_set(&mac->bus->hw_info, QLINK_HW_CAPAB_HW_BRIDGE))
515 dev->needed_tailroom = sizeof(struct qtnf_frame_meta_info);
516
517 qdev_vif = netdev_priv(dev);
518 *((void **)qdev_vif) = vif;
519
520 SET_NETDEV_DEV(dev, wiphy_dev(wiphy));
521
522 ret = register_netdevice(dev);
523 if (ret) {
524 free_netdev(dev);
525 vif->netdev = NULL;
526 }
527
528 return ret;
529}
530
531static void qtnf_core_mac_detach(struct qtnf_bus *bus, unsigned int macid)
532{
533 struct qtnf_wmac *mac;
534 struct wiphy *wiphy;
535 struct qtnf_vif *vif;
536 unsigned int i;
537 enum nl80211_band band;
538
539 mac = bus->mac[macid];
540
541 if (!mac)
542 return;
543
544 wiphy = priv_to_wiphy(mac);
545
546 for (i = 0; i < QTNF_MAX_INTF; i++) {
547 vif = &mac->iflist[i];
548 rtnl_lock();
549 if (vif->netdev &&
550 vif->wdev.iftype != NL80211_IFTYPE_UNSPECIFIED) {
551 qtnf_virtual_intf_cleanup(vif->netdev);
552 qtnf_del_virtual_intf(wiphy, &vif->wdev);
553 }
554 rtnl_unlock();
555 qtnf_sta_list_free(&vif->sta_list);
556 free_percpu(vif->stats64);
557 }
558
559 if (mac->wiphy_registered)
560 wiphy_unregister(wiphy);
561
562 for (band = NL80211_BAND_2GHZ; band < NUM_NL80211_BANDS; ++band) {
563 if (!wiphy->bands[band])
564 continue;
565
566 kfree(wiphy->bands[band]->iftype_data);
567 wiphy->bands[band]->n_iftype_data = 0;
568
569 kfree(wiphy->bands[band]->channels);
570 wiphy->bands[band]->n_channels = 0;
571
572 kfree(wiphy->bands[band]);
573 wiphy->bands[band] = NULL;
574 }
575
576 platform_device_unregister(mac->pdev);
577 qtnf_mac_iface_comb_free(mac);
578 qtnf_mac_ext_caps_free(mac);
579 kfree(mac->macinfo.wowlan);
580 kfree(mac->rd);
581 mac->rd = NULL;
582 wiphy_free(wiphy);
583 bus->mac[macid] = NULL;
584}
585
586static int qtnf_core_mac_attach(struct qtnf_bus *bus, unsigned int macid)
587{
588 struct qtnf_wmac *mac;
589 struct qtnf_vif *vif;
590 int ret;
591
592 if (!(bus->hw_info.mac_bitmap & BIT(macid))) {
593 pr_info("MAC%u is not active in FW\n", macid);
594 return 0;
595 }
596
597 mac = qtnf_core_mac_alloc(bus, macid);
598 if (IS_ERR(mac)) {
599 pr_err("MAC%u allocation failed\n", macid);
600 return PTR_ERR(mac);
601 }
602
603 vif = qtnf_mac_get_base_vif(mac);
604 if (!vif) {
605 pr_err("MAC%u: primary VIF is not ready\n", macid);
606 ret = -EFAULT;
607 goto error;
608 }
609
610 ret = qtnf_cmd_send_add_intf(vif, vif->wdev.iftype,
611 vif->wdev.use_4addr, vif->mac_addr);
612 if (ret) {
613 pr_err("MAC%u: failed to add VIF\n", macid);
614 goto error;
615 }
616
617 ret = qtnf_cmd_get_mac_info(mac);
618 if (ret) {
619 pr_err("MAC%u: failed to get MAC info\n", macid);
620 goto error_del_vif;
621 }
622
623
624 if (is_zero_ether_addr(mac->bus->hw_id))
625 ether_addr_copy(mac->bus->hw_id, mac->macaddr);
626
627 ret = qtnf_mac_init_bands(mac);
628 if (ret) {
629 pr_err("MAC%u: failed to init bands\n", macid);
630 goto error_del_vif;
631 }
632
633 ret = qtnf_wiphy_register(&bus->hw_info, mac);
634 if (ret) {
635 pr_err("MAC%u: wiphy registration failed\n", macid);
636 goto error_del_vif;
637 }
638
639 mac->wiphy_registered = 1;
640
641 rtnl_lock();
642
643 ret = qtnf_core_net_attach(mac, vif, "wlan%d", NET_NAME_ENUM);
644 rtnl_unlock();
645
646 if (ret) {
647 pr_err("MAC%u: failed to attach netdev\n", macid);
648 goto error_del_vif;
649 }
650
651 if (qtnf_hwcap_is_set(&bus->hw_info, QLINK_HW_CAPAB_HW_BRIDGE)) {
652 ret = qtnf_cmd_netdev_changeupper(vif, vif->netdev->ifindex);
653 if (ret)
654 goto error;
655 }
656
657 pr_debug("MAC%u initialized\n", macid);
658
659 return 0;
660
661error_del_vif:
662 qtnf_cmd_send_del_intf(vif);
663 vif->wdev.iftype = NL80211_IFTYPE_UNSPECIFIED;
664error:
665 qtnf_core_mac_detach(bus, macid);
666 return ret;
667}
668
669bool qtnf_netdev_is_qtn(const struct net_device *ndev)
670{
671 return ndev->netdev_ops == &qtnf_netdev_ops;
672}
673
674static int qtnf_check_br_ports(struct net_device *dev,
675 struct netdev_nested_priv *priv)
676{
677 struct net_device *ndev = (struct net_device *)priv->data;
678
679 if (dev != ndev && netdev_port_same_parent_id(dev, ndev))
680 return -ENOTSUPP;
681
682 return 0;
683}
684
685static int qtnf_core_netdevice_event(struct notifier_block *nb,
686 unsigned long event, void *ptr)
687{
688 struct net_device *ndev = netdev_notifier_info_to_dev(ptr);
689 const struct netdev_notifier_changeupper_info *info;
690 struct netdev_nested_priv priv = {
691 .data = (void *)ndev,
692 };
693 struct net_device *brdev;
694 struct qtnf_vif *vif;
695 struct qtnf_bus *bus;
696 int br_domain;
697 int ret = 0;
698
699 if (!qtnf_netdev_is_qtn(ndev))
700 return NOTIFY_DONE;
701
702 if (!net_eq(dev_net(ndev), &init_net))
703 return NOTIFY_OK;
704
705 vif = qtnf_netdev_get_priv(ndev);
706 bus = vif->mac->bus;
707
708 switch (event) {
709 case NETDEV_CHANGEUPPER:
710 info = ptr;
711 brdev = info->upper_dev;
712
713 if (!netif_is_bridge_master(brdev))
714 break;
715
716 pr_debug("[VIF%u.%u] change bridge: %s %s\n",
717 vif->mac->macid, vif->vifid, netdev_name(brdev),
718 info->linking ? "add" : "del");
719
720 if (IS_ENABLED(CONFIG_NET_SWITCHDEV) &&
721 qtnf_hwcap_is_set(&bus->hw_info,
722 QLINK_HW_CAPAB_HW_BRIDGE)) {
723 if (info->linking)
724 br_domain = brdev->ifindex;
725 else
726 br_domain = ndev->ifindex;
727
728 ret = qtnf_cmd_netdev_changeupper(vif, br_domain);
729 } else {
730 ret = netdev_walk_all_lower_dev(brdev,
731 qtnf_check_br_ports,
732 &priv);
733 }
734
735 break;
736 default:
737 break;
738 }
739
740 return notifier_from_errno(ret);
741}
742
743int qtnf_core_attach(struct qtnf_bus *bus)
744{
745 unsigned int i;
746 int ret;
747
748 qtnf_trans_init(bus);
749 qtnf_bus_data_rx_start(bus);
750
751 bus->workqueue = alloc_ordered_workqueue("QTNF_BUS", 0);
752 if (!bus->workqueue) {
753 pr_err("failed to alloc main workqueue\n");
754 ret = -ENOMEM;
755 goto error;
756 }
757
758 bus->hprio_workqueue = alloc_workqueue("QTNF_HPRI", WQ_HIGHPRI, 0);
759 if (!bus->hprio_workqueue) {
760 pr_err("failed to alloc high prio workqueue\n");
761 ret = -ENOMEM;
762 goto error;
763 }
764
765 INIT_WORK(&bus->event_work, qtnf_event_work_handler);
766
767 ret = qtnf_cmd_send_init_fw(bus);
768 if (ret) {
769 pr_err("failed to init FW: %d\n", ret);
770 goto error;
771 }
772
773 if (QLINK_VER_MAJOR(bus->hw_info.ql_proto_ver) !=
774 QLINK_PROTO_VER_MAJOR) {
775 pr_err("qlink driver vs FW version mismatch: %u vs %u\n",
776 QLINK_PROTO_VER_MAJOR,
777 QLINK_VER_MAJOR(bus->hw_info.ql_proto_ver));
778 ret = -EPROTONOSUPPORT;
779 goto error;
780 }
781
782 bus->fw_state = QTNF_FW_STATE_ACTIVE;
783 ret = qtnf_cmd_get_hw_info(bus);
784 if (ret) {
785 pr_err("failed to get HW info: %d\n", ret);
786 goto error;
787 }
788
789 if (qtnf_hwcap_is_set(&bus->hw_info, QLINK_HW_CAPAB_HW_BRIDGE) &&
790 bus->bus_ops->data_tx_use_meta_set)
791 bus->bus_ops->data_tx_use_meta_set(bus, true);
792
793 if (bus->hw_info.num_mac > QTNF_MAX_MAC) {
794 pr_err("no support for number of MACs=%u\n",
795 bus->hw_info.num_mac);
796 ret = -ERANGE;
797 goto error;
798 }
799
800 for (i = 0; i < bus->hw_info.num_mac; i++) {
801 ret = qtnf_core_mac_attach(bus, i);
802
803 if (ret) {
804 pr_err("MAC%u: attach failed: %d\n", i, ret);
805 goto error;
806 }
807 }
808
809 bus->netdev_nb.notifier_call = qtnf_core_netdevice_event;
810 ret = register_netdevice_notifier(&bus->netdev_nb);
811 if (ret) {
812 pr_err("failed to register netdev notifier: %d\n", ret);
813 goto error;
814 }
815
816 bus->fw_state = QTNF_FW_STATE_RUNNING;
817 return 0;
818
819error:
820 qtnf_core_detach(bus);
821 return ret;
822}
823EXPORT_SYMBOL_GPL(qtnf_core_attach);
824
825void qtnf_core_detach(struct qtnf_bus *bus)
826{
827 unsigned int macid;
828
829 unregister_netdevice_notifier(&bus->netdev_nb);
830 qtnf_bus_data_rx_stop(bus);
831
832 for (macid = 0; macid < QTNF_MAX_MAC; macid++)
833 qtnf_core_mac_detach(bus, macid);
834
835 if (qtnf_fw_is_up(bus))
836 qtnf_cmd_send_deinit_fw(bus);
837
838 bus->fw_state = QTNF_FW_STATE_DETACHED;
839
840 if (bus->workqueue) {
841 flush_workqueue(bus->workqueue);
842 destroy_workqueue(bus->workqueue);
843 bus->workqueue = NULL;
844 }
845
846 if (bus->hprio_workqueue) {
847 flush_workqueue(bus->hprio_workqueue);
848 destroy_workqueue(bus->hprio_workqueue);
849 bus->hprio_workqueue = NULL;
850 }
851
852 qtnf_trans_free(bus);
853}
854EXPORT_SYMBOL_GPL(qtnf_core_detach);
855
856static inline int qtnf_is_frame_meta_magic_valid(struct qtnf_frame_meta_info *m)
857{
858 return m->magic_s == HBM_FRAME_META_MAGIC_PATTERN_S &&
859 m->magic_e == HBM_FRAME_META_MAGIC_PATTERN_E;
860}
861
862struct net_device *qtnf_classify_skb(struct qtnf_bus *bus, struct sk_buff *skb)
863{
864 struct qtnf_frame_meta_info *meta;
865 struct net_device *ndev = NULL;
866 struct qtnf_wmac *mac;
867 struct qtnf_vif *vif;
868
869 if (unlikely(bus->fw_state != QTNF_FW_STATE_RUNNING))
870 return NULL;
871
872 meta = (struct qtnf_frame_meta_info *)
873 (skb_tail_pointer(skb) - sizeof(*meta));
874
875 if (unlikely(!qtnf_is_frame_meta_magic_valid(meta))) {
876 pr_err_ratelimited("invalid magic 0x%x:0x%x\n",
877 meta->magic_s, meta->magic_e);
878 goto out;
879 }
880
881 if (unlikely(meta->macid >= QTNF_MAX_MAC)) {
882 pr_err_ratelimited("invalid mac(%u)\n", meta->macid);
883 goto out;
884 }
885
886 if (unlikely(meta->ifidx >= QTNF_MAX_INTF)) {
887 pr_err_ratelimited("invalid vif(%u)\n", meta->ifidx);
888 goto out;
889 }
890
891 mac = bus->mac[meta->macid];
892
893 if (unlikely(!mac)) {
894 pr_err_ratelimited("mac(%d) does not exist\n", meta->macid);
895 goto out;
896 }
897
898 vif = &mac->iflist[meta->ifidx];
899
900 if (unlikely(vif->wdev.iftype == NL80211_IFTYPE_UNSPECIFIED)) {
901 pr_err_ratelimited("vif(%u) does not exists\n", meta->ifidx);
902 goto out;
903 }
904
905 ndev = vif->netdev;
906
907 if (unlikely(!ndev)) {
908 pr_err_ratelimited("netdev for wlan%u.%u does not exists\n",
909 meta->macid, meta->ifidx);
910 goto out;
911 }
912
913 __skb_trim(skb, skb->len - sizeof(*meta));
914
915 qtnfmac_switch_mark_skb_flooded(skb);
916
917out:
918 return ndev;
919}
920EXPORT_SYMBOL_GPL(qtnf_classify_skb);
921
922void qtnf_wake_all_queues(struct net_device *ndev)
923{
924 struct qtnf_vif *vif = qtnf_netdev_get_priv(ndev);
925 struct qtnf_wmac *mac;
926 struct qtnf_bus *bus;
927 int macid;
928 int i;
929
930 if (unlikely(!vif || !vif->mac || !vif->mac->bus))
931 return;
932
933 bus = vif->mac->bus;
934
935 for (macid = 0; macid < QTNF_MAX_MAC; macid++) {
936 if (!(bus->hw_info.mac_bitmap & BIT(macid)))
937 continue;
938
939 mac = bus->mac[macid];
940 for (i = 0; i < QTNF_MAX_INTF; i++) {
941 vif = &mac->iflist[i];
942 if (vif->netdev && netif_queue_stopped(vif->netdev))
943 netif_tx_wake_all_queues(vif->netdev);
944 }
945 }
946}
947EXPORT_SYMBOL_GPL(qtnf_wake_all_queues);
948
949void qtnf_update_rx_stats(struct net_device *ndev, const struct sk_buff *skb)
950{
951 struct qtnf_vif *vif = qtnf_netdev_get_priv(ndev);
952 struct pcpu_sw_netstats *stats64;
953
954 if (unlikely(!vif || !vif->stats64)) {
955 ndev->stats.rx_packets++;
956 ndev->stats.rx_bytes += skb->len;
957 return;
958 }
959
960 stats64 = this_cpu_ptr(vif->stats64);
961
962 u64_stats_update_begin(&stats64->syncp);
963 stats64->rx_packets++;
964 stats64->rx_bytes += skb->len;
965 u64_stats_update_end(&stats64->syncp);
966}
967EXPORT_SYMBOL_GPL(qtnf_update_rx_stats);
968
969void qtnf_update_tx_stats(struct net_device *ndev, const struct sk_buff *skb)
970{
971 struct qtnf_vif *vif = qtnf_netdev_get_priv(ndev);
972 struct pcpu_sw_netstats *stats64;
973
974 if (unlikely(!vif || !vif->stats64)) {
975 ndev->stats.tx_packets++;
976 ndev->stats.tx_bytes += skb->len;
977 return;
978 }
979
980 stats64 = this_cpu_ptr(vif->stats64);
981
982 u64_stats_update_begin(&stats64->syncp);
983 stats64->tx_packets++;
984 stats64->tx_bytes += skb->len;
985 u64_stats_update_end(&stats64->syncp);
986}
987EXPORT_SYMBOL_GPL(qtnf_update_tx_stats);
988
989struct dentry *qtnf_get_debugfs_dir(void)
990{
991 return qtnf_debugfs_dir;
992}
993EXPORT_SYMBOL_GPL(qtnf_get_debugfs_dir);
994
995static int __init qtnf_core_register(void)
996{
997 qtnf_debugfs_dir = debugfs_create_dir(KBUILD_MODNAME, NULL);
998
999 if (IS_ERR(qtnf_debugfs_dir))
1000 qtnf_debugfs_dir = NULL;
1001
1002 return 0;
1003}
1004
1005static void __exit qtnf_core_exit(void)
1006{
1007 debugfs_remove(qtnf_debugfs_dir);
1008}
1009
1010module_init(qtnf_core_register);
1011module_exit(qtnf_core_exit);
1012
1013MODULE_AUTHOR("Quantenna Communications");
1014MODULE_DESCRIPTION("Quantenna 802.11 wireless LAN FullMAC driver.");
1015MODULE_LICENSE("GPL");
1016
