blob: 554c4baed6fbd3d4bdb164eaeea024fcf919bcfb [file] [log] [blame]
Mattias Nisslerad018372007-12-19 01:25:57 +01001/*
2 * Copyright 2002-2005, Instant802 Networks, Inc.
3 * Copyright 2005, Devicescape Software, Inc.
4 * Copyright 2007, Mattias Nissler <mattias.nissler@gmx.de>
Stefano Brivio90d501d2007-12-19 01:26:34 +01005 * Copyright 2007, Stefano Brivio <stefano.brivio@polimi.it>
Mattias Nisslerad018372007-12-19 01:25:57 +01006 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
10 */
11
12#include <linux/netdevice.h>
13#include <linux/types.h>
14#include <linux/skbuff.h>
Johannes Berg4b475892008-01-02 15:17:03 +010015#include <linux/debugfs.h>
Mattias Nisslerad018372007-12-19 01:25:57 +010016#include <net/mac80211.h>
17#include "ieee80211_rate.h"
18
Mattias Nissler12446c62007-12-19 01:27:18 +010019#include "rc80211_pid.h"
20
Mattias Nisslerad018372007-12-19 01:25:57 +010021
22/* This is an implementation of a TX rate control algorithm that uses a PID
23 * controller. Given a target failed frames rate, the controller decides about
24 * TX rate changes to meet the target failed frames rate.
25 *
26 * The controller basically computes the following:
27 *
Stefano Brivio1dc4d1e2007-12-19 01:26:52 +010028 * adj = CP * err + CI * err_avg + CD * (err - last_err) * (1 + sharpening)
Mattias Nisslerad018372007-12-19 01:25:57 +010029 *
30 * where
31 * adj adjustment value that is used to switch TX rate (see below)
32 * err current error: target vs. current failed frames percentage
33 * last_err last error
34 * err_avg average (i.e. poor man's integral) of recent errors
Stefano Brivio1dc4d1e2007-12-19 01:26:52 +010035 * sharpening non-zero when fast response is needed (i.e. right after
36 * association or no frames sent for a long time), heading
37 * to zero over time
Mattias Nisslerad018372007-12-19 01:25:57 +010038 * CP Proportional coefficient
39 * CI Integral coefficient
40 * CD Derivative coefficient
41 *
42 * CP, CI, CD are subject to careful tuning.
43 *
44 * The integral component uses a exponential moving average approach instead of
45 * an actual sliding window. The advantage is that we don't need to keep an
46 * array of the last N error values and computation is easier.
47 *
Stefano Brivio90d501d2007-12-19 01:26:34 +010048 * Once we have the adj value, we map it to a rate by means of a learning
49 * algorithm. This algorithm keeps the state of the percentual failed frames
50 * difference between rates. The behaviour of the lowest available rate is kept
51 * as a reference value, and every time we switch between two rates, we compute
52 * the difference between the failed frames each rate exhibited. By doing so,
53 * we compare behaviours which different rates exhibited in adjacent timeslices,
54 * thus the comparison is minimally affected by external conditions. This
55 * difference gets propagated to the whole set of measurements, so that the
56 * reference is always the same. Periodically, we normalize this set so that
57 * recent events weigh the most. By comparing the adj value with this set, we
58 * avoid pejorative switches to lower rates and allow for switches to higher
59 * rates if they behaved well.
Mattias Nisslerad018372007-12-19 01:25:57 +010060 *
61 * Note that for the computations we use a fixed-point representation to avoid
62 * floating point arithmetic. Hence, all values are shifted left by
63 * RC_PID_ARITH_SHIFT.
64 */
65
Mattias Nisslerad018372007-12-19 01:25:57 +010066
Stefano Brivio90d501d2007-12-19 01:26:34 +010067/* Shift the adjustment so that we won't switch to a lower rate if it exhibited
68 * a worse failed frames behaviour and we'll choose the highest rate whose
69 * failed frames behaviour is not worse than the one of the original rate
70 * target. While at it, check that the adjustment is within the ranges. Then,
71 * provide the new rate index. */
72static int rate_control_pid_shift_adjust(struct rc_pid_rateinfo *r,
73 int adj, int cur, int l)
74{
75 int i, j, k, tmp;
76
Stefano Brivio90d501d2007-12-19 01:26:34 +010077 j = r[cur].rev_index;
Stefano Briviofa443272007-12-23 04:41:19 +010078 i = j + adj;
79
80 if (i < 0)
81 return r[0].index;
82 if (i >= l - 1)
83 return r[l - 1].index;
84
85 tmp = i;
Stefano Brivio90d501d2007-12-19 01:26:34 +010086
87 if (adj < 0) {
Stefano Briviofa443272007-12-23 04:41:19 +010088 for (k = j; k >= i; k--)
89 if (r[k].diff <= r[j].diff)
90 tmp = k;
91 } else {
92 for (k = i + 1; k + i < l; k++)
93 if (r[k].diff <= r[i].diff)
94 tmp = k;
Stefano Brivio90d501d2007-12-19 01:26:34 +010095 }
Stefano Briviofa443272007-12-23 04:41:19 +010096
97 return r[tmp].index;
Stefano Brivio90d501d2007-12-19 01:26:34 +010098}
Mattias Nisslerad018372007-12-19 01:25:57 +010099
100static void rate_control_pid_adjust_rate(struct ieee80211_local *local,
Stefano Brivio90d501d2007-12-19 01:26:34 +0100101 struct sta_info *sta, int adj,
102 struct rc_pid_rateinfo *rinfo)
Mattias Nisslerad018372007-12-19 01:25:57 +0100103{
104 struct ieee80211_sub_if_data *sdata;
105 struct ieee80211_hw_mode *mode;
Stefano Brivio90d501d2007-12-19 01:26:34 +0100106 int newidx;
Mattias Nisslerad018372007-12-19 01:25:57 +0100107 int maxrate;
108 int back = (adj > 0) ? 1 : -1;
109
110 sdata = IEEE80211_DEV_TO_SUB_IF(sta->dev);
Mattias Nisslerad018372007-12-19 01:25:57 +0100111
112 mode = local->oper_hw_mode;
113 maxrate = sdata->bss ? sdata->bss->max_ratectrl_rateidx : -1;
114
Stefano Brivio90d501d2007-12-19 01:26:34 +0100115 newidx = rate_control_pid_shift_adjust(rinfo, adj, sta->txrate,
116 mode->num_rates);
Mattias Nisslerad018372007-12-19 01:25:57 +0100117
118 while (newidx != sta->txrate) {
119 if (rate_supported(sta, mode, newidx) &&
120 (maxrate < 0 || newidx <= maxrate)) {
121 sta->txrate = newidx;
122 break;
123 }
124
125 newidx += back;
126 }
Mattias Nissler12446c62007-12-19 01:27:18 +0100127
128#ifdef CONFIG_MAC80211_DEBUGFS
129 rate_control_pid_event_rate_change(
130 &((struct rc_pid_sta_info *)sta->rate_ctrl_priv)->events,
131 newidx, mode->rates[newidx].rate);
132#endif
Mattias Nisslerad018372007-12-19 01:25:57 +0100133}
134
Stefano Brivio90d501d2007-12-19 01:26:34 +0100135/* Normalize the failed frames per-rate differences. */
Mattias Nissler1946b742007-12-20 13:27:26 +0100136static void rate_control_pid_normalize(struct rc_pid_info *pinfo, int l)
Stefano Brivio90d501d2007-12-19 01:26:34 +0100137{
Mattias Nissler1946b742007-12-20 13:27:26 +0100138 int i, norm_offset = pinfo->norm_offset;
139 struct rc_pid_rateinfo *r = pinfo->rinfo;
Stefano Brivio90d501d2007-12-19 01:26:34 +0100140
Mattias Nissler1946b742007-12-20 13:27:26 +0100141 if (r[0].diff > norm_offset)
142 r[0].diff -= norm_offset;
143 else if (r[0].diff < -norm_offset)
144 r[0].diff += norm_offset;
Stefano Brivio90d501d2007-12-19 01:26:34 +0100145 for (i = 0; i < l - 1; i++)
Mattias Nissler1946b742007-12-20 13:27:26 +0100146 if (r[i + 1].diff > r[i].diff + norm_offset)
147 r[i + 1].diff -= norm_offset;
Stefano Brivio90d501d2007-12-19 01:26:34 +0100148 else if (r[i + 1].diff <= r[i].diff)
Mattias Nissler1946b742007-12-20 13:27:26 +0100149 r[i + 1].diff += norm_offset;
Stefano Brivio90d501d2007-12-19 01:26:34 +0100150}
151
Mattias Nisslerad018372007-12-19 01:25:57 +0100152static void rate_control_pid_sample(struct rc_pid_info *pinfo,
153 struct ieee80211_local *local,
154 struct sta_info *sta)
155{
156 struct rc_pid_sta_info *spinfo = sta->rate_ctrl_priv;
Stefano Brivio90d501d2007-12-19 01:26:34 +0100157 struct rc_pid_rateinfo *rinfo = pinfo->rinfo;
158 struct ieee80211_hw_mode *mode;
Mattias Nisslerad018372007-12-19 01:25:57 +0100159 u32 pf;
160 s32 err_avg;
Mattias Nissler1946b742007-12-20 13:27:26 +0100161 u32 err_prop;
162 u32 err_int;
163 u32 err_der;
Stefano Brivio90d501d2007-12-19 01:26:34 +0100164 int adj, i, j, tmp;
Mattias Nissler1946b742007-12-20 13:27:26 +0100165 unsigned long period;
Mattias Nisslerad018372007-12-19 01:25:57 +0100166
Stefano Brivio90d501d2007-12-19 01:26:34 +0100167 mode = local->oper_hw_mode;
Mattias Nisslerad018372007-12-19 01:25:57 +0100168 spinfo = sta->rate_ctrl_priv;
Stefano Brivio1dc4d1e2007-12-19 01:26:52 +0100169
170 /* In case nothing happened during the previous control interval, turn
171 * the sharpening factor on. */
Mattias Nissler1946b742007-12-20 13:27:26 +0100172 period = (HZ * pinfo->sampling_period + 500) / 1000;
173 if (!period)
174 period = 1;
175 if (jiffies - spinfo->last_sample > 2 * period)
176 spinfo->sharp_cnt = pinfo->sharpen_duration;
Stefano Brivio1dc4d1e2007-12-19 01:26:52 +0100177
Mattias Nisslerad018372007-12-19 01:25:57 +0100178 spinfo->last_sample = jiffies;
179
Stefano Brivio1dc4d1e2007-12-19 01:26:52 +0100180 /* This should never happen, but in case, we assume the old sample is
Mattias Nisslerad018372007-12-19 01:25:57 +0100181 * still a good measurement and copy it. */
Stefano Brivio1dc4d1e2007-12-19 01:26:52 +0100182 if (unlikely(spinfo->tx_num_xmit == 0))
Mattias Nisslerad018372007-12-19 01:25:57 +0100183 pf = spinfo->last_pf;
184 else {
185 pf = spinfo->tx_num_failed * 100 / spinfo->tx_num_xmit;
186 pf <<= RC_PID_ARITH_SHIFT;
Mattias Nisslerad018372007-12-19 01:25:57 +0100187 }
188
Stefano Brivio1dc4d1e2007-12-19 01:26:52 +0100189 spinfo->tx_num_xmit = 0;
190 spinfo->tx_num_failed = 0;
191
Stefano Brivio90d501d2007-12-19 01:26:34 +0100192 /* If we just switched rate, update the rate behaviour info. */
193 if (pinfo->oldrate != sta->txrate) {
194
195 i = rinfo[pinfo->oldrate].rev_index;
196 j = rinfo[sta->txrate].rev_index;
197
198 tmp = (pf - spinfo->last_pf);
199 tmp = RC_PID_DO_ARITH_RIGHT_SHIFT(tmp, RC_PID_ARITH_SHIFT);
200
201 rinfo[j].diff = rinfo[i].diff + tmp;
202 pinfo->oldrate = sta->txrate;
203 }
Mattias Nissler1946b742007-12-20 13:27:26 +0100204 rate_control_pid_normalize(pinfo, mode->num_rates);
Stefano Brivio90d501d2007-12-19 01:26:34 +0100205
Mattias Nisslerad018372007-12-19 01:25:57 +0100206 /* Compute the proportional, integral and derivative errors. */
Stefano Brivio426706c2007-12-23 04:39:17 +0100207 err_prop = (pinfo->target << RC_PID_ARITH_SHIFT) - pf;
Mattias Nisslerad018372007-12-19 01:25:57 +0100208
Mattias Nissler1946b742007-12-20 13:27:26 +0100209 err_avg = spinfo->err_avg_sc >> pinfo->smoothing_shift;
Mattias Nisslerad018372007-12-19 01:25:57 +0100210 spinfo->err_avg_sc = spinfo->err_avg_sc - err_avg + err_prop;
Mattias Nissler1946b742007-12-20 13:27:26 +0100211 err_int = spinfo->err_avg_sc >> pinfo->smoothing_shift;
Mattias Nisslerad018372007-12-19 01:25:57 +0100212
Mattias Nissler1946b742007-12-20 13:27:26 +0100213 err_der = (pf - spinfo->last_pf) *
214 (1 + pinfo->sharpen_factor * spinfo->sharp_cnt);
Mattias Nisslerad018372007-12-19 01:25:57 +0100215 spinfo->last_pf = pf;
Stefano Brivio1dc4d1e2007-12-19 01:26:52 +0100216 if (spinfo->sharp_cnt)
217 spinfo->sharp_cnt--;
Mattias Nisslerad018372007-12-19 01:25:57 +0100218
Mattias Nissler12446c62007-12-19 01:27:18 +0100219#ifdef CONFIG_MAC80211_DEBUGFS
220 rate_control_pid_event_pf_sample(&spinfo->events, pf, err_prop, err_int,
221 err_der);
222#endif
223
Mattias Nisslerad018372007-12-19 01:25:57 +0100224 /* Compute the controller output. */
225 adj = (err_prop * pinfo->coeff_p + err_int * pinfo->coeff_i
226 + err_der * pinfo->coeff_d);
Stefano Brivio90d501d2007-12-19 01:26:34 +0100227 adj = RC_PID_DO_ARITH_RIGHT_SHIFT(adj, 2 * RC_PID_ARITH_SHIFT);
Mattias Nisslerad018372007-12-19 01:25:57 +0100228
229 /* Change rate. */
230 if (adj)
Stefano Brivio90d501d2007-12-19 01:26:34 +0100231 rate_control_pid_adjust_rate(local, sta, adj, rinfo);
Mattias Nisslerad018372007-12-19 01:25:57 +0100232}
233
234static void rate_control_pid_tx_status(void *priv, struct net_device *dev,
235 struct sk_buff *skb,
236 struct ieee80211_tx_status *status)
237{
238 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
239 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
Andrew Lutomirskidf26e7e2008-01-03 21:05:37 -0800240 struct ieee80211_sub_if_data *sdata;
Mattias Nisslerad018372007-12-19 01:25:57 +0100241 struct rc_pid_info *pinfo = priv;
242 struct sta_info *sta;
243 struct rc_pid_sta_info *spinfo;
Mattias Nissler1946b742007-12-20 13:27:26 +0100244 unsigned long period;
Mattias Nisslerad018372007-12-19 01:25:57 +0100245
246 sta = sta_info_get(local, hdr->addr1);
247
248 if (!sta)
249 return;
250
Andrew Lutomirskidf26e7e2008-01-03 21:05:37 -0800251 /* Don't update the state if we're not controlling the rate. */
252 sdata = IEEE80211_DEV_TO_SUB_IF(sta->dev);
253 if (sdata->bss && sdata->bss->force_unicast_rateidx > -1) {
254 sta->txrate = sdata->bss->max_ratectrl_rateidx;
255 return;
256 }
257
Mattias Nisslerad018372007-12-19 01:25:57 +0100258 /* Ignore all frames that were sent with a different rate than the rate
259 * we currently advise mac80211 to use. */
260 if (status->control.rate != &local->oper_hw_mode->rates[sta->txrate])
Stefano Brivio13e05aa2007-12-23 04:43:57 +0100261 goto ignore;
Mattias Nisslerad018372007-12-19 01:25:57 +0100262
263 spinfo = sta->rate_ctrl_priv;
264 spinfo->tx_num_xmit++;
265
Mattias Nissler12446c62007-12-19 01:27:18 +0100266#ifdef CONFIG_MAC80211_DEBUGFS
267 rate_control_pid_event_tx_status(&spinfo->events, status);
268#endif
269
Mattias Nisslerad018372007-12-19 01:25:57 +0100270 /* We count frames that totally failed to be transmitted as two bad
271 * frames, those that made it out but had some retries as one good and
272 * one bad frame. */
273 if (status->excessive_retries) {
274 spinfo->tx_num_failed += 2;
275 spinfo->tx_num_xmit++;
276 } else if (status->retry_count) {
277 spinfo->tx_num_failed++;
278 spinfo->tx_num_xmit++;
279 }
280
281 if (status->excessive_retries) {
282 sta->tx_retry_failed++;
283 sta->tx_num_consecutive_failures++;
284 sta->tx_num_mpdu_fail++;
285 } else {
286 sta->last_ack_rssi[0] = sta->last_ack_rssi[1];
287 sta->last_ack_rssi[1] = sta->last_ack_rssi[2];
288 sta->last_ack_rssi[2] = status->ack_signal;
289 sta->tx_num_consecutive_failures = 0;
290 sta->tx_num_mpdu_ok++;
291 }
292 sta->tx_retry_count += status->retry_count;
293 sta->tx_num_mpdu_fail += status->retry_count;
294
295 /* Update PID controller state. */
Mattias Nissler1946b742007-12-20 13:27:26 +0100296 period = (HZ * pinfo->sampling_period + 500) / 1000;
297 if (!period)
298 period = 1;
299 if (time_after(jiffies, spinfo->last_sample + period))
Mattias Nisslerad018372007-12-19 01:25:57 +0100300 rate_control_pid_sample(pinfo, local, sta);
301
Stefano Brivio13e05aa2007-12-23 04:43:57 +0100302ignore:
Mattias Nisslerad018372007-12-19 01:25:57 +0100303 sta_info_put(sta);
304}
305
306static void rate_control_pid_get_rate(void *priv, struct net_device *dev,
307 struct ieee80211_hw_mode *mode,
308 struct sk_buff *skb,
309 struct rate_selection *sel)
310{
311 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
312 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
Michael Wu2bc454b2007-12-25 19:33:16 -0500313 struct ieee80211_sub_if_data *sdata;
Mattias Nisslerad018372007-12-19 01:25:57 +0100314 struct sta_info *sta;
315 int rateidx;
Michael Wu2bc454b2007-12-25 19:33:16 -0500316 u16 fc;
Mattias Nisslerad018372007-12-19 01:25:57 +0100317
318 sta = sta_info_get(local, hdr->addr1);
319
Michael Wu2bc454b2007-12-25 19:33:16 -0500320 /* Send management frames and broadcast/multicast data using lowest
321 * rate. */
322 fc = le16_to_cpu(hdr->frame_control);
323 if ((fc & IEEE80211_FCTL_FTYPE) != IEEE80211_FTYPE_DATA ||
324 is_multicast_ether_addr(hdr->addr1) || !sta) {
325 sel->rate = rate_lowest(local, mode, sta);
326 if (sta)
327 sta_info_put(sta);
Mattias Nisslerad018372007-12-19 01:25:57 +0100328 return;
329 }
330
Michael Wu2bc454b2007-12-25 19:33:16 -0500331 /* If a forced rate is in effect, select it. */
332 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
333 if (sdata->bss && sdata->bss->force_unicast_rateidx > -1)
334 sta->txrate = sdata->bss->force_unicast_rateidx;
335
Mattias Nisslerad018372007-12-19 01:25:57 +0100336 rateidx = sta->txrate;
337
338 if (rateidx >= mode->num_rates)
339 rateidx = mode->num_rates - 1;
340
Michael Wu2bc454b2007-12-25 19:33:16 -0500341 sta->last_txrate = rateidx;
342
Mattias Nisslerad018372007-12-19 01:25:57 +0100343 sta_info_put(sta);
344
345 sel->rate = &mode->rates[rateidx];
Mattias Nissler12446c62007-12-19 01:27:18 +0100346
347#ifdef CONFIG_MAC80211_DEBUGFS
348 rate_control_pid_event_tx_rate(
349 &((struct rc_pid_sta_info *) sta->rate_ctrl_priv)->events,
350 rateidx, mode->rates[rateidx].rate);
351#endif
Mattias Nisslerad018372007-12-19 01:25:57 +0100352}
353
354static void rate_control_pid_rate_init(void *priv, void *priv_sta,
355 struct ieee80211_local *local,
356 struct sta_info *sta)
357{
358 /* TODO: This routine should consider using RSSI from previous packets
359 * as we need to have IEEE 802.1X auth succeed immediately after assoc..
360 * Until that method is implemented, we will use the lowest supported
361 * rate as a workaround. */
362 sta->txrate = rate_lowest_index(local, local->oper_hw_mode, sta);
363}
364
365static void *rate_control_pid_alloc(struct ieee80211_local *local)
366{
367 struct rc_pid_info *pinfo;
Stefano Brivio90d501d2007-12-19 01:26:34 +0100368 struct rc_pid_rateinfo *rinfo;
369 struct ieee80211_hw_mode *mode;
370 int i, j, tmp;
371 bool s;
Mattias Nissler1946b742007-12-20 13:27:26 +0100372#ifdef CONFIG_MAC80211_DEBUGFS
373 struct rc_pid_debugfs_entries *de;
374#endif
Mattias Nisslerad018372007-12-19 01:25:57 +0100375
376 pinfo = kmalloc(sizeof(*pinfo), GFP_ATOMIC);
Stefano Brivio90d501d2007-12-19 01:26:34 +0100377 if (!pinfo)
378 return NULL;
379
380 /* We can safely assume that oper_hw_mode won't change unless we get
381 * reinitialized. */
382 mode = local->oper_hw_mode;
383 rinfo = kmalloc(sizeof(*rinfo) * mode->num_rates, GFP_ATOMIC);
384 if (!rinfo) {
385 kfree(pinfo);
386 return NULL;
387 }
388
389 /* Sort the rates. This is optimized for the most common case (i.e.
390 * almost-sorted CCK+OFDM rates). Kind of bubble-sort with reversed
391 * mapping too. */
392 for (i = 0; i < mode->num_rates; i++) {
393 rinfo[i].index = i;
394 rinfo[i].rev_index = i;
Mattias Nissler1946b742007-12-20 13:27:26 +0100395 if (pinfo->fast_start)
Stefano Brivio90d501d2007-12-19 01:26:34 +0100396 rinfo[i].diff = 0;
397 else
Mattias Nissler1946b742007-12-20 13:27:26 +0100398 rinfo[i].diff = i * pinfo->norm_offset;
Stefano Brivio90d501d2007-12-19 01:26:34 +0100399 }
400 for (i = 1; i < mode->num_rates; i++) {
401 s = 0;
402 for (j = 0; j < mode->num_rates - i; j++)
403 if (unlikely(mode->rates[rinfo[j].index].rate >
404 mode->rates[rinfo[j + 1].index].rate)) {
405 tmp = rinfo[j].index;
406 rinfo[j].index = rinfo[j + 1].index;
407 rinfo[j + 1].index = tmp;
408 rinfo[rinfo[j].index].rev_index = j;
409 rinfo[rinfo[j + 1].index].rev_index = j + 1;
410 s = 1;
411 }
412 if (!s)
413 break;
414 }
Mattias Nisslerad018372007-12-19 01:25:57 +0100415
416 pinfo->target = RC_PID_TARGET_PF;
Mattias Nissler1946b742007-12-20 13:27:26 +0100417 pinfo->sampling_period = RC_PID_INTERVAL;
Mattias Nisslerad018372007-12-19 01:25:57 +0100418 pinfo->coeff_p = RC_PID_COEFF_P;
419 pinfo->coeff_i = RC_PID_COEFF_I;
420 pinfo->coeff_d = RC_PID_COEFF_D;
Mattias Nissler1946b742007-12-20 13:27:26 +0100421 pinfo->smoothing_shift = RC_PID_SMOOTHING_SHIFT;
422 pinfo->sharpen_factor = RC_PID_SHARPENING_FACTOR;
423 pinfo->sharpen_duration = RC_PID_SHARPENING_DURATION;
424 pinfo->norm_offset = RC_PID_NORM_OFFSET;
425 pinfo->fast_start = RC_PID_FAST_START;
Stefano Brivio90d501d2007-12-19 01:26:34 +0100426 pinfo->rinfo = rinfo;
427 pinfo->oldrate = 0;
Mattias Nisslerad018372007-12-19 01:25:57 +0100428
Mattias Nissler1946b742007-12-20 13:27:26 +0100429#ifdef CONFIG_MAC80211_DEBUGFS
430 de = &pinfo->dentries;
431 de->dir = debugfs_create_dir("rc80211_pid",
432 local->hw.wiphy->debugfsdir);
433 de->target = debugfs_create_u32("target_pf", S_IRUSR | S_IWUSR,
434 de->dir, &pinfo->target);
435 de->sampling_period = debugfs_create_u32("sampling_period",
436 S_IRUSR | S_IWUSR, de->dir,
437 &pinfo->sampling_period);
438 de->coeff_p = debugfs_create_u32("coeff_p", S_IRUSR | S_IWUSR,
439 de->dir, &pinfo->coeff_p);
440 de->coeff_i = debugfs_create_u32("coeff_i", S_IRUSR | S_IWUSR,
441 de->dir, &pinfo->coeff_i);
442 de->coeff_d = debugfs_create_u32("coeff_d", S_IRUSR | S_IWUSR,
443 de->dir, &pinfo->coeff_d);
444 de->smoothing_shift = debugfs_create_u32("smoothing_shift",
445 S_IRUSR | S_IWUSR, de->dir,
446 &pinfo->smoothing_shift);
447 de->sharpen_factor = debugfs_create_u32("sharpen_factor",
448 S_IRUSR | S_IWUSR, de->dir,
449 &pinfo->sharpen_factor);
450 de->sharpen_duration = debugfs_create_u32("sharpen_duration",
451 S_IRUSR | S_IWUSR, de->dir,
452 &pinfo->sharpen_duration);
453 de->norm_offset = debugfs_create_u32("norm_offset",
454 S_IRUSR | S_IWUSR, de->dir,
455 &pinfo->norm_offset);
456 de->fast_start = debugfs_create_bool("fast_start",
457 S_IRUSR | S_IWUSR, de->dir,
458 &pinfo->fast_start);
459#endif
460
Mattias Nisslerad018372007-12-19 01:25:57 +0100461 return pinfo;
462}
463
464static void rate_control_pid_free(void *priv)
465{
466 struct rc_pid_info *pinfo = priv;
Mattias Nissler1946b742007-12-20 13:27:26 +0100467#ifdef CONFIG_MAC80211_DEBUGFS
468 struct rc_pid_debugfs_entries *de = &pinfo->dentries;
469
470 debugfs_remove(de->fast_start);
471 debugfs_remove(de->norm_offset);
472 debugfs_remove(de->sharpen_duration);
473 debugfs_remove(de->sharpen_factor);
474 debugfs_remove(de->smoothing_shift);
475 debugfs_remove(de->coeff_d);
476 debugfs_remove(de->coeff_i);
477 debugfs_remove(de->coeff_p);
478 debugfs_remove(de->sampling_period);
479 debugfs_remove(de->target);
480 debugfs_remove(de->dir);
481#endif
482
Stefano Brivio90d501d2007-12-19 01:26:34 +0100483 kfree(pinfo->rinfo);
Mattias Nisslerad018372007-12-19 01:25:57 +0100484 kfree(pinfo);
485}
486
487static void rate_control_pid_clear(void *priv)
488{
489}
490
491static void *rate_control_pid_alloc_sta(void *priv, gfp_t gfp)
492{
493 struct rc_pid_sta_info *spinfo;
494
495 spinfo = kzalloc(sizeof(*spinfo), gfp);
Mattias Nissler12446c62007-12-19 01:27:18 +0100496 if (spinfo == NULL)
497 return NULL;
498
Stefano Brivioc09c7232008-01-17 00:38:29 +0100499 spinfo->last_sample = jiffies;
500
Mattias Nissler12446c62007-12-19 01:27:18 +0100501#ifdef CONFIG_MAC80211_DEBUGFS
502 spin_lock_init(&spinfo->events.lock);
503 init_waitqueue_head(&spinfo->events.waitqueue);
504#endif
Mattias Nisslerad018372007-12-19 01:25:57 +0100505
506 return spinfo;
507}
508
509static void rate_control_pid_free_sta(void *priv, void *priv_sta)
510{
511 struct rc_pid_sta_info *spinfo = priv_sta;
512 kfree(spinfo);
513}
514
Johannes Berg4b475892008-01-02 15:17:03 +0100515static struct rate_control_ops mac80211_rcpid = {
Mattias Nisslerad018372007-12-19 01:25:57 +0100516 .name = "pid",
517 .tx_status = rate_control_pid_tx_status,
518 .get_rate = rate_control_pid_get_rate,
519 .rate_init = rate_control_pid_rate_init,
520 .clear = rate_control_pid_clear,
521 .alloc = rate_control_pid_alloc,
522 .free = rate_control_pid_free,
523 .alloc_sta = rate_control_pid_alloc_sta,
524 .free_sta = rate_control_pid_free_sta,
Mattias Nissler12446c62007-12-19 01:27:18 +0100525#ifdef CONFIG_MAC80211_DEBUGFS
526 .add_sta_debugfs = rate_control_pid_add_sta_debugfs,
527 .remove_sta_debugfs = rate_control_pid_remove_sta_debugfs,
528#endif
Mattias Nisslerad018372007-12-19 01:25:57 +0100529};
Johannes Berg4b475892008-01-02 15:17:03 +0100530
531MODULE_DESCRIPTION("PID controller based rate control algorithm");
532MODULE_AUTHOR("Stefano Brivio");
533MODULE_AUTHOR("Mattias Nissler");
534MODULE_LICENSE("GPL");
535
536int __init rc80211_pid_init(void)
537{
538 return ieee80211_rate_control_register(&mac80211_rcpid);
539}
540
541void __exit rc80211_pid_exit(void)
542{
543 ieee80211_rate_control_unregister(&mac80211_rcpid);
544}
545
546#ifdef CONFIG_MAC80211_RC_PID_MODULE
547module_init(rc80211_pid_init);
548module_exit(rc80211_pid_exit);
549#endif