~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/mac80211/rate.c

Version: ~ [ linux-5.1-rc2 ] ~ [ linux-5.0.4 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.31 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.108 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.165 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.177 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.137 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.63 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp