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"
42 #define RS_NAME "iwl-3945-rs"
44 struct iwl3945_rate_scale_data
{
53 struct iwl3945_rs_sta
{
55 struct iwl_priv
*priv
;
57 unsigned long last_partial_flush
;
58 unsigned long last_flush
;
66 struct timer_list rate_scale_flush
;
67 struct iwl3945_rate_scale_data win
[IWL_RATE_COUNT_3945
];
68 #ifdef CONFIG_MAC80211_DEBUGFS
69 struct dentry
*rs_sta_dbgfs_stats_table_file
;
72 /* used to be in sta_info */
76 static s32 iwl3945_expected_tpt_g
[IWL_RATE_COUNT_3945
] = {
77 7, 13, 35, 58, 0, 0, 76, 104, 130, 168, 191, 202
80 static s32 iwl3945_expected_tpt_g_prot
[IWL_RATE_COUNT_3945
] = {
81 7, 13, 35, 58, 0, 0, 0, 80, 93, 113, 123, 125
84 static s32 iwl3945_expected_tpt_a
[IWL_RATE_COUNT_3945
] = {
85 0, 0, 0, 0, 40, 57, 72, 98, 121, 154, 177, 186
88 static s32 iwl3945_expected_tpt_b
[IWL_RATE_COUNT_3945
] = {
89 7, 13, 35, 58, 0, 0, 0, 0, 0, 0, 0, 0
92 struct iwl3945_tpt_entry
{
97 static struct iwl3945_tpt_entry iwl3945_tpt_table_a
[] = {
98 {-60, IWL_RATE_54M_INDEX
},
99 {-64, IWL_RATE_48M_INDEX
},
100 {-72, IWL_RATE_36M_INDEX
},
101 {-80, IWL_RATE_24M_INDEX
},
102 {-84, IWL_RATE_18M_INDEX
},
103 {-85, IWL_RATE_12M_INDEX
},
104 {-87, IWL_RATE_9M_INDEX
},
105 {-89, IWL_RATE_6M_INDEX
}
108 static struct iwl3945_tpt_entry iwl3945_tpt_table_g
[] = {
109 {-60, IWL_RATE_54M_INDEX
},
110 {-64, IWL_RATE_48M_INDEX
},
111 {-68, IWL_RATE_36M_INDEX
},
112 {-80, IWL_RATE_24M_INDEX
},
113 {-84, IWL_RATE_18M_INDEX
},
114 {-85, IWL_RATE_12M_INDEX
},
115 {-86, IWL_RATE_11M_INDEX
},
116 {-88, IWL_RATE_5M_INDEX
},
117 {-90, IWL_RATE_2M_INDEX
},
118 {-92, IWL_RATE_1M_INDEX
}
121 #define IWL_RATE_MAX_WINDOW 62
122 #define IWL_RATE_FLUSH (3*HZ)
123 #define IWL_RATE_WIN_FLUSH (HZ/2)
124 #define IWL39_RATE_HIGH_TH 11520
125 #define IWL_SUCCESS_UP_TH 8960
126 #define IWL_SUCCESS_DOWN_TH 10880
127 #define IWL_RATE_MIN_FAILURE_TH 8
128 #define IWL_RATE_MIN_SUCCESS_TH 8
129 #define IWL_RATE_DECREASE_TH 1920
131 static u8
iwl3945_get_rate_index_by_rssi(s32 rssi
, enum ieee80211_band band
)
135 struct iwl3945_tpt_entry
*tpt_table
= NULL
;
137 if ((rssi
< IWL_MIN_RSSI_VAL
) || (rssi
> IWL_MAX_RSSI_VAL
))
138 rssi
= IWL_MIN_RSSI_VAL
;
141 case IEEE80211_BAND_2GHZ
:
142 tpt_table
= iwl3945_tpt_table_g
;
143 table_size
= ARRAY_SIZE(iwl3945_tpt_table_g
);
146 case IEEE80211_BAND_5GHZ
:
147 tpt_table
= iwl3945_tpt_table_a
;
148 table_size
= ARRAY_SIZE(iwl3945_tpt_table_a
);
156 while ((index
< table_size
) && (rssi
< tpt_table
[index
].min_rssi
))
159 index
= min(index
, (table_size
- 1));
161 return tpt_table
[index
].index
;
164 static void iwl3945_clear_window(struct iwl3945_rate_scale_data
*window
)
167 window
->success_counter
= 0;
168 window
->success_ratio
= -1;
170 window
->average_tpt
= IWL_INVALID_VALUE
;
175 * iwl3945_rate_scale_flush_windows - flush out the rate scale windows
177 * Returns the number of windows that have gathered data but were
178 * not flushed. If there were any that were not flushed, then
179 * reschedule the rate flushing routine.
181 static int iwl3945_rate_scale_flush_windows(struct iwl3945_rs_sta
*rs_sta
)
186 struct iwl_priv
*priv
= rs_sta
->priv
;
189 * For each rate, if we have collected data on that rate
190 * and it has been more than IWL_RATE_WIN_FLUSH
191 * since we flushed, clear out the gathered statistics
193 for (i
= 0; i
< IWL_RATE_COUNT_3945
; i
++) {
194 if (!rs_sta
->win
[i
].counter
)
197 spin_lock_irqsave(&rs_sta
->lock
, flags
);
198 if (time_after(jiffies
, rs_sta
->win
[i
].stamp
+
199 IWL_RATE_WIN_FLUSH
)) {
200 IWL_DEBUG_RATE("flushing %d samples of rate "
202 rs_sta
->win
[i
].counter
, i
);
203 iwl3945_clear_window(&rs_sta
->win
[i
]);
206 spin_unlock_irqrestore(&rs_sta
->lock
, flags
);
212 #define IWL_RATE_FLUSH_MAX 5000 /* msec */
213 #define IWL_RATE_FLUSH_MIN 50 /* msec */
214 #define IWL_AVERAGE_PACKETS 1500
216 static void iwl3945_bg_rate_scale_flush(unsigned long data
)
218 struct iwl3945_rs_sta
*rs_sta
= (void *)data
;
219 struct iwl_priv
*priv
= rs_sta
->priv
;
222 u32 packet_count
, duration
, pps
;
224 IWL_DEBUG_RATE("enter\n");
226 unflushed
= iwl3945_rate_scale_flush_windows(rs_sta
);
228 spin_lock_irqsave(&rs_sta
->lock
, flags
);
230 /* Number of packets Rx'd since last time this timer ran */
231 packet_count
= (rs_sta
->tx_packets
- rs_sta
->last_tx_packets
) + 1;
233 rs_sta
->last_tx_packets
= rs_sta
->tx_packets
+ 1;
237 jiffies_to_msecs(jiffies
- rs_sta
->last_partial_flush
);
239 IWL_DEBUG_RATE("Tx'd %d packets in %dms\n",
240 packet_count
, duration
);
242 /* Determine packets per second */
244 pps
= (packet_count
* 1000) / duration
;
249 duration
= (IWL_AVERAGE_PACKETS
* 1000) / pps
;
250 if (duration
< IWL_RATE_FLUSH_MIN
)
251 duration
= IWL_RATE_FLUSH_MIN
;
252 else if (duration
> IWL_RATE_FLUSH_MAX
)
253 duration
= IWL_RATE_FLUSH_MAX
;
255 duration
= IWL_RATE_FLUSH_MAX
;
257 rs_sta
->flush_time
= msecs_to_jiffies(duration
);
259 IWL_DEBUG_RATE("new flush period: %d msec ave %d\n",
260 duration
, packet_count
);
262 mod_timer(&rs_sta
->rate_scale_flush
, jiffies
+
265 rs_sta
->last_partial_flush
= jiffies
;
267 rs_sta
->flush_time
= IWL_RATE_FLUSH
;
268 rs_sta
->flush_pending
= 0;
270 /* If there weren't any unflushed entries, we don't schedule the timer
273 rs_sta
->last_flush
= jiffies
;
275 spin_unlock_irqrestore(&rs_sta
->lock
, flags
);
277 IWL_DEBUG_RATE("leave\n");
281 * iwl3945_collect_tx_data - Update the success/failure sliding window
283 * We keep a sliding window of the last 64 packets transmitted
284 * at this rate. window->data contains the bitmask of successful
287 static void iwl3945_collect_tx_data(struct iwl3945_rs_sta
*rs_sta
,
288 struct iwl3945_rate_scale_data
*window
,
289 int success
, int retries
, int index
)
293 struct iwl_priv
*priv
= rs_sta
->priv
;
296 IWL_DEBUG_RATE("leave: retries == 0 -- should be at least 1\n");
300 spin_lock_irqsave(&rs_sta
->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
;
331 fail_count
= window
->counter
- window
->success_counter
;
332 if ((fail_count
>= IWL_RATE_MIN_FAILURE_TH
) ||
333 (window
->success_counter
>= IWL_RATE_MIN_SUCCESS_TH
))
334 window
->average_tpt
= ((window
->success_ratio
*
335 rs_sta
->expected_tpt
[index
] + 64) / 128);
337 window
->average_tpt
= IWL_INVALID_VALUE
;
339 spin_unlock_irqrestore(&rs_sta
->lock
, flags
);
343 static void rs_rate_init(void *priv_r
, struct ieee80211_supported_band
*sband
,
344 struct ieee80211_sta
*sta
, void *priv_sta
)
346 struct iwl3945_rs_sta
*rs_sta
= priv_sta
;
347 struct iwl_priv
*priv
= (struct iwl_priv
*)priv_r
;
350 IWL_DEBUG_RATE("enter\n");
352 /* TODO: what is a good starting rate for STA? About middle? Maybe not
353 * the lowest or the highest rate.. Could consider using RSSI from
354 * previous packets? Need to have IEEE 802.1X auth succeed immediately
357 for (i
= sband
->n_bitrates
- 1; i
>= 0; i
--) {
358 if (sta
->supp_rates
[sband
->band
] & (1 << i
)) {
359 rs_sta
->last_txrate_idx
= i
;
364 priv
->sta_supp_rates
= sta
->supp_rates
[sband
->band
];
365 /* For 5 GHz band it start at IWL_FIRST_OFDM_RATE */
366 if (sband
->band
== IEEE80211_BAND_5GHZ
) {
367 rs_sta
->last_txrate_idx
+= IWL_FIRST_OFDM_RATE
;
368 priv
->sta_supp_rates
= priv
->sta_supp_rates
<<
373 IWL_DEBUG_RATE("leave\n");
376 static void *rs_alloc(struct ieee80211_hw
*hw
, struct dentry
*debugfsdir
)
381 /* rate scale requires free function to be implemented */
382 static void rs_free(void *priv
)
387 static void *rs_alloc_sta(void *iwl_priv
, struct ieee80211_sta
*sta
, gfp_t gfp
)
389 struct iwl3945_rs_sta
*rs_sta
;
390 struct iwl3945_sta_priv
*psta
= (void *) sta
->drv_priv
;
391 struct iwl_priv
*priv
= iwl_priv
;
395 * XXX: If it's using sta->drv_priv anyway, it might
396 * as well just put all the information there.
399 IWL_DEBUG_RATE("enter\n");
401 rs_sta
= kzalloc(sizeof(struct iwl3945_rs_sta
), gfp
);
403 IWL_DEBUG_RATE("leave: ENOMEM\n");
407 psta
->rs_sta
= rs_sta
;
409 spin_lock_init(&rs_sta
->lock
);
413 rs_sta
->start_rate
= IWL_RATE_INVALID
;
415 /* default to just 802.11b */
416 rs_sta
->expected_tpt
= iwl3945_expected_tpt_b
;
418 rs_sta
->last_partial_flush
= jiffies
;
419 rs_sta
->last_flush
= jiffies
;
420 rs_sta
->flush_time
= IWL_RATE_FLUSH
;
421 rs_sta
->last_tx_packets
= 0;
422 rs_sta
->ibss_sta_added
= 0;
424 init_timer(&rs_sta
->rate_scale_flush
);
425 rs_sta
->rate_scale_flush
.data
= (unsigned long)rs_sta
;
426 rs_sta
->rate_scale_flush
.function
= &iwl3945_bg_rate_scale_flush
;
428 for (i
= 0; i
< IWL_RATE_COUNT_3945
; i
++)
429 iwl3945_clear_window(&rs_sta
->win
[i
]);
431 IWL_DEBUG_RATE("leave\n");
436 static void rs_free_sta(void *iwl_priv
, struct ieee80211_sta
*sta
,
439 struct iwl3945_sta_priv
*psta
= (void *) sta
->drv_priv
;
440 struct iwl3945_rs_sta
*rs_sta
= priv_sta
;
441 struct iwl_priv
*priv
= rs_sta
->priv
;
445 IWL_DEBUG_RATE("enter\n");
446 del_timer_sync(&rs_sta
->rate_scale_flush
);
448 IWL_DEBUG_RATE("leave\n");
453 * rs_tx_status - Update rate control values based on Tx results
455 * NOTE: Uses iwl_priv->retry_rate for the # of retries attempted by
456 * the hardware for each rate.
458 static void rs_tx_status(void *priv_rate
, struct ieee80211_supported_band
*sband
,
459 struct ieee80211_sta
*sta
, void *priv_sta
,
462 s8 retries
= 0, current_count
;
463 int scale_rate_index
, first_index
, last_index
;
465 struct iwl_priv
*priv
= (struct iwl_priv
*)priv_rate
;
466 struct iwl3945_rs_sta
*rs_sta
= priv_sta
;
467 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
469 IWL_DEBUG_RATE("enter\n");
471 retries
= info
->status
.rates
[0].count
;
473 first_index
= sband
->bitrates
[info
->status
.rates
[0].idx
].hw_value
;
474 if ((first_index
< 0) || (first_index
>= IWL_RATE_COUNT_3945
)) {
475 IWL_DEBUG_RATE("leave: Rate out of bounds: %d\n", first_index
);
480 IWL_DEBUG_RATE("leave: No STA priv data to update!\n");
484 rs_sta
->tx_packets
++;
486 scale_rate_index
= first_index
;
487 last_index
= first_index
;
490 * Update the window for each rate. We determine which rates
491 * were Tx'd based on the total number of retries vs. the number
492 * of retries configured for each rate -- currently set to the
493 * priv value 'retry_rate' vs. rate specific
495 * On exit from this while loop last_index indicates the rate
496 * at which the frame was finally transmitted (or failed if no
499 while (retries
> 1) {
500 if ((retries
- 1) < priv
->retry_rate
) {
501 current_count
= (retries
- 1);
502 last_index
= scale_rate_index
;
504 current_count
= priv
->retry_rate
;
505 last_index
= iwl3945_rs_next_rate(priv
,
509 /* Update this rate accounting for as many retries
510 * as was used for it (per current_count) */
511 iwl3945_collect_tx_data(rs_sta
,
512 &rs_sta
->win
[scale_rate_index
],
513 0, current_count
, scale_rate_index
);
514 IWL_DEBUG_RATE("Update rate %d for %d retries.\n",
515 scale_rate_index
, current_count
);
517 retries
-= current_count
;
519 scale_rate_index
= last_index
;
523 /* Update the last index window with success/failure based on ACK */
524 IWL_DEBUG_RATE("Update rate %d with %s.\n",
526 (info
->flags
& IEEE80211_TX_STAT_ACK
) ?
527 "success" : "failure");
528 iwl3945_collect_tx_data(rs_sta
,
529 &rs_sta
->win
[last_index
],
530 info
->flags
& IEEE80211_TX_STAT_ACK
, 1, last_index
);
532 /* We updated the rate scale window -- if its been more than
533 * flush_time since the last run, schedule the flush
535 spin_lock_irqsave(&rs_sta
->lock
, flags
);
537 if (!rs_sta
->flush_pending
&&
538 time_after(jiffies
, rs_sta
->last_flush
+
539 rs_sta
->flush_time
)) {
541 rs_sta
->last_partial_flush
= jiffies
;
542 rs_sta
->flush_pending
= 1;
543 mod_timer(&rs_sta
->rate_scale_flush
,
544 jiffies
+ rs_sta
->flush_time
);
547 spin_unlock_irqrestore(&rs_sta
->lock
, flags
);
549 IWL_DEBUG_RATE("leave\n");
554 static u16
iwl3945_get_adjacent_rate(struct iwl3945_rs_sta
*rs_sta
,
555 u8 index
, u16 rate_mask
, enum ieee80211_band band
)
557 u8 high
= IWL_RATE_INVALID
;
558 u8 low
= IWL_RATE_INVALID
;
559 struct iwl_priv
*priv
= rs_sta
->priv
;
561 /* 802.11A walks to the next literal adjacent rate in
563 if (unlikely(band
== IEEE80211_BAND_5GHZ
)) {
567 /* Find the previous rate that is in the rate mask */
569 for (mask
= (1 << i
); i
>= 0; i
--, mask
>>= 1) {
570 if (rate_mask
& mask
) {
576 /* Find the next rate that is in the rate mask */
578 for (mask
= (1 << i
); i
< IWL_RATE_COUNT_3945
;
580 if (rate_mask
& mask
) {
586 return (high
<< 8) | low
;
590 while (low
!= IWL_RATE_INVALID
) {
592 low
= iwl3945_rates
[low
].prev_rs_tgg
;
594 low
= iwl3945_rates
[low
].prev_rs
;
595 if (low
== IWL_RATE_INVALID
)
597 if (rate_mask
& (1 << low
))
599 IWL_DEBUG_RATE("Skipping masked lower rate: %d\n", low
);
603 while (high
!= IWL_RATE_INVALID
) {
605 high
= iwl3945_rates
[high
].next_rs_tgg
;
607 high
= iwl3945_rates
[high
].next_rs
;
608 if (high
== IWL_RATE_INVALID
)
610 if (rate_mask
& (1 << high
))
612 IWL_DEBUG_RATE("Skipping masked higher rate: %d\n", high
);
615 return (high
<< 8) | low
;
619 * rs_get_rate - find the rate for the requested packet
621 * Returns the ieee80211_rate structure allocated by the driver.
623 * The rate control algorithm has no internal mapping between hw_mode's
624 * rate ordering and the rate ordering used by the rate control algorithm.
626 * The rate control algorithm uses a single table of rates that goes across
627 * the entire A/B/G spectrum vs. being limited to just one particular
630 * As such, we can't convert the index obtained below into the hw_mode's
631 * rate table and must reference the driver allocated rate table
634 static void rs_get_rate(void *priv_r
, struct ieee80211_sta
*sta
,
635 void *priv_sta
, struct ieee80211_tx_rate_control
*txrc
)
637 struct ieee80211_supported_band
*sband
= txrc
->sband
;
638 struct sk_buff
*skb
= txrc
->skb
;
639 u8 low
= IWL_RATE_INVALID
;
640 u8 high
= IWL_RATE_INVALID
;
643 struct iwl3945_rs_sta
*rs_sta
= priv_sta
;
644 struct iwl3945_rate_scale_data
*window
= NULL
;
645 int current_tpt
= IWL_INVALID_VALUE
;
646 int low_tpt
= IWL_INVALID_VALUE
;
647 int high_tpt
= IWL_INVALID_VALUE
;
651 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)skb
->data
;
654 struct iwl_priv
*priv
= (struct iwl_priv
*)priv_r
;
655 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
657 IWL_DEBUG_RATE("enter\n");
660 rate_mask
= sta
->supp_rates
[sband
->band
];
662 /* Send management frames and broadcast/multicast data using lowest
664 fc
= le16_to_cpu(hdr
->frame_control
);
665 if ((fc
& IEEE80211_FCTL_FTYPE
) != IEEE80211_FTYPE_DATA
||
666 is_multicast_ether_addr(hdr
->addr1
) ||
668 IWL_DEBUG_RATE("leave: No STA priv data to update!\n");
670 info
->control
.rates
[0].idx
=
671 rate_lowest_index(sband
, NULL
);
673 info
->control
.rates
[0].idx
=
674 rate_lowest_index(sband
, sta
);
678 index
= min(rs_sta
->last_txrate_idx
& 0xffff, IWL_RATE_COUNT_3945
- 1);
680 if (sband
->band
== IEEE80211_BAND_5GHZ
)
681 rate_mask
= rate_mask
<< IWL_FIRST_OFDM_RATE
;
683 if ((priv
->iw_mode
== NL80211_IFTYPE_ADHOC
) &&
684 !rs_sta
->ibss_sta_added
) {
685 u8 sta_id
= iwl3945_hw_find_station(priv
, hdr
->addr1
);
687 if (sta_id
== IWL_INVALID_STATION
) {
688 IWL_DEBUG_RATE("LQ: ADD station %pm\n",
690 sta_id
= iwl3945_add_station(priv
,
691 hdr
->addr1
, 0, CMD_ASYNC
);
693 if (sta_id
!= IWL_INVALID_STATION
)
694 rs_sta
->ibss_sta_added
= 1;
697 spin_lock_irqsave(&rs_sta
->lock
, flags
);
699 /* for recent assoc, choose best rate regarding
702 if (rs_sta
->start_rate
!= IWL_RATE_INVALID
) {
703 if (rs_sta
->start_rate
< index
&&
704 (rate_mask
& (1 << rs_sta
->start_rate
)))
705 index
= rs_sta
->start_rate
;
706 rs_sta
->start_rate
= IWL_RATE_INVALID
;
709 window
= &(rs_sta
->win
[index
]);
711 fail_count
= window
->counter
- window
->success_counter
;
713 if (((fail_count
<= IWL_RATE_MIN_FAILURE_TH
) &&
714 (window
->success_counter
< IWL_RATE_MIN_SUCCESS_TH
))) {
715 spin_unlock_irqrestore(&rs_sta
->lock
, flags
);
717 IWL_DEBUG_RATE("Invalid average_tpt on rate %d: "
718 "counter: %d, success_counter: %d, "
719 "expected_tpt is %sNULL\n",
722 window
->success_counter
,
723 rs_sta
->expected_tpt
? "not " : "");
728 current_tpt
= window
->average_tpt
;
730 high_low
= iwl3945_get_adjacent_rate(rs_sta
, index
, rate_mask
,
732 low
= high_low
& 0xff;
733 high
= (high_low
>> 8) & 0xff;
735 if (low
!= IWL_RATE_INVALID
)
736 low_tpt
= rs_sta
->win
[low
].average_tpt
;
738 if (high
!= IWL_RATE_INVALID
)
739 high_tpt
= rs_sta
->win
[high
].average_tpt
;
741 spin_unlock_irqrestore(&rs_sta
->lock
, flags
);
745 if ((window
->success_ratio
< IWL_RATE_DECREASE_TH
) || !current_tpt
) {
746 IWL_DEBUG_RATE("decrease rate because of low success_ratio\n");
748 } else if ((low_tpt
== IWL_INVALID_VALUE
) &&
749 (high_tpt
== IWL_INVALID_VALUE
))
751 else if ((low_tpt
!= IWL_INVALID_VALUE
) &&
752 (high_tpt
!= IWL_INVALID_VALUE
) &&
753 (low_tpt
< current_tpt
) && (high_tpt
< current_tpt
)) {
754 IWL_DEBUG_RATE("No action -- low [%d] & high [%d] < "
755 "current_tpt [%d]\n",
756 low_tpt
, high_tpt
, current_tpt
);
759 if (high_tpt
!= IWL_INVALID_VALUE
) {
760 if (high_tpt
> current_tpt
)
764 ("decrease rate because of high tpt\n");
767 } else if (low_tpt
!= IWL_INVALID_VALUE
) {
768 if (low_tpt
> current_tpt
) {
770 ("decrease rate because of low tpt\n");
777 if (scale_action
== -1) {
778 if (window
->success_ratio
> IWL_SUCCESS_DOWN_TH
)
780 } else if (scale_action
== 1) {
781 if (window
->success_ratio
< IWL_SUCCESS_UP_TH
) {
782 IWL_DEBUG_RATE("No action -- success_ratio [%d] < "
783 "SUCCESS UP\n", window
->success_ratio
);
788 switch (scale_action
) {
790 if (low
!= IWL_RATE_INVALID
)
795 if (high
!= IWL_RATE_INVALID
)
805 IWL_DEBUG_RATE("Selected %d (action %d) - low %d high %d\n",
806 index
, scale_action
, low
, high
);
810 rs_sta
->last_txrate_idx
= index
;
811 if (sband
->band
== IEEE80211_BAND_5GHZ
)
812 info
->control
.rates
[0].idx
= rs_sta
->last_txrate_idx
-
815 info
->control
.rates
[0].idx
= rs_sta
->last_txrate_idx
;
817 IWL_DEBUG_RATE("leave: %d\n", index
);
820 #ifdef CONFIG_MAC80211_DEBUGFS
821 static int iwl3945_open_file_generic(struct inode
*inode
, struct file
*file
)
823 file
->private_data
= inode
->i_private
;
827 static ssize_t
iwl3945_sta_dbgfs_stats_table_read(struct file
*file
,
828 char __user
*user_buf
,
829 size_t count
, loff_t
*ppos
)
834 struct iwl3945_rs_sta
*lq_sta
= file
->private_data
;
836 desc
+= sprintf(buff
+ desc
, "tx packets=%d last rate index=%d\n"
837 "rate=0x%X flush time %d\n",
839 lq_sta
->last_txrate_idx
,
840 lq_sta
->start_rate
, jiffies_to_msecs(lq_sta
->flush_time
));
841 for (j
= 0; j
< IWL_RATE_COUNT_3945
; j
++) {
842 desc
+= sprintf(buff
+desc
,
843 "counter=%d success=%d %%=%d\n",
844 lq_sta
->win
[j
].counter
,
845 lq_sta
->win
[j
].success_counter
,
846 lq_sta
->win
[j
].success_ratio
);
848 return simple_read_from_buffer(user_buf
, count
, ppos
, buff
, desc
);
851 static const struct file_operations rs_sta_dbgfs_stats_table_ops
= {
852 .read
= iwl3945_sta_dbgfs_stats_table_read
,
853 .open
= iwl3945_open_file_generic
,
856 static void iwl3945_add_debugfs(void *priv
, void *priv_sta
,
859 struct iwl3945_rs_sta
*lq_sta
= priv_sta
;
861 lq_sta
->rs_sta_dbgfs_stats_table_file
=
862 debugfs_create_file("rate_stats_table", 0600, dir
,
863 lq_sta
, &rs_sta_dbgfs_stats_table_ops
);
867 static void iwl3945_remove_debugfs(void *priv
, void *priv_sta
)
869 struct iwl3945_rs_sta
*lq_sta
= priv_sta
;
870 debugfs_remove(lq_sta
->rs_sta_dbgfs_stats_table_file
);
874 static struct rate_control_ops rs_ops
= {
877 .tx_status
= rs_tx_status
,
878 .get_rate
= rs_get_rate
,
879 .rate_init
= rs_rate_init
,
882 .alloc_sta
= rs_alloc_sta
,
883 .free_sta
= rs_free_sta
,
884 #ifdef CONFIG_MAC80211_DEBUGFS
885 .add_sta_debugfs
= iwl3945_add_debugfs
,
886 .remove_sta_debugfs
= iwl3945_remove_debugfs
,
891 void iwl3945_rate_scale_init(struct ieee80211_hw
*hw
, s32 sta_id
)
893 struct iwl_priv
*priv
= hw
->priv
;
896 struct iwl3945_rs_sta
*rs_sta
;
897 struct ieee80211_sta
*sta
;
898 struct iwl3945_sta_priv
*psta
;
900 IWL_DEBUG_RATE("enter\n");
904 sta
= ieee80211_find_sta(hw
, priv
->stations_39
[sta_id
].sta
.sta
.addr
);
910 psta
= (void *) sta
->drv_priv
;
911 rs_sta
= psta
->rs_sta
;
913 spin_lock_irqsave(&rs_sta
->lock
, flags
);
916 switch (priv
->band
) {
917 case IEEE80211_BAND_2GHZ
:
918 /* TODO: this always does G, not a regression */
919 if (priv
->active39_rxon
.flags
& RXON_FLG_TGG_PROTECT_MSK
) {
921 rs_sta
->expected_tpt
= iwl3945_expected_tpt_g_prot
;
923 rs_sta
->expected_tpt
= iwl3945_expected_tpt_g
;
926 case IEEE80211_BAND_5GHZ
:
927 rs_sta
->expected_tpt
= iwl3945_expected_tpt_a
;
929 case IEEE80211_NUM_BANDS
:
934 spin_unlock_irqrestore(&rs_sta
->lock
, flags
);
936 rssi
= priv
->last_rx_rssi
;
938 rssi
= IWL_MIN_RSSI_VAL
;
940 IWL_DEBUG(IWL_DL_INFO
| IWL_DL_RATE
, "Network RSSI: %d\n", rssi
);
942 rs_sta
->start_rate
= iwl3945_get_rate_index_by_rssi(rssi
, priv
->band
);
944 IWL_DEBUG_RATE("leave: rssi %d assign rate index: "
945 "%d (plcp 0x%x)\n", rssi
, rs_sta
->start_rate
,
946 iwl3945_rates
[rs_sta
->start_rate
].plcp
);
950 int iwl3945_rate_control_register(void)
952 return ieee80211_rate_control_register(&rs_ops
);
955 void iwl3945_rate_control_unregister(void)
957 ieee80211_rate_control_unregister(&rs_ops
);