1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright 2002-2005, Instant802 Networks, Inc. 4 * Copyright 2005-2006, Devicescape Software, Inc. 5 * Copyright (c) 2006 Jiri Benc <jbenc@suse.cz> 6 * Copyright 2017 Intel Deutschland GmbH 7 */ 8 9 #include <linux/kernel.h> 10 #include <linux/rtnetlink.h> 11 #include <linux/module.h> 12 #include <linux/slab.h> 13 #include "rate.h" 14 #include "ieee80211_i.h" 15 #include "debugfs.h" 16 17 struct rate_control_alg { 18 struct list_head list; 19 const struct rate_control_ops *ops; 20 }; 21 22 static LIST_HEAD(rate_ctrl_algs); 23 static DEFINE_MUTEX(rate_ctrl_mutex); 24 25 static char *ieee80211_default_rc_algo = CONFIG_MAC80211_RC_DEFAULT; 26 module_param(ieee80211_default_rc_algo, charp, 0644); 27 MODULE_PARM_DESC(ieee80211_default_rc_algo, 28 "Default rate control algorithm for mac80211 to use"); 29 30 void rate_control_rate_init(struct sta_info *sta) 31 { 32 struct ieee80211_local *local = sta->sdata->local; 33 struct rate_control_ref *ref = sta->rate_ctrl; 34 struct ieee80211_sta *ista = &sta->sta; 35 void *priv_sta = sta->rate_ctrl_priv; 36 struct ieee80211_supported_band *sband; 37 struct ieee80211_chanctx_conf *chanctx_conf; 38 39 ieee80211_sta_set_rx_nss(sta); 40 41 if (!ref) 42 return; 43 44 rcu_read_lock(); 45 46 chanctx_conf = rcu_dereference(sta->sdata->vif.chanctx_conf); 47 if (WARN_ON(!chanctx_conf)) { 48 rcu_read_unlock(); 49 return; 50 } 51 52 sband = local->hw.wiphy->bands[chanctx_conf->def.chan->band]; 53 54 /* TODO: check for minstrel_s1g ? */ 55 if (sband->band == NL80211_BAND_S1GHZ) { 56 ieee80211_s1g_sta_rate_init(sta); 57 rcu_read_unlock(); 58 return; 59 } 60 61 spin_lock_bh(&sta->rate_ctrl_lock); 62 ref->ops->rate_init(ref->priv, sband, &chanctx_conf->def, ista, 63 priv_sta); 64 spin_unlock_bh(&sta->rate_ctrl_lock); 65 rcu_read_unlock(); 66 set_sta_flag(sta, WLAN_STA_RATE_CONTROL); 67 } 68 69 void rate_control_tx_status(struct ieee80211_local *local, 70 struct ieee80211_supported_band *sband, 71 struct ieee80211_tx_status *st) 72 { 73 struct rate_control_ref *ref = local->rate_ctrl; 74 struct sta_info *sta = container_of(st->sta, struct sta_info, sta); 75 void *priv_sta = sta->rate_ctrl_priv; 76 77 if (!ref || !test_sta_flag(sta, WLAN_STA_RATE_CONTROL)) 78 return; 79 80 spin_lock_bh(&sta->rate_ctrl_lock); 81 if (ref->ops->tx_status_ext) 82 ref->ops->tx_status_ext(ref->priv, sband, priv_sta, st); 83 else if (st->skb) 84 ref->ops->tx_status(ref->priv, sband, st->sta, priv_sta, st->skb); 85 else 86 WARN_ON_ONCE(1); 87 88 spin_unlock_bh(&sta->rate_ctrl_lock); 89 } 90 91 void rate_control_rate_update(struct ieee80211_local *local, 92 struct ieee80211_supported_band *sband, 93 struct sta_info *sta, u32 changed) 94 { 95 struct rate_control_ref *ref = local->rate_ctrl; 96 struct ieee80211_sta *ista = &sta->sta; 97 void *priv_sta = sta->rate_ctrl_priv; 98 struct ieee80211_chanctx_conf *chanctx_conf; 99 100 if (ref && ref->ops->rate_update) { 101 rcu_read_lock(); 102 103 chanctx_conf = rcu_dereference(sta->sdata->vif.chanctx_conf); 104 if (WARN_ON(!chanctx_conf)) { 105 rcu_read_unlock(); 106 return; 107 } 108 109 spin_lock_bh(&sta->rate_ctrl_lock); 110 ref->ops->rate_update(ref->priv, sband, &chanctx_conf->def, 111 ista, priv_sta, changed); 112 spin_unlock_bh(&sta->rate_ctrl_lock); 113 rcu_read_unlock(); 114 } 115 drv_sta_rc_update(local, sta->sdata, &sta->sta, changed); 116 } 117 118 int ieee80211_rate_control_register(const struct rate_control_ops *ops) 119 { 120 struct rate_control_alg *alg; 121 122 if (!ops->name) 123 return -EINVAL; 124 125 mutex_lock(&rate_ctrl_mutex); 126 list_for_each_entry(alg, &rate_ctrl_algs, list) { 127 if (!strcmp(alg->ops->name, ops->name)) { 128 /* don't register an algorithm twice */ 129 WARN_ON(1); 130 mutex_unlock(&rate_ctrl_mutex); 131 return -EALREADY; 132 } 133 } 134 135 alg = kzalloc(sizeof(*alg), GFP_KERNEL); 136 if (alg == NULL) { 137 mutex_unlock(&rate_ctrl_mutex); 138 return -ENOMEM; 139 } 140 alg->ops = ops; 141 142 list_add_tail(&alg->list, &rate_ctrl_algs); 143 mutex_unlock(&rate_ctrl_mutex); 144 145 return 0; 146 } 147 EXPORT_SYMBOL(ieee80211_rate_control_register); 148 149 void ieee80211_rate_control_unregister(const struct rate_control_ops *ops) 150 { 151 struct rate_control_alg *alg; 152 153 mutex_lock(&rate_ctrl_mutex); 154 list_for_each_entry(alg, &rate_ctrl_algs, list) { 155 if (alg->ops == ops) { 156 list_del(&alg->list); 157 kfree(alg); 158 break; 159 } 160 } 161 mutex_unlock(&rate_ctrl_mutex); 162 } 163 EXPORT_SYMBOL(ieee80211_rate_control_unregister); 164 165 static const struct rate_control_ops * 166 ieee80211_try_rate_control_ops_get(const char *name) 167 { 168 struct rate_control_alg *alg; 169 const struct rate_control_ops *ops = NULL; 170 171 if (!name) 172 return NULL; 173 174 mutex_lock(&rate_ctrl_mutex); 175 list_for_each_entry(alg, &rate_ctrl_algs, list) { 176 if (!strcmp(alg->ops->name, name)) { 177 ops = alg->ops; 178 break; 179 } 180 } 181 mutex_unlock(&rate_ctrl_mutex); 182 return ops; 183 } 184 185 /* Get the rate control algorithm. */ 186 static const struct rate_control_ops * 187 ieee80211_rate_control_ops_get(const char *name) 188 { 189 const struct rate_control_ops *ops; 190 const char *alg_name; 191 192 kernel_param_lock(THIS_MODULE); 193 if (!name) 194 alg_name = ieee80211_default_rc_algo; 195 else 196 alg_name = name; 197 198 ops = ieee80211_try_rate_control_ops_get(alg_name); 199 if (!ops && name) 200 /* try default if specific alg requested but not found */ 201 ops = ieee80211_try_rate_control_ops_get(ieee80211_default_rc_algo); 202 203 /* Note: check for > 0 is intentional to avoid clang warning */ 204 if (!ops && (strlen(CONFIG_MAC80211_RC_DEFAULT) > 0)) 205 /* try built-in one if specific alg requested but not found */ 206 ops = ieee80211_try_rate_control_ops_get(CONFIG_MAC80211_RC_DEFAULT); 207 208 kernel_param_unlock(THIS_MODULE); 209 210 return ops; 211 } 212 213 #ifdef CONFIG_MAC80211_DEBUGFS 214 static ssize_t rcname_read(struct file *file, char __user *userbuf, 215 size_t count, loff_t *ppos) 216 { 217 struct rate_control_ref *ref = file->private_data; 218 int len = strlen(ref->ops->name); 219 220 return simple_read_from_buffer(userbuf, count, ppos, 221 ref->ops->name, len); 222 } 223 224 const struct file_operations rcname_ops = { 225 .read = rcname_read, 226 .open = simple_open, 227 .llseek = default_llseek, 228 }; 229 #endif 230 231 static struct rate_control_ref * 232 rate_control_alloc(const char *name, struct ieee80211_local *local) 233 { 234 struct rate_control_ref *ref; 235 236 ref = kmalloc(sizeof(struct rate_control_ref), GFP_KERNEL); 237 if (!ref) 238 return NULL; 239 ref->ops = ieee80211_rate_control_ops_get(name); 240 if (!ref->ops) 241 goto free; 242 243 ref->priv = ref->ops->alloc(&local->hw); 244 if (!ref->priv) 245 goto free; 246 return ref; 247 248 free: 249 kfree(ref); 250 return NULL; 251 } 252 253 static void rate_control_free(struct ieee80211_local *local, 254 struct rate_control_ref *ctrl_ref) 255 { 256 ctrl_ref->ops->free(ctrl_ref->priv); 257 258 #ifdef CONFIG_MAC80211_DEBUGFS 259 debugfs_remove_recursive(local->debugfs.rcdir); 260 local->debugfs.rcdir = NULL; 261 #endif 262 263 kfree(ctrl_ref); 264 } 265 266 void ieee80211_check_rate_mask(struct ieee80211_sub_if_data *sdata) 267 { 268 struct ieee80211_local *local = sdata->local; 269 struct ieee80211_supported_band *sband; 270 u32 user_mask, basic_rates = sdata->vif.bss_conf.basic_rates; 271 enum nl80211_band band; 272 273 if (WARN_ON(!sdata->vif.bss_conf.chandef.chan)) 274 return; 275 276 band = sdata->vif.bss_conf.chandef.chan->band; 277 if (band == NL80211_BAND_S1GHZ) { 278 /* TODO */ 279 return; 280 } 281 282 if (WARN_ON_ONCE(!basic_rates)) 283 return; 284 285 user_mask = sdata->rc_rateidx_mask[band]; 286 sband = local->hw.wiphy->bands[band]; 287 288 if (user_mask & basic_rates) 289 return; 290 291 sdata_dbg(sdata, 292 "no overlap between basic rates (0x%x) and user mask (0x%x on band %d) - clearing the latter", 293 basic_rates, user_mask, band); 294 sdata->rc_rateidx_mask[band] = (1 << sband->n_bitrates) - 1; 295 } 296 297 static bool rc_no_data_or_no_ack_use_min(struct ieee80211_tx_rate_control *txrc) 298 { 299 struct sk_buff *skb = txrc->skb; 300 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data; 301 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 302 __le16 fc; 303 304 fc = hdr->frame_control; 305 306 return (info->flags & (IEEE80211_TX_CTL_NO_ACK | 307 IEEE80211_TX_CTL_USE_MINRATE)) || 308 !ieee80211_is_data(fc); 309 } 310 311 static void rc_send_low_basicrate(struct ieee80211_tx_rate *rate, 312 u32 basic_rates, 313 struct ieee80211_supported_band *sband) 314 { 315 u8 i; 316 317 if (sband->band == NL80211_BAND_S1GHZ) { 318 /* TODO */ 319 rate->flags |= IEEE80211_TX_RC_S1G_MCS; 320 rate->idx = 0; 321 return; 322 } 323 324 if (basic_rates == 0) 325 return; /* assume basic rates unknown and accept rate */ 326 if (rate->idx < 0) 327 return; 328 if (basic_rates & (1 << rate->idx)) 329 return; /* selected rate is a basic rate */ 330 331 for (i = rate->idx + 1; i <= sband->n_bitrates; i++) { 332 if (basic_rates & (1 << i)) { 333 rate->idx = i; 334 return; 335 } 336 } 337 338 /* could not find a basic rate; use original selection */ 339 } 340 341 static void __rate_control_send_low(struct ieee80211_hw *hw, 342 struct ieee80211_supported_band *sband, 343 struct ieee80211_sta *sta, 344 struct ieee80211_tx_info *info, 345 u32 rate_mask) 346 { 347 int i; 348 u32 rate_flags = 349 ieee80211_chandef_rate_flags(&hw->conf.chandef); 350 351 if (sband->band == NL80211_BAND_S1GHZ) { 352 info->control.rates[0].flags |= IEEE80211_TX_RC_S1G_MCS; 353 info->control.rates[0].idx = 0; 354 return; 355 } 356 357 if ((sband->band == NL80211_BAND_2GHZ) && 358 (info->flags & IEEE80211_TX_CTL_NO_CCK_RATE)) 359 rate_flags |= IEEE80211_RATE_ERP_G; 360 361 info->control.rates[0].idx = 0; 362 for (i = 0; i < sband->n_bitrates; i++) { 363 if (!(rate_mask & BIT(i))) 364 continue; 365 366 if ((rate_flags & sband->bitrates[i].flags) != rate_flags) 367 continue; 368 369 if (!rate_supported(sta, sband->band, i)) 370 continue; 371 372 info->control.rates[0].idx = i; 373 break; 374 } 375 WARN_ONCE(i == sband->n_bitrates, 376 "no supported rates for sta %pM (0x%x, band %d) in rate_mask 0x%x with flags 0x%x\n", 377 sta ? sta->addr : NULL, 378 sta ? sta->supp_rates[sband->band] : -1, 379 sband->band, 380 rate_mask, rate_flags); 381 382 info->control.rates[0].count = 383 (info->flags & IEEE80211_TX_CTL_NO_ACK) ? 384 1 : hw->max_rate_tries; 385 386 info->control.skip_table = 1; 387 } 388 389 390 static bool rate_control_send_low(struct ieee80211_sta *pubsta, 391 struct ieee80211_tx_rate_control *txrc) 392 { 393 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(txrc->skb); 394 struct ieee80211_supported_band *sband = txrc->sband; 395 struct sta_info *sta; 396 int mcast_rate; 397 bool use_basicrate = false; 398 399 if (!pubsta || rc_no_data_or_no_ack_use_min(txrc)) { 400 __rate_control_send_low(txrc->hw, sband, pubsta, info, 401 txrc->rate_idx_mask); 402 403 if (!pubsta && txrc->bss) { 404 mcast_rate = txrc->bss_conf->mcast_rate[sband->band]; 405 if (mcast_rate > 0) { 406 info->control.rates[0].idx = mcast_rate - 1; 407 return true; 408 } 409 use_basicrate = true; 410 } else if (pubsta) { 411 sta = container_of(pubsta, struct sta_info, sta); 412 if (ieee80211_vif_is_mesh(&sta->sdata->vif)) 413 use_basicrate = true; 414 } 415 416 if (use_basicrate) 417 rc_send_low_basicrate(&info->control.rates[0], 418 txrc->bss_conf->basic_rates, 419 sband); 420 421 return true; 422 } 423 return false; 424 } 425 426 static bool rate_idx_match_legacy_mask(s8 *rate_idx, int n_bitrates, u32 mask) 427 { 428 int j; 429 430 /* See whether the selected rate or anything below it is allowed. */ 431 for (j = *rate_idx; j >= 0; j--) { 432 if (mask & (1 << j)) { 433 /* Okay, found a suitable rate. Use it. */ 434 *rate_idx = j; 435 return true; 436 } 437 } 438 439 /* Try to find a higher rate that would be allowed */ 440 for (j = *rate_idx + 1; j < n_bitrates; j++) { 441 if (mask & (1 << j)) { 442 /* Okay, found a suitable rate. Use it. */ 443 *rate_idx = j; 444 return true; 445 } 446 } 447 return false; 448 } 449 450 static bool rate_idx_match_mcs_mask(s8 *rate_idx, u8 *mcs_mask) 451 { 452 int i, j; 453 int ridx, rbit; 454 455 ridx = *rate_idx / 8; 456 rbit = *rate_idx % 8; 457 458 /* sanity check */ 459 if (ridx < 0 || ridx >= IEEE80211_HT_MCS_MASK_LEN) 460 return false; 461 462 /* See whether the selected rate or anything below it is allowed. */ 463 for (i = ridx; i >= 0; i--) { 464 for (j = rbit; j >= 0; j--) 465 if (mcs_mask[i] & BIT(j)) { 466 *rate_idx = i * 8 + j; 467 return true; 468 } 469 rbit = 7; 470 } 471 472 /* Try to find a higher rate that would be allowed */ 473 ridx = (*rate_idx + 1) / 8; 474 rbit = (*rate_idx + 1) % 8; 475 476 for (i = ridx; i < IEEE80211_HT_MCS_MASK_LEN; i++) { 477 for (j = rbit; j < 8; j++) 478 if (mcs_mask[i] & BIT(j)) { 479 *rate_idx = i * 8 + j; 480 return true; 481 } 482 rbit = 0; 483 } 484 return false; 485 } 486 487 static bool rate_idx_match_vht_mcs_mask(s8 *rate_idx, u16 *vht_mask) 488 { 489 int i, j; 490 int ridx, rbit; 491 492 ridx = *rate_idx >> 4; 493 rbit = *rate_idx & 0xf; 494 495 if (ridx < 0 || ridx >= NL80211_VHT_NSS_MAX) 496 return false; 497 498 /* See whether the selected rate or anything below it is allowed. */ 499 for (i = ridx; i >= 0; i--) { 500 for (j = rbit; j >= 0; j--) { 501 if (vht_mask[i] & BIT(j)) { 502 *rate_idx = (i << 4) | j; 503 return true; 504 } 505 } 506 rbit = 15; 507 } 508 509 /* Try to find a higher rate that would be allowed */ 510 ridx = (*rate_idx + 1) >> 4; 511 rbit = (*rate_idx + 1) & 0xf; 512 513 for (i = ridx; i < NL80211_VHT_NSS_MAX; i++) { 514 for (j = rbit; j < 16; j++) { 515 if (vht_mask[i] & BIT(j)) { 516 *rate_idx = (i << 4) | j; 517 return true; 518 } 519 } 520 rbit = 0; 521 } 522 return false; 523 } 524 525 static void rate_idx_match_mask(s8 *rate_idx, u16 *rate_flags, 526 struct ieee80211_supported_band *sband, 527 enum nl80211_chan_width chan_width, 528 u32 mask, 529 u8 mcs_mask[IEEE80211_HT_MCS_MASK_LEN], 530 u16 vht_mask[NL80211_VHT_NSS_MAX]) 531 { 532 if (*rate_flags & IEEE80211_TX_RC_VHT_MCS) { 533 /* handle VHT rates */ 534 if (rate_idx_match_vht_mcs_mask(rate_idx, vht_mask)) 535 return; 536 537 *rate_idx = 0; 538 /* keep protection flags */ 539 *rate_flags &= (IEEE80211_TX_RC_USE_RTS_CTS | 540 IEEE80211_TX_RC_USE_CTS_PROTECT | 541 IEEE80211_TX_RC_USE_SHORT_PREAMBLE); 542 543 *rate_flags |= IEEE80211_TX_RC_MCS; 544 if (chan_width == NL80211_CHAN_WIDTH_40) 545 *rate_flags |= IEEE80211_TX_RC_40_MHZ_WIDTH; 546 547 if (rate_idx_match_mcs_mask(rate_idx, mcs_mask)) 548 return; 549 550 /* also try the legacy rates. */ 551 *rate_flags &= ~(IEEE80211_TX_RC_MCS | 552 IEEE80211_TX_RC_40_MHZ_WIDTH); 553 if (rate_idx_match_legacy_mask(rate_idx, sband->n_bitrates, 554 mask)) 555 return; 556 } else if (*rate_flags & IEEE80211_TX_RC_MCS) { 557 /* handle HT rates */ 558 if (rate_idx_match_mcs_mask(rate_idx, mcs_mask)) 559 return; 560 561 /* also try the legacy rates. */ 562 *rate_idx = 0; 563 /* keep protection flags */ 564 *rate_flags &= (IEEE80211_TX_RC_USE_RTS_CTS | 565 IEEE80211_TX_RC_USE_CTS_PROTECT | 566 IEEE80211_TX_RC_USE_SHORT_PREAMBLE); 567 if (rate_idx_match_legacy_mask(rate_idx, sband->n_bitrates, 568 mask)) 569 return; 570 } else { 571 /* handle legacy rates */ 572 if (rate_idx_match_legacy_mask(rate_idx, sband->n_bitrates, 573 mask)) 574 return; 575 576 /* if HT BSS, and we handle a data frame, also try HT rates */ 577 switch (chan_width) { 578 case NL80211_CHAN_WIDTH_20_NOHT: 579 case NL80211_CHAN_WIDTH_5: 580 case NL80211_CHAN_WIDTH_10: 581 return; 582 default: 583 break; 584 } 585 586 *rate_idx = 0; 587 /* keep protection flags */ 588 *rate_flags &= (IEEE80211_TX_RC_USE_RTS_CTS | 589 IEEE80211_TX_RC_USE_CTS_PROTECT | 590 IEEE80211_TX_RC_USE_SHORT_PREAMBLE); 591 592 *rate_flags |= IEEE80211_TX_RC_MCS; 593 594 if (chan_width == NL80211_CHAN_WIDTH_40) 595 *rate_flags |= IEEE80211_TX_RC_40_MHZ_WIDTH; 596 597 if (rate_idx_match_mcs_mask(rate_idx, mcs_mask)) 598 return; 599 } 600 601 /* 602 * Uh.. No suitable rate exists. This should not really happen with 603 * sane TX rate mask configurations. However, should someone manage to 604 * configure supported rates and TX rate mask in incompatible way, 605 * allow the frame to be transmitted with whatever the rate control 606 * selected. 607 */ 608 } 609 610 static void rate_fixup_ratelist(struct ieee80211_vif *vif, 611 struct ieee80211_supported_band *sband, 612 struct ieee80211_tx_info *info, 613 struct ieee80211_tx_rate *rates, 614 int max_rates) 615 { 616 struct ieee80211_rate *rate; 617 bool inval = false; 618 int i; 619 620 /* 621 * Set up the RTS/CTS rate as the fastest basic rate 622 * that is not faster than the data rate unless there 623 * is no basic rate slower than the data rate, in which 624 * case we pick the slowest basic rate 625 * 626 * XXX: Should this check all retry rates? 627 */ 628 if (!(rates[0].flags & 629 (IEEE80211_TX_RC_MCS | IEEE80211_TX_RC_VHT_MCS))) { 630 u32 basic_rates = vif->bss_conf.basic_rates; 631 s8 baserate = basic_rates ? ffs(basic_rates) - 1 : 0; 632 633 rate = &sband->bitrates[rates[0].idx]; 634 635 for (i = 0; i < sband->n_bitrates; i++) { 636 /* must be a basic rate */ 637 if (!(basic_rates & BIT(i))) 638 continue; 639 /* must not be faster than the data rate */ 640 if (sband->bitrates[i].bitrate > rate->bitrate) 641 continue; 642 /* maximum */ 643 if (sband->bitrates[baserate].bitrate < 644 sband->bitrates[i].bitrate) 645 baserate = i; 646 } 647 648 info->control.rts_cts_rate_idx = baserate; 649 } 650 651 for (i = 0; i < max_rates; i++) { 652 /* 653 * make sure there's no valid rate following 654 * an invalid one, just in case drivers don't 655 * take the API seriously to stop at -1. 656 */ 657 if (inval) { 658 rates[i].idx = -1; 659 continue; 660 } 661 if (rates[i].idx < 0) { 662 inval = true; 663 continue; 664 } 665 666 /* 667 * For now assume MCS is already set up correctly, this 668 * needs to be fixed. 669 */ 670 if (rates[i].flags & IEEE80211_TX_RC_MCS) { 671 WARN_ON(rates[i].idx > 76); 672 673 if (!(rates[i].flags & IEEE80211_TX_RC_USE_RTS_CTS) && 674 info->control.use_cts_prot) 675 rates[i].flags |= 676 IEEE80211_TX_RC_USE_CTS_PROTECT; 677 continue; 678 } 679 680 if (rates[i].flags & IEEE80211_TX_RC_VHT_MCS) { 681 WARN_ON(ieee80211_rate_get_vht_mcs(&rates[i]) > 9); 682 continue; 683 } 684 685 /* set up RTS protection if desired */ 686 if (info->control.use_rts) { 687 rates[i].flags |= IEEE80211_TX_RC_USE_RTS_CTS; 688 info->control.use_cts_prot = false; 689 } 690 691 /* RC is busted */ 692 if (WARN_ON_ONCE(rates[i].idx >= sband->n_bitrates)) { 693 rates[i].idx = -1; 694 continue; 695 } 696 697 rate = &sband->bitrates[rates[i].idx]; 698 699 /* set up short preamble */ 700 if (info->control.short_preamble && 701 rate->flags & IEEE80211_RATE_SHORT_PREAMBLE) 702 rates[i].flags |= IEEE80211_TX_RC_USE_SHORT_PREAMBLE; 703 704 /* set up G protection */ 705 if (!(rates[i].flags & IEEE80211_TX_RC_USE_RTS_CTS) && 706 info->control.use_cts_prot && 707 rate->flags & IEEE80211_RATE_ERP_G) 708 rates[i].flags |= IEEE80211_TX_RC_USE_CTS_PROTECT; 709 } 710 } 711 712 713 static void rate_control_fill_sta_table(struct ieee80211_sta *sta, 714 struct ieee80211_tx_info *info, 715 struct ieee80211_tx_rate *rates, 716 int max_rates) 717 { 718 struct ieee80211_sta_rates *ratetbl = NULL; 719 int i; 720 721 if (sta && !info->control.skip_table) 722 ratetbl = rcu_dereference(sta->rates); 723 724 /* Fill remaining rate slots with data from the sta rate table. */ 725 max_rates = min_t(int, max_rates, IEEE80211_TX_RATE_TABLE_SIZE); 726 for (i = 0; i < max_rates; i++) { 727 if (i < ARRAY_SIZE(info->control.rates) && 728 info->control.rates[i].idx >= 0 && 729 info->control.rates[i].count) { 730 if (rates != info->control.rates) 731 rates[i] = info->control.rates[i]; 732 } else if (ratetbl) { 733 rates[i].idx = ratetbl->rate[i].idx; 734 rates[i].flags = ratetbl->rate[i].flags; 735 if (info->control.use_rts) 736 rates[i].count = ratetbl->rate[i].count_rts; 737 else if (info->control.use_cts_prot) 738 rates[i].count = ratetbl->rate[i].count_cts; 739 else 740 rates[i].count = ratetbl->rate[i].count; 741 } else { 742 rates[i].idx = -1; 743 rates[i].count = 0; 744 } 745 746 if (rates[i].idx < 0 || !rates[i].count) 747 break; 748 } 749 } 750 751 static bool rate_control_cap_mask(struct ieee80211_sub_if_data *sdata, 752 struct ieee80211_supported_band *sband, 753 struct ieee80211_sta *sta, u32 *mask, 754 u8 mcs_mask[IEEE80211_HT_MCS_MASK_LEN], 755 u16 vht_mask[NL80211_VHT_NSS_MAX]) 756 { 757 u32 i, flags; 758 759 *mask = sdata->rc_rateidx_mask[sband->band]; 760 flags = ieee80211_chandef_rate_flags(&sdata->vif.bss_conf.chandef); 761 for (i = 0; i < sband->n_bitrates; i++) { 762 if ((flags & sband->bitrates[i].flags) != flags) 763 *mask &= ~BIT(i); 764 } 765 766 if (*mask == (1 << sband->n_bitrates) - 1 && 767 !sdata->rc_has_mcs_mask[sband->band] && 768 !sdata->rc_has_vht_mcs_mask[sband->band]) 769 return false; 770 771 if (sdata->rc_has_mcs_mask[sband->band]) 772 memcpy(mcs_mask, sdata->rc_rateidx_mcs_mask[sband->band], 773 IEEE80211_HT_MCS_MASK_LEN); 774 else 775 memset(mcs_mask, 0xff, IEEE80211_HT_MCS_MASK_LEN); 776 777 if (sdata->rc_has_vht_mcs_mask[sband->band]) 778 memcpy(vht_mask, sdata->rc_rateidx_vht_mcs_mask[sband->band], 779 sizeof(u16) * NL80211_VHT_NSS_MAX); 780 else 781 memset(vht_mask, 0xff, sizeof(u16) * NL80211_VHT_NSS_MAX); 782 783 if (sta) { 784 __le16 sta_vht_cap; 785 u16 sta_vht_mask[NL80211_VHT_NSS_MAX]; 786 787 /* Filter out rates that the STA does not support */ 788 *mask &= sta->supp_rates[sband->band]; 789 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) 790 mcs_mask[i] &= sta->ht_cap.mcs.rx_mask[i]; 791 792 sta_vht_cap = sta->vht_cap.vht_mcs.rx_mcs_map; 793 ieee80211_get_vht_mask_from_cap(sta_vht_cap, sta_vht_mask); 794 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) 795 vht_mask[i] &= sta_vht_mask[i]; 796 } 797 798 return true; 799 } 800 801 static void 802 rate_control_apply_mask_ratetbl(struct sta_info *sta, 803 struct ieee80211_supported_band *sband, 804 struct ieee80211_sta_rates *rates) 805 { 806 int i; 807 u32 mask; 808 u8 mcs_mask[IEEE80211_HT_MCS_MASK_LEN]; 809 u16 vht_mask[NL80211_VHT_NSS_MAX]; 810 enum nl80211_chan_width chan_width; 811 812 if (!rate_control_cap_mask(sta->sdata, sband, &sta->sta, &mask, 813 mcs_mask, vht_mask)) 814 return; 815 816 chan_width = sta->sdata->vif.bss_conf.chandef.width; 817 for (i = 0; i < IEEE80211_TX_RATE_TABLE_SIZE; i++) { 818 if (rates->rate[i].idx < 0) 819 break; 820 821 rate_idx_match_mask(&rates->rate[i].idx, &rates->rate[i].flags, 822 sband, chan_width, mask, mcs_mask, 823 vht_mask); 824 } 825 } 826 827 static void rate_control_apply_mask(struct ieee80211_sub_if_data *sdata, 828 struct ieee80211_sta *sta, 829 struct ieee80211_supported_band *sband, 830 struct ieee80211_tx_rate *rates, 831 int max_rates) 832 { 833 enum nl80211_chan_width chan_width; 834 u8 mcs_mask[IEEE80211_HT_MCS_MASK_LEN]; 835 u32 mask; 836 u16 rate_flags, vht_mask[NL80211_VHT_NSS_MAX]; 837 int i; 838 839 /* 840 * Try to enforce the rateidx mask the user wanted. skip this if the 841 * default mask (allow all rates) is used to save some processing for 842 * the common case. 843 */ 844 if (!rate_control_cap_mask(sdata, sband, sta, &mask, mcs_mask, 845 vht_mask)) 846 return; 847 848 /* 849 * Make sure the rate index selected for each TX rate is 850 * included in the configured mask and change the rate indexes 851 * if needed. 852 */ 853 chan_width = sdata->vif.bss_conf.chandef.width; 854 for (i = 0; i < max_rates; i++) { 855 /* Skip invalid rates */ 856 if (rates[i].idx < 0) 857 break; 858 859 rate_flags = rates[i].flags; 860 rate_idx_match_mask(&rates[i].idx, &rate_flags, sband, 861 chan_width, mask, mcs_mask, vht_mask); 862 rates[i].flags = rate_flags; 863 } 864 } 865 866 void ieee80211_get_tx_rates(struct ieee80211_vif *vif, 867 struct ieee80211_sta *sta, 868 struct sk_buff *skb, 869 struct ieee80211_tx_rate *dest, 870 int max_rates) 871 { 872 struct ieee80211_sub_if_data *sdata; 873 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data; 874 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 875 struct ieee80211_supported_band *sband; 876 877 rate_control_fill_sta_table(sta, info, dest, max_rates); 878 879 if (!vif) 880 return; 881 882 sdata = vif_to_sdata(vif); 883 sband = sdata->local->hw.wiphy->bands[info->band]; 884 885 if (ieee80211_is_data(hdr->frame_control)) 886 rate_control_apply_mask(sdata, sta, sband, dest, max_rates); 887 888 if (dest[0].idx < 0) 889 __rate_control_send_low(&sdata->local->hw, sband, sta, info, 890 sdata->rc_rateidx_mask[info->band]); 891 892 if (sta) 893 rate_fixup_ratelist(vif, sband, info, dest, max_rates); 894 } 895 EXPORT_SYMBOL(ieee80211_get_tx_rates); 896 897 void rate_control_get_rate(struct ieee80211_sub_if_data *sdata, 898 struct sta_info *sta, 899 struct ieee80211_tx_rate_control *txrc) 900 { 901 struct rate_control_ref *ref = sdata->local->rate_ctrl; 902 void *priv_sta = NULL; 903 struct ieee80211_sta *ista = NULL; 904 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(txrc->skb); 905 int i; 906 907 for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) { 908 info->control.rates[i].idx = -1; 909 info->control.rates[i].flags = 0; 910 info->control.rates[i].count = 0; 911 } 912 913 if (rate_control_send_low(sta ? &sta->sta : NULL, txrc)) 914 return; 915 916 if (ieee80211_hw_check(&sdata->local->hw, HAS_RATE_CONTROL)) 917 return; 918 919 if (sta && test_sta_flag(sta, WLAN_STA_RATE_CONTROL)) { 920 ista = &sta->sta; 921 priv_sta = sta->rate_ctrl_priv; 922 } 923 924 if (ista) { 925 spin_lock_bh(&sta->rate_ctrl_lock); 926 ref->ops->get_rate(ref->priv, ista, priv_sta, txrc); 927 spin_unlock_bh(&sta->rate_ctrl_lock); 928 } else { 929 rate_control_send_low(NULL, txrc); 930 } 931 932 if (ieee80211_hw_check(&sdata->local->hw, SUPPORTS_RC_TABLE)) 933 return; 934 935 ieee80211_get_tx_rates(&sdata->vif, ista, txrc->skb, 936 info->control.rates, 937 ARRAY_SIZE(info->control.rates)); 938 } 939 940 int rate_control_set_rates(struct ieee80211_hw *hw, 941 struct ieee80211_sta *pubsta, 942 struct ieee80211_sta_rates *rates) 943 { 944 struct sta_info *sta = container_of(pubsta, struct sta_info, sta); 945 struct ieee80211_sta_rates *old; 946 struct ieee80211_supported_band *sband; 947 948 sband = ieee80211_get_sband(sta->sdata); 949 if (!sband) 950 return -EINVAL; 951 rate_control_apply_mask_ratetbl(sta, sband, rates); 952 /* 953 * mac80211 guarantees that this function will not be called 954 * concurrently, so the following RCU access is safe, even without 955 * extra locking. This can not be checked easily, so we just set 956 * the condition to true. 957 */ 958 old = rcu_dereference_protected(pubsta->rates, true); 959 rcu_assign_pointer(pubsta->rates, rates); 960 if (old) 961 kfree_rcu(old, rcu_head); 962 963 if (sta->uploaded) 964 drv_sta_rate_tbl_update(hw_to_local(hw), sta->sdata, pubsta); 965 966 ieee80211_sta_set_expected_throughput(pubsta, sta_get_expected_throughput(sta)); 967 968 return 0; 969 } 970 EXPORT_SYMBOL(rate_control_set_rates); 971 972 int ieee80211_init_rate_ctrl_alg(struct ieee80211_local *local, 973 const char *name) 974 { 975 struct rate_control_ref *ref; 976 977 ASSERT_RTNL(); 978 979 if (local->open_count) 980 return -EBUSY; 981 982 if (ieee80211_hw_check(&local->hw, HAS_RATE_CONTROL)) { 983 if (WARN_ON(!local->ops->set_rts_threshold)) 984 return -EINVAL; 985 return 0; 986 } 987 988 ref = rate_control_alloc(name, local); 989 if (!ref) { 990 wiphy_warn(local->hw.wiphy, 991 "Failed to select rate control algorithm\n"); 992 return -ENOENT; 993 } 994 995 WARN_ON(local->rate_ctrl); 996 local->rate_ctrl = ref; 997 998 wiphy_debug(local->hw.wiphy, "Selected rate control algorithm '%s'\n", 999 ref->ops->name); 1000 1001 return 0; 1002 } 1003 1004 void rate_control_deinitialize(struct ieee80211_local *local) 1005 { 1006 struct rate_control_ref *ref; 1007 1008 ref = local->rate_ctrl; 1009 1010 if (!ref) 1011 return; 1012 1013 local->rate_ctrl = NULL; 1014 rate_control_free(local, ref); 1015 } 1016