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 if (IS_ENABLED(CONFIG_MT76_LEDS)) {
346 ret = mt76_led_init(dev);
347 if (ret)
348 return ret;
349 }
350
351 return ieee80211_register_hw(hw);
352 }
353 EXPORT_SYMBOL_GPL(mt76_register_device);
354
mt76_unregister_device(struct mt76_dev * dev)355 void mt76_unregister_device(struct mt76_dev *dev)
356 {
357 struct ieee80211_hw *hw = dev->hw;
358
359 ieee80211_unregister_hw(hw);
360 mt76_tx_free(dev);
361 }
362 EXPORT_SYMBOL_GPL(mt76_unregister_device);
363
mt76_rx(struct mt76_dev * dev,enum mt76_rxq_id q,struct sk_buff * skb)364 void mt76_rx(struct mt76_dev *dev, enum mt76_rxq_id q, struct sk_buff *skb)
365 {
366 if (!test_bit(MT76_STATE_RUNNING, &dev->state)) {
367 dev_kfree_skb(skb);
368 return;
369 }
370
371 __skb_queue_tail(&dev->rx_skb[q], skb);
372 }
373 EXPORT_SYMBOL_GPL(mt76_rx);
374
mt76_has_tx_pending(struct mt76_dev * dev)375 static bool mt76_has_tx_pending(struct mt76_dev *dev)
376 {
377 int i;
378
379 for (i = 0; i < ARRAY_SIZE(dev->q_tx); i++) {
380 if (dev->q_tx[i].queued)
381 return true;
382 }
383
384 return false;
385 }
386
mt76_set_channel(struct mt76_dev * dev)387 void mt76_set_channel(struct mt76_dev *dev)
388 {
389 struct ieee80211_hw *hw = dev->hw;
390 struct cfg80211_chan_def *chandef = &hw->conf.chandef;
391 struct mt76_channel_state *state;
392 bool offchannel = hw->conf.flags & IEEE80211_CONF_OFFCHANNEL;
393 int timeout = HZ / 5;
394
395 if (offchannel)
396 set_bit(MT76_OFFCHANNEL, &dev->state);
397 else
398 clear_bit(MT76_OFFCHANNEL, &dev->state);
399
400 wait_event_timeout(dev->tx_wait, !mt76_has_tx_pending(dev), timeout);
401
402 if (dev->drv->update_survey)
403 dev->drv->update_survey(dev);
404
405 dev->chandef = *chandef;
406
407 if (!offchannel)
408 dev->main_chan = chandef->chan;
409
410 if (chandef->chan != dev->main_chan) {
411 state = mt76_channel_state(dev, chandef->chan);
412 memset(state, 0, sizeof(*state));
413 }
414 }
415 EXPORT_SYMBOL_GPL(mt76_set_channel);
416
mt76_get_survey(struct ieee80211_hw * hw,int idx,struct survey_info * survey)417 int mt76_get_survey(struct ieee80211_hw *hw, int idx,
418 struct survey_info *survey)
419 {
420 struct mt76_dev *dev = hw->priv;
421 struct mt76_sband *sband;
422 struct ieee80211_channel *chan;
423 struct mt76_channel_state *state;
424 int ret = 0;
425
426 if (idx == 0 && dev->drv->update_survey)
427 dev->drv->update_survey(dev);
428
429 sband = &dev->sband_2g;
430 if (idx >= sband->sband.n_channels) {
431 idx -= sband->sband.n_channels;
432 sband = &dev->sband_5g;
433 }
434
435 if (idx >= sband->sband.n_channels)
436 return -ENOENT;
437
438 chan = &sband->sband.channels[idx];
439 state = mt76_channel_state(dev, chan);
440
441 memset(survey, 0, sizeof(*survey));
442 survey->channel = chan;
443 survey->filled = SURVEY_INFO_TIME | SURVEY_INFO_TIME_BUSY;
444 if (chan == dev->main_chan)
445 survey->filled |= SURVEY_INFO_IN_USE;
446
447 spin_lock_bh(&dev->cc_lock);
448 survey->time = div_u64(state->cc_active, 1000);
449 survey->time_busy = div_u64(state->cc_busy, 1000);
450 spin_unlock_bh(&dev->cc_lock);
451
452 return ret;
453 }
454 EXPORT_SYMBOL_GPL(mt76_get_survey);
455
mt76_wcid_key_setup(struct mt76_dev * dev,struct mt76_wcid * wcid,struct ieee80211_key_conf * key)456 void mt76_wcid_key_setup(struct mt76_dev *dev, struct mt76_wcid *wcid,
457 struct ieee80211_key_conf *key)
458 {
459 struct ieee80211_key_seq seq;
460 int i;
461
462 wcid->rx_check_pn = false;
463
464 if (!key)
465 return;
466
467 if (key->cipher == WLAN_CIPHER_SUITE_CCMP)
468 wcid->rx_check_pn = true;
469
470 for (i = 0; i < IEEE80211_NUM_TIDS; i++) {
471 ieee80211_get_key_rx_seq(key, i, &seq);
472 memcpy(wcid->rx_key_pn[i], seq.ccmp.pn, sizeof(seq.ccmp.pn));
473 }
474 }
475 EXPORT_SYMBOL(mt76_wcid_key_setup);
476
mt76_rx_convert(struct sk_buff * skb)477 static struct ieee80211_sta *mt76_rx_convert(struct sk_buff *skb)
478 {
479 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
480 struct mt76_rx_status mstat;
481
482 mstat = *((struct mt76_rx_status *) skb->cb);
483 memset(status, 0, sizeof(*status));
484
485 status->flag = mstat.flag;
486 status->freq = mstat.freq;
487 status->enc_flags = mstat.enc_flags;
488 status->encoding = mstat.encoding;
489 status->bw = mstat.bw;
490 status->rate_idx = mstat.rate_idx;
491 status->nss = mstat.nss;
492 status->band = mstat.band;
493 status->signal = mstat.signal;
494 status->chains = mstat.chains;
495
496 BUILD_BUG_ON(sizeof(mstat) > sizeof(skb->cb));
497 BUILD_BUG_ON(sizeof(status->chain_signal) != sizeof(mstat.chain_signal));
498 memcpy(status->chain_signal, mstat.chain_signal, sizeof(mstat.chain_signal));
499
500 return wcid_to_sta(mstat.wcid);
501 }
502
503 static int
mt76_check_ccmp_pn(struct sk_buff * skb)504 mt76_check_ccmp_pn(struct sk_buff *skb)
505 {
506 struct mt76_rx_status *status = (struct mt76_rx_status *) skb->cb;
507 struct mt76_wcid *wcid = status->wcid;
508 struct ieee80211_hdr *hdr;
509 int ret;
510
511 if (!(status->flag & RX_FLAG_DECRYPTED))
512 return 0;
513
514 if (!wcid || !wcid->rx_check_pn)
515 return 0;
516
517 if (!(status->flag & RX_FLAG_IV_STRIPPED)) {
518 /*
519 * Validate the first fragment both here and in mac80211
520 * All further fragments will be validated by mac80211 only.
521 */
522 hdr = (struct ieee80211_hdr *) skb->data;
523 if (ieee80211_is_frag(hdr) &&
524 !ieee80211_is_first_frag(hdr->frame_control))
525 return 0;
526 }
527
528 BUILD_BUG_ON(sizeof(status->iv) != sizeof(wcid->rx_key_pn[0]));
529 ret = memcmp(status->iv, wcid->rx_key_pn[status->tid],
530 sizeof(status->iv));
531 if (ret <= 0)
532 return -EINVAL; /* replay */
533
534 memcpy(wcid->rx_key_pn[status->tid], status->iv, sizeof(status->iv));
535
536 if (status->flag & RX_FLAG_IV_STRIPPED)
537 status->flag |= RX_FLAG_PN_VALIDATED;
538
539 return 0;
540 }
541
542 static void
mt76_check_ps(struct mt76_dev * dev,struct sk_buff * skb)543 mt76_check_ps(struct mt76_dev *dev, struct sk_buff *skb)
544 {
545 struct mt76_rx_status *status = (struct mt76_rx_status *) skb->cb;
546 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
547 struct ieee80211_sta *sta;
548 struct mt76_wcid *wcid = status->wcid;
549 bool ps;
550
551 if (ieee80211_is_pspoll(hdr->frame_control) && !wcid) {
552 sta = ieee80211_find_sta_by_ifaddr(dev->hw, hdr->addr2, NULL);
553 if (sta)
554 wcid = status->wcid = (struct mt76_wcid *) sta->drv_priv;
555 }
556
557 if (!wcid || !wcid->sta)
558 return;
559
560 sta = container_of((void *) wcid, struct ieee80211_sta, drv_priv);
561
562 if (!test_bit(MT_WCID_FLAG_CHECK_PS, &wcid->flags))
563 return;
564
565 if (ieee80211_is_pspoll(hdr->frame_control)) {
566 ieee80211_sta_pspoll(sta);
567 return;
568 }
569
570 if (ieee80211_has_morefrags(hdr->frame_control) ||
571 !(ieee80211_is_mgmt(hdr->frame_control) ||
572 ieee80211_is_data(hdr->frame_control)))
573 return;
574
575 ps = ieee80211_has_pm(hdr->frame_control);
576
577 if (ps && (ieee80211_is_data_qos(hdr->frame_control) ||
578 ieee80211_is_qos_nullfunc(hdr->frame_control)))
579 ieee80211_sta_uapsd_trigger(sta, status->tid);
580
581 if (!!test_bit(MT_WCID_FLAG_PS, &wcid->flags) == ps)
582 return;
583
584 if (ps)
585 set_bit(MT_WCID_FLAG_PS, &wcid->flags);
586 else
587 clear_bit(MT_WCID_FLAG_PS, &wcid->flags);
588
589 dev->drv->sta_ps(dev, sta, ps);
590 ieee80211_sta_ps_transition(sta, ps);
591 }
592
mt76_rx_complete(struct mt76_dev * dev,struct sk_buff_head * frames,struct napi_struct * napi)593 void mt76_rx_complete(struct mt76_dev *dev, struct sk_buff_head *frames,
594 struct napi_struct *napi)
595 {
596 struct ieee80211_sta *sta;
597 struct sk_buff *skb;
598
599 spin_lock(&dev->rx_lock);
600 while ((skb = __skb_dequeue(frames)) != NULL) {
601 if (mt76_check_ccmp_pn(skb)) {
602 dev_kfree_skb(skb);
603 continue;
604 }
605
606 sta = mt76_rx_convert(skb);
607 ieee80211_rx_napi(dev->hw, sta, skb, napi);
608 }
609 spin_unlock(&dev->rx_lock);
610 }
611
mt76_rx_poll_complete(struct mt76_dev * dev,enum mt76_rxq_id q,struct napi_struct * napi)612 void mt76_rx_poll_complete(struct mt76_dev *dev, enum mt76_rxq_id q,
613 struct napi_struct *napi)
614 {
615 struct sk_buff_head frames;
616 struct sk_buff *skb;
617
618 __skb_queue_head_init(&frames);
619
620 while ((skb = __skb_dequeue(&dev->rx_skb[q])) != NULL) {
621 mt76_check_ps(dev, skb);
622 mt76_rx_aggr_reorder(skb, &frames);
623 }
624
625 mt76_rx_complete(dev, &frames, napi);
626 }
627 EXPORT_SYMBOL_GPL(mt76_rx_poll_complete);
628