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