1
2
3
4
5#include <linux/sched.h>
6#include <linux/of.h>
7#include "mt76.h"
8
9#define CHAN2G(_idx, _freq) { \
10 .band = NL80211_BAND_2GHZ, \
11 .center_freq = (_freq), \
12 .hw_value = (_idx), \
13 .max_power = 30, \
14}
15
16#define CHAN5G(_idx, _freq) { \
17 .band = NL80211_BAND_5GHZ, \
18 .center_freq = (_freq), \
19 .hw_value = (_idx), \
20 .max_power = 30, \
21}
22
23static const struct ieee80211_channel mt76_channels_2ghz[] = {
24 CHAN2G(1, 2412),
25 CHAN2G(2, 2417),
26 CHAN2G(3, 2422),
27 CHAN2G(4, 2427),
28 CHAN2G(5, 2432),
29 CHAN2G(6, 2437),
30 CHAN2G(7, 2442),
31 CHAN2G(8, 2447),
32 CHAN2G(9, 2452),
33 CHAN2G(10, 2457),
34 CHAN2G(11, 2462),
35 CHAN2G(12, 2467),
36 CHAN2G(13, 2472),
37 CHAN2G(14, 2484),
38};
39
40static const struct ieee80211_channel mt76_channels_5ghz[] = {
41 CHAN5G(36, 5180),
42 CHAN5G(40, 5200),
43 CHAN5G(44, 5220),
44 CHAN5G(48, 5240),
45
46 CHAN5G(52, 5260),
47 CHAN5G(56, 5280),
48 CHAN5G(60, 5300),
49 CHAN5G(64, 5320),
50
51 CHAN5G(100, 5500),
52 CHAN5G(104, 5520),
53 CHAN5G(108, 5540),
54 CHAN5G(112, 5560),
55 CHAN5G(116, 5580),
56 CHAN5G(120, 5600),
57 CHAN5G(124, 5620),
58 CHAN5G(128, 5640),
59 CHAN5G(132, 5660),
60 CHAN5G(136, 5680),
61 CHAN5G(140, 5700),
62 CHAN5G(144, 5720),
63
64 CHAN5G(149, 5745),
65 CHAN5G(153, 5765),
66 CHAN5G(157, 5785),
67 CHAN5G(161, 5805),
68 CHAN5G(165, 5825),
69 CHAN5G(169, 5845),
70 CHAN5G(173, 5865),
71};
72
73static const struct ieee80211_tpt_blink mt76_tpt_blink[] = {
74 { .throughput = 0 * 1024, .blink_time = 334 },
75 { .throughput = 1 * 1024, .blink_time = 260 },
76 { .throughput = 5 * 1024, .blink_time = 220 },
77 { .throughput = 10 * 1024, .blink_time = 190 },
78 { .throughput = 20 * 1024, .blink_time = 170 },
79 { .throughput = 50 * 1024, .blink_time = 150 },
80 { .throughput = 70 * 1024, .blink_time = 130 },
81 { .throughput = 100 * 1024, .blink_time = 110 },
82 { .throughput = 200 * 1024, .blink_time = 80 },
83 { .throughput = 300 * 1024, .blink_time = 50 },
84};
85
86struct ieee80211_rate mt76_rates[] = {
87 CCK_RATE(0, 10),
88 CCK_RATE(1, 20),
89 CCK_RATE(2, 55),
90 CCK_RATE(3, 110),
91 OFDM_RATE(11, 60),
92 OFDM_RATE(15, 90),
93 OFDM_RATE(10, 120),
94 OFDM_RATE(14, 180),
95 OFDM_RATE(9, 240),
96 OFDM_RATE(13, 360),
97 OFDM_RATE(8, 480),
98 OFDM_RATE(12, 540),
99};
100EXPORT_SYMBOL_GPL(mt76_rates);
101
102static int mt76_led_init(struct mt76_dev *dev)
103{
104 struct device_node *np = dev->dev->of_node;
105 struct ieee80211_hw *hw = dev->hw;
106 int led_pin;
107
108 if (!dev->led_cdev.brightness_set && !dev->led_cdev.blink_set)
109 return 0;
110
111 snprintf(dev->led_name, sizeof(dev->led_name),
112 "mt76-%s", wiphy_name(hw->wiphy));
113
114 dev->led_cdev.name = dev->led_name;
115 dev->led_cdev.default_trigger =
116 ieee80211_create_tpt_led_trigger(hw,
117 IEEE80211_TPT_LEDTRIG_FL_RADIO,
118 mt76_tpt_blink,
119 ARRAY_SIZE(mt76_tpt_blink));
120
121 np = of_get_child_by_name(np, "led");
122 if (np) {
123 if (!of_property_read_u32(np, "led-sources", &led_pin))
124 dev->led_pin = led_pin;
125 dev->led_al = of_property_read_bool(np, "led-active-low");
126 }
127
128 return led_classdev_register(dev->dev, &dev->led_cdev);
129}
130
131static void mt76_led_cleanup(struct mt76_dev *dev)
132{
133 if (!dev->led_cdev.brightness_set && !dev->led_cdev.blink_set)
134 return;
135
136 led_classdev_unregister(&dev->led_cdev);
137}
138
139static void mt76_init_stream_cap(struct mt76_phy *phy,
140 struct ieee80211_supported_band *sband,
141 bool vht)
142{
143 struct ieee80211_sta_ht_cap *ht_cap = &sband->ht_cap;
144 int i, nstream = hweight8(phy->antenna_mask);
145 struct ieee80211_sta_vht_cap *vht_cap;
146 u16 mcs_map = 0;
147
148 if (nstream > 1)
149 ht_cap->cap |= IEEE80211_HT_CAP_TX_STBC;
150 else
151 ht_cap->cap &= ~IEEE80211_HT_CAP_TX_STBC;
152
153 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++)
154 ht_cap->mcs.rx_mask[i] = i < nstream ? 0xff : 0;
155
156 if (!vht)
157 return;
158
159 vht_cap = &sband->vht_cap;
160 if (nstream > 1)
161 vht_cap->cap |= IEEE80211_VHT_CAP_TXSTBC;
162 else
163 vht_cap->cap &= ~IEEE80211_VHT_CAP_TXSTBC;
164
165 for (i = 0; i < 8; i++) {
166 if (i < nstream)
167 mcs_map |= (IEEE80211_VHT_MCS_SUPPORT_0_9 << (i * 2));
168 else
169 mcs_map |=
170 (IEEE80211_VHT_MCS_NOT_SUPPORTED << (i * 2));
171 }
172 vht_cap->vht_mcs.rx_mcs_map = cpu_to_le16(mcs_map);
173 vht_cap->vht_mcs.tx_mcs_map = cpu_to_le16(mcs_map);
174}
175
176void mt76_set_stream_caps(struct mt76_phy *phy, bool vht)
177{
178 if (phy->cap.has_2ghz)
179 mt76_init_stream_cap(phy, &phy->sband_2g.sband, false);
180 if (phy->cap.has_5ghz)
181 mt76_init_stream_cap(phy, &phy->sband_5g.sband, vht);
182}
183EXPORT_SYMBOL_GPL(mt76_set_stream_caps);
184
185static int
186mt76_init_sband(struct mt76_phy *phy, struct mt76_sband *msband,
187 const struct ieee80211_channel *chan, int n_chan,
188 struct ieee80211_rate *rates, int n_rates, bool vht)
189{
190 struct ieee80211_supported_band *sband = &msband->sband;
191 struct ieee80211_sta_vht_cap *vht_cap;
192 struct ieee80211_sta_ht_cap *ht_cap;
193 struct mt76_dev *dev = phy->dev;
194 void *chanlist;
195 int size;
196
197 size = n_chan * sizeof(*chan);
198 chanlist = devm_kmemdup(dev->dev, chan, size, GFP_KERNEL);
199 if (!chanlist)
200 return -ENOMEM;
201
202 msband->chan = devm_kcalloc(dev->dev, n_chan, sizeof(*msband->chan),
203 GFP_KERNEL);
204 if (!msband->chan)
205 return -ENOMEM;
206
207 sband->channels = chanlist;
208 sband->n_channels = n_chan;
209 sband->bitrates = rates;
210 sband->n_bitrates = n_rates;
211
212 ht_cap = &sband->ht_cap;
213 ht_cap->ht_supported = true;
214 ht_cap->cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40 |
215 IEEE80211_HT_CAP_GRN_FLD |
216 IEEE80211_HT_CAP_SGI_20 |
217 IEEE80211_HT_CAP_SGI_40 |
218 (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT);
219
220 ht_cap->mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED;
221 ht_cap->ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
222
223 mt76_init_stream_cap(phy, sband, vht);
224
225 if (!vht)
226 return 0;
227
228 vht_cap = &sband->vht_cap;
229 vht_cap->vht_supported = true;
230 vht_cap->cap |= IEEE80211_VHT_CAP_RXLDPC |
231 IEEE80211_VHT_CAP_RXSTBC_1 |
232 IEEE80211_VHT_CAP_SHORT_GI_80 |
233 IEEE80211_VHT_CAP_RX_ANTENNA_PATTERN |
234 IEEE80211_VHT_CAP_TX_ANTENNA_PATTERN |
235 (3 << IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT);
236
237 return 0;
238}
239
240static int
241mt76_init_sband_2g(struct mt76_phy *phy, struct ieee80211_rate *rates,
242 int n_rates)
243{
244 phy->hw->wiphy->bands[NL80211_BAND_2GHZ] = &phy->sband_2g.sband;
245
246 return mt76_init_sband(phy, &phy->sband_2g, mt76_channels_2ghz,
247 ARRAY_SIZE(mt76_channels_2ghz), rates,
248 n_rates, false);
249}
250
251static int
252mt76_init_sband_5g(struct mt76_phy *phy, struct ieee80211_rate *rates,
253 int n_rates, bool vht)
254{
255 phy->hw->wiphy->bands[NL80211_BAND_5GHZ] = &phy->sband_5g.sband;
256
257 return mt76_init_sband(phy, &phy->sband_5g, mt76_channels_5ghz,
258 ARRAY_SIZE(mt76_channels_5ghz), rates,
259 n_rates, vht);
260}
261
262static void
263mt76_check_sband(struct mt76_phy *phy, struct mt76_sband *msband,
264 enum nl80211_band band)
265{
266 struct ieee80211_supported_band *sband = &msband->sband;
267 bool found = false;
268 int i;
269
270 if (!sband)
271 return;
272
273 for (i = 0; i < sband->n_channels; i++) {
274 if (sband->channels[i].flags & IEEE80211_CHAN_DISABLED)
275 continue;
276
277 found = true;
278 break;
279 }
280
281 if (found) {
282 phy->chandef.chan = &sband->channels[0];
283 phy->chan_state = &msband->chan[0];
284 return;
285 }
286
287 sband->n_channels = 0;
288 phy->hw->wiphy->bands[band] = NULL;
289}
290
291static void
292mt76_phy_init(struct mt76_phy *phy, struct ieee80211_hw *hw)
293{
294 struct mt76_dev *dev = phy->dev;
295 struct wiphy *wiphy = hw->wiphy;
296
297 SET_IEEE80211_DEV(hw, dev->dev);
298 SET_IEEE80211_PERM_ADDR(hw, phy->macaddr);
299
300 wiphy->features |= NL80211_FEATURE_ACTIVE_MONITOR;
301 wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH |
302 WIPHY_FLAG_SUPPORTS_TDLS |
303 WIPHY_FLAG_AP_UAPSD;
304
305 wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_CQM_RSSI_LIST);
306 wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_AIRTIME_FAIRNESS);
307 wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_AQL);
308
309 wiphy->available_antennas_tx = dev->phy.antenna_mask;
310 wiphy->available_antennas_rx = dev->phy.antenna_mask;
311
312 hw->txq_data_size = sizeof(struct mt76_txq);
313 hw->uapsd_max_sp_len = IEEE80211_WMM_IE_STA_QOSINFO_SP_ALL;
314
315 if (!hw->max_tx_fragments)
316 hw->max_tx_fragments = 16;
317
318 ieee80211_hw_set(hw, SIGNAL_DBM);
319 ieee80211_hw_set(hw, AMPDU_AGGREGATION);
320 ieee80211_hw_set(hw, SUPPORTS_RC_TABLE);
321 ieee80211_hw_set(hw, SUPPORT_FAST_XMIT);
322 ieee80211_hw_set(hw, SUPPORTS_CLONED_SKBS);
323 ieee80211_hw_set(hw, SUPPORTS_AMSDU_IN_AMPDU);
324 ieee80211_hw_set(hw, SUPPORTS_REORDERING_BUFFER);
325
326 if (!(dev->drv->drv_flags & MT_DRV_AMSDU_OFFLOAD)) {
327 ieee80211_hw_set(hw, TX_AMSDU);
328 ieee80211_hw_set(hw, TX_FRAG_LIST);
329 }
330
331 ieee80211_hw_set(hw, MFP_CAPABLE);
332 ieee80211_hw_set(hw, AP_LINK_PS);
333 ieee80211_hw_set(hw, REPORTS_TX_ACK_STATUS);
334}
335
336struct mt76_phy *
337mt76_alloc_phy(struct mt76_dev *dev, unsigned int size,
338 const struct ieee80211_ops *ops)
339{
340 struct ieee80211_hw *hw;
341 unsigned int phy_size;
342 struct mt76_phy *phy;
343
344 phy_size = ALIGN(sizeof(*phy), 8);
345 hw = ieee80211_alloc_hw(size + phy_size, ops);
346 if (!hw)
347 return NULL;
348
349 phy = hw->priv;
350 phy->dev = dev;
351 phy->hw = hw;
352 phy->priv = hw->priv + phy_size;
353
354 hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
355 hw->wiphy->interface_modes =
356 BIT(NL80211_IFTYPE_STATION) |
357 BIT(NL80211_IFTYPE_AP) |
358#ifdef CONFIG_MAC80211_MESH
359 BIT(NL80211_IFTYPE_MESH_POINT) |
360#endif
361 BIT(NL80211_IFTYPE_P2P_CLIENT) |
362 BIT(NL80211_IFTYPE_P2P_GO) |
363 BIT(NL80211_IFTYPE_ADHOC);
364
365 return phy;
366}
367EXPORT_SYMBOL_GPL(mt76_alloc_phy);
368
369int mt76_register_phy(struct mt76_phy *phy, bool vht,
370 struct ieee80211_rate *rates, int n_rates)
371{
372 int ret;
373
374 mt76_phy_init(phy, phy->hw);
375
376 if (phy->cap.has_2ghz) {
377 ret = mt76_init_sband_2g(phy, rates, n_rates);
378 if (ret)
379 return ret;
380 }
381
382 if (phy->cap.has_5ghz) {
383 ret = mt76_init_sband_5g(phy, rates + 4, n_rates - 4, vht);
384 if (ret)
385 return ret;
386 }
387
388 wiphy_read_of_freq_limits(phy->hw->wiphy);
389 mt76_check_sband(phy, &phy->sband_2g, NL80211_BAND_2GHZ);
390 mt76_check_sband(phy, &phy->sband_5g, NL80211_BAND_5GHZ);
391
392 ret = ieee80211_register_hw(phy->hw);
393 if (ret)
394 return ret;
395
396 phy->dev->phy2 = phy;
397
398 return 0;
399}
400EXPORT_SYMBOL_GPL(mt76_register_phy);
401
402void mt76_unregister_phy(struct mt76_phy *phy)
403{
404 struct mt76_dev *dev = phy->dev;
405
406 mt76_tx_status_check(dev, NULL, true);
407 ieee80211_unregister_hw(phy->hw);
408 dev->phy2 = NULL;
409}
410EXPORT_SYMBOL_GPL(mt76_unregister_phy);
411
412struct mt76_dev *
413mt76_alloc_device(struct device *pdev, unsigned int size,
414 const struct ieee80211_ops *ops,
415 const struct mt76_driver_ops *drv_ops)
416{
417 struct ieee80211_hw *hw;
418 struct mt76_phy *phy;
419 struct mt76_dev *dev;
420 int i;
421
422 hw = ieee80211_alloc_hw(size, ops);
423 if (!hw)
424 return NULL;
425
426 dev = hw->priv;
427 dev->hw = hw;
428 dev->dev = pdev;
429 dev->drv = drv_ops;
430
431 phy = &dev->phy;
432 phy->dev = dev;
433 phy->hw = hw;
434
435 spin_lock_init(&dev->rx_lock);
436 spin_lock_init(&dev->lock);
437 spin_lock_init(&dev->cc_lock);
438 mutex_init(&dev->mutex);
439 init_waitqueue_head(&dev->tx_wait);
440 skb_queue_head_init(&dev->status_list);
441
442 skb_queue_head_init(&dev->mcu.res_q);
443 init_waitqueue_head(&dev->mcu.wait);
444 mutex_init(&dev->mcu.mutex);
445 dev->tx_worker.fn = mt76_tx_worker;
446
447 hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
448 hw->wiphy->interface_modes =
449 BIT(NL80211_IFTYPE_STATION) |
450 BIT(NL80211_IFTYPE_AP) |
451#ifdef CONFIG_MAC80211_MESH
452 BIT(NL80211_IFTYPE_MESH_POINT) |
453#endif
454 BIT(NL80211_IFTYPE_P2P_CLIENT) |
455 BIT(NL80211_IFTYPE_P2P_GO) |
456 BIT(NL80211_IFTYPE_ADHOC);
457
458 spin_lock_init(&dev->token_lock);
459 idr_init(&dev->token);
460
461 INIT_LIST_HEAD(&dev->txwi_cache);
462
463 for (i = 0; i < ARRAY_SIZE(dev->q_rx); i++)
464 skb_queue_head_init(&dev->rx_skb[i]);
465
466 dev->wq = alloc_ordered_workqueue("mt76", 0);
467 if (!dev->wq) {
468 ieee80211_free_hw(hw);
469 return NULL;
470 }
471
472 return dev;
473}
474EXPORT_SYMBOL_GPL(mt76_alloc_device);
475
476int mt76_register_device(struct mt76_dev *dev, bool vht,
477 struct ieee80211_rate *rates, int n_rates)
478{
479 struct ieee80211_hw *hw = dev->hw;
480 struct mt76_phy *phy = &dev->phy;
481 int ret;
482
483 dev_set_drvdata(dev->dev, dev);
484 mt76_phy_init(phy, hw);
485
486 if (phy->cap.has_2ghz) {
487 ret = mt76_init_sband_2g(phy, rates, n_rates);
488 if (ret)
489 return ret;
490 }
491
492 if (phy->cap.has_5ghz) {
493 ret = mt76_init_sband_5g(phy, rates + 4, n_rates - 4, vht);
494 if (ret)
495 return ret;
496 }
497
498 wiphy_read_of_freq_limits(hw->wiphy);
499 mt76_check_sband(&dev->phy, &phy->sband_2g, NL80211_BAND_2GHZ);
500 mt76_check_sband(&dev->phy, &phy->sband_5g, NL80211_BAND_5GHZ);
501
502 if (IS_ENABLED(CONFIG_MT76_LEDS)) {
503 ret = mt76_led_init(dev);
504 if (ret)
505 return ret;
506 }
507
508 ret = ieee80211_register_hw(hw);
509 if (ret)
510 return ret;
511
512 WARN_ON(mt76_worker_setup(hw, &dev->tx_worker, NULL, "tx"));
513 sched_set_fifo_low(dev->tx_worker.task);
514
515 return 0;
516}
517EXPORT_SYMBOL_GPL(mt76_register_device);
518
519void mt76_unregister_device(struct mt76_dev *dev)
520{
521 struct ieee80211_hw *hw = dev->hw;
522
523 if (IS_ENABLED(CONFIG_MT76_LEDS))
524 mt76_led_cleanup(dev);
525 mt76_tx_status_check(dev, NULL, true);
526 ieee80211_unregister_hw(hw);
527}
528EXPORT_SYMBOL_GPL(mt76_unregister_device);
529
530void mt76_free_device(struct mt76_dev *dev)
531{
532 mt76_worker_teardown(&dev->tx_worker);
533 if (dev->wq) {
534 destroy_workqueue(dev->wq);
535 dev->wq = NULL;
536 }
537 ieee80211_free_hw(dev->hw);
538}
539EXPORT_SYMBOL_GPL(mt76_free_device);
540
541static void mt76_rx_release_amsdu(struct mt76_phy *phy, enum mt76_rxq_id q)
542{
543 struct sk_buff *skb = phy->rx_amsdu[q].head;
544 struct mt76_rx_status *status = (struct mt76_rx_status *)skb->cb;
545 struct mt76_dev *dev = phy->dev;
546
547 phy->rx_amsdu[q].head = NULL;
548 phy->rx_amsdu[q].tail = NULL;
549
550
551
552
553
554
555
556
557 if (skb_shinfo(skb)->frag_list) {
558 int offset = 0;
559
560 if (!(status->flag & RX_FLAG_8023)) {
561 offset = ieee80211_get_hdrlen_from_skb(skb);
562
563 if ((status->flag &
564 (RX_FLAG_DECRYPTED | RX_FLAG_IV_STRIPPED)) ==
565 RX_FLAG_DECRYPTED)
566 offset += 8;
567 }
568
569 if (ether_addr_equal(skb->data + offset, rfc1042_header)) {
570 dev_kfree_skb(skb);
571 return;
572 }
573 }
574 __skb_queue_tail(&dev->rx_skb[q], skb);
575}
576
577static void mt76_rx_release_burst(struct mt76_phy *phy, enum mt76_rxq_id q,
578 struct sk_buff *skb)
579{
580 struct mt76_rx_status *status = (struct mt76_rx_status *)skb->cb;
581
582 if (phy->rx_amsdu[q].head &&
583 (!status->amsdu || status->first_amsdu ||
584 status->seqno != phy->rx_amsdu[q].seqno))
585 mt76_rx_release_amsdu(phy, q);
586
587 if (!phy->rx_amsdu[q].head) {
588 phy->rx_amsdu[q].tail = &skb_shinfo(skb)->frag_list;
589 phy->rx_amsdu[q].seqno = status->seqno;
590 phy->rx_amsdu[q].head = skb;
591 } else {
592 *phy->rx_amsdu[q].tail = skb;
593 phy->rx_amsdu[q].tail = &skb->next;
594 }
595
596 if (!status->amsdu || status->last_amsdu)
597 mt76_rx_release_amsdu(phy, q);
598}
599
600void mt76_rx(struct mt76_dev *dev, enum mt76_rxq_id q, struct sk_buff *skb)
601{
602 struct mt76_rx_status *status = (struct mt76_rx_status *)skb->cb;
603 struct mt76_phy *phy = mt76_dev_phy(dev, status->ext_phy);
604
605 if (!test_bit(MT76_STATE_RUNNING, &phy->state)) {
606 dev_kfree_skb(skb);
607 return;
608 }
609
610#ifdef CONFIG_NL80211_TESTMODE
611 if (phy->test.state == MT76_TM_STATE_RX_FRAMES) {
612 phy->test.rx_stats.packets[q]++;
613 if (status->flag & RX_FLAG_FAILED_FCS_CRC)
614 phy->test.rx_stats.fcs_error[q]++;
615 }
616#endif
617
618 mt76_rx_release_burst(phy, q, skb);
619}
620EXPORT_SYMBOL_GPL(mt76_rx);
621
622bool mt76_has_tx_pending(struct mt76_phy *phy)
623{
624 struct mt76_queue *q;
625 int i;
626
627 for (i = 0; i < __MT_TXQ_MAX; i++) {
628 q = phy->q_tx[i];
629 if (q && q->queued)
630 return true;
631 }
632
633 return false;
634}
635EXPORT_SYMBOL_GPL(mt76_has_tx_pending);
636
637static struct mt76_channel_state *
638mt76_channel_state(struct mt76_phy *phy, struct ieee80211_channel *c)
639{
640 struct mt76_sband *msband;
641 int idx;
642
643 if (c->band == NL80211_BAND_2GHZ)
644 msband = &phy->sband_2g;
645 else
646 msband = &phy->sband_5g;
647
648 idx = c - &msband->sband.channels[0];
649 return &msband->chan[idx];
650}
651
652void mt76_update_survey_active_time(struct mt76_phy *phy, ktime_t time)
653{
654 struct mt76_channel_state *state = phy->chan_state;
655
656 state->cc_active += ktime_to_us(ktime_sub(time,
657 phy->survey_time));
658 phy->survey_time = time;
659}
660EXPORT_SYMBOL_GPL(mt76_update_survey_active_time);
661
662void mt76_update_survey(struct mt76_phy *phy)
663{
664 struct mt76_dev *dev = phy->dev;
665 ktime_t cur_time;
666
667 if (dev->drv->update_survey)
668 dev->drv->update_survey(phy);
669
670 cur_time = ktime_get_boottime();
671 mt76_update_survey_active_time(phy, cur_time);
672
673 if (dev->drv->drv_flags & MT_DRV_SW_RX_AIRTIME) {
674 struct mt76_channel_state *state = phy->chan_state;
675
676 spin_lock_bh(&dev->cc_lock);
677 state->cc_bss_rx += dev->cur_cc_bss_rx;
678 dev->cur_cc_bss_rx = 0;
679 spin_unlock_bh(&dev->cc_lock);
680 }
681}
682EXPORT_SYMBOL_GPL(mt76_update_survey);
683
684void mt76_set_channel(struct mt76_phy *phy)
685{
686 struct mt76_dev *dev = phy->dev;
687 struct ieee80211_hw *hw = phy->hw;
688 struct cfg80211_chan_def *chandef = &hw->conf.chandef;
689 bool offchannel = hw->conf.flags & IEEE80211_CONF_OFFCHANNEL;
690 int timeout = HZ / 5;
691
692 wait_event_timeout(dev->tx_wait, !mt76_has_tx_pending(phy), timeout);
693 mt76_update_survey(phy);
694
695 phy->chandef = *chandef;
696 phy->chan_state = mt76_channel_state(phy, chandef->chan);
697
698 if (!offchannel)
699 phy->main_chan = chandef->chan;
700
701 if (chandef->chan != phy->main_chan)
702 memset(phy->chan_state, 0, sizeof(*phy->chan_state));
703}
704EXPORT_SYMBOL_GPL(mt76_set_channel);
705
706int mt76_get_survey(struct ieee80211_hw *hw, int idx,
707 struct survey_info *survey)
708{
709 struct mt76_phy *phy = hw->priv;
710 struct mt76_dev *dev = phy->dev;
711 struct mt76_sband *sband;
712 struct ieee80211_channel *chan;
713 struct mt76_channel_state *state;
714 int ret = 0;
715
716 mutex_lock(&dev->mutex);
717 if (idx == 0 && dev->drv->update_survey)
718 mt76_update_survey(phy);
719
720 sband = &phy->sband_2g;
721 if (idx >= sband->sband.n_channels) {
722 idx -= sband->sband.n_channels;
723 sband = &phy->sband_5g;
724 }
725
726 if (idx >= sband->sband.n_channels) {
727 ret = -ENOENT;
728 goto out;
729 }
730
731 chan = &sband->sband.channels[idx];
732 state = mt76_channel_state(phy, chan);
733
734 memset(survey, 0, sizeof(*survey));
735 survey->channel = chan;
736 survey->filled = SURVEY_INFO_TIME | SURVEY_INFO_TIME_BUSY;
737 survey->filled |= dev->drv->survey_flags;
738 if (state->noise)
739 survey->filled |= SURVEY_INFO_NOISE_DBM;
740
741 if (chan == phy->main_chan) {
742 survey->filled |= SURVEY_INFO_IN_USE;
743
744 if (dev->drv->drv_flags & MT_DRV_SW_RX_AIRTIME)
745 survey->filled |= SURVEY_INFO_TIME_BSS_RX;
746 }
747
748 survey->time_busy = div_u64(state->cc_busy, 1000);
749 survey->time_rx = div_u64(state->cc_rx, 1000);
750 survey->time = div_u64(state->cc_active, 1000);
751 survey->noise = state->noise;
752
753 spin_lock_bh(&dev->cc_lock);
754 survey->time_bss_rx = div_u64(state->cc_bss_rx, 1000);
755 survey->time_tx = div_u64(state->cc_tx, 1000);
756 spin_unlock_bh(&dev->cc_lock);
757
758out:
759 mutex_unlock(&dev->mutex);
760
761 return ret;
762}
763EXPORT_SYMBOL_GPL(mt76_get_survey);
764
765void mt76_wcid_key_setup(struct mt76_dev *dev, struct mt76_wcid *wcid,
766 struct ieee80211_key_conf *key)
767{
768 struct ieee80211_key_seq seq;
769 int i;
770
771 wcid->rx_check_pn = false;
772
773 if (!key)
774 return;
775
776 if (key->cipher != WLAN_CIPHER_SUITE_CCMP)
777 return;
778
779 wcid->rx_check_pn = true;
780 for (i = 0; i < IEEE80211_NUM_TIDS; i++) {
781 ieee80211_get_key_rx_seq(key, i, &seq);
782 memcpy(wcid->rx_key_pn[i], seq.ccmp.pn, sizeof(seq.ccmp.pn));
783 }
784}
785EXPORT_SYMBOL(mt76_wcid_key_setup);
786
787static void
788mt76_rx_convert(struct mt76_dev *dev, struct sk_buff *skb,
789 struct ieee80211_hw **hw,
790 struct ieee80211_sta **sta)
791{
792 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
793 struct mt76_rx_status mstat;
794
795 mstat = *((struct mt76_rx_status *)skb->cb);
796 memset(status, 0, sizeof(*status));
797
798 status->flag = mstat.flag;
799 status->freq = mstat.freq;
800 status->enc_flags = mstat.enc_flags;
801 status->encoding = mstat.encoding;
802 status->bw = mstat.bw;
803 status->he_ru = mstat.he_ru;
804 status->he_gi = mstat.he_gi;
805 status->he_dcm = mstat.he_dcm;
806 status->rate_idx = mstat.rate_idx;
807 status->nss = mstat.nss;
808 status->band = mstat.band;
809 status->signal = mstat.signal;
810 status->chains = mstat.chains;
811 status->ampdu_reference = mstat.ampdu_ref;
812 status->device_timestamp = mstat.timestamp;
813 status->mactime = mstat.timestamp;
814
815 BUILD_BUG_ON(sizeof(mstat) > sizeof(skb->cb));
816 BUILD_BUG_ON(sizeof(status->chain_signal) !=
817 sizeof(mstat.chain_signal));
818 memcpy(status->chain_signal, mstat.chain_signal,
819 sizeof(mstat.chain_signal));
820
821 *sta = wcid_to_sta(mstat.wcid);
822 *hw = mt76_phy_hw(dev, mstat.ext_phy);
823}
824
825static int
826mt76_check_ccmp_pn(struct sk_buff *skb)
827{
828 struct mt76_rx_status *status = (struct mt76_rx_status *)skb->cb;
829 struct mt76_wcid *wcid = status->wcid;
830 struct ieee80211_hdr *hdr;
831 u8 tidno = status->qos_ctl & IEEE80211_QOS_CTL_TID_MASK;
832 int ret;
833
834 if (!(status->flag & RX_FLAG_DECRYPTED))
835 return 0;
836
837 if (!wcid || !wcid->rx_check_pn)
838 return 0;
839
840 if (!(status->flag & RX_FLAG_IV_STRIPPED)) {
841
842
843
844
845 hdr = mt76_skb_get_hdr(skb);
846 if (ieee80211_is_frag(hdr) &&
847 !ieee80211_is_first_frag(hdr->frame_control))
848 return 0;
849 }
850
851 BUILD_BUG_ON(sizeof(status->iv) != sizeof(wcid->rx_key_pn[0]));
852 ret = memcmp(status->iv, wcid->rx_key_pn[tidno],
853 sizeof(status->iv));
854 if (ret <= 0)
855 return -EINVAL;
856
857 memcpy(wcid->rx_key_pn[tidno], status->iv, sizeof(status->iv));
858
859 if (status->flag & RX_FLAG_IV_STRIPPED)
860 status->flag |= RX_FLAG_PN_VALIDATED;
861
862 return 0;
863}
864
865static void
866mt76_airtime_report(struct mt76_dev *dev, struct mt76_rx_status *status,
867 int len)
868{
869 struct mt76_wcid *wcid = status->wcid;
870 struct ieee80211_rx_status info = {
871 .enc_flags = status->enc_flags,
872 .rate_idx = status->rate_idx,
873 .encoding = status->encoding,
874 .band = status->band,
875 .nss = status->nss,
876 .bw = status->bw,
877 };
878 struct ieee80211_sta *sta;
879 u32 airtime;
880 u8 tidno = status->qos_ctl & IEEE80211_QOS_CTL_TID_MASK;
881
882 airtime = ieee80211_calc_rx_airtime(dev->hw, &info, len);
883 spin_lock(&dev->cc_lock);
884 dev->cur_cc_bss_rx += airtime;
885 spin_unlock(&dev->cc_lock);
886
887 if (!wcid || !wcid->sta)
888 return;
889
890 sta = container_of((void *)wcid, struct ieee80211_sta, drv_priv);
891 ieee80211_sta_register_airtime(sta, tidno, 0, airtime);
892}
893
894static void
895mt76_airtime_flush_ampdu(struct mt76_dev *dev)
896{
897 struct mt76_wcid *wcid;
898 int wcid_idx;
899
900 if (!dev->rx_ampdu_len)
901 return;
902
903 wcid_idx = dev->rx_ampdu_status.wcid_idx;
904 if (wcid_idx < ARRAY_SIZE(dev->wcid))
905 wcid = rcu_dereference(dev->wcid[wcid_idx]);
906 else
907 wcid = NULL;
908 dev->rx_ampdu_status.wcid = wcid;
909
910 mt76_airtime_report(dev, &dev->rx_ampdu_status, dev->rx_ampdu_len);
911
912 dev->rx_ampdu_len = 0;
913 dev->rx_ampdu_ref = 0;
914}
915
916static void
917mt76_airtime_check(struct mt76_dev *dev, struct sk_buff *skb)
918{
919 struct mt76_rx_status *status = (struct mt76_rx_status *)skb->cb;
920 struct mt76_wcid *wcid = status->wcid;
921
922 if (!(dev->drv->drv_flags & MT_DRV_SW_RX_AIRTIME))
923 return;
924
925 if (!wcid || !wcid->sta) {
926 struct ieee80211_hdr *hdr = mt76_skb_get_hdr(skb);
927
928 if (status->flag & RX_FLAG_8023)
929 return;
930
931 if (!ether_addr_equal(hdr->addr1, dev->phy.macaddr))
932 return;
933
934 wcid = NULL;
935 }
936
937 if (!(status->flag & RX_FLAG_AMPDU_DETAILS) ||
938 status->ampdu_ref != dev->rx_ampdu_ref)
939 mt76_airtime_flush_ampdu(dev);
940
941 if (status->flag & RX_FLAG_AMPDU_DETAILS) {
942 if (!dev->rx_ampdu_len ||
943 status->ampdu_ref != dev->rx_ampdu_ref) {
944 dev->rx_ampdu_status = *status;
945 dev->rx_ampdu_status.wcid_idx = wcid ? wcid->idx : 0xff;
946 dev->rx_ampdu_ref = status->ampdu_ref;
947 }
948
949 dev->rx_ampdu_len += skb->len;
950 return;
951 }
952
953 mt76_airtime_report(dev, status, skb->len);
954}
955
956static void
957mt76_check_sta(struct mt76_dev *dev, struct sk_buff *skb)
958{
959 struct mt76_rx_status *status = (struct mt76_rx_status *)skb->cb;
960 struct ieee80211_hdr *hdr = mt76_skb_get_hdr(skb);
961 struct ieee80211_sta *sta;
962 struct ieee80211_hw *hw;
963 struct mt76_wcid *wcid = status->wcid;
964 u8 tidno = status->qos_ctl & IEEE80211_QOS_CTL_TID_MASK;
965 bool ps;
966
967 hw = mt76_phy_hw(dev, status->ext_phy);
968 if (ieee80211_is_pspoll(hdr->frame_control) && !wcid &&
969 !(status->flag & RX_FLAG_8023)) {
970 sta = ieee80211_find_sta_by_ifaddr(hw, hdr->addr2, NULL);
971 if (sta)
972 wcid = status->wcid = (struct mt76_wcid *)sta->drv_priv;
973 }
974
975 mt76_airtime_check(dev, skb);
976
977 if (!wcid || !wcid->sta)
978 return;
979
980 sta = container_of((void *)wcid, struct ieee80211_sta, drv_priv);
981
982 if (status->signal <= 0)
983 ewma_signal_add(&wcid->rssi, -status->signal);
984
985 wcid->inactive_count = 0;
986
987 if (status->flag & RX_FLAG_8023)
988 return;
989
990 if (!test_bit(MT_WCID_FLAG_CHECK_PS, &wcid->flags))
991 return;
992
993 if (ieee80211_is_pspoll(hdr->frame_control)) {
994 ieee80211_sta_pspoll(sta);
995 return;
996 }
997
998 if (ieee80211_has_morefrags(hdr->frame_control) ||
999 !(ieee80211_is_mgmt(hdr->frame_control) ||
1000 ieee80211_is_data(hdr->frame_control)))
1001 return;
1002
1003 ps = ieee80211_has_pm(hdr->frame_control);
1004
1005 if (ps && (ieee80211_is_data_qos(hdr->frame_control) ||
1006 ieee80211_is_qos_nullfunc(hdr->frame_control)))
1007 ieee80211_sta_uapsd_trigger(sta, tidno);
1008
1009 if (!!test_bit(MT_WCID_FLAG_PS, &wcid->flags) == ps)
1010 return;
1011
1012 if (ps)
1013 set_bit(MT_WCID_FLAG_PS, &wcid->flags);
1014 else
1015 clear_bit(MT_WCID_FLAG_PS, &wcid->flags);
1016
1017 dev->drv->sta_ps(dev, sta, ps);
1018 ieee80211_sta_ps_transition(sta, ps);
1019}
1020
1021void mt76_rx_complete(struct mt76_dev *dev, struct sk_buff_head *frames,
1022 struct napi_struct *napi)
1023{
1024 struct ieee80211_sta *sta;
1025 struct ieee80211_hw *hw;
1026 struct sk_buff *skb, *tmp;
1027 LIST_HEAD(list);
1028
1029 spin_lock(&dev->rx_lock);
1030 while ((skb = __skb_dequeue(frames)) != NULL) {
1031 struct sk_buff *nskb = skb_shinfo(skb)->frag_list;
1032
1033 if (mt76_check_ccmp_pn(skb)) {
1034 dev_kfree_skb(skb);
1035 continue;
1036 }
1037
1038 skb_shinfo(skb)->frag_list = NULL;
1039 mt76_rx_convert(dev, skb, &hw, &sta);
1040 ieee80211_rx_list(hw, sta, skb, &list);
1041
1042
1043 while (nskb) {
1044 skb = nskb;
1045 nskb = nskb->next;
1046 skb->next = NULL;
1047
1048 mt76_rx_convert(dev, skb, &hw, &sta);
1049 ieee80211_rx_list(hw, sta, skb, &list);
1050 }
1051 }
1052 spin_unlock(&dev->rx_lock);
1053
1054 if (!napi) {
1055 netif_receive_skb_list(&list);
1056 return;
1057 }
1058
1059 list_for_each_entry_safe(skb, tmp, &list, list) {
1060 skb_list_del_init(skb);
1061 napi_gro_receive(napi, skb);
1062 }
1063}
1064
1065void mt76_rx_poll_complete(struct mt76_dev *dev, enum mt76_rxq_id q,
1066 struct napi_struct *napi)
1067{
1068 struct sk_buff_head frames;
1069 struct sk_buff *skb;
1070
1071 __skb_queue_head_init(&frames);
1072
1073 while ((skb = __skb_dequeue(&dev->rx_skb[q])) != NULL) {
1074 mt76_check_sta(dev, skb);
1075 mt76_rx_aggr_reorder(skb, &frames);
1076 }
1077
1078 mt76_rx_complete(dev, &frames, napi);
1079}
1080EXPORT_SYMBOL_GPL(mt76_rx_poll_complete);
1081
1082static int
1083mt76_sta_add(struct mt76_dev *dev, struct ieee80211_vif *vif,
1084 struct ieee80211_sta *sta, bool ext_phy)
1085{
1086 struct mt76_wcid *wcid = (struct mt76_wcid *)sta->drv_priv;
1087 int ret;
1088 int i;
1089
1090 mutex_lock(&dev->mutex);
1091
1092 ret = dev->drv->sta_add(dev, vif, sta);
1093 if (ret)
1094 goto out;
1095
1096 for (i = 0; i < ARRAY_SIZE(sta->txq); i++) {
1097 struct mt76_txq *mtxq;
1098
1099 if (!sta->txq[i])
1100 continue;
1101
1102 mtxq = (struct mt76_txq *)sta->txq[i]->drv_priv;
1103 mtxq->wcid = wcid;
1104 }
1105
1106 ewma_signal_init(&wcid->rssi);
1107 if (ext_phy)
1108 mt76_wcid_mask_set(dev->wcid_phy_mask, wcid->idx);
1109 wcid->ext_phy = ext_phy;
1110 rcu_assign_pointer(dev->wcid[wcid->idx], wcid);
1111
1112out:
1113 mutex_unlock(&dev->mutex);
1114
1115 return ret;
1116}
1117
1118void __mt76_sta_remove(struct mt76_dev *dev, struct ieee80211_vif *vif,
1119 struct ieee80211_sta *sta)
1120{
1121 struct mt76_wcid *wcid = (struct mt76_wcid *)sta->drv_priv;
1122 int i, idx = wcid->idx;
1123
1124 for (i = 0; i < ARRAY_SIZE(wcid->aggr); i++)
1125 mt76_rx_aggr_stop(dev, wcid, i);
1126
1127 if (dev->drv->sta_remove)
1128 dev->drv->sta_remove(dev, vif, sta);
1129
1130 mt76_tx_status_check(dev, wcid, true);
1131 mt76_wcid_mask_clear(dev->wcid_mask, idx);
1132 mt76_wcid_mask_clear(dev->wcid_phy_mask, idx);
1133}
1134EXPORT_SYMBOL_GPL(__mt76_sta_remove);
1135
1136static void
1137mt76_sta_remove(struct mt76_dev *dev, struct ieee80211_vif *vif,
1138 struct ieee80211_sta *sta)
1139{
1140 mutex_lock(&dev->mutex);
1141 __mt76_sta_remove(dev, vif, sta);
1142 mutex_unlock(&dev->mutex);
1143}
1144
1145int mt76_sta_state(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
1146 struct ieee80211_sta *sta,
1147 enum ieee80211_sta_state old_state,
1148 enum ieee80211_sta_state new_state)
1149{
1150 struct mt76_phy *phy = hw->priv;
1151 struct mt76_dev *dev = phy->dev;
1152 bool ext_phy = phy != &dev->phy;
1153
1154 if (old_state == IEEE80211_STA_NOTEXIST &&
1155 new_state == IEEE80211_STA_NONE)
1156 return mt76_sta_add(dev, vif, sta, ext_phy);
1157
1158 if (old_state == IEEE80211_STA_AUTH &&
1159 new_state == IEEE80211_STA_ASSOC &&
1160 dev->drv->sta_assoc)
1161 dev->drv->sta_assoc(dev, vif, sta);
1162
1163 if (old_state == IEEE80211_STA_NONE &&
1164 new_state == IEEE80211_STA_NOTEXIST)
1165 mt76_sta_remove(dev, vif, sta);
1166
1167 return 0;
1168}
1169EXPORT_SYMBOL_GPL(mt76_sta_state);
1170
1171void mt76_sta_pre_rcu_remove(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
1172 struct ieee80211_sta *sta)
1173{
1174 struct mt76_phy *phy = hw->priv;
1175 struct mt76_dev *dev = phy->dev;
1176 struct mt76_wcid *wcid = (struct mt76_wcid *)sta->drv_priv;
1177
1178 mutex_lock(&dev->mutex);
1179 rcu_assign_pointer(dev->wcid[wcid->idx], NULL);
1180 mutex_unlock(&dev->mutex);
1181}
1182EXPORT_SYMBOL_GPL(mt76_sta_pre_rcu_remove);
1183
1184int mt76_get_txpower(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
1185 int *dbm)
1186{
1187 struct mt76_phy *phy = hw->priv;
1188 int n_chains = hweight8(phy->antenna_mask);
1189 int delta = mt76_tx_power_nss_delta(n_chains);
1190
1191 *dbm = DIV_ROUND_UP(phy->txpower_cur + delta, 2);
1192
1193 return 0;
1194}
1195EXPORT_SYMBOL_GPL(mt76_get_txpower);
1196
1197static void
1198__mt76_csa_finish(void *priv, u8 *mac, struct ieee80211_vif *vif)
1199{
1200 if (vif->csa_active && ieee80211_beacon_cntdwn_is_complete(vif))
1201 ieee80211_csa_finish(vif);
1202}
1203
1204void mt76_csa_finish(struct mt76_dev *dev)
1205{
1206 if (!dev->csa_complete)
1207 return;
1208
1209 ieee80211_iterate_active_interfaces_atomic(dev->hw,
1210 IEEE80211_IFACE_ITER_RESUME_ALL,
1211 __mt76_csa_finish, dev);
1212
1213 dev->csa_complete = 0;
1214}
1215EXPORT_SYMBOL_GPL(mt76_csa_finish);
1216
1217static void
1218__mt76_csa_check(void *priv, u8 *mac, struct ieee80211_vif *vif)
1219{
1220 struct mt76_dev *dev = priv;
1221
1222 if (!vif->csa_active)
1223 return;
1224
1225 dev->csa_complete |= ieee80211_beacon_cntdwn_is_complete(vif);
1226}
1227
1228void mt76_csa_check(struct mt76_dev *dev)
1229{
1230 ieee80211_iterate_active_interfaces_atomic(dev->hw,
1231 IEEE80211_IFACE_ITER_RESUME_ALL,
1232 __mt76_csa_check, dev);
1233}
1234EXPORT_SYMBOL_GPL(mt76_csa_check);
1235
1236int
1237mt76_set_tim(struct ieee80211_hw *hw, struct ieee80211_sta *sta, bool set)
1238{
1239 return 0;
1240}
1241EXPORT_SYMBOL_GPL(mt76_set_tim);
1242
1243void mt76_insert_ccmp_hdr(struct sk_buff *skb, u8 key_id)
1244{
1245 struct mt76_rx_status *status = (struct mt76_rx_status *)skb->cb;
1246 int hdr_len = ieee80211_get_hdrlen_from_skb(skb);
1247 u8 *hdr, *pn = status->iv;
1248
1249 __skb_push(skb, 8);
1250 memmove(skb->data, skb->data + 8, hdr_len);
1251 hdr = skb->data + hdr_len;
1252
1253 hdr[0] = pn[5];
1254 hdr[1] = pn[4];
1255 hdr[2] = 0;
1256 hdr[3] = 0x20 | (key_id << 6);
1257 hdr[4] = pn[3];
1258 hdr[5] = pn[2];
1259 hdr[6] = pn[1];
1260 hdr[7] = pn[0];
1261
1262 status->flag &= ~RX_FLAG_IV_STRIPPED;
1263}
1264EXPORT_SYMBOL_GPL(mt76_insert_ccmp_hdr);
1265
1266int mt76_get_rate(struct mt76_dev *dev,
1267 struct ieee80211_supported_band *sband,
1268 int idx, bool cck)
1269{
1270 int i, offset = 0, len = sband->n_bitrates;
1271
1272 if (cck) {
1273 if (sband == &dev->phy.sband_5g.sband)
1274 return 0;
1275
1276 idx &= ~BIT(2);
1277 } else if (sband == &dev->phy.sband_2g.sband) {
1278 offset = 4;
1279 }
1280
1281 for (i = offset; i < len; i++) {
1282 if ((sband->bitrates[i].hw_value & GENMASK(7, 0)) == idx)
1283 return i;
1284 }
1285
1286 return 0;
1287}
1288EXPORT_SYMBOL_GPL(mt76_get_rate);
1289
1290void mt76_sw_scan(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
1291 const u8 *mac)
1292{
1293 struct mt76_phy *phy = hw->priv;
1294
1295 set_bit(MT76_SCANNING, &phy->state);
1296}
1297EXPORT_SYMBOL_GPL(mt76_sw_scan);
1298
1299void mt76_sw_scan_complete(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
1300{
1301 struct mt76_phy *phy = hw->priv;
1302
1303 clear_bit(MT76_SCANNING, &phy->state);
1304}
1305EXPORT_SYMBOL_GPL(mt76_sw_scan_complete);
1306
1307int mt76_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant)
1308{
1309 struct mt76_phy *phy = hw->priv;
1310 struct mt76_dev *dev = phy->dev;
1311
1312 mutex_lock(&dev->mutex);
1313 *tx_ant = phy->antenna_mask;
1314 *rx_ant = phy->antenna_mask;
1315 mutex_unlock(&dev->mutex);
1316
1317 return 0;
1318}
1319EXPORT_SYMBOL_GPL(mt76_get_antenna);
1320
1321struct mt76_queue *
1322mt76_init_queue(struct mt76_dev *dev, int qid, int idx, int n_desc,
1323 int ring_base)
1324{
1325 struct mt76_queue *hwq;
1326 int err;
1327
1328 hwq = devm_kzalloc(dev->dev, sizeof(*hwq), GFP_KERNEL);
1329 if (!hwq)
1330 return ERR_PTR(-ENOMEM);
1331
1332 err = dev->queue_ops->alloc(dev, hwq, idx, n_desc, 0, ring_base);
1333 if (err < 0)
1334 return ERR_PTR(err);
1335
1336 return hwq;
1337}
1338EXPORT_SYMBOL_GPL(mt76_init_queue);
1339
