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