net/mac80211/rate.c

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