2 * Copyright (C) 2016 Felix Fietkau <nbd@nbd.name>
3 * Copyright (C) 2018 Stanislaw Gruszka <stf_xl@wp.pl>
5 * Permission to use, copy, modify, and/or distribute this software for any
6 * purpose with or without fee is hereby granted, provided that the above
7 * copyright notice and this permission notice appear in all copies.
9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19 #include "mt76x02_trace.h"
21 static enum mt76x02_cipher_type
22 mt76x02_mac_get_key_info(struct ieee80211_key_conf
*key
, u8
*key_data
)
24 memset(key_data
, 0, 32);
26 return MT_CIPHER_NONE
;
29 return MT_CIPHER_NONE
;
31 memcpy(key_data
, key
->key
, key
->keylen
);
33 switch (key
->cipher
) {
34 case WLAN_CIPHER_SUITE_WEP40
:
35 return MT_CIPHER_WEP40
;
36 case WLAN_CIPHER_SUITE_WEP104
:
37 return MT_CIPHER_WEP104
;
38 case WLAN_CIPHER_SUITE_TKIP
:
39 return MT_CIPHER_TKIP
;
40 case WLAN_CIPHER_SUITE_CCMP
:
41 return MT_CIPHER_AES_CCMP
;
43 return MT_CIPHER_NONE
;
47 int mt76x02_mac_shared_key_setup(struct mt76x02_dev
*dev
, u8 vif_idx
,
48 u8 key_idx
, struct ieee80211_key_conf
*key
)
50 enum mt76x02_cipher_type cipher
;
54 cipher
= mt76x02_mac_get_key_info(key
, key_data
);
55 if (cipher
== MT_CIPHER_NONE
&& key
)
58 val
= mt76_rr(dev
, MT_SKEY_MODE(vif_idx
));
59 val
&= ~(MT_SKEY_MODE_MASK
<< MT_SKEY_MODE_SHIFT(vif_idx
, key_idx
));
60 val
|= cipher
<< MT_SKEY_MODE_SHIFT(vif_idx
, key_idx
);
61 mt76_wr(dev
, MT_SKEY_MODE(vif_idx
), val
);
63 mt76_wr_copy(dev
, MT_SKEY(vif_idx
, key_idx
), key_data
,
68 EXPORT_SYMBOL_GPL(mt76x02_mac_shared_key_setup
);
70 void mt76x02_mac_wcid_sync_pn(struct mt76x02_dev
*dev
, u8 idx
,
71 struct ieee80211_key_conf
*key
)
73 enum mt76x02_cipher_type cipher
;
78 cipher
= mt76x02_mac_get_key_info(key
, key_data
);
79 iv
= mt76_rr(dev
, MT_WCID_IV(idx
));
80 eiv
= mt76_rr(dev
, MT_WCID_IV(idx
) + 4);
83 if (cipher
== MT_CIPHER_TKIP
) {
84 pn
|= (iv
>> 16) & 0xff;
85 pn
|= (iv
& 0xff) << 8;
86 } else if (cipher
>= MT_CIPHER_AES_CCMP
) {
92 atomic64_set(&key
->tx_pn
, pn
);
96 int mt76x02_mac_wcid_set_key(struct mt76x02_dev
*dev
, u8 idx
,
97 struct ieee80211_key_conf
*key
)
99 enum mt76x02_cipher_type cipher
;
104 cipher
= mt76x02_mac_get_key_info(key
, key_data
);
105 if (cipher
== MT_CIPHER_NONE
&& key
)
108 mt76_wr_copy(dev
, MT_WCID_KEY(idx
), key_data
, sizeof(key_data
));
109 mt76_rmw_field(dev
, MT_WCID_ATTR(idx
), MT_WCID_ATTR_PKEY_MODE
, cipher
);
111 memset(iv_data
, 0, sizeof(iv_data
));
113 mt76_rmw_field(dev
, MT_WCID_ATTR(idx
), MT_WCID_ATTR_PAIRWISE
,
114 !!(key
->flags
& IEEE80211_KEY_FLAG_PAIRWISE
));
116 pn
= atomic64_read(&key
->tx_pn
);
118 iv_data
[3] = key
->keyidx
<< 6;
119 if (cipher
>= MT_CIPHER_TKIP
) {
121 put_unaligned_le32(pn
>> 16, &iv_data
[4]);
124 if (cipher
== MT_CIPHER_TKIP
) {
125 iv_data
[0] = (pn
>> 8) & 0xff;
126 iv_data
[1] = (iv_data
[0] | 0x20) & 0x7f;
127 iv_data
[2] = pn
& 0xff;
128 } else if (cipher
>= MT_CIPHER_AES_CCMP
) {
129 put_unaligned_le16((pn
& 0xffff), &iv_data
[0]);
133 mt76_wr_copy(dev
, MT_WCID_IV(idx
), iv_data
, sizeof(iv_data
));
138 void mt76x02_mac_wcid_setup(struct mt76x02_dev
*dev
, u8 idx
,
141 struct mt76_wcid_addr addr
= {};
144 attr
= FIELD_PREP(MT_WCID_ATTR_BSS_IDX
, vif_idx
& 7) |
145 FIELD_PREP(MT_WCID_ATTR_BSS_IDX_EXT
, !!(vif_idx
& 8));
147 mt76_wr(dev
, MT_WCID_ATTR(idx
), attr
);
153 memcpy(addr
.macaddr
, mac
, ETH_ALEN
);
155 mt76_wr_copy(dev
, MT_WCID_ADDR(idx
), &addr
, sizeof(addr
));
157 EXPORT_SYMBOL_GPL(mt76x02_mac_wcid_setup
);
159 void mt76x02_mac_wcid_set_drop(struct mt76x02_dev
*dev
, u8 idx
, bool drop
)
161 u32 val
= mt76_rr(dev
, MT_WCID_DROP(idx
));
162 u32 bit
= MT_WCID_DROP_MASK(idx
);
164 /* prevent unnecessary writes */
165 if ((val
& bit
) != (bit
* drop
))
166 mt76_wr(dev
, MT_WCID_DROP(idx
), (val
& ~bit
) | (bit
* drop
));
170 mt76x02_mac_tx_rate_val(struct mt76x02_dev
*dev
,
171 const struct ieee80211_tx_rate
*rate
, u8
*nss_val
)
173 u8 phy
, rate_idx
, nss
, bw
= 0;
176 if (rate
->flags
& IEEE80211_TX_RC_VHT_MCS
) {
177 rate_idx
= rate
->idx
;
178 nss
= 1 + (rate
->idx
>> 4);
179 phy
= MT_PHY_TYPE_VHT
;
180 if (rate
->flags
& IEEE80211_TX_RC_80_MHZ_WIDTH
)
182 else if (rate
->flags
& IEEE80211_TX_RC_40_MHZ_WIDTH
)
184 } else if (rate
->flags
& IEEE80211_TX_RC_MCS
) {
185 rate_idx
= rate
->idx
;
186 nss
= 1 + (rate
->idx
>> 3);
187 phy
= MT_PHY_TYPE_HT
;
188 if (rate
->flags
& IEEE80211_TX_RC_GREEN_FIELD
)
189 phy
= MT_PHY_TYPE_HT_GF
;
190 if (rate
->flags
& IEEE80211_TX_RC_40_MHZ_WIDTH
)
193 const struct ieee80211_rate
*r
;
194 int band
= dev
->mt76
.chandef
.chan
->band
;
197 r
= &dev
->mt76
.hw
->wiphy
->bands
[band
]->bitrates
[rate
->idx
];
198 if (rate
->flags
& IEEE80211_TX_RC_USE_SHORT_PREAMBLE
)
199 val
= r
->hw_value_short
;
204 rate_idx
= val
& 0xff;
208 rateval
= FIELD_PREP(MT_RXWI_RATE_INDEX
, rate_idx
);
209 rateval
|= FIELD_PREP(MT_RXWI_RATE_PHY
, phy
);
210 rateval
|= FIELD_PREP(MT_RXWI_RATE_BW
, bw
);
211 if (rate
->flags
& IEEE80211_TX_RC_SHORT_GI
)
212 rateval
|= MT_RXWI_RATE_SGI
;
215 return cpu_to_le16(rateval
);
218 void mt76x02_mac_wcid_set_rate(struct mt76x02_dev
*dev
, struct mt76_wcid
*wcid
,
219 const struct ieee80211_tx_rate
*rate
)
221 spin_lock_bh(&dev
->mt76
.lock
);
222 wcid
->tx_rate
= mt76x02_mac_tx_rate_val(dev
, rate
, &wcid
->tx_rate_nss
);
223 wcid
->tx_rate_set
= true;
224 spin_unlock_bh(&dev
->mt76
.lock
);
227 void mt76x02_mac_set_short_preamble(struct mt76x02_dev
*dev
, bool enable
)
230 mt76_set(dev
, MT_AUTO_RSP_CFG
, MT_AUTO_RSP_PREAMB_SHORT
);
232 mt76_clear(dev
, MT_AUTO_RSP_CFG
, MT_AUTO_RSP_PREAMB_SHORT
);
235 bool mt76x02_mac_load_tx_status(struct mt76x02_dev
*dev
,
236 struct mt76x02_tx_status
*stat
)
240 stat2
= mt76_rr(dev
, MT_TX_STAT_FIFO_EXT
);
241 stat1
= mt76_rr(dev
, MT_TX_STAT_FIFO
);
243 stat
->valid
= !!(stat1
& MT_TX_STAT_FIFO_VALID
);
247 stat
->success
= !!(stat1
& MT_TX_STAT_FIFO_SUCCESS
);
248 stat
->aggr
= !!(stat1
& MT_TX_STAT_FIFO_AGGR
);
249 stat
->ack_req
= !!(stat1
& MT_TX_STAT_FIFO_ACKREQ
);
250 stat
->wcid
= FIELD_GET(MT_TX_STAT_FIFO_WCID
, stat1
);
251 stat
->rate
= FIELD_GET(MT_TX_STAT_FIFO_RATE
, stat1
);
253 stat
->retry
= FIELD_GET(MT_TX_STAT_FIFO_EXT_RETRY
, stat2
);
254 stat
->pktid
= FIELD_GET(MT_TX_STAT_FIFO_EXT_PKTID
, stat2
);
256 trace_mac_txstat_fetch(dev
, stat
);
262 mt76x02_mac_process_tx_rate(struct ieee80211_tx_rate
*txrate
, u16 rate
,
263 enum nl80211_band band
)
265 u8 idx
= FIELD_GET(MT_RXWI_RATE_INDEX
, rate
);
271 switch (FIELD_GET(MT_RXWI_RATE_PHY
, rate
)) {
272 case MT_PHY_TYPE_OFDM
:
273 if (band
== NL80211_BAND_2GHZ
)
278 case MT_PHY_TYPE_CCK
:
284 case MT_PHY_TYPE_HT_GF
:
285 txrate
->flags
|= IEEE80211_TX_RC_GREEN_FIELD
;
288 txrate
->flags
|= IEEE80211_TX_RC_MCS
;
291 case MT_PHY_TYPE_VHT
:
292 txrate
->flags
|= IEEE80211_TX_RC_VHT_MCS
;
299 switch (FIELD_GET(MT_RXWI_RATE_BW
, rate
)) {
303 txrate
->flags
|= IEEE80211_TX_RC_40_MHZ_WIDTH
;
306 txrate
->flags
|= IEEE80211_TX_RC_80_MHZ_WIDTH
;
312 if (rate
& MT_RXWI_RATE_SGI
)
313 txrate
->flags
|= IEEE80211_TX_RC_SHORT_GI
;
318 void mt76x02_mac_write_txwi(struct mt76x02_dev
*dev
, struct mt76x02_txwi
*txwi
,
319 struct sk_buff
*skb
, struct mt76_wcid
*wcid
,
320 struct ieee80211_sta
*sta
, int len
)
322 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)skb
->data
;
323 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
324 struct ieee80211_tx_rate
*rate
= &info
->control
.rates
[0];
325 struct ieee80211_key_conf
*key
= info
->control
.hw_key
;
326 u16 rate_ht_mask
= FIELD_PREP(MT_RXWI_RATE_PHY
, BIT(1) | BIT(2));
329 s8 txpwr_adj
, max_txpwr_adj
;
330 u8 ccmp_pn
[8], nstreams
= dev
->mt76
.chainmask
& 0xf;
332 memset(txwi
, 0, sizeof(*txwi
));
334 if (!info
->control
.hw_key
&& wcid
&& wcid
->hw_key_idx
!= 0xff &&
335 ieee80211_has_protected(hdr
->frame_control
)) {
337 ieee80211_get_tx_rates(info
->control
.vif
, sta
, skb
,
338 info
->control
.rates
, 1);
342 txwi
->wcid
= wcid
->idx
;
346 if (wcid
&& wcid
->sw_iv
&& key
) {
347 u64 pn
= atomic64_inc_return(&key
->tx_pn
);
349 ccmp_pn
[1] = pn
>> 8;
351 ccmp_pn
[3] = 0x20 | (key
->keyidx
<< 6);
352 ccmp_pn
[4] = pn
>> 16;
353 ccmp_pn
[5] = pn
>> 24;
354 ccmp_pn
[6] = pn
>> 32;
355 ccmp_pn
[7] = pn
>> 40;
356 txwi
->iv
= *((__le32
*)&ccmp_pn
[0]);
357 txwi
->eiv
= *((__le32
*)&ccmp_pn
[4]);
360 spin_lock_bh(&dev
->mt76
.lock
);
361 if (wcid
&& (rate
->idx
< 0 || !rate
->count
)) {
362 txwi
->rate
= wcid
->tx_rate
;
363 max_txpwr_adj
= wcid
->max_txpwr_adj
;
364 nss
= wcid
->tx_rate_nss
;
366 txwi
->rate
= mt76x02_mac_tx_rate_val(dev
, rate
, &nss
);
367 max_txpwr_adj
= mt76x02_tx_get_max_txpwr_adj(dev
, rate
);
369 spin_unlock_bh(&dev
->mt76
.lock
);
371 txpwr_adj
= mt76x02_tx_get_txpwr_adj(dev
, dev
->mt76
.txpower_conf
,
373 txwi
->ctl2
= FIELD_PREP(MT_TX_PWR_ADJ
, txpwr_adj
);
375 if (nstreams
> 1 && mt76_rev(&dev
->mt76
) >= MT76XX_REV_E4
)
376 txwi
->txstream
= 0x13;
377 else if (nstreams
> 1 && mt76_rev(&dev
->mt76
) >= MT76XX_REV_E3
&&
378 !(txwi
->rate
& cpu_to_le16(rate_ht_mask
)))
379 txwi
->txstream
= 0x93;
381 if (is_mt76x2(dev
) && (info
->flags
& IEEE80211_TX_CTL_LDPC
))
382 txwi
->rate
|= cpu_to_le16(MT_RXWI_RATE_LDPC
);
383 if ((info
->flags
& IEEE80211_TX_CTL_STBC
) && nss
== 1)
384 txwi
->rate
|= cpu_to_le16(MT_RXWI_RATE_STBC
);
385 if (nss
> 1 && sta
&& sta
->smps_mode
== IEEE80211_SMPS_DYNAMIC
)
386 txwi_flags
|= MT_TXWI_FLAGS_MMPS
;
387 if (!(info
->flags
& IEEE80211_TX_CTL_NO_ACK
))
388 txwi
->ack_ctl
|= MT_TXWI_ACK_CTL_REQ
;
389 if (info
->flags
& IEEE80211_TX_CTL_ASSIGN_SEQ
)
390 txwi
->ack_ctl
|= MT_TXWI_ACK_CTL_NSEQ
;
391 if ((info
->flags
& IEEE80211_TX_CTL_AMPDU
) && sta
) {
392 u8 ba_size
= IEEE80211_MIN_AMPDU_BUF
;
394 ba_size
<<= sta
->ht_cap
.ampdu_factor
;
395 ba_size
= min_t(int, 63, ba_size
- 1);
396 if (info
->flags
& IEEE80211_TX_CTL_RATE_CTRL_PROBE
)
398 txwi
->ack_ctl
|= FIELD_PREP(MT_TXWI_ACK_CTL_BA_WINDOW
, ba_size
);
400 txwi_flags
|= MT_TXWI_FLAGS_AMPDU
|
401 FIELD_PREP(MT_TXWI_FLAGS_MPDU_DENSITY
,
402 sta
->ht_cap
.ampdu_density
);
405 if (ieee80211_is_probe_resp(hdr
->frame_control
) ||
406 ieee80211_is_beacon(hdr
->frame_control
))
407 txwi_flags
|= MT_TXWI_FLAGS_TS
;
409 txwi
->flags
|= cpu_to_le16(txwi_flags
);
410 txwi
->len_ctl
= cpu_to_le16(len
);
412 EXPORT_SYMBOL_GPL(mt76x02_mac_write_txwi
);
415 mt76x02_mac_fill_tx_status(struct mt76x02_dev
*dev
,
416 struct ieee80211_tx_info
*info
,
417 struct mt76x02_tx_status
*st
, int n_frames
)
419 struct ieee80211_tx_rate
*rate
= info
->status
.rates
;
420 int cur_idx
, last_rate
;
426 last_rate
= min_t(int, st
->retry
, IEEE80211_TX_MAX_RATES
- 1);
427 mt76x02_mac_process_tx_rate(&rate
[last_rate
], st
->rate
,
428 dev
->mt76
.chandef
.chan
->band
);
429 if (last_rate
< IEEE80211_TX_MAX_RATES
- 1)
430 rate
[last_rate
+ 1].idx
= -1;
432 cur_idx
= rate
[last_rate
].idx
+ last_rate
;
433 for (i
= 0; i
<= last_rate
; i
++) {
434 rate
[i
].flags
= rate
[last_rate
].flags
;
435 rate
[i
].idx
= max_t(int, 0, cur_idx
- i
);
438 rate
[last_rate
].count
= st
->retry
+ 1 - last_rate
;
440 info
->status
.ampdu_len
= n_frames
;
441 info
->status
.ampdu_ack_len
= st
->success
? n_frames
: 0;
444 info
->flags
|= IEEE80211_TX_CTL_AMPDU
|
445 IEEE80211_TX_STAT_AMPDU
;
448 info
->flags
|= IEEE80211_TX_CTL_NO_ACK
;
449 else if (st
->success
)
450 info
->flags
|= IEEE80211_TX_STAT_ACK
;
453 void mt76x02_send_tx_status(struct mt76x02_dev
*dev
,
454 struct mt76x02_tx_status
*stat
, u8
*update
)
456 struct ieee80211_tx_info info
= {};
457 struct ieee80211_tx_status status
= {
460 struct mt76_wcid
*wcid
= NULL
;
461 struct mt76x02_sta
*msta
= NULL
;
462 struct mt76_dev
*mdev
= &dev
->mt76
;
463 struct sk_buff_head list
;
465 if (stat
->pktid
== MT_PACKET_ID_NO_ACK
)
469 mt76_tx_status_lock(mdev
, &list
);
471 if (stat
->wcid
< ARRAY_SIZE(dev
->mt76
.wcid
))
472 wcid
= rcu_dereference(dev
->mt76
.wcid
[stat
->wcid
]);
474 if (wcid
&& wcid
->sta
) {
477 priv
= msta
= container_of(wcid
, struct mt76x02_sta
, wcid
);
478 status
.sta
= container_of(priv
, struct ieee80211_sta
,
483 if (stat
->pktid
>= MT_PACKET_ID_FIRST
)
484 status
.skb
= mt76_tx_status_skb_get(mdev
, wcid
,
487 status
.info
= IEEE80211_SKB_CB(status
.skb
);
490 if (msta
&& stat
->aggr
&& !status
.skb
) {
491 u32 stat_val
, stat_cache
;
493 stat_val
= stat
->rate
;
494 stat_val
|= ((u32
) stat
->retry
) << 16;
495 stat_cache
= msta
->status
.rate
;
496 stat_cache
|= ((u32
) msta
->status
.retry
) << 16;
498 if (*update
== 0 && stat_val
== stat_cache
&&
499 stat
->wcid
== msta
->status
.wcid
&& msta
->n_frames
< 32) {
504 mt76x02_mac_fill_tx_status(dev
, status
.info
, &msta
->status
,
507 msta
->status
= *stat
;
511 mt76x02_mac_fill_tx_status(dev
, status
.info
, stat
, 1);
516 mt76_tx_status_skb_done(mdev
, status
.skb
, &list
);
518 ieee80211_tx_status_ext(mt76_hw(dev
), &status
);
521 mt76_tx_status_unlock(mdev
, &list
);
526 mt76x02_mac_process_rate(struct mt76x02_dev
*dev
,
527 struct mt76_rx_status
*status
,
530 u8 idx
= FIELD_GET(MT_RXWI_RATE_INDEX
, rate
);
532 switch (FIELD_GET(MT_RXWI_RATE_PHY
, rate
)) {
533 case MT_PHY_TYPE_OFDM
:
537 if (status
->band
== NL80211_BAND_2GHZ
)
540 status
->rate_idx
= idx
;
542 case MT_PHY_TYPE_CCK
:
545 status
->enc_flags
|= RX_ENC_FLAG_SHORTPRE
;
551 status
->rate_idx
= idx
;
553 case MT_PHY_TYPE_HT_GF
:
554 status
->enc_flags
|= RX_ENC_FLAG_HT_GF
;
557 status
->encoding
= RX_ENC_HT
;
558 status
->rate_idx
= idx
;
560 case MT_PHY_TYPE_VHT
: {
561 u8 n_rxstream
= dev
->mt76
.chainmask
& 0xf;
563 status
->encoding
= RX_ENC_VHT
;
564 status
->rate_idx
= FIELD_GET(MT_RATE_INDEX_VHT_IDX
, idx
);
565 status
->nss
= min_t(u8
, n_rxstream
,
566 FIELD_GET(MT_RATE_INDEX_VHT_NSS
, idx
) + 1);
573 if (rate
& MT_RXWI_RATE_LDPC
)
574 status
->enc_flags
|= RX_ENC_FLAG_LDPC
;
576 if (rate
& MT_RXWI_RATE_SGI
)
577 status
->enc_flags
|= RX_ENC_FLAG_SHORT_GI
;
579 if (rate
& MT_RXWI_RATE_STBC
)
580 status
->enc_flags
|= 1 << RX_ENC_FLAG_STBC_SHIFT
;
582 switch (FIELD_GET(MT_RXWI_RATE_BW
, rate
)) {
586 status
->bw
= RATE_INFO_BW_40
;
589 status
->bw
= RATE_INFO_BW_80
;
598 void mt76x02_mac_setaddr(struct mt76x02_dev
*dev
, const u8
*addr
)
600 static const u8 null_addr
[ETH_ALEN
] = {};
603 ether_addr_copy(dev
->mt76
.macaddr
, addr
);
605 if (!is_valid_ether_addr(dev
->mt76
.macaddr
)) {
606 eth_random_addr(dev
->mt76
.macaddr
);
607 dev_info(dev
->mt76
.dev
,
608 "Invalid MAC address, using random address %pM\n",
612 mt76_wr(dev
, MT_MAC_ADDR_DW0
, get_unaligned_le32(dev
->mt76
.macaddr
));
613 mt76_wr(dev
, MT_MAC_ADDR_DW1
,
614 get_unaligned_le16(dev
->mt76
.macaddr
+ 4) |
615 FIELD_PREP(MT_MAC_ADDR_DW1_U2ME_MASK
, 0xff));
617 mt76_wr(dev
, MT_MAC_BSSID_DW0
,
618 get_unaligned_le32(dev
->mt76
.macaddr
));
619 mt76_wr(dev
, MT_MAC_BSSID_DW1
,
620 get_unaligned_le16(dev
->mt76
.macaddr
+ 4) |
621 FIELD_PREP(MT_MAC_BSSID_DW1_MBSS_MODE
, 3) | /* 8 APs + 8 STAs */
622 MT_MAC_BSSID_DW1_MBSS_LOCAL_BIT
);
624 for (i
= 0; i
< 16; i
++)
625 mt76x02_mac_set_bssid(dev
, i
, null_addr
);
627 EXPORT_SYMBOL_GPL(mt76x02_mac_setaddr
);
630 mt76x02_mac_get_rssi(struct mt76x02_dev
*dev
, s8 rssi
, int chain
)
632 struct mt76x02_rx_freq_cal
*cal
= &dev
->cal
.rx
;
634 rssi
+= cal
->rssi_offset
[chain
];
635 rssi
-= cal
->lna_gain
;
640 int mt76x02_mac_process_rx(struct mt76x02_dev
*dev
, struct sk_buff
*skb
,
643 struct mt76_rx_status
*status
= (struct mt76_rx_status
*) skb
->cb
;
644 struct mt76x02_rxwi
*rxwi
= rxi
;
645 struct mt76x02_sta
*sta
;
646 u32 rxinfo
= le32_to_cpu(rxwi
->rxinfo
);
647 u32 ctl
= le32_to_cpu(rxwi
->ctl
);
648 u16 rate
= le16_to_cpu(rxwi
->rate
);
649 u16 tid_sn
= le16_to_cpu(rxwi
->tid_sn
);
650 bool unicast
= rxwi
->rxinfo
& cpu_to_le32(MT_RXINFO_UNICAST
);
651 int pad_len
= 0, nstreams
= dev
->mt76
.chainmask
& 0xf;
657 if (!test_bit(MT76_STATE_RUNNING
, &dev
->mt76
.state
))
660 if (rxinfo
& MT_RXINFO_L2PAD
)
663 if (rxinfo
& MT_RXINFO_DECRYPT
) {
664 status
->flag
|= RX_FLAG_DECRYPTED
;
665 status
->flag
|= RX_FLAG_MMIC_STRIPPED
;
666 status
->flag
|= RX_FLAG_MIC_STRIPPED
;
667 status
->flag
|= RX_FLAG_IV_STRIPPED
;
670 wcid
= FIELD_GET(MT_RXWI_CTL_WCID
, ctl
);
671 sta
= mt76x02_rx_get_sta(&dev
->mt76
, wcid
);
672 status
->wcid
= mt76x02_rx_get_sta_wcid(sta
, unicast
);
674 len
= FIELD_GET(MT_RXWI_CTL_MPDU_LEN
, ctl
);
675 pn_len
= FIELD_GET(MT_RXINFO_PN_LEN
, rxinfo
);
677 int offset
= ieee80211_get_hdrlen_from_skb(skb
) + pad_len
;
678 u8
*data
= skb
->data
+ offset
;
680 status
->iv
[0] = data
[7];
681 status
->iv
[1] = data
[6];
682 status
->iv
[2] = data
[5];
683 status
->iv
[3] = data
[4];
684 status
->iv
[4] = data
[1];
685 status
->iv
[5] = data
[0];
688 * Driver CCMP validation can't deal with fragments.
689 * Let mac80211 take care of it.
691 if (rxinfo
& MT_RXINFO_FRAG
) {
692 status
->flag
&= ~RX_FLAG_IV_STRIPPED
;
694 pad_len
+= pn_len
<< 2;
699 mt76x02_remove_hdr_pad(skb
, pad_len
);
701 if ((rxinfo
& MT_RXINFO_BA
) && !(rxinfo
& MT_RXINFO_NULL
))
704 if (WARN_ON_ONCE(len
> skb
->len
))
709 status
->chains
= BIT(0);
710 signal
= mt76x02_mac_get_rssi(dev
, rxwi
->rssi
[0], 0);
711 status
->chain_signal
[0] = signal
;
713 status
->chains
|= BIT(1);
714 status
->chain_signal
[1] = mt76x02_mac_get_rssi(dev
,
717 signal
= max_t(s8
, signal
, status
->chain_signal
[1]);
719 status
->signal
= signal
;
720 status
->freq
= dev
->mt76
.chandef
.chan
->center_freq
;
721 status
->band
= dev
->mt76
.chandef
.chan
->band
;
723 status
->tid
= FIELD_GET(MT_RXWI_TID
, tid_sn
);
724 status
->seqno
= FIELD_GET(MT_RXWI_SN
, tid_sn
);
726 return mt76x02_mac_process_rate(dev
, status
, rate
);
729 void mt76x02_mac_poll_tx_status(struct mt76x02_dev
*dev
, bool irq
)
731 struct mt76x02_tx_status stat
= {};
736 if (!test_bit(MT76_STATE_RUNNING
, &dev
->mt76
.state
))
739 trace_mac_txstat_poll(dev
);
741 while (!irq
|| !kfifo_is_full(&dev
->txstatus_fifo
)) {
742 spin_lock_irqsave(&dev
->mt76
.mmio
.irq_lock
, flags
);
743 ret
= mt76x02_mac_load_tx_status(dev
, &stat
);
744 spin_unlock_irqrestore(&dev
->mt76
.mmio
.irq_lock
, flags
);
750 mt76x02_send_tx_status(dev
, &stat
, &update
);
754 kfifo_put(&dev
->txstatus_fifo
, stat
);
758 void mt76x02_tx_complete_skb(struct mt76_dev
*mdev
, struct mt76_queue
*q
,
759 struct mt76_queue_entry
*e
, bool flush
)
761 struct mt76x02_dev
*dev
= container_of(mdev
, struct mt76x02_dev
, mt76
);
762 struct mt76x02_txwi
*txwi
;
765 dev_kfree_skb_any(e
->skb
);
769 mt76x02_mac_poll_tx_status(dev
, false);
771 txwi
= (struct mt76x02_txwi
*) &e
->txwi
->txwi
;
772 trace_mac_txdone_add(dev
, txwi
->wcid
, txwi
->pktid
);
774 mt76_tx_complete_skb(mdev
, e
->skb
);
776 EXPORT_SYMBOL_GPL(mt76x02_tx_complete_skb
);
778 void mt76x02_mac_set_rts_thresh(struct mt76x02_dev
*dev
, u32 val
)
783 data
= FIELD_PREP(MT_PROT_CFG_CTRL
, 1) |
784 MT_PROT_CFG_RTS_THRESH
;
786 mt76_rmw_field(dev
, MT_TX_RTS_CFG
, MT_TX_RTS_CFG_THRESH
, val
);
788 mt76_rmw(dev
, MT_CCK_PROT_CFG
,
789 MT_PROT_CFG_CTRL
| MT_PROT_CFG_RTS_THRESH
, data
);
790 mt76_rmw(dev
, MT_OFDM_PROT_CFG
,
791 MT_PROT_CFG_CTRL
| MT_PROT_CFG_RTS_THRESH
, data
);
794 void mt76x02_mac_set_tx_protection(struct mt76x02_dev
*dev
, bool legacy_prot
,
797 int mode
= ht_mode
& IEEE80211_HT_OP_MODE_PROTECTION
;
798 bool non_gf
= !!(ht_mode
& IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT
);
804 for (i
= 0; i
< ARRAY_SIZE(prot
); i
++) {
805 prot
[i
] = mt76_rr(dev
, MT_CCK_PROT_CFG
+ i
* 4);
806 prot
[i
] &= ~MT_PROT_CFG_CTRL
;
808 prot
[i
] &= ~MT_PROT_CFG_RATE
;
811 for (i
= 0; i
< ARRAY_SIZE(vht_prot
); i
++) {
812 vht_prot
[i
] = mt76_rr(dev
, MT_TX_PROT_CFG6
+ i
* 4);
813 vht_prot
[i
] &= ~(MT_PROT_CFG_CTRL
| MT_PROT_CFG_RATE
);
816 rts_thr
= mt76_get_field(dev
, MT_TX_RTS_CFG
, MT_TX_RTS_CFG_THRESH
);
818 if (rts_thr
!= 0xffff)
819 prot
[0] |= MT_PROT_CTRL_RTS_CTS
;
822 prot
[1] |= MT_PROT_CTRL_CTS2SELF
;
824 prot
[2] |= MT_PROT_RATE_CCK_11
;
825 prot
[3] |= MT_PROT_RATE_CCK_11
;
826 prot
[4] |= MT_PROT_RATE_CCK_11
;
827 prot
[5] |= MT_PROT_RATE_CCK_11
;
829 vht_prot
[0] |= MT_PROT_RATE_CCK_11
;
830 vht_prot
[1] |= MT_PROT_RATE_CCK_11
;
831 vht_prot
[2] |= MT_PROT_RATE_CCK_11
;
833 if (rts_thr
!= 0xffff)
834 prot
[1] |= MT_PROT_CTRL_RTS_CTS
;
836 prot
[2] |= MT_PROT_RATE_OFDM_24
;
837 prot
[3] |= MT_PROT_RATE_DUP_OFDM_24
;
838 prot
[4] |= MT_PROT_RATE_OFDM_24
;
839 prot
[5] |= MT_PROT_RATE_DUP_OFDM_24
;
841 vht_prot
[0] |= MT_PROT_RATE_OFDM_24
;
842 vht_prot
[1] |= MT_PROT_RATE_DUP_OFDM_24
;
843 vht_prot
[2] |= MT_PROT_RATE_SGI_OFDM_24
;
847 case IEEE80211_HT_OP_MODE_PROTECTION_NONMEMBER
:
848 case IEEE80211_HT_OP_MODE_PROTECTION_NONHT_MIXED
:
849 prot
[2] |= MT_PROT_CTRL_RTS_CTS
;
850 prot
[3] |= MT_PROT_CTRL_RTS_CTS
;
851 prot
[4] |= MT_PROT_CTRL_RTS_CTS
;
852 prot
[5] |= MT_PROT_CTRL_RTS_CTS
;
853 vht_prot
[0] |= MT_PROT_CTRL_RTS_CTS
;
854 vht_prot
[1] |= MT_PROT_CTRL_RTS_CTS
;
855 vht_prot
[2] |= MT_PROT_CTRL_RTS_CTS
;
857 case IEEE80211_HT_OP_MODE_PROTECTION_20MHZ
:
858 prot
[3] |= MT_PROT_CTRL_RTS_CTS
;
859 prot
[5] |= MT_PROT_CTRL_RTS_CTS
;
860 vht_prot
[1] |= MT_PROT_CTRL_RTS_CTS
;
861 vht_prot
[2] |= MT_PROT_CTRL_RTS_CTS
;
866 prot
[4] |= MT_PROT_CTRL_RTS_CTS
;
867 prot
[5] |= MT_PROT_CTRL_RTS_CTS
;
870 for (i
= 0; i
< ARRAY_SIZE(prot
); i
++)
871 mt76_wr(dev
, MT_CCK_PROT_CFG
+ i
* 4, prot
[i
]);
873 for (i
= 0; i
< ARRAY_SIZE(vht_prot
); i
++)
874 mt76_wr(dev
, MT_TX_PROT_CFG6
+ i
* 4, vht_prot
[i
]);
877 void mt76x02_update_channel(struct mt76_dev
*mdev
)
879 struct mt76x02_dev
*dev
= container_of(mdev
, struct mt76x02_dev
, mt76
);
880 struct mt76_channel_state
*state
;
883 state
= mt76_channel_state(&dev
->mt76
, dev
->mt76
.chandef
.chan
);
885 busy
= mt76_rr(dev
, MT_CH_BUSY
);
886 active
= busy
+ mt76_rr(dev
, MT_CH_IDLE
);
888 spin_lock_bh(&dev
->mt76
.cc_lock
);
889 state
->cc_busy
+= busy
;
890 state
->cc_active
+= active
;
891 spin_unlock_bh(&dev
->mt76
.cc_lock
);
893 EXPORT_SYMBOL_GPL(mt76x02_update_channel
);
895 static void mt76x02_check_mac_err(struct mt76x02_dev
*dev
)
897 u32 val
= mt76_rr(dev
, 0x10f4);
899 if (!(val
& BIT(29)) || !(val
& (BIT(7) | BIT(5))))
902 dev_err(dev
->mt76
.dev
, "mac specific condition occurred\n");
904 mt76_set(dev
, MT_MAC_SYS_CTRL
, MT_MAC_SYS_CTRL_RESET_CSR
);
906 mt76_wr(dev
, MT_MAC_SYS_CTRL
,
907 MT_MAC_SYS_CTRL_ENABLE_TX
| MT_MAC_SYS_CTRL_ENABLE_RX
);
911 mt76x02_edcca_tx_enable(struct mt76x02_dev
*dev
, bool enable
)
916 mt76_set(dev
, MT_MAC_SYS_CTRL
, MT_MAC_SYS_CTRL_ENABLE_TX
);
917 mt76_set(dev
, MT_AUTO_RSP_CFG
, MT_AUTO_RSP_EN
);
919 data
= mt76_rr(dev
, MT_TX_PIN_CFG
);
920 data
|= MT_TX_PIN_CFG_TXANT
|
921 MT_TX_PIN_CFG_RXANT
|
924 mt76_wr(dev
, MT_TX_PIN_CFG
, data
);
926 mt76_clear(dev
, MT_MAC_SYS_CTRL
, MT_MAC_SYS_CTRL_ENABLE_TX
);
927 mt76_clear(dev
, MT_AUTO_RSP_CFG
, MT_AUTO_RSP_EN
);
929 mt76_clear(dev
, MT_TX_PIN_CFG
, MT_TX_PIN_CFG_TXANT
);
930 mt76_clear(dev
, MT_TX_PIN_CFG
, MT_TX_PIN_CFG_RXANT
);
932 dev
->ed_tx_blocked
= !enable
;
935 void mt76x02_edcca_init(struct mt76x02_dev
*dev
, bool enable
)
940 if (dev
->ed_monitor
&& enable
) {
941 struct ieee80211_channel
*chan
= dev
->mt76
.chandef
.chan
;
942 u8 ed_th
= chan
->band
== NL80211_BAND_5GHZ
? 0x0e : 0x20;
944 mt76_clear(dev
, MT_TX_LINK_CFG
, MT_TX_CFACK_EN
);
945 mt76_set(dev
, MT_TXOP_CTRL_CFG
, MT_TXOP_ED_CCA_EN
);
946 mt76_rmw(dev
, MT_BBP(AGC
, 2), GENMASK(15, 0),
948 mt76_set(dev
, MT_TXOP_HLDR_ET
, MT_TXOP_HLDR_TX40M_BLK_EN
);
950 mt76_set(dev
, MT_TX_LINK_CFG
, MT_TX_CFACK_EN
);
951 mt76_clear(dev
, MT_TXOP_CTRL_CFG
, MT_TXOP_ED_CCA_EN
);
952 if (is_mt76x2(dev
)) {
953 mt76_wr(dev
, MT_BBP(AGC
, 2), 0x00007070);
954 mt76_set(dev
, MT_TXOP_HLDR_ET
,
955 MT_TXOP_HLDR_TX40M_BLK_EN
);
957 mt76_wr(dev
, MT_BBP(AGC
, 2), 0x003a6464);
958 mt76_clear(dev
, MT_TXOP_HLDR_ET
,
959 MT_TXOP_HLDR_TX40M_BLK_EN
);
962 mt76x02_edcca_tx_enable(dev
, true);
963 dev
->ed_monitor_learning
= true;
965 /* clear previous CCA timer value */
966 mt76_rr(dev
, MT_ED_CCA_TIMER
);
967 dev
->ed_time
= ktime_get_boottime();
969 EXPORT_SYMBOL_GPL(mt76x02_edcca_init
);
971 #define MT_EDCCA_TH 92
972 #define MT_EDCCA_BLOCK_TH 2
973 #define MT_EDCCA_LEARN_TH 50
974 #define MT_EDCCA_LEARN_CCA 180
975 #define MT_EDCCA_LEARN_TIMEOUT (20 * HZ)
977 static void mt76x02_edcca_check(struct mt76x02_dev
*dev
)
980 u32 active
, val
, busy
;
982 cur_time
= ktime_get_boottime();
983 val
= mt76_rr(dev
, MT_ED_CCA_TIMER
);
985 active
= ktime_to_us(ktime_sub(cur_time
, dev
->ed_time
));
986 dev
->ed_time
= cur_time
;
988 busy
= (val
* 100) / active
;
989 busy
= min_t(u32
, busy
, 100);
991 if (busy
> MT_EDCCA_TH
) {
999 if (dev
->cal
.agc_lowest_gain
&&
1000 dev
->cal
.false_cca
> MT_EDCCA_LEARN_CCA
&&
1001 dev
->ed_trigger
> MT_EDCCA_LEARN_TH
) {
1002 dev
->ed_monitor_learning
= false;
1003 dev
->ed_trigger_timeout
= jiffies
+ 20 * HZ
;
1004 } else if (!dev
->ed_monitor_learning
&&
1005 time_is_after_jiffies(dev
->ed_trigger_timeout
)) {
1006 dev
->ed_monitor_learning
= true;
1007 mt76x02_edcca_tx_enable(dev
, true);
1010 if (dev
->ed_monitor_learning
)
1013 if (dev
->ed_trigger
> MT_EDCCA_BLOCK_TH
&& !dev
->ed_tx_blocked
)
1014 mt76x02_edcca_tx_enable(dev
, false);
1015 else if (dev
->ed_silent
> MT_EDCCA_BLOCK_TH
&& dev
->ed_tx_blocked
)
1016 mt76x02_edcca_tx_enable(dev
, true);
1019 void mt76x02_mac_work(struct work_struct
*work
)
1021 struct mt76x02_dev
*dev
= container_of(work
, struct mt76x02_dev
,
1025 mutex_lock(&dev
->mt76
.mutex
);
1027 mt76x02_update_channel(&dev
->mt76
);
1028 for (i
= 0, idx
= 0; i
< 16; i
++) {
1029 u32 val
= mt76_rr(dev
, MT_TX_AGG_CNT(i
));
1031 dev
->aggr_stats
[idx
++] += val
& 0xffff;
1032 dev
->aggr_stats
[idx
++] += val
>> 16;
1035 if (!dev
->beacon_mask
)
1036 mt76x02_check_mac_err(dev
);
1038 if (dev
->ed_monitor
)
1039 mt76x02_edcca_check(dev
);
1041 mutex_unlock(&dev
->mt76
.mutex
);
1043 mt76_tx_status_check(&dev
->mt76
, NULL
, false);
1045 ieee80211_queue_delayed_work(mt76_hw(dev
), &dev
->mac_work
,
1046 MT_MAC_WORK_INTERVAL
);
1049 void mt76x02_mac_set_bssid(struct mt76x02_dev
*dev
, u8 idx
, const u8
*addr
)
1052 mt76_wr(dev
, MT_MAC_APC_BSSID_L(idx
), get_unaligned_le32(addr
));
1053 mt76_rmw_field(dev
, MT_MAC_APC_BSSID_H(idx
), MT_MAC_APC_BSSID_H_ADDR
,
1054 get_unaligned_le16(addr
+ 4));
1058 mt76x02_write_beacon(struct mt76x02_dev
*dev
, int offset
, struct sk_buff
*skb
)
1060 int beacon_len
= mt76x02_beacon_offsets
[1] - mt76x02_beacon_offsets
[0];
1061 struct mt76x02_txwi txwi
;
1063 if (WARN_ON_ONCE(beacon_len
< skb
->len
+ sizeof(struct mt76x02_txwi
)))
1066 mt76x02_mac_write_txwi(dev
, &txwi
, skb
, NULL
, NULL
, skb
->len
);
1068 mt76_wr_copy(dev
, offset
, &txwi
, sizeof(txwi
));
1069 offset
+= sizeof(txwi
);
1071 mt76_wr_copy(dev
, offset
, skb
->data
, skb
->len
);
1076 __mt76x02_mac_set_beacon(struct mt76x02_dev
*dev
, u8 bcn_idx
,
1077 struct sk_buff
*skb
)
1079 int beacon_len
= mt76x02_beacon_offsets
[1] - mt76x02_beacon_offsets
[0];
1080 int beacon_addr
= mt76x02_beacon_offsets
[bcn_idx
];
1084 /* Prevent corrupt transmissions during update */
1085 mt76_set(dev
, MT_BCN_BYPASS_MASK
, BIT(bcn_idx
));
1088 ret
= mt76x02_write_beacon(dev
, beacon_addr
, skb
);
1090 dev
->beacon_data_mask
|= BIT(bcn_idx
);
1092 dev
->beacon_data_mask
&= ~BIT(bcn_idx
);
1093 for (i
= 0; i
< beacon_len
; i
+= 4)
1094 mt76_wr(dev
, beacon_addr
+ i
, 0);
1097 mt76_wr(dev
, MT_BCN_BYPASS_MASK
, 0xff00 | ~dev
->beacon_data_mask
);
1102 int mt76x02_mac_set_beacon(struct mt76x02_dev
*dev
, u8 vif_idx
,
1103 struct sk_buff
*skb
)
1105 bool force_update
= false;
1109 for (i
= 0; i
< ARRAY_SIZE(dev
->beacons
); i
++) {
1111 force_update
= !!dev
->beacons
[i
] ^ !!skb
;
1113 if (dev
->beacons
[i
])
1114 dev_kfree_skb(dev
->beacons
[i
]);
1116 dev
->beacons
[i
] = skb
;
1117 __mt76x02_mac_set_beacon(dev
, bcn_idx
, skb
);
1118 } else if (force_update
&& dev
->beacons
[i
]) {
1119 __mt76x02_mac_set_beacon(dev
, bcn_idx
,
1123 bcn_idx
+= !!dev
->beacons
[i
];
1126 for (i
= bcn_idx
; i
< ARRAY_SIZE(dev
->beacons
); i
++) {
1127 if (!(dev
->beacon_data_mask
& BIT(i
)))
1130 __mt76x02_mac_set_beacon(dev
, i
, NULL
);
1133 mt76_rmw_field(dev
, MT_MAC_BSSID_DW1
, MT_MAC_BSSID_DW1_MBEACON_N
,
1139 __mt76x02_mac_set_beacon_enable(struct mt76x02_dev
*dev
, u8 vif_idx
,
1140 bool val
, struct sk_buff
*skb
)
1142 u8 old_mask
= dev
->beacon_mask
;
1147 dev
->beacon_mask
|= BIT(vif_idx
);
1149 mt76x02_mac_set_beacon(dev
, vif_idx
, skb
);
1151 dev
->beacon_mask
&= ~BIT(vif_idx
);
1152 mt76x02_mac_set_beacon(dev
, vif_idx
, NULL
);
1155 if (!!old_mask
== !!dev
->beacon_mask
)
1158 en
= dev
->beacon_mask
;
1160 reg
= MT_BEACON_TIME_CFG_BEACON_TX
|
1161 MT_BEACON_TIME_CFG_TBTT_EN
|
1162 MT_BEACON_TIME_CFG_TIMER_EN
;
1163 mt76_rmw(dev
, MT_BEACON_TIME_CFG
, reg
, reg
* en
);
1165 if (mt76_is_usb(dev
))
1168 mt76_rmw_field(dev
, MT_INT_TIMER_EN
, MT_INT_TIMER_EN_PRE_TBTT_EN
, en
);
1170 mt76x02_irq_enable(dev
, MT_INT_PRE_TBTT
| MT_INT_TBTT
);
1172 mt76x02_irq_disable(dev
, MT_INT_PRE_TBTT
| MT_INT_TBTT
);
1175 void mt76x02_mac_set_beacon_enable(struct mt76x02_dev
*dev
,
1176 struct ieee80211_vif
*vif
, bool val
)
1178 u8 vif_idx
= ((struct mt76x02_vif
*)vif
->drv_priv
)->idx
;
1179 struct sk_buff
*skb
= NULL
;
1181 if (mt76_is_mmio(dev
))
1182 tasklet_disable(&dev
->pre_tbtt_tasklet
);
1184 skb
= ieee80211_beacon_get(mt76_hw(dev
), vif
);
1186 if (!dev
->beacon_mask
)
1187 dev
->tbtt_count
= 0;
1189 __mt76x02_mac_set_beacon_enable(dev
, vif_idx
, val
, skb
);
1191 if (mt76_is_mmio(dev
))
1192 tasklet_enable(&dev
->pre_tbtt_tasklet
);