1 /******************************************************************************
3 * Copyright(c) 2005 - 2009 Intel Corporation. All rights reserved.
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.
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
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
18 * The full GNU General Public License is included in this distribution in the
19 * file called LICENSE.
21 * Contact Information:
22 * Intel Linux Wireless <ilw@linux.intel.com>
23 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
25 *****************************************************************************/
27 #include <linux/kernel.h>
28 #include <linux/init.h>
29 #include <linux/skbuff.h>
30 #include <linux/wireless.h>
31 #include <net/mac80211.h>
33 #include <linux/netdevice.h>
34 #include <linux/etherdevice.h>
35 #include <linux/delay.h>
37 #include <linux/workqueue.h>
39 #include "iwl-commands.h"
43 #define RS_NAME "iwl-3945-rs"
45 static s32 iwl3945_expected_tpt_g
[IWL_RATE_COUNT_3945
] = {
46 7, 13, 35, 58, 0, 0, 76, 104, 130, 168, 191, 202
49 static s32 iwl3945_expected_tpt_g_prot
[IWL_RATE_COUNT_3945
] = {
50 7, 13, 35, 58, 0, 0, 0, 80, 93, 113, 123, 125
53 static s32 iwl3945_expected_tpt_a
[IWL_RATE_COUNT_3945
] = {
54 0, 0, 0, 0, 40, 57, 72, 98, 121, 154, 177, 186
57 static s32 iwl3945_expected_tpt_b
[IWL_RATE_COUNT_3945
] = {
58 7, 13, 35, 58, 0, 0, 0, 0, 0, 0, 0, 0
61 struct iwl3945_tpt_entry
{
66 static struct iwl3945_tpt_entry iwl3945_tpt_table_a
[] = {
67 {-60, IWL_RATE_54M_INDEX
},
68 {-64, IWL_RATE_48M_INDEX
},
69 {-72, IWL_RATE_36M_INDEX
},
70 {-80, IWL_RATE_24M_INDEX
},
71 {-84, IWL_RATE_18M_INDEX
},
72 {-85, IWL_RATE_12M_INDEX
},
73 {-87, IWL_RATE_9M_INDEX
},
74 {-89, IWL_RATE_6M_INDEX
}
77 static struct iwl3945_tpt_entry iwl3945_tpt_table_g
[] = {
78 {-60, IWL_RATE_54M_INDEX
},
79 {-64, IWL_RATE_48M_INDEX
},
80 {-68, IWL_RATE_36M_INDEX
},
81 {-80, IWL_RATE_24M_INDEX
},
82 {-84, IWL_RATE_18M_INDEX
},
83 {-85, IWL_RATE_12M_INDEX
},
84 {-86, IWL_RATE_11M_INDEX
},
85 {-88, IWL_RATE_5M_INDEX
},
86 {-90, IWL_RATE_2M_INDEX
},
87 {-92, IWL_RATE_1M_INDEX
}
90 #define IWL_RATE_MAX_WINDOW 62
91 #define IWL_RATE_FLUSH (3*HZ)
92 #define IWL_RATE_WIN_FLUSH (HZ/2)
93 #define IWL39_RATE_HIGH_TH 11520
94 #define IWL_SUCCESS_UP_TH 8960
95 #define IWL_SUCCESS_DOWN_TH 10880
96 #define IWL_RATE_MIN_FAILURE_TH 6
97 #define IWL_RATE_MIN_SUCCESS_TH 8
98 #define IWL_RATE_DECREASE_TH 1920
99 #define IWL_RATE_RETRY_TH 15
101 static u8
iwl3945_get_rate_index_by_rssi(s32 rssi
, enum ieee80211_band band
)
105 struct iwl3945_tpt_entry
*tpt_table
= NULL
;
107 if ((rssi
< IWL_MIN_RSSI_VAL
) || (rssi
> IWL_MAX_RSSI_VAL
))
108 rssi
= IWL_MIN_RSSI_VAL
;
111 case IEEE80211_BAND_2GHZ
:
112 tpt_table
= iwl3945_tpt_table_g
;
113 table_size
= ARRAY_SIZE(iwl3945_tpt_table_g
);
116 case IEEE80211_BAND_5GHZ
:
117 tpt_table
= iwl3945_tpt_table_a
;
118 table_size
= ARRAY_SIZE(iwl3945_tpt_table_a
);
126 while ((index
< table_size
) && (rssi
< tpt_table
[index
].min_rssi
))
129 index
= min(index
, (table_size
- 1));
131 return tpt_table
[index
].index
;
134 static void iwl3945_clear_window(struct iwl3945_rate_scale_data
*window
)
137 window
->success_counter
= 0;
138 window
->success_ratio
= -1;
140 window
->average_tpt
= IWL_INVALID_VALUE
;
145 * iwl3945_rate_scale_flush_windows - flush out the rate scale windows
147 * Returns the number of windows that have gathered data but were
148 * not flushed. If there were any that were not flushed, then
149 * reschedule the rate flushing routine.
151 static int iwl3945_rate_scale_flush_windows(struct iwl3945_rs_sta
*rs_sta
)
156 struct iwl_priv
*priv __maybe_unused
= rs_sta
->priv
;
159 * For each rate, if we have collected data on that rate
160 * and it has been more than IWL_RATE_WIN_FLUSH
161 * since we flushed, clear out the gathered statistics
163 for (i
= 0; i
< IWL_RATE_COUNT_3945
; i
++) {
164 if (!rs_sta
->win
[i
].counter
)
167 spin_lock_irqsave(&rs_sta
->lock
, flags
);
168 if (time_after(jiffies
, rs_sta
->win
[i
].stamp
+
169 IWL_RATE_WIN_FLUSH
)) {
170 IWL_DEBUG_RATE(priv
, "flushing %d samples of rate "
172 rs_sta
->win
[i
].counter
, i
);
173 iwl3945_clear_window(&rs_sta
->win
[i
]);
176 spin_unlock_irqrestore(&rs_sta
->lock
, flags
);
182 #define IWL_RATE_FLUSH_MAX 5000 /* msec */
183 #define IWL_RATE_FLUSH_MIN 50 /* msec */
184 #define IWL_AVERAGE_PACKETS 1500
186 static void iwl3945_bg_rate_scale_flush(unsigned long data
)
188 struct iwl3945_rs_sta
*rs_sta
= (void *)data
;
189 struct iwl_priv
*priv __maybe_unused
= rs_sta
->priv
;
192 u32 packet_count
, duration
, pps
;
194 IWL_DEBUG_RATE(priv
, "enter\n");
196 unflushed
= iwl3945_rate_scale_flush_windows(rs_sta
);
198 spin_lock_irqsave(&rs_sta
->lock
, flags
);
200 /* Number of packets Rx'd since last time this timer ran */
201 packet_count
= (rs_sta
->tx_packets
- rs_sta
->last_tx_packets
) + 1;
203 rs_sta
->last_tx_packets
= rs_sta
->tx_packets
+ 1;
207 jiffies_to_msecs(jiffies
- rs_sta
->last_partial_flush
);
209 IWL_DEBUG_RATE(priv
, "Tx'd %d packets in %dms\n",
210 packet_count
, duration
);
212 /* Determine packets per second */
214 pps
= (packet_count
* 1000) / duration
;
219 duration
= (IWL_AVERAGE_PACKETS
* 1000) / pps
;
220 if (duration
< IWL_RATE_FLUSH_MIN
)
221 duration
= IWL_RATE_FLUSH_MIN
;
222 else if (duration
> IWL_RATE_FLUSH_MAX
)
223 duration
= IWL_RATE_FLUSH_MAX
;
225 duration
= IWL_RATE_FLUSH_MAX
;
227 rs_sta
->flush_time
= msecs_to_jiffies(duration
);
229 IWL_DEBUG_RATE(priv
, "new flush period: %d msec ave %d\n",
230 duration
, packet_count
);
232 mod_timer(&rs_sta
->rate_scale_flush
, jiffies
+
235 rs_sta
->last_partial_flush
= jiffies
;
237 rs_sta
->flush_time
= IWL_RATE_FLUSH
;
238 rs_sta
->flush_pending
= 0;
240 /* If there weren't any unflushed entries, we don't schedule the timer
243 rs_sta
->last_flush
= jiffies
;
245 spin_unlock_irqrestore(&rs_sta
->lock
, flags
);
247 IWL_DEBUG_RATE(priv
, "leave\n");
251 * iwl3945_collect_tx_data - Update the success/failure sliding window
253 * We keep a sliding window of the last 64 packets transmitted
254 * at this rate. window->data contains the bitmask of successful
257 static void iwl3945_collect_tx_data(struct iwl3945_rs_sta
*rs_sta
,
258 struct iwl3945_rate_scale_data
*window
,
259 int success
, int retries
, int index
)
263 struct iwl_priv
*priv __maybe_unused
= rs_sta
->priv
;
266 IWL_DEBUG_RATE(priv
, "leave: retries == 0 -- should be at least 1\n");
270 spin_lock_irqsave(&rs_sta
->lock
, flags
);
273 * Keep track of only the latest 62 tx frame attempts in this rate's
274 * history window; anything older isn't really relevant any more.
275 * If we have filled up the sliding window, drop the oldest attempt;
276 * if the oldest attempt (highest bit in bitmap) shows "success",
277 * subtract "1" from the success counter (this is the main reason
278 * we keep these bitmaps!).
280 while (retries
> 0) {
281 if (window
->counter
>= IWL_RATE_MAX_WINDOW
) {
283 /* remove earliest */
284 window
->counter
= IWL_RATE_MAX_WINDOW
- 1;
286 if (window
->data
& (1ULL << (IWL_RATE_MAX_WINDOW
- 1))) {
287 window
->data
&= ~(1ULL << (IWL_RATE_MAX_WINDOW
- 1));
288 window
->success_counter
--;
292 /* Increment frames-attempted counter */
295 /* Shift bitmap by one frame (throw away oldest history),
296 * OR in "1", and increment "success" if this
297 * frame was successful. */
300 window
->success_counter
++;
308 /* Calculate current success ratio, avoid divide-by-0! */
309 if (window
->counter
> 0)
310 window
->success_ratio
= 128 * (100 * window
->success_counter
)
313 window
->success_ratio
= IWL_INVALID_VALUE
;
315 fail_count
= window
->counter
- window
->success_counter
;
317 /* Calculate average throughput, if we have enough history. */
318 if ((fail_count
>= IWL_RATE_MIN_FAILURE_TH
) ||
319 (window
->success_counter
>= IWL_RATE_MIN_SUCCESS_TH
))
320 window
->average_tpt
= ((window
->success_ratio
*
321 rs_sta
->expected_tpt
[index
] + 64) / 128);
323 window
->average_tpt
= IWL_INVALID_VALUE
;
325 /* Tag this window as having been updated */
326 window
->stamp
= jiffies
;
328 spin_unlock_irqrestore(&rs_sta
->lock
, flags
);
332 static void rs_rate_init(void *priv_r
, struct ieee80211_supported_band
*sband
,
333 struct ieee80211_sta
*sta
, void *priv_sta
)
335 struct iwl3945_rs_sta
*rs_sta
= priv_sta
;
336 struct iwl_priv
*priv
= (struct iwl_priv
*)priv_r
;
339 IWL_DEBUG_RATE(priv
, "enter\n");
341 spin_lock_init(&rs_sta
->lock
);
345 rs_sta
->start_rate
= IWL_RATE_INVALID
;
347 /* default to just 802.11b */
348 rs_sta
->expected_tpt
= iwl3945_expected_tpt_b
;
350 rs_sta
->last_partial_flush
= jiffies
;
351 rs_sta
->last_flush
= jiffies
;
352 rs_sta
->flush_time
= IWL_RATE_FLUSH
;
353 rs_sta
->last_tx_packets
= 0;
354 rs_sta
->ibss_sta_added
= 0;
356 init_timer(&rs_sta
->rate_scale_flush
);
357 rs_sta
->rate_scale_flush
.data
= (unsigned long)rs_sta
;
358 rs_sta
->rate_scale_flush
.function
= iwl3945_bg_rate_scale_flush
;
360 for (i
= 0; i
< IWL_RATE_COUNT_3945
; i
++)
361 iwl3945_clear_window(&rs_sta
->win
[i
]);
363 /* TODO: what is a good starting rate for STA? About middle? Maybe not
364 * the lowest or the highest rate.. Could consider using RSSI from
365 * previous packets? Need to have IEEE 802.1X auth succeed immediately
368 for (i
= sband
->n_bitrates
- 1; i
>= 0; i
--) {
369 if (sta
->supp_rates
[sband
->band
] & (1 << i
)) {
370 rs_sta
->last_txrate_idx
= i
;
375 priv
->sta_supp_rates
= sta
->supp_rates
[sband
->band
];
376 /* For 5 GHz band it start at IWL_FIRST_OFDM_RATE */
377 if (sband
->band
== IEEE80211_BAND_5GHZ
) {
378 rs_sta
->last_txrate_idx
+= IWL_FIRST_OFDM_RATE
;
379 priv
->sta_supp_rates
= priv
->sta_supp_rates
<<
384 IWL_DEBUG_RATE(priv
, "leave\n");
387 static void *rs_alloc(struct ieee80211_hw
*hw
, struct dentry
*debugfsdir
)
392 /* rate scale requires free function to be implemented */
393 static void rs_free(void *priv
)
398 static void *rs_alloc_sta(void *iwl_priv
, struct ieee80211_sta
*sta
, gfp_t gfp
)
400 struct iwl3945_rs_sta
*rs_sta
;
401 struct iwl3945_sta_priv
*psta
= (void *) sta
->drv_priv
;
402 struct iwl_priv
*priv __maybe_unused
= iwl_priv
;
404 IWL_DEBUG_RATE(priv
, "enter\n");
406 rs_sta
= &psta
->rs_sta
;
408 IWL_DEBUG_RATE(priv
, "leave\n");
413 static void rs_free_sta(void *iwl_priv
, struct ieee80211_sta
*sta
,
416 struct iwl3945_sta_priv
*psta
= (void *) sta
->drv_priv
;
417 struct iwl3945_rs_sta
*rs_sta
= &psta
->rs_sta
;
418 struct iwl_priv
*priv __maybe_unused
= rs_sta
->priv
;
420 IWL_DEBUG_RATE(priv
, "enter\n");
421 del_timer_sync(&rs_sta
->rate_scale_flush
);
422 IWL_DEBUG_RATE(priv
, "leave\n");
427 * rs_tx_status - Update rate control values based on Tx results
429 * NOTE: Uses iwl_priv->retry_rate for the # of retries attempted by
430 * the hardware for each rate.
432 static void rs_tx_status(void *priv_rate
, struct ieee80211_supported_band
*sband
,
433 struct ieee80211_sta
*sta
, void *priv_sta
,
436 s8 retries
= 0, current_count
;
437 int scale_rate_index
, first_index
, last_index
;
439 struct iwl_priv
*priv
= (struct iwl_priv
*)priv_rate
;
440 struct iwl3945_rs_sta
*rs_sta
= priv_sta
;
441 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
443 IWL_DEBUG_RATE(priv
, "enter\n");
445 retries
= info
->status
.rates
[0].count
;
446 /* Sanity Check for retries */
447 if (retries
> IWL_RATE_RETRY_TH
)
448 retries
= IWL_RATE_RETRY_TH
;
450 first_index
= sband
->bitrates
[info
->status
.rates
[0].idx
].hw_value
;
451 if ((first_index
< 0) || (first_index
>= IWL_RATE_COUNT_3945
)) {
452 IWL_DEBUG_RATE(priv
, "leave: Rate out of bounds: %d\n", first_index
);
457 IWL_DEBUG_RATE(priv
, "leave: No STA priv data to update!\n");
461 rs_sta
->tx_packets
++;
463 scale_rate_index
= first_index
;
464 last_index
= first_index
;
467 * Update the window for each rate. We determine which rates
468 * were Tx'd based on the total number of retries vs. the number
469 * of retries configured for each rate -- currently set to the
470 * priv value 'retry_rate' vs. rate specific
472 * On exit from this while loop last_index indicates the rate
473 * at which the frame was finally transmitted (or failed if no
476 while (retries
> 1) {
477 if ((retries
- 1) < priv
->retry_rate
) {
478 current_count
= (retries
- 1);
479 last_index
= scale_rate_index
;
481 current_count
= priv
->retry_rate
;
482 last_index
= iwl3945_rs_next_rate(priv
,
486 /* Update this rate accounting for as many retries
487 * as was used for it (per current_count) */
488 iwl3945_collect_tx_data(rs_sta
,
489 &rs_sta
->win
[scale_rate_index
],
490 0, current_count
, scale_rate_index
);
491 IWL_DEBUG_RATE(priv
, "Update rate %d for %d retries.\n",
492 scale_rate_index
, current_count
);
494 retries
-= current_count
;
496 scale_rate_index
= last_index
;
500 /* Update the last index window with success/failure based on ACK */
501 IWL_DEBUG_RATE(priv
, "Update rate %d with %s.\n",
503 (info
->flags
& IEEE80211_TX_STAT_ACK
) ?
504 "success" : "failure");
505 iwl3945_collect_tx_data(rs_sta
,
506 &rs_sta
->win
[last_index
],
507 info
->flags
& IEEE80211_TX_STAT_ACK
, 1, last_index
);
509 /* We updated the rate scale window -- if its been more than
510 * flush_time since the last run, schedule the flush
512 spin_lock_irqsave(&rs_sta
->lock
, flags
);
514 if (!rs_sta
->flush_pending
&&
515 time_after(jiffies
, rs_sta
->last_flush
+
516 rs_sta
->flush_time
)) {
518 rs_sta
->last_partial_flush
= jiffies
;
519 rs_sta
->flush_pending
= 1;
520 mod_timer(&rs_sta
->rate_scale_flush
,
521 jiffies
+ rs_sta
->flush_time
);
524 spin_unlock_irqrestore(&rs_sta
->lock
, flags
);
526 IWL_DEBUG_RATE(priv
, "leave\n");
531 static u16
iwl3945_get_adjacent_rate(struct iwl3945_rs_sta
*rs_sta
,
532 u8 index
, u16 rate_mask
, enum ieee80211_band band
)
534 u8 high
= IWL_RATE_INVALID
;
535 u8 low
= IWL_RATE_INVALID
;
536 struct iwl_priv
*priv __maybe_unused
= rs_sta
->priv
;
538 /* 802.11A walks to the next literal adjacent rate in
540 if (unlikely(band
== IEEE80211_BAND_5GHZ
)) {
544 /* Find the previous rate that is in the rate mask */
546 for (mask
= (1 << i
); i
>= 0; i
--, mask
>>= 1) {
547 if (rate_mask
& mask
) {
553 /* Find the next rate that is in the rate mask */
555 for (mask
= (1 << i
); i
< IWL_RATE_COUNT_3945
;
557 if (rate_mask
& mask
) {
563 return (high
<< 8) | low
;
567 while (low
!= IWL_RATE_INVALID
) {
569 low
= iwl3945_rates
[low
].prev_rs_tgg
;
571 low
= iwl3945_rates
[low
].prev_rs
;
572 if (low
== IWL_RATE_INVALID
)
574 if (rate_mask
& (1 << low
))
576 IWL_DEBUG_RATE(priv
, "Skipping masked lower rate: %d\n", low
);
580 while (high
!= IWL_RATE_INVALID
) {
582 high
= iwl3945_rates
[high
].next_rs_tgg
;
584 high
= iwl3945_rates
[high
].next_rs
;
585 if (high
== IWL_RATE_INVALID
)
587 if (rate_mask
& (1 << high
))
589 IWL_DEBUG_RATE(priv
, "Skipping masked higher rate: %d\n", high
);
592 return (high
<< 8) | low
;
596 * rs_get_rate - find the rate for the requested packet
598 * Returns the ieee80211_rate structure allocated by the driver.
600 * The rate control algorithm has no internal mapping between hw_mode's
601 * rate ordering and the rate ordering used by the rate control algorithm.
603 * The rate control algorithm uses a single table of rates that goes across
604 * the entire A/B/G spectrum vs. being limited to just one particular
607 * As such, we can't convert the index obtained below into the hw_mode's
608 * rate table and must reference the driver allocated rate table
611 static void rs_get_rate(void *priv_r
, struct ieee80211_sta
*sta
,
612 void *priv_sta
, struct ieee80211_tx_rate_control
*txrc
)
614 struct ieee80211_supported_band
*sband
= txrc
->sband
;
615 struct sk_buff
*skb
= txrc
->skb
;
616 u8 low
= IWL_RATE_INVALID
;
617 u8 high
= IWL_RATE_INVALID
;
620 struct iwl3945_rs_sta
*rs_sta
= priv_sta
;
621 struct iwl3945_rate_scale_data
*window
= NULL
;
622 int current_tpt
= IWL_INVALID_VALUE
;
623 int low_tpt
= IWL_INVALID_VALUE
;
624 int high_tpt
= IWL_INVALID_VALUE
;
628 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)skb
->data
;
629 u16 rate_mask
= sta
? sta
->supp_rates
[sband
->band
] : 0;
630 s8 max_rate_idx
= -1;
631 struct iwl_priv
*priv
= (struct iwl_priv
*)priv_r
;
632 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
634 IWL_DEBUG_RATE(priv
, "enter\n");
636 if (rate_control_send_low(sta
, priv_sta
, txrc
))
639 rate_mask
= sta
->supp_rates
[sband
->band
];
641 /* get user max rate if set */
642 max_rate_idx
= txrc
->max_rate_idx
;
643 if ((sband
->band
== IEEE80211_BAND_5GHZ
) && (max_rate_idx
!= -1))
644 max_rate_idx
+= IWL_FIRST_OFDM_RATE
;
645 if ((max_rate_idx
< 0) || (max_rate_idx
>= IWL_RATE_COUNT
))
648 index
= min(rs_sta
->last_txrate_idx
& 0xffff, IWL_RATE_COUNT_3945
- 1);
650 if (sband
->band
== IEEE80211_BAND_5GHZ
)
651 rate_mask
= rate_mask
<< IWL_FIRST_OFDM_RATE
;
653 if ((priv
->iw_mode
== NL80211_IFTYPE_ADHOC
) &&
654 !rs_sta
->ibss_sta_added
) {
655 u8 sta_id
= iwl_find_station(priv
, hdr
->addr1
);
657 if (sta_id
== IWL_INVALID_STATION
) {
658 IWL_DEBUG_RATE(priv
, "LQ: ADD station %pM\n",
660 sta_id
= iwl_add_station(priv
, hdr
->addr1
, false,
663 if (sta_id
!= IWL_INVALID_STATION
)
664 rs_sta
->ibss_sta_added
= 1;
667 spin_lock_irqsave(&rs_sta
->lock
, flags
);
669 /* for recent assoc, choose best rate regarding
672 if (rs_sta
->start_rate
!= IWL_RATE_INVALID
) {
673 if (rs_sta
->start_rate
< index
&&
674 (rate_mask
& (1 << rs_sta
->start_rate
)))
675 index
= rs_sta
->start_rate
;
676 rs_sta
->start_rate
= IWL_RATE_INVALID
;
679 /* force user max rate if set by user */
680 if ((max_rate_idx
!= -1) && (max_rate_idx
< index
)) {
681 if (rate_mask
& (1 << max_rate_idx
))
682 index
= max_rate_idx
;
685 window
= &(rs_sta
->win
[index
]);
687 fail_count
= window
->counter
- window
->success_counter
;
689 if (((fail_count
< IWL_RATE_MIN_FAILURE_TH
) &&
690 (window
->success_counter
< IWL_RATE_MIN_SUCCESS_TH
))) {
691 spin_unlock_irqrestore(&rs_sta
->lock
, flags
);
693 IWL_DEBUG_RATE(priv
, "Invalid average_tpt on rate %d: "
694 "counter: %d, success_counter: %d, "
695 "expected_tpt is %sNULL\n",
698 window
->success_counter
,
699 rs_sta
->expected_tpt
? "not " : "");
701 /* Can't calculate this yet; not enough history */
702 window
->average_tpt
= IWL_INVALID_VALUE
;
707 current_tpt
= window
->average_tpt
;
709 high_low
= iwl3945_get_adjacent_rate(rs_sta
, index
, rate_mask
,
711 low
= high_low
& 0xff;
712 high
= (high_low
>> 8) & 0xff;
714 /* If user set max rate, dont allow higher than user constrain */
715 if ((max_rate_idx
!= -1) && (max_rate_idx
< high
))
716 high
= IWL_RATE_INVALID
;
718 /* Collect Measured throughputs of adjacent rates */
719 if (low
!= IWL_RATE_INVALID
)
720 low_tpt
= rs_sta
->win
[low
].average_tpt
;
722 if (high
!= IWL_RATE_INVALID
)
723 high_tpt
= rs_sta
->win
[high
].average_tpt
;
725 spin_unlock_irqrestore(&rs_sta
->lock
, flags
);
729 /* Low success ratio , need to drop the rate */
730 if ((window
->success_ratio
< IWL_RATE_DECREASE_TH
) || !current_tpt
) {
731 IWL_DEBUG_RATE(priv
, "decrease rate because of low success_ratio\n");
733 /* No throughput measured yet for adjacent rates,
735 } else if ((low_tpt
== IWL_INVALID_VALUE
) &&
736 (high_tpt
== IWL_INVALID_VALUE
)) {
738 if (high
!= IWL_RATE_INVALID
&& window
->success_ratio
>= IWL_RATE_INCREASE_TH
)
740 else if (low
!= IWL_RATE_INVALID
)
743 /* Both adjacent throughputs are measured, but neither one has
744 * better throughput; we're using the best rate, don't change
746 } else if ((low_tpt
!= IWL_INVALID_VALUE
) &&
747 (high_tpt
!= IWL_INVALID_VALUE
) &&
748 (low_tpt
< current_tpt
) && (high_tpt
< current_tpt
)) {
750 IWL_DEBUG_RATE(priv
, "No action -- low [%d] & high [%d] < "
751 "current_tpt [%d]\n",
752 low_tpt
, high_tpt
, current_tpt
);
755 /* At least one of the rates has better throughput */
757 if (high_tpt
!= IWL_INVALID_VALUE
) {
759 /* High rate has better throughput, Increase
761 if (high_tpt
> current_tpt
&&
762 window
->success_ratio
>= IWL_RATE_INCREASE_TH
)
766 "decrease rate because of high tpt\n");
769 } else if (low_tpt
!= IWL_INVALID_VALUE
) {
770 if (low_tpt
> current_tpt
) {
772 "decrease rate because of low tpt\n");
774 } else if (window
->success_ratio
>= IWL_RATE_INCREASE_TH
) {
775 /* Lower rate has better
776 * throughput,decrease rate */
782 /* Sanity check; asked for decrease, but success rate or throughput
783 * has been good at old rate. Don't change it. */
784 if ((scale_action
== -1) && (low
!= IWL_RATE_INVALID
) &&
785 ((window
->success_ratio
> IWL_RATE_HIGH_TH
) ||
786 (current_tpt
> (100 * rs_sta
->expected_tpt
[low
]))))
789 switch (scale_action
) {
793 if (low
!= IWL_RATE_INVALID
)
799 if (high
!= IWL_RATE_INVALID
)
810 IWL_DEBUG_RATE(priv
, "Selected %d (action %d) - low %d high %d\n",
811 index
, scale_action
, low
, high
);
815 rs_sta
->last_txrate_idx
= index
;
816 if (sband
->band
== IEEE80211_BAND_5GHZ
)
817 info
->control
.rates
[0].idx
= rs_sta
->last_txrate_idx
-
820 info
->control
.rates
[0].idx
= rs_sta
->last_txrate_idx
;
822 IWL_DEBUG_RATE(priv
, "leave: %d\n", index
);
825 #ifdef CONFIG_MAC80211_DEBUGFS
826 static int iwl3945_open_file_generic(struct inode
*inode
, struct file
*file
)
828 file
->private_data
= inode
->i_private
;
832 static ssize_t
iwl3945_sta_dbgfs_stats_table_read(struct file
*file
,
833 char __user
*user_buf
,
834 size_t count
, loff_t
*ppos
)
840 struct iwl3945_rs_sta
*lq_sta
= file
->private_data
;
842 buff
= kmalloc(1024, GFP_KERNEL
);
846 desc
+= sprintf(buff
+ desc
, "tx packets=%d last rate index=%d\n"
847 "rate=0x%X flush time %d\n",
849 lq_sta
->last_txrate_idx
,
850 lq_sta
->start_rate
, jiffies_to_msecs(lq_sta
->flush_time
));
851 for (j
= 0; j
< IWL_RATE_COUNT_3945
; j
++) {
852 desc
+= sprintf(buff
+desc
,
853 "counter=%d success=%d %%=%d\n",
854 lq_sta
->win
[j
].counter
,
855 lq_sta
->win
[j
].success_counter
,
856 lq_sta
->win
[j
].success_ratio
);
858 ret
= simple_read_from_buffer(user_buf
, count
, ppos
, buff
, desc
);
863 static const struct file_operations rs_sta_dbgfs_stats_table_ops
= {
864 .read
= iwl3945_sta_dbgfs_stats_table_read
,
865 .open
= iwl3945_open_file_generic
,
868 static void iwl3945_add_debugfs(void *priv
, void *priv_sta
,
871 struct iwl3945_rs_sta
*lq_sta
= priv_sta
;
873 lq_sta
->rs_sta_dbgfs_stats_table_file
=
874 debugfs_create_file("rate_stats_table", 0600, dir
,
875 lq_sta
, &rs_sta_dbgfs_stats_table_ops
);
879 static void iwl3945_remove_debugfs(void *priv
, void *priv_sta
)
881 struct iwl3945_rs_sta
*lq_sta
= priv_sta
;
882 debugfs_remove(lq_sta
->rs_sta_dbgfs_stats_table_file
);
886 static struct rate_control_ops rs_ops
= {
889 .tx_status
= rs_tx_status
,
890 .get_rate
= rs_get_rate
,
891 .rate_init
= rs_rate_init
,
894 .alloc_sta
= rs_alloc_sta
,
895 .free_sta
= rs_free_sta
,
896 #ifdef CONFIG_MAC80211_DEBUGFS
897 .add_sta_debugfs
= iwl3945_add_debugfs
,
898 .remove_sta_debugfs
= iwl3945_remove_debugfs
,
903 void iwl3945_rate_scale_init(struct ieee80211_hw
*hw
, s32 sta_id
)
905 struct iwl_priv
*priv
= hw
->priv
;
908 struct iwl3945_rs_sta
*rs_sta
;
909 struct ieee80211_sta
*sta
;
910 struct iwl3945_sta_priv
*psta
;
912 IWL_DEBUG_RATE(priv
, "enter\n");
916 sta
= ieee80211_find_sta(priv
->vif
,
917 priv
->stations
[sta_id
].sta
.sta
.addr
);
923 psta
= (void *) sta
->drv_priv
;
924 rs_sta
= &psta
->rs_sta
;
926 spin_lock_irqsave(&rs_sta
->lock
, flags
);
929 switch (priv
->band
) {
930 case IEEE80211_BAND_2GHZ
:
931 /* TODO: this always does G, not a regression */
932 if (priv
->active_rxon
.flags
& RXON_FLG_TGG_PROTECT_MSK
) {
934 rs_sta
->expected_tpt
= iwl3945_expected_tpt_g_prot
;
936 rs_sta
->expected_tpt
= iwl3945_expected_tpt_g
;
939 case IEEE80211_BAND_5GHZ
:
940 rs_sta
->expected_tpt
= iwl3945_expected_tpt_a
;
942 case IEEE80211_NUM_BANDS
:
947 spin_unlock_irqrestore(&rs_sta
->lock
, flags
);
949 rssi
= priv
->last_rx_rssi
;
951 rssi
= IWL_MIN_RSSI_VAL
;
953 IWL_DEBUG_RATE(priv
, "Network RSSI: %d\n", rssi
);
955 rs_sta
->start_rate
= iwl3945_get_rate_index_by_rssi(rssi
, priv
->band
);
957 IWL_DEBUG_RATE(priv
, "leave: rssi %d assign rate index: "
958 "%d (plcp 0x%x)\n", rssi
, rs_sta
->start_rate
,
959 iwl3945_rates
[rs_sta
->start_rate
].plcp
);
963 int iwl3945_rate_control_register(void)
965 return ieee80211_rate_control_register(&rs_ops
);
968 void iwl3945_rate_control_unregister(void)
970 ieee80211_rate_control_unregister(&rs_ops
);