1 /******************************************************************************
3 * Copyright(c) 2005 - 2008 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>
41 #define RS_NAME "iwl-3945-rs"
43 struct iwl3945_rate_scale_data
{
52 struct iwl3945_rs_sta
{
55 unsigned long last_partial_flush
;
56 unsigned long last_flush
;
64 struct timer_list rate_scale_flush
;
65 struct iwl3945_rate_scale_data win
[IWL_RATE_COUNT
];
66 #ifdef CONFIG_MAC80211_DEBUGFS
67 struct dentry
*rs_sta_dbgfs_stats_table_file
;
70 /* used to be in sta_info */
74 static s32 iwl3945_expected_tpt_g
[IWL_RATE_COUNT
] = {
75 7, 13, 35, 58, 0, 0, 76, 104, 130, 168, 191, 202
78 static s32 iwl3945_expected_tpt_g_prot
[IWL_RATE_COUNT
] = {
79 7, 13, 35, 58, 0, 0, 0, 80, 93, 113, 123, 125
82 static s32 iwl3945_expected_tpt_a
[IWL_RATE_COUNT
] = {
83 0, 0, 0, 0, 40, 57, 72, 98, 121, 154, 177, 186
86 static s32 iwl3945_expected_tpt_b
[IWL_RATE_COUNT
] = {
87 7, 13, 35, 58, 0, 0, 0, 0, 0, 0, 0, 0
90 struct iwl3945_tpt_entry
{
95 static struct iwl3945_tpt_entry iwl3945_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 iwl3945_tpt_entry iwl3945_tpt_table_g
[] = {
107 {-60, IWL_RATE_54M_INDEX
},
108 {-64, IWL_RATE_48M_INDEX
},
109 {-68, IWL_RATE_36M_INDEX
},
110 {-80, IWL_RATE_24M_INDEX
},
111 {-84, IWL_RATE_18M_INDEX
},
112 {-85, IWL_RATE_12M_INDEX
},
113 {-86, IWL_RATE_11M_INDEX
},
114 {-88, IWL_RATE_5M_INDEX
},
115 {-90, IWL_RATE_2M_INDEX
},
116 {-92, IWL_RATE_1M_INDEX
}
119 #define IWL_RATE_MAX_WINDOW 62
120 #define IWL_RATE_FLUSH (3*HZ)
121 #define IWL_RATE_WIN_FLUSH (HZ/2)
122 #define IWL_RATE_HIGH_TH 11520
123 #define IWL_SUCCESS_UP_TH 8960
124 #define IWL_SUCCESS_DOWN_TH 10880
125 #define IWL_RATE_MIN_FAILURE_TH 8
126 #define IWL_RATE_MIN_SUCCESS_TH 8
127 #define IWL_RATE_DECREASE_TH 1920
129 static u8
iwl3945_get_rate_index_by_rssi(s32 rssi
, enum ieee80211_band band
)
133 struct iwl3945_tpt_entry
*tpt_table
= NULL
;
135 if ((rssi
< IWL_MIN_RSSI_VAL
) || (rssi
> IWL_MAX_RSSI_VAL
))
136 rssi
= IWL_MIN_RSSI_VAL
;
139 case IEEE80211_BAND_2GHZ
:
140 tpt_table
= iwl3945_tpt_table_g
;
141 table_size
= ARRAY_SIZE(iwl3945_tpt_table_g
);
144 case IEEE80211_BAND_5GHZ
:
145 tpt_table
= iwl3945_tpt_table_a
;
146 table_size
= ARRAY_SIZE(iwl3945_tpt_table_a
);
154 while ((index
< table_size
) && (rssi
< tpt_table
[index
].min_rssi
))
157 index
= min(index
, (table_size
- 1));
159 return tpt_table
[index
].index
;
162 static void iwl3945_clear_window(struct iwl3945_rate_scale_data
*window
)
165 window
->success_counter
= 0;
166 window
->success_ratio
= -1;
168 window
->average_tpt
= IWL_INV_TPT
;
173 * iwl3945_rate_scale_flush_windows - flush out the rate scale windows
175 * Returns the number of windows that have gathered data but were
176 * not flushed. If there were any that were not flushed, then
177 * reschedule the rate flushing routine.
179 static int iwl3945_rate_scale_flush_windows(struct iwl3945_rs_sta
*rs_sta
)
186 * For each rate, if we have collected data on that rate
187 * and it has been more than IWL_RATE_WIN_FLUSH
188 * since we flushed, clear out the gathered statistics
190 for (i
= 0; i
< IWL_RATE_COUNT
; i
++) {
191 if (!rs_sta
->win
[i
].counter
)
194 spin_lock_irqsave(&rs_sta
->lock
, flags
);
195 if (time_after(jiffies
, rs_sta
->win
[i
].stamp
+
196 IWL_RATE_WIN_FLUSH
)) {
197 IWL_DEBUG_RATE("flushing %d samples of rate "
199 rs_sta
->win
[i
].counter
, i
);
200 iwl3945_clear_window(&rs_sta
->win
[i
]);
203 spin_unlock_irqrestore(&rs_sta
->lock
, flags
);
209 #define IWL_RATE_FLUSH_MAX 5000 /* msec */
210 #define IWL_RATE_FLUSH_MIN 50 /* msec */
211 #define IWL_AVERAGE_PACKETS 1500
213 static void iwl3945_bg_rate_scale_flush(unsigned long data
)
215 struct iwl3945_rs_sta
*rs_sta
= (void *)data
;
218 u32 packet_count
, duration
, pps
;
220 IWL_DEBUG_RATE("enter\n");
222 unflushed
= iwl3945_rate_scale_flush_windows(rs_sta
);
224 spin_lock_irqsave(&rs_sta
->lock
, flags
);
226 /* Number of packets Rx'd since last time this timer ran */
227 packet_count
= (rs_sta
->tx_packets
- rs_sta
->last_tx_packets
) + 1;
229 rs_sta
->last_tx_packets
= rs_sta
->tx_packets
+ 1;
233 jiffies_to_msecs(jiffies
- rs_sta
->last_partial_flush
);
235 IWL_DEBUG_RATE("Tx'd %d packets in %dms\n",
236 packet_count
, duration
);
238 /* Determine packets per second */
240 pps
= (packet_count
* 1000) / duration
;
245 duration
= (IWL_AVERAGE_PACKETS
* 1000) / pps
;
246 if (duration
< IWL_RATE_FLUSH_MIN
)
247 duration
= IWL_RATE_FLUSH_MIN
;
248 else if (duration
> IWL_RATE_FLUSH_MAX
)
249 duration
= IWL_RATE_FLUSH_MAX
;
251 duration
= IWL_RATE_FLUSH_MAX
;
253 rs_sta
->flush_time
= msecs_to_jiffies(duration
);
255 IWL_DEBUG_RATE("new flush period: %d msec ave %d\n",
256 duration
, packet_count
);
258 mod_timer(&rs_sta
->rate_scale_flush
, jiffies
+
261 rs_sta
->last_partial_flush
= jiffies
;
263 rs_sta
->flush_time
= IWL_RATE_FLUSH
;
264 rs_sta
->flush_pending
= 0;
266 /* If there weren't any unflushed entries, we don't schedule the timer
269 rs_sta
->last_flush
= jiffies
;
271 spin_unlock_irqrestore(&rs_sta
->lock
, flags
);
273 IWL_DEBUG_RATE("leave\n");
277 * iwl3945_collect_tx_data - Update the success/failure sliding window
279 * We keep a sliding window of the last 64 packets transmitted
280 * at this rate. window->data contains the bitmask of successful
283 static void iwl3945_collect_tx_data(struct iwl3945_rs_sta
*rs_sta
,
284 struct iwl3945_rate_scale_data
*window
,
285 int success
, int retries
, int index
)
291 IWL_DEBUG_RATE("leave: retries == 0 -- should be at least 1\n");
295 spin_lock_irqsave(&rs_sta
->lock
, flags
);
298 /* If we have filled up the window then subtract one from the
299 * success counter if the high-bit is counting toward
301 if (window
->counter
== IWL_RATE_MAX_WINDOW
) {
302 if (window
->data
& (1ULL << (IWL_RATE_MAX_WINDOW
- 1)))
303 window
->success_counter
--;
307 /* Slide the window to the left one bit */
308 window
->data
= (window
->data
<< 1);
310 /* If this packet was a success then set the low bit high */
312 window
->success_counter
++;
316 /* window->counter can't be 0 -- it is either >0 or
317 * IWL_RATE_MAX_WINDOW */
318 window
->success_ratio
= 12800 * window
->success_counter
/
321 /* Tag this window as having been updated */
322 window
->stamp
= jiffies
;
326 fail_count
= window
->counter
- window
->success_counter
;
327 if ((fail_count
>= IWL_RATE_MIN_FAILURE_TH
) ||
328 (window
->success_counter
>= IWL_RATE_MIN_SUCCESS_TH
))
329 window
->average_tpt
= ((window
->success_ratio
*
330 rs_sta
->expected_tpt
[index
] + 64) / 128);
332 window
->average_tpt
= IWL_INV_TPT
;
334 spin_unlock_irqrestore(&rs_sta
->lock
, flags
);
338 static void rs_rate_init(void *priv_r
, struct ieee80211_supported_band
*sband
,
339 struct ieee80211_sta
*sta
, void *priv_sta
)
341 struct iwl3945_rs_sta
*rs_sta
= priv_sta
;
342 struct iwl3945_priv
*priv
= (struct iwl3945_priv
*)priv_r
;
345 IWL_DEBUG_RATE("enter\n");
347 /* TODO: what is a good starting rate for STA? About middle? Maybe not
348 * the lowest or the highest rate.. Could consider using RSSI from
349 * previous packets? Need to have IEEE 802.1X auth succeed immediately
352 for (i
= sband
->n_bitrates
- 1; i
>= 0; i
--) {
353 if (sta
->supp_rates
[sband
->band
] & (1 << i
)) {
354 rs_sta
->last_txrate_idx
= i
;
359 priv
->sta_supp_rates
= sta
->supp_rates
[sband
->band
];
360 /* For 5 GHz band it start at IWL_FIRST_OFDM_RATE */
361 if (sband
->band
== IEEE80211_BAND_5GHZ
) {
362 rs_sta
->last_txrate_idx
+= IWL_FIRST_OFDM_RATE
;
363 priv
->sta_supp_rates
= priv
->sta_supp_rates
<<
368 IWL_DEBUG_RATE("leave\n");
371 static void *rs_alloc(struct ieee80211_hw
*hw
, struct dentry
*debugfsdir
)
376 /* rate scale requires free function to be implemented */
377 static void rs_free(void *priv
)
382 static void *rs_alloc_sta(void *priv
, struct ieee80211_sta
*sta
, gfp_t gfp
)
384 struct iwl3945_rs_sta
*rs_sta
;
385 struct iwl3945_sta_priv
*psta
= (void *) sta
->drv_priv
;
389 * XXX: If it's using sta->drv_priv anyway, it might
390 * as well just put all the information there.
393 IWL_DEBUG_RATE("enter\n");
395 rs_sta
= kzalloc(sizeof(struct iwl3945_rs_sta
), gfp
);
397 IWL_DEBUG_RATE("leave: ENOMEM\n");
401 psta
->rs_sta
= rs_sta
;
403 spin_lock_init(&rs_sta
->lock
);
405 rs_sta
->start_rate
= IWL_RATE_INVALID
;
407 /* default to just 802.11b */
408 rs_sta
->expected_tpt
= iwl3945_expected_tpt_b
;
410 rs_sta
->last_partial_flush
= jiffies
;
411 rs_sta
->last_flush
= jiffies
;
412 rs_sta
->flush_time
= IWL_RATE_FLUSH
;
413 rs_sta
->last_tx_packets
= 0;
414 rs_sta
->ibss_sta_added
= 0;
416 init_timer(&rs_sta
->rate_scale_flush
);
417 rs_sta
->rate_scale_flush
.data
= (unsigned long)rs_sta
;
418 rs_sta
->rate_scale_flush
.function
= &iwl3945_bg_rate_scale_flush
;
420 for (i
= 0; i
< IWL_RATE_COUNT
; i
++)
421 iwl3945_clear_window(&rs_sta
->win
[i
]);
423 IWL_DEBUG_RATE("leave\n");
428 static void rs_free_sta(void *priv
, struct ieee80211_sta
*sta
,
431 struct iwl3945_sta_priv
*psta
= (void *) sta
->drv_priv
;
432 struct iwl3945_rs_sta
*rs_sta
= priv_sta
;
436 IWL_DEBUG_RATE("enter\n");
437 del_timer_sync(&rs_sta
->rate_scale_flush
);
439 IWL_DEBUG_RATE("leave\n");
444 * rs_tx_status - Update rate control values based on Tx results
446 * NOTE: Uses iwl3945_priv->retry_rate for the # of retries attempted by
447 * the hardware for each rate.
449 static void rs_tx_status(void *priv_rate
, struct ieee80211_supported_band
*sband
,
450 struct ieee80211_sta
*sta
, void *priv_sta
,
453 s8 retries
= 0, current_count
;
454 int scale_rate_index
, first_index
, last_index
;
456 struct iwl3945_priv
*priv
= (struct iwl3945_priv
*)priv_rate
;
457 struct iwl3945_rs_sta
*rs_sta
= priv_sta
;
458 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
460 IWL_DEBUG_RATE("enter\n");
462 retries
= info
->status
.rates
[0].count
;
464 first_index
= sband
->bitrates
[info
->status
.rates
[0].idx
].hw_value
;
465 if ((first_index
< 0) || (first_index
>= IWL_RATE_COUNT
)) {
466 IWL_DEBUG_RATE("leave: Rate out of bounds: %d\n", first_index
);
471 IWL_DEBUG_RATE("leave: No STA priv data to update!\n");
475 rs_sta
->tx_packets
++;
477 scale_rate_index
= first_index
;
478 last_index
= first_index
;
481 * Update the window for each rate. We determine which rates
482 * were Tx'd based on the total number of retries vs. the number
483 * of retries configured for each rate -- currently set to the
484 * priv value 'retry_rate' vs. rate specific
486 * On exit from this while loop last_index indicates the rate
487 * at which the frame was finally transmitted (or failed if no
490 while (retries
> 1) {
491 if ((retries
- 1) < priv
->retry_rate
) {
492 current_count
= (retries
- 1);
493 last_index
= scale_rate_index
;
495 current_count
= priv
->retry_rate
;
496 last_index
= iwl3945_rs_next_rate(priv
,
500 /* Update this rate accounting for as many retries
501 * as was used for it (per current_count) */
502 iwl3945_collect_tx_data(rs_sta
,
503 &rs_sta
->win
[scale_rate_index
],
504 0, current_count
, scale_rate_index
);
505 IWL_DEBUG_RATE("Update rate %d for %d retries.\n",
506 scale_rate_index
, current_count
);
508 retries
-= current_count
;
510 scale_rate_index
= last_index
;
514 /* Update the last index window with success/failure based on ACK */
515 IWL_DEBUG_RATE("Update rate %d with %s.\n",
517 (info
->flags
& IEEE80211_TX_STAT_ACK
) ?
518 "success" : "failure");
519 iwl3945_collect_tx_data(rs_sta
,
520 &rs_sta
->win
[last_index
],
521 info
->flags
& IEEE80211_TX_STAT_ACK
, 1, last_index
);
523 /* We updated the rate scale window -- if its been more than
524 * flush_time since the last run, schedule the flush
526 spin_lock_irqsave(&rs_sta
->lock
, flags
);
528 if (!rs_sta
->flush_pending
&&
529 time_after(jiffies
, rs_sta
->last_flush
+
530 rs_sta
->flush_time
)) {
532 rs_sta
->last_partial_flush
= jiffies
;
533 rs_sta
->flush_pending
= 1;
534 mod_timer(&rs_sta
->rate_scale_flush
,
535 jiffies
+ rs_sta
->flush_time
);
538 spin_unlock_irqrestore(&rs_sta
->lock
, flags
);
540 IWL_DEBUG_RATE("leave\n");
545 static u16
iwl3945_get_adjacent_rate(struct iwl3945_rs_sta
*rs_sta
,
546 u8 index
, u16 rate_mask
, enum ieee80211_band band
)
548 u8 high
= IWL_RATE_INVALID
;
549 u8 low
= IWL_RATE_INVALID
;
551 /* 802.11A walks to the next literal adjacent rate in
553 if (unlikely(band
== IEEE80211_BAND_5GHZ
)) {
557 /* Find the previous rate that is in the rate mask */
559 for (mask
= (1 << i
); i
>= 0; i
--, mask
>>= 1) {
560 if (rate_mask
& mask
) {
566 /* Find the next rate that is in the rate mask */
568 for (mask
= (1 << i
); i
< IWL_RATE_COUNT
; i
++, mask
<<= 1) {
569 if (rate_mask
& mask
) {
575 return (high
<< 8) | low
;
579 while (low
!= IWL_RATE_INVALID
) {
581 low
= iwl3945_rates
[low
].prev_rs_tgg
;
583 low
= iwl3945_rates
[low
].prev_rs
;
584 if (low
== IWL_RATE_INVALID
)
586 if (rate_mask
& (1 << low
))
588 IWL_DEBUG_RATE("Skipping masked lower rate: %d\n", low
);
592 while (high
!= IWL_RATE_INVALID
) {
594 high
= iwl3945_rates
[high
].next_rs_tgg
;
596 high
= iwl3945_rates
[high
].next_rs
;
597 if (high
== IWL_RATE_INVALID
)
599 if (rate_mask
& (1 << high
))
601 IWL_DEBUG_RATE("Skipping masked higher rate: %d\n", high
);
604 return (high
<< 8) | low
;
608 * rs_get_rate - find the rate for the requested packet
610 * Returns the ieee80211_rate structure allocated by the driver.
612 * The rate control algorithm has no internal mapping between hw_mode's
613 * rate ordering and the rate ordering used by the rate control algorithm.
615 * The rate control algorithm uses a single table of rates that goes across
616 * the entire A/B/G spectrum vs. being limited to just one particular
619 * As such, we can't convert the index obtained below into the hw_mode's
620 * rate table and must reference the driver allocated rate table
623 static void rs_get_rate(void *priv_r
, struct ieee80211_sta
*sta
,
624 void *priv_sta
, struct ieee80211_tx_rate_control
*txrc
)
626 struct ieee80211_supported_band
*sband
= txrc
->sband
;
627 struct sk_buff
*skb
= txrc
->skb
;
628 u8 low
= IWL_RATE_INVALID
;
629 u8 high
= IWL_RATE_INVALID
;
632 struct iwl3945_rs_sta
*rs_sta
= priv_sta
;
633 struct iwl3945_rate_scale_data
*window
= NULL
;
634 int current_tpt
= IWL_INV_TPT
;
635 int low_tpt
= IWL_INV_TPT
;
636 int high_tpt
= IWL_INV_TPT
;
640 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)skb
->data
;
643 struct iwl3945_priv
*priv
= (struct iwl3945_priv
*)priv_r
;
644 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
646 IWL_DEBUG_RATE("enter\n");
649 rate_mask
= sta
->supp_rates
[sband
->band
];
651 /* Send management frames and broadcast/multicast data using lowest
653 fc
= le16_to_cpu(hdr
->frame_control
);
654 if ((fc
& IEEE80211_FCTL_FTYPE
) != IEEE80211_FTYPE_DATA
||
655 is_multicast_ether_addr(hdr
->addr1
) ||
657 IWL_DEBUG_RATE("leave: No STA priv data to update!\n");
659 info
->control
.rates
[0].idx
=
660 rate_lowest_index(sband
, NULL
);
662 info
->control
.rates
[0].idx
=
663 rate_lowest_index(sband
, sta
);
667 index
= min(rs_sta
->last_txrate_idx
& 0xffff, IWL_RATE_COUNT
- 1);
669 if (sband
->band
== IEEE80211_BAND_5GHZ
)
670 rate_mask
= rate_mask
<< IWL_FIRST_OFDM_RATE
;
672 if ((priv
->iw_mode
== NL80211_IFTYPE_ADHOC
) &&
673 !rs_sta
->ibss_sta_added
) {
674 u8 sta_id
= iwl3945_hw_find_station(priv
, hdr
->addr1
);
676 if (sta_id
== IWL_INVALID_STATION
) {
677 IWL_DEBUG_RATE("LQ: ADD station %pm\n",
679 sta_id
= iwl3945_add_station(priv
,
680 hdr
->addr1
, 0, CMD_ASYNC
);
682 if (sta_id
!= IWL_INVALID_STATION
)
683 rs_sta
->ibss_sta_added
= 1;
686 spin_lock_irqsave(&rs_sta
->lock
, flags
);
688 /* for recent assoc, choose best rate regarding
691 if (rs_sta
->start_rate
!= IWL_RATE_INVALID
) {
692 if (rs_sta
->start_rate
< index
&&
693 (rate_mask
& (1 << rs_sta
->start_rate
)))
694 index
= rs_sta
->start_rate
;
695 rs_sta
->start_rate
= IWL_RATE_INVALID
;
698 window
= &(rs_sta
->win
[index
]);
700 fail_count
= window
->counter
- window
->success_counter
;
702 if (((fail_count
<= IWL_RATE_MIN_FAILURE_TH
) &&
703 (window
->success_counter
< IWL_RATE_MIN_SUCCESS_TH
))) {
704 spin_unlock_irqrestore(&rs_sta
->lock
, flags
);
706 IWL_DEBUG_RATE("Invalid average_tpt on rate %d: "
707 "counter: %d, success_counter: %d, "
708 "expected_tpt is %sNULL\n",
711 window
->success_counter
,
712 rs_sta
->expected_tpt
? "not " : "");
717 current_tpt
= window
->average_tpt
;
719 high_low
= iwl3945_get_adjacent_rate(rs_sta
, index
, rate_mask
,
721 low
= high_low
& 0xff;
722 high
= (high_low
>> 8) & 0xff;
724 if (low
!= IWL_RATE_INVALID
)
725 low_tpt
= rs_sta
->win
[low
].average_tpt
;
727 if (high
!= IWL_RATE_INVALID
)
728 high_tpt
= rs_sta
->win
[high
].average_tpt
;
730 spin_unlock_irqrestore(&rs_sta
->lock
, flags
);
734 if ((window
->success_ratio
< IWL_RATE_DECREASE_TH
) || !current_tpt
) {
735 IWL_DEBUG_RATE("decrease rate because of low success_ratio\n");
737 } else if ((low_tpt
== IWL_INV_TPT
) && (high_tpt
== IWL_INV_TPT
))
739 else if ((low_tpt
!= IWL_INV_TPT
) && (high_tpt
!= IWL_INV_TPT
) &&
740 (low_tpt
< current_tpt
) && (high_tpt
< current_tpt
)) {
741 IWL_DEBUG_RATE("No action -- low [%d] & high [%d] < "
742 "current_tpt [%d]\n",
743 low_tpt
, high_tpt
, current_tpt
);
746 if (high_tpt
!= IWL_INV_TPT
) {
747 if (high_tpt
> current_tpt
)
751 ("decrease rate because of high tpt\n");
754 } else if (low_tpt
!= IWL_INV_TPT
) {
755 if (low_tpt
> current_tpt
) {
757 ("decrease rate because of low tpt\n");
764 if (scale_action
== -1) {
765 if (window
->success_ratio
> IWL_SUCCESS_DOWN_TH
)
767 } else if (scale_action
== 1) {
768 if (window
->success_ratio
< IWL_SUCCESS_UP_TH
) {
769 IWL_DEBUG_RATE("No action -- success_ratio [%d] < "
770 "SUCCESS UP\n", window
->success_ratio
);
775 switch (scale_action
) {
777 if (low
!= IWL_RATE_INVALID
)
782 if (high
!= IWL_RATE_INVALID
)
792 IWL_DEBUG_RATE("Selected %d (action %d) - low %d high %d\n",
793 index
, scale_action
, low
, high
);
797 rs_sta
->last_txrate_idx
= index
;
798 if (sband
->band
== IEEE80211_BAND_5GHZ
)
799 info
->control
.rates
[0].idx
= rs_sta
->last_txrate_idx
-
802 info
->control
.rates
[0].idx
= rs_sta
->last_txrate_idx
;
804 IWL_DEBUG_RATE("leave: %d\n", index
);
807 #ifdef CONFIG_MAC80211_DEBUGFS
808 static int iwl3945_open_file_generic(struct inode
*inode
, struct file
*file
)
810 file
->private_data
= inode
->i_private
;
814 static ssize_t
iwl3945_sta_dbgfs_stats_table_read(struct file
*file
,
815 char __user
*user_buf
,
816 size_t count
, loff_t
*ppos
)
821 struct iwl3945_rs_sta
*lq_sta
= file
->private_data
;
823 desc
+= sprintf(buff
+ desc
, "tx packets=%d last rate index=%d\n"
824 "rate=0x%X flush time %d\n",
826 lq_sta
->last_txrate_idx
,
827 lq_sta
->start_rate
, jiffies_to_msecs(lq_sta
->flush_time
));
828 for (j
= 0; j
< IWL_RATE_COUNT
; j
++) {
829 desc
+= sprintf(buff
+desc
,
830 "counter=%d success=%d %%=%d\n",
831 lq_sta
->win
[j
].counter
,
832 lq_sta
->win
[j
].success_counter
,
833 lq_sta
->win
[j
].success_ratio
);
835 return simple_read_from_buffer(user_buf
, count
, ppos
, buff
, desc
);
838 static const struct file_operations rs_sta_dbgfs_stats_table_ops
= {
839 .read
= iwl3945_sta_dbgfs_stats_table_read
,
840 .open
= iwl3945_open_file_generic
,
843 static void iwl3945_add_debugfs(void *priv
, void *priv_sta
,
846 struct iwl3945_rs_sta
*lq_sta
= priv_sta
;
848 lq_sta
->rs_sta_dbgfs_stats_table_file
=
849 debugfs_create_file("rate_stats_table", 0600, dir
,
850 lq_sta
, &rs_sta_dbgfs_stats_table_ops
);
854 static void iwl3945_remove_debugfs(void *priv
, void *priv_sta
)
856 struct iwl3945_rs_sta
*lq_sta
= priv_sta
;
857 debugfs_remove(lq_sta
->rs_sta_dbgfs_stats_table_file
);
861 static struct rate_control_ops rs_ops
= {
864 .tx_status
= rs_tx_status
,
865 .get_rate
= rs_get_rate
,
866 .rate_init
= rs_rate_init
,
869 .alloc_sta
= rs_alloc_sta
,
870 .free_sta
= rs_free_sta
,
871 #ifdef CONFIG_MAC80211_DEBUGFS
872 .add_sta_debugfs
= iwl3945_add_debugfs
,
873 .remove_sta_debugfs
= iwl3945_remove_debugfs
,
878 void iwl3945_rate_scale_init(struct ieee80211_hw
*hw
, s32 sta_id
)
880 struct iwl3945_priv
*priv
= hw
->priv
;
883 struct iwl3945_rs_sta
*rs_sta
;
884 struct ieee80211_sta
*sta
;
885 struct iwl3945_sta_priv
*psta
;
887 IWL_DEBUG_RATE("enter\n");
891 sta
= ieee80211_find_sta(hw
, priv
->stations
[sta_id
].sta
.sta
.addr
);
897 psta
= (void *) sta
->drv_priv
;
898 rs_sta
= psta
->rs_sta
;
900 spin_lock_irqsave(&rs_sta
->lock
, flags
);
903 switch (priv
->band
) {
904 case IEEE80211_BAND_2GHZ
:
905 /* TODO: this always does G, not a regression */
906 if (priv
->active_rxon
.flags
& RXON_FLG_TGG_PROTECT_MSK
) {
908 rs_sta
->expected_tpt
= iwl3945_expected_tpt_g_prot
;
910 rs_sta
->expected_tpt
= iwl3945_expected_tpt_g
;
913 case IEEE80211_BAND_5GHZ
:
914 rs_sta
->expected_tpt
= iwl3945_expected_tpt_a
;
916 case IEEE80211_NUM_BANDS
:
921 spin_unlock_irqrestore(&rs_sta
->lock
, flags
);
923 rssi
= priv
->last_rx_rssi
;
925 rssi
= IWL_MIN_RSSI_VAL
;
927 IWL_DEBUG(IWL_DL_INFO
| IWL_DL_RATE
, "Network RSSI: %d\n", rssi
);
929 rs_sta
->start_rate
= iwl3945_get_rate_index_by_rssi(rssi
, priv
->band
);
931 IWL_DEBUG_RATE("leave: rssi %d assign rate index: "
932 "%d (plcp 0x%x)\n", rssi
, rs_sta
->start_rate
,
933 iwl3945_rates
[rs_sta
->start_rate
].plcp
);
937 int iwl3945_rate_control_register(void)
939 return ieee80211_rate_control_register(&rs_ops
);
942 void iwl3945_rate_control_unregister(void)
944 ieee80211_rate_control_unregister(&rs_ops
);