rate.c 25.2 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0-only
2 3 4 5
/*
 * Copyright 2002-2005, Instant802 Networks, Inc.
 * Copyright 2005-2006, Devicescape Software, Inc.
 * 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>
Johannes Berg's avatar
Johannes Berg committed
13
#include "rate.h"
14
#include "ieee80211_i.h"
15
#include "debugfs.h"
16 17 18

struct rate_control_alg {
	struct list_head list;
19
	const struct rate_control_ops *ops;
20 21 22 23 24
};

static LIST_HEAD(rate_ctrl_algs);
static DEFINE_MUTEX(rate_ctrl_mutex);

25 26 27 28 29
static char *ieee80211_default_rc_algo = CONFIG_MAC80211_RC_DEFAULT;
module_param(ieee80211_default_rc_algo, charp, 0644);
MODULE_PARM_DESC(ieee80211_default_rc_algo,
		 "Default rate control algorithm for mac80211 to use");

30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61
void rate_control_rate_init(struct sta_info *sta)
{
	struct ieee80211_local *local = sta->sdata->local;
	struct rate_control_ref *ref = sta->rate_ctrl;
	struct ieee80211_sta *ista = &sta->sta;
	void *priv_sta = sta->rate_ctrl_priv;
	struct ieee80211_supported_band *sband;
	struct ieee80211_chanctx_conf *chanctx_conf;

	ieee80211_sta_set_rx_nss(sta);

	if (!ref)
		return;

	rcu_read_lock();

	chanctx_conf = rcu_dereference(sta->sdata->vif.chanctx_conf);
	if (WARN_ON(!chanctx_conf)) {
		rcu_read_unlock();
		return;
	}

	sband = local->hw.wiphy->bands[chanctx_conf->def.chan->band];

	spin_lock_bh(&sta->rate_ctrl_lock);
	ref->ops->rate_init(ref->priv, sband, &chanctx_conf->def, ista,
			    priv_sta);
	spin_unlock_bh(&sta->rate_ctrl_lock);
	rcu_read_unlock();
	set_sta_flag(sta, WLAN_STA_RATE_CONTROL);
}

62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83
void rate_control_tx_status(struct ieee80211_local *local,
			    struct ieee80211_supported_band *sband,
			    struct ieee80211_tx_status *st)
{
	struct rate_control_ref *ref = local->rate_ctrl;
	struct sta_info *sta = container_of(st->sta, struct sta_info, sta);
	void *priv_sta = sta->rate_ctrl_priv;

	if (!ref || !test_sta_flag(sta, WLAN_STA_RATE_CONTROL))
		return;

	spin_lock_bh(&sta->rate_ctrl_lock);
	if (ref->ops->tx_status_ext)
		ref->ops->tx_status_ext(ref->priv, sband, priv_sta, st);
	else if (st->skb)
		ref->ops->tx_status(ref->priv, sband, st->sta, priv_sta, st->skb);
	else
		WARN_ON_ONCE(1);

	spin_unlock_bh(&sta->rate_ctrl_lock);
}

84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110
void rate_control_rate_update(struct ieee80211_local *local,
				    struct ieee80211_supported_band *sband,
				    struct sta_info *sta, u32 changed)
{
	struct rate_control_ref *ref = local->rate_ctrl;
	struct ieee80211_sta *ista = &sta->sta;
	void *priv_sta = sta->rate_ctrl_priv;
	struct ieee80211_chanctx_conf *chanctx_conf;

	if (ref && ref->ops->rate_update) {
		rcu_read_lock();

		chanctx_conf = rcu_dereference(sta->sdata->vif.chanctx_conf);
		if (WARN_ON(!chanctx_conf)) {
			rcu_read_unlock();
			return;
		}

		spin_lock_bh(&sta->rate_ctrl_lock);
		ref->ops->rate_update(ref->priv, sband, &chanctx_conf->def,
				      ista, priv_sta, changed);
		spin_unlock_bh(&sta->rate_ctrl_lock);
		rcu_read_unlock();
	}
	drv_sta_rc_update(local, sta->sdata, &sta->sta, changed);
}

111
int ieee80211_rate_control_register(const struct rate_control_ops *ops)
112 113 114
{
	struct rate_control_alg *alg;

115 116 117
	if (!ops->name)
		return -EINVAL;

118 119 120 121 122
	mutex_lock(&rate_ctrl_mutex);
	list_for_each_entry(alg, &rate_ctrl_algs, list) {
		if (!strcmp(alg->ops->name, ops->name)) {
			/* don't register an algorithm twice */
			WARN_ON(1);
123
			mutex_unlock(&rate_ctrl_mutex);
124 125 126 127
			return -EALREADY;
		}
	}

128
	alg = kzalloc(sizeof(*alg), GFP_KERNEL);
129
	if (alg == NULL) {
130
		mutex_unlock(&rate_ctrl_mutex);
131 132 133 134 135 136 137 138 139 140 141
		return -ENOMEM;
	}
	alg->ops = ops;

	list_add_tail(&alg->list, &rate_ctrl_algs);
	mutex_unlock(&rate_ctrl_mutex);

	return 0;
}
EXPORT_SYMBOL(ieee80211_rate_control_register);

142
void ieee80211_rate_control_unregister(const struct rate_control_ops *ops)
143 144 145 146 147 148 149
{
	struct rate_control_alg *alg;

	mutex_lock(&rate_ctrl_mutex);
	list_for_each_entry(alg, &rate_ctrl_algs, list) {
		if (alg->ops == ops) {
			list_del(&alg->list);
150
			kfree(alg);
151 152 153 154 155 156 157
			break;
		}
	}
	mutex_unlock(&rate_ctrl_mutex);
}
EXPORT_SYMBOL(ieee80211_rate_control_unregister);

158
static const struct rate_control_ops *
159 160 161
ieee80211_try_rate_control_ops_get(const char *name)
{
	struct rate_control_alg *alg;
162
	const struct rate_control_ops *ops = NULL;
163

164 165 166
	if (!name)
		return NULL;

167 168
	mutex_lock(&rate_ctrl_mutex);
	list_for_each_entry(alg, &rate_ctrl_algs, list) {
169 170 171 172
		if (!strcmp(alg->ops->name, name)) {
			ops = alg->ops;
			break;
		}
173 174 175 176 177
	}
	mutex_unlock(&rate_ctrl_mutex);
	return ops;
}

178
/* Get the rate control algorithm. */
179
static const struct rate_control_ops *
180 181
ieee80211_rate_control_ops_get(const char *name)
{
182
	const struct rate_control_ops *ops;
183
	const char *alg_name;
184

185
	kernel_param_lock(THIS_MODULE);
186
	if (!name)
187 188 189
		alg_name = ieee80211_default_rc_algo;
	else
		alg_name = name;
190

191 192 193 194 195
	ops = ieee80211_try_rate_control_ops_get(alg_name);
	if (!ops && name)
		/* try default if specific alg requested but not found */
		ops = ieee80211_try_rate_control_ops_get(ieee80211_default_rc_algo);

196 197 198
	/* Note: check for > 0 is intentional to avoid clang warning */
	if (!ops && (strlen(CONFIG_MAC80211_RC_DEFAULT) > 0))
		/* try built-in one if specific alg requested but not found */
199
		ops = ieee80211_try_rate_control_ops_get(CONFIG_MAC80211_RC_DEFAULT);
200

201
	kernel_param_unlock(THIS_MODULE);
202

203 204 205
	return ops;
}

206 207 208 209 210 211 212 213 214 215 216 217 218
#ifdef CONFIG_MAC80211_DEBUGFS
static ssize_t rcname_read(struct file *file, char __user *userbuf,
			   size_t count, loff_t *ppos)
{
	struct rate_control_ref *ref = file->private_data;
	int len = strlen(ref->ops->name);

	return simple_read_from_buffer(userbuf, count, ppos,
				       ref->ops->name, len);
}

static const struct file_operations rcname_ops = {
	.read = rcname_read,
219
	.open = simple_open,
220
	.llseek = default_llseek,
221 222 223
};
#endif

224
static struct rate_control_ref *rate_control_alloc(const char *name,
225 226
					    struct ieee80211_local *local)
{
227
	struct dentry *debugfsdir = NULL;
228 229 230 231
	struct rate_control_ref *ref;

	ref = kmalloc(sizeof(struct rate_control_ref), GFP_KERNEL);
	if (!ref)
232
		return NULL;
233 234
	ref->ops = ieee80211_rate_control_ops_get(name);
	if (!ref->ops)
235
		goto free;
236 237 238 239

#ifdef CONFIG_MAC80211_DEBUGFS
	debugfsdir = debugfs_create_dir("rc", local->hw.wiphy->debugfsdir);
	local->debugfs.rcdir = debugfsdir;
240
	debugfs_create_file("name", 0400, debugfsdir, ref, &rcname_ops);
241 242 243
#endif

	ref->priv = ref->ops->alloc(&local->hw, debugfsdir);
244
	if (!ref->priv)
245
		goto free;
246 247
	return ref;

248
free:
249 250 251 252
	kfree(ref);
	return NULL;
}

253 254
static void rate_control_free(struct ieee80211_local *local,
			      struct rate_control_ref *ctrl_ref)
255 256
{
	ctrl_ref->ops->free(ctrl_ref->priv);
257 258

#ifdef CONFIG_MAC80211_DEBUGFS
259 260
	debugfs_remove_recursive(local->debugfs.rcdir);
	local->debugfs.rcdir = NULL;
261 262
#endif

263 264 265
	kfree(ctrl_ref);
}

266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291
void ieee80211_check_rate_mask(struct ieee80211_sub_if_data *sdata)
{
	struct ieee80211_local *local = sdata->local;
	struct ieee80211_supported_band *sband;
	u32 user_mask, basic_rates = sdata->vif.bss_conf.basic_rates;
	enum nl80211_band band;

	if (WARN_ON(!sdata->vif.bss_conf.chandef.chan))
		return;

	if (WARN_ON_ONCE(!basic_rates))
		return;

	band = sdata->vif.bss_conf.chandef.chan->band;
	user_mask = sdata->rc_rateidx_mask[band];
	sband = local->hw.wiphy->bands[band];

	if (user_mask & basic_rates)
		return;

	sdata_dbg(sdata,
		  "no overlap between basic rates (0x%x) and user mask (0x%x on band %d) - clearing the latter",
		  basic_rates, user_mask, band);
	sdata->rc_rateidx_mask[band] = (1 << sband->n_bitrates) - 1;
}

292
static bool rc_no_data_or_no_ack_use_min(struct ieee80211_tx_rate_control *txrc)
293 294 295 296 297 298 299 300
{
	struct sk_buff *skb = txrc->skb;
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
	__le16 fc;

	fc = hdr->frame_control;

301 302 303
	return (info->flags & (IEEE80211_TX_CTL_NO_ACK |
			       IEEE80211_TX_CTL_USE_MINRATE)) ||
		!ieee80211_is_data(fc);
304 305
}

306
static void rc_send_low_basicrate(s8 *idx, u32 basic_rates,
307
				  struct ieee80211_supported_band *sband)
308 309 310 311 312 313 314 315 316 317
{
	u8 i;

	if (basic_rates == 0)
		return; /* assume basic rates unknown and accept rate */
	if (*idx < 0)
		return;
	if (basic_rates & (1 << *idx))
		return; /* selected rate is a basic rate */

318
	for (i = *idx + 1; i <= sband->n_bitrates; i++) {
319 320 321 322 323 324 325 326 327
		if (basic_rates & (1 << i)) {
			*idx = i;
			return;
		}
	}

	/* could not find a basic rate; use original selection */
}

328 329 330
static void __rate_control_send_low(struct ieee80211_hw *hw,
				    struct ieee80211_supported_band *sband,
				    struct ieee80211_sta *sta,
331 332
				    struct ieee80211_tx_info *info,
				    u32 rate_mask)
333 334
{
	int i;
335 336
	u32 rate_flags =
		ieee80211_chandef_rate_flags(&hw->conf.chandef);
337

338
	if ((sband->band == NL80211_BAND_2GHZ) &&
339 340 341 342
	    (info->flags & IEEE80211_TX_CTL_NO_CCK_RATE))
		rate_flags |= IEEE80211_RATE_ERP_G;

	info->control.rates[0].idx = 0;
343
	for (i = 0; i < sband->n_bitrates; i++) {
344 345 346
		if (!(rate_mask & BIT(i)))
			continue;

347 348 349
		if ((rate_flags & sband->bitrates[i].flags) != rate_flags)
			continue;

350
		if (!rate_supported(sta, sband->band, i))
351 352
			continue;

353 354
		info->control.rates[0].idx = i;
		break;
355
	}
356
	WARN_ONCE(i == sband->n_bitrates,
357 358
		  "no supported rates for sta %pM (0x%x, band %d) in rate_mask 0x%x with flags 0x%x\n",
		  sta ? sta->addr : NULL,
359
		  sta ? sta->supp_rates[sband->band] : -1,
360
		  sband->band,
361
		  rate_mask, rate_flags);
362 363 364 365 366 367 368 369

	info->control.rates[0].count =
		(info->flags & IEEE80211_TX_CTL_NO_ACK) ?
		1 : hw->max_rate_tries;

	info->control.skip_table = 1;
}

370

371 372
static bool rate_control_send_low(struct ieee80211_sta *pubsta,
				  struct ieee80211_tx_rate_control *txrc)
373 374
{
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(txrc->skb);
375
	struct ieee80211_supported_band *sband = txrc->sband;
376
	struct sta_info *sta;
377
	int mcast_rate;
378
	bool use_basicrate = false;
379

380
	if (!pubsta || rc_no_data_or_no_ack_use_min(txrc)) {
381 382
		__rate_control_send_low(txrc->hw, sband, pubsta, info,
					txrc->rate_idx_mask);
383

384
		if (!pubsta && txrc->bss) {
385 386 387 388 389
			mcast_rate = txrc->bss_conf->mcast_rate[sband->band];
			if (mcast_rate > 0) {
				info->control.rates[0].idx = mcast_rate - 1;
				return true;
			}
390 391 392 393 394 395
			use_basicrate = true;
		} else if (pubsta) {
			sta = container_of(pubsta, struct sta_info, sta);
			if (ieee80211_vif_is_mesh(&sta->sdata->vif))
				use_basicrate = true;
		}
396

397 398
		if (use_basicrate)
			rc_send_low_basicrate(&info->control.rates[0].idx,
399
					      txrc->bss_conf->basic_rates,
400
					      sband);
401

402 403 404 405 406
		return true;
	}
	return false;
}

407
static bool rate_idx_match_legacy_mask(s8 *rate_idx, int n_bitrates, u32 mask)
408 409 410 411
{
	int j;

	/* See whether the selected rate or anything below it is allowed. */
412
	for (j = *rate_idx; j >= 0; j--) {
413 414
		if (mask & (1 << j)) {
			/* Okay, found a suitable rate. Use it. */
415
			*rate_idx = j;
416
			return true;
417 418 419 420
		}
	}

	/* Try to find a higher rate that would be allowed */
421
	for (j = *rate_idx + 1; j < n_bitrates; j++) {
422 423
		if (mask & (1 << j)) {
			/* Okay, found a suitable rate. Use it. */
424
			*rate_idx = j;
425 426 427 428 429 430
			return true;
		}
	}
	return false;
}

431
static bool rate_idx_match_mcs_mask(s8 *rate_idx, u8 *mcs_mask)
432 433 434 435
{
	int i, j;
	int ridx, rbit;

436 437
	ridx = *rate_idx / 8;
	rbit = *rate_idx % 8;
438 439

	/* sanity check */
440
	if (ridx < 0 || ridx >= IEEE80211_HT_MCS_MASK_LEN)
441 442 443 444 445 446
		return false;

	/* See whether the selected rate or anything below it is allowed. */
	for (i = ridx; i >= 0; i--) {
		for (j = rbit; j >= 0; j--)
			if (mcs_mask[i] & BIT(j)) {
447
				*rate_idx = i * 8 + j;
448 449 450 451 452 453
				return true;
			}
		rbit = 7;
	}

	/* Try to find a higher rate that would be allowed */
454 455
	ridx = (*rate_idx + 1) / 8;
	rbit = (*rate_idx + 1) % 8;
456 457 458 459

	for (i = ridx; i < IEEE80211_HT_MCS_MASK_LEN; i++) {
		for (j = rbit; j < 8; j++)
			if (mcs_mask[i] & BIT(j)) {
460
				*rate_idx = i * 8 + j;
461 462 463 464 465 466 467
				return true;
			}
		rbit = 0;
	}
	return false;
}

468 469 470 471 472 473 474 475 476 477
static bool rate_idx_match_vht_mcs_mask(s8 *rate_idx, u16 *vht_mask)
{
	int i, j;
	int ridx, rbit;

	ridx = *rate_idx >> 4;
	rbit = *rate_idx & 0xf;

	if (ridx < 0 || ridx >= NL80211_VHT_NSS_MAX)
		return false;
478

479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504
	/* See whether the selected rate or anything below it is allowed. */
	for (i = ridx; i >= 0; i--) {
		for (j = rbit; j >= 0; j--) {
			if (vht_mask[i] & BIT(j)) {
				*rate_idx = (i << 4) | j;
				return true;
			}
		}
		rbit = 15;
	}

	/* Try to find a higher rate that would be allowed */
	ridx = (*rate_idx + 1) >> 4;
	rbit = (*rate_idx + 1) & 0xf;

	for (i = ridx; i < NL80211_VHT_NSS_MAX; i++) {
		for (j = rbit; j < 16; j++) {
			if (vht_mask[i] & BIT(j)) {
				*rate_idx = (i << 4) | j;
				return true;
			}
		}
		rbit = 0;
	}
	return false;
}
505

506
static void rate_idx_match_mask(s8 *rate_idx, u16 *rate_flags,
507 508
				struct ieee80211_supported_band *sband,
				enum nl80211_chan_width chan_width,
509
				u32 mask,
510 511
				u8 mcs_mask[IEEE80211_HT_MCS_MASK_LEN],
				u16 vht_mask[NL80211_VHT_NSS_MAX])
512
{
513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538
	if (*rate_flags & IEEE80211_TX_RC_VHT_MCS) {
		/* handle VHT rates */
		if (rate_idx_match_vht_mcs_mask(rate_idx, vht_mask))
			return;

		*rate_idx = 0;
		/* keep protection flags */
		*rate_flags &= (IEEE80211_TX_RC_USE_RTS_CTS |
				IEEE80211_TX_RC_USE_CTS_PROTECT |
				IEEE80211_TX_RC_USE_SHORT_PREAMBLE);

		*rate_flags |= IEEE80211_TX_RC_MCS;
		if (chan_width == NL80211_CHAN_WIDTH_40)
			*rate_flags |= IEEE80211_TX_RC_40_MHZ_WIDTH;

		if (rate_idx_match_mcs_mask(rate_idx, mcs_mask))
			return;

		/* also try the legacy rates. */
		*rate_flags &= ~(IEEE80211_TX_RC_MCS |
				 IEEE80211_TX_RC_40_MHZ_WIDTH);
		if (rate_idx_match_legacy_mask(rate_idx, sband->n_bitrates,
					       mask))
			return;
	} else if (*rate_flags & IEEE80211_TX_RC_MCS) {
		/* handle HT rates */
539
		if (rate_idx_match_mcs_mask(rate_idx, mcs_mask))
540 541 542
			return;

		/* also try the legacy rates. */
543
		*rate_idx = 0;
544
		/* keep protection flags */
545 546 547 548 549
		*rate_flags &= (IEEE80211_TX_RC_USE_RTS_CTS |
				IEEE80211_TX_RC_USE_CTS_PROTECT |
				IEEE80211_TX_RC_USE_SHORT_PREAMBLE);
		if (rate_idx_match_legacy_mask(rate_idx, sband->n_bitrates,
					       mask))
550
			return;
551
	} else {
552
		/* handle legacy rates */
553 554
		if (rate_idx_match_legacy_mask(rate_idx, sband->n_bitrates,
					       mask))
555 556 557
			return;

		/* if HT BSS, and we handle a data frame, also try HT rates */
558 559 560 561
		switch (chan_width) {
		case NL80211_CHAN_WIDTH_20_NOHT:
		case NL80211_CHAN_WIDTH_5:
		case NL80211_CHAN_WIDTH_10:
562
			return;
563 564 565
		default:
			break;
		}
566

567
		*rate_idx = 0;
568
		/* keep protection flags */
569 570 571
		*rate_flags &= (IEEE80211_TX_RC_USE_RTS_CTS |
				IEEE80211_TX_RC_USE_CTS_PROTECT |
				IEEE80211_TX_RC_USE_SHORT_PREAMBLE);
572

573
		*rate_flags |= IEEE80211_TX_RC_MCS;
574

575
		if (chan_width == NL80211_CHAN_WIDTH_40)
576
			*rate_flags |= IEEE80211_TX_RC_40_MHZ_WIDTH;
577

578
		if (rate_idx_match_mcs_mask(rate_idx, mcs_mask))
579 580 581 582 583 584 585 586 587 588 589 590
			return;
	}

	/*
	 * Uh.. No suitable rate exists. This should not really happen with
	 * sane TX rate mask configurations. However, should someone manage to
	 * configure supported rates and TX rate mask in incompatible way,
	 * allow the frame to be transmitted with whatever the rate control
	 * selected.
	 */
}

591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608
static void rate_fixup_ratelist(struct ieee80211_vif *vif,
				struct ieee80211_supported_band *sband,
				struct ieee80211_tx_info *info,
				struct ieee80211_tx_rate *rates,
				int max_rates)
{
	struct ieee80211_rate *rate;
	bool inval = false;
	int i;

	/*
	 * Set up the RTS/CTS rate as the fastest basic rate
	 * that is not faster than the data rate unless there
	 * is no basic rate slower than the data rate, in which
	 * case we pick the slowest basic rate
	 *
	 * XXX: Should this check all retry rates?
	 */
609 610
	if (!(rates[0].flags &
	      (IEEE80211_TX_RC_MCS | IEEE80211_TX_RC_VHT_MCS))) {
611
		u32 basic_rates = vif->bss_conf.basic_rates;
612
		s8 baserate = basic_rates ? ffs(basic_rates) - 1 : 0;
613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731

		rate = &sband->bitrates[rates[0].idx];

		for (i = 0; i < sband->n_bitrates; i++) {
			/* must be a basic rate */
			if (!(basic_rates & BIT(i)))
				continue;
			/* must not be faster than the data rate */
			if (sband->bitrates[i].bitrate > rate->bitrate)
				continue;
			/* maximum */
			if (sband->bitrates[baserate].bitrate <
			     sband->bitrates[i].bitrate)
				baserate = i;
		}

		info->control.rts_cts_rate_idx = baserate;
	}

	for (i = 0; i < max_rates; i++) {
		/*
		 * make sure there's no valid rate following
		 * an invalid one, just in case drivers don't
		 * take the API seriously to stop at -1.
		 */
		if (inval) {
			rates[i].idx = -1;
			continue;
		}
		if (rates[i].idx < 0) {
			inval = true;
			continue;
		}

		/*
		 * For now assume MCS is already set up correctly, this
		 * needs to be fixed.
		 */
		if (rates[i].flags & IEEE80211_TX_RC_MCS) {
			WARN_ON(rates[i].idx > 76);

			if (!(rates[i].flags & IEEE80211_TX_RC_USE_RTS_CTS) &&
			    info->control.use_cts_prot)
				rates[i].flags |=
					IEEE80211_TX_RC_USE_CTS_PROTECT;
			continue;
		}

		if (rates[i].flags & IEEE80211_TX_RC_VHT_MCS) {
			WARN_ON(ieee80211_rate_get_vht_mcs(&rates[i]) > 9);
			continue;
		}

		/* set up RTS protection if desired */
		if (info->control.use_rts) {
			rates[i].flags |= IEEE80211_TX_RC_USE_RTS_CTS;
			info->control.use_cts_prot = false;
		}

		/* RC is busted */
		if (WARN_ON_ONCE(rates[i].idx >= sband->n_bitrates)) {
			rates[i].idx = -1;
			continue;
		}

		rate = &sband->bitrates[rates[i].idx];

		/* set up short preamble */
		if (info->control.short_preamble &&
		    rate->flags & IEEE80211_RATE_SHORT_PREAMBLE)
			rates[i].flags |= IEEE80211_TX_RC_USE_SHORT_PREAMBLE;

		/* set up G protection */
		if (!(rates[i].flags & IEEE80211_TX_RC_USE_RTS_CTS) &&
		    info->control.use_cts_prot &&
		    rate->flags & IEEE80211_RATE_ERP_G)
			rates[i].flags |= IEEE80211_TX_RC_USE_CTS_PROTECT;
	}
}


static void rate_control_fill_sta_table(struct ieee80211_sta *sta,
					struct ieee80211_tx_info *info,
					struct ieee80211_tx_rate *rates,
					int max_rates)
{
	struct ieee80211_sta_rates *ratetbl = NULL;
	int i;

	if (sta && !info->control.skip_table)
		ratetbl = rcu_dereference(sta->rates);

	/* Fill remaining rate slots with data from the sta rate table. */
	max_rates = min_t(int, max_rates, IEEE80211_TX_RATE_TABLE_SIZE);
	for (i = 0; i < max_rates; i++) {
		if (i < ARRAY_SIZE(info->control.rates) &&
		    info->control.rates[i].idx >= 0 &&
		    info->control.rates[i].count) {
			if (rates != info->control.rates)
				rates[i] = info->control.rates[i];
		} else if (ratetbl) {
			rates[i].idx = ratetbl->rate[i].idx;
			rates[i].flags = ratetbl->rate[i].flags;
			if (info->control.use_rts)
				rates[i].count = ratetbl->rate[i].count_rts;
			else if (info->control.use_cts_prot)
				rates[i].count = ratetbl->rate[i].count_cts;
			else
				rates[i].count = ratetbl->rate[i].count;
		} else {
			rates[i].idx = -1;
			rates[i].count = 0;
		}

		if (rates[i].idx < 0 || !rates[i].count)
			break;
	}
}

732 733 734
static bool rate_control_cap_mask(struct ieee80211_sub_if_data *sdata,
				  struct ieee80211_supported_band *sband,
				  struct ieee80211_sta *sta, u32 *mask,
735 736
				  u8 mcs_mask[IEEE80211_HT_MCS_MASK_LEN],
				  u16 vht_mask[NL80211_VHT_NSS_MAX])
737 738 739 740 741 742 743 744 745 746 747
{
	u32 i, flags;

	*mask = sdata->rc_rateidx_mask[sband->band];
	flags = ieee80211_chandef_rate_flags(&sdata->vif.bss_conf.chandef);
	for (i = 0; i < sband->n_bitrates; i++) {
		if ((flags & sband->bitrates[i].flags) != flags)
			*mask &= ~BIT(i);
	}

	if (*mask == (1 << sband->n_bitrates) - 1 &&
748 749
	    !sdata->rc_has_mcs_mask[sband->band] &&
	    !sdata->rc_has_vht_mcs_mask[sband->band])
750 751 752 753 754 755 756 757
		return false;

	if (sdata->rc_has_mcs_mask[sband->band])
		memcpy(mcs_mask, sdata->rc_rateidx_mcs_mask[sband->band],
		       IEEE80211_HT_MCS_MASK_LEN);
	else
		memset(mcs_mask, 0xff, IEEE80211_HT_MCS_MASK_LEN);

758 759 760 761 762 763
	if (sdata->rc_has_vht_mcs_mask[sband->band])
		memcpy(vht_mask, sdata->rc_rateidx_vht_mcs_mask[sband->band],
		       sizeof(u16) * NL80211_VHT_NSS_MAX);
	else
		memset(vht_mask, 0xff, sizeof(u16) * NL80211_VHT_NSS_MAX);

764
	if (sta) {
765 766 767
		__le16 sta_vht_cap;
		u16 sta_vht_mask[NL80211_VHT_NSS_MAX];

768 769
		/* Filter out rates that the STA does not support */
		*mask &= sta->supp_rates[sband->band];
770
		for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++)
771
			mcs_mask[i] &= sta->ht_cap.mcs.rx_mask[i];
772 773 774 775 776

		sta_vht_cap = sta->vht_cap.vht_mcs.rx_mcs_map;
		ieee80211_get_vht_mask_from_cap(sta_vht_cap, sta_vht_mask);
		for (i = 0; i < NL80211_VHT_NSS_MAX; i++)
			vht_mask[i] &= sta_vht_mask[i];
777 778 779 780 781
	}

	return true;
}

782 783 784 785 786 787 788 789
static void
rate_control_apply_mask_ratetbl(struct sta_info *sta,
				struct ieee80211_supported_band *sband,
				struct ieee80211_sta_rates *rates)
{
	int i;
	u32 mask;
	u8 mcs_mask[IEEE80211_HT_MCS_MASK_LEN];
790
	u16 vht_mask[NL80211_VHT_NSS_MAX];
791 792 793
	enum nl80211_chan_width chan_width;

	if (!rate_control_cap_mask(sta->sdata, sband, &sta->sta, &mask,
794
				   mcs_mask, vht_mask))
795 796 797 798 799 800 801 802
		return;

	chan_width = sta->sdata->vif.bss_conf.chandef.width;
	for (i = 0; i < IEEE80211_TX_RATE_TABLE_SIZE; i++) {
		if (rates->rate[i].idx < 0)
			break;

		rate_idx_match_mask(&rates->rate[i].idx, &rates->rate[i].flags,
803 804
				    sband, chan_width, mask, mcs_mask,
				    vht_mask);
805 806 807
	}
}

808 809 810 811 812 813 814 815 816
static void rate_control_apply_mask(struct ieee80211_sub_if_data *sdata,
				    struct ieee80211_sta *sta,
				    struct ieee80211_supported_band *sband,
				    struct ieee80211_tx_rate *rates,
				    int max_rates)
{
	enum nl80211_chan_width chan_width;
	u8 mcs_mask[IEEE80211_HT_MCS_MASK_LEN];
	u32 mask;
817
	u16 rate_flags, vht_mask[NL80211_VHT_NSS_MAX];
818 819 820 821 822 823 824
	int i;

	/*
	 * Try to enforce the rateidx mask the user wanted. skip this if the
	 * default mask (allow all rates) is used to save some processing for
	 * the common case.
	 */
825 826
	if (!rate_control_cap_mask(sdata, sband, sta, &mask, mcs_mask,
				   vht_mask))
827 828 829 830 831 832 833 834 835 836 837 838 839
		return;

	/*
	 * Make sure the rate index selected for each TX rate is
	 * included in the configured mask and change the rate indexes
	 * if needed.
	 */
	chan_width = sdata->vif.bss_conf.chandef.width;
	for (i = 0; i < max_rates; i++) {
		/* Skip invalid rates */
		if (rates[i].idx < 0)
			break;

840 841
		rate_flags = rates[i].flags;
		rate_idx_match_mask(&rates[i].idx, &rate_flags, sband,
842
				    chan_width, mask, mcs_mask, vht_mask);
843
		rates[i].flags = rate_flags;
844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866
	}
}

void ieee80211_get_tx_rates(struct ieee80211_vif *vif,
			    struct ieee80211_sta *sta,
			    struct sk_buff *skb,
			    struct ieee80211_tx_rate *dest,
			    int max_rates)
{
	struct ieee80211_sub_if_data *sdata;
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
	struct ieee80211_supported_band *sband;

	rate_control_fill_sta_table(sta, info, dest, max_rates);

	if (!vif)
		return;

	sdata = vif_to_sdata(vif);
	sband = sdata->local->hw.wiphy->bands[info->band];

	if (ieee80211_is_data(hdr->frame_control))
867
		rate_control_apply_mask(sdata, sta, sband, dest, max_rates);
868 869

	if (dest[0].idx < 0)
870 871
		__rate_control_send_low(&sdata->local->hw, sband, sta, info,
					sdata->rc_rateidx_mask[info->band]);
872 873 874 875 876 877

	if (sta)
		rate_fixup_ratelist(vif, sband, info, dest, max_rates);
}
EXPORT_SYMBOL(ieee80211_get_tx_rates);

878
void rate_control_get_rate(struct ieee80211_sub_if_data *sdata,
879 880
			   struct sta_info *sta,
			   struct ieee80211_tx_rate_control *txrc)
881
{
882 883 884
	struct rate_control_ref *ref = sdata->local->rate_ctrl;
	void *priv_sta = NULL;
	struct ieee80211_sta *ista = NULL;
885
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(txrc->skb);
886 887
	int i;

888 889 890
	for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
		info->control.rates[i].idx = -1;
		info->control.rates[i].flags = 0;
891
		info->control.rates[i].count = 0;
892 893
	}

894
	if (rate_control_send_low(sta ? &sta->sta : NULL, txrc))
895 896
		return;

897
	if (ieee80211_hw_check(&sdata->local->hw, HAS_RATE_CONTROL))
898 899
		return;

900 901 902 903 904
	if (sta && test_sta_flag(sta, WLAN_STA_RATE_CONTROL)) {
		ista = &sta->sta;
		priv_sta = sta->rate_ctrl_priv;
	}

Johannes Berg's avatar
Johannes Berg committed
905 906 907 908 909
	if (ista) {
		spin_lock_bh(&sta->rate_ctrl_lock);
		ref->ops->get_rate(ref->priv, ista, priv_sta, txrc);
		spin_unlock_bh(&sta->rate_ctrl_lock);
	} else {
910
		rate_control_send_low(NULL, txrc);
Johannes Berg's avatar
Johannes Berg committed
911
	}
912

913
	if (ieee80211_hw_check(&sdata->local->hw, SUPPORTS_RC_TABLE))
914 915 916 917 918 919
		return;

	ieee80211_get_tx_rates(&sdata->vif, ista, txrc->skb,
			       info->control.rates,
			       ARRAY_SIZE(info->control.rates));
}
920

921 922 923 924
int rate_control_set_rates(struct ieee80211_hw *hw,
			   struct ieee80211_sta *pubsta,
			   struct ieee80211_sta_rates *rates)
{
925
	struct sta_info *sta = container_of(pubsta, struct sta_info, sta);
926
	struct ieee80211_sta_rates *old;
927
	struct ieee80211_supported_band *sband;
928

929 930 931
	sband = ieee80211_get_sband(sta->sdata);
	if (!sband)
		return -EINVAL;
932
	rate_control_apply_mask_ratetbl(sta, sband, rates);
933 934 935 936 937 938 939
	/*
	 * mac80211 guarantees that this function will not be called
	 * concurrently, so the following RCU access is safe, even without
	 * extra locking. This can not be checked easily, so we just set
	 * the condition to true.
	 */
	old = rcu_dereference_protected(pubsta->rates, true);
940 941 942 943
	rcu_assign_pointer(pubsta->rates, rates);
	if (old)
		kfree_rcu(old, rcu_head);

944 945
	drv_sta_rate_tbl_update(hw_to_local(hw), sta->sdata, pubsta);

946 947
	ieee80211_sta_set_expected_throughput(pubsta, sta_get_expected_throughput(sta));

948
	return 0;
949
}
950
EXPORT_SYMBOL(rate_control_set_rates);
951

952 953 954
int ieee80211_init_rate_ctrl_alg(struct ieee80211_local *local,
				 const char *name)
{
955
	struct rate_control_ref *ref;
956 957

	ASSERT_RTNL();
958

959
	if (local->open_count)
960 961
		return -EBUSY;

962
	if (ieee80211_hw_check(&local->hw, HAS_RATE_CONTROL)) {
963 964 965 966 967
		if (WARN_ON(!local->ops->set_rts_threshold))
			return -EINVAL;
		return 0;
	}

968 969
	ref = rate_control_alloc(name, local);
	if (!ref) {
970 971
		wiphy_warn(local->hw.wiphy,
			   "Failed to select rate control algorithm\n");
972 973 974
		return -ENOENT;
	}

975
	WARN_ON(local->rate_ctrl);
976 977
	local->rate_ctrl = ref;

978 979
	wiphy_debug(local->hw.wiphy, "Selected rate control algorithm '%s'\n",
		    ref->ops->name);
980 981 982 983 984 985 986 987 988

	return 0;
}

void rate_control_deinitialize(struct ieee80211_local *local)
{
	struct rate_control_ref *ref;

	ref = local->rate_ctrl;
989 990 991 992

	if (!ref)
		return;

993
	local->rate_ctrl = NULL;
994
	rate_control_free(local, ref);
995
}