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
ieee80211_rate_control_register(struct rate_control_ops * ops)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
ieee80211_rate_control_unregister(struct rate_control_ops * ops)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 *
ieee80211_try_rate_control_ops_get(const char * name)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 *
ieee80211_rate_control_ops_get(const char * name)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
ieee80211_rate_control_ops_put(struct rate_control_ops * ops)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
rcname_read(struct file * file,char __user * userbuf,size_t count,loff_t * ppos)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
rate_control_alloc(const char * name,struct ieee80211_local * local)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
rate_control_release(struct kref * kref)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
rate_control_get_rate(struct ieee80211_sub_if_data * sdata,struct sta_info * sta,struct ieee80211_tx_rate_control * txrc)201 void rate_control_get_rate(struct ieee80211_sub_if_data *sdata,
202 struct sta_info *sta,
203 struct ieee80211_tx_rate_control *txrc)
204 {
205 struct rate_control_ref *ref = sdata->local->rate_ctrl;
206 void *priv_sta = NULL;
207 struct ieee80211_sta *ista = NULL;
208 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(txrc->skb);
209 int i;
210
211 if (sta) {
212 ista = &sta->sta;
213 priv_sta = sta->rate_ctrl_priv;
214 }
215
216 for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
217 info->control.rates[i].idx = -1;
218 info->control.rates[i].flags = 0;
219 info->control.rates[i].count = 1;
220 }
221
222 if (sta && sdata->force_unicast_rateidx > -1)
223 info->control.rates[0].idx = sdata->force_unicast_rateidx;
224 else
225 ref->ops->get_rate(ref->priv, ista, priv_sta, txrc);
226
227 /*
228 * try to enforce the maximum rate the user wanted
229 */
230 if (sdata->max_ratectrl_rateidx > -1)
231 for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
232 if (info->control.rates[i].flags & IEEE80211_TX_RC_MCS)
233 continue;
234 info->control.rates[i].idx =
235 min_t(s8, info->control.rates[i].idx,
236 sdata->max_ratectrl_rateidx);
237 }
238
239 BUG_ON(info->control.rates[0].idx < 0);
240 }
241
rate_control_get(struct rate_control_ref * ref)242 struct rate_control_ref *rate_control_get(struct rate_control_ref *ref)
243 {
244 kref_get(&ref->kref);
245 return ref;
246 }
247
rate_control_put(struct rate_control_ref * ref)248 void rate_control_put(struct rate_control_ref *ref)
249 {
250 kref_put(&ref->kref, rate_control_release);
251 }
252
ieee80211_init_rate_ctrl_alg(struct ieee80211_local * local,const char * name)253 int ieee80211_init_rate_ctrl_alg(struct ieee80211_local *local,
254 const char *name)
255 {
256 struct rate_control_ref *ref, *old;
257
258 ASSERT_RTNL();
259 if (local->open_count || netif_running(local->mdev))
260 return -EBUSY;
261
262 ref = rate_control_alloc(name, local);
263 if (!ref) {
264 printk(KERN_WARNING "%s: Failed to select rate control "
265 "algorithm\n", wiphy_name(local->hw.wiphy));
266 return -ENOENT;
267 }
268
269 old = local->rate_ctrl;
270 local->rate_ctrl = ref;
271 if (old) {
272 rate_control_put(old);
273 sta_info_flush(local, NULL);
274 }
275
276 printk(KERN_DEBUG "%s: Selected rate control "
277 "algorithm '%s'\n", wiphy_name(local->hw.wiphy),
278 ref->ops->name);
279
280
281 return 0;
282 }
283
rate_control_deinitialize(struct ieee80211_local * local)284 void rate_control_deinitialize(struct ieee80211_local *local)
285 {
286 struct rate_control_ref *ref;
287
288 ref = local->rate_ctrl;
289 local->rate_ctrl = NULL;
290 rate_control_put(ref);
291 }
292
293