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