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