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