1 /*
2 * Copyright (C) 2016 Felix Fietkau <nbd@nbd.name>
3 *
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
7 *
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15 */
16 #include <linux/of.h>
17 #include "mt76.h"
18
19 #define CHAN2G(_idx, _freq) { \
20 .band = NL80211_BAND_2GHZ, \
21 .center_freq = (_freq), \
22 .hw_value = (_idx), \
23 .max_power = 30, \
24 }
25
26 #define CHAN5G(_idx, _freq) { \
27 .band = NL80211_BAND_5GHZ, \
28 .center_freq = (_freq), \
29 .hw_value = (_idx), \
30 .max_power = 30, \
31 }
32
33 static const struct ieee80211_channel mt76_channels_2ghz[] = {
34 CHAN2G(1, 2412),
35 CHAN2G(2, 2417),
36 CHAN2G(3, 2422),
37 CHAN2G(4, 2427),
38 CHAN2G(5, 2432),
39 CHAN2G(6, 2437),
40 CHAN2G(7, 2442),
41 CHAN2G(8, 2447),
42 CHAN2G(9, 2452),
43 CHAN2G(10, 2457),
44 CHAN2G(11, 2462),
45 CHAN2G(12, 2467),
46 CHAN2G(13, 2472),
47 CHAN2G(14, 2484),
48 };
49
50 static const struct ieee80211_channel mt76_channels_5ghz[] = {
51 CHAN5G(36, 5180),
52 CHAN5G(40, 5200),
53 CHAN5G(44, 5220),
54 CHAN5G(48, 5240),
55
56 CHAN5G(52, 5260),
57 CHAN5G(56, 5280),
58 CHAN5G(60, 5300),
59 CHAN5G(64, 5320),
60
61 CHAN5G(100, 5500),
62 CHAN5G(104, 5520),
63 CHAN5G(108, 5540),
64 CHAN5G(112, 5560),
65 CHAN5G(116, 5580),
66 CHAN5G(120, 5600),
67 CHAN5G(124, 5620),
68 CHAN5G(128, 5640),
69 CHAN5G(132, 5660),
70 CHAN5G(136, 5680),
71 CHAN5G(140, 5700),
72
73 CHAN5G(149, 5745),
74 CHAN5G(153, 5765),
75 CHAN5G(157, 5785),
76 CHAN5G(161, 5805),
77 CHAN5G(165, 5825),
78 };
79
80 static const struct ieee80211_tpt_blink mt76_tpt_blink[] = {
81 { .throughput = 0 * 1024, .blink_time = 334 },
82 { .throughput = 1 * 1024, .blink_time = 260 },
83 { .throughput = 5 * 1024, .blink_time = 220 },
84 { .throughput = 10 * 1024, .blink_time = 190 },
85 { .throughput = 20 * 1024, .blink_time = 170 },
86 { .throughput = 50 * 1024, .blink_time = 150 },
87 { .throughput = 70 * 1024, .blink_time = 130 },
88 { .throughput = 100 * 1024, .blink_time = 110 },
89 { .throughput = 200 * 1024, .blink_time = 80 },
90 { .throughput = 300 * 1024, .blink_time = 50 },
91 };
92
mt76_led_init(struct mt76_dev * dev)93 static int mt76_led_init(struct mt76_dev *dev)
94 {
95 struct device_node *np = dev->dev->of_node;
96 struct ieee80211_hw *hw = dev->hw;
97 int led_pin;
98
99 if (!dev->led_cdev.brightness_set && !dev->led_cdev.blink_set)
100 return 0;
101
102 snprintf(dev->led_name, sizeof(dev->led_name),
103 "mt76-%s", wiphy_name(hw->wiphy));
104
105 dev->led_cdev.name = dev->led_name;
106 dev->led_cdev.default_trigger =
107 ieee80211_create_tpt_led_trigger(hw,
108 IEEE80211_TPT_LEDTRIG_FL_RADIO,
109 mt76_tpt_blink,
110 ARRAY_SIZE(mt76_tpt_blink));
111
112 np = of_get_child_by_name(np, "led");
113 if (np) {
114 if (!of_property_read_u32(np, "led-sources", &led_pin))
115 dev->led_pin = led_pin;
116 dev->led_al = of_property_read_bool(np, "led-active-low");
117 }
118
119 return devm_led_classdev_register(dev->dev, &dev->led_cdev);
120 }
121
mt76_init_stream_cap(struct mt76_dev * dev,struct ieee80211_supported_band * sband,bool vht)122 static void mt76_init_stream_cap(struct mt76_dev *dev,
123 struct ieee80211_supported_band *sband,
124 bool vht)
125 {
126 struct ieee80211_sta_ht_cap *ht_cap = &sband->ht_cap;
127 int i, nstream = __sw_hweight8(dev->antenna_mask);
128 struct ieee80211_sta_vht_cap *vht_cap;
129 u16 mcs_map = 0;
130
131 if (nstream > 1)
132 ht_cap->cap |= IEEE80211_HT_CAP_TX_STBC;
133 else
134 ht_cap->cap &= ~IEEE80211_HT_CAP_TX_STBC;
135
136 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++)
137 ht_cap->mcs.rx_mask[i] = i < nstream ? 0xff : 0;
138
139 if (!vht)
140 return;
141
142 vht_cap = &sband->vht_cap;
143 if (nstream > 1)
144 vht_cap->cap |= IEEE80211_VHT_CAP_TXSTBC;
145 else
146 vht_cap->cap &= ~IEEE80211_VHT_CAP_TXSTBC;
147
148 for (i = 0; i < 8; i++) {
149 if (i < nstream)
150 mcs_map |= (IEEE80211_VHT_MCS_SUPPORT_0_9 << (i * 2));
151 else
152 mcs_map |=
153 (IEEE80211_VHT_MCS_NOT_SUPPORTED << (i * 2));
154 }
155 vht_cap->vht_mcs.rx_mcs_map = cpu_to_le16(mcs_map);
156 vht_cap->vht_mcs.tx_mcs_map = cpu_to_le16(mcs_map);
157 }
158
mt76_set_stream_caps(struct mt76_dev * dev,bool vht)159 void mt76_set_stream_caps(struct mt76_dev *dev, bool vht)
160 {
161 if (dev->cap.has_2ghz)
162 mt76_init_stream_cap(dev, &dev->sband_2g.sband, false);
163 if (dev->cap.has_5ghz)
164 mt76_init_stream_cap(dev, &dev->sband_5g.sband, vht);
165 }
166 EXPORT_SYMBOL_GPL(mt76_set_stream_caps);
167
168 static int
mt76_init_sband(struct mt76_dev * dev,struct mt76_sband * msband,const struct ieee80211_channel * chan,int n_chan,struct ieee80211_rate * rates,int n_rates,bool vht)169 mt76_init_sband(struct mt76_dev *dev, struct mt76_sband *msband,
170 const struct ieee80211_channel *chan, int n_chan,
171 struct ieee80211_rate *rates, int n_rates, bool vht)
172 {
173 struct ieee80211_supported_band *sband = &msband->sband;
174 struct ieee80211_sta_ht_cap *ht_cap;
175 struct ieee80211_sta_vht_cap *vht_cap;
176 void *chanlist;
177 int size;
178
179 size = n_chan * sizeof(*chan);
180 chanlist = devm_kmemdup(dev->dev, chan, size, GFP_KERNEL);
181 if (!chanlist)
182 return -ENOMEM;
183
184 msband->chan = devm_kcalloc(dev->dev, n_chan, sizeof(*msband->chan),
185 GFP_KERNEL);
186 if (!msband->chan)
187 return -ENOMEM;
188
189 sband->channels = chanlist;
190 sband->n_channels = n_chan;
191 sband->bitrates = rates;
192 sband->n_bitrates = n_rates;
193 dev->chandef.chan = &sband->channels[0];
194
195 ht_cap = &sband->ht_cap;
196 ht_cap->ht_supported = true;
197 ht_cap->cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40 |
198 IEEE80211_HT_CAP_GRN_FLD |
199 IEEE80211_HT_CAP_SGI_20 |
200 IEEE80211_HT_CAP_SGI_40 |
201 (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT);
202
203 ht_cap->mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED;
204 ht_cap->ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
205 ht_cap->ampdu_density = IEEE80211_HT_MPDU_DENSITY_4;
206
207 mt76_init_stream_cap(dev, sband, vht);
208
209 if (!vht)
210 return 0;
211
212 vht_cap = &sband->vht_cap;
213 vht_cap->vht_supported = true;
214 vht_cap->cap |= IEEE80211_VHT_CAP_RXLDPC |
215 IEEE80211_VHT_CAP_RXSTBC_1 |
216 IEEE80211_VHT_CAP_SHORT_GI_80 |
217 (3 << IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT);
218
219 return 0;
220 }
221
222 static int
mt76_init_sband_2g(struct mt76_dev * dev,struct ieee80211_rate * rates,int n_rates)223 mt76_init_sband_2g(struct mt76_dev *dev, struct ieee80211_rate *rates,
224 int n_rates)
225 {
226 dev->hw->wiphy->bands[NL80211_BAND_2GHZ] = &dev->sband_2g.sband;
227
228 return mt76_init_sband(dev, &dev->sband_2g,
229 mt76_channels_2ghz,
230 ARRAY_SIZE(mt76_channels_2ghz),
231 rates, n_rates, false);
232 }
233
234 static int
mt76_init_sband_5g(struct mt76_dev * dev,struct ieee80211_rate * rates,int n_rates,bool vht)235 mt76_init_sband_5g(struct mt76_dev *dev, struct ieee80211_rate *rates,
236 int n_rates, bool vht)
237 {
238 dev->hw->wiphy->bands[NL80211_BAND_5GHZ] = &dev->sband_5g.sband;
239
240 return mt76_init_sband(dev, &dev->sband_5g,
241 mt76_channels_5ghz,
242 ARRAY_SIZE(mt76_channels_5ghz),
243 rates, n_rates, vht);
244 }
245
246 static void
mt76_check_sband(struct mt76_dev * dev,int band)247 mt76_check_sband(struct mt76_dev *dev, int band)
248 {
249 struct ieee80211_supported_band *sband = dev->hw->wiphy->bands[band];
250 bool found = false;
251 int i;
252
253 if (!sband)
254 return;
255
256 for (i = 0; i < sband->n_channels; i++) {
257 if (sband->channels[i].flags & IEEE80211_CHAN_DISABLED)
258 continue;
259
260 found = true;
261 break;
262 }
263
264 if (found)
265 return;
266
267 sband->n_channels = 0;
268 dev->hw->wiphy->bands[band] = NULL;
269 }
270
271 struct mt76_dev *
mt76_alloc_device(unsigned int size,const struct ieee80211_ops * ops)272 mt76_alloc_device(unsigned int size, const struct ieee80211_ops *ops)
273 {
274 struct ieee80211_hw *hw;
275 struct mt76_dev *dev;
276
277 hw = ieee80211_alloc_hw(size, ops);
278 if (!hw)
279 return NULL;
280
281 dev = hw->priv;
282 dev->hw = hw;
283 spin_lock_init(&dev->rx_lock);
284 spin_lock_init(&dev->lock);
285 spin_lock_init(&dev->cc_lock);
286 init_waitqueue_head(&dev->tx_wait);
287
288 return dev;
289 }
290 EXPORT_SYMBOL_GPL(mt76_alloc_device);
291
mt76_register_device(struct mt76_dev * dev,bool vht,struct ieee80211_rate * rates,int n_rates)292 int mt76_register_device(struct mt76_dev *dev, bool vht,
293 struct ieee80211_rate *rates, int n_rates)
294 {
295 struct ieee80211_hw *hw = dev->hw;
296 struct wiphy *wiphy = hw->wiphy;
297 int ret;
298
299 dev_set_drvdata(dev->dev, dev);
300
301 INIT_LIST_HEAD(&dev->txwi_cache);
302
303 SET_IEEE80211_DEV(hw, dev->dev);
304 SET_IEEE80211_PERM_ADDR(hw, dev->macaddr);
305
306 wiphy->features |= NL80211_FEATURE_ACTIVE_MONITOR;
307
308 wiphy->available_antennas_tx = dev->antenna_mask;
309 wiphy->available_antennas_rx = dev->antenna_mask;
310
311 hw->txq_data_size = sizeof(struct mt76_txq);
312 hw->max_tx_fragments = 16;
313
314 ieee80211_hw_set(hw, SIGNAL_DBM);
315 ieee80211_hw_set(hw, PS_NULLFUNC_STACK);
316 ieee80211_hw_set(hw, HOST_BROADCAST_PS_BUFFERING);
317 ieee80211_hw_set(hw, AMPDU_AGGREGATION);
318 ieee80211_hw_set(hw, SUPPORTS_RC_TABLE);
319 ieee80211_hw_set(hw, SUPPORT_FAST_XMIT);
320 ieee80211_hw_set(hw, SUPPORTS_CLONED_SKBS);
321 ieee80211_hw_set(hw, SUPPORTS_AMSDU_IN_AMPDU);
322 ieee80211_hw_set(hw, TX_AMSDU);
323 ieee80211_hw_set(hw, TX_FRAG_LIST);
324 ieee80211_hw_set(hw, MFP_CAPABLE);
325 ieee80211_hw_set(hw, AP_LINK_PS);
326
327 wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
328
329 if (dev->cap.has_2ghz) {
330 ret = mt76_init_sband_2g(dev, rates, n_rates);
331 if (ret)
332 return ret;
333 }
334
335 if (dev->cap.has_5ghz) {
336 ret = mt76_init_sband_5g(dev, rates + 4, n_rates - 4, vht);
337 if (ret)
338 return ret;
339 }
340
341 wiphy_read_of_freq_limits(dev->hw->wiphy);
342 mt76_check_sband(dev, NL80211_BAND_2GHZ);
343 mt76_check_sband(dev, NL80211_BAND_5GHZ);
344
345 ret = mt76_led_init(dev);
346 if (ret)
347 return ret;
348
349 return ieee80211_register_hw(hw);
350 }
351 EXPORT_SYMBOL_GPL(mt76_register_device);
352
mt76_unregister_device(struct mt76_dev * dev)353 void mt76_unregister_device(struct mt76_dev *dev)
354 {
355 struct ieee80211_hw *hw = dev->hw;
356
357 ieee80211_unregister_hw(hw);
358 mt76_tx_free(dev);
359 }
360 EXPORT_SYMBOL_GPL(mt76_unregister_device);
361
mt76_rx(struct mt76_dev * dev,enum mt76_rxq_id q,struct sk_buff * skb)362 void mt76_rx(struct mt76_dev *dev, enum mt76_rxq_id q, struct sk_buff *skb)
363 {
364 if (!test_bit(MT76_STATE_RUNNING, &dev->state)) {
365 dev_kfree_skb(skb);
366 return;
367 }
368
369 __skb_queue_tail(&dev->rx_skb[q], skb);
370 }
371 EXPORT_SYMBOL_GPL(mt76_rx);
372
mt76_has_tx_pending(struct mt76_dev * dev)373 static bool mt76_has_tx_pending(struct mt76_dev *dev)
374 {
375 int i;
376
377 for (i = 0; i < ARRAY_SIZE(dev->q_tx); i++) {
378 if (dev->q_tx[i].queued)
379 return true;
380 }
381
382 return false;
383 }
384
mt76_set_channel(struct mt76_dev * dev)385 void mt76_set_channel(struct mt76_dev *dev)
386 {
387 struct ieee80211_hw *hw = dev->hw;
388 struct cfg80211_chan_def *chandef = &hw->conf.chandef;
389 struct mt76_channel_state *state;
390 bool offchannel = hw->conf.flags & IEEE80211_CONF_OFFCHANNEL;
391 int timeout = HZ / 5;
392
393 if (offchannel)
394 set_bit(MT76_OFFCHANNEL, &dev->state);
395 else
396 clear_bit(MT76_OFFCHANNEL, &dev->state);
397
398 wait_event_timeout(dev->tx_wait, !mt76_has_tx_pending(dev), timeout);
399
400 if (dev->drv->update_survey)
401 dev->drv->update_survey(dev);
402
403 dev->chandef = *chandef;
404
405 if (!offchannel)
406 dev->main_chan = chandef->chan;
407
408 if (chandef->chan != dev->main_chan) {
409 state = mt76_channel_state(dev, chandef->chan);
410 memset(state, 0, sizeof(*state));
411 }
412 }
413 EXPORT_SYMBOL_GPL(mt76_set_channel);
414
mt76_get_survey(struct ieee80211_hw * hw,int idx,struct survey_info * survey)415 int mt76_get_survey(struct ieee80211_hw *hw, int idx,
416 struct survey_info *survey)
417 {
418 struct mt76_dev *dev = hw->priv;
419 struct mt76_sband *sband;
420 struct ieee80211_channel *chan;
421 struct mt76_channel_state *state;
422 int ret = 0;
423
424 if (idx == 0 && dev->drv->update_survey)
425 dev->drv->update_survey(dev);
426
427 sband = &dev->sband_2g;
428 if (idx >= sband->sband.n_channels) {
429 idx -= sband->sband.n_channels;
430 sband = &dev->sband_5g;
431 }
432
433 if (idx >= sband->sband.n_channels)
434 return -ENOENT;
435
436 chan = &sband->sband.channels[idx];
437 state = mt76_channel_state(dev, chan);
438
439 memset(survey, 0, sizeof(*survey));
440 survey->channel = chan;
441 survey->filled = SURVEY_INFO_TIME | SURVEY_INFO_TIME_BUSY;
442 if (chan == dev->main_chan)
443 survey->filled |= SURVEY_INFO_IN_USE;
444
445 spin_lock_bh(&dev->cc_lock);
446 survey->time = div_u64(state->cc_active, 1000);
447 survey->time_busy = div_u64(state->cc_busy, 1000);
448 spin_unlock_bh(&dev->cc_lock);
449
450 return ret;
451 }
452 EXPORT_SYMBOL_GPL(mt76_get_survey);
453
mt76_wcid_key_setup(struct mt76_dev * dev,struct mt76_wcid * wcid,struct ieee80211_key_conf * key)454 void mt76_wcid_key_setup(struct mt76_dev *dev, struct mt76_wcid *wcid,
455 struct ieee80211_key_conf *key)
456 {
457 struct ieee80211_key_seq seq;
458 int i;
459
460 wcid->rx_check_pn = false;
461
462 if (!key)
463 return;
464
465 if (key->cipher == WLAN_CIPHER_SUITE_CCMP)
466 wcid->rx_check_pn = true;
467
468 for (i = 0; i < IEEE80211_NUM_TIDS; i++) {
469 ieee80211_get_key_rx_seq(key, i, &seq);
470 memcpy(wcid->rx_key_pn[i], seq.ccmp.pn, sizeof(seq.ccmp.pn));
471 }
472 }
473 EXPORT_SYMBOL(mt76_wcid_key_setup);
474
mt76_rx_convert(struct sk_buff * skb)475 static struct ieee80211_sta *mt76_rx_convert(struct sk_buff *skb)
476 {
477 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
478 struct mt76_rx_status mstat;
479
480 mstat = *((struct mt76_rx_status *) skb->cb);
481 memset(status, 0, sizeof(*status));
482
483 status->flag = mstat.flag;
484 status->freq = mstat.freq;
485 status->enc_flags = mstat.enc_flags;
486 status->encoding = mstat.encoding;
487 status->bw = mstat.bw;
488 status->rate_idx = mstat.rate_idx;
489 status->nss = mstat.nss;
490 status->band = mstat.band;
491 status->signal = mstat.signal;
492 status->chains = mstat.chains;
493
494 BUILD_BUG_ON(sizeof(mstat) > sizeof(skb->cb));
495 BUILD_BUG_ON(sizeof(status->chain_signal) != sizeof(mstat.chain_signal));
496 memcpy(status->chain_signal, mstat.chain_signal, sizeof(mstat.chain_signal));
497
498 return wcid_to_sta(mstat.wcid);
499 }
500
501 static int
mt76_check_ccmp_pn(struct sk_buff * skb)502 mt76_check_ccmp_pn(struct sk_buff *skb)
503 {
504 struct mt76_rx_status *status = (struct mt76_rx_status *) skb->cb;
505 struct mt76_wcid *wcid = status->wcid;
506 struct ieee80211_hdr *hdr;
507 int ret;
508
509 if (!(status->flag & RX_FLAG_DECRYPTED))
510 return 0;
511
512 if (!wcid || !wcid->rx_check_pn)
513 return 0;
514
515 if (!(status->flag & RX_FLAG_IV_STRIPPED)) {
516 /*
517 * Validate the first fragment both here and in mac80211
518 * All further fragments will be validated by mac80211 only.
519 */
520 hdr = (struct ieee80211_hdr *) skb->data;
521 if (ieee80211_is_frag(hdr) &&
522 !ieee80211_is_first_frag(hdr->frame_control))
523 return 0;
524 }
525
526 BUILD_BUG_ON(sizeof(status->iv) != sizeof(wcid->rx_key_pn[0]));
527 ret = memcmp(status->iv, wcid->rx_key_pn[status->tid],
528 sizeof(status->iv));
529 if (ret <= 0)
530 return -EINVAL; /* replay */
531
532 memcpy(wcid->rx_key_pn[status->tid], status->iv, sizeof(status->iv));
533
534 if (status->flag & RX_FLAG_IV_STRIPPED)
535 status->flag |= RX_FLAG_PN_VALIDATED;
536
537 return 0;
538 }
539
540 static void
mt76_check_ps(struct mt76_dev * dev,struct sk_buff * skb)541 mt76_check_ps(struct mt76_dev *dev, struct sk_buff *skb)
542 {
543 struct mt76_rx_status *status = (struct mt76_rx_status *) skb->cb;
544 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
545 struct ieee80211_sta *sta;
546 struct mt76_wcid *wcid = status->wcid;
547 bool ps;
548
549 if (!wcid || !wcid->sta)
550 return;
551
552 sta = container_of((void *) wcid, struct ieee80211_sta, drv_priv);
553
554 if (!test_bit(MT_WCID_FLAG_CHECK_PS, &wcid->flags))
555 return;
556
557 if (ieee80211_is_pspoll(hdr->frame_control)) {
558 ieee80211_sta_pspoll(sta);
559 return;
560 }
561
562 if (ieee80211_has_morefrags(hdr->frame_control) ||
563 !(ieee80211_is_mgmt(hdr->frame_control) ||
564 ieee80211_is_data(hdr->frame_control)))
565 return;
566
567 ps = ieee80211_has_pm(hdr->frame_control);
568
569 if (ps && (ieee80211_is_data_qos(hdr->frame_control) ||
570 ieee80211_is_qos_nullfunc(hdr->frame_control)))
571 ieee80211_sta_uapsd_trigger(sta, status->tid);
572
573 if (!!test_bit(MT_WCID_FLAG_PS, &wcid->flags) == ps)
574 return;
575
576 if (ps)
577 set_bit(MT_WCID_FLAG_PS, &wcid->flags);
578 else
579 clear_bit(MT_WCID_FLAG_PS, &wcid->flags);
580
581 dev->drv->sta_ps(dev, sta, ps);
582 ieee80211_sta_ps_transition(sta, ps);
583 }
584
mt76_rx_complete(struct mt76_dev * dev,struct sk_buff_head * frames,struct napi_struct * napi)585 void mt76_rx_complete(struct mt76_dev *dev, struct sk_buff_head *frames,
586 struct napi_struct *napi)
587 {
588 struct ieee80211_sta *sta;
589 struct sk_buff *skb;
590
591 spin_lock(&dev->rx_lock);
592 while ((skb = __skb_dequeue(frames)) != NULL) {
593 if (mt76_check_ccmp_pn(skb)) {
594 dev_kfree_skb(skb);
595 continue;
596 }
597
598 sta = mt76_rx_convert(skb);
599 ieee80211_rx_napi(dev->hw, sta, skb, napi);
600 }
601 spin_unlock(&dev->rx_lock);
602 }
603
mt76_rx_poll_complete(struct mt76_dev * dev,enum mt76_rxq_id q,struct napi_struct * napi)604 void mt76_rx_poll_complete(struct mt76_dev *dev, enum mt76_rxq_id q,
605 struct napi_struct *napi)
606 {
607 struct sk_buff_head frames;
608 struct sk_buff *skb;
609
610 __skb_queue_head_init(&frames);
611
612 while ((skb = __skb_dequeue(&dev->rx_skb[q])) != NULL) {
613 mt76_check_ps(dev, skb);
614 mt76_rx_aggr_reorder(skb, &frames);
615 }
616
617 mt76_rx_complete(dev, &frames, napi);
618 }
619 EXPORT_SYMBOL_GPL(mt76_rx_poll_complete);
620
