1 // SPDX-License-Identifier: BSD-3-Clause-Clear 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_AP_MODE_CHAN_WIDTH_CHANGE; 443 if (!phy->no_active_monitor) 444 wiphy->features |= NL80211_FEATURE_ACTIVE_MONITOR; 445 wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH | 446 WIPHY_FLAG_SUPPORTS_TDLS | 447 WIPHY_FLAG_AP_UAPSD; 448 449 wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_CQM_RSSI_LIST); 450 wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_AIRTIME_FAIRNESS); 451 wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_AQL); 452 453 if (!wiphy->max_remain_on_channel_duration) 454 wiphy->max_remain_on_channel_duration = 5000; 455 if (!wiphy->available_antennas_tx) 456 wiphy->available_antennas_tx = phy->antenna_mask; 457 if (!wiphy->available_antennas_rx) 458 wiphy->available_antennas_rx = phy->antenna_mask; 459 460 wiphy->sar_capa = &mt76_sar_capa; 461 phy->frp = devm_kcalloc(dev->dev, wiphy->sar_capa->num_freq_ranges, 462 sizeof(struct mt76_freq_range_power), 463 GFP_KERNEL); 464 if (!phy->frp) 465 return -ENOMEM; 466 467 hw->txq_data_size = sizeof(struct mt76_txq); 468 hw->uapsd_max_sp_len = IEEE80211_WMM_IE_STA_QOSINFO_SP_ALL; 469 470 if (!hw->max_tx_fragments) 471 hw->max_tx_fragments = 16; 472 473 ieee80211_hw_set(hw, SIGNAL_DBM); 474 ieee80211_hw_set(hw, AMPDU_AGGREGATION); 475 ieee80211_hw_set(hw, SUPPORTS_RC_TABLE); 476 ieee80211_hw_set(hw, SUPPORT_FAST_XMIT); 477 ieee80211_hw_set(hw, SUPPORTS_CLONED_SKBS); 478 ieee80211_hw_set(hw, SUPPORTS_AMSDU_IN_AMPDU); 479 ieee80211_hw_set(hw, SUPPORTS_REORDERING_BUFFER); 480 ieee80211_hw_set(hw, SPECTRUM_MGMT); 481 482 if (!(dev->drv->drv_flags & MT_DRV_AMSDU_OFFLOAD) && 483 hw->max_tx_fragments > 1) { 484 ieee80211_hw_set(hw, TX_AMSDU); 485 ieee80211_hw_set(hw, TX_FRAG_LIST); 486 } 487 488 ieee80211_hw_set(hw, MFP_CAPABLE); 489 ieee80211_hw_set(hw, AP_LINK_PS); 490 ieee80211_hw_set(hw, REPORTS_TX_ACK_STATUS); 491 492 return 0; 493 } 494 495 struct mt76_phy * 496 mt76_alloc_radio_phy(struct mt76_dev *dev, unsigned int size, 497 u8 band_idx) 498 { 499 struct ieee80211_hw *hw = dev->phy.hw; 500 unsigned int phy_size; 501 struct mt76_phy *phy; 502 503 phy_size = ALIGN(sizeof(*phy), 8); 504 phy = devm_kzalloc(dev->dev, size + phy_size, GFP_KERNEL); 505 if (!phy) 506 return NULL; 507 508 phy->dev = dev; 509 phy->hw = hw; 510 phy->priv = (void *)phy + phy_size; 511 phy->band_idx = band_idx; 512 513 return phy; 514 } 515 EXPORT_SYMBOL_GPL(mt76_alloc_radio_phy); 516 517 struct mt76_phy * 518 mt76_alloc_phy(struct mt76_dev *dev, unsigned int size, 519 const struct ieee80211_ops *ops, u8 band_idx) 520 { 521 struct ieee80211_hw *hw; 522 unsigned int phy_size; 523 struct mt76_phy *phy; 524 525 phy_size = ALIGN(sizeof(*phy), 8); 526 hw = ieee80211_alloc_hw(size + phy_size, ops); 527 if (!hw) 528 return NULL; 529 530 phy = hw->priv; 531 phy->dev = dev; 532 phy->hw = hw; 533 phy->priv = hw->priv + phy_size; 534 phy->band_idx = band_idx; 535 536 hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN; 537 hw->wiphy->interface_modes = 538 BIT(NL80211_IFTYPE_STATION) | 539 BIT(NL80211_IFTYPE_AP) | 540 #ifdef CONFIG_MAC80211_MESH 541 BIT(NL80211_IFTYPE_MESH_POINT) | 542 #endif 543 BIT(NL80211_IFTYPE_P2P_CLIENT) | 544 BIT(NL80211_IFTYPE_P2P_GO) | 545 BIT(NL80211_IFTYPE_ADHOC); 546 547 return phy; 548 } 549 EXPORT_SYMBOL_GPL(mt76_alloc_phy); 550 551 int mt76_register_phy(struct mt76_phy *phy, bool vht, 552 struct ieee80211_rate *rates, int n_rates) 553 { 554 int ret; 555 556 ret = mt76_phy_init(phy, phy->hw); 557 if (ret) 558 return ret; 559 560 if (phy->cap.has_2ghz) { 561 ret = mt76_init_sband_2g(phy, rates, n_rates); 562 if (ret) 563 return ret; 564 } 565 566 if (phy->cap.has_5ghz) { 567 ret = mt76_init_sband_5g(phy, rates + 4, n_rates - 4, vht); 568 if (ret) 569 return ret; 570 } 571 572 if (phy->cap.has_6ghz) { 573 ret = mt76_init_sband_6g(phy, rates + 4, n_rates - 4); 574 if (ret) 575 return ret; 576 } 577 578 if (IS_ENABLED(CONFIG_MT76_LEDS)) { 579 ret = mt76_led_init(phy); 580 if (ret) 581 return ret; 582 } 583 584 wiphy_read_of_freq_limits(phy->hw->wiphy); 585 mt76_check_sband(phy, &phy->sband_2g, NL80211_BAND_2GHZ); 586 mt76_check_sband(phy, &phy->sband_5g, NL80211_BAND_5GHZ); 587 mt76_check_sband(phy, &phy->sband_6g, NL80211_BAND_6GHZ); 588 589 if ((void *)phy == phy->hw->priv) { 590 ret = ieee80211_register_hw(phy->hw); 591 if (ret) 592 return ret; 593 } 594 595 set_bit(MT76_STATE_REGISTERED, &phy->state); 596 phy->dev->phys[phy->band_idx] = phy; 597 598 return 0; 599 } 600 EXPORT_SYMBOL_GPL(mt76_register_phy); 601 602 void mt76_unregister_phy(struct mt76_phy *phy) 603 { 604 struct mt76_dev *dev = phy->dev; 605 606 if (!test_bit(MT76_STATE_REGISTERED, &phy->state)) 607 return; 608 609 if (IS_ENABLED(CONFIG_MT76_LEDS)) 610 mt76_led_cleanup(phy); 611 mt76_tx_status_check(dev, true); 612 ieee80211_unregister_hw(phy->hw); 613 dev->phys[phy->band_idx] = NULL; 614 } 615 EXPORT_SYMBOL_GPL(mt76_unregister_phy); 616 617 int mt76_create_page_pool(struct mt76_dev *dev, struct mt76_queue *q) 618 { 619 bool is_qrx = mt76_queue_is_rx(dev, q); 620 struct page_pool_params pp_params = { 621 .order = 0, 622 .flags = 0, 623 .nid = NUMA_NO_NODE, 624 .dev = dev->dma_dev, 625 }; 626 int idx = is_qrx ? q - dev->q_rx : -1; 627 628 /* Allocate page_pools just for rx/wed_tx_free queues */ 629 if (!is_qrx && !mt76_queue_is_wed_tx_free(q)) 630 return 0; 631 632 switch (idx) { 633 case MT_RXQ_MAIN: 634 case MT_RXQ_BAND1: 635 case MT_RXQ_BAND2: 636 case MT_RXQ_NPU0: 637 case MT_RXQ_NPU1: 638 pp_params.pool_size = 256; 639 break; 640 default: 641 pp_params.pool_size = 16; 642 break; 643 } 644 645 if (mt76_is_mmio(dev)) { 646 /* rely on page_pool for DMA mapping */ 647 pp_params.flags |= PP_FLAG_DMA_MAP | PP_FLAG_DMA_SYNC_DEV; 648 pp_params.dma_dir = DMA_FROM_DEVICE; 649 pp_params.max_len = PAGE_SIZE; 650 pp_params.offset = 0; 651 /* NAPI is available just for rx queues */ 652 if (idx >= 0 && idx < ARRAY_SIZE(dev->napi)) 653 pp_params.napi = &dev->napi[idx]; 654 } 655 656 q->page_pool = page_pool_create(&pp_params); 657 if (IS_ERR(q->page_pool)) { 658 int err = PTR_ERR(q->page_pool); 659 660 q->page_pool = NULL; 661 return err; 662 } 663 664 return 0; 665 } 666 EXPORT_SYMBOL_GPL(mt76_create_page_pool); 667 668 struct mt76_dev * 669 mt76_alloc_device(struct device *pdev, unsigned int size, 670 const struct ieee80211_ops *ops, 671 const struct mt76_driver_ops *drv_ops) 672 { 673 struct ieee80211_hw *hw; 674 struct mt76_phy *phy; 675 struct mt76_dev *dev; 676 int i; 677 678 hw = ieee80211_alloc_hw(size, ops); 679 if (!hw) 680 return NULL; 681 682 dev = hw->priv; 683 dev->hw = hw; 684 dev->dev = pdev; 685 dev->init_wiphy = NULL; 686 dev->drv = drv_ops; 687 dev->dma_dev = pdev; 688 689 phy = &dev->phy; 690 phy->dev = dev; 691 phy->hw = hw; 692 phy->band_idx = MT_BAND0; 693 dev->phys[phy->band_idx] = phy; 694 695 spin_lock_init(&dev->rx_lock); 696 spin_lock_init(&dev->lock); 697 spin_lock_init(&dev->cc_lock); 698 spin_lock_init(&dev->status_lock); 699 spin_lock_init(&dev->wed_lock); 700 mutex_init(&dev->mutex); 701 init_waitqueue_head(&dev->tx_wait); 702 703 skb_queue_head_init(&dev->mcu.res_q); 704 init_waitqueue_head(&dev->mcu.wait); 705 mutex_init(&dev->mcu.mutex); 706 dev->tx_worker.fn = mt76_tx_worker; 707 708 hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN; 709 hw->wiphy->interface_modes = 710 BIT(NL80211_IFTYPE_STATION) | 711 BIT(NL80211_IFTYPE_AP) | 712 #ifdef CONFIG_MAC80211_MESH 713 BIT(NL80211_IFTYPE_MESH_POINT) | 714 #endif 715 BIT(NL80211_IFTYPE_P2P_CLIENT) | 716 BIT(NL80211_IFTYPE_P2P_GO) | 717 BIT(NL80211_IFTYPE_ADHOC); 718 719 spin_lock_init(&dev->token_lock); 720 idr_init(&dev->token); 721 722 spin_lock_init(&dev->rx_token_lock); 723 idr_init(&dev->rx_token); 724 725 INIT_LIST_HEAD(&dev->wcid_list); 726 INIT_LIST_HEAD(&dev->sta_poll_list); 727 spin_lock_init(&dev->sta_poll_lock); 728 729 INIT_LIST_HEAD(&dev->txwi_cache); 730 INIT_LIST_HEAD(&dev->rxwi_cache); 731 dev->token_size = dev->drv->token_size; 732 INIT_DELAYED_WORK(&dev->scan_work, mt76_scan_work); 733 spin_lock_init(&dev->scan_lock); 734 735 for (i = 0; i < ARRAY_SIZE(dev->q_rx); i++) 736 skb_queue_head_init(&dev->rx_skb[i]); 737 738 dev->wq = alloc_ordered_workqueue("mt76", 0); 739 if (!dev->wq) { 740 ieee80211_free_hw(hw); 741 return NULL; 742 } 743 744 return dev; 745 } 746 EXPORT_SYMBOL_GPL(mt76_alloc_device); 747 748 int mt76_register_device(struct mt76_dev *dev, bool vht, 749 struct ieee80211_rate *rates, int n_rates) 750 { 751 struct ieee80211_hw *hw = dev->hw; 752 struct mt76_phy *phy = &dev->phy; 753 int ret; 754 755 dev_set_drvdata(dev->dev, dev); 756 mt76_wcid_init(&dev->global_wcid, phy->band_idx); 757 ret = mt76_phy_init(phy, hw); 758 if (ret) 759 return ret; 760 761 if (phy->cap.has_2ghz) { 762 ret = mt76_init_sband_2g(phy, rates, n_rates); 763 if (ret) 764 return ret; 765 } 766 767 if (phy->cap.has_5ghz) { 768 ret = mt76_init_sband_5g(phy, rates + 4, n_rates - 4, vht); 769 if (ret) 770 return ret; 771 } 772 773 if (phy->cap.has_6ghz) { 774 ret = mt76_init_sband_6g(phy, rates + 4, n_rates - 4); 775 if (ret) 776 return ret; 777 } 778 779 wiphy_read_of_freq_limits(hw->wiphy); 780 mt76_check_sband(&dev->phy, &phy->sband_2g, NL80211_BAND_2GHZ); 781 mt76_check_sband(&dev->phy, &phy->sband_5g, NL80211_BAND_5GHZ); 782 mt76_check_sband(&dev->phy, &phy->sband_6g, NL80211_BAND_6GHZ); 783 784 if (dev->init_wiphy) { 785 ret = dev->init_wiphy(dev); 786 if (ret) 787 return ret; 788 } 789 790 if (IS_ENABLED(CONFIG_MT76_LEDS)) { 791 ret = mt76_led_init(phy); 792 if (ret) 793 return ret; 794 } 795 796 ret = ieee80211_register_hw(hw); 797 if (ret) 798 return ret; 799 800 WARN_ON(mt76_worker_setup(hw, &dev->tx_worker, NULL, "tx")); 801 set_bit(MT76_STATE_REGISTERED, &phy->state); 802 sched_set_fifo_low(dev->tx_worker.task); 803 804 return 0; 805 } 806 EXPORT_SYMBOL_GPL(mt76_register_device); 807 808 void mt76_unregister_device(struct mt76_dev *dev) 809 { 810 struct ieee80211_hw *hw = dev->hw; 811 812 if (!test_bit(MT76_STATE_REGISTERED, &dev->phy.state)) 813 return; 814 815 if (IS_ENABLED(CONFIG_MT76_LEDS)) 816 mt76_led_cleanup(&dev->phy); 817 mt76_tx_status_check(dev, true); 818 mt76_wcid_cleanup(dev, &dev->global_wcid); 819 ieee80211_unregister_hw(hw); 820 } 821 EXPORT_SYMBOL_GPL(mt76_unregister_device); 822 823 void mt76_free_device(struct mt76_dev *dev) 824 { 825 mt76_worker_teardown(&dev->tx_worker); 826 if (dev->wq) { 827 destroy_workqueue(dev->wq); 828 dev->wq = NULL; 829 } 830 mt76_npu_deinit(dev); 831 ieee80211_free_hw(dev->hw); 832 } 833 EXPORT_SYMBOL_GPL(mt76_free_device); 834 835 static void mt76_reset_phy(struct mt76_phy *phy) 836 { 837 if (!phy) 838 return; 839 840 INIT_LIST_HEAD(&phy->tx_list); 841 phy->num_sta = 0; 842 phy->chanctx = NULL; 843 mt76_roc_complete(phy); 844 } 845 846 void mt76_reset_device(struct mt76_dev *dev) 847 { 848 int i; 849 850 rcu_read_lock(); 851 for (i = 0; i < ARRAY_SIZE(dev->wcid); i++) { 852 struct mt76_wcid *wcid; 853 854 wcid = rcu_dereference(dev->wcid[i]); 855 if (!wcid) 856 continue; 857 858 wcid->sta = 0; 859 mt76_wcid_cleanup(dev, wcid); 860 rcu_assign_pointer(dev->wcid[i], NULL); 861 } 862 rcu_read_unlock(); 863 864 INIT_LIST_HEAD(&dev->wcid_list); 865 INIT_LIST_HEAD(&dev->sta_poll_list); 866 dev->vif_mask = 0; 867 memset(dev->wcid_mask, 0, sizeof(dev->wcid_mask)); 868 869 mt76_reset_phy(&dev->phy); 870 for (i = 0; i < ARRAY_SIZE(dev->phys); i++) 871 mt76_reset_phy(dev->phys[i]); 872 } 873 EXPORT_SYMBOL_GPL(mt76_reset_device); 874 875 struct mt76_phy *mt76_vif_phy(struct ieee80211_hw *hw, 876 struct ieee80211_vif *vif) 877 { 878 struct mt76_vif_link *mlink = (struct mt76_vif_link *)vif->drv_priv; 879 struct mt76_chanctx *ctx; 880 881 if (!hw->wiphy->n_radio) 882 return hw->priv; 883 884 if (!mlink->ctx) 885 return NULL; 886 887 ctx = (struct mt76_chanctx *)mlink->ctx->drv_priv; 888 return ctx->phy; 889 } 890 EXPORT_SYMBOL_GPL(mt76_vif_phy); 891 892 static void mt76_rx_release_amsdu(struct mt76_phy *phy, enum mt76_rxq_id q) 893 { 894 struct sk_buff *skb = phy->rx_amsdu[q].head; 895 struct mt76_rx_status *status = (struct mt76_rx_status *)skb->cb; 896 struct mt76_dev *dev = phy->dev; 897 struct mt76_queue *rxq = &dev->q_rx[q]; 898 899 phy->rx_amsdu[q].head = NULL; 900 phy->rx_amsdu[q].tail = NULL; 901 902 /* 903 * Validate if the amsdu has a proper first subframe. 904 * A single MSDU can be parsed as A-MSDU when the unauthenticated A-MSDU 905 * flag of the QoS header gets flipped. In such cases, the first 906 * subframe has a LLC/SNAP header in the location of the destination 907 * address. 908 */ 909 if (skb_shinfo(skb)->frag_list) { 910 int offset = 0; 911 912 if (!(status->flag & RX_FLAG_8023)) { 913 offset = ieee80211_get_hdrlen_from_skb(skb); 914 915 if ((status->flag & 916 (RX_FLAG_DECRYPTED | RX_FLAG_IV_STRIPPED)) == 917 RX_FLAG_DECRYPTED) 918 offset += 8; 919 } 920 921 if (ether_addr_equal(skb->data + offset, rfc1042_header)) { 922 dev_kfree_skb(skb); 923 return; 924 } 925 } 926 927 /* RRO 3.0 data queue skbs are processed and completed in the context 928 * of the indicator queue NAPI, which only polls its own skb list 929 */ 930 if (mt76_queue_is_wed_rro_data(rxq) && dev->hwrro_mode == MT76_HWRRO_V3) 931 q = MT_RXQ_RRO_IND; 932 933 __skb_queue_tail(&dev->rx_skb[q], skb); 934 } 935 936 static void mt76_rx_release_burst(struct mt76_phy *phy, enum mt76_rxq_id q, 937 struct sk_buff *skb) 938 { 939 struct mt76_rx_status *status = (struct mt76_rx_status *)skb->cb; 940 941 if (phy->rx_amsdu[q].head && 942 (!status->amsdu || status->first_amsdu || 943 status->seqno != phy->rx_amsdu[q].seqno)) 944 mt76_rx_release_amsdu(phy, q); 945 946 if (!phy->rx_amsdu[q].head) { 947 phy->rx_amsdu[q].tail = &skb_shinfo(skb)->frag_list; 948 phy->rx_amsdu[q].seqno = status->seqno; 949 phy->rx_amsdu[q].head = skb; 950 } else { 951 *phy->rx_amsdu[q].tail = skb; 952 phy->rx_amsdu[q].tail = &skb->next; 953 } 954 955 if (!status->amsdu || status->last_amsdu) 956 mt76_rx_release_amsdu(phy, q); 957 } 958 959 void mt76_rx(struct mt76_dev *dev, enum mt76_rxq_id q, struct sk_buff *skb) 960 { 961 struct mt76_rx_status *status = (struct mt76_rx_status *)skb->cb; 962 struct mt76_phy *phy = mt76_dev_phy(dev, status->phy_idx); 963 964 if (!test_bit(MT76_STATE_RUNNING, &phy->state)) { 965 dev_kfree_skb(skb); 966 return; 967 } 968 969 #ifdef CONFIG_NL80211_TESTMODE 970 if (phy->test.state == MT76_TM_STATE_RX_FRAMES) { 971 phy->test.rx_stats.packets[q]++; 972 if (status->flag & RX_FLAG_FAILED_FCS_CRC) 973 phy->test.rx_stats.fcs_error[q]++; 974 } 975 #endif 976 977 mt76_rx_release_burst(phy, q, skb); 978 } 979 EXPORT_SYMBOL_GPL(mt76_rx); 980 981 bool mt76_has_tx_pending(struct mt76_phy *phy) 982 { 983 struct mt76_queue *q; 984 int i; 985 986 for (i = 0; i < __MT_TXQ_MAX; i++) { 987 q = phy->q_tx[i]; 988 if (q && q->queued) 989 return true; 990 } 991 992 if (atomic_read(&phy->mgmt_tx_pending)) 993 return true; 994 995 return false; 996 } 997 EXPORT_SYMBOL_GPL(mt76_has_tx_pending); 998 999 static struct mt76_channel_state * 1000 mt76_channel_state(struct mt76_phy *phy, struct ieee80211_channel *c) 1001 { 1002 struct mt76_sband *msband; 1003 int idx; 1004 1005 if (c->band == NL80211_BAND_2GHZ) 1006 msband = &phy->sband_2g; 1007 else if (c->band == NL80211_BAND_6GHZ) 1008 msband = &phy->sband_6g; 1009 else 1010 msband = &phy->sband_5g; 1011 1012 idx = c - &msband->sband.channels[0]; 1013 return &msband->chan[idx]; 1014 } 1015 1016 void mt76_update_survey_active_time(struct mt76_phy *phy, ktime_t time) 1017 { 1018 struct mt76_channel_state *state = phy->chan_state; 1019 1020 state->cc_active += ktime_to_us(ktime_sub(time, 1021 phy->survey_time)); 1022 phy->survey_time = time; 1023 } 1024 EXPORT_SYMBOL_GPL(mt76_update_survey_active_time); 1025 1026 void mt76_update_survey(struct mt76_phy *phy) 1027 { 1028 struct mt76_dev *dev = phy->dev; 1029 ktime_t cur_time; 1030 1031 if (dev->drv->update_survey) 1032 dev->drv->update_survey(phy); 1033 1034 cur_time = ktime_get_boottime(); 1035 mt76_update_survey_active_time(phy, cur_time); 1036 1037 if (dev->drv->drv_flags & MT_DRV_SW_RX_AIRTIME) { 1038 struct mt76_channel_state *state = phy->chan_state; 1039 1040 spin_lock_bh(&dev->cc_lock); 1041 state->cc_bss_rx += dev->cur_cc_bss_rx; 1042 dev->cur_cc_bss_rx = 0; 1043 spin_unlock_bh(&dev->cc_lock); 1044 } 1045 } 1046 EXPORT_SYMBOL_GPL(mt76_update_survey); 1047 1048 int __mt76_set_channel(struct mt76_phy *phy, struct cfg80211_chan_def *chandef, 1049 bool offchannel) 1050 { 1051 struct mt76_dev *dev = phy->dev; 1052 int timeout = HZ / 5; 1053 int ret; 1054 1055 mt76_worker_disable(&dev->tx_worker); 1056 mt76_txq_schedule_pending(phy); 1057 1058 set_bit(MT76_RESET, &phy->state); 1059 wait_event_timeout(dev->tx_wait, !mt76_has_tx_pending(phy), timeout); 1060 mt76_update_survey(phy); 1061 1062 if (phy->chandef.chan->center_freq != chandef->chan->center_freq || 1063 phy->chandef.width != chandef->width) 1064 phy->dfs_state = MT_DFS_STATE_UNKNOWN; 1065 1066 phy->chandef = *chandef; 1067 phy->chan_state = mt76_channel_state(phy, chandef->chan); 1068 phy->offchannel = offchannel; 1069 1070 if (!offchannel) 1071 phy->main_chandef = *chandef; 1072 1073 if (chandef->chan != phy->main_chandef.chan) 1074 memset(phy->chan_state, 0, sizeof(*phy->chan_state)); 1075 1076 ret = dev->drv->set_channel(phy); 1077 1078 clear_bit(MT76_RESET, &phy->state); 1079 mt76_worker_enable(&dev->tx_worker); 1080 mt76_worker_schedule(&dev->tx_worker); 1081 1082 return ret; 1083 } 1084 1085 int mt76_set_channel(struct mt76_phy *phy, struct cfg80211_chan_def *chandef, 1086 bool offchannel) 1087 { 1088 struct mt76_dev *dev = phy->dev; 1089 int ret; 1090 1091 cancel_delayed_work_sync(&phy->mac_work); 1092 1093 mutex_lock(&dev->mutex); 1094 ret = __mt76_set_channel(phy, chandef, offchannel); 1095 mutex_unlock(&dev->mutex); 1096 1097 return ret; 1098 } 1099 1100 int mt76_update_channel(struct mt76_phy *phy) 1101 { 1102 struct ieee80211_hw *hw = phy->hw; 1103 struct cfg80211_chan_def *chandef = &hw->conf.chandef; 1104 bool offchannel = hw->conf.flags & IEEE80211_CONF_OFFCHANNEL; 1105 1106 phy->radar_enabled = hw->conf.radar_enabled; 1107 1108 return mt76_set_channel(phy, chandef, offchannel); 1109 } 1110 EXPORT_SYMBOL_GPL(mt76_update_channel); 1111 1112 static struct mt76_sband * 1113 mt76_get_survey_sband(struct mt76_phy *phy, int *idx) 1114 { 1115 if (*idx < phy->sband_2g.sband.n_channels) 1116 return &phy->sband_2g; 1117 1118 *idx -= phy->sband_2g.sband.n_channels; 1119 if (*idx < phy->sband_5g.sband.n_channels) 1120 return &phy->sband_5g; 1121 1122 *idx -= phy->sband_5g.sband.n_channels; 1123 if (*idx < phy->sband_6g.sband.n_channels) 1124 return &phy->sband_6g; 1125 1126 *idx -= phy->sband_6g.sband.n_channels; 1127 return NULL; 1128 } 1129 1130 int mt76_get_survey(struct ieee80211_hw *hw, int idx, 1131 struct survey_info *survey) 1132 { 1133 struct mt76_phy *phy = hw->priv; 1134 struct mt76_dev *dev = phy->dev; 1135 struct mt76_sband *sband = NULL; 1136 struct ieee80211_channel *chan; 1137 struct mt76_channel_state *state; 1138 int phy_idx = 0; 1139 int ret = 0; 1140 1141 mutex_lock(&dev->mutex); 1142 1143 for (phy_idx = 0; phy_idx < ARRAY_SIZE(dev->phys); phy_idx++) { 1144 sband = NULL; 1145 phy = dev->phys[phy_idx]; 1146 if (!phy || phy->hw != hw) 1147 continue; 1148 1149 sband = mt76_get_survey_sband(phy, &idx); 1150 1151 if (idx == 0 && phy->dev->drv->update_survey) 1152 mt76_update_survey(phy); 1153 1154 if (sband || !hw->wiphy->n_radio) 1155 break; 1156 } 1157 1158 if (!sband) { 1159 ret = -ENOENT; 1160 goto out; 1161 } 1162 1163 chan = &sband->sband.channels[idx]; 1164 state = mt76_channel_state(phy, chan); 1165 1166 memset(survey, 0, sizeof(*survey)); 1167 survey->channel = chan; 1168 survey->filled = SURVEY_INFO_TIME | SURVEY_INFO_TIME_BUSY; 1169 survey->filled |= dev->drv->survey_flags; 1170 if (state->noise) 1171 survey->filled |= SURVEY_INFO_NOISE_DBM; 1172 1173 if (chan == phy->main_chandef.chan) { 1174 survey->filled |= SURVEY_INFO_IN_USE; 1175 1176 if (dev->drv->drv_flags & MT_DRV_SW_RX_AIRTIME) 1177 survey->filled |= SURVEY_INFO_TIME_BSS_RX; 1178 } 1179 1180 survey->time_busy = div_u64(state->cc_busy, 1000); 1181 survey->time_rx = div_u64(state->cc_rx, 1000); 1182 survey->time = div_u64(state->cc_active, 1000); 1183 survey->noise = state->noise; 1184 1185 spin_lock_bh(&dev->cc_lock); 1186 survey->time_bss_rx = div_u64(state->cc_bss_rx, 1000); 1187 survey->time_tx = div_u64(state->cc_tx, 1000); 1188 spin_unlock_bh(&dev->cc_lock); 1189 1190 out: 1191 mutex_unlock(&dev->mutex); 1192 1193 return ret; 1194 } 1195 EXPORT_SYMBOL_GPL(mt76_get_survey); 1196 1197 void mt76_wcid_key_setup(struct mt76_dev *dev, struct mt76_wcid *wcid, 1198 struct ieee80211_key_conf *key) 1199 { 1200 struct ieee80211_key_seq seq; 1201 int i; 1202 1203 wcid->rx_check_pn = false; 1204 1205 if (!key) 1206 return; 1207 1208 if (key->cipher != WLAN_CIPHER_SUITE_CCMP) 1209 return; 1210 1211 wcid->rx_check_pn = true; 1212 1213 /* data frame */ 1214 for (i = 0; i < IEEE80211_NUM_TIDS; i++) { 1215 ieee80211_get_key_rx_seq(key, i, &seq); 1216 memcpy(wcid->rx_key_pn[i], seq.ccmp.pn, sizeof(seq.ccmp.pn)); 1217 } 1218 1219 /* robust management frame */ 1220 ieee80211_get_key_rx_seq(key, -1, &seq); 1221 memcpy(wcid->rx_key_pn[i], seq.ccmp.pn, sizeof(seq.ccmp.pn)); 1222 1223 } 1224 EXPORT_SYMBOL(mt76_wcid_key_setup); 1225 1226 int mt76_rx_signal(u8 chain_mask, s8 *chain_signal) 1227 { 1228 int signal = -128; 1229 u8 chains; 1230 1231 for (chains = chain_mask; chains; chains >>= 1, chain_signal++) { 1232 int cur, diff; 1233 1234 cur = *chain_signal; 1235 if (!(chains & BIT(0)) || 1236 cur > 0) 1237 continue; 1238 1239 if (cur > signal) 1240 swap(cur, signal); 1241 1242 diff = signal - cur; 1243 if (diff == 0) 1244 signal += 3; 1245 else if (diff <= 2) 1246 signal += 2; 1247 else if (diff <= 6) 1248 signal += 1; 1249 } 1250 1251 return signal; 1252 } 1253 EXPORT_SYMBOL(mt76_rx_signal); 1254 1255 static void 1256 mt76_rx_convert(struct mt76_dev *dev, struct sk_buff *skb, 1257 struct ieee80211_hw **hw, 1258 struct ieee80211_sta **sta) 1259 { 1260 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb); 1261 struct ieee80211_hdr *hdr = mt76_skb_get_hdr(skb); 1262 struct mt76_rx_status mstat; 1263 1264 mstat = *((struct mt76_rx_status *)skb->cb); 1265 memset(status, 0, sizeof(*status)); 1266 1267 skb->priority = mstat.qos_ctl & IEEE80211_QOS_CTL_TID_MASK; 1268 1269 status->flag = mstat.flag; 1270 status->freq = mstat.freq; 1271 status->enc_flags = mstat.enc_flags; 1272 status->encoding = mstat.encoding; 1273 status->bw = mstat.bw; 1274 if (status->encoding == RX_ENC_EHT) { 1275 status->eht.ru = mstat.eht.ru; 1276 status->eht.gi = mstat.eht.gi; 1277 } else { 1278 status->he_ru = mstat.he_ru; 1279 status->he_gi = mstat.he_gi; 1280 status->he_dcm = mstat.he_dcm; 1281 } 1282 status->rate_idx = mstat.rate_idx; 1283 status->nss = mstat.nss; 1284 status->band = mstat.band; 1285 status->signal = mstat.signal; 1286 status->chains = mstat.chains; 1287 status->ampdu_reference = mstat.ampdu_ref; 1288 status->device_timestamp = mstat.timestamp; 1289 status->mactime = mstat.timestamp; 1290 status->signal = mt76_rx_signal(mstat.chains, mstat.chain_signal); 1291 if (status->signal <= -128) 1292 status->flag |= RX_FLAG_NO_SIGNAL_VAL; 1293 1294 if (ieee80211_is_beacon(hdr->frame_control) || 1295 ieee80211_is_probe_resp(hdr->frame_control)) 1296 status->boottime_ns = ktime_get_boottime_ns(); 1297 1298 BUILD_BUG_ON(sizeof(mstat) > sizeof(skb->cb)); 1299 BUILD_BUG_ON(sizeof(status->chain_signal) != 1300 sizeof(mstat.chain_signal)); 1301 memcpy(status->chain_signal, mstat.chain_signal, 1302 sizeof(mstat.chain_signal)); 1303 1304 if (mstat.wcid) { 1305 status->link_valid = mstat.wcid->link_valid; 1306 status->link_id = mstat.wcid->link_id; 1307 } 1308 1309 *sta = wcid_to_sta(mstat.wcid); 1310 *hw = mt76_phy_hw(dev, mstat.phy_idx); 1311 } 1312 1313 static void 1314 mt76_check_ccmp_pn(struct sk_buff *skb) 1315 { 1316 struct mt76_rx_status *status = (struct mt76_rx_status *)skb->cb; 1317 struct mt76_wcid *wcid = status->wcid; 1318 struct ieee80211_hdr *hdr; 1319 int security_idx; 1320 int ret; 1321 1322 if (!(status->flag & RX_FLAG_DECRYPTED)) 1323 return; 1324 1325 if (status->flag & RX_FLAG_ONLY_MONITOR) 1326 return; 1327 1328 if (!wcid || !wcid->rx_check_pn) 1329 return; 1330 1331 security_idx = status->qos_ctl & IEEE80211_QOS_CTL_TID_MASK; 1332 if (status->flag & RX_FLAG_8023) 1333 goto skip_hdr_check; 1334 1335 hdr = mt76_skb_get_hdr(skb); 1336 if (!(status->flag & RX_FLAG_IV_STRIPPED)) { 1337 /* 1338 * Validate the first fragment both here and in mac80211 1339 * All further fragments will be validated by mac80211 only. 1340 */ 1341 if (ieee80211_is_frag(hdr) && 1342 !ieee80211_is_first_frag(hdr->seq_ctrl)) 1343 return; 1344 } 1345 1346 /* IEEE 802.11-2020, 12.5.3.4.4 "PN and replay detection" c): 1347 * 1348 * the recipient shall maintain a single replay counter for received 1349 * individually addressed robust Management frames that are received 1350 * with the To DS subfield equal to 0, [...] 1351 */ 1352 if (ieee80211_is_mgmt(hdr->frame_control) && 1353 !ieee80211_has_tods(hdr->frame_control)) 1354 security_idx = IEEE80211_NUM_TIDS; 1355 1356 skip_hdr_check: 1357 BUILD_BUG_ON(sizeof(status->iv) != sizeof(wcid->rx_key_pn[0])); 1358 ret = memcmp(status->iv, wcid->rx_key_pn[security_idx], 1359 sizeof(status->iv)); 1360 if (ret <= 0) { 1361 status->flag |= RX_FLAG_ONLY_MONITOR; 1362 return; 1363 } 1364 1365 memcpy(wcid->rx_key_pn[security_idx], status->iv, sizeof(status->iv)); 1366 1367 if (status->flag & RX_FLAG_IV_STRIPPED) 1368 status->flag |= RX_FLAG_PN_VALIDATED; 1369 } 1370 1371 static void 1372 mt76_airtime_report(struct mt76_dev *dev, struct mt76_rx_status *status, 1373 int len) 1374 { 1375 struct mt76_wcid *wcid = status->wcid; 1376 struct ieee80211_rx_status info = { 1377 .enc_flags = status->enc_flags, 1378 .rate_idx = status->rate_idx, 1379 .encoding = status->encoding, 1380 .band = status->band, 1381 .nss = status->nss, 1382 .bw = status->bw, 1383 }; 1384 struct ieee80211_sta *sta; 1385 u32 airtime; 1386 u8 tidno = status->qos_ctl & IEEE80211_QOS_CTL_TID_MASK; 1387 1388 airtime = ieee80211_calc_rx_airtime(dev->hw, &info, len); 1389 spin_lock(&dev->cc_lock); 1390 dev->cur_cc_bss_rx += airtime; 1391 spin_unlock(&dev->cc_lock); 1392 1393 if (!wcid || !wcid->sta) 1394 return; 1395 1396 sta = container_of((void *)wcid, struct ieee80211_sta, drv_priv); 1397 ieee80211_sta_register_airtime(sta, tidno, 0, airtime); 1398 } 1399 1400 static void 1401 mt76_airtime_flush_ampdu(struct mt76_dev *dev) 1402 { 1403 struct mt76_wcid *wcid; 1404 int wcid_idx; 1405 1406 if (!dev->rx_ampdu_len) 1407 return; 1408 1409 wcid_idx = dev->rx_ampdu_status.wcid_idx; 1410 if (wcid_idx < ARRAY_SIZE(dev->wcid)) 1411 wcid = rcu_dereference(dev->wcid[wcid_idx]); 1412 else 1413 wcid = NULL; 1414 dev->rx_ampdu_status.wcid = wcid; 1415 1416 mt76_airtime_report(dev, &dev->rx_ampdu_status, dev->rx_ampdu_len); 1417 1418 dev->rx_ampdu_len = 0; 1419 dev->rx_ampdu_ref = 0; 1420 } 1421 1422 static void 1423 mt76_airtime_check(struct mt76_dev *dev, struct sk_buff *skb) 1424 { 1425 struct mt76_rx_status *status = (struct mt76_rx_status *)skb->cb; 1426 struct mt76_wcid *wcid = status->wcid; 1427 1428 if (!(dev->drv->drv_flags & MT_DRV_SW_RX_AIRTIME)) 1429 return; 1430 1431 if (!wcid || !wcid->sta) { 1432 struct ieee80211_hdr *hdr = mt76_skb_get_hdr(skb); 1433 1434 if (status->flag & RX_FLAG_8023) 1435 return; 1436 1437 if (!ether_addr_equal(hdr->addr1, dev->phy.macaddr)) 1438 return; 1439 1440 wcid = NULL; 1441 } 1442 1443 if (!(status->flag & RX_FLAG_AMPDU_DETAILS) || 1444 status->ampdu_ref != dev->rx_ampdu_ref) 1445 mt76_airtime_flush_ampdu(dev); 1446 1447 if (status->flag & RX_FLAG_AMPDU_DETAILS) { 1448 if (!dev->rx_ampdu_len || 1449 status->ampdu_ref != dev->rx_ampdu_ref) { 1450 dev->rx_ampdu_status = *status; 1451 dev->rx_ampdu_status.wcid_idx = wcid ? wcid->idx : 0xff; 1452 dev->rx_ampdu_ref = status->ampdu_ref; 1453 } 1454 1455 dev->rx_ampdu_len += skb->len; 1456 return; 1457 } 1458 1459 mt76_airtime_report(dev, status, skb->len); 1460 } 1461 1462 static void 1463 mt76_check_sta(struct mt76_dev *dev, struct sk_buff *skb) 1464 { 1465 struct mt76_rx_status *status = (struct mt76_rx_status *)skb->cb; 1466 struct ieee80211_hdr *hdr = mt76_skb_get_hdr(skb); 1467 struct ieee80211_sta *sta; 1468 struct ieee80211_hw *hw; 1469 struct mt76_wcid *wcid = status->wcid; 1470 u8 tidno = status->qos_ctl & IEEE80211_QOS_CTL_TID_MASK; 1471 bool ps; 1472 1473 hw = mt76_phy_hw(dev, status->phy_idx); 1474 if (ieee80211_is_pspoll(hdr->frame_control) && !wcid && 1475 !(status->flag & RX_FLAG_8023)) { 1476 sta = ieee80211_find_sta_by_ifaddr(hw, hdr->addr2, NULL); 1477 if (sta) 1478 wcid = status->wcid = (struct mt76_wcid *)sta->drv_priv; 1479 } 1480 1481 mt76_airtime_check(dev, skb); 1482 1483 if (!wcid || !wcid->sta) 1484 return; 1485 1486 sta = container_of((void *)wcid, struct ieee80211_sta, drv_priv); 1487 1488 if (status->signal <= 0) 1489 ewma_signal_add(&wcid->rssi, -status->signal); 1490 1491 wcid->inactive_count = 0; 1492 1493 if (status->flag & RX_FLAG_8023) 1494 return; 1495 1496 if (!test_bit(MT_WCID_FLAG_CHECK_PS, &wcid->flags)) 1497 return; 1498 1499 if (ieee80211_is_pspoll(hdr->frame_control)) { 1500 ieee80211_sta_pspoll(sta); 1501 return; 1502 } 1503 1504 if (ieee80211_has_morefrags(hdr->frame_control) || 1505 !(ieee80211_is_mgmt(hdr->frame_control) || 1506 ieee80211_is_data(hdr->frame_control))) 1507 return; 1508 1509 ps = ieee80211_has_pm(hdr->frame_control); 1510 1511 if (ps && (ieee80211_is_data_qos(hdr->frame_control) || 1512 ieee80211_is_qos_nullfunc(hdr->frame_control))) 1513 ieee80211_sta_uapsd_trigger(sta, tidno); 1514 1515 if (!!test_bit(MT_WCID_FLAG_PS, &wcid->flags) == ps) 1516 return; 1517 1518 if (ps) 1519 set_bit(MT_WCID_FLAG_PS, &wcid->flags); 1520 1521 if (dev->drv->sta_ps) 1522 dev->drv->sta_ps(dev, sta, ps); 1523 1524 if (!ps) 1525 clear_bit(MT_WCID_FLAG_PS, &wcid->flags); 1526 1527 ieee80211_sta_ps_transition(sta, ps); 1528 } 1529 1530 void mt76_rx_complete(struct mt76_dev *dev, struct sk_buff_head *frames, 1531 struct napi_struct *napi) 1532 { 1533 struct ieee80211_sta *sta; 1534 struct ieee80211_hw *hw; 1535 struct sk_buff *skb, *tmp; 1536 LIST_HEAD(list); 1537 1538 spin_lock(&dev->rx_lock); 1539 while ((skb = __skb_dequeue(frames)) != NULL) { 1540 struct sk_buff *nskb = skb_shinfo(skb)->frag_list; 1541 1542 mt76_check_ccmp_pn(skb); 1543 skb_shinfo(skb)->frag_list = NULL; 1544 mt76_rx_convert(dev, skb, &hw, &sta); 1545 ieee80211_rx_list(hw, sta, skb, &list); 1546 1547 /* subsequent amsdu frames */ 1548 while (nskb) { 1549 skb = nskb; 1550 nskb = nskb->next; 1551 skb->next = NULL; 1552 1553 mt76_rx_convert(dev, skb, &hw, &sta); 1554 ieee80211_rx_list(hw, sta, skb, &list); 1555 } 1556 } 1557 spin_unlock(&dev->rx_lock); 1558 1559 if (!napi) { 1560 netif_receive_skb_list(&list); 1561 return; 1562 } 1563 1564 list_for_each_entry_safe(skb, tmp, &list, list) { 1565 skb_list_del_init(skb); 1566 napi_gro_receive(napi, skb); 1567 } 1568 } 1569 1570 void mt76_rx_poll_complete(struct mt76_dev *dev, enum mt76_rxq_id q, 1571 struct napi_struct *napi) 1572 { 1573 struct sk_buff_head frames; 1574 struct sk_buff *skb; 1575 1576 __skb_queue_head_init(&frames); 1577 1578 while ((skb = __skb_dequeue(&dev->rx_skb[q])) != NULL) { 1579 mt76_check_sta(dev, skb); 1580 if (mtk_wed_device_active(&dev->mmio.wed) || 1581 mt76_npu_device_active(dev)) 1582 __skb_queue_tail(&frames, skb); 1583 else 1584 mt76_rx_aggr_reorder(skb, &frames); 1585 } 1586 1587 mt76_rx_complete(dev, &frames, napi); 1588 } 1589 EXPORT_SYMBOL_GPL(mt76_rx_poll_complete); 1590 1591 static int 1592 mt76_sta_add(struct mt76_phy *phy, struct ieee80211_vif *vif, 1593 struct ieee80211_sta *sta) 1594 { 1595 struct mt76_wcid *wcid = (struct mt76_wcid *)sta->drv_priv; 1596 struct mt76_dev *dev = phy->dev; 1597 struct mt76_wcid *published; 1598 int ret; 1599 int i; 1600 1601 mutex_lock(&dev->mutex); 1602 1603 ret = dev->drv->sta_add(dev, vif, sta); 1604 if (ret) 1605 goto out; 1606 1607 for (i = 0; i < ARRAY_SIZE(sta->txq); i++) { 1608 struct mt76_txq *mtxq; 1609 1610 if (!sta->txq[i]) 1611 continue; 1612 1613 mtxq = (struct mt76_txq *)sta->txq[i]->drv_priv; 1614 mtxq->wcid = wcid->idx; 1615 } 1616 1617 published = rcu_dereference_protected(dev->wcid[wcid->idx], 1618 lockdep_is_held(&dev->mutex)); 1619 if (published != wcid) { 1620 WARN_ON_ONCE(published); 1621 ewma_signal_init(&wcid->rssi); 1622 rcu_assign_pointer(dev->wcid[wcid->idx], wcid); 1623 mt76_wcid_init(wcid, phy->band_idx); 1624 } else { 1625 wcid->phy_idx = phy->band_idx; 1626 } 1627 1628 phy->num_sta++; 1629 1630 out: 1631 mutex_unlock(&dev->mutex); 1632 1633 return ret; 1634 } 1635 1636 void __mt76_sta_remove(struct mt76_phy *phy, struct ieee80211_vif *vif, 1637 struct ieee80211_sta *sta) 1638 { 1639 struct mt76_dev *dev = phy->dev; 1640 struct mt76_wcid *wcid = (struct mt76_wcid *)sta->drv_priv; 1641 int i, idx = wcid->idx; 1642 1643 for (i = 0; i < ARRAY_SIZE(wcid->aggr); i++) 1644 mt76_rx_aggr_stop(dev, wcid, i); 1645 1646 if (dev->drv->sta_remove) 1647 dev->drv->sta_remove(dev, vif, sta); 1648 1649 mt76_wcid_cleanup(dev, wcid); 1650 1651 mt76_wcid_mask_clear(dev->wcid_mask, idx); 1652 phy->num_sta--; 1653 } 1654 EXPORT_SYMBOL_GPL(__mt76_sta_remove); 1655 1656 static void 1657 mt76_sta_remove(struct mt76_phy *phy, struct ieee80211_vif *vif, 1658 struct ieee80211_sta *sta) 1659 { 1660 struct mt76_dev *dev = phy->dev; 1661 1662 mutex_lock(&dev->mutex); 1663 __mt76_sta_remove(phy, vif, sta); 1664 mutex_unlock(&dev->mutex); 1665 } 1666 1667 int mt76_sta_state(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 1668 struct ieee80211_sta *sta, 1669 enum ieee80211_sta_state old_state, 1670 enum ieee80211_sta_state new_state) 1671 { 1672 struct mt76_phy *phy = hw->priv; 1673 struct mt76_dev *dev = phy->dev; 1674 enum mt76_sta_event ev; 1675 1676 phy = mt76_vif_phy(hw, vif); 1677 if (!phy) 1678 return -EINVAL; 1679 1680 if (old_state == IEEE80211_STA_NOTEXIST && 1681 new_state == IEEE80211_STA_NONE) 1682 return mt76_sta_add(phy, vif, sta); 1683 1684 if (old_state == IEEE80211_STA_NONE && 1685 new_state == IEEE80211_STA_NOTEXIST) 1686 mt76_sta_remove(phy, vif, sta); 1687 1688 if (!dev->drv->sta_event) 1689 return 0; 1690 1691 if (old_state == IEEE80211_STA_AUTH && 1692 new_state == IEEE80211_STA_ASSOC) 1693 ev = MT76_STA_EVENT_ASSOC; 1694 else if (old_state == IEEE80211_STA_ASSOC && 1695 new_state == IEEE80211_STA_AUTHORIZED) 1696 ev = MT76_STA_EVENT_AUTHORIZE; 1697 else if (old_state == IEEE80211_STA_ASSOC && 1698 new_state == IEEE80211_STA_AUTH) 1699 ev = MT76_STA_EVENT_DISASSOC; 1700 else 1701 return 0; 1702 1703 return dev->drv->sta_event(dev, vif, sta, ev); 1704 } 1705 EXPORT_SYMBOL_GPL(mt76_sta_state); 1706 1707 void mt76_sta_pre_rcu_remove(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 1708 struct ieee80211_sta *sta) 1709 { 1710 struct mt76_phy *phy = hw->priv; 1711 struct mt76_dev *dev = phy->dev; 1712 struct mt76_wcid *wcid = (struct mt76_wcid *)sta->drv_priv; 1713 1714 mutex_lock(&dev->mutex); 1715 spin_lock_bh(&dev->status_lock); 1716 rcu_assign_pointer(dev->wcid[wcid->idx], NULL); 1717 spin_unlock_bh(&dev->status_lock); 1718 mutex_unlock(&dev->mutex); 1719 } 1720 EXPORT_SYMBOL_GPL(mt76_sta_pre_rcu_remove); 1721 1722 void mt76_wcid_init(struct mt76_wcid *wcid, u8 band_idx) 1723 { 1724 wcid->hw_key_idx = -1; 1725 wcid->phy_idx = band_idx; 1726 1727 INIT_LIST_HEAD(&wcid->tx_list); 1728 skb_queue_head_init(&wcid->tx_pending); 1729 skb_queue_head_init(&wcid->tx_offchannel); 1730 1731 INIT_LIST_HEAD(&wcid->list); 1732 idr_init(&wcid->pktid); 1733 1734 INIT_LIST_HEAD(&wcid->poll_list); 1735 } 1736 EXPORT_SYMBOL_GPL(mt76_wcid_init); 1737 1738 void mt76_wcid_cleanup(struct mt76_dev *dev, struct mt76_wcid *wcid) 1739 { 1740 struct mt76_phy *phy = mt76_dev_phy(dev, wcid->phy_idx); 1741 struct ieee80211_hw *hw; 1742 struct sk_buff_head list; 1743 struct sk_buff *skb; 1744 1745 mt76_tx_status_lock(dev, &list); 1746 mt76_tx_status_skb_get(dev, wcid, -1, &list); 1747 mt76_tx_status_unlock(dev, &list); 1748 1749 idr_destroy(&wcid->pktid); 1750 1751 /* Remove from sta_poll_list to prevent list corruption after reset. 1752 * Without this, mt76_reset_device() reinitializes sta_poll_list but 1753 * leaves wcid->poll_list with stale pointers, causing list corruption 1754 * when mt76_wcid_add_poll() checks list_empty(). 1755 */ 1756 spin_lock_bh(&dev->sta_poll_lock); 1757 if (!list_empty(&wcid->poll_list)) 1758 list_del_init(&wcid->poll_list); 1759 spin_unlock_bh(&dev->sta_poll_lock); 1760 1761 spin_lock_bh(&phy->tx_lock); 1762 1763 if (!list_empty(&wcid->tx_list)) 1764 list_del_init(&wcid->tx_list); 1765 1766 spin_lock(&wcid->tx_pending.lock); 1767 skb_queue_splice_tail_init(&wcid->tx_pending, &list); 1768 spin_unlock(&wcid->tx_pending.lock); 1769 1770 spin_lock(&wcid->tx_offchannel.lock); 1771 skb_queue_splice_tail_init(&wcid->tx_offchannel, &list); 1772 spin_unlock(&wcid->tx_offchannel.lock); 1773 1774 spin_unlock_bh(&phy->tx_lock); 1775 1776 while ((skb = __skb_dequeue(&list)) != NULL) { 1777 hw = mt76_tx_status_get_hw(dev, skb); 1778 ieee80211_free_txskb(hw, skb); 1779 } 1780 } 1781 EXPORT_SYMBOL_GPL(mt76_wcid_cleanup); 1782 1783 void mt76_wcid_add_poll(struct mt76_dev *dev, struct mt76_wcid *wcid) 1784 { 1785 if (test_bit(MT76_MCU_RESET, &dev->phy.state) || !wcid->sta) 1786 return; 1787 1788 spin_lock_bh(&dev->sta_poll_lock); 1789 if (list_empty(&wcid->poll_list)) 1790 list_add_tail(&wcid->poll_list, &dev->sta_poll_list); 1791 spin_unlock_bh(&dev->sta_poll_lock); 1792 } 1793 EXPORT_SYMBOL_GPL(mt76_wcid_add_poll); 1794 1795 s8 mt76_get_power_bound(struct mt76_phy *phy, s8 txpower) 1796 { 1797 int n_chains = hweight16(phy->chainmask); 1798 1799 txpower = mt76_get_sar_power(phy, phy->chandef.chan, txpower * 2); 1800 txpower -= mt76_tx_power_path_delta(n_chains); 1801 1802 return txpower; 1803 } 1804 EXPORT_SYMBOL_GPL(mt76_get_power_bound); 1805 1806 int mt76_get_txpower(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 1807 unsigned int link_id, int *dbm) 1808 { 1809 struct mt76_phy *phy = mt76_vif_phy(hw, vif); 1810 int n_chains, delta; 1811 1812 if (!phy) 1813 return -EINVAL; 1814 1815 n_chains = hweight16(phy->chainmask); 1816 delta = mt76_tx_power_path_delta(n_chains); 1817 *dbm = DIV_ROUND_UP(phy->txpower_cur + delta, 2); 1818 1819 return 0; 1820 } 1821 EXPORT_SYMBOL_GPL(mt76_get_txpower); 1822 1823 int mt76_init_sar_power(struct ieee80211_hw *hw, 1824 const struct cfg80211_sar_specs *sar) 1825 { 1826 struct mt76_phy *phy = hw->priv; 1827 const struct cfg80211_sar_capa *capa = hw->wiphy->sar_capa; 1828 int i; 1829 1830 if (sar->type != NL80211_SAR_TYPE_POWER || !sar->num_sub_specs) 1831 return -EINVAL; 1832 1833 for (i = 0; i < sar->num_sub_specs; i++) { 1834 u32 index = sar->sub_specs[i].freq_range_index; 1835 /* SAR specifies power limitaton in 0.25dbm */ 1836 s32 power = sar->sub_specs[i].power >> 1; 1837 1838 if (power > 127 || power < -127) 1839 power = 127; 1840 1841 phy->frp[index].range = &capa->freq_ranges[index]; 1842 phy->frp[index].power = power; 1843 } 1844 1845 return 0; 1846 } 1847 EXPORT_SYMBOL_GPL(mt76_init_sar_power); 1848 1849 int mt76_get_sar_power(struct mt76_phy *phy, 1850 struct ieee80211_channel *chan, 1851 int power) 1852 { 1853 const struct cfg80211_sar_capa *capa = phy->hw->wiphy->sar_capa; 1854 int freq, i; 1855 1856 if (!capa || !phy->frp) 1857 return power; 1858 1859 if (power > 127 || power < -127) 1860 power = 127; 1861 1862 freq = ieee80211_channel_to_frequency(chan->hw_value, chan->band); 1863 for (i = 0 ; i < capa->num_freq_ranges; i++) { 1864 if (phy->frp[i].range && 1865 freq >= phy->frp[i].range->start_freq && 1866 freq < phy->frp[i].range->end_freq) { 1867 power = min_t(int, phy->frp[i].power, power); 1868 break; 1869 } 1870 } 1871 1872 return power; 1873 } 1874 EXPORT_SYMBOL_GPL(mt76_get_sar_power); 1875 1876 static void 1877 __mt76_csa_finish(void *priv, u8 *mac, struct ieee80211_vif *vif) 1878 { 1879 if (vif->bss_conf.csa_active && ieee80211_beacon_cntdwn_is_complete(vif, 0)) 1880 ieee80211_csa_finish(vif, 0); 1881 } 1882 1883 void mt76_csa_finish(struct mt76_dev *dev) 1884 { 1885 if (!dev->csa_complete) 1886 return; 1887 1888 ieee80211_iterate_active_interfaces_atomic(dev->hw, 1889 IEEE80211_IFACE_ITER_RESUME_ALL, 1890 __mt76_csa_finish, dev); 1891 1892 dev->csa_complete = 0; 1893 } 1894 EXPORT_SYMBOL_GPL(mt76_csa_finish); 1895 1896 static void 1897 __mt76_csa_check(void *priv, u8 *mac, struct ieee80211_vif *vif) 1898 { 1899 struct mt76_dev *dev = priv; 1900 1901 if (!vif->bss_conf.csa_active) 1902 return; 1903 1904 dev->csa_complete |= ieee80211_beacon_cntdwn_is_complete(vif, 0); 1905 } 1906 1907 void mt76_csa_check(struct mt76_dev *dev) 1908 { 1909 ieee80211_iterate_active_interfaces_atomic(dev->hw, 1910 IEEE80211_IFACE_ITER_RESUME_ALL, 1911 __mt76_csa_check, dev); 1912 } 1913 EXPORT_SYMBOL_GPL(mt76_csa_check); 1914 1915 int 1916 mt76_set_tim(struct ieee80211_hw *hw, struct ieee80211_sta *sta, bool set) 1917 { 1918 return 0; 1919 } 1920 EXPORT_SYMBOL_GPL(mt76_set_tim); 1921 1922 void mt76_insert_ccmp_hdr(struct sk_buff *skb, u8 key_id) 1923 { 1924 struct mt76_rx_status *status = (struct mt76_rx_status *)skb->cb; 1925 int hdr_len = ieee80211_get_hdrlen_from_skb(skb); 1926 u8 *hdr, *pn = status->iv; 1927 1928 __skb_push(skb, 8); 1929 memmove(skb->data, skb->data + 8, hdr_len); 1930 hdr = skb->data + hdr_len; 1931 1932 hdr[0] = pn[5]; 1933 hdr[1] = pn[4]; 1934 hdr[2] = 0; 1935 hdr[3] = 0x20 | (key_id << 6); 1936 hdr[4] = pn[3]; 1937 hdr[5] = pn[2]; 1938 hdr[6] = pn[1]; 1939 hdr[7] = pn[0]; 1940 1941 status->flag &= ~RX_FLAG_IV_STRIPPED; 1942 } 1943 EXPORT_SYMBOL_GPL(mt76_insert_ccmp_hdr); 1944 1945 int mt76_get_rate(struct mt76_dev *dev, 1946 struct ieee80211_supported_band *sband, 1947 int idx, bool cck) 1948 { 1949 bool is_2g = sband->band == NL80211_BAND_2GHZ; 1950 int i, offset = 0, len = sband->n_bitrates; 1951 1952 if (cck) { 1953 if (!is_2g) 1954 return 0; 1955 1956 idx &= ~BIT(2); /* short preamble */ 1957 } else if (is_2g) { 1958 offset = 4; 1959 } 1960 1961 for (i = offset; i < len; i++) { 1962 if ((sband->bitrates[i].hw_value & GENMASK(7, 0)) == idx) 1963 return i; 1964 } 1965 1966 return 0; 1967 } 1968 EXPORT_SYMBOL_GPL(mt76_get_rate); 1969 1970 void mt76_sw_scan(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 1971 const u8 *mac) 1972 { 1973 struct mt76_phy *phy = hw->priv; 1974 1975 set_bit(MT76_SCANNING, &phy->state); 1976 } 1977 EXPORT_SYMBOL_GPL(mt76_sw_scan); 1978 1979 void mt76_sw_scan_complete(struct ieee80211_hw *hw, struct ieee80211_vif *vif) 1980 { 1981 struct mt76_phy *phy = hw->priv; 1982 1983 clear_bit(MT76_SCANNING, &phy->state); 1984 } 1985 EXPORT_SYMBOL_GPL(mt76_sw_scan_complete); 1986 1987 int mt76_get_antenna(struct ieee80211_hw *hw, int radio_idx, u32 *tx_ant, 1988 u32 *rx_ant) 1989 { 1990 struct mt76_phy *phy = hw->priv; 1991 struct mt76_dev *dev = phy->dev; 1992 int i; 1993 1994 mutex_lock(&dev->mutex); 1995 *tx_ant = 0; 1996 for (i = 0; i < ARRAY_SIZE(dev->phys); i++) 1997 if (dev->phys[i] && dev->phys[i]->hw == hw) 1998 *tx_ant |= dev->phys[i]->chainmask; 1999 *rx_ant = *tx_ant; 2000 mutex_unlock(&dev->mutex); 2001 2002 return 0; 2003 } 2004 EXPORT_SYMBOL_GPL(mt76_get_antenna); 2005 2006 struct mt76_queue * 2007 mt76_init_queue(struct mt76_dev *dev, int qid, int idx, int n_desc, 2008 int ring_base, void *wed, u32 flags) 2009 { 2010 struct mt76_queue *hwq; 2011 int err; 2012 2013 hwq = devm_kzalloc(dev->dev, sizeof(*hwq), GFP_KERNEL); 2014 if (!hwq) 2015 return ERR_PTR(-ENOMEM); 2016 2017 hwq->flags = flags; 2018 hwq->wed = wed; 2019 2020 err = dev->queue_ops->alloc(dev, hwq, idx, n_desc, 0, ring_base); 2021 if (err < 0) 2022 return ERR_PTR(err); 2023 2024 return hwq; 2025 } 2026 EXPORT_SYMBOL_GPL(mt76_init_queue); 2027 2028 void mt76_ethtool_worker(struct mt76_ethtool_worker_info *wi, 2029 struct mt76_sta_stats *stats, bool eht) 2030 { 2031 int i, ei = wi->initial_stat_idx; 2032 u64 *data = wi->data; 2033 2034 wi->sta_count++; 2035 2036 data[ei++] += stats->tx_mode[MT_PHY_TYPE_CCK]; 2037 data[ei++] += stats->tx_mode[MT_PHY_TYPE_OFDM]; 2038 data[ei++] += stats->tx_mode[MT_PHY_TYPE_HT]; 2039 data[ei++] += stats->tx_mode[MT_PHY_TYPE_HT_GF]; 2040 data[ei++] += stats->tx_mode[MT_PHY_TYPE_VHT]; 2041 data[ei++] += stats->tx_mode[MT_PHY_TYPE_HE_SU]; 2042 data[ei++] += stats->tx_mode[MT_PHY_TYPE_HE_EXT_SU]; 2043 data[ei++] += stats->tx_mode[MT_PHY_TYPE_HE_TB]; 2044 data[ei++] += stats->tx_mode[MT_PHY_TYPE_HE_MU]; 2045 if (eht) { 2046 data[ei++] += stats->tx_mode[MT_PHY_TYPE_EHT_SU]; 2047 data[ei++] += stats->tx_mode[MT_PHY_TYPE_EHT_TRIG]; 2048 data[ei++] += stats->tx_mode[MT_PHY_TYPE_EHT_MU]; 2049 } 2050 2051 for (i = 0; i < (ARRAY_SIZE(stats->tx_bw) - !eht); i++) 2052 data[ei++] += stats->tx_bw[i]; 2053 2054 for (i = 0; i < (eht ? 14 : 12); i++) 2055 data[ei++] += stats->tx_mcs[i]; 2056 2057 for (i = 0; i < 4; i++) 2058 data[ei++] += stats->tx_nss[i]; 2059 2060 wi->worker_stat_count = ei - wi->initial_stat_idx; 2061 } 2062 EXPORT_SYMBOL_GPL(mt76_ethtool_worker); 2063 2064 void mt76_ethtool_page_pool_stats(struct mt76_dev *dev, u64 *data, int *index) 2065 { 2066 #ifdef CONFIG_PAGE_POOL_STATS 2067 struct page_pool_stats stats = {}; 2068 int i; 2069 2070 mt76_for_each_q_rx(dev, i) 2071 page_pool_get_stats(dev->q_rx[i].page_pool, &stats); 2072 2073 page_pool_ethtool_stats_get(data, &stats); 2074 *index += page_pool_ethtool_stats_get_count(); 2075 #endif 2076 } 2077 EXPORT_SYMBOL_GPL(mt76_ethtool_page_pool_stats); 2078 2079 enum mt76_dfs_state mt76_phy_dfs_state(struct mt76_phy *phy) 2080 { 2081 struct ieee80211_hw *hw = phy->hw; 2082 struct mt76_dev *dev = phy->dev; 2083 2084 if (dev->region == NL80211_DFS_UNSET || 2085 test_bit(MT76_SCANNING, &phy->state)) 2086 return MT_DFS_STATE_DISABLED; 2087 2088 if (!phy->radar_enabled) { 2089 if ((hw->conf.flags & IEEE80211_CONF_MONITOR) && 2090 (phy->chandef.chan->flags & IEEE80211_CHAN_RADAR)) 2091 return MT_DFS_STATE_ACTIVE; 2092 2093 return MT_DFS_STATE_DISABLED; 2094 } 2095 2096 if (!cfg80211_reg_can_beacon(hw->wiphy, &phy->chandef, NL80211_IFTYPE_AP)) 2097 return MT_DFS_STATE_CAC; 2098 2099 return MT_DFS_STATE_ACTIVE; 2100 } 2101 EXPORT_SYMBOL_GPL(mt76_phy_dfs_state); 2102 2103 void mt76_vif_cleanup(struct mt76_dev *dev, struct ieee80211_vif *vif) 2104 { 2105 struct mt76_vif_link *mlink = (struct mt76_vif_link *)vif->drv_priv; 2106 struct mt76_vif_data *mvif = mlink->mvif; 2107 2108 rcu_assign_pointer(mvif->link[0], NULL); 2109 mt76_abort_scan(dev); 2110 if (mvif->roc_phy) 2111 mt76_abort_roc(mvif->roc_phy); 2112 } 2113 EXPORT_SYMBOL_GPL(mt76_vif_cleanup); 2114 2115 u16 mt76_select_links(struct ieee80211_vif *vif, int max_active_links) 2116 { 2117 unsigned long usable_links = ieee80211_vif_usable_links(vif); 2118 struct { 2119 u8 link_id; 2120 enum nl80211_band band; 2121 } data[IEEE80211_MLD_MAX_NUM_LINKS]; 2122 unsigned int link_id; 2123 int i, n_data = 0; 2124 u16 sel_links = 0; 2125 2126 if (!ieee80211_vif_is_mld(vif)) 2127 return 0; 2128 2129 if (vif->active_links == usable_links) 2130 return vif->active_links; 2131 2132 rcu_read_lock(); 2133 for_each_set_bit(link_id, &usable_links, IEEE80211_MLD_MAX_NUM_LINKS) { 2134 struct ieee80211_bss_conf *link_conf; 2135 2136 link_conf = rcu_dereference(vif->link_conf[link_id]); 2137 if (WARN_ON_ONCE(!link_conf)) 2138 continue; 2139 2140 data[n_data].link_id = link_id; 2141 data[n_data].band = link_conf->chanreq.oper.chan->band; 2142 n_data++; 2143 } 2144 rcu_read_unlock(); 2145 2146 for (i = 0; i < n_data; i++) { 2147 int j; 2148 2149 if (!(BIT(data[i].link_id) & vif->active_links)) 2150 continue; 2151 2152 sel_links = BIT(data[i].link_id); 2153 for (j = 0; j < n_data; j++) { 2154 if (data[i].band != data[j].band) { 2155 sel_links |= BIT(data[j].link_id); 2156 if (hweight16(sel_links) == max_active_links) 2157 break; 2158 } 2159 } 2160 break; 2161 } 2162 2163 return sel_links; 2164 } 2165 EXPORT_SYMBOL_GPL(mt76_select_links); 2166 2167 struct mt76_offchannel_cb_data { 2168 struct mt76_phy *phy; 2169 bool offchannel; 2170 }; 2171 2172 static void 2173 mt76_offchannel_send_nullfunc(struct mt76_offchannel_cb_data *data, 2174 struct ieee80211_vif *vif, int link_id) 2175 { 2176 struct mt76_phy *phy = data->phy; 2177 struct ieee80211_tx_info *info; 2178 struct ieee80211_sta *sta = NULL; 2179 struct ieee80211_hdr *hdr; 2180 struct mt76_wcid *wcid; 2181 struct sk_buff *skb; 2182 2183 skb = ieee80211_nullfunc_get(phy->hw, vif, link_id, true); 2184 if (!skb) 2185 return; 2186 2187 hdr = (struct ieee80211_hdr *)skb->data; 2188 if (data->offchannel) 2189 hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM); 2190 2191 skb->priority = 7; 2192 skb_set_queue_mapping(skb, IEEE80211_AC_VO); 2193 2194 if (!ieee80211_tx_prepare_skb(phy->hw, vif, skb, 2195 phy->main_chandef.chan->band, 2196 &sta)) 2197 return; 2198 2199 if (sta) 2200 wcid = (struct mt76_wcid *)sta->drv_priv; 2201 else 2202 wcid = ((struct mt76_vif_link *)vif->drv_priv)->wcid; 2203 2204 if (link_id >= 0) { 2205 info = IEEE80211_SKB_CB(skb); 2206 info->control.flags &= ~IEEE80211_TX_CTRL_MLO_LINK; 2207 info->control.flags |= 2208 u32_encode_bits(link_id, IEEE80211_TX_CTRL_MLO_LINK); 2209 } 2210 2211 mt76_tx(phy, sta, wcid, skb); 2212 } 2213 2214 static void 2215 mt76_offchannel_notify_iter(void *_data, u8 *mac, struct ieee80211_vif *vif) 2216 { 2217 struct mt76_offchannel_cb_data *data = _data; 2218 struct mt76_vif_link *mlink; 2219 struct mt76_vif_data *mvif; 2220 int link_id; 2221 2222 if (vif->type != NL80211_IFTYPE_STATION || !vif->cfg.assoc) 2223 return; 2224 2225 mlink = (struct mt76_vif_link *)vif->drv_priv; 2226 mvif = mlink->mvif; 2227 2228 if (!ieee80211_vif_is_mld(vif)) { 2229 if (mt76_vif_link_phy(mlink) == data->phy) { 2230 if (!data->offchannel && mlink->beacon_mon_interval) 2231 WRITE_ONCE(mlink->beacon_mon_last, jiffies); 2232 mt76_offchannel_send_nullfunc(data, vif, -1); 2233 } 2234 return; 2235 } 2236 2237 for (link_id = 0; link_id < IEEE80211_MLD_MAX_NUM_LINKS; link_id++) { 2238 if (link_id == mvif->deflink_id) 2239 mlink = (struct mt76_vif_link *)vif->drv_priv; 2240 else 2241 mlink = rcu_dereference(mvif->link[link_id]); 2242 if (!mlink) 2243 continue; 2244 if (mt76_vif_link_phy(mlink) != data->phy) 2245 continue; 2246 2247 if (!data->offchannel && mlink->beacon_mon_interval) 2248 WRITE_ONCE(mlink->beacon_mon_last, jiffies); 2249 2250 mt76_offchannel_send_nullfunc(data, vif, link_id); 2251 } 2252 } 2253 2254 void mt76_offchannel_notify(struct mt76_phy *phy, bool offchannel) 2255 { 2256 struct mt76_offchannel_cb_data data = { 2257 .phy = phy, 2258 .offchannel = offchannel, 2259 }; 2260 2261 if (!phy->num_sta) 2262 return; 2263 2264 local_bh_disable(); 2265 ieee80211_iterate_active_interfaces_atomic(phy->hw, 2266 IEEE80211_IFACE_ITER_NORMAL, 2267 mt76_offchannel_notify_iter, &data); 2268 local_bh_enable(); 2269 } 2270 EXPORT_SYMBOL_GPL(mt76_offchannel_notify); 2271 2272 struct mt76_rx_beacon_data { 2273 struct mt76_phy *phy; 2274 const u8 *bssid; 2275 }; 2276 2277 static void mt76_rx_beacon_iter(void *_data, u8 *mac, 2278 struct ieee80211_vif *vif) 2279 { 2280 struct mt76_rx_beacon_data *data = _data; 2281 struct mt76_vif_link *mlink = (struct mt76_vif_link *)vif->drv_priv; 2282 struct mt76_vif_data *mvif = mlink->mvif; 2283 int link_id; 2284 2285 if (vif->type != NL80211_IFTYPE_STATION || !vif->cfg.assoc) 2286 return; 2287 2288 for (link_id = 0; link_id < IEEE80211_MLD_MAX_NUM_LINKS; link_id++) { 2289 struct ieee80211_bss_conf *link_conf; 2290 2291 if (link_id == mvif->deflink_id) 2292 mlink = (struct mt76_vif_link *)vif->drv_priv; 2293 else 2294 mlink = rcu_dereference(mvif->link[link_id]); 2295 if (!mlink || !mlink->beacon_mon_interval) 2296 continue; 2297 2298 if (mt76_vif_link_phy(mlink) != data->phy) 2299 continue; 2300 2301 link_conf = rcu_dereference(vif->link_conf[link_id]); 2302 if (!link_conf) 2303 continue; 2304 2305 if (!ether_addr_equal(link_conf->bssid, data->bssid) && 2306 (!link_conf->nontransmitted || 2307 !ether_addr_equal(link_conf->transmitter_bssid, 2308 data->bssid))) 2309 continue; 2310 2311 WRITE_ONCE(mlink->beacon_mon_last, jiffies); 2312 } 2313 } 2314 2315 void mt76_rx_beacon(struct mt76_phy *phy, struct sk_buff *skb) 2316 { 2317 struct mt76_rx_status *status = (struct mt76_rx_status *)skb->cb; 2318 struct ieee80211_hdr *hdr = mt76_skb_get_hdr(skb); 2319 struct mt76_rx_beacon_data data = { 2320 .phy = phy, 2321 .bssid = hdr->addr3, 2322 }; 2323 2324 mt76_scan_rx_beacon(phy->dev, phy->chandef.chan); 2325 2326 if (!phy->num_sta) 2327 return; 2328 2329 if (status->flag & (RX_FLAG_FAILED_FCS_CRC | RX_FLAG_ONLY_MONITOR)) 2330 return; 2331 2332 ieee80211_iterate_active_interfaces_atomic(phy->hw, 2333 IEEE80211_IFACE_ITER_RESUME_ALL, 2334 mt76_rx_beacon_iter, &data); 2335 } 2336 EXPORT_SYMBOL_GPL(mt76_rx_beacon); 2337 2338 static void mt76_beacon_mon_iter(void *data, u8 *mac, 2339 struct ieee80211_vif *vif) 2340 { 2341 struct mt76_phy *phy = data; 2342 struct mt76_vif_link *mlink = (struct mt76_vif_link *)vif->drv_priv; 2343 struct mt76_vif_data *mvif = mlink->mvif; 2344 int link_id; 2345 2346 if (vif->type != NL80211_IFTYPE_STATION || !vif->cfg.assoc) 2347 return; 2348 2349 for (link_id = 0; link_id < IEEE80211_MLD_MAX_NUM_LINKS; link_id++) { 2350 if (link_id == mvif->deflink_id) 2351 mlink = (struct mt76_vif_link *)vif->drv_priv; 2352 else 2353 mlink = rcu_dereference(mvif->link[link_id]); 2354 if (!mlink || !mlink->beacon_mon_interval) 2355 continue; 2356 2357 if (mt76_vif_link_phy(mlink) != phy) 2358 continue; 2359 2360 if (time_after(jiffies, 2361 READ_ONCE(mlink->beacon_mon_last) + 2362 MT76_BEACON_MON_MAX_MISS * mlink->beacon_mon_interval)) 2363 ieee80211_beacon_loss(vif); 2364 } 2365 } 2366 2367 void mt76_beacon_mon_check(struct mt76_phy *phy) 2368 { 2369 if (phy->offchannel) 2370 return; 2371 2372 ieee80211_iterate_active_interfaces_atomic(phy->hw, 2373 IEEE80211_IFACE_ITER_RESUME_ALL, 2374 mt76_beacon_mon_iter, phy); 2375 } 2376 EXPORT_SYMBOL_GPL(mt76_beacon_mon_check); 2377