Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/linville/wirel...
[linux-2.6.git] / net / mac80211 / rate.c
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 static 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 static void rc_send_low_broadcast(s8 *idx, u32 basic_rates, u8 max_rate_idx)
211 {
212         u8 i;
213
214         if (basic_rates == 0)
215                 return; /* assume basic rates unknown and accept rate */
216         if (*idx < 0)
217                 return;
218         if (basic_rates & (1 << *idx))
219                 return; /* selected rate is a basic rate */
220
221         for (i = *idx + 1; i <= max_rate_idx; i++) {
222                 if (basic_rates & (1 << i)) {
223                         *idx = i;
224                         return;
225                 }
226         }
227
228         /* could not find a basic rate; use original selection */
229 }
230
231 bool rate_control_send_low(struct ieee80211_sta *sta,
232                            void *priv_sta,
233                            struct ieee80211_tx_rate_control *txrc)
234 {
235         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(txrc->skb);
236
237         if (!sta || !priv_sta || rc_no_data_or_no_ack(txrc)) {
238                 info->control.rates[0].idx = rate_lowest_index(txrc->sband, sta);
239                 info->control.rates[0].count =
240                         (info->flags & IEEE80211_TX_CTL_NO_ACK) ?
241                         1 : txrc->hw->max_rate_tries;
242                 if (!sta && txrc->ap)
243                         rc_send_low_broadcast(&info->control.rates[0].idx,
244                                               txrc->bss_conf->basic_rates,
245                                               txrc->sband->n_bitrates);
246                 return true;
247         }
248         return false;
249 }
250 EXPORT_SYMBOL(rate_control_send_low);
251
252 static void rate_idx_match_mask(struct ieee80211_tx_rate *rate,
253                                 int n_bitrates, u32 mask)
254 {
255         int j;
256
257         /* See whether the selected rate or anything below it is allowed. */
258         for (j = rate->idx; j >= 0; j--) {
259                 if (mask & (1 << j)) {
260                         /* Okay, found a suitable rate. Use it. */
261                         rate->idx = j;
262                         return;
263                 }
264         }
265
266         /* Try to find a higher rate that would be allowed */
267         for (j = rate->idx + 1; j < n_bitrates; j++) {
268                 if (mask & (1 << j)) {
269                         /* Okay, found a suitable rate. Use it. */
270                         rate->idx = j;
271                         return;
272                 }
273         }
274
275         /*
276          * Uh.. No suitable rate exists. This should not really happen with
277          * sane TX rate mask configurations. However, should someone manage to
278          * configure supported rates and TX rate mask in incompatible way,
279          * allow the frame to be transmitted with whatever the rate control
280          * selected.
281          */
282 }
283
284 void rate_control_get_rate(struct ieee80211_sub_if_data *sdata,
285                            struct sta_info *sta,
286                            struct ieee80211_tx_rate_control *txrc)
287 {
288         struct rate_control_ref *ref = sdata->local->rate_ctrl;
289         void *priv_sta = NULL;
290         struct ieee80211_sta *ista = NULL;
291         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(txrc->skb);
292         int i;
293         u32 mask;
294
295         if (sta) {
296                 ista = &sta->sta;
297                 priv_sta = sta->rate_ctrl_priv;
298         }
299
300         for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
301                 info->control.rates[i].idx = -1;
302                 info->control.rates[i].flags = 0;
303                 info->control.rates[i].count = 1;
304         }
305
306         if (sdata->local->hw.flags & IEEE80211_HW_HAS_RATE_CONTROL)
307                 return;
308
309         ref->ops->get_rate(ref->priv, ista, priv_sta, txrc);
310
311         /*
312          * Try to enforce the rateidx mask the user wanted. skip this if the
313          * default mask (allow all rates) is used to save some processing for
314          * the common case.
315          */
316         mask = sdata->rc_rateidx_mask[info->band];
317         if (mask != (1 << txrc->sband->n_bitrates) - 1) {
318                 if (sta) {
319                         /* Filter out rates that the STA does not support */
320                         mask &= sta->sta.supp_rates[info->band];
321                 }
322                 /*
323                  * Make sure the rate index selected for each TX rate is
324                  * included in the configured mask and change the rate indexes
325                  * if needed.
326                  */
327                 for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
328                         /* Rate masking supports only legacy rates for now */
329                         if (info->control.rates[i].flags & IEEE80211_TX_RC_MCS)
330                                 continue;
331                         rate_idx_match_mask(&info->control.rates[i],
332                                             txrc->sband->n_bitrates, mask);
333                 }
334         }
335
336         BUG_ON(info->control.rates[0].idx < 0);
337 }
338
339 struct rate_control_ref *rate_control_get(struct rate_control_ref *ref)
340 {
341         kref_get(&ref->kref);
342         return ref;
343 }
344
345 void rate_control_put(struct rate_control_ref *ref)
346 {
347         kref_put(&ref->kref, rate_control_release);
348 }
349
350 int ieee80211_init_rate_ctrl_alg(struct ieee80211_local *local,
351                                  const char *name)
352 {
353         struct rate_control_ref *ref, *old;
354
355         ASSERT_RTNL();
356
357         if (local->open_count)
358                 return -EBUSY;
359
360         if (local->hw.flags & IEEE80211_HW_HAS_RATE_CONTROL) {
361                 if (WARN_ON(!local->ops->set_rts_threshold))
362                         return -EINVAL;
363                 return 0;
364         }
365
366         ref = rate_control_alloc(name, local);
367         if (!ref) {
368                 printk(KERN_WARNING "%s: Failed to select rate control "
369                        "algorithm\n", wiphy_name(local->hw.wiphy));
370                 return -ENOENT;
371         }
372
373         old = local->rate_ctrl;
374         local->rate_ctrl = ref;
375         if (old) {
376                 rate_control_put(old);
377                 sta_info_flush(local, NULL);
378         }
379
380         printk(KERN_DEBUG "%s: Selected rate control "
381                "algorithm '%s'\n", wiphy_name(local->hw.wiphy),
382                ref->ops->name);
383
384         return 0;
385 }
386
387 void rate_control_deinitialize(struct ieee80211_local *local)
388 {
389         struct rate_control_ref *ref;
390
391         ref = local->rate_ctrl;
392
393         if (!ref)
394                 return;
395
396         local->rate_ctrl = NULL;
397         rate_control_put(ref);
398 }
399