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