drivers/net/wireless/mediatek/mt76-6e-usb/mac80211.c

   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 static 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
 189 static int mt76_led_init(struct mt76_dev *dev)
 190 {
 191         struct device_node *np = dev->dev->of_node;
 192         struct ieee80211_hw *hw = dev->hw;
 193         int led_pin;
 194
 195         if (!dev->led_cdev.brightness_set && !dev->led_cdev.blink_set)
 196                 return 0;
 197
 198         snprintf(dev->led_name, sizeof(dev->led_name),
 199                  "mt76-%s", wiphy_name(hw->wiphy));
 200
 201         dev->led_cdev.name = dev->led_name;
 202         dev->led_cdev.default_trigger =
 203                 ieee80211_create_tpt_led_trigger(hw,
 204                                         IEEE80211_TPT_LEDTRIG_FL_RADIO,
 205                                         mt76_tpt_blink,
 206                                         ARRAY_SIZE(mt76_tpt_blink));
 207
 208         np = of_get_child_by_name(np, "led");
 209         if (np) {
 210                 if (!of_property_read_u32(np, "led-sources", &led_pin))
 211                         dev->led_pin = led_pin;
 212                 dev->led_al = of_property_read_bool(np, "led-active-low");
 213                 of_node_put(np);
 214         }
 215
 216         return led_classdev_register(dev->dev, &dev->led_cdev);
 217 }
 218
 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
 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         vht_cap->cap |= IEEE80211_VHT_CAP_TX_ANTENNA_PATTERN |
 253                         IEEE80211_VHT_CAP_RX_ANTENNA_PATTERN;
 254
 255         for (i = 0; i < 8; i++) {
 256                 if (i < nstream)
 257                         mcs_map |= (IEEE80211_VHT_MCS_SUPPORT_0_9 << (i * 2));
 258                 else
 259                         mcs_map |=
 260                                 (IEEE80211_VHT_MCS_NOT_SUPPORTED << (i * 2));
 261         }
 262         vht_cap->vht_mcs.rx_mcs_map = cpu_to_le16(mcs_map);
 263         vht_cap->vht_mcs.tx_mcs_map = cpu_to_le16(mcs_map);
 264 }
 265
 266 void mt76_set_stream_caps(struct mt76_phy *phy, bool vht)
 267 {
 268         if (phy->cap.has_2ghz)
 269                 mt76_init_stream_cap(phy, &phy->sband_2g.sband, false);
 270         if (phy->cap.has_5ghz)
 271                 mt76_init_stream_cap(phy, &phy->sband_5g.sband, vht);
 272         if (phy->cap.has_6ghz)
 273                 mt76_init_stream_cap(phy, &phy->sband_6g.sband, vht);
 274 }
 275 EXPORT_SYMBOL_GPL(mt76_set_stream_caps);
 276
 277 static int
 278 mt76_init_sband(struct mt76_phy *phy, struct mt76_sband *msband,
 279                 const struct ieee80211_channel *chan, int n_chan,
 280                 struct ieee80211_rate *rates, int n_rates,
 281                 bool ht, bool vht)
 282 {
 283         struct ieee80211_supported_band *sband = &msband->sband;
 284         struct ieee80211_sta_vht_cap *vht_cap;
 285         struct ieee80211_sta_ht_cap *ht_cap;
 286         struct mt76_dev *dev = phy->dev;
 287         void *chanlist;
 288         int size;
 289
 290         size = n_chan * sizeof(*chan);
 291         chanlist = devm_kmemdup(dev->dev, chan, size, GFP_KERNEL);
 292         if (!chanlist)
 293                 return -ENOMEM;
 294
 295         msband->chan = devm_kcalloc(dev->dev, n_chan, sizeof(*msband->chan),
 296                                     GFP_KERNEL);
 297         if (!msband->chan)
 298                 return -ENOMEM;
 299
 300         sband->channels = chanlist;
 301         sband->n_channels = n_chan;
 302         sband->bitrates = rates;
 303         sband->n_bitrates = n_rates;
 304
 305         if (!ht)
 306                 return 0;
 307
 308         ht_cap = &sband->ht_cap;
 309         ht_cap->ht_supported = true;
 310         ht_cap->cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40 |
 311                        IEEE80211_HT_CAP_GRN_FLD |
 312                        IEEE80211_HT_CAP_SGI_20 |
 313                        IEEE80211_HT_CAP_SGI_40 |
 314                        (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT);
 315
 316         ht_cap->mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED;
 317         ht_cap->ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
 318
 319         mt76_init_stream_cap(phy, sband, vht);
 320
 321         if (!vht)
 322                 return 0;
 323
 324         vht_cap = &sband->vht_cap;
 325         vht_cap->vht_supported = true;
 326         vht_cap->cap |= IEEE80211_VHT_CAP_RXLDPC |
 327                         IEEE80211_VHT_CAP_RXSTBC_1 |
 328                         IEEE80211_VHT_CAP_SHORT_GI_80 |
 329                         (3 << IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT);
 330
 331         return 0;
 332 }
 333
 334 static int
 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
 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
 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
 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 int
 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 = phy->antenna_mask;
 415         wiphy->available_antennas_rx = phy->antenna_mask;
 416
 417         wiphy->sar_capa = &mt76_sar_capa;
 418         phy->frp = devm_kcalloc(dev->dev, wiphy->sar_capa->num_freq_ranges,
 419                                 sizeof(struct mt76_freq_range_power),
 420                                 GFP_KERNEL);
 421         if (!phy->frp)
 422                 return -ENOMEM;
 423
 424         hw->txq_data_size = sizeof(struct mt76_txq);
 425         hw->uapsd_max_sp_len = IEEE80211_WMM_IE_STA_QOSINFO_SP_ALL;
 426
 427         if (!hw->max_tx_fragments)
 428                 hw->max_tx_fragments = 16;
 429
 430         ieee80211_hw_set(hw, SIGNAL_DBM);
 431         ieee80211_hw_set(hw, AMPDU_AGGREGATION);
 432         ieee80211_hw_set(hw, SUPPORTS_RC_TABLE);
 433         ieee80211_hw_set(hw, SUPPORT_FAST_XMIT);
 434         ieee80211_hw_set(hw, SUPPORTS_CLONED_SKBS);
 435         ieee80211_hw_set(hw, SUPPORTS_AMSDU_IN_AMPDU);
 436         ieee80211_hw_set(hw, SUPPORTS_REORDERING_BUFFER);
 437         ieee80211_hw_set(hw, TX_AMSDU);
 438         ieee80211_hw_set(hw, TX_FRAG_LIST);
 439         ieee80211_hw_set(hw, MFP_CAPABLE);
 440         ieee80211_hw_set(hw, AP_LINK_PS);
 441         ieee80211_hw_set(hw, REPORTS_TX_ACK_STATUS);
 442
 443         return 0;
 444 }
 445
 446 struct mt76_phy *
 447 mt76_alloc_phy(struct mt76_dev *dev, unsigned int size,
 448                const struct ieee80211_ops *ops)
 449 {
 450         struct ieee80211_hw *hw;
 451         unsigned int phy_size;
 452         struct mt76_phy *phy;
 453
 454         phy_size = ALIGN(sizeof(*phy), 8);
 455         hw = ieee80211_alloc_hw(size + phy_size, ops);
 456         if (!hw)
 457                 return NULL;
 458
 459         phy = hw->priv;
 460         phy->dev = dev;
 461         phy->hw = hw;
 462         phy->priv = hw->priv + phy_size;
 463
 464         hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
 465         hw->wiphy->interface_modes =
 466                 BIT(NL80211_IFTYPE_STATION) |
 467                 BIT(NL80211_IFTYPE_AP) |
 468 #ifdef CONFIG_MAC80211_MESH
 469                 BIT(NL80211_IFTYPE_MESH_POINT) |
 470 #endif
 471                 BIT(NL80211_IFTYPE_P2P_CLIENT) |
 472                 BIT(NL80211_IFTYPE_P2P_GO) |
 473                 BIT(NL80211_IFTYPE_ADHOC);
 474
 475         return phy;
 476 }
 477 EXPORT_SYMBOL_GPL(mt76_alloc_phy);
 478
 479 int mt76_register_phy(struct mt76_phy *phy, bool vht,
 480                       struct ieee80211_rate *rates, int n_rates)
 481 {
 482         int ret;
 483
 484         ret = mt76_phy_init(phy, phy->hw);
 485         if (ret)
 486                 return ret;
 487
 488         if (phy->cap.has_2ghz) {
 489                 ret = mt76_init_sband_2g(phy, rates, n_rates);
 490                 if (ret)
 491                         return ret;
 492         }
 493
 494         if (phy->cap.has_5ghz) {
 495                 ret = mt76_init_sband_5g(phy, rates + 4, n_rates - 4, vht);
 496                 if (ret)
 497                         return ret;
 498         }
 499
 500         if (phy->cap.has_6ghz) {
 501                 ret = mt76_init_sband_6g(phy, rates + 4, n_rates - 4);
 502                 if (ret)
 503                         return ret;
 504         }
 505
 506         wiphy_read_of_freq_limits(phy->hw->wiphy);
 507         mt76_check_sband(phy, &phy->sband_2g, NL80211_BAND_2GHZ);
 508         mt76_check_sband(phy, &phy->sband_5g, NL80211_BAND_5GHZ);
 509         mt76_check_sband(phy, &phy->sband_6g, NL80211_BAND_6GHZ);
 510
 511         ret = ieee80211_register_hw(phy->hw);
 512         if (ret)
 513                 return ret;
 514
 515         phy->dev->phy2 = phy;
 516
 517         return 0;
 518 }
 519 EXPORT_SYMBOL_GPL(mt76_register_phy);
 520
 521 void mt76_unregister_phy(struct mt76_phy *phy)
 522 {
 523         struct mt76_dev *dev = phy->dev;
 524
 525         mt76_tx_status_check(dev, true);
 526         ieee80211_unregister_hw(phy->hw);
 527         dev->phy2 = NULL;
 528 }
 529 EXPORT_SYMBOL_GPL(mt76_unregister_phy);
 530
 531 struct mt76_dev *
 532 mt76_alloc_device(struct device *pdev, unsigned int size,
 533                   const struct ieee80211_ops *ops,
 534                   const struct mt76_driver_ops *drv_ops)
 535 {
 536         struct ieee80211_hw *hw;
 537         struct mt76_phy *phy;
 538         struct mt76_dev *dev;
 539         int i;
 540
 541         hw = ieee80211_alloc_hw(size, ops);
 542         if (!hw)
 543                 return NULL;
 544
 545         dev = hw->priv;
 546         dev->hw = hw;
 547         dev->dev = pdev;
 548         dev->drv = drv_ops;
 549
 550         phy = &dev->phy;
 551         phy->dev = dev;
 552         phy->hw = hw;
 553
 554         spin_lock_init(&dev->rx_lock);
 555         spin_lock_init(&dev->lock);
 556         spin_lock_init(&dev->cc_lock);
 557         spin_lock_init(&dev->status_lock);
 558         mutex_init(&dev->mutex);
 559         init_waitqueue_head(&dev->tx_wait);
 560
 561         skb_queue_head_init(&dev->mcu.res_q);
 562         init_waitqueue_head(&dev->mcu.wait);
 563         mutex_init(&dev->mcu.mutex);
 564         dev->tx_worker.fn = mt76_tx_worker;
 565
 566         hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
 567         hw->wiphy->interface_modes =
 568                 BIT(NL80211_IFTYPE_STATION) |
 569                 BIT(NL80211_IFTYPE_AP) |
 570 #ifdef CONFIG_MAC80211_MESH
 571                 BIT(NL80211_IFTYPE_MESH_POINT) |
 572 #endif
 573                 BIT(NL80211_IFTYPE_P2P_CLIENT) |
 574                 BIT(NL80211_IFTYPE_P2P_GO) |
 575                 BIT(NL80211_IFTYPE_ADHOC);
 576
 577         spin_lock_init(&dev->token_lock);
 578         idr_init(&dev->token);
 579
 580         INIT_LIST_HEAD(&dev->wcid_list);
 581
 582         INIT_LIST_HEAD(&dev->txwi_cache);
 583
 584         for (i = 0; i < ARRAY_SIZE(dev->q_rx); i++)
 585                 skb_queue_head_init(&dev->rx_skb[i]);
 586
 587         dev->wq = alloc_ordered_workqueue("mt76", 0);
 588         if (!dev->wq) {
 589                 ieee80211_free_hw(hw);
 590                 return NULL;
 591         }
 592
 593         return dev;
 594 }
 595 EXPORT_SYMBOL_GPL(mt76_alloc_device);
 596
 597 int mt76_register_device(struct mt76_dev *dev, bool vht,
 598                          struct ieee80211_rate *rates, int n_rates)
 599 {
 600         struct ieee80211_hw *hw = dev->hw;
 601         struct mt76_phy *phy = &dev->phy;
 602         int ret;
 603
 604         dev_set_drvdata(dev->dev, dev);
 605         ret = mt76_phy_init(phy, hw);
 606         if (ret)
 607                 return ret;
 608
 609         if (phy->cap.has_2ghz) {
 610                 ret = mt76_init_sband_2g(phy, rates, n_rates);
 611                 if (ret)
 612                         return ret;
 613         }
 614
 615         if (phy->cap.has_5ghz) {
 616                 ret = mt76_init_sband_5g(phy, rates + 4, n_rates - 4, vht);
 617                 if (ret)
 618                         return ret;
 619         }
 620
 621         if (phy->cap.has_6ghz) {
 622                 ret = mt76_init_sband_6g(phy, rates + 4, n_rates - 4);
 623                 if (ret)
 624                         return ret;
 625         }
 626
 627         wiphy_read_of_freq_limits(hw->wiphy);
 628         mt76_check_sband(&dev->phy, &phy->sband_2g, NL80211_BAND_2GHZ);
 629         mt76_check_sband(&dev->phy, &phy->sband_5g, NL80211_BAND_5GHZ);
 630         mt76_check_sband(&dev->phy, &phy->sband_6g, NL80211_BAND_6GHZ);
 631
 632         if (IS_ENABLED(CONFIG_MT76_LEDS)) {
 633                 ret = mt76_led_init(dev);
 634                 if (ret)
 635                         return ret;
 636         }
 637
 638         ret = ieee80211_register_hw(hw);
 639         if (ret)
 640                 return ret;
 641
 642         WARN_ON(mt76_worker_setup(hw, &dev->tx_worker, NULL, "tx"));
 643         sched_set_fifo_low(dev->tx_worker.task);
 644
 645         return 0;
 646 }
 647 EXPORT_SYMBOL_GPL(mt76_register_device);
 648
 649 void mt76_unregister_device(struct mt76_dev *dev)
 650 {
 651         struct ieee80211_hw *hw = dev->hw;
 652
 653         if (IS_ENABLED(CONFIG_MT76_LEDS))
 654                 mt76_led_cleanup(dev);
 655         mt76_tx_status_check(dev, true);
 656         ieee80211_unregister_hw(hw);
 657 }
 658 EXPORT_SYMBOL_GPL(mt76_unregister_device);
 659
 660 void mt76_free_device(struct mt76_dev *dev)
 661 {
 662         mt76_worker_teardown(&dev->tx_worker);
 663         if (dev->wq) {
 664                 destroy_workqueue(dev->wq);
 665                 dev->wq = NULL;
 666         }
 667         ieee80211_free_hw(dev->hw);
 668 }
 669 EXPORT_SYMBOL_GPL(mt76_free_device);
 670
 671 static void mt76_rx_release_amsdu(struct mt76_phy *phy, enum mt76_rxq_id q)
 672 {
 673         struct sk_buff *skb = phy->rx_amsdu[q].head;
 674         struct mt76_rx_status *status = (struct mt76_rx_status *)skb->cb;
 675         struct mt76_dev *dev = phy->dev;
 676
 677         phy->rx_amsdu[q].head = NULL;
 678         phy->rx_amsdu[q].tail = NULL;
 679
 680         /*
 681          * Validate if the amsdu has a proper first subframe.
 682          * A single MSDU can be parsed as A-MSDU when the unauthenticated A-MSDU
 683          * flag of the QoS header gets flipped. In such cases, the first
 684          * subframe has a LLC/SNAP header in the location of the destination
 685          * address.
 686          */
 687         if (skb_shinfo(skb)->frag_list) {
 688                 int offset = 0;
 689
 690                 if (!(status->flag & RX_FLAG_8023)) {
 691                         offset = ieee80211_get_hdrlen_from_skb(skb);
 692
 693                         if ((status->flag &
 694                              (RX_FLAG_DECRYPTED | RX_FLAG_IV_STRIPPED)) ==
 695                             RX_FLAG_DECRYPTED)
 696                                 offset += 8;
 697                 }
 698
 699                 if (ether_addr_equal(skb->data + offset, rfc1042_header)) {
 700                         dev_kfree_skb(skb);
 701                         return;
 702                 }
 703         }
 704         __skb_queue_tail(&dev->rx_skb[q], skb);
 705 }
 706
 707 static void mt76_rx_release_burst(struct mt76_phy *phy, enum mt76_rxq_id q,
 708                                   struct sk_buff *skb)
 709 {
 710         struct mt76_rx_status *status = (struct mt76_rx_status *)skb->cb;
 711
 712         if (phy->rx_amsdu[q].head &&
 713             (!status->amsdu || status->first_amsdu ||
 714              status->seqno != phy->rx_amsdu[q].seqno))
 715                 mt76_rx_release_amsdu(phy, q);
 716
 717         if (!phy->rx_amsdu[q].head) {
 718                 phy->rx_amsdu[q].tail = &skb_shinfo(skb)->frag_list;
 719                 phy->rx_amsdu[q].seqno = status->seqno;
 720                 phy->rx_amsdu[q].head = skb;
 721         } else {
 722                 *phy->rx_amsdu[q].tail = skb;
 723                 phy->rx_amsdu[q].tail = &skb->next;
 724         }
 725
 726         if (!status->amsdu || status->last_amsdu)
 727                 mt76_rx_release_amsdu(phy, q);
 728 }
 729
 730 void mt76_rx(struct mt76_dev *dev, enum mt76_rxq_id q, struct sk_buff *skb)
 731 {
 732         struct mt76_rx_status *status = (struct mt76_rx_status *)skb->cb;
 733         struct mt76_phy *phy = mt76_dev_phy(dev, status->ext_phy);
 734
 735         if (!test_bit(MT76_STATE_RUNNING, &phy->state)) {
 736                 dev_kfree_skb(skb);
 737                 return;
 738         }
 739
 740 #ifdef CONFIG_NL80211_TESTMODE
 741         if (phy->test.state == MT76_TM_STATE_RX_FRAMES) {
 742                 phy->test.rx_stats.packets[q]++;
 743                 if (status->flag & RX_FLAG_FAILED_FCS_CRC)
 744                         phy->test.rx_stats.fcs_error[q]++;
 745         }
 746 #endif
 747
 748         mt76_rx_release_burst(phy, q, skb);
 749 }
 750 EXPORT_SYMBOL_GPL(mt76_rx);
 751
 752 bool mt76_has_tx_pending(struct mt76_phy *phy)
 753 {
 754         struct mt76_queue *q;
 755         int i;
 756
 757         for (i = 0; i < __MT_TXQ_MAX; i++) {
 758                 q = phy->q_tx[i];
 759                 if (q && q->queued)
 760                         return true;
 761         }
 762
 763         return false;
 764 }
 765 EXPORT_SYMBOL_GPL(mt76_has_tx_pending);
 766
 767 static struct mt76_channel_state *
 768 mt76_channel_state(struct mt76_phy *phy, struct ieee80211_channel *c)
 769 {
 770         struct mt76_sband *msband;
 771         int idx;
 772
 773         if (c->band == NL80211_BAND_2GHZ)
 774                 msband = &phy->sband_2g;
 775         else if (c->band == NL80211_BAND_6GHZ)
 776                 msband = &phy->sband_6g;
 777         else
 778                 msband = &phy->sband_5g;
 779
 780         idx = c - &msband->sband.channels[0];
 781         return &msband->chan[idx];
 782 }
 783
 784 void mt76_update_survey_active_time(struct mt76_phy *phy, ktime_t time)
 785 {
 786         struct mt76_channel_state *state = phy->chan_state;
 787
 788         state->cc_active += ktime_to_us(ktime_sub(time,
 789                                                   phy->survey_time));
 790         phy->survey_time = time;
 791 }
 792 EXPORT_SYMBOL_GPL(mt76_update_survey_active_time);
 793
 794 void mt76_update_survey(struct mt76_phy *phy)
 795 {
 796         struct mt76_dev *dev = phy->dev;
 797         ktime_t cur_time;
 798
 799         if (dev->drv->update_survey)
 800                 dev->drv->update_survey(phy);
 801
 802         cur_time = ktime_get_boottime();
 803         mt76_update_survey_active_time(phy, cur_time);
 804
 805         if (dev->drv->drv_flags & MT_DRV_SW_RX_AIRTIME) {
 806                 struct mt76_channel_state *state = phy->chan_state;
 807
 808                 spin_lock_bh(&dev->cc_lock);
 809                 state->cc_bss_rx += dev->cur_cc_bss_rx;
 810                 dev->cur_cc_bss_rx = 0;
 811                 spin_unlock_bh(&dev->cc_lock);
 812         }
 813 }
 814 EXPORT_SYMBOL_GPL(mt76_update_survey);
 815
 816 void mt76_set_channel(struct mt76_phy *phy)
 817 {
 818         struct mt76_dev *dev = phy->dev;
 819         struct ieee80211_hw *hw = phy->hw;
 820         struct cfg80211_chan_def *chandef = &hw->conf.chandef;
 821         bool offchannel = hw->conf.flags & IEEE80211_CONF_OFFCHANNEL;
 822         int timeout = HZ / 5;
 823
 824         wait_event_timeout(dev->tx_wait, !mt76_has_tx_pending(phy), timeout);
 825         mt76_update_survey(phy);
 826
 827         if (phy->chandef.chan->center_freq != chandef->chan->center_freq ||
 828             phy->chandef.width != chandef->width)
 829                 phy->dfs_state = MT_DFS_STATE_UNKNOWN;
 830
 831         phy->chandef = *chandef;
 832         phy->chan_state = mt76_channel_state(phy, chandef->chan);
 833
 834         if (!offchannel)
 835                 phy->main_chan = chandef->chan;
 836
 837         if (chandef->chan != phy->main_chan)
 838                 memset(phy->chan_state, 0, sizeof(*phy->chan_state));
 839 }
 840 EXPORT_SYMBOL_GPL(mt76_set_channel);
 841
 842 int mt76_get_survey(struct ieee80211_hw *hw, int idx,
 843                     struct survey_info *survey)
 844 {
 845         struct mt76_phy *phy = hw->priv;
 846         struct mt76_dev *dev = phy->dev;
 847         struct mt76_sband *sband;
 848         struct ieee80211_channel *chan;
 849         struct mt76_channel_state *state;
 850         int ret = 0;
 851
 852         mutex_lock(&dev->mutex);
 853         if (idx == 0 && dev->drv->update_survey)
 854                 mt76_update_survey(phy);
 855
 856         if (idx >= phy->sband_2g.sband.n_channels +
 857                    phy->sband_5g.sband.n_channels) {
 858                 idx -= (phy->sband_2g.sband.n_channels +
 859                         phy->sband_5g.sband.n_channels);
 860                 sband = &phy->sband_6g;
 861         } else if (idx >= phy->sband_2g.sband.n_channels) {
 862                 idx -= phy->sband_2g.sband.n_channels;
 863                 sband = &phy->sband_5g;
 864         } else {
 865                 sband = &phy->sband_2g;
 866         }
 867
 868         if (idx >= sband->sband.n_channels) {
 869                 ret = -ENOENT;
 870                 goto out;
 871         }
 872
 873         chan = &sband->sband.channels[idx];
 874         state = mt76_channel_state(phy, chan);
 875
 876         memset(survey, 0, sizeof(*survey));
 877         survey->channel = chan;
 878         survey->filled = SURVEY_INFO_TIME | SURVEY_INFO_TIME_BUSY;
 879         survey->filled |= dev->drv->survey_flags;
 880         if (state->noise)
 881                 survey->filled |= SURVEY_INFO_NOISE_DBM;
 882
 883         if (chan == phy->main_chan) {
 884                 survey->filled |= SURVEY_INFO_IN_USE;
 885
 886                 if (dev->drv->drv_flags & MT_DRV_SW_RX_AIRTIME)
 887                         survey->filled |= SURVEY_INFO_TIME_BSS_RX;
 888         }
 889
 890         survey->time_busy = div_u64(state->cc_busy, 1000);
 891         survey->time_rx = div_u64(state->cc_rx, 1000);
 892         survey->time = div_u64(state->cc_active, 1000);
 893         survey->noise = state->noise;
 894
 895         spin_lock_bh(&dev->cc_lock);
 896         survey->time_bss_rx = div_u64(state->cc_bss_rx, 1000);
 897         survey->time_tx = div_u64(state->cc_tx, 1000);
 898         spin_unlock_bh(&dev->cc_lock);
 899
 900 out:
 901         mutex_unlock(&dev->mutex);
 902
 903         return ret;
 904 }
 905 EXPORT_SYMBOL_GPL(mt76_get_survey);
 906
 907 void mt76_wcid_key_setup(struct mt76_dev *dev, struct mt76_wcid *wcid,
 908                          struct ieee80211_key_conf *key)
 909 {
 910         struct ieee80211_key_seq seq;
 911         int i;
 912
 913         wcid->rx_check_pn = false;
 914
 915         if (!key)
 916                 return;
 917
 918         if (key->cipher != WLAN_CIPHER_SUITE_CCMP)
 919                 return;
 920
 921         wcid->rx_check_pn = true;
 922
 923         /* data frame */
 924         for (i = 0; i < IEEE80211_NUM_TIDS; i++) {
 925                 ieee80211_get_key_rx_seq(key, i, &seq);
 926                 memcpy(wcid->rx_key_pn[i], seq.ccmp.pn, sizeof(seq.ccmp.pn));
 927         }
 928
 929         /* robust management frame */
 930         ieee80211_get_key_rx_seq(key, -1, &seq);
 931         memcpy(wcid->rx_key_pn[i], seq.ccmp.pn, sizeof(seq.ccmp.pn));
 932
 933 }
 934 EXPORT_SYMBOL(mt76_wcid_key_setup);
 935
 936 static int
 937 mt76_rx_signal(struct mt76_rx_status *status)
 938 {
 939         s8 *chain_signal = status->chain_signal;
 940         int signal = -128;
 941         u8 chains;
 942
 943         for (chains = status->chains; chains; chains >>= 1, chain_signal++) {
 944                 int cur, diff;
 945
 946                 cur = *chain_signal;
 947                 if (!(chains & BIT(0)) ||
 948                     cur > 0)
 949                         continue;
 950
 951                 if (cur > signal)
 952                         swap(cur, signal);
 953
 954                 diff = signal - cur;
 955                 if (diff == 0)
 956                         signal += 3;
 957                 else if (diff <= 2)
 958                         signal += 2;
 959                 else if (diff <= 6)
 960                         signal += 1;
 961         }
 962
 963         return signal;
 964 }
 965
 966 static void
 967 mt76_rx_convert(struct mt76_dev *dev, struct sk_buff *skb,
 968                 struct ieee80211_hw **hw,
 969                 struct ieee80211_sta **sta)
 970 {
 971         struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
 972         struct ieee80211_hdr *hdr = mt76_skb_get_hdr(skb);
 973         struct mt76_rx_status mstat;
 974
 975         mstat = *((struct mt76_rx_status *)skb->cb);
 976         memset(status, 0, sizeof(*status));
 977
 978         status->flag = mstat.flag;
 979         status->freq = mstat.freq;
 980         status->enc_flags = mstat.enc_flags;
 981         status->encoding = mstat.encoding;
 982         status->bw = mstat.bw;
 983         status->he_ru = mstat.he_ru;
 984         status->he_gi = mstat.he_gi;
 985         status->he_dcm = mstat.he_dcm;
 986         status->rate_idx = mstat.rate_idx;
 987         status->nss = mstat.nss;
 988         status->band = mstat.band;
 989         status->signal = mstat.signal;
 990         status->chains = mstat.chains;
 991         status->ampdu_reference = mstat.ampdu_ref;
 992         status->device_timestamp = mstat.timestamp;
 993         status->mactime = mstat.timestamp;
 994         status->signal = mt76_rx_signal(&mstat);
 995         if (status->signal <= -128)
 996                 status->flag |= RX_FLAG_NO_SIGNAL_VAL;
 997
 998         if (ieee80211_is_beacon(hdr->frame_control) ||
 999             ieee80211_is_probe_resp(hdr->frame_control))
1000                 status->boottime_ns = ktime_get_boottime_ns();
1001
1002         BUILD_BUG_ON(sizeof(mstat) > sizeof(skb->cb));
1003         BUILD_BUG_ON(sizeof(status->chain_signal) !=
1004                      sizeof(mstat.chain_signal));
1005         memcpy(status->chain_signal, mstat.chain_signal,
1006                sizeof(mstat.chain_signal));
1007
1008         *sta = wcid_to_sta(mstat.wcid);
1009         *hw = mt76_phy_hw(dev, mstat.ext_phy);
1010 }
1011
1012 static int
1013 mt76_check_ccmp_pn(struct sk_buff *skb)
1014 {
1015         struct mt76_rx_status *status = (struct mt76_rx_status *)skb->cb;
1016         struct mt76_wcid *wcid = status->wcid;
1017         struct ieee80211_hdr *hdr;
1018         int security_idx;
1019         int ret;
1020
1021         if (!(status->flag & RX_FLAG_DECRYPTED))
1022                 return 0;
1023
1024         if (!wcid || !wcid->rx_check_pn)
1025                 return 0;
1026
1027         security_idx = status->qos_ctl & IEEE80211_QOS_CTL_TID_MASK;
1028         if (status->flag & RX_FLAG_8023)
1029                 goto skip_hdr_check;
1030
1031         hdr = mt76_skb_get_hdr(skb);
1032         if (!(status->flag & RX_FLAG_IV_STRIPPED)) {
1033                 /*
1034                  * Validate the first fragment both here and in mac80211
1035                  * All further fragments will be validated by mac80211 only.
1036                  */
1037                 if (ieee80211_is_frag(hdr) &&
1038                     !ieee80211_is_first_frag(hdr->frame_control))
1039                         return 0;
1040         }
1041
1042         /* IEEE 802.11-2020, 12.5.3.4.4 "PN and replay detection" c):
1043          *
1044          * the recipient shall maintain a single replay counter for received
1045          * individually addressed robust Management frames that are received
1046          * with the To DS subfield equal to 0, [...]
1047          */
1048         if (ieee80211_is_mgmt(hdr->frame_control) &&
1049             !ieee80211_has_tods(hdr->frame_control))
1050                 security_idx = IEEE80211_NUM_TIDS;
1051
1052 skip_hdr_check:
1053         BUILD_BUG_ON(sizeof(status->iv) != sizeof(wcid->rx_key_pn[0]));
1054         ret = memcmp(status->iv, wcid->rx_key_pn[security_idx],
1055                      sizeof(status->iv));
1056         if (ret <= 0)
1057                 return -EINVAL; /* replay */
1058
1059         memcpy(wcid->rx_key_pn[security_idx], status->iv, sizeof(status->iv));
1060
1061         if (status->flag & RX_FLAG_IV_STRIPPED)
1062                 status->flag |= RX_FLAG_PN_VALIDATED;
1063
1064         return 0;
1065 }
1066
1067 static void
1068 mt76_airtime_report(struct mt76_dev *dev, struct mt76_rx_status *status,
1069                     int len)
1070 {
1071         struct mt76_wcid *wcid = status->wcid;
1072         struct ieee80211_rx_status info = {
1073                 .enc_flags = status->enc_flags,
1074                 .rate_idx = status->rate_idx,
1075                 .encoding = status->encoding,
1076                 .band = status->band,
1077                 .nss = status->nss,
1078                 .bw = status->bw,
1079         };
1080         struct ieee80211_sta *sta;
1081         u32 airtime;
1082         u8 tidno = status->qos_ctl & IEEE80211_QOS_CTL_TID_MASK;
1083
1084         airtime = ieee80211_calc_rx_airtime(dev->hw, &info, len);
1085         spin_lock(&dev->cc_lock);
1086         dev->cur_cc_bss_rx += airtime;
1087         spin_unlock(&dev->cc_lock);
1088
1089         if (!wcid || !wcid->sta)
1090                 return;
1091
1092         sta = container_of((void *)wcid, struct ieee80211_sta, drv_priv);
1093         ieee80211_sta_register_airtime(sta, tidno, 0, airtime);
1094 }
1095
1096 static void
1097 mt76_airtime_flush_ampdu(struct mt76_dev *dev)
1098 {
1099         struct mt76_wcid *wcid;
1100         int wcid_idx;
1101
1102         if (!dev->rx_ampdu_len)
1103                 return;
1104
1105         wcid_idx = dev->rx_ampdu_status.wcid_idx;
1106         if (wcid_idx < ARRAY_SIZE(dev->wcid))
1107                 wcid = rcu_dereference(dev->wcid[wcid_idx]);
1108         else
1109                 wcid = NULL;
1110         dev->rx_ampdu_status.wcid = wcid;
1111
1112         mt76_airtime_report(dev, &dev->rx_ampdu_status, dev->rx_ampdu_len);
1113
1114         dev->rx_ampdu_len = 0;
1115         dev->rx_ampdu_ref = 0;
1116 }
1117
1118 static void
1119 mt76_airtime_check(struct mt76_dev *dev, struct sk_buff *skb)
1120 {
1121         struct mt76_rx_status *status = (struct mt76_rx_status *)skb->cb;
1122         struct mt76_wcid *wcid = status->wcid;
1123
1124         if (!(dev->drv->drv_flags & MT_DRV_SW_RX_AIRTIME))
1125                 return;
1126
1127         if (!wcid || !wcid->sta) {
1128                 struct ieee80211_hdr *hdr = mt76_skb_get_hdr(skb);
1129
1130                 if (status->flag & RX_FLAG_8023)
1131                         return;
1132
1133                 if (!ether_addr_equal(hdr->addr1, dev->phy.macaddr))
1134                         return;
1135
1136                 wcid = NULL;
1137         }
1138
1139         if (!(status->flag & RX_FLAG_AMPDU_DETAILS) ||
1140             status->ampdu_ref != dev->rx_ampdu_ref)
1141                 mt76_airtime_flush_ampdu(dev);
1142
1143         if (status->flag & RX_FLAG_AMPDU_DETAILS) {
1144                 if (!dev->rx_ampdu_len ||
1145                     status->ampdu_ref != dev->rx_ampdu_ref) {
1146                         dev->rx_ampdu_status = *status;
1147                         dev->rx_ampdu_status.wcid_idx = wcid ? wcid->idx : 0xff;
1148                         dev->rx_ampdu_ref = status->ampdu_ref;
1149                 }
1150
1151                 dev->rx_ampdu_len += skb->len;
1152                 return;
1153         }
1154
1155         mt76_airtime_report(dev, status, skb->len);
1156 }
1157
1158 static void
1159 mt76_check_sta(struct mt76_dev *dev, struct sk_buff *skb)
1160 {
1161         struct mt76_rx_status *status = (struct mt76_rx_status *)skb->cb;
1162         struct ieee80211_hdr *hdr = mt76_skb_get_hdr(skb);
1163         struct ieee80211_sta *sta;
1164         struct ieee80211_hw *hw;
1165         struct mt76_wcid *wcid = status->wcid;
1166         u8 tidno = status->qos_ctl & IEEE80211_QOS_CTL_TID_MASK;
1167         bool ps;
1168
1169         hw = mt76_phy_hw(dev, status->ext_phy);
1170         if (ieee80211_is_pspoll(hdr->frame_control) && !wcid &&
1171             !(status->flag & RX_FLAG_8023)) {
1172                 sta = ieee80211_find_sta_by_ifaddr(hw, hdr->addr2, NULL);
1173                 if (sta)
1174                         wcid = status->wcid = (struct mt76_wcid *)sta->drv_priv;
1175         }
1176
1177         mt76_airtime_check(dev, skb);
1178
1179         if (!wcid || !wcid->sta)
1180                 return;
1181
1182         sta = container_of((void *)wcid, struct ieee80211_sta, drv_priv);
1183
1184         if (status->signal <= 0)
1185                 ewma_signal_add(&wcid->rssi, -status->signal);
1186
1187         wcid->inactive_count = 0;
1188
1189         if (status->flag & RX_FLAG_8023)
1190                 return;
1191
1192         if (!test_bit(MT_WCID_FLAG_CHECK_PS, &wcid->flags))
1193                 return;
1194
1195         if (ieee80211_is_pspoll(hdr->frame_control)) {
1196                 ieee80211_sta_pspoll(sta);
1197                 return;
1198         }
1199
1200         if (ieee80211_has_morefrags(hdr->frame_control) ||
1201             !(ieee80211_is_mgmt(hdr->frame_control) ||
1202               ieee80211_is_data(hdr->frame_control)))
1203                 return;
1204
1205         ps = ieee80211_has_pm(hdr->frame_control);
1206
1207         if (ps && (ieee80211_is_data_qos(hdr->frame_control) ||
1208                    ieee80211_is_qos_nullfunc(hdr->frame_control)))
1209                 ieee80211_sta_uapsd_trigger(sta, tidno);
1210
1211         if (!!test_bit(MT_WCID_FLAG_PS, &wcid->flags) == ps)
1212                 return;
1213
1214         if (ps)
1215                 set_bit(MT_WCID_FLAG_PS, &wcid->flags);
1216
1217         dev->drv->sta_ps(dev, sta, ps);
1218
1219         if (!ps)
1220                 clear_bit(MT_WCID_FLAG_PS, &wcid->flags);
1221
1222         ieee80211_sta_ps_transition(sta, ps);
1223 }
1224
1225 void mt76_rx_complete(struct mt76_dev *dev, struct sk_buff_head *frames,
1226                       struct napi_struct *napi)
1227 {
1228         struct ieee80211_sta *sta;
1229         struct ieee80211_hw *hw;
1230         struct sk_buff *skb, *tmp;
1231         LIST_HEAD(list);
1232
1233         spin_lock(&dev->rx_lock);
1234         while ((skb = __skb_dequeue(frames)) != NULL) {
1235                 struct sk_buff *nskb = skb_shinfo(skb)->frag_list;
1236
1237                 if (mt76_check_ccmp_pn(skb)) {
1238                         dev_kfree_skb(skb);
1239                         continue;
1240                 }
1241
1242                 skb_shinfo(skb)->frag_list = NULL;
1243                 mt76_rx_convert(dev, skb, &hw, &sta);
1244                 ieee80211_rx_list(hw, sta, skb, &list);
1245
1246                 /* subsequent amsdu frames */
1247                 while (nskb) {
1248                         skb = nskb;
1249                         nskb = nskb->next;
1250                         skb->next = NULL;
1251
1252                         mt76_rx_convert(dev, skb, &hw, &sta);
1253                         ieee80211_rx_list(hw, sta, skb, &list);
1254                 }
1255         }
1256         spin_unlock(&dev->rx_lock);
1257
1258         if (!napi) {
1259                 netif_receive_skb_list(&list);
1260                 return;
1261         }
1262
1263         list_for_each_entry_safe(skb, tmp, &list, list) {
1264                 skb_list_del_init(skb);
1265                 napi_gro_receive(napi, skb);
1266         }
1267 }
1268
1269 void mt76_rx_poll_complete(struct mt76_dev *dev, enum mt76_rxq_id q,
1270                            struct napi_struct *napi)
1271 {
1272         struct sk_buff_head frames;
1273         struct sk_buff *skb;
1274
1275         __skb_queue_head_init(&frames);
1276
1277         while ((skb = __skb_dequeue(&dev->rx_skb[q])) != NULL) {
1278                 mt76_check_sta(dev, skb);
1279                 mt76_rx_aggr_reorder(skb, &frames);
1280         }
1281
1282         mt76_rx_complete(dev, &frames, napi);
1283 }
1284 EXPORT_SYMBOL_GPL(mt76_rx_poll_complete);
1285
1286 static int
1287 mt76_sta_add(struct mt76_dev *dev, struct ieee80211_vif *vif,
1288              struct ieee80211_sta *sta, bool ext_phy)
1289 {
1290         struct mt76_wcid *wcid = (struct mt76_wcid *)sta->drv_priv;
1291         int ret;
1292         int i;
1293
1294         mutex_lock(&dev->mutex);
1295
1296         ret = dev->drv->sta_add(dev, vif, sta);
1297         if (ret)
1298                 goto out;
1299
1300         for (i = 0; i < ARRAY_SIZE(sta->txq); i++) {
1301                 struct mt76_txq *mtxq;
1302
1303                 if (!sta->txq[i])
1304                         continue;
1305
1306                 mtxq = (struct mt76_txq *)sta->txq[i]->drv_priv;
1307                 mtxq->wcid = wcid->idx;
1308         }
1309
1310         ewma_signal_init(&wcid->rssi);
1311         if (ext_phy)
1312                 mt76_wcid_mask_set(dev->wcid_phy_mask, wcid->idx);
1313         wcid->ext_phy = ext_phy;
1314         rcu_assign_pointer(dev->wcid[wcid->idx], wcid);
1315
1316         mt76_packet_id_init(wcid);
1317 out:
1318         mutex_unlock(&dev->mutex);
1319
1320         return ret;
1321 }
1322
1323 void __mt76_sta_remove(struct mt76_dev *dev, struct ieee80211_vif *vif,
1324                        struct ieee80211_sta *sta)
1325 {
1326         struct mt76_wcid *wcid = (struct mt76_wcid *)sta->drv_priv;
1327         int i, idx = wcid->idx;
1328
1329         for (i = 0; i < ARRAY_SIZE(wcid->aggr); i++)
1330                 mt76_rx_aggr_stop(dev, wcid, i);
1331
1332         if (dev->drv->sta_remove)
1333                 dev->drv->sta_remove(dev, vif, sta);
1334
1335         mt76_packet_id_flush(dev, wcid);
1336
1337         mt76_wcid_mask_clear(dev->wcid_mask, idx);
1338         mt76_wcid_mask_clear(dev->wcid_phy_mask, idx);
1339 }
1340 EXPORT_SYMBOL_GPL(__mt76_sta_remove);
1341
1342 static void
1343 mt76_sta_remove(struct mt76_dev *dev, struct ieee80211_vif *vif,
1344                 struct ieee80211_sta *sta)
1345 {
1346         mutex_lock(&dev->mutex);
1347         __mt76_sta_remove(dev, vif, sta);
1348         mutex_unlock(&dev->mutex);
1349 }
1350
1351 int mt76_sta_state(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
1352                    struct ieee80211_sta *sta,
1353                    enum ieee80211_sta_state old_state,
1354                    enum ieee80211_sta_state new_state)
1355 {
1356         struct mt76_phy *phy = hw->priv;
1357         struct mt76_dev *dev = phy->dev;
1358         bool ext_phy = phy != &dev->phy;
1359
1360         if (old_state == IEEE80211_STA_NOTEXIST &&
1361             new_state == IEEE80211_STA_NONE)
1362                 return mt76_sta_add(dev, vif, sta, ext_phy);
1363
1364         if (old_state == IEEE80211_STA_AUTH &&
1365             new_state == IEEE80211_STA_ASSOC &&
1366             dev->drv->sta_assoc)
1367                 dev->drv->sta_assoc(dev, vif, sta);
1368
1369         if (old_state == IEEE80211_STA_NONE &&
1370             new_state == IEEE80211_STA_NOTEXIST)
1371                 mt76_sta_remove(dev, vif, sta);
1372
1373         return 0;
1374 }
1375 EXPORT_SYMBOL_GPL(mt76_sta_state);
1376
1377 void mt76_sta_pre_rcu_remove(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
1378                              struct ieee80211_sta *sta)
1379 {
1380         struct mt76_phy *phy = hw->priv;
1381         struct mt76_dev *dev = phy->dev;
1382         struct mt76_wcid *wcid = (struct mt76_wcid *)sta->drv_priv;
1383
1384         mutex_lock(&dev->mutex);
1385         spin_lock_bh(&dev->status_lock);
1386         rcu_assign_pointer(dev->wcid[wcid->idx], NULL);
1387         spin_unlock_bh(&dev->status_lock);
1388         mutex_unlock(&dev->mutex);
1389 }
1390 EXPORT_SYMBOL_GPL(mt76_sta_pre_rcu_remove);
1391
1392 int mt76_get_txpower(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
1393                      int *dbm)
1394 {
1395         struct mt76_phy *phy = hw->priv;
1396         int n_chains = hweight8(phy->antenna_mask);
1397         int delta = mt76_tx_power_nss_delta(n_chains);
1398
1399         *dbm = DIV_ROUND_UP(phy->txpower_cur + delta, 2);
1400
1401         return 0;
1402 }
1403 EXPORT_SYMBOL_GPL(mt76_get_txpower);
1404
1405 int mt76_init_sar_power(struct ieee80211_hw *hw,
1406                         const struct cfg80211_sar_specs *sar)
1407 {
1408         struct mt76_phy *phy = hw->priv;
1409         const struct cfg80211_sar_capa *capa = hw->wiphy->sar_capa;
1410         int i;
1411
1412         if (sar->type != NL80211_SAR_TYPE_POWER || !sar->num_sub_specs)
1413                 return -EINVAL;
1414
1415         for (i = 0; i < sar->num_sub_specs; i++) {
1416                 u32 index = sar->sub_specs[i].freq_range_index;
1417                 /* SAR specifies power limitaton in 0.25dbm */
1418                 s32 power = sar->sub_specs[i].power >> 1;
1419
1420                 if (power > 127 || power < -127)
1421                         power = 127;
1422
1423                 phy->frp[index].range = &capa->freq_ranges[index];
1424                 phy->frp[index].power = power;
1425         }
1426
1427         return 0;
1428 }
1429 EXPORT_SYMBOL_GPL(mt76_init_sar_power);
1430
1431 int mt76_get_sar_power(struct mt76_phy *phy,
1432                        struct ieee80211_channel *chan,
1433                        int power)
1434 {
1435         const struct cfg80211_sar_capa *capa = phy->hw->wiphy->sar_capa;
1436         int freq, i;
1437
1438         if (!capa || !phy->frp)
1439                 return power;
1440
1441         if (power > 127 || power < -127)
1442                 power = 127;
1443
1444         freq = ieee80211_channel_to_frequency(chan->hw_value, chan->band);
1445         for (i = 0 ; i < capa->num_freq_ranges; i++) {
1446                 if (phy->frp[i].range &&
1447                     freq >= phy->frp[i].range->start_freq &&
1448                     freq < phy->frp[i].range->end_freq) {
1449                         power = min_t(int, phy->frp[i].power, power);
1450                         break;
1451                 }
1452         }
1453
1454         return power;
1455 }
1456 EXPORT_SYMBOL_GPL(mt76_get_sar_power);
1457
1458 static void
1459 __mt76_csa_finish(void *priv, u8 *mac, struct ieee80211_vif *vif)
1460 {
1461         if (vif->csa_active && ieee80211_beacon_cntdwn_is_complete(vif))
1462                 ieee80211_csa_finish(vif);
1463 }
1464
1465 void mt76_csa_finish(struct mt76_dev *dev)
1466 {
1467         if (!dev->csa_complete)
1468                 return;
1469
1470         ieee80211_iterate_active_interfaces_atomic(dev->hw,
1471                 IEEE80211_IFACE_ITER_RESUME_ALL,
1472                 __mt76_csa_finish, dev);
1473
1474         dev->csa_complete = 0;
1475 }
1476 EXPORT_SYMBOL_GPL(mt76_csa_finish);
1477
1478 static void
1479 __mt76_csa_check(void *priv, u8 *mac, struct ieee80211_vif *vif)
1480 {
1481         struct mt76_dev *dev = priv;
1482
1483         if (!vif->csa_active)
1484                 return;
1485
1486         dev->csa_complete |= ieee80211_beacon_cntdwn_is_complete(vif);
1487 }
1488
1489 void mt76_csa_check(struct mt76_dev *dev)
1490 {
1491         ieee80211_iterate_active_interfaces_atomic(dev->hw,
1492                 IEEE80211_IFACE_ITER_RESUME_ALL,
1493                 __mt76_csa_check, dev);
1494 }
1495 EXPORT_SYMBOL_GPL(mt76_csa_check);
1496
1497 int
1498 mt76_set_tim(struct ieee80211_hw *hw, struct ieee80211_sta *sta, bool set)
1499 {
1500         return 0;
1501 }
1502 EXPORT_SYMBOL_GPL(mt76_set_tim);
1503
1504 void mt76_insert_ccmp_hdr(struct sk_buff *skb, u8 key_id)
1505 {
1506         struct mt76_rx_status *status = (struct mt76_rx_status *)skb->cb;
1507         int hdr_len = ieee80211_get_hdrlen_from_skb(skb);
1508         u8 *hdr, *pn = status->iv;
1509
1510         __skb_push(skb, 8);
1511         memmove(skb->data, skb->data + 8, hdr_len);
1512         hdr = skb->data + hdr_len;
1513
1514         hdr[0] = pn[5];
1515         hdr[1] = pn[4];
1516         hdr[2] = 0;
1517         hdr[3] = 0x20 | (key_id << 6);
1518         hdr[4] = pn[3];
1519         hdr[5] = pn[2];
1520         hdr[6] = pn[1];
1521         hdr[7] = pn[0];
1522
1523         status->flag &= ~RX_FLAG_IV_STRIPPED;
1524 }
1525 EXPORT_SYMBOL_GPL(mt76_insert_ccmp_hdr);
1526
1527 int mt76_get_rate(struct mt76_dev *dev,
1528                   struct ieee80211_supported_band *sband,
1529                   int idx, bool cck)
1530 {
1531         int i, offset = 0, len = sband->n_bitrates;
1532
1533         if (cck) {
1534                 if (sband != &dev->phy.sband_2g.sband)
1535                         return 0;
1536
1537                 idx &= ~BIT(2); /* short preamble */
1538         } else if (sband == &dev->phy.sband_2g.sband) {
1539                 offset = 4;
1540         }
1541
1542         for (i = offset; i < len; i++) {
1543                 if ((sband->bitrates[i].hw_value & GENMASK(7, 0)) == idx)
1544                         return i;
1545         }
1546
1547         return 0;
1548 }
1549 EXPORT_SYMBOL_GPL(mt76_get_rate);
1550
1551 void mt76_sw_scan(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
1552                   const u8 *mac)
1553 {
1554         struct mt76_phy *phy = hw->priv;
1555
1556         set_bit(MT76_SCANNING, &phy->state);
1557 }
1558 EXPORT_SYMBOL_GPL(mt76_sw_scan);
1559
1560 void mt76_sw_scan_complete(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
1561 {
1562         struct mt76_phy *phy = hw->priv;
1563
1564         clear_bit(MT76_SCANNING, &phy->state);
1565 }
1566 EXPORT_SYMBOL_GPL(mt76_sw_scan_complete);
1567
1568 int mt76_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant)
1569 {
1570         struct mt76_phy *phy = hw->priv;
1571         struct mt76_dev *dev = phy->dev;
1572
1573         mutex_lock(&dev->mutex);
1574         *tx_ant = phy->antenna_mask;
1575         *rx_ant = phy->antenna_mask;
1576         mutex_unlock(&dev->mutex);
1577
1578         return 0;
1579 }
1580 EXPORT_SYMBOL_GPL(mt76_get_antenna);
1581
1582 struct mt76_queue *
1583 mt76_init_queue(struct mt76_dev *dev, int qid, int idx, int n_desc,
1584                 int ring_base)
1585 {
1586         struct mt76_queue *hwq;
1587         int err;
1588
1589         hwq = devm_kzalloc(dev->dev, sizeof(*hwq), GFP_KERNEL);
1590         if (!hwq)
1591                 return ERR_PTR(-ENOMEM);
1592
1593         err = dev->queue_ops->alloc(dev, hwq, idx, n_desc, 0, ring_base);
1594         if (err < 0)
1595                 return ERR_PTR(err);
1596
1597         return hwq;
1598 }
1599 EXPORT_SYMBOL_GPL(mt76_init_queue);
1600
1601 u16 mt76_calculate_default_rate(struct mt76_phy *phy, int rateidx)
1602 {
1603         int offset = 0;
1604
1605         if (phy->chandef.chan->band != NL80211_BAND_2GHZ)
1606                 offset = 4;
1607
1608         /* pick the lowest rate for hidden nodes */
1609         if (rateidx < 0)
1610                 rateidx = 0;
1611
1612         rateidx += offset;
1613         if (rateidx >= ARRAY_SIZE(mt76_rates))
1614                 rateidx = offset;
1615
1616         return mt76_rates[rateidx].hw_value;
1617 }
1618 EXPORT_SYMBOL_GPL(mt76_calculate_default_rate);
1619
1620 void mt76_ethtool_worker(struct mt76_ethtool_worker_info *wi,
1621                          struct mt76_sta_stats *stats)
1622 {
1623         int i, ei = wi->initial_stat_idx;
1624         u64 *data = wi->data;
1625
1626         wi->sta_count++;
1627
1628         data[ei++] += stats->tx_mode[MT_PHY_TYPE_CCK];
1629         data[ei++] += stats->tx_mode[MT_PHY_TYPE_OFDM];
1630         data[ei++] += stats->tx_mode[MT_PHY_TYPE_HT];
1631         data[ei++] += stats->tx_mode[MT_PHY_TYPE_HT_GF];
1632         data[ei++] += stats->tx_mode[MT_PHY_TYPE_VHT];
1633         data[ei++] += stats->tx_mode[MT_PHY_TYPE_HE_SU];
1634         data[ei++] += stats->tx_mode[MT_PHY_TYPE_HE_EXT_SU];
1635         data[ei++] += stats->tx_mode[MT_PHY_TYPE_HE_TB];
1636         data[ei++] += stats->tx_mode[MT_PHY_TYPE_HE_MU];
1637
1638         for (i = 0; i < ARRAY_SIZE(stats->tx_bw); i++)
1639                 data[ei++] += stats->tx_bw[i];
1640
1641         for (i = 0; i < 12; i++)
1642                 data[ei++] += stats->tx_mcs[i];
1643
1644         wi->worker_stat_count = ei - wi->initial_stat_idx;
1645 }
1646 EXPORT_SYMBOL_GPL(mt76_ethtool_worker);
1647
1648 enum mt76_dfs_state mt76_phy_dfs_state(struct mt76_phy *phy)
1649 {
1650         struct ieee80211_hw *hw = phy->hw;
1651         struct mt76_dev *dev = phy->dev;
1652
1653         if (dev->region == NL80211_DFS_UNSET ||
1654             test_bit(MT76_SCANNING, &phy->state))
1655                 return MT_DFS_STATE_DISABLED;
1656
1657         if (!hw->conf.radar_enabled) {
1658                 if ((hw->conf.flags & IEEE80211_CONF_MONITOR) &&
1659                     (phy->chandef.chan->flags & IEEE80211_CHAN_RADAR))
1660                         return MT_DFS_STATE_ACTIVE;
1661
1662                 return MT_DFS_STATE_DISABLED;
1663         }
1664
1665         if (!cfg80211_reg_can_beacon(hw->wiphy, &phy->chandef, NL80211_IFTYPE_AP))
1666                 return MT_DFS_STATE_CAC;
1667
1668         return MT_DFS_STATE_ACTIVE;
1669 }
1670 EXPORT_SYMBOL_GPL(mt76_phy_dfs_state);