USB: serial: ipw: clean up urb->status usage
[pandora-kernel.git] / 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: This routine should consider using RSSI from previous packets
287          * as we need to have IEEE 802.1X auth succeed immediately after assoc..
288          * Until that method is implemented, we will use the lowest supported rate
289          * as a workaround, */
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                         break;
295                 }
296         }
297 }
298
299
300 static void * rate_control_simple_alloc(struct ieee80211_local *local)
301 {
302         struct global_rate_control *rctrl;
303
304         rctrl = kzalloc(sizeof(*rctrl), GFP_ATOMIC);
305
306         return rctrl;
307 }
308
309
310 static void rate_control_simple_free(void *priv)
311 {
312         struct global_rate_control *rctrl = priv;
313         kfree(rctrl);
314 }
315
316
317 static void rate_control_simple_clear(void *priv)
318 {
319 }
320
321
322 static void * rate_control_simple_alloc_sta(void *priv, gfp_t gfp)
323 {
324         struct sta_rate_control *rctrl;
325
326         rctrl = kzalloc(sizeof(*rctrl), gfp);
327
328         return rctrl;
329 }
330
331
332 static void rate_control_simple_free_sta(void *priv, void *priv_sta)
333 {
334         struct sta_rate_control *rctrl = priv_sta;
335         kfree(rctrl);
336 }
337
338 #ifdef CONFIG_MAC80211_DEBUGFS
339
340 static int open_file_generic(struct inode *inode, struct file *file)
341 {
342         file->private_data = inode->i_private;
343         return 0;
344 }
345
346 static ssize_t sta_tx_avg_rate_sum_read(struct file *file,
347                                         char __user *userbuf,
348                                         size_t count, loff_t *ppos)
349 {
350         struct sta_rate_control *srctrl = file->private_data;
351         char buf[20];
352
353         sprintf(buf, "%d\n", srctrl->tx_avg_rate_sum);
354         return simple_read_from_buffer(userbuf, count, ppos, buf, strlen(buf));
355 }
356
357 static const struct file_operations sta_tx_avg_rate_sum_ops = {
358         .read = sta_tx_avg_rate_sum_read,
359         .open = open_file_generic,
360 };
361
362 static ssize_t sta_tx_avg_rate_num_read(struct file *file,
363                                         char __user *userbuf,
364                                         size_t count, loff_t *ppos)
365 {
366         struct sta_rate_control *srctrl = file->private_data;
367         char buf[20];
368
369         sprintf(buf, "%d\n", srctrl->tx_avg_rate_num);
370         return simple_read_from_buffer(userbuf, count, ppos, buf, strlen(buf));
371 }
372
373 static const struct file_operations sta_tx_avg_rate_num_ops = {
374         .read = sta_tx_avg_rate_num_read,
375         .open = open_file_generic,
376 };
377
378 static void rate_control_simple_add_sta_debugfs(void *priv, void *priv_sta,
379                                                 struct dentry *dir)
380 {
381         struct sta_rate_control *srctrl = priv_sta;
382
383         srctrl->tx_avg_rate_num_dentry =
384                 debugfs_create_file("rc_simple_sta_tx_avg_rate_num", 0400,
385                                     dir, srctrl, &sta_tx_avg_rate_num_ops);
386         srctrl->tx_avg_rate_sum_dentry =
387                 debugfs_create_file("rc_simple_sta_tx_avg_rate_sum", 0400,
388                                     dir, srctrl, &sta_tx_avg_rate_sum_ops);
389 }
390
391 static void rate_control_simple_remove_sta_debugfs(void *priv, void *priv_sta)
392 {
393         struct sta_rate_control *srctrl = priv_sta;
394
395         debugfs_remove(srctrl->tx_avg_rate_sum_dentry);
396         debugfs_remove(srctrl->tx_avg_rate_num_dentry);
397 }
398 #endif
399
400 static struct rate_control_ops rate_control_simple = {
401         .module = THIS_MODULE,
402         .name = "simple",
403         .tx_status = rate_control_simple_tx_status,
404         .get_rate = rate_control_simple_get_rate,
405         .rate_init = rate_control_simple_rate_init,
406         .clear = rate_control_simple_clear,
407         .alloc = rate_control_simple_alloc,
408         .free = rate_control_simple_free,
409         .alloc_sta = rate_control_simple_alloc_sta,
410         .free_sta = rate_control_simple_free_sta,
411 #ifdef CONFIG_MAC80211_DEBUGFS
412         .add_sta_debugfs = rate_control_simple_add_sta_debugfs,
413         .remove_sta_debugfs = rate_control_simple_remove_sta_debugfs,
414 #endif
415 };
416
417
418 static int __init rate_control_simple_init(void)
419 {
420         return ieee80211_rate_control_register(&rate_control_simple);
421 }
422
423
424 static void __exit rate_control_simple_exit(void)
425 {
426         ieee80211_rate_control_unregister(&rate_control_simple);
427 }
428
429
430 module_init(rate_control_simple_init);
431 module_exit(rate_control_simple_exit);
432
433 MODULE_DESCRIPTION("Simple rate control algorithm for ieee80211");
434 MODULE_LICENSE("GPL");