net/mac80211/rate.c

   1 /*
   2  * Copyright 2002-2005, Instant802 Networks, Inc.
   3  * Copyright 2005-2006, Devicescape Software, Inc.
   4  * Copyright (c) 2006 Jiri Benc <jbenc@suse.cz>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  */
  10
  11 #include <linux/kernel.h>
  12 #include <linux/rtnetlink.h>
  13 #include "rate.h"
  14 #include "ieee80211_i.h"
  15 #include "debugfs.h"
  16
  17 struct rate_control_alg {
  18         struct list_head list;
  19         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_COMPAT_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 int ieee80211_rate_control_register(struct rate_control_ops *ops)
  31 {
  32         struct rate_control_alg *alg;
  33
  34         if (!ops->name)
  35                 return -EINVAL;
  36
  37         mutex_lock(&rate_ctrl_mutex);
  38         list_for_each_entry(alg, &rate_ctrl_algs, list) {
  39                 if (!strcmp(alg->ops->name, ops->name)) {
  40                         /* don't register an algorithm twice */
  41                         WARN_ON(1);
  42                         mutex_unlock(&rate_ctrl_mutex);
  43                         return -EALREADY;
  44                 }
  45         }
  46
  47         alg = kzalloc(sizeof(*alg), GFP_KERNEL);
  48         if (alg == NULL) {
  49                 mutex_unlock(&rate_ctrl_mutex);
  50                 return -ENOMEM;
  51         }
  52         alg->ops = ops;
  53
  54         list_add_tail(&alg->list, &rate_ctrl_algs);
  55         mutex_unlock(&rate_ctrl_mutex);
  56
  57         return 0;
  58 }
  59 EXPORT_SYMBOL(ieee80211_rate_control_register);
  60
  61 void ieee80211_rate_control_unregister(struct rate_control_ops *ops)
  62 {
  63         struct rate_control_alg *alg;
  64
  65         mutex_lock(&rate_ctrl_mutex);
  66         list_for_each_entry(alg, &rate_ctrl_algs, list) {
  67                 if (alg->ops == ops) {
  68                         list_del(&alg->list);
  69                         kfree(alg);
  70                         break;
  71                 }
  72         }
  73         mutex_unlock(&rate_ctrl_mutex);
  74 }
  75 EXPORT_SYMBOL(ieee80211_rate_control_unregister);
  76
  77 static struct rate_control_ops *
  78 ieee80211_try_rate_control_ops_get(const char *name)
  79 {
  80         struct rate_control_alg *alg;
  81         struct rate_control_ops *ops = NULL;
  82
  83         if (!name)
  84                 return NULL;
  85
  86         mutex_lock(&rate_ctrl_mutex);
  87         list_for_each_entry(alg, &rate_ctrl_algs, list) {
  88                 if (!strcmp(alg->ops->name, name))
  89                         if (try_module_get(alg->ops->module)) {
  90                                 ops = alg->ops;
  91                                 break;
  92                         }
  93         }
  94         mutex_unlock(&rate_ctrl_mutex);
  95         return ops;
  96 }
  97
  98 /* Get the rate control algorithm. */
  99 static struct rate_control_ops *
 100 ieee80211_rate_control_ops_get(const char *name)
 101 {
 102         struct rate_control_ops *ops;
 103         const char *alg_name;
 104
 105         if (!name)
 106                 alg_name = ieee80211_default_rc_algo;
 107         else
 108                 alg_name = name;
 109
 110         ops = ieee80211_try_rate_control_ops_get(alg_name);
 111         if (!ops) {
 112                 request_module("rc80211_%s", alg_name);
 113                 ops = ieee80211_try_rate_control_ops_get(alg_name);
 114         }
 115         if (!ops && name)
 116                 /* try default if specific alg requested but not found */
 117                 ops = ieee80211_try_rate_control_ops_get(ieee80211_default_rc_algo);
 118
 119         /* try built-in one if specific alg requested but not found */
 120         if (!ops && strlen(CONFIG_COMPAT_MAC80211_RC_DEFAULT))
 121                 ops = ieee80211_try_rate_control_ops_get(CONFIG_COMPAT_MAC80211_RC_DEFAULT);
 122
 123         return ops;
 124 }
 125
 126 static void ieee80211_rate_control_ops_put(struct rate_control_ops *ops)
 127 {
 128         module_put(ops->module);
 129 }
 130
 131 #ifdef CONFIG_MAC80211_DEBUGFS
 132 static ssize_t rcname_read(struct file *file, char __user *userbuf,
 133                            size_t count, loff_t *ppos)
 134 {
 135         struct rate_control_ref *ref = file->private_data;
 136         int len = strlen(ref->ops->name);
 137
 138         return simple_read_from_buffer(userbuf, count, ppos,
 139                                        ref->ops->name, len);
 140 }
 141
 142 static const struct file_operations rcname_ops = {
 143         .read = rcname_read,
 144         .open = mac80211_open_file_generic,
 145 };
 146 #endif
 147
 148 static struct rate_control_ref *rate_control_alloc(const char *name,
 149                                             struct ieee80211_local *local)
 150 {
 151         struct dentry *debugfsdir = NULL;
 152         struct rate_control_ref *ref;
 153
 154         ref = kmalloc(sizeof(struct rate_control_ref), GFP_KERNEL);
 155         if (!ref)
 156                 goto fail_ref;
 157         kref_init(&ref->kref);
 158         ref->local = local;
 159         ref->ops = ieee80211_rate_control_ops_get(name);
 160         if (!ref->ops)
 161                 goto fail_ops;
 162
 163 #ifdef CONFIG_MAC80211_DEBUGFS
 164         debugfsdir = debugfs_create_dir("rc", local->hw.wiphy->debugfsdir);
 165         local->debugfs.rcdir = debugfsdir;
 166         debugfs_create_file("name", 0400, debugfsdir, ref, &rcname_ops);
 167 #endif
 168
 169         ref->priv = ref->ops->alloc(&local->hw, debugfsdir);
 170         if (!ref->priv)
 171                 goto fail_priv;
 172         return ref;
 173
 174 fail_priv:
 175         ieee80211_rate_control_ops_put(ref->ops);
 176 fail_ops:
 177         kfree(ref);
 178 fail_ref:
 179         return NULL;
 180 }
 181
 182 static void rate_control_release(struct kref *kref)
 183 {
 184         struct rate_control_ref *ctrl_ref;
 185
 186         ctrl_ref = container_of(kref, struct rate_control_ref, kref);
 187         ctrl_ref->ops->free(ctrl_ref->priv);
 188
 189 #ifdef CONFIG_MAC80211_DEBUGFS
 190         debugfs_remove_recursive(ctrl_ref->local->debugfs.rcdir);
 191         ctrl_ref->local->debugfs.rcdir = NULL;
 192 #endif
 193
 194         ieee80211_rate_control_ops_put(ctrl_ref->ops);
 195         kfree(ctrl_ref);
 196 }
 197
 198 static bool rc_no_data_or_no_ack(struct ieee80211_tx_rate_control *txrc)
 199 {
 200         struct sk_buff *skb = txrc->skb;
 201         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
 202         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
 203         __le16 fc;
 204
 205         fc = hdr->frame_control;
 206
 207         return ((info->flags & IEEE80211_TX_CTL_NO_ACK) || !ieee80211_is_data(fc));
 208 }
 209
 210 static void rc_send_low_broadcast(s8 *idx, u32 basic_rates, u8 max_rate_idx)
 211 {
 212         u8 i;
 213
 214         if (basic_rates == 0)
 215                 return; /* assume basic rates unknown and accept rate */
 216         if (*idx < 0)
 217                 return;
 218         if (basic_rates & (1 << *idx))
 219                 return; /* selected rate is a basic rate */
 220
 221         for (i = *idx + 1; i <= max_rate_idx; i++) {
 222                 if (basic_rates & (1 << i)) {
 223                         *idx = i;
 224                         return;
 225                 }
 226         }
 227
 228         /* could not find a basic rate; use original selection */
 229 }
 230
 231 bool rate_control_send_low(struct ieee80211_sta *sta,
 232                            void *priv_sta,
 233                            struct ieee80211_tx_rate_control *txrc)
 234 {
 235         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(txrc->skb);
 236
 237         if (!sta || !priv_sta || rc_no_data_or_no_ack(txrc)) {
 238                 info->control.rates[0].idx = rate_lowest_index(txrc->sband, sta);
 239                 info->control.rates[0].count =
 240                         (info->flags & IEEE80211_TX_CTL_NO_ACK) ?
 241                         1 : txrc->hw->max_rate_tries;
 242                 if (!sta && txrc->ap)
 243                         rc_send_low_broadcast(&info->control.rates[0].idx,
 244                                               txrc->bss_conf->basic_rates,
 245                                               txrc->sband->n_bitrates);
 246                 return true;
 247         }
 248         return false;
 249 }
 250 EXPORT_SYMBOL(rate_control_send_low);
 251
 252 static void rate_idx_match_mask(struct ieee80211_tx_rate *rate,
 253                                 int n_bitrates, u32 mask)
 254 {
 255         int j;
 256
 257         /* See whether the selected rate or anything below it is allowed. */
 258         for (j = rate->idx; j >= 0; j--) {
 259                 if (mask & (1 << j)) {
 260                         /* Okay, found a suitable rate. Use it. */
 261                         rate->idx = j;
 262                         return;
 263                 }
 264         }
 265
 266         /* Try to find a higher rate that would be allowed */
 267         for (j = rate->idx + 1; j < n_bitrates; j++) {
 268                 if (mask & (1 << j)) {
 269                         /* Okay, found a suitable rate. Use it. */
 270                         rate->idx = j;
 271                         return;
 272                 }
 273         }
 274
 275         /*
 276          * Uh.. No suitable rate exists. This should not really happen with
 277          * sane TX rate mask configurations. However, should someone manage to
 278          * configure supported rates and TX rate mask in incompatible way,
 279          * allow the frame to be transmitted with whatever the rate control
 280          * selected.
 281          */
 282 }
 283
 284 void rate_control_get_rate(struct ieee80211_sub_if_data *sdata,
 285                            struct sta_info *sta,
 286                            struct ieee80211_tx_rate_control *txrc)
 287 {
 288         struct rate_control_ref *ref = sdata->local->rate_ctrl;
 289         void *priv_sta = NULL;
 290         struct ieee80211_sta *ista = NULL;
 291         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(txrc->skb);
 292         int i;
 293         u32 mask;
 294
 295         if (sta) {
 296                 ista = &sta->sta;
 297                 priv_sta = sta->rate_ctrl_priv;
 298         }
 299
 300         for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
 301                 info->control.rates[i].idx = -1;
 302                 info->control.rates[i].flags = 0;
 303                 info->control.rates[i].count = 1;
 304         }
 305
 306         if (sdata->local->hw.flags & IEEE80211_HW_HAS_RATE_CONTROL)
 307                 return;
 308
 309         ref->ops->get_rate(ref->priv, ista, priv_sta, txrc);
 310
 311         /*
 312          * Try to enforce the rateidx mask the user wanted. skip this if the
 313          * default mask (allow all rates) is used to save some processing for
 314          * the common case.
 315          */
 316         mask = sdata->rc_rateidx_mask[info->band];
 317         if (mask != (1 << txrc->sband->n_bitrates) - 1) {
 318                 if (sta) {
 319                         /* Filter out rates that the STA does not support */
 320                         mask &= sta->sta.supp_rates[info->band];
 321                 }
 322                 /*
 323                  * Make sure the rate index selected for each TX rate is
 324                  * included in the configured mask and change the rate indexes
 325                  * if needed.
 326                  */
 327                 for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
 328                         /* Rate masking supports only legacy rates for now */
 329                         if (info->control.rates[i].flags & IEEE80211_TX_RC_MCS)
 330                                 continue;
 331                         rate_idx_match_mask(&info->control.rates[i],
 332                                             txrc->sband->n_bitrates, mask);
 333                 }
 334         }
 335
 336         BUG_ON(info->control.rates[0].idx < 0);
 337 }
 338
 339 struct rate_control_ref *rate_control_get(struct rate_control_ref *ref)
 340 {
 341         kref_get(&ref->kref);
 342         return ref;
 343 }
 344
 345 void rate_control_put(struct rate_control_ref *ref)
 346 {
 347         kref_put(&ref->kref, rate_control_release);
 348 }
 349
 350 int ieee80211_init_rate_ctrl_alg(struct ieee80211_local *local,
 351                                  const char *name)
 352 {
 353         struct rate_control_ref *ref, *old;
 354
 355         ASSERT_RTNL();
 356
 357         if (local->open_count)
 358                 return -EBUSY;
 359
 360         if (local->hw.flags & IEEE80211_HW_HAS_RATE_CONTROL) {
 361                 if (WARN_ON(!local->ops->set_rts_threshold))
 362                         return -EINVAL;
 363                 return 0;
 364         }
 365
 366         ref = rate_control_alloc(name, local);
 367         if (!ref) {
 368                 printk(KERN_WARNING "%s: Failed to select rate control "
 369                        "algorithm\n", wiphy_name(local->hw.wiphy));
 370                 return -ENOENT;
 371         }
 372
 373         old = local->rate_ctrl;
 374         local->rate_ctrl = ref;
 375         if (old) {
 376                 rate_control_put(old);
 377                 sta_info_flush(local, NULL);
 378         }
 379
 380         printk(KERN_DEBUG "%s: Selected rate control "
 381                "algorithm '%s'\n", wiphy_name(local->hw.wiphy),
 382                ref->ops->name);
 383
 384         return 0;
 385 }
 386
 387 void rate_control_deinitialize(struct ieee80211_local *local)
 388 {
 389         struct rate_control_ref *ref;
 390
 391         ref = local->rate_ctrl;
 392
 393         if (!ref)
 394                 return;
 395
 396         local->rate_ctrl = NULL;
 397         rate_control_put(ref);
 398 }
 399