← Back to branch summary

~ubuntu-branches/debian/wheezy/linux-2.6/wheezy

« back to all changes in this revision

Viewing changes to drivers/net/wireless/iwlegacy/iwl-3945-rs.c

  • Committer: Bazaar Package Importer
  • Author(s): Ben Hutchings, Ben Hutchings, Aurelien Jarno
  • Date: 2011-06-07 12:14:05 UTC
  • mfrom: (43.1.9 sid)
  • Revision ID: james.westby@ubuntu.com-20110607121405-i3h1rd7nrnd2b73h
Tags: 2.6.39-2
http://bugs.debian.org/627492
http://bugs.debian.org/596626
http://bugs.debian.org/628932
http://bugs.debian.org/628191
http://bugs.debian.org/627837
http://bugs.debian.org/622997
http://bugs.debian.org/622745
http://bugs.debian.org/619827
http://bugs.debian.org/629401
[ Ben Hutchings ]
* [x86] Enable BACKLIGHT_APPLE, replacing BACKLIGHT_MBP_NVIDIA
  (Closes: #627492)
* cgroups: Disable memory resource controller by default. Allow it
  to be enabled using kernel parameter 'cgroup_enable=memory'.
* rt2800usb: Enable support for more USB devices including
  Linksys WUSB600N (Closes: #596626) (this change was accidentally
  omitted from 2.6.39-1)
* [x86] Remove Celeron from list of processors supporting PAE. Most
  'Celeron M' models do not.
* Update debconf template translations:
  - Swedish (Martin Bagge) (Closes: #628932)
  - French (David Prévot) (Closes: #628191)
* aufs: Update for 2.6.39 (Closes: #627837)
* Add stable 2.6.39.1, including:
  - ext4: dont set PageUptodate in ext4_end_bio()
  - pata_cmd64x: fix boot crash on parisc (Closes: #622997, #622745)
  - ext3: Fix fs corruption when make_indexed_dir() fails
  - netfilter: nf_ct_sip: validate Content-Length in TCP SIP messages
  - sctp: fix race between sctp_bind_addr_free() and
    sctp_bind_addr_conflict()
  - sctp: fix memory leak of the ASCONF queue when free asoc
  - md/bitmap: fix saving of events_cleared and other state
  - cdc_acm: Fix oops when Droids MuIn LCD is connected
  - cx88: Fix conversion from BKL to fine-grained locks (Closes: #619827)
  - keys: Set cred->user_ns in key_replace_session_keyring (CVE-2011-2184)
  - tmpfs: fix race between truncate and writepage
  - nfs41: Correct offset for LAYOUTCOMMIT
  - xen/mmu: fix a race window causing leave_mm BUG()
  - ext4: fix possible use-after-free in ext4_remove_li_request()
  For the complete list of changes, see:
   http://www.kernel.org/pub/linux/kernel/v2.6/ChangeLog-2.6.39.1
* Bump ABI to 2
* netfilter: Enable IP_SET, IP_SET_BITMAP_IP, IP_SET_BITMAP_IPMAC,
  IP_SET_BITMAP_PORT, IP_SET_HASH_IP, IP_SET_HASH_IPPORT,
  IP_SET_HASH_IPPORTIP, IP_SET_HASH_IPPORTNET, IP_SET_HASH_NET,
  IP_SET_HASH_NETPORT, IP_SET_LIST_SET, NETFILTER_XT_SET as modules
  (Closes: #629401)

[ Aurelien Jarno ]
* [mipsel/loongson-2f] Disable_SCSI_LPFC to workaround GCC ICE.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/net/wireless/iwlegacy/iwl-3945-rs.c
 
1
/******************************************************************************
 
2
 *
 
3
 * Copyright(c) 2005 - 2011 Intel Corporation. All rights reserved.
 
4
 *
 
5
 * This program is free software; you can redistribute it and/or modify it
 
6
 * under the terms of version 2 of the GNU General Public License as
 
7
 * published by the Free Software Foundation.
 
8
 *
 
9
 * This program is distributed in the hope that it will be useful, but WITHOUT
 
10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 
11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 
12
 * more details.
 
13
 *
 
14
 * You should have received a copy of the GNU General Public License along with
 
15
 * this program; if not, write to the Free Software Foundation, Inc.,
 
16
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
 
17
 *
 
18
 * The full GNU General Public License is included in this distribution in the
 
19
 * file called LICENSE.
 
20
 *
 
21
 * Contact Information:
 
22
 *  Intel Linux Wireless <ilw@linux.intel.com>
 
23
 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
 
24
 *
 
25
 *****************************************************************************/
 
26
 
 
27
#include <linux/kernel.h>
 
28
#include <linux/init.h>
 
29
#include <linux/skbuff.h>
 
30
#include <linux/slab.h>
 
31
#include <linux/wireless.h>
 
32
#include <net/mac80211.h>
 
33
 
 
34
#include <linux/netdevice.h>
 
35
#include <linux/etherdevice.h>
 
36
#include <linux/delay.h>
 
37
 
 
38
#include <linux/workqueue.h>
 
39
 
 
40
#include "iwl-commands.h"
 
41
#include "iwl-3945.h"
 
42
#include "iwl-sta.h"
 
43
 
 
44
#define RS_NAME "iwl-3945-rs"
 
45
 
 
46
static s32 iwl3945_expected_tpt_g[IWL_RATE_COUNT_3945] = {
 
47
        7, 13, 35, 58, 0, 0, 76, 104, 130, 168, 191, 202
 
48
};
 
49
 
 
50
static s32 iwl3945_expected_tpt_g_prot[IWL_RATE_COUNT_3945] = {
 
51
        7, 13, 35, 58, 0, 0, 0, 80, 93, 113, 123, 125
 
52
};
 
53
 
 
54
static s32 iwl3945_expected_tpt_a[IWL_RATE_COUNT_3945] = {
 
55
        0, 0, 0, 0, 40, 57, 72, 98, 121, 154, 177, 186
 
56
};
 
57
 
 
58
static s32 iwl3945_expected_tpt_b[IWL_RATE_COUNT_3945] = {
 
59
        7, 13, 35, 58, 0, 0, 0, 0, 0, 0, 0, 0
 
60
};
 
61
 
 
62
struct iwl3945_tpt_entry {
 
63
        s8 min_rssi;
 
64
        u8 index;
 
65
};
 
66
 
 
67
static struct iwl3945_tpt_entry iwl3945_tpt_table_a[] = {
 
68
        {-60, IWL_RATE_54M_INDEX},
 
69
        {-64, IWL_RATE_48M_INDEX},
 
70
        {-72, IWL_RATE_36M_INDEX},
 
71
        {-80, IWL_RATE_24M_INDEX},
 
72
        {-84, IWL_RATE_18M_INDEX},
 
73
        {-85, IWL_RATE_12M_INDEX},
 
74
        {-87, IWL_RATE_9M_INDEX},
 
75
        {-89, IWL_RATE_6M_INDEX}
 
76
};
 
77
 
 
78
static struct iwl3945_tpt_entry iwl3945_tpt_table_g[] = {
 
79
        {-60, IWL_RATE_54M_INDEX},
 
80
        {-64, IWL_RATE_48M_INDEX},
 
81
        {-68, IWL_RATE_36M_INDEX},
 
82
        {-80, IWL_RATE_24M_INDEX},
 
83
        {-84, IWL_RATE_18M_INDEX},
 
84
        {-85, IWL_RATE_12M_INDEX},
 
85
        {-86, IWL_RATE_11M_INDEX},
 
86
        {-88, IWL_RATE_5M_INDEX},
 
87
        {-90, IWL_RATE_2M_INDEX},
 
88
        {-92, IWL_RATE_1M_INDEX}
 
89
};
 
90
 
 
91
#define IWL_RATE_MAX_WINDOW          62
 
92
#define IWL_RATE_FLUSH          (3*HZ)
 
93
#define IWL_RATE_WIN_FLUSH       (HZ/2)
 
94
#define IWL39_RATE_HIGH_TH          11520
 
95
#define IWL_SUCCESS_UP_TH          8960
 
96
#define IWL_SUCCESS_DOWN_TH       10880
 
97
#define IWL_RATE_MIN_FAILURE_TH       6
 
98
#define IWL_RATE_MIN_SUCCESS_TH       8
 
99
#define IWL_RATE_DECREASE_TH       1920
 
100
#define IWL_RATE_RETRY_TH            15
 
101
 
 
102
static u8 iwl3945_get_rate_index_by_rssi(s32 rssi, enum ieee80211_band band)
 
103
{
 
104
        u32 index = 0;
 
105
        u32 table_size = 0;
 
106
        struct iwl3945_tpt_entry *tpt_table = NULL;
 
107
 
 
108
        if ((rssi < IWL_MIN_RSSI_VAL) || (rssi > IWL_MAX_RSSI_VAL))
 
109
                rssi = IWL_MIN_RSSI_VAL;
 
110
 
 
111
        switch (band) {
 
112
        case IEEE80211_BAND_2GHZ:
 
113
                tpt_table = iwl3945_tpt_table_g;
 
114
                table_size = ARRAY_SIZE(iwl3945_tpt_table_g);
 
115
                break;
 
116
 
 
117
        case IEEE80211_BAND_5GHZ:
 
118
                tpt_table = iwl3945_tpt_table_a;
 
119
                table_size = ARRAY_SIZE(iwl3945_tpt_table_a);
 
120
                break;
 
121
 
 
122
        default:
 
123
                BUG();
 
124
                break;
 
125
        }
 
126
 
 
127
        while ((index < table_size) && (rssi < tpt_table[index].min_rssi))
 
128
                index++;
 
129
 
 
130
        index = min(index, (table_size - 1));
 
131
 
 
132
        return tpt_table[index].index;
 
133
}
 
134
 
 
135
static void iwl3945_clear_window(struct iwl3945_rate_scale_data *window)
 
136
{
 
137
        window->data = 0;
 
138
        window->success_counter = 0;
 
139
        window->success_ratio = -1;
 
140
        window->counter = 0;
 
141
        window->average_tpt = IWL_INVALID_VALUE;
 
142
        window->stamp = 0;
 
143
}
 
144
 
 
145
/**
 
146
 * iwl3945_rate_scale_flush_windows - flush out the rate scale windows
 
147
 *
 
148
 * Returns the number of windows that have gathered data but were
 
149
 * not flushed.  If there were any that were not flushed, then
 
150
 * reschedule the rate flushing routine.
 
151
 */
 
152
static int iwl3945_rate_scale_flush_windows(struct iwl3945_rs_sta *rs_sta)
 
153
{
 
154
        int unflushed = 0;
 
155
        int i;
 
156
        unsigned long flags;
 
157
        struct iwl_priv *priv __maybe_unused = rs_sta->priv;
 
158
 
 
159
        /*
 
160
         * For each rate, if we have collected data on that rate
 
161
         * and it has been more than IWL_RATE_WIN_FLUSH
 
162
         * since we flushed, clear out the gathered statistics
 
163
         */
 
164
        for (i = 0; i < IWL_RATE_COUNT_3945; i++) {
 
165
                if (!rs_sta->win[i].counter)
 
166
                        continue;
 
167
 
 
168
                spin_lock_irqsave(&rs_sta->lock, flags);
 
169
                if (time_after(jiffies, rs_sta->win[i].stamp +
 
170
                               IWL_RATE_WIN_FLUSH)) {
 
171
                        IWL_DEBUG_RATE(priv, "flushing %d samples of rate "
 
172
                                       "index %d\n",
 
173
                                       rs_sta->win[i].counter, i);
 
174
                        iwl3945_clear_window(&rs_sta->win[i]);
 
175
                } else
 
176
                        unflushed++;
 
177
                spin_unlock_irqrestore(&rs_sta->lock, flags);
 
178
        }
 
179
 
 
180
        return unflushed;
 
181
}
 
182
 
 
183
#define IWL_RATE_FLUSH_MAX              5000    /* msec */
 
184
#define IWL_RATE_FLUSH_MIN              50      /* msec */
 
185
#define IWL_AVERAGE_PACKETS             1500
 
186
 
 
187
static void iwl3945_bg_rate_scale_flush(unsigned long data)
 
188
{
 
189
        struct iwl3945_rs_sta *rs_sta = (void *)data;
 
190
        struct iwl_priv *priv __maybe_unused = rs_sta->priv;
 
191
        int unflushed = 0;
 
192
        unsigned long flags;
 
193
        u32 packet_count, duration, pps;
 
194
 
 
195
        IWL_DEBUG_RATE(priv, "enter\n");
 
196
 
 
197
        unflushed = iwl3945_rate_scale_flush_windows(rs_sta);
 
198
 
 
199
        spin_lock_irqsave(&rs_sta->lock, flags);
 
200
 
 
201
        /* Number of packets Rx'd since last time this timer ran */
 
202
        packet_count = (rs_sta->tx_packets - rs_sta->last_tx_packets) + 1;
 
203
 
 
204
        rs_sta->last_tx_packets = rs_sta->tx_packets + 1;
 
205
 
 
206
        if (unflushed) {
 
207
                duration =
 
208
                    jiffies_to_msecs(jiffies - rs_sta->last_partial_flush);
 
209
 
 
210
                IWL_DEBUG_RATE(priv, "Tx'd %d packets in %dms\n",
 
211
                               packet_count, duration);
 
212
 
 
213
                /* Determine packets per second */
 
214
                if (duration)
 
215
                        pps = (packet_count * 1000) / duration;
 
216
                else
 
217
                        pps = 0;
 
218
 
 
219
                if (pps) {
 
220
                        duration = (IWL_AVERAGE_PACKETS * 1000) / pps;
 
221
                        if (duration < IWL_RATE_FLUSH_MIN)
 
222
                                duration = IWL_RATE_FLUSH_MIN;
 
223
                        else if (duration > IWL_RATE_FLUSH_MAX)
 
224
                                duration = IWL_RATE_FLUSH_MAX;
 
225
                } else
 
226
                        duration = IWL_RATE_FLUSH_MAX;
 
227
 
 
228
                rs_sta->flush_time = msecs_to_jiffies(duration);
 
229
 
 
230
                IWL_DEBUG_RATE(priv, "new flush period: %d msec ave %d\n",
 
231
                               duration, packet_count);
 
232
 
 
233
                mod_timer(&rs_sta->rate_scale_flush, jiffies +
 
234
                          rs_sta->flush_time);
 
235
 
 
236
                rs_sta->last_partial_flush = jiffies;
 
237
        } else {
 
238
                rs_sta->flush_time = IWL_RATE_FLUSH;
 
239
                rs_sta->flush_pending = 0;
 
240
        }
 
241
        /* If there weren't any unflushed entries, we don't schedule the timer
 
242
         * to run again */
 
243
 
 
244
        rs_sta->last_flush = jiffies;
 
245
 
 
246
        spin_unlock_irqrestore(&rs_sta->lock, flags);
 
247
 
 
248
        IWL_DEBUG_RATE(priv, "leave\n");
 
249
}
 
250
 
 
251
/**
 
252
 * iwl3945_collect_tx_data - Update the success/failure sliding window
 
253
 *
 
254
 * We keep a sliding window of the last 64 packets transmitted
 
255
 * at this rate.  window->data contains the bitmask of successful
 
256
 * packets.
 
257
 */
 
258
static void iwl3945_collect_tx_data(struct iwl3945_rs_sta *rs_sta,
 
259
                                struct iwl3945_rate_scale_data *window,
 
260
                                int success, int retries, int index)
 
261
{
 
262
        unsigned long flags;
 
263
        s32 fail_count;
 
264
        struct iwl_priv *priv __maybe_unused = rs_sta->priv;
 
265
 
 
266
        if (!retries) {
 
267
                IWL_DEBUG_RATE(priv, "leave: retries == 0 -- should be at least 1\n");
 
268
                return;
 
269
        }
 
270
 
 
271
        spin_lock_irqsave(&rs_sta->lock, flags);
 
272
 
 
273
        /*
 
274
         * Keep track of only the latest 62 tx frame attempts in this rate's
 
275
         * history window; anything older isn't really relevant any more.
 
276
         * If we have filled up the sliding window, drop the oldest attempt;
 
277
         * if the oldest attempt (highest bit in bitmap) shows "success",
 
278
         * subtract "1" from the success counter (this is the main reason
 
279
         * we keep these bitmaps!).
 
280
         * */
 
281
        while (retries > 0) {
 
282
                if (window->counter >= IWL_RATE_MAX_WINDOW) {
 
283
 
 
284
                        /* remove earliest */
 
285
                        window->counter = IWL_RATE_MAX_WINDOW - 1;
 
286
 
 
287
                        if (window->data & (1ULL << (IWL_RATE_MAX_WINDOW - 1))) {
 
288
                                window->data &= ~(1ULL << (IWL_RATE_MAX_WINDOW - 1));
 
289
                                window->success_counter--;
 
290
                        }
 
291
                }
 
292
 
 
293
                /* Increment frames-attempted counter */
 
294
                window->counter++;
 
295
 
 
296
                /* Shift bitmap by one frame (throw away oldest history),
 
297
                 * OR in "1", and increment "success" if this
 
298
                 * frame was successful. */
 
299
                window->data <<= 1;
 
300
                if (success > 0) {
 
301
                        window->success_counter++;
 
302
                        window->data |= 0x1;
 
303
                        success--;
 
304
                }
 
305
 
 
306
                retries--;
 
307
        }
 
308
 
 
309
        /* Calculate current success ratio, avoid divide-by-0! */
 
310
        if (window->counter > 0)
 
311
                window->success_ratio = 128 * (100 * window->success_counter)
 
312
                                        / window->counter;
 
313
        else
 
314
                window->success_ratio = IWL_INVALID_VALUE;
 
315
 
 
316
        fail_count = window->counter - window->success_counter;
 
317
 
 
318
        /* Calculate average throughput, if we have enough history. */
 
319
        if ((fail_count >= IWL_RATE_MIN_FAILURE_TH) ||
 
320
            (window->success_counter >= IWL_RATE_MIN_SUCCESS_TH))
 
321
                window->average_tpt = ((window->success_ratio *
 
322
                                rs_sta->expected_tpt[index] + 64) / 128);
 
323
        else
 
324
                window->average_tpt = IWL_INVALID_VALUE;
 
325
 
 
326
        /* Tag this window as having been updated */
 
327
        window->stamp = jiffies;
 
328
 
 
329
        spin_unlock_irqrestore(&rs_sta->lock, flags);
 
330
 
 
331
}
 
332
 
 
333
/*
 
334
 * Called after adding a new station to initialize rate scaling
 
335
 */
 
336
void iwl3945_rs_rate_init(struct iwl_priv *priv, struct ieee80211_sta *sta, u8 sta_id)
 
337
{
 
338
        struct ieee80211_hw *hw = priv->hw;
 
339
        struct ieee80211_conf *conf = &priv->hw->conf;
 
340
        struct iwl3945_sta_priv *psta;
 
341
        struct iwl3945_rs_sta *rs_sta;
 
342
        struct ieee80211_supported_band *sband;
 
343
        int i;
 
344
 
 
345
        IWL_DEBUG_INFO(priv, "enter\n");
 
346
        if (sta_id == priv->contexts[IWL_RXON_CTX_BSS].bcast_sta_id)
 
347
                goto out;
 
348
 
 
349
        psta = (struct iwl3945_sta_priv *) sta->drv_priv;
 
350
        rs_sta = &psta->rs_sta;
 
351
        sband = hw->wiphy->bands[conf->channel->band];
 
352
 
 
353
        rs_sta->priv = priv;
 
354
 
 
355
        rs_sta->start_rate = IWL_RATE_INVALID;
 
356
 
 
357
        /* default to just 802.11b */
 
358
        rs_sta->expected_tpt = iwl3945_expected_tpt_b;
 
359
 
 
360
        rs_sta->last_partial_flush = jiffies;
 
361
        rs_sta->last_flush = jiffies;
 
362
        rs_sta->flush_time = IWL_RATE_FLUSH;
 
363
        rs_sta->last_tx_packets = 0;
 
364
 
 
365
        rs_sta->rate_scale_flush.data = (unsigned long)rs_sta;
 
366
        rs_sta->rate_scale_flush.function = iwl3945_bg_rate_scale_flush;
 
367
 
 
368
        for (i = 0; i < IWL_RATE_COUNT_3945; i++)
 
369
                iwl3945_clear_window(&rs_sta->win[i]);
 
370
 
 
371
        /* TODO: what is a good starting rate for STA? About middle? Maybe not
 
372
         * the lowest or the highest rate.. Could consider using RSSI from
 
373
         * previous packets? Need to have IEEE 802.1X auth succeed immediately
 
374
         * after assoc.. */
 
375
 
 
376
        for (i = sband->n_bitrates - 1; i >= 0; i--) {
 
377
                if (sta->supp_rates[sband->band] & (1 << i)) {
 
378
                        rs_sta->last_txrate_idx = i;
 
379
                        break;
 
380
                }
 
381
        }
 
382
 
 
383
        priv->_3945.sta_supp_rates = sta->supp_rates[sband->band];
 
384
        /* For 5 GHz band it start at IWL_FIRST_OFDM_RATE */
 
385
        if (sband->band == IEEE80211_BAND_5GHZ) {
 
386
                rs_sta->last_txrate_idx += IWL_FIRST_OFDM_RATE;
 
387
                priv->_3945.sta_supp_rates = priv->_3945.sta_supp_rates <<
 
388
                                                IWL_FIRST_OFDM_RATE;
 
389
        }
 
390
 
 
391
out:
 
392
        priv->stations[sta_id].used &= ~IWL_STA_UCODE_INPROGRESS;
 
393
 
 
394
        IWL_DEBUG_INFO(priv, "leave\n");
 
395
}
 
396
 
 
397
static void *iwl3945_rs_alloc(struct ieee80211_hw *hw, struct dentry *debugfsdir)
 
398
{
 
399
        return hw->priv;
 
400
}
 
401
 
 
402
/* rate scale requires free function to be implemented */
 
403
static void iwl3945_rs_free(void *priv)
 
404
{
 
405
        return;
 
406
}
 
407
 
 
408
static void *iwl3945_rs_alloc_sta(void *iwl_priv, struct ieee80211_sta *sta, gfp_t gfp)
 
409
{
 
410
        struct iwl3945_rs_sta *rs_sta;
 
411
        struct iwl3945_sta_priv *psta = (void *) sta->drv_priv;
 
412
        struct iwl_priv *priv __maybe_unused = iwl_priv;
 
413
 
 
414
        IWL_DEBUG_RATE(priv, "enter\n");
 
415
 
 
416
        rs_sta = &psta->rs_sta;
 
417
 
 
418
        spin_lock_init(&rs_sta->lock);
 
419
        init_timer(&rs_sta->rate_scale_flush);
 
420
 
 
421
        IWL_DEBUG_RATE(priv, "leave\n");
 
422
 
 
423
        return rs_sta;
 
424
}
 
425
 
 
426
static void iwl3945_rs_free_sta(void *iwl_priv, struct ieee80211_sta *sta,
 
427
                        void *priv_sta)
 
428
{
 
429
        struct iwl3945_rs_sta *rs_sta = priv_sta;
 
430
 
 
431
        /*
 
432
         * Be careful not to use any members of iwl3945_rs_sta (like trying
 
433
         * to use iwl_priv to print out debugging) since it may not be fully
 
434
         * initialized at this point.
 
435
         */
 
436
        del_timer_sync(&rs_sta->rate_scale_flush);
 
437
}
 
438
 
 
439
 
 
440
/**
 
441
 * iwl3945_rs_tx_status - Update rate control values based on Tx results
 
442
 *
 
443
 * NOTE: Uses iwl_priv->retry_rate for the # of retries attempted by
 
444
 * the hardware for each rate.
 
445
 */
 
446
static void iwl3945_rs_tx_status(void *priv_rate, struct ieee80211_supported_band *sband,
 
447
                         struct ieee80211_sta *sta, void *priv_sta,
 
448
                         struct sk_buff *skb)
 
449
{
 
450
        s8 retries = 0, current_count;
 
451
        int scale_rate_index, first_index, last_index;
 
452
        unsigned long flags;
 
453
        struct iwl_priv *priv = (struct iwl_priv *)priv_rate;
 
454
        struct iwl3945_rs_sta *rs_sta = priv_sta;
 
455
        struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
 
456
 
 
457
        IWL_DEBUG_RATE(priv, "enter\n");
 
458
 
 
459
        retries = info->status.rates[0].count;
 
460
        /* Sanity Check for retries */
 
461
        if (retries > IWL_RATE_RETRY_TH)
 
462
                retries = IWL_RATE_RETRY_TH;
 
463
 
 
464
        first_index = sband->bitrates[info->status.rates[0].idx].hw_value;
 
465
        if ((first_index < 0) || (first_index >= IWL_RATE_COUNT_3945)) {
 
466
                IWL_DEBUG_RATE(priv, "leave: Rate out of bounds: %d\n", first_index);
 
467
                return;
 
468
        }
 
469
 
 
470
        if (!priv_sta) {
 
471
                IWL_DEBUG_RATE(priv, "leave: No STA priv data to update!\n");
 
472
                return;
 
473
        }
 
474
 
 
475
        /* Treat uninitialized rate scaling data same as non-existing. */
 
476
        if (!rs_sta->priv) {
 
477
                IWL_DEBUG_RATE(priv, "leave: STA priv data uninitialized!\n");
 
478
                return;
 
479
        }
 
480
 
 
481
 
 
482
        rs_sta->tx_packets++;
 
483
 
 
484
        scale_rate_index = first_index;
 
485
        last_index = first_index;
 
486
 
 
487
        /*
 
488
         * Update the window for each rate.  We determine which rates
 
489
         * were Tx'd based on the total number of retries vs. the number
 
490
         * of retries configured for each rate -- currently set to the
 
491
         * priv value 'retry_rate' vs. rate specific
 
492
         *
 
493
         * On exit from this while loop last_index indicates the rate
 
494
         * at which the frame was finally transmitted (or failed if no
 
495
         * ACK)
 
496
         */
 
497
        while (retries > 1) {
 
498
                if ((retries - 1) < priv->retry_rate) {
 
499
                        current_count = (retries - 1);
 
500
                        last_index = scale_rate_index;
 
501
                } else {
 
502
                        current_count = priv->retry_rate;
 
503
                        last_index = iwl3945_rs_next_rate(priv,
 
504
                                                         scale_rate_index);
 
505
                }
 
506
 
 
507
                /* Update this rate accounting for as many retries
 
508
                 * as was used for it (per current_count) */
 
509
                iwl3945_collect_tx_data(rs_sta,
 
510
                                    &rs_sta->win[scale_rate_index],
 
511
                                    0, current_count, scale_rate_index);
 
512
                IWL_DEBUG_RATE(priv, "Update rate %d for %d retries.\n",
 
513
                               scale_rate_index, current_count);
 
514
 
 
515
                retries -= current_count;
 
516
 
 
517
                scale_rate_index = last_index;
 
518
        }
 
519
 
 
520
 
 
521
        /* Update the last index window with success/failure based on ACK */
 
522
        IWL_DEBUG_RATE(priv, "Update rate %d with %s.\n",
 
523
                       last_index,
 
524
                       (info->flags & IEEE80211_TX_STAT_ACK) ?
 
525
                       "success" : "failure");
 
526
        iwl3945_collect_tx_data(rs_sta,
 
527
                            &rs_sta->win[last_index],
 
528
                            info->flags & IEEE80211_TX_STAT_ACK, 1, last_index);
 
529
 
 
530
        /* We updated the rate scale window -- if its been more than
 
531
         * flush_time since the last run, schedule the flush
 
532
         * again */
 
533
        spin_lock_irqsave(&rs_sta->lock, flags);
 
534
 
 
535
        if (!rs_sta->flush_pending &&
 
536
            time_after(jiffies, rs_sta->last_flush +
 
537
                       rs_sta->flush_time)) {
 
538
 
 
539
                rs_sta->last_partial_flush = jiffies;
 
540
                rs_sta->flush_pending = 1;
 
541
                mod_timer(&rs_sta->rate_scale_flush,
 
542
                          jiffies + rs_sta->flush_time);
 
543
        }
 
544
 
 
545
        spin_unlock_irqrestore(&rs_sta->lock, flags);
 
546
 
 
547
        IWL_DEBUG_RATE(priv, "leave\n");
 
548
}
 
549
 
 
550
static u16 iwl3945_get_adjacent_rate(struct iwl3945_rs_sta *rs_sta,
 
551
                                 u8 index, u16 rate_mask, enum ieee80211_band band)
 
552
{
 
553
        u8 high = IWL_RATE_INVALID;
 
554
        u8 low = IWL_RATE_INVALID;
 
555
        struct iwl_priv *priv __maybe_unused = rs_sta->priv;
 
556
 
 
557
        /* 802.11A walks to the next literal adjacent rate in
 
558
         * the rate table */
 
559
        if (unlikely(band == IEEE80211_BAND_5GHZ)) {
 
560
                int i;
 
561
                u32 mask;
 
562
 
 
563
                /* Find the previous rate that is in the rate mask */
 
564
                i = index - 1;
 
565
                for (mask = (1 << i); i >= 0; i--, mask >>= 1) {
 
566
                        if (rate_mask & mask) {
 
567
                                low = i;
 
568
                                break;
 
569
                        }
 
570
                }
 
571
 
 
572
                /* Find the next rate that is in the rate mask */
 
573
                i = index + 1;
 
574
                for (mask = (1 << i); i < IWL_RATE_COUNT_3945;
 
575
                     i++, mask <<= 1) {
 
576
                        if (rate_mask & mask) {
 
577
                                high = i;
 
578
                                break;
 
579
                        }
 
580
                }
 
581
 
 
582
                return (high << 8) | low;
 
583
        }
 
584
 
 
585
        low = index;
 
586
        while (low != IWL_RATE_INVALID) {
 
587
                if (rs_sta->tgg)
 
588
                        low = iwl3945_rates[low].prev_rs_tgg;
 
589
                else
 
590
                        low = iwl3945_rates[low].prev_rs;
 
591
                if (low == IWL_RATE_INVALID)
 
592
                        break;
 
593
                if (rate_mask & (1 << low))
 
594
                        break;
 
595
                IWL_DEBUG_RATE(priv, "Skipping masked lower rate: %d\n", low);
 
596
        }
 
597
 
 
598
        high = index;
 
599
        while (high != IWL_RATE_INVALID) {
 
600
                if (rs_sta->tgg)
 
601
                        high = iwl3945_rates[high].next_rs_tgg;
 
602
                else
 
603
                        high = iwl3945_rates[high].next_rs;
 
604
                if (high == IWL_RATE_INVALID)
 
605
                        break;
 
606
                if (rate_mask & (1 << high))
 
607
                        break;
 
608
                IWL_DEBUG_RATE(priv, "Skipping masked higher rate: %d\n", high);
 
609
        }
 
610
 
 
611
        return (high << 8) | low;
 
612
}
 
613
 
 
614
/**
 
615
 * iwl3945_rs_get_rate - find the rate for the requested packet
 
616
 *
 
617
 * Returns the ieee80211_rate structure allocated by the driver.
 
618
 *
 
619
 * The rate control algorithm has no internal mapping between hw_mode's
 
620
 * rate ordering and the rate ordering used by the rate control algorithm.
 
621
 *
 
622
 * The rate control algorithm uses a single table of rates that goes across
 
623
 * the entire A/B/G spectrum vs. being limited to just one particular
 
624
 * hw_mode.
 
625
 *
 
626
 * As such, we can't convert the index obtained below into the hw_mode's
 
627
 * rate table and must reference the driver allocated rate table
 
628
 *
 
629
 */
 
630
static void iwl3945_rs_get_rate(void *priv_r, struct ieee80211_sta *sta,
 
631
                        void *priv_sta, struct ieee80211_tx_rate_control *txrc)
 
632
{
 
633
        struct ieee80211_supported_band *sband = txrc->sband;
 
634
        struct sk_buff *skb = txrc->skb;
 
635
        u8 low = IWL_RATE_INVALID;
 
636
        u8 high = IWL_RATE_INVALID;
 
637
        u16 high_low;
 
638
        int index;
 
639
        struct iwl3945_rs_sta *rs_sta = priv_sta;
 
640
        struct iwl3945_rate_scale_data *window = NULL;
 
641
        int current_tpt = IWL_INVALID_VALUE;
 
642
        int low_tpt = IWL_INVALID_VALUE;
 
643
        int high_tpt = IWL_INVALID_VALUE;
 
644
        u32 fail_count;
 
645
        s8 scale_action = 0;
 
646
        unsigned long flags;
 
647
        u16 rate_mask;
 
648
        s8 max_rate_idx = -1;
 
649
        struct iwl_priv *priv __maybe_unused = (struct iwl_priv *)priv_r;
 
650
        struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
 
651
 
 
652
        IWL_DEBUG_RATE(priv, "enter\n");
 
653
 
 
654
        /* Treat uninitialized rate scaling data same as non-existing. */
 
655
        if (rs_sta && !rs_sta->priv) {
 
656
                IWL_DEBUG_RATE(priv, "Rate scaling information not initialized yet.\n");
 
657
                priv_sta = NULL;
 
658
        }
 
659
 
 
660
        if (rate_control_send_low(sta, priv_sta, txrc))
 
661
                return;
 
662
 
 
663
        rate_mask = sta->supp_rates[sband->band];
 
664
 
 
665
        /* get user max rate if set */
 
666
        max_rate_idx = txrc->max_rate_idx;
 
667
        if ((sband->band == IEEE80211_BAND_5GHZ) && (max_rate_idx != -1))
 
668
                max_rate_idx += IWL_FIRST_OFDM_RATE;
 
669
        if ((max_rate_idx < 0) || (max_rate_idx >= IWL_RATE_COUNT))
 
670
                max_rate_idx = -1;
 
671
 
 
672
        index = min(rs_sta->last_txrate_idx & 0xffff, IWL_RATE_COUNT_3945 - 1);
 
673
 
 
674
        if (sband->band == IEEE80211_BAND_5GHZ)
 
675
                rate_mask = rate_mask << IWL_FIRST_OFDM_RATE;
 
676
 
 
677
        spin_lock_irqsave(&rs_sta->lock, flags);
 
678
 
 
679
        /* for recent assoc, choose best rate regarding
 
680
         * to rssi value
 
681
         */
 
682
        if (rs_sta->start_rate != IWL_RATE_INVALID) {
 
683
                if (rs_sta->start_rate < index &&
 
684
                   (rate_mask & (1 << rs_sta->start_rate)))
 
685
                        index = rs_sta->start_rate;
 
686
                rs_sta->start_rate = IWL_RATE_INVALID;
 
687
        }
 
688
 
 
689
        /* force user max rate if set by user */
 
690
        if ((max_rate_idx != -1) && (max_rate_idx < index)) {
 
691
                if (rate_mask & (1 << max_rate_idx))
 
692
                        index = max_rate_idx;
 
693
        }
 
694
 
 
695
        window = &(rs_sta->win[index]);
 
696
 
 
697
        fail_count = window->counter - window->success_counter;
 
698
 
 
699
        if (((fail_count < IWL_RATE_MIN_FAILURE_TH) &&
 
700
             (window->success_counter < IWL_RATE_MIN_SUCCESS_TH))) {
 
701
                spin_unlock_irqrestore(&rs_sta->lock, flags);
 
702
 
 
703
                IWL_DEBUG_RATE(priv, "Invalid average_tpt on rate %d: "
 
704
                               "counter: %d, success_counter: %d, "
 
705
                               "expected_tpt is %sNULL\n",
 
706
                               index,
 
707
                               window->counter,
 
708
                               window->success_counter,
 
709
                               rs_sta->expected_tpt ? "not " : "");
 
710
 
 
711
           /* Can't calculate this yet; not enough history */
 
712
                window->average_tpt = IWL_INVALID_VALUE;
 
713
                goto out;
 
714
 
 
715
        }
 
716
 
 
717
        current_tpt = window->average_tpt;
 
718
 
 
719
        high_low = iwl3945_get_adjacent_rate(rs_sta, index, rate_mask,
 
720
                                             sband->band);
 
721
        low = high_low & 0xff;
 
722
        high = (high_low >> 8) & 0xff;
 
723
 
 
724
        /* If user set max rate, dont allow higher than user constrain */
 
725
        if ((max_rate_idx != -1) && (max_rate_idx < high))
 
726
                high = IWL_RATE_INVALID;
 
727
 
 
728
        /* Collect Measured throughputs of adjacent rates */
 
729
        if (low != IWL_RATE_INVALID)
 
730
                low_tpt = rs_sta->win[low].average_tpt;
 
731
 
 
732
        if (high != IWL_RATE_INVALID)
 
733
                high_tpt = rs_sta->win[high].average_tpt;
 
734
 
 
735
        spin_unlock_irqrestore(&rs_sta->lock, flags);
 
736
 
 
737
        scale_action = 0;
 
738
 
 
739
        /* Low success ratio , need to drop the rate */
 
740
        if ((window->success_ratio < IWL_RATE_DECREASE_TH) || !current_tpt) {
 
741
                IWL_DEBUG_RATE(priv, "decrease rate because of low success_ratio\n");
 
742
                scale_action = -1;
 
743
        /* No throughput measured yet for adjacent rates,
 
744
         * try increase */
 
745
        } else if ((low_tpt == IWL_INVALID_VALUE) &&
 
746
                   (high_tpt == IWL_INVALID_VALUE)) {
 
747
 
 
748
                if (high != IWL_RATE_INVALID && window->success_ratio >= IWL_RATE_INCREASE_TH)
 
749
                        scale_action = 1;
 
750
                else if (low != IWL_RATE_INVALID)
 
751
                        scale_action = 0;
 
752
 
 
753
        /* Both adjacent throughputs are measured, but neither one has
 
754
         * better throughput; we're using the best rate, don't change
 
755
         * it! */
 
756
        } else if ((low_tpt != IWL_INVALID_VALUE) &&
 
757
                 (high_tpt != IWL_INVALID_VALUE) &&
 
758
                 (low_tpt < current_tpt) && (high_tpt < current_tpt)) {
 
759
 
 
760
                IWL_DEBUG_RATE(priv, "No action -- low [%d] & high [%d] < "
 
761
                               "current_tpt [%d]\n",
 
762
                               low_tpt, high_tpt, current_tpt);
 
763
                scale_action = 0;
 
764
 
 
765
        /* At least one of the rates has better throughput */
 
766
        } else {
 
767
                if (high_tpt != IWL_INVALID_VALUE) {
 
768
 
 
769
                        /* High rate has better throughput, Increase
 
770
                         * rate */
 
771
                        if (high_tpt > current_tpt &&
 
772
                                window->success_ratio >= IWL_RATE_INCREASE_TH)
 
773
                                scale_action = 1;
 
774
                        else {
 
775
                                IWL_DEBUG_RATE(priv,
 
776
                                    "decrease rate because of high tpt\n");
 
777
                                scale_action = 0;
 
778
                        }
 
779
                } else if (low_tpt != IWL_INVALID_VALUE) {
 
780
                        if (low_tpt > current_tpt) {
 
781
                                IWL_DEBUG_RATE(priv,
 
782
                                    "decrease rate because of low tpt\n");
 
783
                                scale_action = -1;
 
784
                        } else if (window->success_ratio >= IWL_RATE_INCREASE_TH) {
 
785
                                /* Lower rate has better
 
786
                                 * throughput,decrease rate */
 
787
                                scale_action = 1;
 
788
                        }
 
789
                }
 
790
        }
 
791
 
 
792
        /* Sanity check; asked for decrease, but success rate or throughput
 
793
         * has been good at old rate.  Don't change it. */
 
794
        if ((scale_action == -1) && (low != IWL_RATE_INVALID) &&
 
795
                    ((window->success_ratio > IWL_RATE_HIGH_TH) ||
 
796
                     (current_tpt > (100 * rs_sta->expected_tpt[low]))))
 
797
                scale_action = 0;
 
798
 
 
799
        switch (scale_action) {
 
800
        case -1:
 
801
 
 
802
                /* Decrese rate */
 
803
                if (low != IWL_RATE_INVALID)
 
804
                        index = low;
 
805
                break;
 
806
 
 
807
        case 1:
 
808
                /* Increase rate */
 
809
                if (high != IWL_RATE_INVALID)
 
810
                        index = high;
 
811
 
 
812
                break;
 
813
 
 
814
        case 0:
 
815
        default:
 
816
                /* No change */
 
817
                break;
 
818
        }
 
819
 
 
820
        IWL_DEBUG_RATE(priv, "Selected %d (action %d) - low %d high %d\n",
 
821
                       index, scale_action, low, high);
 
822
 
 
823
 out:
 
824
 
 
825
        rs_sta->last_txrate_idx = index;
 
826
        if (sband->band == IEEE80211_BAND_5GHZ)
 
827
                info->control.rates[0].idx = rs_sta->last_txrate_idx -
 
828
                                IWL_FIRST_OFDM_RATE;
 
829
        else
 
830
                info->control.rates[0].idx = rs_sta->last_txrate_idx;
 
831
 
 
832
        IWL_DEBUG_RATE(priv, "leave: %d\n", index);
 
833
}
 
834
 
 
835
#ifdef CONFIG_MAC80211_DEBUGFS
 
836
static int iwl3945_open_file_generic(struct inode *inode, struct file *file)
 
837
{
 
838
        file->private_data = inode->i_private;
 
839
        return 0;
 
840
}
 
841
 
 
842
static ssize_t iwl3945_sta_dbgfs_stats_table_read(struct file *file,
 
843
                                                  char __user *user_buf,
 
844
                                                  size_t count, loff_t *ppos)
 
845
{
 
846
        char *buff;
 
847
        int desc = 0;
 
848
        int j;
 
849
        ssize_t ret;
 
850
        struct iwl3945_rs_sta *lq_sta = file->private_data;
 
851
 
 
852
        buff = kmalloc(1024, GFP_KERNEL);
 
853
        if (!buff)
 
854
                return -ENOMEM;
 
855
 
 
856
        desc += sprintf(buff + desc, "tx packets=%d last rate index=%d\n"
 
857
                        "rate=0x%X flush time %d\n",
 
858
                        lq_sta->tx_packets,
 
859
                        lq_sta->last_txrate_idx,
 
860
                        lq_sta->start_rate, jiffies_to_msecs(lq_sta->flush_time));
 
861
        for (j = 0; j < IWL_RATE_COUNT_3945; j++) {
 
862
                desc += sprintf(buff+desc,
 
863
                                "counter=%d success=%d %%=%d\n",
 
864
                                lq_sta->win[j].counter,
 
865
                                lq_sta->win[j].success_counter,
 
866
                                lq_sta->win[j].success_ratio);
 
867
        }
 
868
        ret = simple_read_from_buffer(user_buf, count, ppos, buff, desc);
 
869
        kfree(buff);
 
870
        return ret;
 
871
}
 
872
 
 
873
static const struct file_operations rs_sta_dbgfs_stats_table_ops = {
 
874
        .read = iwl3945_sta_dbgfs_stats_table_read,
 
875
        .open = iwl3945_open_file_generic,
 
876
        .llseek = default_llseek,
 
877
};
 
878
 
 
879
static void iwl3945_add_debugfs(void *priv, void *priv_sta,
 
880
                                struct dentry *dir)
 
881
{
 
882
        struct iwl3945_rs_sta *lq_sta = priv_sta;
 
883
 
 
884
        lq_sta->rs_sta_dbgfs_stats_table_file =
 
885
                debugfs_create_file("rate_stats_table", 0600, dir,
 
886
                lq_sta, &rs_sta_dbgfs_stats_table_ops);
 
887
 
 
888
}
 
889
 
 
890
static void iwl3945_remove_debugfs(void *priv, void *priv_sta)
 
891
{
 
892
        struct iwl3945_rs_sta *lq_sta = priv_sta;
 
893
        debugfs_remove(lq_sta->rs_sta_dbgfs_stats_table_file);
 
894
}
 
895
#endif
 
896
 
 
897
/*
 
898
 * Initialization of rate scaling information is done by driver after
 
899
 * the station is added. Since mac80211 calls this function before a
 
900
 * station is added we ignore it.
 
901
 */
 
902
static void iwl3945_rs_rate_init_stub(void *priv_r,
 
903
                                struct ieee80211_supported_band *sband,
 
904
                              struct ieee80211_sta *sta, void *priv_sta)
 
905
{
 
906
}
 
907
 
 
908
static struct rate_control_ops rs_ops = {
 
909
        .module = NULL,
 
910
        .name = RS_NAME,
 
911
        .tx_status = iwl3945_rs_tx_status,
 
912
        .get_rate = iwl3945_rs_get_rate,
 
913
        .rate_init = iwl3945_rs_rate_init_stub,
 
914
        .alloc = iwl3945_rs_alloc,
 
915
        .free = iwl3945_rs_free,
 
916
        .alloc_sta = iwl3945_rs_alloc_sta,
 
917
        .free_sta = iwl3945_rs_free_sta,
 
918
#ifdef CONFIG_MAC80211_DEBUGFS
 
919
        .add_sta_debugfs = iwl3945_add_debugfs,
 
920
        .remove_sta_debugfs = iwl3945_remove_debugfs,
 
921
#endif
 
922
 
 
923
};
 
924
void iwl3945_rate_scale_init(struct ieee80211_hw *hw, s32 sta_id)
 
925
{
 
926
        struct iwl_priv *priv = hw->priv;
 
927
        s32 rssi = 0;
 
928
        unsigned long flags;
 
929
        struct iwl3945_rs_sta *rs_sta;
 
930
        struct ieee80211_sta *sta;
 
931
        struct iwl3945_sta_priv *psta;
 
932
 
 
933
        IWL_DEBUG_RATE(priv, "enter\n");
 
934
 
 
935
        rcu_read_lock();
 
936
 
 
937
        sta = ieee80211_find_sta(priv->contexts[IWL_RXON_CTX_BSS].vif,
 
938
                                 priv->stations[sta_id].sta.sta.addr);
 
939
        if (!sta) {
 
940
                IWL_DEBUG_RATE(priv, "Unable to find station to initialize rate scaling.\n");
 
941
                rcu_read_unlock();
 
942
                return;
 
943
        }
 
944
 
 
945
        psta = (void *) sta->drv_priv;
 
946
        rs_sta = &psta->rs_sta;
 
947
 
 
948
        spin_lock_irqsave(&rs_sta->lock, flags);
 
949
 
 
950
        rs_sta->tgg = 0;
 
951
        switch (priv->band) {
 
952
        case IEEE80211_BAND_2GHZ:
 
953
                /* TODO: this always does G, not a regression */
 
954
                if (priv->contexts[IWL_RXON_CTX_BSS].active.flags &
 
955
                                                RXON_FLG_TGG_PROTECT_MSK) {
 
956
                        rs_sta->tgg = 1;
 
957
                        rs_sta->expected_tpt = iwl3945_expected_tpt_g_prot;
 
958
                } else
 
959
                        rs_sta->expected_tpt = iwl3945_expected_tpt_g;
 
960
                break;
 
961
 
 
962
        case IEEE80211_BAND_5GHZ:
 
963
                rs_sta->expected_tpt = iwl3945_expected_tpt_a;
 
964
                break;
 
965
        case IEEE80211_NUM_BANDS:
 
966
                BUG();
 
967
                break;
 
968
        }
 
969
 
 
970
        spin_unlock_irqrestore(&rs_sta->lock, flags);
 
971
 
 
972
        rssi = priv->_3945.last_rx_rssi;
 
973
        if (rssi == 0)
 
974
                rssi = IWL_MIN_RSSI_VAL;
 
975
 
 
976
        IWL_DEBUG_RATE(priv, "Network RSSI: %d\n", rssi);
 
977
 
 
978
        rs_sta->start_rate = iwl3945_get_rate_index_by_rssi(rssi, priv->band);
 
979
 
 
980
        IWL_DEBUG_RATE(priv, "leave: rssi %d assign rate index: "
 
981
                       "%d (plcp 0x%x)\n", rssi, rs_sta->start_rate,
 
982
                       iwl3945_rates[rs_sta->start_rate].plcp);
 
983
        rcu_read_unlock();
 
984
}
 
985
 
 
986
int iwl3945_rate_control_register(void)
 
987
{
 
988
        return ieee80211_rate_control_register(&rs_ops);
 
989
}
 
990
 
 
991
void iwl3945_rate_control_unregister(void)
 
992
{
 
993
        ieee80211_rate_control_unregister(&rs_ops);
 
994
}