Merge git://git.kernel.org/pub/scm/linux/kernel/git/aegl/linux-2.6
[linux-2.6] / net / mac80211 / rc80211_simple.c
1 /*
2  * Copyright 2002-2005, Instant802 Networks, Inc.
3  * Copyright 2005, Devicescape Software, Inc.
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License version 2 as
7  * published by the Free Software Foundation.
8  */
9
10 #include <linux/module.h>
11 #include <linux/init.h>
12 #include <linux/netdevice.h>
13 #include <linux/types.h>
14 #include <linux/slab.h>
15 #include <linux/skbuff.h>
16 #include <linux/compiler.h>
17
18 #include <net/mac80211.h>
19 #include "ieee80211_i.h"
20 #include "ieee80211_rate.h"
21 #include "debugfs.h"
22
23
24 /* This is a minimal implementation of TX rate controlling that can be used
25  * as the default when no improved mechanisms are available. */
26
27
28 #define RATE_CONTROL_EMERG_DEC 2
29 #define RATE_CONTROL_INTERVAL (HZ / 20)
30 #define RATE_CONTROL_MIN_TX 10
31
32 MODULE_ALIAS("rc80211_default");
33
34 static void rate_control_rate_inc(struct ieee80211_local *local,
35                                   struct sta_info *sta)
36 {
37         struct ieee80211_sub_if_data *sdata;
38         struct ieee80211_hw_mode *mode;
39         int i = sta->txrate;
40         int maxrate;
41
42         sdata = IEEE80211_DEV_TO_SUB_IF(sta->dev);
43         if (sdata->bss && sdata->bss->force_unicast_rateidx > -1) {
44                 /* forced unicast rate - do not change STA rate */
45                 return;
46         }
47
48         mode = local->oper_hw_mode;
49         maxrate = sdata->bss ? sdata->bss->max_ratectrl_rateidx : -1;
50
51         if (i > mode->num_rates)
52                 i = mode->num_rates - 2;
53
54         while (i + 1 < mode->num_rates) {
55                 i++;
56                 if (sta->supp_rates & BIT(i) &&
57                     mode->rates[i].flags & IEEE80211_RATE_SUPPORTED &&
58                     (maxrate < 0 || i <= maxrate)) {
59                         sta->txrate = i;
60                         break;
61                 }
62         }
63 }
64
65
66 static void rate_control_rate_dec(struct ieee80211_local *local,
67                                   struct sta_info *sta)
68 {
69         struct ieee80211_sub_if_data *sdata;
70         struct ieee80211_hw_mode *mode;
71         int i = sta->txrate;
72
73         sdata = IEEE80211_DEV_TO_SUB_IF(sta->dev);
74         if (sdata->bss && sdata->bss->force_unicast_rateidx > -1) {
75                 /* forced unicast rate - do not change STA rate */
76                 return;
77         }
78
79         mode = local->oper_hw_mode;
80         if (i > mode->num_rates)
81                 i = mode->num_rates;
82
83         while (i > 0) {
84                 i--;
85                 if (sta->supp_rates & BIT(i) &&
86                     mode->rates[i].flags & IEEE80211_RATE_SUPPORTED) {
87                         sta->txrate = i;
88                         break;
89                 }
90         }
91 }
92
93
94 static struct ieee80211_rate *
95 rate_control_lowest_rate(struct ieee80211_local *local,
96                          struct ieee80211_hw_mode *mode)
97 {
98         int i;
99
100         for (i = 0; i < mode->num_rates; i++) {
101                 struct ieee80211_rate *rate = &mode->rates[i];
102
103                 if (rate->flags & IEEE80211_RATE_SUPPORTED)
104                         return rate;
105         }
106
107         printk(KERN_DEBUG "rate_control_lowest_rate - no supported rates "
108                "found\n");
109         return &mode->rates[0];
110 }
111
112
113 struct global_rate_control {
114         int dummy;
115 };
116
117 struct sta_rate_control {
118         unsigned long last_rate_change;
119         u32 tx_num_failures;
120         u32 tx_num_xmit;
121
122         unsigned long avg_rate_update;
123         u32 tx_avg_rate_sum;
124         u32 tx_avg_rate_num;
125
126 #ifdef CONFIG_MAC80211_DEBUGFS
127         struct dentry *tx_avg_rate_sum_dentry;
128         struct dentry *tx_avg_rate_num_dentry;
129 #endif
130 };
131
132
133 static void rate_control_simple_tx_status(void *priv, struct net_device *dev,
134                                           struct sk_buff *skb,
135                                           struct ieee80211_tx_status *status)
136 {
137         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
138         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
139         struct sta_info *sta;
140         struct sta_rate_control *srctrl;
141
142         sta = sta_info_get(local, hdr->addr1);
143
144         if (!sta)
145             return;
146
147         srctrl = sta->rate_ctrl_priv;
148         srctrl->tx_num_xmit++;
149         if (status->excessive_retries) {
150                 sta->antenna_sel_tx = sta->antenna_sel_tx == 1 ? 2 : 1;
151                 sta->antenna_sel_rx = sta->antenna_sel_rx == 1 ? 2 : 1;
152                 if (local->sta_antenna_sel == STA_ANTENNA_SEL_SW_CTRL_DEBUG) {
153                         printk(KERN_DEBUG "%s: " MAC_FMT " TX antenna --> %d "
154                                "RX antenna --> %d (@%lu)\n",
155                                dev->name, MAC_ARG(hdr->addr1),
156                                sta->antenna_sel_tx, sta->antenna_sel_rx, jiffies);
157                 }
158                 srctrl->tx_num_failures++;
159                 sta->tx_retry_failed++;
160                 sta->tx_num_consecutive_failures++;
161                 sta->tx_num_mpdu_fail++;
162         } else {
163                 sta->last_ack_rssi[0] = sta->last_ack_rssi[1];
164                 sta->last_ack_rssi[1] = sta->last_ack_rssi[2];
165                 sta->last_ack_rssi[2] = status->ack_signal;
166                 sta->tx_num_consecutive_failures = 0;
167                 sta->tx_num_mpdu_ok++;
168         }
169         sta->tx_retry_count += status->retry_count;
170         sta->tx_num_mpdu_fail += status->retry_count;
171
172         if (time_after(jiffies,
173                        srctrl->last_rate_change + RATE_CONTROL_INTERVAL) &&
174                 srctrl->tx_num_xmit > RATE_CONTROL_MIN_TX) {
175                 u32 per_failed;
176                 srctrl->last_rate_change = jiffies;
177
178                 per_failed = (100 * sta->tx_num_mpdu_fail) /
179                         (sta->tx_num_mpdu_fail + sta->tx_num_mpdu_ok);
180                 /* TODO: calculate average per_failed to make adjusting
181                  * parameters easier */
182 #if 0
183                 if (net_ratelimit()) {
184                         printk(KERN_DEBUG "MPDU fail=%d ok=%d per_failed=%d\n",
185                                sta->tx_num_mpdu_fail, sta->tx_num_mpdu_ok,
186                                per_failed);
187                 }
188 #endif
189
190                 if (per_failed > local->rate_ctrl_num_down) {
191                         rate_control_rate_dec(local, sta);
192                 } else if (per_failed < local->rate_ctrl_num_up) {
193                         rate_control_rate_inc(local, sta);
194                 }
195                 srctrl->tx_avg_rate_sum += status->control.rate->rate;
196                 srctrl->tx_avg_rate_num++;
197                 srctrl->tx_num_failures = 0;
198                 srctrl->tx_num_xmit = 0;
199         } else if (sta->tx_num_consecutive_failures >=
200                    RATE_CONTROL_EMERG_DEC) {
201                 rate_control_rate_dec(local, sta);
202         }
203
204         if (srctrl->avg_rate_update + 60 * HZ < jiffies) {
205                 srctrl->avg_rate_update = jiffies;
206                 if (srctrl->tx_avg_rate_num > 0) {
207 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
208                         printk(KERN_DEBUG "%s: STA " MAC_FMT " Average rate: "
209                                "%d (%d/%d)\n",
210                                dev->name, MAC_ARG(sta->addr),
211                                srctrl->tx_avg_rate_sum /
212                                srctrl->tx_avg_rate_num,
213                                srctrl->tx_avg_rate_sum,
214                                srctrl->tx_avg_rate_num);
215 #endif /* CONFIG_MAC80211_VERBOSE_DEBUG */
216                         srctrl->tx_avg_rate_sum = 0;
217                         srctrl->tx_avg_rate_num = 0;
218                 }
219         }
220
221         sta_info_put(sta);
222 }
223
224
225 static struct ieee80211_rate *
226 rate_control_simple_get_rate(void *priv, struct net_device *dev,
227                              struct sk_buff *skb,
228                              struct rate_control_extra *extra)
229 {
230         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
231         struct ieee80211_sub_if_data *sdata;
232         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
233         struct ieee80211_hw_mode *mode = extra->mode;
234         struct sta_info *sta;
235         int rateidx, nonerp_idx;
236         u16 fc;
237
238         memset(extra, 0, sizeof(*extra));
239
240         fc = le16_to_cpu(hdr->frame_control);
241         if ((fc & IEEE80211_FCTL_FTYPE) != IEEE80211_FTYPE_DATA ||
242             (hdr->addr1[0] & 0x01)) {
243                 /* Send management frames and broadcast/multicast data using
244                  * lowest rate. */
245                 /* TODO: this could probably be improved.. */
246                 return rate_control_lowest_rate(local, mode);
247         }
248
249         sta = sta_info_get(local, hdr->addr1);
250
251         if (!sta)
252                 return rate_control_lowest_rate(local, mode);
253
254         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
255         if (sdata->bss && sdata->bss->force_unicast_rateidx > -1)
256                 sta->txrate = sdata->bss->force_unicast_rateidx;
257
258         rateidx = sta->txrate;
259
260         if (rateidx >= mode->num_rates)
261                 rateidx = mode->num_rates - 1;
262
263         sta->last_txrate = rateidx;
264         nonerp_idx = rateidx;
265         while (nonerp_idx > 0 &&
266                ((mode->rates[nonerp_idx].flags & IEEE80211_RATE_ERP) ||
267                 !(mode->rates[nonerp_idx].flags & IEEE80211_RATE_SUPPORTED) ||
268                 !(sta->supp_rates & BIT(nonerp_idx))))
269                 nonerp_idx--;
270         extra->nonerp = &mode->rates[nonerp_idx];
271
272         sta_info_put(sta);
273
274         return &mode->rates[rateidx];
275 }
276
277
278 static void rate_control_simple_rate_init(void *priv, void *priv_sta,
279                                           struct ieee80211_local *local,
280                                           struct sta_info *sta)
281 {
282         struct ieee80211_hw_mode *mode;
283         int i;
284         sta->txrate = 0;
285         mode = local->oper_hw_mode;
286         /* TODO: what is a good starting rate for STA? About middle? Maybe not
287          * the lowest or the highest rate.. Could consider using RSSI from
288          * previous packets? Need to have IEEE 802.1X auth succeed immediately
289          * after assoc.. */
290         for (i = 0; i < mode->num_rates; i++) {
291                 if ((sta->supp_rates & BIT(i)) &&
292                     (mode->rates[i].flags & IEEE80211_RATE_SUPPORTED))
293                         sta->txrate = i;
294         }
295 }
296
297
298 static void * rate_control_simple_alloc(struct ieee80211_local *local)
299 {
300         struct global_rate_control *rctrl;
301
302         rctrl = kzalloc(sizeof(*rctrl), GFP_ATOMIC);
303
304         return rctrl;
305 }
306
307
308 static void rate_control_simple_free(void *priv)
309 {
310         struct global_rate_control *rctrl = priv;
311         kfree(rctrl);
312 }
313
314
315 static void rate_control_simple_clear(void *priv)
316 {
317 }
318
319
320 static void * rate_control_simple_alloc_sta(void *priv, gfp_t gfp)
321 {
322         struct sta_rate_control *rctrl;
323
324         rctrl = kzalloc(sizeof(*rctrl), gfp);
325
326         return rctrl;
327 }
328
329
330 static void rate_control_simple_free_sta(void *priv, void *priv_sta)
331 {
332         struct sta_rate_control *rctrl = priv_sta;
333         kfree(rctrl);
334 }
335
336 #ifdef CONFIG_MAC80211_DEBUGFS
337
338 static int open_file_generic(struct inode *inode, struct file *file)
339 {
340         file->private_data = inode->i_private;
341         return 0;
342 }
343
344 static ssize_t sta_tx_avg_rate_sum_read(struct file *file,
345                                         char __user *userbuf,
346                                         size_t count, loff_t *ppos)
347 {
348         struct sta_rate_control *srctrl = file->private_data;
349         char buf[20];
350
351         sprintf(buf, "%d\n", srctrl->tx_avg_rate_sum);
352         return simple_read_from_buffer(userbuf, count, ppos, buf, strlen(buf));
353 }
354
355 static const struct file_operations sta_tx_avg_rate_sum_ops = {
356         .read = sta_tx_avg_rate_sum_read,
357         .open = open_file_generic,
358 };
359
360 static ssize_t sta_tx_avg_rate_num_read(struct file *file,
361                                         char __user *userbuf,
362                                         size_t count, loff_t *ppos)
363 {
364         struct sta_rate_control *srctrl = file->private_data;
365         char buf[20];
366
367         sprintf(buf, "%d\n", srctrl->tx_avg_rate_num);
368         return simple_read_from_buffer(userbuf, count, ppos, buf, strlen(buf));
369 }
370
371 static const struct file_operations sta_tx_avg_rate_num_ops = {
372         .read = sta_tx_avg_rate_num_read,
373         .open = open_file_generic,
374 };
375
376 static void rate_control_simple_add_sta_debugfs(void *priv, void *priv_sta,
377                                                 struct dentry *dir)
378 {
379         struct sta_rate_control *srctrl = priv_sta;
380
381         srctrl->tx_avg_rate_num_dentry =
382                 debugfs_create_file("rc_simple_sta_tx_avg_rate_num", 0400,
383                                     dir, srctrl, &sta_tx_avg_rate_num_ops);
384         srctrl->tx_avg_rate_sum_dentry =
385                 debugfs_create_file("rc_simple_sta_tx_avg_rate_sum", 0400,
386                                     dir, srctrl, &sta_tx_avg_rate_sum_ops);
387 }
388
389 static void rate_control_simple_remove_sta_debugfs(void *priv, void *priv_sta)
390 {
391         struct sta_rate_control *srctrl = priv_sta;
392
393         debugfs_remove(srctrl->tx_avg_rate_sum_dentry);
394         debugfs_remove(srctrl->tx_avg_rate_num_dentry);
395 }
396 #endif
397
398 static struct rate_control_ops rate_control_simple = {
399         .module = THIS_MODULE,
400         .name = "simple",
401         .tx_status = rate_control_simple_tx_status,
402         .get_rate = rate_control_simple_get_rate,
403         .rate_init = rate_control_simple_rate_init,
404         .clear = rate_control_simple_clear,
405         .alloc = rate_control_simple_alloc,
406         .free = rate_control_simple_free,
407         .alloc_sta = rate_control_simple_alloc_sta,
408         .free_sta = rate_control_simple_free_sta,
409 #ifdef CONFIG_MAC80211_DEBUGFS
410         .add_sta_debugfs = rate_control_simple_add_sta_debugfs,
411         .remove_sta_debugfs = rate_control_simple_remove_sta_debugfs,
412 #endif
413 };
414
415
416 static int __init rate_control_simple_init(void)
417 {
418         return ieee80211_rate_control_register(&rate_control_simple);
419 }
420
421
422 static void __exit rate_control_simple_exit(void)
423 {
424         ieee80211_rate_control_unregister(&rate_control_simple);
425 }
426
427
428 module_init(rate_control_simple_init);
429 module_exit(rate_control_simple_exit);
430
431 MODULE_DESCRIPTION("Simple rate control algorithm for ieee80211");
432 MODULE_LICENSE("GPL");