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