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 CHAN5G(177, 5885), 79 }; 80 81 static const struct ieee80211_channel mt76_channels_6ghz[] = { 82 /* UNII-5 */ 83 CHAN6G(1, 5955), 84 CHAN6G(5, 5975), 85 CHAN6G(9, 5995), 86 CHAN6G(13, 6015), 87 CHAN6G(17, 6035), 88 CHAN6G(21, 6055), 89 CHAN6G(25, 6075), 90 CHAN6G(29, 6095), 91 CHAN6G(33, 6115), 92 CHAN6G(37, 6135), 93 CHAN6G(41, 6155), 94 CHAN6G(45, 6175), 95 CHAN6G(49, 6195), 96 CHAN6G(53, 6215), 97 CHAN6G(57, 6235), 98 CHAN6G(61, 6255), 99 CHAN6G(65, 6275), 100 CHAN6G(69, 6295), 101 CHAN6G(73, 6315), 102 CHAN6G(77, 6335), 103 CHAN6G(81, 6355), 104 CHAN6G(85, 6375), 105 CHAN6G(89, 6395), 106 CHAN6G(93, 6415), 107 /* UNII-6 */ 108 CHAN6G(97, 6435), 109 CHAN6G(101, 6455), 110 CHAN6G(105, 6475), 111 CHAN6G(109, 6495), 112 CHAN6G(113, 6515), 113 CHAN6G(117, 6535), 114 /* UNII-7 */ 115 CHAN6G(121, 6555), 116 CHAN6G(125, 6575), 117 CHAN6G(129, 6595), 118 CHAN6G(133, 6615), 119 CHAN6G(137, 6635), 120 CHAN6G(141, 6655), 121 CHAN6G(145, 6675), 122 CHAN6G(149, 6695), 123 CHAN6G(153, 6715), 124 CHAN6G(157, 6735), 125 CHAN6G(161, 6755), 126 CHAN6G(165, 6775), 127 CHAN6G(169, 6795), 128 CHAN6G(173, 6815), 129 CHAN6G(177, 6835), 130 CHAN6G(181, 6855), 131 CHAN6G(185, 6875), 132 /* UNII-8 */ 133 CHAN6G(189, 6895), 134 CHAN6G(193, 6915), 135 CHAN6G(197, 6935), 136 CHAN6G(201, 6955), 137 CHAN6G(205, 6975), 138 CHAN6G(209, 6995), 139 CHAN6G(213, 7015), 140 CHAN6G(217, 7035), 141 CHAN6G(221, 7055), 142 CHAN6G(225, 7075), 143 CHAN6G(229, 7095), 144 CHAN6G(233, 7115), 145 }; 146 147 static const struct ieee80211_tpt_blink mt76_tpt_blink[] = { 148 { .throughput = 0 * 1024, .blink_time = 334 }, 149 { .throughput = 1 * 1024, .blink_time = 260 }, 150 { .throughput = 5 * 1024, .blink_time = 220 }, 151 { .throughput = 10 * 1024, .blink_time = 190 }, 152 { .throughput = 20 * 1024, .blink_time = 170 }, 153 { .throughput = 50 * 1024, .blink_time = 150 }, 154 { .throughput = 70 * 1024, .blink_time = 130 }, 155 { .throughput = 100 * 1024, .blink_time = 110 }, 156 { .throughput = 200 * 1024, .blink_time = 80 }, 157 { .throughput = 300 * 1024, .blink_time = 50 }, 158 }; 159 160 struct ieee80211_rate mt76_rates[] = { 161 CCK_RATE(0, 10), 162 CCK_RATE(1, 20), 163 CCK_RATE(2, 55), 164 CCK_RATE(3, 110), 165 OFDM_RATE(11, 60), 166 OFDM_RATE(15, 90), 167 OFDM_RATE(10, 120), 168 OFDM_RATE(14, 180), 169 OFDM_RATE(9, 240), 170 OFDM_RATE(13, 360), 171 OFDM_RATE(8, 480), 172 OFDM_RATE(12, 540), 173 }; 174 EXPORT_SYMBOL_GPL(mt76_rates); 175 176 static const struct cfg80211_sar_freq_ranges mt76_sar_freq_ranges[] = { 177 { .start_freq = 2402, .end_freq = 2494, }, 178 { .start_freq = 5150, .end_freq = 5350, }, 179 { .start_freq = 5350, .end_freq = 5470, }, 180 { .start_freq = 5470, .end_freq = 5725, }, 181 { .start_freq = 5725, .end_freq = 5950, }, 182 { .start_freq = 5945, .end_freq = 6165, }, 183 { .start_freq = 6165, .end_freq = 6405, }, 184 { .start_freq = 6405, .end_freq = 6525, }, 185 { .start_freq = 6525, .end_freq = 6705, }, 186 { .start_freq = 6705, .end_freq = 6865, }, 187 { .start_freq = 6865, .end_freq = 7125, }, 188 }; 189 190 static const struct cfg80211_sar_capa mt76_sar_capa = { 191 .type = NL80211_SAR_TYPE_POWER, 192 .num_freq_ranges = ARRAY_SIZE(mt76_sar_freq_ranges), 193 .freq_ranges = &mt76_sar_freq_ranges[0], 194 }; 195 196 static int mt76_led_init(struct mt76_phy *phy) 197 { 198 struct mt76_dev *dev = phy->dev; 199 struct ieee80211_hw *hw = phy->hw; 200 struct device_node *np = dev->dev->of_node; 201 202 if (!phy->leds.cdev.brightness_set && !phy->leds.cdev.blink_set) 203 return 0; 204 205 np = of_get_child_by_name(np, "led"); 206 if (np) { 207 if (!of_device_is_available(np)) { 208 of_node_put(np); 209 dev_info(dev->dev, 210 "led registration was explicitly disabled by dts\n"); 211 return 0; 212 } 213 214 if (phy == &dev->phy) { 215 int led_pin; 216 217 if (!of_property_read_u32(np, "led-sources", &led_pin)) 218 phy->leds.pin = led_pin; 219 220 phy->leds.al = 221 of_property_read_bool(np, "led-active-low"); 222 } 223 224 of_node_put(np); 225 } 226 227 snprintf(phy->leds.name, sizeof(phy->leds.name), "mt76-%s", 228 wiphy_name(hw->wiphy)); 229 230 phy->leds.cdev.name = phy->leds.name; 231 phy->leds.cdev.default_trigger = 232 ieee80211_create_tpt_led_trigger(hw, 233 IEEE80211_TPT_LEDTRIG_FL_RADIO, 234 mt76_tpt_blink, 235 ARRAY_SIZE(mt76_tpt_blink)); 236 237 dev_info(dev->dev, 238 "registering led '%s'\n", phy->leds.name); 239 240 return led_classdev_register(dev->dev, &phy->leds.cdev); 241 } 242 243 static void mt76_led_cleanup(struct mt76_phy *phy) 244 { 245 if (!phy->leds.cdev.brightness_set && !phy->leds.cdev.blink_set) 246 return; 247 248 led_classdev_unregister(&phy->leds.cdev); 249 } 250 251 static void mt76_init_stream_cap(struct mt76_phy *phy, 252 struct ieee80211_supported_band *sband, 253 bool vht) 254 { 255 struct ieee80211_sta_ht_cap *ht_cap = &sband->ht_cap; 256 int i, nstream = hweight8(phy->antenna_mask); 257 struct ieee80211_sta_vht_cap *vht_cap; 258 u16 mcs_map = 0; 259 260 if (nstream > 1) 261 ht_cap->cap |= IEEE80211_HT_CAP_TX_STBC; 262 else 263 ht_cap->cap &= ~IEEE80211_HT_CAP_TX_STBC; 264 265 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) 266 ht_cap->mcs.rx_mask[i] = i < nstream ? 0xff : 0; 267 268 if (!vht) 269 return; 270 271 vht_cap = &sband->vht_cap; 272 if (nstream > 1) 273 vht_cap->cap |= IEEE80211_VHT_CAP_TXSTBC; 274 else 275 vht_cap->cap &= ~IEEE80211_VHT_CAP_TXSTBC; 276 vht_cap->cap |= IEEE80211_VHT_CAP_TX_ANTENNA_PATTERN | 277 IEEE80211_VHT_CAP_RX_ANTENNA_PATTERN; 278 279 for (i = 0; i < 8; i++) { 280 if (i < nstream) 281 mcs_map |= (IEEE80211_VHT_MCS_SUPPORT_0_9 << (i * 2)); 282 else 283 mcs_map |= 284 (IEEE80211_VHT_MCS_NOT_SUPPORTED << (i * 2)); 285 } 286 vht_cap->vht_mcs.rx_mcs_map = cpu_to_le16(mcs_map); 287 vht_cap->vht_mcs.tx_mcs_map = cpu_to_le16(mcs_map); 288 if (ieee80211_hw_check(phy->hw, SUPPORTS_VHT_EXT_NSS_BW)) 289 vht_cap->vht_mcs.tx_highest |= 290 cpu_to_le16(IEEE80211_VHT_EXT_NSS_BW_CAPABLE); 291 } 292 293 void mt76_set_stream_caps(struct mt76_phy *phy, bool vht) 294 { 295 if (phy->cap.has_2ghz) 296 mt76_init_stream_cap(phy, &phy->sband_2g.sband, false); 297 if (phy->cap.has_5ghz) 298 mt76_init_stream_cap(phy, &phy->sband_5g.sband, vht); 299 if (phy->cap.has_6ghz) 300 mt76_init_stream_cap(phy, &phy->sband_6g.sband, vht); 301 } 302 EXPORT_SYMBOL_GPL(mt76_set_stream_caps); 303 304 static int 305 mt76_init_sband(struct mt76_phy *phy, struct mt76_sband *msband, 306 const struct ieee80211_channel *chan, int n_chan, 307 struct ieee80211_rate *rates, int n_rates, 308 bool ht, bool vht) 309 { 310 struct ieee80211_supported_band *sband = &msband->sband; 311 struct ieee80211_sta_vht_cap *vht_cap; 312 struct ieee80211_sta_ht_cap *ht_cap; 313 struct mt76_dev *dev = phy->dev; 314 void *chanlist; 315 int size; 316 317 size = n_chan * sizeof(*chan); 318 chanlist = devm_kmemdup(dev->dev, chan, size, GFP_KERNEL); 319 if (!chanlist) 320 return -ENOMEM; 321 322 msband->chan = devm_kcalloc(dev->dev, n_chan, sizeof(*msband->chan), 323 GFP_KERNEL); 324 if (!msband->chan) 325 return -ENOMEM; 326 327 sband->channels = chanlist; 328 sband->n_channels = n_chan; 329 sband->bitrates = rates; 330 sband->n_bitrates = n_rates; 331 332 if (!ht) 333 return 0; 334 335 ht_cap = &sband->ht_cap; 336 ht_cap->ht_supported = true; 337 ht_cap->cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40 | 338 IEEE80211_HT_CAP_GRN_FLD | 339 IEEE80211_HT_CAP_SGI_20 | 340 IEEE80211_HT_CAP_SGI_40 | 341 (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT); 342 343 ht_cap->mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED; 344 ht_cap->ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K; 345 346 mt76_init_stream_cap(phy, sband, vht); 347 348 if (!vht) 349 return 0; 350 351 vht_cap = &sband->vht_cap; 352 vht_cap->vht_supported = true; 353 vht_cap->cap |= IEEE80211_VHT_CAP_RXLDPC | 354 IEEE80211_VHT_CAP_RXSTBC_1 | 355 IEEE80211_VHT_CAP_SHORT_GI_80 | 356 (3 << IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT); 357 358 return 0; 359 } 360 361 static int 362 mt76_init_sband_2g(struct mt76_phy *phy, struct ieee80211_rate *rates, 363 int n_rates) 364 { 365 phy->hw->wiphy->bands[NL80211_BAND_2GHZ] = &phy->sband_2g.sband; 366 367 return mt76_init_sband(phy, &phy->sband_2g, mt76_channels_2ghz, 368 ARRAY_SIZE(mt76_channels_2ghz), rates, 369 n_rates, true, false); 370 } 371 372 static int 373 mt76_init_sband_5g(struct mt76_phy *phy, struct ieee80211_rate *rates, 374 int n_rates, bool vht) 375 { 376 phy->hw->wiphy->bands[NL80211_BAND_5GHZ] = &phy->sband_5g.sband; 377 378 return mt76_init_sband(phy, &phy->sband_5g, mt76_channels_5ghz, 379 ARRAY_SIZE(mt76_channels_5ghz), rates, 380 n_rates, true, vht); 381 } 382 383 static int 384 mt76_init_sband_6g(struct mt76_phy *phy, struct ieee80211_rate *rates, 385 int n_rates) 386 { 387 phy->hw->wiphy->bands[NL80211_BAND_6GHZ] = &phy->sband_6g.sband; 388 389 return mt76_init_sband(phy, &phy->sband_6g, mt76_channels_6ghz, 390 ARRAY_SIZE(mt76_channels_6ghz), rates, 391 n_rates, false, false); 392 } 393 394 static void 395 mt76_check_sband(struct mt76_phy *phy, struct mt76_sband *msband, 396 enum nl80211_band band) 397 { 398 struct ieee80211_supported_band *sband = &msband->sband; 399 bool found = false; 400 int i; 401 402 if (!sband) 403 return; 404 405 for (i = 0; i < sband->n_channels; i++) { 406 if (sband->channels[i].flags & IEEE80211_CHAN_DISABLED) 407 continue; 408 409 found = true; 410 break; 411 } 412 413 if (found) { 414 cfg80211_chandef_create(&phy->chandef, &sband->channels[0], 415 NL80211_CHAN_HT20); 416 phy->chan_state = &msband->chan[0]; 417 phy->dev->band_phys[band] = phy; 418 return; 419 } 420 421 sband->n_channels = 0; 422 if (phy->hw->wiphy->bands[band] == sband) 423 phy->hw->wiphy->bands[band] = NULL; 424 } 425 426 static int 427 mt76_phy_init(struct mt76_phy *phy, struct ieee80211_hw *hw) 428 { 429 struct mt76_dev *dev = phy->dev; 430 struct wiphy *wiphy = hw->wiphy; 431 432 INIT_LIST_HEAD(&phy->tx_list); 433 spin_lock_init(&phy->tx_lock); 434 INIT_DELAYED_WORK(&phy->roc_work, mt76_roc_complete_work); 435 436 if ((void *)phy != hw->priv) 437 return 0; 438 439 SET_IEEE80211_DEV(hw, dev->dev); 440 SET_IEEE80211_PERM_ADDR(hw, phy->macaddr); 441 442 wiphy->features |= NL80211_FEATURE_ACTIVE_MONITOR | 443 NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE; 444 wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH | 445 WIPHY_FLAG_SUPPORTS_TDLS | 446 WIPHY_FLAG_AP_UAPSD; 447 448 wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_CQM_RSSI_LIST); 449 wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_AIRTIME_FAIRNESS); 450 wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_AQL); 451 452 wiphy->available_antennas_tx = phy->antenna_mask; 453 wiphy->available_antennas_rx = phy->antenna_mask; 454 455 wiphy->sar_capa = &mt76_sar_capa; 456 phy->frp = devm_kcalloc(dev->dev, wiphy->sar_capa->num_freq_ranges, 457 sizeof(struct mt76_freq_range_power), 458 GFP_KERNEL); 459 if (!phy->frp) 460 return -ENOMEM; 461 462 hw->txq_data_size = sizeof(struct mt76_txq); 463 hw->uapsd_max_sp_len = IEEE80211_WMM_IE_STA_QOSINFO_SP_ALL; 464 465 if (!hw->max_tx_fragments) 466 hw->max_tx_fragments = 16; 467 468 ieee80211_hw_set(hw, SIGNAL_DBM); 469 ieee80211_hw_set(hw, AMPDU_AGGREGATION); 470 ieee80211_hw_set(hw, SUPPORTS_RC_TABLE); 471 ieee80211_hw_set(hw, SUPPORT_FAST_XMIT); 472 ieee80211_hw_set(hw, SUPPORTS_CLONED_SKBS); 473 ieee80211_hw_set(hw, SUPPORTS_AMSDU_IN_AMPDU); 474 ieee80211_hw_set(hw, SUPPORTS_REORDERING_BUFFER); 475 ieee80211_hw_set(hw, SPECTRUM_MGMT); 476 477 if (!(dev->drv->drv_flags & MT_DRV_AMSDU_OFFLOAD) && 478 hw->max_tx_fragments > 1) { 479 ieee80211_hw_set(hw, TX_AMSDU); 480 ieee80211_hw_set(hw, TX_FRAG_LIST); 481 } 482 483 ieee80211_hw_set(hw, MFP_CAPABLE); 484 ieee80211_hw_set(hw, AP_LINK_PS); 485 ieee80211_hw_set(hw, REPORTS_TX_ACK_STATUS); 486 487 return 0; 488 } 489 490 struct mt76_phy * 491 mt76_alloc_radio_phy(struct mt76_dev *dev, unsigned int size, 492 u8 band_idx) 493 { 494 struct ieee80211_hw *hw = dev->phy.hw; 495 unsigned int phy_size; 496 struct mt76_phy *phy; 497 498 phy_size = ALIGN(sizeof(*phy), 8); 499 phy = devm_kzalloc(dev->dev, size + phy_size, GFP_KERNEL); 500 if (!phy) 501 return NULL; 502 503 phy->dev = dev; 504 phy->hw = hw; 505 phy->priv = (void *)phy + phy_size; 506 phy->band_idx = band_idx; 507 508 return phy; 509 } 510 EXPORT_SYMBOL_GPL(mt76_alloc_radio_phy); 511 512 struct mt76_phy * 513 mt76_alloc_phy(struct mt76_dev *dev, unsigned int size, 514 const struct ieee80211_ops *ops, u8 band_idx) 515 { 516 struct ieee80211_hw *hw; 517 unsigned int phy_size; 518 struct mt76_phy *phy; 519 520 phy_size = ALIGN(sizeof(*phy), 8); 521 hw = ieee80211_alloc_hw(size + phy_size, ops); 522 if (!hw) 523 return NULL; 524 525 phy = hw->priv; 526 phy->dev = dev; 527 phy->hw = hw; 528 phy->priv = hw->priv + phy_size; 529 phy->band_idx = band_idx; 530 531 hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN; 532 hw->wiphy->interface_modes = 533 BIT(NL80211_IFTYPE_STATION) | 534 BIT(NL80211_IFTYPE_AP) | 535 #ifdef CONFIG_MAC80211_MESH 536 BIT(NL80211_IFTYPE_MESH_POINT) | 537 #endif 538 BIT(NL80211_IFTYPE_P2P_CLIENT) | 539 BIT(NL80211_IFTYPE_P2P_GO) | 540 BIT(NL80211_IFTYPE_ADHOC); 541 542 return phy; 543 } 544 EXPORT_SYMBOL_GPL(mt76_alloc_phy); 545 546 int mt76_register_phy(struct mt76_phy *phy, bool vht, 547 struct ieee80211_rate *rates, int n_rates) 548 { 549 int ret; 550 551 ret = mt76_phy_init(phy, phy->hw); 552 if (ret) 553 return ret; 554 555 if (phy->cap.has_2ghz) { 556 ret = mt76_init_sband_2g(phy, rates, n_rates); 557 if (ret) 558 return ret; 559 } 560 561 if (phy->cap.has_5ghz) { 562 ret = mt76_init_sband_5g(phy, rates + 4, n_rates - 4, vht); 563 if (ret) 564 return ret; 565 } 566 567 if (phy->cap.has_6ghz) { 568 ret = mt76_init_sband_6g(phy, rates + 4, n_rates - 4); 569 if (ret) 570 return ret; 571 } 572 573 if (IS_ENABLED(CONFIG_MT76_LEDS)) { 574 ret = mt76_led_init(phy); 575 if (ret) 576 return ret; 577 } 578 579 wiphy_read_of_freq_limits(phy->hw->wiphy); 580 mt76_check_sband(phy, &phy->sband_2g, NL80211_BAND_2GHZ); 581 mt76_check_sband(phy, &phy->sband_5g, NL80211_BAND_5GHZ); 582 mt76_check_sband(phy, &phy->sband_6g, NL80211_BAND_6GHZ); 583 584 if ((void *)phy == phy->hw->priv) { 585 ret = ieee80211_register_hw(phy->hw); 586 if (ret) 587 return ret; 588 } 589 590 set_bit(MT76_STATE_REGISTERED, &phy->state); 591 phy->dev->phys[phy->band_idx] = phy; 592 593 return 0; 594 } 595 EXPORT_SYMBOL_GPL(mt76_register_phy); 596 597 void mt76_unregister_phy(struct mt76_phy *phy) 598 { 599 struct mt76_dev *dev = phy->dev; 600 601 if (!test_bit(MT76_STATE_REGISTERED, &phy->state)) 602 return; 603 604 if (IS_ENABLED(CONFIG_MT76_LEDS)) 605 mt76_led_cleanup(phy); 606 mt76_tx_status_check(dev, true); 607 ieee80211_unregister_hw(phy->hw); 608 dev->phys[phy->band_idx] = NULL; 609 } 610 EXPORT_SYMBOL_GPL(mt76_unregister_phy); 611 612 int mt76_create_page_pool(struct mt76_dev *dev, struct mt76_queue *q) 613 { 614 bool is_qrx = mt76_queue_is_rx(dev, q); 615 struct page_pool_params pp_params = { 616 .order = 0, 617 .flags = 0, 618 .nid = NUMA_NO_NODE, 619 .dev = dev->dma_dev, 620 }; 621 int idx = is_qrx ? q - dev->q_rx : -1; 622 623 /* Allocate page_pools just for rx/wed_tx_free queues */ 624 if (!is_qrx && !mt76_queue_is_wed_tx_free(q)) 625 return 0; 626 627 switch (idx) { 628 case MT_RXQ_MAIN: 629 case MT_RXQ_BAND1: 630 case MT_RXQ_BAND2: 631 pp_params.pool_size = 256; 632 break; 633 default: 634 pp_params.pool_size = 16; 635 break; 636 } 637 638 if (mt76_is_mmio(dev)) { 639 /* rely on page_pool for DMA mapping */ 640 pp_params.flags |= PP_FLAG_DMA_MAP | PP_FLAG_DMA_SYNC_DEV; 641 pp_params.dma_dir = DMA_FROM_DEVICE; 642 pp_params.max_len = PAGE_SIZE; 643 pp_params.offset = 0; 644 /* NAPI is available just for rx queues */ 645 if (idx >= 0 && idx < ARRAY_SIZE(dev->napi)) 646 pp_params.napi = &dev->napi[idx]; 647 } 648 649 q->page_pool = page_pool_create(&pp_params); 650 if (IS_ERR(q->page_pool)) { 651 int err = PTR_ERR(q->page_pool); 652 653 q->page_pool = NULL; 654 return err; 655 } 656 657 return 0; 658 } 659 EXPORT_SYMBOL_GPL(mt76_create_page_pool); 660 661 struct mt76_dev * 662 mt76_alloc_device(struct device *pdev, unsigned int size, 663 const struct ieee80211_ops *ops, 664 const struct mt76_driver_ops *drv_ops) 665 { 666 struct ieee80211_hw *hw; 667 struct mt76_phy *phy; 668 struct mt76_dev *dev; 669 int i; 670 671 hw = ieee80211_alloc_hw(size, ops); 672 if (!hw) 673 return NULL; 674 675 dev = hw->priv; 676 dev->hw = hw; 677 dev->dev = pdev; 678 dev->drv = drv_ops; 679 dev->dma_dev = pdev; 680 681 phy = &dev->phy; 682 phy->dev = dev; 683 phy->hw = hw; 684 phy->band_idx = MT_BAND0; 685 dev->phys[phy->band_idx] = phy; 686 687 spin_lock_init(&dev->rx_lock); 688 spin_lock_init(&dev->lock); 689 spin_lock_init(&dev->cc_lock); 690 spin_lock_init(&dev->status_lock); 691 spin_lock_init(&dev->wed_lock); 692 mutex_init(&dev->mutex); 693 init_waitqueue_head(&dev->tx_wait); 694 695 skb_queue_head_init(&dev->mcu.res_q); 696 init_waitqueue_head(&dev->mcu.wait); 697 mutex_init(&dev->mcu.mutex); 698 dev->tx_worker.fn = mt76_tx_worker; 699 700 hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN; 701 hw->wiphy->interface_modes = 702 BIT(NL80211_IFTYPE_STATION) | 703 BIT(NL80211_IFTYPE_AP) | 704 #ifdef CONFIG_MAC80211_MESH 705 BIT(NL80211_IFTYPE_MESH_POINT) | 706 #endif 707 BIT(NL80211_IFTYPE_P2P_CLIENT) | 708 BIT(NL80211_IFTYPE_P2P_GO) | 709 BIT(NL80211_IFTYPE_ADHOC); 710 711 spin_lock_init(&dev->token_lock); 712 idr_init(&dev->token); 713 714 spin_lock_init(&dev->rx_token_lock); 715 idr_init(&dev->rx_token); 716 717 INIT_LIST_HEAD(&dev->wcid_list); 718 INIT_LIST_HEAD(&dev->sta_poll_list); 719 spin_lock_init(&dev->sta_poll_lock); 720 721 INIT_LIST_HEAD(&dev->txwi_cache); 722 INIT_LIST_HEAD(&dev->rxwi_cache); 723 dev->token_size = dev->drv->token_size; 724 INIT_DELAYED_WORK(&dev->scan_work, mt76_scan_work); 725 726 for (i = 0; i < ARRAY_SIZE(dev->q_rx); i++) 727 skb_queue_head_init(&dev->rx_skb[i]); 728 729 dev->wq = alloc_ordered_workqueue("mt76", 0); 730 if (!dev->wq) { 731 ieee80211_free_hw(hw); 732 return NULL; 733 } 734 735 return dev; 736 } 737 EXPORT_SYMBOL_GPL(mt76_alloc_device); 738 739 int mt76_register_device(struct mt76_dev *dev, bool vht, 740 struct ieee80211_rate *rates, int n_rates) 741 { 742 struct ieee80211_hw *hw = dev->hw; 743 struct mt76_phy *phy = &dev->phy; 744 int ret; 745 746 dev_set_drvdata(dev->dev, dev); 747 mt76_wcid_init(&dev->global_wcid, phy->band_idx); 748 ret = mt76_phy_init(phy, hw); 749 if (ret) 750 return ret; 751 752 if (phy->cap.has_2ghz) { 753 ret = mt76_init_sband_2g(phy, rates, n_rates); 754 if (ret) 755 return ret; 756 } 757 758 if (phy->cap.has_5ghz) { 759 ret = mt76_init_sband_5g(phy, rates + 4, n_rates - 4, vht); 760 if (ret) 761 return ret; 762 } 763 764 if (phy->cap.has_6ghz) { 765 ret = mt76_init_sband_6g(phy, rates + 4, n_rates - 4); 766 if (ret) 767 return ret; 768 } 769 770 wiphy_read_of_freq_limits(hw->wiphy); 771 mt76_check_sband(&dev->phy, &phy->sband_2g, NL80211_BAND_2GHZ); 772 mt76_check_sband(&dev->phy, &phy->sband_5g, NL80211_BAND_5GHZ); 773 mt76_check_sband(&dev->phy, &phy->sband_6g, NL80211_BAND_6GHZ); 774 775 if (IS_ENABLED(CONFIG_MT76_LEDS)) { 776 ret = mt76_led_init(phy); 777 if (ret) 778 return ret; 779 } 780 781 ret = ieee80211_register_hw(hw); 782 if (ret) 783 return ret; 784 785 WARN_ON(mt76_worker_setup(hw, &dev->tx_worker, NULL, "tx")); 786 set_bit(MT76_STATE_REGISTERED, &phy->state); 787 sched_set_fifo_low(dev->tx_worker.task); 788 789 return 0; 790 } 791 EXPORT_SYMBOL_GPL(mt76_register_device); 792 793 void mt76_unregister_device(struct mt76_dev *dev) 794 { 795 struct ieee80211_hw *hw = dev->hw; 796 797 if (!test_bit(MT76_STATE_REGISTERED, &dev->phy.state)) 798 return; 799 800 if (IS_ENABLED(CONFIG_MT76_LEDS)) 801 mt76_led_cleanup(&dev->phy); 802 mt76_tx_status_check(dev, true); 803 mt76_wcid_cleanup(dev, &dev->global_wcid); 804 ieee80211_unregister_hw(hw); 805 } 806 EXPORT_SYMBOL_GPL(mt76_unregister_device); 807 808 void mt76_free_device(struct mt76_dev *dev) 809 { 810 mt76_worker_teardown(&dev->tx_worker); 811 if (dev->wq) { 812 destroy_workqueue(dev->wq); 813 dev->wq = NULL; 814 } 815 ieee80211_free_hw(dev->hw); 816 } 817 EXPORT_SYMBOL_GPL(mt76_free_device); 818 819 struct mt76_phy *mt76_vif_phy(struct ieee80211_hw *hw, 820 struct ieee80211_vif *vif) 821 { 822 struct mt76_vif_link *mlink = (struct mt76_vif_link *)vif->drv_priv; 823 struct mt76_chanctx *ctx; 824 825 if (!hw->wiphy->n_radio) 826 return hw->priv; 827 828 if (!mlink->ctx) 829 return NULL; 830 831 ctx = (struct mt76_chanctx *)mlink->ctx->drv_priv; 832 return ctx->phy; 833 } 834 EXPORT_SYMBOL_GPL(mt76_vif_phy); 835 836 static void mt76_rx_release_amsdu(struct mt76_phy *phy, enum mt76_rxq_id q) 837 { 838 struct sk_buff *skb = phy->rx_amsdu[q].head; 839 struct mt76_rx_status *status = (struct mt76_rx_status *)skb->cb; 840 struct mt76_dev *dev = phy->dev; 841 842 phy->rx_amsdu[q].head = NULL; 843 phy->rx_amsdu[q].tail = NULL; 844 845 /* 846 * Validate if the amsdu has a proper first subframe. 847 * A single MSDU can be parsed as A-MSDU when the unauthenticated A-MSDU 848 * flag of the QoS header gets flipped. In such cases, the first 849 * subframe has a LLC/SNAP header in the location of the destination 850 * address. 851 */ 852 if (skb_shinfo(skb)->frag_list) { 853 int offset = 0; 854 855 if (!(status->flag & RX_FLAG_8023)) { 856 offset = ieee80211_get_hdrlen_from_skb(skb); 857 858 if ((status->flag & 859 (RX_FLAG_DECRYPTED | RX_FLAG_IV_STRIPPED)) == 860 RX_FLAG_DECRYPTED) 861 offset += 8; 862 } 863 864 if (ether_addr_equal(skb->data + offset, rfc1042_header)) { 865 dev_kfree_skb(skb); 866 return; 867 } 868 } 869 __skb_queue_tail(&dev->rx_skb[q], skb); 870 } 871 872 static void mt76_rx_release_burst(struct mt76_phy *phy, enum mt76_rxq_id q, 873 struct sk_buff *skb) 874 { 875 struct mt76_rx_status *status = (struct mt76_rx_status *)skb->cb; 876 877 if (phy->rx_amsdu[q].head && 878 (!status->amsdu || status->first_amsdu || 879 status->seqno != phy->rx_amsdu[q].seqno)) 880 mt76_rx_release_amsdu(phy, q); 881 882 if (!phy->rx_amsdu[q].head) { 883 phy->rx_amsdu[q].tail = &skb_shinfo(skb)->frag_list; 884 phy->rx_amsdu[q].seqno = status->seqno; 885 phy->rx_amsdu[q].head = skb; 886 } else { 887 *phy->rx_amsdu[q].tail = skb; 888 phy->rx_amsdu[q].tail = &skb->next; 889 } 890 891 if (!status->amsdu || status->last_amsdu) 892 mt76_rx_release_amsdu(phy, q); 893 } 894 895 void mt76_rx(struct mt76_dev *dev, enum mt76_rxq_id q, struct sk_buff *skb) 896 { 897 struct mt76_rx_status *status = (struct mt76_rx_status *)skb->cb; 898 struct mt76_phy *phy = mt76_dev_phy(dev, status->phy_idx); 899 900 if (!test_bit(MT76_STATE_RUNNING, &phy->state)) { 901 dev_kfree_skb(skb); 902 return; 903 } 904 905 #ifdef CONFIG_NL80211_TESTMODE 906 if (phy->test.state == MT76_TM_STATE_RX_FRAMES) { 907 phy->test.rx_stats.packets[q]++; 908 if (status->flag & RX_FLAG_FAILED_FCS_CRC) 909 phy->test.rx_stats.fcs_error[q]++; 910 } 911 #endif 912 913 mt76_rx_release_burst(phy, q, skb); 914 } 915 EXPORT_SYMBOL_GPL(mt76_rx); 916 917 bool mt76_has_tx_pending(struct mt76_phy *phy) 918 { 919 struct mt76_queue *q; 920 int i; 921 922 for (i = 0; i < __MT_TXQ_MAX; i++) { 923 q = phy->q_tx[i]; 924 if (q && q->queued) 925 return true; 926 } 927 928 return false; 929 } 930 EXPORT_SYMBOL_GPL(mt76_has_tx_pending); 931 932 static struct mt76_channel_state * 933 mt76_channel_state(struct mt76_phy *phy, struct ieee80211_channel *c) 934 { 935 struct mt76_sband *msband; 936 int idx; 937 938 if (c->band == NL80211_BAND_2GHZ) 939 msband = &phy->sband_2g; 940 else if (c->band == NL80211_BAND_6GHZ) 941 msband = &phy->sband_6g; 942 else 943 msband = &phy->sband_5g; 944 945 idx = c - &msband->sband.channels[0]; 946 return &msband->chan[idx]; 947 } 948 949 void mt76_update_survey_active_time(struct mt76_phy *phy, ktime_t time) 950 { 951 struct mt76_channel_state *state = phy->chan_state; 952 953 state->cc_active += ktime_to_us(ktime_sub(time, 954 phy->survey_time)); 955 phy->survey_time = time; 956 } 957 EXPORT_SYMBOL_GPL(mt76_update_survey_active_time); 958 959 void mt76_update_survey(struct mt76_phy *phy) 960 { 961 struct mt76_dev *dev = phy->dev; 962 ktime_t cur_time; 963 964 if (dev->drv->update_survey) 965 dev->drv->update_survey(phy); 966 967 cur_time = ktime_get_boottime(); 968 mt76_update_survey_active_time(phy, cur_time); 969 970 if (dev->drv->drv_flags & MT_DRV_SW_RX_AIRTIME) { 971 struct mt76_channel_state *state = phy->chan_state; 972 973 spin_lock_bh(&dev->cc_lock); 974 state->cc_bss_rx += dev->cur_cc_bss_rx; 975 dev->cur_cc_bss_rx = 0; 976 spin_unlock_bh(&dev->cc_lock); 977 } 978 } 979 EXPORT_SYMBOL_GPL(mt76_update_survey); 980 981 int __mt76_set_channel(struct mt76_phy *phy, struct cfg80211_chan_def *chandef, 982 bool offchannel) 983 { 984 struct mt76_dev *dev = phy->dev; 985 int timeout = HZ / 5; 986 int ret; 987 988 set_bit(MT76_RESET, &phy->state); 989 990 mt76_worker_disable(&dev->tx_worker); 991 wait_event_timeout(dev->tx_wait, !mt76_has_tx_pending(phy), timeout); 992 mt76_update_survey(phy); 993 994 if (phy->chandef.chan->center_freq != chandef->chan->center_freq || 995 phy->chandef.width != chandef->width) 996 phy->dfs_state = MT_DFS_STATE_UNKNOWN; 997 998 phy->chandef = *chandef; 999 phy->chan_state = mt76_channel_state(phy, chandef->chan); 1000 phy->offchannel = offchannel; 1001 1002 if (!offchannel) 1003 phy->main_chandef = *chandef; 1004 1005 if (chandef->chan != phy->main_chandef.chan) 1006 memset(phy->chan_state, 0, sizeof(*phy->chan_state)); 1007 1008 ret = dev->drv->set_channel(phy); 1009 1010 clear_bit(MT76_RESET, &phy->state); 1011 mt76_worker_enable(&dev->tx_worker); 1012 mt76_worker_schedule(&dev->tx_worker); 1013 1014 return ret; 1015 } 1016 1017 int mt76_set_channel(struct mt76_phy *phy, struct cfg80211_chan_def *chandef, 1018 bool offchannel) 1019 { 1020 struct mt76_dev *dev = phy->dev; 1021 int ret; 1022 1023 cancel_delayed_work_sync(&phy->mac_work); 1024 1025 mutex_lock(&dev->mutex); 1026 ret = __mt76_set_channel(phy, chandef, offchannel); 1027 mutex_unlock(&dev->mutex); 1028 1029 return ret; 1030 } 1031 1032 int mt76_update_channel(struct mt76_phy *phy) 1033 { 1034 struct ieee80211_hw *hw = phy->hw; 1035 struct cfg80211_chan_def *chandef = &hw->conf.chandef; 1036 bool offchannel = hw->conf.flags & IEEE80211_CONF_OFFCHANNEL; 1037 1038 phy->radar_enabled = hw->conf.radar_enabled; 1039 1040 return mt76_set_channel(phy, chandef, offchannel); 1041 } 1042 EXPORT_SYMBOL_GPL(mt76_update_channel); 1043 1044 static struct mt76_sband * 1045 mt76_get_survey_sband(struct mt76_phy *phy, int *idx) 1046 { 1047 if (*idx < phy->sband_2g.sband.n_channels) 1048 return &phy->sband_2g; 1049 1050 *idx -= phy->sband_2g.sband.n_channels; 1051 if (*idx < phy->sband_5g.sband.n_channels) 1052 return &phy->sband_5g; 1053 1054 *idx -= phy->sband_5g.sband.n_channels; 1055 if (*idx < phy->sband_6g.sband.n_channels) 1056 return &phy->sband_6g; 1057 1058 *idx -= phy->sband_6g.sband.n_channels; 1059 return NULL; 1060 } 1061 1062 int mt76_get_survey(struct ieee80211_hw *hw, int idx, 1063 struct survey_info *survey) 1064 { 1065 struct mt76_phy *phy = hw->priv; 1066 struct mt76_dev *dev = phy->dev; 1067 struct mt76_sband *sband = NULL; 1068 struct ieee80211_channel *chan; 1069 struct mt76_channel_state *state; 1070 int phy_idx = 0; 1071 int ret = 0; 1072 1073 mutex_lock(&dev->mutex); 1074 1075 for (phy_idx = 0; phy_idx < ARRAY_SIZE(dev->phys); phy_idx++) { 1076 sband = NULL; 1077 phy = dev->phys[phy_idx]; 1078 if (!phy || phy->hw != hw) 1079 continue; 1080 1081 sband = mt76_get_survey_sband(phy, &idx); 1082 1083 if (idx == 0 && phy->dev->drv->update_survey) 1084 mt76_update_survey(phy); 1085 1086 if (sband || !hw->wiphy->n_radio) 1087 break; 1088 } 1089 1090 if (!sband) { 1091 ret = -ENOENT; 1092 goto out; 1093 } 1094 1095 chan = &sband->sband.channels[idx]; 1096 state = mt76_channel_state(phy, chan); 1097 1098 memset(survey, 0, sizeof(*survey)); 1099 survey->channel = chan; 1100 survey->filled = SURVEY_INFO_TIME | SURVEY_INFO_TIME_BUSY; 1101 survey->filled |= dev->drv->survey_flags; 1102 if (state->noise) 1103 survey->filled |= SURVEY_INFO_NOISE_DBM; 1104 1105 if (chan == phy->main_chandef.chan) { 1106 survey->filled |= SURVEY_INFO_IN_USE; 1107 1108 if (dev->drv->drv_flags & MT_DRV_SW_RX_AIRTIME) 1109 survey->filled |= SURVEY_INFO_TIME_BSS_RX; 1110 } 1111 1112 survey->time_busy = div_u64(state->cc_busy, 1000); 1113 survey->time_rx = div_u64(state->cc_rx, 1000); 1114 survey->time = div_u64(state->cc_active, 1000); 1115 survey->noise = state->noise; 1116 1117 spin_lock_bh(&dev->cc_lock); 1118 survey->time_bss_rx = div_u64(state->cc_bss_rx, 1000); 1119 survey->time_tx = div_u64(state->cc_tx, 1000); 1120 spin_unlock_bh(&dev->cc_lock); 1121 1122 out: 1123 mutex_unlock(&dev->mutex); 1124 1125 return ret; 1126 } 1127 EXPORT_SYMBOL_GPL(mt76_get_survey); 1128 1129 void mt76_wcid_key_setup(struct mt76_dev *dev, struct mt76_wcid *wcid, 1130 struct ieee80211_key_conf *key) 1131 { 1132 struct ieee80211_key_seq seq; 1133 int i; 1134 1135 wcid->rx_check_pn = false; 1136 1137 if (!key) 1138 return; 1139 1140 if (key->cipher != WLAN_CIPHER_SUITE_CCMP) 1141 return; 1142 1143 wcid->rx_check_pn = true; 1144 1145 /* data frame */ 1146 for (i = 0; i < IEEE80211_NUM_TIDS; i++) { 1147 ieee80211_get_key_rx_seq(key, i, &seq); 1148 memcpy(wcid->rx_key_pn[i], seq.ccmp.pn, sizeof(seq.ccmp.pn)); 1149 } 1150 1151 /* robust management frame */ 1152 ieee80211_get_key_rx_seq(key, -1, &seq); 1153 memcpy(wcid->rx_key_pn[i], seq.ccmp.pn, sizeof(seq.ccmp.pn)); 1154 1155 } 1156 EXPORT_SYMBOL(mt76_wcid_key_setup); 1157 1158 int mt76_rx_signal(u8 chain_mask, s8 *chain_signal) 1159 { 1160 int signal = -128; 1161 u8 chains; 1162 1163 for (chains = chain_mask; chains; chains >>= 1, chain_signal++) { 1164 int cur, diff; 1165 1166 cur = *chain_signal; 1167 if (!(chains & BIT(0)) || 1168 cur > 0) 1169 continue; 1170 1171 if (cur > signal) 1172 swap(cur, signal); 1173 1174 diff = signal - cur; 1175 if (diff == 0) 1176 signal += 3; 1177 else if (diff <= 2) 1178 signal += 2; 1179 else if (diff <= 6) 1180 signal += 1; 1181 } 1182 1183 return signal; 1184 } 1185 EXPORT_SYMBOL(mt76_rx_signal); 1186 1187 static void 1188 mt76_rx_convert(struct mt76_dev *dev, struct sk_buff *skb, 1189 struct ieee80211_hw **hw, 1190 struct ieee80211_sta **sta) 1191 { 1192 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb); 1193 struct ieee80211_hdr *hdr = mt76_skb_get_hdr(skb); 1194 struct mt76_rx_status mstat; 1195 1196 mstat = *((struct mt76_rx_status *)skb->cb); 1197 memset(status, 0, sizeof(*status)); 1198 1199 status->flag = mstat.flag; 1200 status->freq = mstat.freq; 1201 status->enc_flags = mstat.enc_flags; 1202 status->encoding = mstat.encoding; 1203 status->bw = mstat.bw; 1204 if (status->encoding == RX_ENC_EHT) { 1205 status->eht.ru = mstat.eht.ru; 1206 status->eht.gi = mstat.eht.gi; 1207 } else { 1208 status->he_ru = mstat.he_ru; 1209 status->he_gi = mstat.he_gi; 1210 status->he_dcm = mstat.he_dcm; 1211 } 1212 status->rate_idx = mstat.rate_idx; 1213 status->nss = mstat.nss; 1214 status->band = mstat.band; 1215 status->signal = mstat.signal; 1216 status->chains = mstat.chains; 1217 status->ampdu_reference = mstat.ampdu_ref; 1218 status->device_timestamp = mstat.timestamp; 1219 status->mactime = mstat.timestamp; 1220 status->signal = mt76_rx_signal(mstat.chains, mstat.chain_signal); 1221 if (status->signal <= -128) 1222 status->flag |= RX_FLAG_NO_SIGNAL_VAL; 1223 1224 if (ieee80211_is_beacon(hdr->frame_control) || 1225 ieee80211_is_probe_resp(hdr->frame_control)) 1226 status->boottime_ns = ktime_get_boottime_ns(); 1227 1228 BUILD_BUG_ON(sizeof(mstat) > sizeof(skb->cb)); 1229 BUILD_BUG_ON(sizeof(status->chain_signal) != 1230 sizeof(mstat.chain_signal)); 1231 memcpy(status->chain_signal, mstat.chain_signal, 1232 sizeof(mstat.chain_signal)); 1233 1234 if (mstat.wcid) { 1235 status->link_valid = mstat.wcid->link_valid; 1236 status->link_id = mstat.wcid->link_id; 1237 } 1238 1239 *sta = wcid_to_sta(mstat.wcid); 1240 *hw = mt76_phy_hw(dev, mstat.phy_idx); 1241 } 1242 1243 static void 1244 mt76_check_ccmp_pn(struct sk_buff *skb) 1245 { 1246 struct mt76_rx_status *status = (struct mt76_rx_status *)skb->cb; 1247 struct mt76_wcid *wcid = status->wcid; 1248 struct ieee80211_hdr *hdr; 1249 int security_idx; 1250 int ret; 1251 1252 if (!(status->flag & RX_FLAG_DECRYPTED)) 1253 return; 1254 1255 if (status->flag & RX_FLAG_ONLY_MONITOR) 1256 return; 1257 1258 if (!wcid || !wcid->rx_check_pn) 1259 return; 1260 1261 security_idx = status->qos_ctl & IEEE80211_QOS_CTL_TID_MASK; 1262 if (status->flag & RX_FLAG_8023) 1263 goto skip_hdr_check; 1264 1265 hdr = mt76_skb_get_hdr(skb); 1266 if (!(status->flag & RX_FLAG_IV_STRIPPED)) { 1267 /* 1268 * Validate the first fragment both here and in mac80211 1269 * All further fragments will be validated by mac80211 only. 1270 */ 1271 if (ieee80211_is_frag(hdr) && 1272 !ieee80211_is_first_frag(hdr->frame_control)) 1273 return; 1274 } 1275 1276 /* IEEE 802.11-2020, 12.5.3.4.4 "PN and replay detection" c): 1277 * 1278 * the recipient shall maintain a single replay counter for received 1279 * individually addressed robust Management frames that are received 1280 * with the To DS subfield equal to 0, [...] 1281 */ 1282 if (ieee80211_is_mgmt(hdr->frame_control) && 1283 !ieee80211_has_tods(hdr->frame_control)) 1284 security_idx = IEEE80211_NUM_TIDS; 1285 1286 skip_hdr_check: 1287 BUILD_BUG_ON(sizeof(status->iv) != sizeof(wcid->rx_key_pn[0])); 1288 ret = memcmp(status->iv, wcid->rx_key_pn[security_idx], 1289 sizeof(status->iv)); 1290 if (ret <= 0) { 1291 status->flag |= RX_FLAG_ONLY_MONITOR; 1292 return; 1293 } 1294 1295 memcpy(wcid->rx_key_pn[security_idx], status->iv, sizeof(status->iv)); 1296 1297 if (status->flag & RX_FLAG_IV_STRIPPED) 1298 status->flag |= RX_FLAG_PN_VALIDATED; 1299 } 1300 1301 static void 1302 mt76_airtime_report(struct mt76_dev *dev, struct mt76_rx_status *status, 1303 int len) 1304 { 1305 struct mt76_wcid *wcid = status->wcid; 1306 struct ieee80211_rx_status info = { 1307 .enc_flags = status->enc_flags, 1308 .rate_idx = status->rate_idx, 1309 .encoding = status->encoding, 1310 .band = status->band, 1311 .nss = status->nss, 1312 .bw = status->bw, 1313 }; 1314 struct ieee80211_sta *sta; 1315 u32 airtime; 1316 u8 tidno = status->qos_ctl & IEEE80211_QOS_CTL_TID_MASK; 1317 1318 airtime = ieee80211_calc_rx_airtime(dev->hw, &info, len); 1319 spin_lock(&dev->cc_lock); 1320 dev->cur_cc_bss_rx += airtime; 1321 spin_unlock(&dev->cc_lock); 1322 1323 if (!wcid || !wcid->sta) 1324 return; 1325 1326 sta = container_of((void *)wcid, struct ieee80211_sta, drv_priv); 1327 ieee80211_sta_register_airtime(sta, tidno, 0, airtime); 1328 } 1329 1330 static void 1331 mt76_airtime_flush_ampdu(struct mt76_dev *dev) 1332 { 1333 struct mt76_wcid *wcid; 1334 int wcid_idx; 1335 1336 if (!dev->rx_ampdu_len) 1337 return; 1338 1339 wcid_idx = dev->rx_ampdu_status.wcid_idx; 1340 if (wcid_idx < ARRAY_SIZE(dev->wcid)) 1341 wcid = rcu_dereference(dev->wcid[wcid_idx]); 1342 else 1343 wcid = NULL; 1344 dev->rx_ampdu_status.wcid = wcid; 1345 1346 mt76_airtime_report(dev, &dev->rx_ampdu_status, dev->rx_ampdu_len); 1347 1348 dev->rx_ampdu_len = 0; 1349 dev->rx_ampdu_ref = 0; 1350 } 1351 1352 static void 1353 mt76_airtime_check(struct mt76_dev *dev, struct sk_buff *skb) 1354 { 1355 struct mt76_rx_status *status = (struct mt76_rx_status *)skb->cb; 1356 struct mt76_wcid *wcid = status->wcid; 1357 1358 if (!(dev->drv->drv_flags & MT_DRV_SW_RX_AIRTIME)) 1359 return; 1360 1361 if (!wcid || !wcid->sta) { 1362 struct ieee80211_hdr *hdr = mt76_skb_get_hdr(skb); 1363 1364 if (status->flag & RX_FLAG_8023) 1365 return; 1366 1367 if (!ether_addr_equal(hdr->addr1, dev->phy.macaddr)) 1368 return; 1369 1370 wcid = NULL; 1371 } 1372 1373 if (!(status->flag & RX_FLAG_AMPDU_DETAILS) || 1374 status->ampdu_ref != dev->rx_ampdu_ref) 1375 mt76_airtime_flush_ampdu(dev); 1376 1377 if (status->flag & RX_FLAG_AMPDU_DETAILS) { 1378 if (!dev->rx_ampdu_len || 1379 status->ampdu_ref != dev->rx_ampdu_ref) { 1380 dev->rx_ampdu_status = *status; 1381 dev->rx_ampdu_status.wcid_idx = wcid ? wcid->idx : 0xff; 1382 dev->rx_ampdu_ref = status->ampdu_ref; 1383 } 1384 1385 dev->rx_ampdu_len += skb->len; 1386 return; 1387 } 1388 1389 mt76_airtime_report(dev, status, skb->len); 1390 } 1391 1392 static void 1393 mt76_check_sta(struct mt76_dev *dev, struct sk_buff *skb) 1394 { 1395 struct mt76_rx_status *status = (struct mt76_rx_status *)skb->cb; 1396 struct ieee80211_hdr *hdr = mt76_skb_get_hdr(skb); 1397 struct ieee80211_sta *sta; 1398 struct ieee80211_hw *hw; 1399 struct mt76_wcid *wcid = status->wcid; 1400 u8 tidno = status->qos_ctl & IEEE80211_QOS_CTL_TID_MASK; 1401 bool ps; 1402 1403 hw = mt76_phy_hw(dev, status->phy_idx); 1404 if (ieee80211_is_pspoll(hdr->frame_control) && !wcid && 1405 !(status->flag & RX_FLAG_8023)) { 1406 sta = ieee80211_find_sta_by_ifaddr(hw, hdr->addr2, NULL); 1407 if (sta) 1408 wcid = status->wcid = (struct mt76_wcid *)sta->drv_priv; 1409 } 1410 1411 mt76_airtime_check(dev, skb); 1412 1413 if (!wcid || !wcid->sta) 1414 return; 1415 1416 sta = container_of((void *)wcid, struct ieee80211_sta, drv_priv); 1417 1418 if (status->signal <= 0) 1419 ewma_signal_add(&wcid->rssi, -status->signal); 1420 1421 wcid->inactive_count = 0; 1422 1423 if (status->flag & RX_FLAG_8023) 1424 return; 1425 1426 if (!test_bit(MT_WCID_FLAG_CHECK_PS, &wcid->flags)) 1427 return; 1428 1429 if (ieee80211_is_pspoll(hdr->frame_control)) { 1430 ieee80211_sta_pspoll(sta); 1431 return; 1432 } 1433 1434 if (ieee80211_has_morefrags(hdr->frame_control) || 1435 !(ieee80211_is_mgmt(hdr->frame_control) || 1436 ieee80211_is_data(hdr->frame_control))) 1437 return; 1438 1439 ps = ieee80211_has_pm(hdr->frame_control); 1440 1441 if (ps && (ieee80211_is_data_qos(hdr->frame_control) || 1442 ieee80211_is_qos_nullfunc(hdr->frame_control))) 1443 ieee80211_sta_uapsd_trigger(sta, tidno); 1444 1445 if (!!test_bit(MT_WCID_FLAG_PS, &wcid->flags) == ps) 1446 return; 1447 1448 if (ps) 1449 set_bit(MT_WCID_FLAG_PS, &wcid->flags); 1450 1451 if (dev->drv->sta_ps) 1452 dev->drv->sta_ps(dev, sta, ps); 1453 1454 if (!ps) 1455 clear_bit(MT_WCID_FLAG_PS, &wcid->flags); 1456 1457 ieee80211_sta_ps_transition(sta, ps); 1458 } 1459 1460 void mt76_rx_complete(struct mt76_dev *dev, struct sk_buff_head *frames, 1461 struct napi_struct *napi) 1462 { 1463 struct ieee80211_sta *sta; 1464 struct ieee80211_hw *hw; 1465 struct sk_buff *skb, *tmp; 1466 LIST_HEAD(list); 1467 1468 spin_lock(&dev->rx_lock); 1469 while ((skb = __skb_dequeue(frames)) != NULL) { 1470 struct sk_buff *nskb = skb_shinfo(skb)->frag_list; 1471 1472 mt76_check_ccmp_pn(skb); 1473 skb_shinfo(skb)->frag_list = NULL; 1474 mt76_rx_convert(dev, skb, &hw, &sta); 1475 ieee80211_rx_list(hw, sta, skb, &list); 1476 1477 /* subsequent amsdu frames */ 1478 while (nskb) { 1479 skb = nskb; 1480 nskb = nskb->next; 1481 skb->next = NULL; 1482 1483 mt76_rx_convert(dev, skb, &hw, &sta); 1484 ieee80211_rx_list(hw, sta, skb, &list); 1485 } 1486 } 1487 spin_unlock(&dev->rx_lock); 1488 1489 if (!napi) { 1490 netif_receive_skb_list(&list); 1491 return; 1492 } 1493 1494 list_for_each_entry_safe(skb, tmp, &list, list) { 1495 skb_list_del_init(skb); 1496 napi_gro_receive(napi, skb); 1497 } 1498 } 1499 1500 void mt76_rx_poll_complete(struct mt76_dev *dev, enum mt76_rxq_id q, 1501 struct napi_struct *napi) 1502 { 1503 struct sk_buff_head frames; 1504 struct sk_buff *skb; 1505 1506 __skb_queue_head_init(&frames); 1507 1508 while ((skb = __skb_dequeue(&dev->rx_skb[q])) != NULL) { 1509 mt76_check_sta(dev, skb); 1510 if (mtk_wed_device_active(&dev->mmio.wed)) 1511 __skb_queue_tail(&frames, skb); 1512 else 1513 mt76_rx_aggr_reorder(skb, &frames); 1514 } 1515 1516 mt76_rx_complete(dev, &frames, napi); 1517 } 1518 EXPORT_SYMBOL_GPL(mt76_rx_poll_complete); 1519 1520 static int 1521 mt76_sta_add(struct mt76_phy *phy, struct ieee80211_vif *vif, 1522 struct ieee80211_sta *sta) 1523 { 1524 struct mt76_wcid *wcid = (struct mt76_wcid *)sta->drv_priv; 1525 struct mt76_dev *dev = phy->dev; 1526 int ret; 1527 int i; 1528 1529 mutex_lock(&dev->mutex); 1530 1531 ret = dev->drv->sta_add(dev, vif, sta); 1532 if (ret) 1533 goto out; 1534 1535 for (i = 0; i < ARRAY_SIZE(sta->txq); i++) { 1536 struct mt76_txq *mtxq; 1537 1538 if (!sta->txq[i]) 1539 continue; 1540 1541 mtxq = (struct mt76_txq *)sta->txq[i]->drv_priv; 1542 mtxq->wcid = wcid->idx; 1543 } 1544 1545 ewma_signal_init(&wcid->rssi); 1546 rcu_assign_pointer(dev->wcid[wcid->idx], wcid); 1547 phy->num_sta++; 1548 1549 mt76_wcid_init(wcid, phy->band_idx); 1550 out: 1551 mutex_unlock(&dev->mutex); 1552 1553 return ret; 1554 } 1555 1556 void __mt76_sta_remove(struct mt76_phy *phy, struct ieee80211_vif *vif, 1557 struct ieee80211_sta *sta) 1558 { 1559 struct mt76_dev *dev = phy->dev; 1560 struct mt76_wcid *wcid = (struct mt76_wcid *)sta->drv_priv; 1561 int i, idx = wcid->idx; 1562 1563 for (i = 0; i < ARRAY_SIZE(wcid->aggr); i++) 1564 mt76_rx_aggr_stop(dev, wcid, i); 1565 1566 if (dev->drv->sta_remove) 1567 dev->drv->sta_remove(dev, vif, sta); 1568 1569 mt76_wcid_cleanup(dev, wcid); 1570 1571 mt76_wcid_mask_clear(dev->wcid_mask, idx); 1572 phy->num_sta--; 1573 } 1574 EXPORT_SYMBOL_GPL(__mt76_sta_remove); 1575 1576 static void 1577 mt76_sta_remove(struct mt76_phy *phy, struct ieee80211_vif *vif, 1578 struct ieee80211_sta *sta) 1579 { 1580 struct mt76_dev *dev = phy->dev; 1581 1582 mutex_lock(&dev->mutex); 1583 __mt76_sta_remove(phy, vif, sta); 1584 mutex_unlock(&dev->mutex); 1585 } 1586 1587 int mt76_sta_state(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 1588 struct ieee80211_sta *sta, 1589 enum ieee80211_sta_state old_state, 1590 enum ieee80211_sta_state new_state) 1591 { 1592 struct mt76_phy *phy = hw->priv; 1593 struct mt76_dev *dev = phy->dev; 1594 enum mt76_sta_event ev; 1595 1596 phy = mt76_vif_phy(hw, vif); 1597 if (!phy) 1598 return -EINVAL; 1599 1600 if (old_state == IEEE80211_STA_NOTEXIST && 1601 new_state == IEEE80211_STA_NONE) 1602 return mt76_sta_add(phy, vif, sta); 1603 1604 if (old_state == IEEE80211_STA_NONE && 1605 new_state == IEEE80211_STA_NOTEXIST) 1606 mt76_sta_remove(phy, vif, sta); 1607 1608 if (!dev->drv->sta_event) 1609 return 0; 1610 1611 if (old_state == IEEE80211_STA_AUTH && 1612 new_state == IEEE80211_STA_ASSOC) 1613 ev = MT76_STA_EVENT_ASSOC; 1614 else if (old_state == IEEE80211_STA_ASSOC && 1615 new_state == IEEE80211_STA_AUTHORIZED) 1616 ev = MT76_STA_EVENT_AUTHORIZE; 1617 else if (old_state == IEEE80211_STA_ASSOC && 1618 new_state == IEEE80211_STA_AUTH) 1619 ev = MT76_STA_EVENT_DISASSOC; 1620 else 1621 return 0; 1622 1623 return dev->drv->sta_event(dev, vif, sta, ev); 1624 } 1625 EXPORT_SYMBOL_GPL(mt76_sta_state); 1626 1627 void mt76_sta_pre_rcu_remove(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 1628 struct ieee80211_sta *sta) 1629 { 1630 struct mt76_phy *phy = hw->priv; 1631 struct mt76_dev *dev = phy->dev; 1632 struct mt76_wcid *wcid = (struct mt76_wcid *)sta->drv_priv; 1633 1634 mutex_lock(&dev->mutex); 1635 spin_lock_bh(&dev->status_lock); 1636 rcu_assign_pointer(dev->wcid[wcid->idx], NULL); 1637 spin_unlock_bh(&dev->status_lock); 1638 mutex_unlock(&dev->mutex); 1639 } 1640 EXPORT_SYMBOL_GPL(mt76_sta_pre_rcu_remove); 1641 1642 void mt76_wcid_init(struct mt76_wcid *wcid, u8 band_idx) 1643 { 1644 wcid->hw_key_idx = -1; 1645 wcid->phy_idx = band_idx; 1646 1647 INIT_LIST_HEAD(&wcid->tx_list); 1648 skb_queue_head_init(&wcid->tx_pending); 1649 skb_queue_head_init(&wcid->tx_offchannel); 1650 1651 INIT_LIST_HEAD(&wcid->list); 1652 idr_init(&wcid->pktid); 1653 1654 INIT_LIST_HEAD(&wcid->poll_list); 1655 } 1656 EXPORT_SYMBOL_GPL(mt76_wcid_init); 1657 1658 void mt76_wcid_cleanup(struct mt76_dev *dev, struct mt76_wcid *wcid) 1659 { 1660 struct mt76_phy *phy = mt76_dev_phy(dev, wcid->phy_idx); 1661 struct ieee80211_hw *hw; 1662 struct sk_buff_head list; 1663 struct sk_buff *skb; 1664 1665 mt76_tx_status_lock(dev, &list); 1666 mt76_tx_status_skb_get(dev, wcid, -1, &list); 1667 mt76_tx_status_unlock(dev, &list); 1668 1669 idr_destroy(&wcid->pktid); 1670 1671 spin_lock_bh(&phy->tx_lock); 1672 1673 if (!list_empty(&wcid->tx_list)) 1674 list_del_init(&wcid->tx_list); 1675 1676 spin_lock(&wcid->tx_pending.lock); 1677 skb_queue_splice_tail_init(&wcid->tx_pending, &list); 1678 spin_unlock(&wcid->tx_pending.lock); 1679 1680 spin_unlock_bh(&phy->tx_lock); 1681 1682 while ((skb = __skb_dequeue(&list)) != NULL) { 1683 hw = mt76_tx_status_get_hw(dev, skb); 1684 ieee80211_free_txskb(hw, skb); 1685 } 1686 } 1687 EXPORT_SYMBOL_GPL(mt76_wcid_cleanup); 1688 1689 void mt76_wcid_add_poll(struct mt76_dev *dev, struct mt76_wcid *wcid) 1690 { 1691 if (test_bit(MT76_MCU_RESET, &dev->phy.state)) 1692 return; 1693 1694 spin_lock_bh(&dev->sta_poll_lock); 1695 if (list_empty(&wcid->poll_list)) 1696 list_add_tail(&wcid->poll_list, &dev->sta_poll_list); 1697 spin_unlock_bh(&dev->sta_poll_lock); 1698 } 1699 EXPORT_SYMBOL_GPL(mt76_wcid_add_poll); 1700 1701 s8 mt76_get_power_bound(struct mt76_phy *phy, s8 txpower) 1702 { 1703 int n_chains = hweight16(phy->chainmask); 1704 1705 txpower = mt76_get_sar_power(phy, phy->chandef.chan, txpower * 2); 1706 txpower -= mt76_tx_power_nss_delta(n_chains); 1707 1708 return txpower; 1709 } 1710 EXPORT_SYMBOL_GPL(mt76_get_power_bound); 1711 1712 int mt76_get_txpower(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 1713 unsigned int link_id, int *dbm) 1714 { 1715 struct mt76_phy *phy = mt76_vif_phy(hw, vif); 1716 int n_chains, delta; 1717 1718 if (!phy) 1719 return -EINVAL; 1720 1721 n_chains = hweight16(phy->chainmask); 1722 delta = mt76_tx_power_nss_delta(n_chains); 1723 *dbm = DIV_ROUND_UP(phy->txpower_cur + delta, 2); 1724 1725 return 0; 1726 } 1727 EXPORT_SYMBOL_GPL(mt76_get_txpower); 1728 1729 int mt76_init_sar_power(struct ieee80211_hw *hw, 1730 const struct cfg80211_sar_specs *sar) 1731 { 1732 struct mt76_phy *phy = hw->priv; 1733 const struct cfg80211_sar_capa *capa = hw->wiphy->sar_capa; 1734 int i; 1735 1736 if (sar->type != NL80211_SAR_TYPE_POWER || !sar->num_sub_specs) 1737 return -EINVAL; 1738 1739 for (i = 0; i < sar->num_sub_specs; i++) { 1740 u32 index = sar->sub_specs[i].freq_range_index; 1741 /* SAR specifies power limitaton in 0.25dbm */ 1742 s32 power = sar->sub_specs[i].power >> 1; 1743 1744 if (power > 127 || power < -127) 1745 power = 127; 1746 1747 phy->frp[index].range = &capa->freq_ranges[index]; 1748 phy->frp[index].power = power; 1749 } 1750 1751 return 0; 1752 } 1753 EXPORT_SYMBOL_GPL(mt76_init_sar_power); 1754 1755 int mt76_get_sar_power(struct mt76_phy *phy, 1756 struct ieee80211_channel *chan, 1757 int power) 1758 { 1759 const struct cfg80211_sar_capa *capa = phy->hw->wiphy->sar_capa; 1760 int freq, i; 1761 1762 if (!capa || !phy->frp) 1763 return power; 1764 1765 if (power > 127 || power < -127) 1766 power = 127; 1767 1768 freq = ieee80211_channel_to_frequency(chan->hw_value, chan->band); 1769 for (i = 0 ; i < capa->num_freq_ranges; i++) { 1770 if (phy->frp[i].range && 1771 freq >= phy->frp[i].range->start_freq && 1772 freq < phy->frp[i].range->end_freq) { 1773 power = min_t(int, phy->frp[i].power, power); 1774 break; 1775 } 1776 } 1777 1778 return power; 1779 } 1780 EXPORT_SYMBOL_GPL(mt76_get_sar_power); 1781 1782 static void 1783 __mt76_csa_finish(void *priv, u8 *mac, struct ieee80211_vif *vif) 1784 { 1785 if (vif->bss_conf.csa_active && ieee80211_beacon_cntdwn_is_complete(vif, 0)) 1786 ieee80211_csa_finish(vif, 0); 1787 } 1788 1789 void mt76_csa_finish(struct mt76_dev *dev) 1790 { 1791 if (!dev->csa_complete) 1792 return; 1793 1794 ieee80211_iterate_active_interfaces_atomic(dev->hw, 1795 IEEE80211_IFACE_ITER_RESUME_ALL, 1796 __mt76_csa_finish, dev); 1797 1798 dev->csa_complete = 0; 1799 } 1800 EXPORT_SYMBOL_GPL(mt76_csa_finish); 1801 1802 static void 1803 __mt76_csa_check(void *priv, u8 *mac, struct ieee80211_vif *vif) 1804 { 1805 struct mt76_dev *dev = priv; 1806 1807 if (!vif->bss_conf.csa_active) 1808 return; 1809 1810 dev->csa_complete |= ieee80211_beacon_cntdwn_is_complete(vif, 0); 1811 } 1812 1813 void mt76_csa_check(struct mt76_dev *dev) 1814 { 1815 ieee80211_iterate_active_interfaces_atomic(dev->hw, 1816 IEEE80211_IFACE_ITER_RESUME_ALL, 1817 __mt76_csa_check, dev); 1818 } 1819 EXPORT_SYMBOL_GPL(mt76_csa_check); 1820 1821 int 1822 mt76_set_tim(struct ieee80211_hw *hw, struct ieee80211_sta *sta, bool set) 1823 { 1824 return 0; 1825 } 1826 EXPORT_SYMBOL_GPL(mt76_set_tim); 1827 1828 void mt76_insert_ccmp_hdr(struct sk_buff *skb, u8 key_id) 1829 { 1830 struct mt76_rx_status *status = (struct mt76_rx_status *)skb->cb; 1831 int hdr_len = ieee80211_get_hdrlen_from_skb(skb); 1832 u8 *hdr, *pn = status->iv; 1833 1834 __skb_push(skb, 8); 1835 memmove(skb->data, skb->data + 8, hdr_len); 1836 hdr = skb->data + hdr_len; 1837 1838 hdr[0] = pn[5]; 1839 hdr[1] = pn[4]; 1840 hdr[2] = 0; 1841 hdr[3] = 0x20 | (key_id << 6); 1842 hdr[4] = pn[3]; 1843 hdr[5] = pn[2]; 1844 hdr[6] = pn[1]; 1845 hdr[7] = pn[0]; 1846 1847 status->flag &= ~RX_FLAG_IV_STRIPPED; 1848 } 1849 EXPORT_SYMBOL_GPL(mt76_insert_ccmp_hdr); 1850 1851 int mt76_get_rate(struct mt76_dev *dev, 1852 struct ieee80211_supported_band *sband, 1853 int idx, bool cck) 1854 { 1855 bool is_2g = sband->band == NL80211_BAND_2GHZ; 1856 int i, offset = 0, len = sband->n_bitrates; 1857 1858 if (cck) { 1859 if (!is_2g) 1860 return 0; 1861 1862 idx &= ~BIT(2); /* short preamble */ 1863 } else if (is_2g) { 1864 offset = 4; 1865 } 1866 1867 for (i = offset; i < len; i++) { 1868 if ((sband->bitrates[i].hw_value & GENMASK(7, 0)) == idx) 1869 return i; 1870 } 1871 1872 return 0; 1873 } 1874 EXPORT_SYMBOL_GPL(mt76_get_rate); 1875 1876 void mt76_sw_scan(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 1877 const u8 *mac) 1878 { 1879 struct mt76_phy *phy = hw->priv; 1880 1881 set_bit(MT76_SCANNING, &phy->state); 1882 } 1883 EXPORT_SYMBOL_GPL(mt76_sw_scan); 1884 1885 void mt76_sw_scan_complete(struct ieee80211_hw *hw, struct ieee80211_vif *vif) 1886 { 1887 struct mt76_phy *phy = hw->priv; 1888 1889 clear_bit(MT76_SCANNING, &phy->state); 1890 } 1891 EXPORT_SYMBOL_GPL(mt76_sw_scan_complete); 1892 1893 int mt76_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant) 1894 { 1895 struct mt76_phy *phy = hw->priv; 1896 struct mt76_dev *dev = phy->dev; 1897 int i; 1898 1899 mutex_lock(&dev->mutex); 1900 *tx_ant = 0; 1901 for (i = 0; i < ARRAY_SIZE(dev->phys); i++) 1902 if (dev->phys[i] && dev->phys[i]->hw == hw) 1903 *tx_ant |= dev->phys[i]->chainmask; 1904 *rx_ant = *tx_ant; 1905 mutex_unlock(&dev->mutex); 1906 1907 return 0; 1908 } 1909 EXPORT_SYMBOL_GPL(mt76_get_antenna); 1910 1911 struct mt76_queue * 1912 mt76_init_queue(struct mt76_dev *dev, int qid, int idx, int n_desc, 1913 int ring_base, void *wed, u32 flags) 1914 { 1915 struct mt76_queue *hwq; 1916 int err; 1917 1918 hwq = devm_kzalloc(dev->dev, sizeof(*hwq), GFP_KERNEL); 1919 if (!hwq) 1920 return ERR_PTR(-ENOMEM); 1921 1922 hwq->flags = flags; 1923 hwq->wed = wed; 1924 1925 err = dev->queue_ops->alloc(dev, hwq, idx, n_desc, 0, ring_base); 1926 if (err < 0) 1927 return ERR_PTR(err); 1928 1929 return hwq; 1930 } 1931 EXPORT_SYMBOL_GPL(mt76_init_queue); 1932 1933 void mt76_ethtool_worker(struct mt76_ethtool_worker_info *wi, 1934 struct mt76_sta_stats *stats, bool eht) 1935 { 1936 int i, ei = wi->initial_stat_idx; 1937 u64 *data = wi->data; 1938 1939 wi->sta_count++; 1940 1941 data[ei++] += stats->tx_mode[MT_PHY_TYPE_CCK]; 1942 data[ei++] += stats->tx_mode[MT_PHY_TYPE_OFDM]; 1943 data[ei++] += stats->tx_mode[MT_PHY_TYPE_HT]; 1944 data[ei++] += stats->tx_mode[MT_PHY_TYPE_HT_GF]; 1945 data[ei++] += stats->tx_mode[MT_PHY_TYPE_VHT]; 1946 data[ei++] += stats->tx_mode[MT_PHY_TYPE_HE_SU]; 1947 data[ei++] += stats->tx_mode[MT_PHY_TYPE_HE_EXT_SU]; 1948 data[ei++] += stats->tx_mode[MT_PHY_TYPE_HE_TB]; 1949 data[ei++] += stats->tx_mode[MT_PHY_TYPE_HE_MU]; 1950 if (eht) { 1951 data[ei++] += stats->tx_mode[MT_PHY_TYPE_EHT_SU]; 1952 data[ei++] += stats->tx_mode[MT_PHY_TYPE_EHT_TRIG]; 1953 data[ei++] += stats->tx_mode[MT_PHY_TYPE_EHT_MU]; 1954 } 1955 1956 for (i = 0; i < (ARRAY_SIZE(stats->tx_bw) - !eht); i++) 1957 data[ei++] += stats->tx_bw[i]; 1958 1959 for (i = 0; i < (eht ? 14 : 12); i++) 1960 data[ei++] += stats->tx_mcs[i]; 1961 1962 for (i = 0; i < 4; i++) 1963 data[ei++] += stats->tx_nss[i]; 1964 1965 wi->worker_stat_count = ei - wi->initial_stat_idx; 1966 } 1967 EXPORT_SYMBOL_GPL(mt76_ethtool_worker); 1968 1969 void mt76_ethtool_page_pool_stats(struct mt76_dev *dev, u64 *data, int *index) 1970 { 1971 #ifdef CONFIG_PAGE_POOL_STATS 1972 struct page_pool_stats stats = {}; 1973 int i; 1974 1975 mt76_for_each_q_rx(dev, i) 1976 page_pool_get_stats(dev->q_rx[i].page_pool, &stats); 1977 1978 page_pool_ethtool_stats_get(data, &stats); 1979 *index += page_pool_ethtool_stats_get_count(); 1980 #endif 1981 } 1982 EXPORT_SYMBOL_GPL(mt76_ethtool_page_pool_stats); 1983 1984 enum mt76_dfs_state mt76_phy_dfs_state(struct mt76_phy *phy) 1985 { 1986 struct ieee80211_hw *hw = phy->hw; 1987 struct mt76_dev *dev = phy->dev; 1988 1989 if (dev->region == NL80211_DFS_UNSET || 1990 test_bit(MT76_SCANNING, &phy->state)) 1991 return MT_DFS_STATE_DISABLED; 1992 1993 if (!phy->radar_enabled) { 1994 if ((hw->conf.flags & IEEE80211_CONF_MONITOR) && 1995 (phy->chandef.chan->flags & IEEE80211_CHAN_RADAR)) 1996 return MT_DFS_STATE_ACTIVE; 1997 1998 return MT_DFS_STATE_DISABLED; 1999 } 2000 2001 if (!cfg80211_reg_can_beacon(hw->wiphy, &phy->chandef, NL80211_IFTYPE_AP)) 2002 return MT_DFS_STATE_CAC; 2003 2004 return MT_DFS_STATE_ACTIVE; 2005 } 2006 EXPORT_SYMBOL_GPL(mt76_phy_dfs_state); 2007 2008 void mt76_vif_cleanup(struct mt76_dev *dev, struct ieee80211_vif *vif) 2009 { 2010 struct mt76_vif_link *mlink = (struct mt76_vif_link *)vif->drv_priv; 2011 struct mt76_vif_data *mvif = mlink->mvif; 2012 2013 rcu_assign_pointer(mvif->link[0], NULL); 2014 mt76_abort_scan(dev); 2015 if (mvif->roc_phy) 2016 mt76_abort_roc(mvif->roc_phy); 2017 } 2018 EXPORT_SYMBOL_GPL(mt76_vif_cleanup); 2019