1 /******************************************************************************
3 * Copyright(c) 2005 - 2007 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 * James P. Ketrenos <ipw2100-admin@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>
32 #include <net/ieee80211.h>
34 #include <linux/netdevice.h>
35 #include <linux/etherdevice.h>
36 #include <linux/delay.h>
38 #include <linux/workqueue.h>
40 #include <net/mac80211.h>
41 #include <linux/wireless.h>
43 #include "../net/mac80211/ieee80211_rate.h"
47 #define RS_NAME "iwl-3945-rs"
49 struct iwl_rate_scale_data
{
58 struct iwl_rate_scale_priv
{
61 unsigned long last_partial_flush
;
62 unsigned long last_flush
;
70 struct timer_list rate_scale_flush
;
71 struct iwl_rate_scale_data win
[IWL_RATE_COUNT
];
74 static s32 iwl_expected_tpt_g
[IWL_RATE_COUNT
] = {
75 0, 0, 76, 104, 130, 168, 191, 202, 7, 13, 35, 58
78 static s32 iwl_expected_tpt_g_prot
[IWL_RATE_COUNT
] = {
79 0, 0, 0, 80, 93, 113, 123, 125, 7, 13, 35, 58
82 static s32 iwl_expected_tpt_a
[IWL_RATE_COUNT
] = {
83 40, 57, 72, 98, 121, 154, 177, 186, 0, 0, 0, 0
86 static s32 iwl_expected_tpt_b
[IWL_RATE_COUNT
] = {
87 0, 0, 0, 0, 0, 0, 0, 0, 7, 13, 35, 58
90 struct iwl_tpt_entry
{
95 static struct iwl_tpt_entry iwl_tpt_table_a
[] = {
96 {-60, IWL_RATE_54M_INDEX
},
97 {-64, IWL_RATE_48M_INDEX
},
98 {-72, IWL_RATE_36M_INDEX
},
99 {-80, IWL_RATE_24M_INDEX
},
100 {-84, IWL_RATE_18M_INDEX
},
101 {-85, IWL_RATE_12M_INDEX
},
102 {-87, IWL_RATE_9M_INDEX
},
103 {-89, IWL_RATE_6M_INDEX
}
106 static struct iwl_tpt_entry iwl_tpt_table_b
[] = {
107 {-86, IWL_RATE_11M_INDEX
},
108 {-88, IWL_RATE_5M_INDEX
},
109 {-90, IWL_RATE_2M_INDEX
},
110 {-92, IWL_RATE_1M_INDEX
}
114 static struct iwl_tpt_entry iwl_tpt_table_g
[] = {
115 {-60, IWL_RATE_54M_INDEX
},
116 {-64, IWL_RATE_48M_INDEX
},
117 {-68, IWL_RATE_36M_INDEX
},
118 {-80, IWL_RATE_24M_INDEX
},
119 {-84, IWL_RATE_18M_INDEX
},
120 {-85, IWL_RATE_12M_INDEX
},
121 {-86, IWL_RATE_11M_INDEX
},
122 {-88, IWL_RATE_5M_INDEX
},
123 {-90, IWL_RATE_2M_INDEX
},
124 {-92, IWL_RATE_1M_INDEX
}
127 #define IWL_RATE_MAX_WINDOW 62
128 #define IWL_RATE_FLUSH (3*HZ/10)
129 #define IWL_RATE_WIN_FLUSH (HZ/2)
130 #define IWL_RATE_HIGH_TH 11520
131 #define IWL_RATE_MIN_FAILURE_TH 8
132 #define IWL_RATE_MIN_SUCCESS_TH 8
133 #define IWL_RATE_DECREASE_TH 1920
135 static u8
iwl_get_rate_index_by_rssi(s32 rssi
, u8 mode
)
139 struct iwl_tpt_entry
*tpt_table
= NULL
;
141 if ((rssi
< IWL_MIN_RSSI_VAL
) || (rssi
> IWL_MAX_RSSI_VAL
))
142 rssi
= IWL_MIN_RSSI_VAL
;
145 case MODE_IEEE80211G
:
146 tpt_table
= iwl_tpt_table_g
;
147 table_size
= ARRAY_SIZE(iwl_tpt_table_g
);
150 case MODE_IEEE80211A
:
151 tpt_table
= iwl_tpt_table_a
;
152 table_size
= ARRAY_SIZE(iwl_tpt_table_a
);
156 case MODE_IEEE80211B
:
157 tpt_table
= iwl_tpt_table_b
;
158 table_size
= ARRAY_SIZE(iwl_tpt_table_b
);
162 while ((index
< table_size
) && (rssi
< tpt_table
[index
].min_rssi
))
165 index
= min(index
, (table_size
- 1));
167 return tpt_table
[index
].index
;
170 static void iwl_clear_window(struct iwl_rate_scale_data
*window
)
173 window
->success_counter
= 0;
174 window
->success_ratio
= IWL_INVALID_VALUE
;
176 window
->average_tpt
= IWL_INVALID_VALUE
;
181 * iwl_rate_scale_flush_windows - flush out the rate scale windows
183 * Returns the number of windows that have gathered data but were
184 * not flushed. If there were any that were not flushed, then
185 * reschedule the rate flushing routine.
187 static int iwl_rate_scale_flush_windows(struct iwl_rate_scale_priv
*rs_priv
)
194 * For each rate, if we have collected data on that rate
195 * and it has been more than IWL_RATE_WIN_FLUSH
196 * since we flushed, clear out the gathered statistics
198 for (i
= 0; i
< IWL_RATE_COUNT
; i
++) {
199 if (!rs_priv
->win
[i
].counter
)
202 spin_lock_irqsave(&rs_priv
->lock
, flags
);
203 if (time_after(jiffies
, rs_priv
->win
[i
].stamp
+
204 IWL_RATE_WIN_FLUSH
)) {
205 IWL_DEBUG_RATE("flushing %d samples of rate "
207 rs_priv
->win
[i
].counter
, i
);
208 iwl_clear_window(&rs_priv
->win
[i
]);
211 spin_unlock_irqrestore(&rs_priv
->lock
, flags
);
217 #define IWL_RATE_FLUSH_MAX 5000 /* msec */
218 #define IWL_RATE_FLUSH_MIN 50 /* msec */
220 static void iwl_bg_rate_scale_flush(unsigned long data
)
222 struct iwl_rate_scale_priv
*rs_priv
= (void *)data
;
225 u32 packet_count
, duration
, pps
;
227 IWL_DEBUG_RATE("enter\n");
229 unflushed
= iwl_rate_scale_flush_windows(rs_priv
);
231 spin_lock_irqsave(&rs_priv
->lock
, flags
);
233 rs_priv
->flush_pending
= 0;
235 /* Number of packets Rx'd since last time this timer ran */
236 packet_count
= (rs_priv
->tx_packets
- rs_priv
->last_tx_packets
) + 1;
238 rs_priv
->last_tx_packets
= rs_priv
->tx_packets
+ 1;
242 jiffies_to_msecs(jiffies
- rs_priv
->last_partial_flush
);
243 /* duration = jiffies_to_msecs(rs_priv->flush_time); */
245 IWL_DEBUG_RATE("Tx'd %d packets in %dms\n",
246 packet_count
, duration
);
248 /* Determine packets per second */
250 pps
= (packet_count
* 1000) / duration
;
255 duration
= IWL_RATE_FLUSH_MAX
/ pps
;
256 if (duration
< IWL_RATE_FLUSH_MIN
)
257 duration
= IWL_RATE_FLUSH_MIN
;
259 duration
= IWL_RATE_FLUSH_MAX
;
261 rs_priv
->flush_time
= msecs_to_jiffies(duration
);
263 IWL_DEBUG_RATE("new flush period: %d msec ave %d\n",
264 duration
, packet_count
);
266 mod_timer(&rs_priv
->rate_scale_flush
, jiffies
+
267 rs_priv
->flush_time
);
269 rs_priv
->last_partial_flush
= jiffies
;
272 /* If there weren't any unflushed entries, we don't schedule the timer
275 rs_priv
->last_flush
= jiffies
;
277 spin_unlock_irqrestore(&rs_priv
->lock
, flags
);
279 IWL_DEBUG_RATE("leave\n");
283 * iwl_collect_tx_data - Update the success/failure sliding window
285 * We keep a sliding window of the last 64 packets transmitted
286 * at this rate. window->data contains the bitmask of successful
289 static void iwl_collect_tx_data(struct iwl_rate_scale_priv
*rs_priv
,
290 struct iwl_rate_scale_data
*window
,
291 int success
, int retries
)
296 IWL_DEBUG_RATE("leave: retries == 0 -- should be at least 1\n");
301 spin_lock_irqsave(&rs_priv
->lock
, flags
);
303 /* If we have filled up the window then subtract one from the
304 * success counter if the high-bit is counting toward
306 if (window
->counter
== IWL_RATE_MAX_WINDOW
) {
307 if (window
->data
& (1ULL << (IWL_RATE_MAX_WINDOW
- 1)))
308 window
->success_counter
--;
312 /* Slide the window to the left one bit */
313 window
->data
= (window
->data
<< 1);
315 /* If this packet was a success then set the low bit high */
317 window
->success_counter
++;
321 /* window->counter can't be 0 -- it is either >0 or
322 * IWL_RATE_MAX_WINDOW */
323 window
->success_ratio
= 12800 * window
->success_counter
/
326 /* Tag this window as having been updated */
327 window
->stamp
= jiffies
;
329 spin_unlock_irqrestore(&rs_priv
->lock
, flags
);
333 static void rs_rate_init(void *priv_rate
, void *priv_sta
,
334 struct ieee80211_local
*local
, struct sta_info
*sta
)
338 IWL_DEBUG_RATE("enter\n");
340 /* TODO: what is a good starting rate for STA? About middle? Maybe not
341 * the lowest or the highest rate.. Could consider using RSSI from
342 * previous packets? Need to have IEEE 802.1X auth succeed immediately
345 for (i
= IWL_RATE_COUNT
- 1; i
>= 0; i
--) {
346 if (sta
->supp_rates
& (1 << i
)) {
352 sta
->last_txrate
= sta
->txrate
;
354 IWL_DEBUG_RATE("leave\n");
357 static void *rs_alloc(struct ieee80211_local
*local
)
359 return local
->hw
.priv
;
362 /* rate scale requires free function to be implmented */
363 static void rs_free(void *priv
)
367 static void rs_clear(void *priv
)
373 static void *rs_alloc_sta(void *priv
, gfp_t gfp
)
375 struct iwl_rate_scale_priv
*rs_priv
;
378 IWL_DEBUG_RATE("enter\n");
380 rs_priv
= kzalloc(sizeof(struct iwl_rate_scale_priv
), gfp
);
382 IWL_DEBUG_RATE("leave: ENOMEM\n");
386 spin_lock_init(&rs_priv
->lock
);
388 rs_priv
->start_rate
= IWL_RATE_INVALID
;
390 /* default to just 802.11b */
391 rs_priv
->expected_tpt
= iwl_expected_tpt_b
;
393 rs_priv
->last_partial_flush
= jiffies
;
394 rs_priv
->last_flush
= jiffies
;
395 rs_priv
->flush_time
= IWL_RATE_FLUSH
;
396 rs_priv
->last_tx_packets
= 0;
397 rs_priv
->ibss_sta_added
= 0;
399 init_timer(&rs_priv
->rate_scale_flush
);
400 rs_priv
->rate_scale_flush
.data
= (unsigned long)rs_priv
;
401 rs_priv
->rate_scale_flush
.function
= &iwl_bg_rate_scale_flush
;
403 for (i
= 0; i
< IWL_RATE_COUNT
; i
++)
404 iwl_clear_window(&rs_priv
->win
[i
]);
406 IWL_DEBUG_RATE("leave\n");
411 static void rs_free_sta(void *priv
, void *priv_sta
)
413 struct iwl_rate_scale_priv
*rs_priv
= priv_sta
;
415 IWL_DEBUG_RATE("enter\n");
416 del_timer_sync(&rs_priv
->rate_scale_flush
);
418 IWL_DEBUG_RATE("leave\n");
422 * rs_tx_status - Update rate control values based on Tx results
424 * NOTE: Uses iwl_priv->retry_rate for the # of retries attempted by
425 * the hardware for each rate.
427 static void rs_tx_status(void *priv_rate
,
428 struct net_device
*dev
,
430 struct ieee80211_tx_status
*tx_resp
)
432 u8 retries
, current_count
;
433 int scale_rate_index
, first_index
, last_index
;
435 struct sta_info
*sta
;
436 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)skb
->data
;
437 struct iwl_priv
*priv
= (struct iwl_priv
*)priv_rate
;
438 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
439 struct iwl_rate_scale_priv
*rs_priv
;
441 IWL_DEBUG_RATE("enter\n");
443 retries
= tx_resp
->retry_count
;
445 first_index
= tx_resp
->control
.tx_rate
;
446 if ((first_index
< 0) || (first_index
>= IWL_RATE_COUNT
)) {
447 IWL_DEBUG_RATE("leave: Rate out of bounds: %0x for %d\n",
448 tx_resp
->control
.tx_rate
, first_index
);
452 sta
= sta_info_get(local
, hdr
->addr1
);
453 if (!sta
|| !sta
->rate_ctrl_priv
) {
456 IWL_DEBUG_RATE("leave: No STA priv data to update!\n");
460 rs_priv
= (void *)sta
->rate_ctrl_priv
;
462 rs_priv
->tx_packets
++;
464 scale_rate_index
= first_index
;
465 last_index
= first_index
;
468 * Update the window for each rate. We determine which rates
469 * were Tx'd based on the total number of retries vs. the number
470 * of retries configured for each rate -- currently set to the
471 * priv value 'retry_rate' vs. rate specific
473 * On exit from this while loop last_index indicates the rate
474 * at which the frame was finally transmitted (or failed if no
477 while (retries
> 0) {
478 if (retries
< priv
->retry_rate
) {
479 current_count
= retries
;
480 last_index
= scale_rate_index
;
482 current_count
= priv
->retry_rate
;
483 last_index
= iwl_get_prev_ieee_rate(scale_rate_index
);
486 /* Update this rate accounting for as many retries
487 * as was used for it (per current_count) */
488 iwl_collect_tx_data(rs_priv
,
489 &rs_priv
->win
[scale_rate_index
],
491 IWL_DEBUG_RATE("Update rate %d for %d retries.\n",
492 scale_rate_index
, current_count
);
494 retries
-= current_count
;
498 iwl_get_prev_ieee_rate(scale_rate_index
);
501 /* Update the last index window with success/failure based on ACK */
502 IWL_DEBUG_RATE("Update rate %d with %s.\n",
504 (tx_resp
->flags
& IEEE80211_TX_STATUS_ACK
) ?
505 "success" : "failure");
506 iwl_collect_tx_data(rs_priv
,
507 &rs_priv
->win
[last_index
],
508 tx_resp
->flags
& IEEE80211_TX_STATUS_ACK
, 1);
510 /* We updated the rate scale window -- if its been more than
511 * flush_time since the last run, schedule the flush
513 spin_lock_irqsave(&rs_priv
->lock
, flags
);
515 if (!rs_priv
->flush_pending
&&
516 time_after(jiffies
, rs_priv
->last_partial_flush
+
517 rs_priv
->flush_time
)) {
519 rs_priv
->flush_pending
= 1;
520 mod_timer(&rs_priv
->rate_scale_flush
,
521 jiffies
+ rs_priv
->flush_time
);
524 spin_unlock_irqrestore(&rs_priv
->lock
, flags
);
528 IWL_DEBUG_RATE("leave\n");
533 static struct ieee80211_rate
*iwl_get_lowest_rate(struct ieee80211_local
536 struct ieee80211_hw_mode
*mode
= local
->oper_hw_mode
;
539 for (i
= 0; i
< mode
->num_rates
; i
++) {
540 struct ieee80211_rate
*rate
= &mode
->rates
[i
];
542 if (rate
->flags
& IEEE80211_RATE_SUPPORTED
)
546 return &mode
->rates
[0];
549 static u16
iwl_get_adjacent_rate(struct iwl_rate_scale_priv
*rs_priv
,
550 u8 index
, u16 rate_mask
, int phymode
)
552 u8 high
= IWL_RATE_INVALID
;
553 u8 low
= IWL_RATE_INVALID
;
555 /* 802.11A walks to the next literal adjascent rate in
557 if (unlikely(phymode
== MODE_IEEE80211A
)) {
561 /* Find the previous rate that is in the rate mask */
563 for (mask
= (1 << i
); i
>= 0; i
--, mask
>>= 1) {
564 if (rate_mask
& mask
) {
570 /* Find the next rate that is in the rate mask */
572 for (mask
= (1 << i
); i
< IWL_RATE_COUNT
; i
++, mask
<<= 1) {
573 if (rate_mask
& mask
) {
579 return (high
<< 8) | low
;
583 while (low
!= IWL_RATE_INVALID
) {
585 low
= iwl_rates
[low
].prev_rs_tgg
;
587 low
= iwl_rates
[low
].prev_rs
;
588 if (low
== IWL_RATE_INVALID
)
590 if (rate_mask
& (1 << low
))
592 IWL_DEBUG_RATE("Skipping masked lower rate: %d\n", low
);
596 while (high
!= IWL_RATE_INVALID
) {
598 high
= iwl_rates
[high
].next_rs_tgg
;
600 high
= iwl_rates
[high
].next_rs
;
601 if (high
== IWL_RATE_INVALID
)
603 if (rate_mask
& (1 << high
))
605 IWL_DEBUG_RATE("Skipping masked higher rate: %d\n", high
);
608 return (high
<< 8) | low
;
612 * rs_get_rate - find the rate for the requested packet
614 * Returns the ieee80211_rate structure allocated by the driver.
616 * The rate control algorithm has no internal mapping between hw_mode's
617 * rate ordering and the rate ordering used by the rate control algorithm.
619 * The rate control algorithm uses a single table of rates that goes across
620 * the entire A/B/G spectrum vs. being limited to just one particular
623 * As such, we can't convert the index obtained below into the hw_mode's
624 * rate table and must reference the driver allocated rate table
627 static struct ieee80211_rate
*rs_get_rate(void *priv_rate
,
628 struct net_device
*dev
,
630 struct rate_control_extra
*extra
)
632 u8 low
= IWL_RATE_INVALID
;
633 u8 high
= IWL_RATE_INVALID
;
636 struct iwl_rate_scale_priv
*rs_priv
;
637 struct iwl_rate_scale_data
*window
= NULL
;
638 int current_tpt
= IWL_INVALID_VALUE
;
639 int low_tpt
= IWL_INVALID_VALUE
;
640 int high_tpt
= IWL_INVALID_VALUE
;
644 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
645 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)skb
->data
;
646 struct sta_info
*sta
;
648 struct iwl_priv
*priv
= (struct iwl_priv
*)priv_rate
;
650 IWL_DEBUG_RATE("enter\n");
652 memset(extra
, 0, sizeof(*extra
));
654 fc
= le16_to_cpu(hdr
->frame_control
);
655 if (((fc
& IEEE80211_FCTL_FTYPE
) != IEEE80211_FTYPE_DATA
) ||
656 (is_multicast_ether_addr(hdr
->addr1
))) {
657 /* Send management frames and broadcast/multicast data using
659 /* TODO: this could probably be improved.. */
660 IWL_DEBUG_RATE("leave: lowest rate (not data or is "
663 return iwl_get_lowest_rate(local
);
666 sta
= sta_info_get(local
, hdr
->addr1
);
667 if (!sta
|| !sta
->rate_ctrl_priv
) {
668 IWL_DEBUG_RATE("leave: No STA priv data to update!\n");
674 rate_mask
= sta
->supp_rates
;
675 index
= min(sta
->txrate
& 0xffff, IWL_RATE_COUNT
- 1);
677 rs_priv
= (void *)sta
->rate_ctrl_priv
;
679 if ((priv
->iw_mode
== IEEE80211_IF_TYPE_IBSS
) &&
680 !rs_priv
->ibss_sta_added
) {
681 u8 sta_id
= iwl_hw_find_station(priv
, hdr
->addr1
);
683 if (sta_id
== IWL_INVALID_STATION
) {
684 IWL_DEBUG_RATE("LQ: ADD station " MAC_FMT
"\n",
685 MAC_ARG(hdr
->addr1
));
686 sta_id
= iwl_add_station(priv
,
687 hdr
->addr1
, 0, CMD_ASYNC
);
689 if (sta_id
!= IWL_INVALID_STATION
)
690 rs_priv
->ibss_sta_added
= 1;
693 spin_lock_irqsave(&rs_priv
->lock
, flags
);
695 if (rs_priv
->start_rate
!= IWL_RATE_INVALID
) {
696 index
= rs_priv
->start_rate
;
697 rs_priv
->start_rate
= IWL_RATE_INVALID
;
700 window
= &(rs_priv
->win
[index
]);
702 fail_count
= window
->counter
- window
->success_counter
;
704 if (((fail_count
<= IWL_RATE_MIN_FAILURE_TH
) &&
705 (window
->success_counter
< IWL_RATE_MIN_SUCCESS_TH
))) {
706 window
->average_tpt
= IWL_INVALID_VALUE
;
707 spin_unlock_irqrestore(&rs_priv
->lock
, flags
);
709 IWL_DEBUG_RATE("Invalid average_tpt on rate %d: "
710 "counter: %d, success_counter: %d, "
711 "expected_tpt is %sNULL\n",
714 window
->success_counter
,
715 rs_priv
->expected_tpt
? "not " : "");
720 window
->average_tpt
= ((window
->success_ratio
*
721 rs_priv
->expected_tpt
[index
] + 64) / 128);
722 current_tpt
= window
->average_tpt
;
724 high_low
= iwl_get_adjacent_rate(rs_priv
, index
, rate_mask
,
725 local
->hw
.conf
.phymode
);
726 low
= high_low
& 0xff;
727 high
= (high_low
>> 8) & 0xff;
729 if (low
!= IWL_RATE_INVALID
)
730 low_tpt
= rs_priv
->win
[low
].average_tpt
;
732 if (high
!= IWL_RATE_INVALID
)
733 high_tpt
= rs_priv
->win
[high
].average_tpt
;
735 spin_unlock_irqrestore(&rs_priv
->lock
, flags
);
739 if ((window
->success_ratio
< IWL_RATE_DECREASE_TH
) || !current_tpt
) {
740 IWL_DEBUG_RATE("decrease rate because of low success_ratio\n");
742 } else if ((low_tpt
== IWL_INVALID_VALUE
) &&
743 (high_tpt
== IWL_INVALID_VALUE
))
745 else if ((low_tpt
!= IWL_INVALID_VALUE
) &&
746 (high_tpt
!= IWL_INVALID_VALUE
)
747 && (low_tpt
< current_tpt
)
748 && (high_tpt
< current_tpt
)) {
749 IWL_DEBUG_RATE("No action -- low [%d] & high [%d] < "
750 "current_tpt [%d]\n",
751 low_tpt
, high_tpt
, current_tpt
);
754 if (high_tpt
!= IWL_INVALID_VALUE
) {
755 if (high_tpt
> current_tpt
)
759 ("decrease rate because of high tpt\n");
762 } else if (low_tpt
!= IWL_INVALID_VALUE
) {
763 if (low_tpt
> current_tpt
) {
765 ("decrease rate because of low tpt\n");
772 if ((window
->success_ratio
> IWL_RATE_HIGH_TH
) ||
773 (current_tpt
> window
->average_tpt
)) {
774 IWL_DEBUG_RATE("No action -- success_ratio [%d] > HIGH_TH or "
775 "current_tpt [%d] > average_tpt [%d]\n",
776 window
->success_ratio
,
777 current_tpt
, window
->average_tpt
);
781 switch (scale_action
) {
783 if (low
!= IWL_RATE_INVALID
)
788 if (high
!= IWL_RATE_INVALID
)
798 IWL_DEBUG_RATE("Selected %d (action %d) - low %d high %d\n",
799 index
, scale_action
, low
, high
);
803 sta
->last_txrate
= index
;
804 sta
->txrate
= sta
->last_txrate
;
807 IWL_DEBUG_RATE("leave: %d\n", index
);
809 return &priv
->ieee_rates
[index
];
812 static struct rate_control_ops rs_ops
= {
815 .tx_status
= rs_tx_status
,
816 .get_rate
= rs_get_rate
,
817 .rate_init
= rs_rate_init
,
821 .alloc_sta
= rs_alloc_sta
,
822 .free_sta
= rs_free_sta
,
825 int iwl_fill_rs_info(struct ieee80211_hw
*hw
, char *buf
, u8 sta_id
)
827 struct ieee80211_local
*local
= hw_to_local(hw
);
828 struct iwl_priv
*priv
= hw
->priv
;
829 struct iwl_rate_scale_priv
*rs_priv
;
830 struct sta_info
*sta
;
833 u32 samples
= 0, success
= 0, good
= 0;
834 unsigned long now
= jiffies
;
837 sta
= sta_info_get(local
, priv
->stations
[sta_id
].sta
.sta
.addr
);
838 if (!sta
|| !sta
->rate_ctrl_priv
) {
841 IWL_DEBUG_RATE("leave - no private rate data!\n");
843 IWL_DEBUG_RATE("leave - no station!\n");
844 return sprintf(buf
, "station %d not found\n", sta_id
);
847 rs_priv
= (void *)sta
->rate_ctrl_priv
;
848 spin_lock_irqsave(&rs_priv
->lock
, flags
);
849 i
= IWL_RATE_54M_INDEX
;
855 sprintf(&buf
[count
], " %2dMbs: ", iwl_rates
[i
].ieee
/ 2);
857 mask
= (1ULL << (IWL_RATE_MAX_WINDOW
- 1));
858 for (j
= 0; j
< IWL_RATE_MAX_WINDOW
; j
++, mask
>>= 1)
860 (rs_priv
->win
[i
].data
& mask
) ? '1' : '0';
862 samples
+= rs_priv
->win
[i
].counter
;
863 good
+= rs_priv
->win
[i
].success_counter
;
864 success
+= rs_priv
->win
[i
].success_counter
* iwl_rates
[i
].ieee
;
866 if (rs_priv
->win
[i
].stamp
) {
868 jiffies_to_msecs(now
- rs_priv
->win
[i
].stamp
);
870 if (delta
> max_time
)
873 count
+= sprintf(&buf
[count
], "%5dms\n", delta
);
877 j
= iwl_get_prev_ieee_rate(i
);
882 spin_unlock_irqrestore(&rs_priv
->lock
, flags
);
885 /* Display the average rate of all samples taken.
887 * NOTE: We multiple # of samples by 2 since the IEEE measurement
888 * added from iwl_rates is actually 2X the rate */
892 "\nAverage rate is %3d.%02dMbs over last %4dms\n"
893 "%3d%% success (%d good packets over %d tries)\n",
894 success
/ (2 * samples
), (success
* 5 / samples
) % 10,
895 max_time
, good
* 100 / samples
, good
, samples
);
897 count
+= sprintf(&buf
[count
], "\nAverage rate: 0Mbs\n");
902 void iwl_rate_scale_init(struct ieee80211_hw
*hw
, s32 sta_id
)
904 struct iwl_priv
*priv
= hw
->priv
;
907 struct ieee80211_local
*local
= hw_to_local(hw
);
908 struct iwl_rate_scale_priv
*rs_priv
;
909 struct sta_info
*sta
;
911 IWL_DEBUG_RATE("enter\n");
913 if (!local
->rate_ctrl
->ops
->name
||
914 strcmp(local
->rate_ctrl
->ops
->name
, RS_NAME
)) {
915 IWL_WARNING("iwl-3945-rs not selected as rate control algo!\n");
916 IWL_DEBUG_RATE("leave - mac80211 picked the wrong RC algo.\n");
920 sta
= sta_info_get(local
, priv
->stations
[sta_id
].sta
.sta
.addr
);
921 if (!sta
|| !sta
->rate_ctrl_priv
) {
924 IWL_DEBUG_RATE("leave - no private rate data!\n");
928 rs_priv
= (void *)sta
->rate_ctrl_priv
;
930 spin_lock_irqsave(&rs_priv
->lock
, flags
);
933 switch (priv
->phymode
) {
934 case MODE_IEEE80211G
:
935 if (priv
->active_rxon
.flags
& RXON_FLG_TGG_PROTECT_MSK
) {
937 rs_priv
->expected_tpt
= iwl_expected_tpt_g_prot
;
939 rs_priv
->expected_tpt
= iwl_expected_tpt_g
;
942 case MODE_IEEE80211A
:
943 rs_priv
->expected_tpt
= iwl_expected_tpt_a
;
947 IWL_WARNING("Invalid phymode. Defaulting to 802.11b\n");
948 case MODE_IEEE80211B
:
949 rs_priv
->expected_tpt
= iwl_expected_tpt_b
;
954 spin_unlock_irqrestore(&rs_priv
->lock
, flags
);
956 rssi
= priv
->last_rx_rssi
;
958 rssi
= IWL_MIN_RSSI_VAL
;
960 IWL_DEBUG(IWL_DL_INFO
| IWL_DL_RATE
, "Network RSSI: %d\n", rssi
);
962 rs_priv
->start_rate
= iwl_get_rate_index_by_rssi(rssi
, priv
->phymode
);
964 IWL_DEBUG_RATE("leave: rssi %d assign rate index: "
965 "%d (plcp 0x%x)\n", rssi
, rs_priv
->start_rate
,
966 iwl_rates
[rs_priv
->start_rate
].plcp
);
969 void iwl_rate_control_register(struct ieee80211_hw
*hw
)
971 ieee80211_rate_control_register(&rs_ops
);
974 void iwl_rate_control_unregister(struct ieee80211_hw
*hw
)
976 ieee80211_rate_control_unregister(&rs_ops
);