Commit | Line | Data |
---|---|---|
f0706e82 JB |
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" | |
e9f207f0 | 21 | #include "debugfs.h" |
f0706e82 JB |
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; | |
e9f207f0 JB |
125 | |
126 | #ifdef CONFIG_MAC80211_DEBUGFS | |
127 | struct dentry *tx_avg_rate_sum_dentry; | |
128 | struct dentry *tx_avg_rate_num_dentry; | |
129 | #endif | |
f0706e82 JB |
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; | |
eef6caf8 LF |
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, */ | |
f0706e82 JB |
290 | for (i = 0; i < mode->num_rates; i++) { |
291 | if ((sta->supp_rates & BIT(i)) && | |
eef6caf8 | 292 | (mode->rates[i].flags & IEEE80211_RATE_SUPPORTED)) { |
f0706e82 | 293 | sta->txrate = i; |
eef6caf8 LF |
294 | break; |
295 | } | |
f0706e82 JB |
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 | ||
e9f207f0 JB |
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 | |
f0706e82 JB |
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, | |
e9f207f0 JB |
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 | |
f0706e82 JB |
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"); |