1
2
3
4
5
6
7
8
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
17struct rate_control_alg {
18 struct list_head list;
19 struct rate_control_ops *ops;
20};
21
22static LIST_HEAD(rate_ctrl_algs);
23static DEFINE_MUTEX(rate_ctrl_mutex);
24
25static char *ieee80211_default_rc_algo = CONFIG_MAC80211_RC_DEFAULT;
26module_param(ieee80211_default_rc_algo, charp, 0644);
27MODULE_PARM_DESC(ieee80211_default_rc_algo,
28 "Default rate control algorithm for mac80211 to use");
29
30int 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
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}
59EXPORT_SYMBOL(ieee80211_rate_control_register);
60
61void 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}
75EXPORT_SYMBOL(ieee80211_rate_control_unregister);
76
77static struct rate_control_ops *
78ieee80211_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
99static struct rate_control_ops *
100ieee80211_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
117 ops = ieee80211_try_rate_control_ops_get(ieee80211_default_rc_algo);
118
119
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
126static void ieee80211_rate_control_ops_put(struct rate_control_ops *ops)
127{
128 module_put(ops->module);
129}
130
131#ifdef CONFIG_MAC80211_DEBUGFS
132static 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
142static const struct file_operations rcname_ops = {
143 .read = rcname_read,
144 .open = mac80211_open_file_generic,
145};
146#endif
147
148struct 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
175fail_priv:
176 ieee80211_rate_control_ops_put(ref->ops);
177fail_ops:
178 kfree(ref);
179fail_ref:
180 return NULL;
181}
182
183static 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
201static 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
213bool 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}
228EXPORT_SYMBOL(rate_control_send_low);
229
230void 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
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
273struct rate_control_ref *rate_control_get(struct rate_control_ref *ref)
274{
275 kref_get(&ref->kref);
276 return ref;
277}
278
279void rate_control_put(struct rate_control_ref *ref)
280{
281 kref_put(&ref->kref, rate_control_release);
282}
283
284int 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
315void 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
