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_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_MAC80211_RC_DEFAULT)) 121 ops = ieee80211_try_rate_control_ops_get(CONFIG_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 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 bool rate_control_send_low(struct ieee80211_sta *sta, 211 void *priv_sta, 212 struct ieee80211_tx_rate_control *txrc) 213 { 214 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(txrc->skb); 215 216 if (!sta || !priv_sta || rc_no_data_or_no_ack(txrc)) { 217 info->control.rates[0].idx = rate_lowest_index(txrc->sband, sta); 218 info->control.rates[0].count = 219 (info->flags & IEEE80211_TX_CTL_NO_ACK) ? 220 1 : txrc->hw->max_rate_tries; 221 return true; 222 } 223 return false; 224 } 225 EXPORT_SYMBOL(rate_control_send_low); 226 227 void rate_control_get_rate(struct ieee80211_sub_if_data *sdata, 228 struct sta_info *sta, 229 struct ieee80211_tx_rate_control *txrc) 230 { 231 struct rate_control_ref *ref = sdata->local->rate_ctrl; 232 void *priv_sta = NULL; 233 struct ieee80211_sta *ista = NULL; 234 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(txrc->skb); 235 int i; 236 237 if (sta) { 238 ista = &sta->sta; 239 priv_sta = sta->rate_ctrl_priv; 240 } 241 242 for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) { 243 info->control.rates[i].idx = -1; 244 info->control.rates[i].flags = 0; 245 info->control.rates[i].count = 1; 246 } 247 248 if (sta && sdata->force_unicast_rateidx > -1) { 249 info->control.rates[0].idx = sdata->force_unicast_rateidx; 250 } else { 251 ref->ops->get_rate(ref->priv, ista, priv_sta, txrc); 252 info->flags |= IEEE80211_TX_INTFL_RCALGO; 253 } 254 255 /* 256 * try to enforce the maximum rate the user wanted 257 */ 258 if (sdata->max_ratectrl_rateidx > -1) 259 for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) { 260 if (info->control.rates[i].flags & IEEE80211_TX_RC_MCS) 261 continue; 262 info->control.rates[i].idx = 263 min_t(s8, info->control.rates[i].idx, 264 sdata->max_ratectrl_rateidx); 265 } 266 267 BUG_ON(info->control.rates[0].idx < 0); 268 } 269 270 struct rate_control_ref *rate_control_get(struct rate_control_ref *ref) 271 { 272 kref_get(&ref->kref); 273 return ref; 274 } 275 276 void rate_control_put(struct rate_control_ref *ref) 277 { 278 kref_put(&ref->kref, rate_control_release); 279 } 280 281 int ieee80211_init_rate_ctrl_alg(struct ieee80211_local *local, 282 const char *name) 283 { 284 struct rate_control_ref *ref, *old; 285 286 ASSERT_RTNL(); 287 288 if (local->open_count) 289 return -EBUSY; 290 291 if (local->hw.flags & IEEE80211_HW_HAS_RATE_CONTROL) { 292 if (WARN_ON(!local->ops->set_rts_threshold)) 293 return -EINVAL; 294 return 0; 295 } 296 297 ref = rate_control_alloc(name, local); 298 if (!ref) { 299 printk(KERN_WARNING "%s: Failed to select rate control " 300 "algorithm\n", wiphy_name(local->hw.wiphy)); 301 return -ENOENT; 302 } 303 304 old = local->rate_ctrl; 305 local->rate_ctrl = ref; 306 if (old) { 307 rate_control_put(old); 308 sta_info_flush(local, NULL); 309 } 310 311 printk(KERN_DEBUG "%s: Selected rate control " 312 "algorithm '%s'\n", wiphy_name(local->hw.wiphy), 313 ref->ops->name); 314 315 return 0; 316 } 317 318 void rate_control_deinitialize(struct ieee80211_local *local) 319 { 320 struct rate_control_ref *ref; 321 322 ref = local->rate_ctrl; 323 324 if (!ref) 325 return; 326 327 local->rate_ctrl = NULL; 328 rate_control_put(ref); 329 } 330 331