2 * Copyright (c) 2004 Video54 Technologies, Inc.
3 * Copyright (c) 2004-2008 Atheros Communications, Inc.
5 * Permission to use, copy, modify, and/or distribute this software for any
6 * purpose with or without fee is hereby granted, provided that the above
7 * copyright notice and this permission notice appear in all copies.
9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19 * Atheros rate control algorithm
23 #include "../net/mac80211/rate.h"
25 static u_int32_t tx_triglevel_max
;
27 static struct ath_rate_table ar5416_11na_ratetable
= {
30 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 6000, /* 6 Mb */
32 0, 2, 1, 0, 0, 0, 0, 0 },
33 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 9000, /* 9 Mb */
35 0, 3, 1, 1, 1, 1, 1, 0 },
36 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 12000, /* 12 Mb */
37 10000, 0x0a, 0x00, 24,
38 2, 4, 2, 2, 2, 2, 2, 0 },
39 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 18000, /* 18 Mb */
40 13900, 0x0e, 0x00, 36,
41 2, 6, 2, 3, 3, 3, 3, 0 },
42 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 24000, /* 24 Mb */
43 17300, 0x09, 0x00, 48,
44 4, 10, 3, 4, 4, 4, 4, 0 },
45 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 36000, /* 36 Mb */
46 23000, 0x0d, 0x00, 72,
47 4, 14, 3, 5, 5, 5, 5, 0 },
48 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 48000, /* 48 Mb */
49 27400, 0x08, 0x00, 96,
50 4, 20, 3, 6, 6, 6, 6, 0 },
51 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 54000, /* 54 Mb */
52 29300, 0x0c, 0x00, 108,
53 4, 23, 3, 7, 7, 7, 7, 0 },
54 { TRUE_20
, TRUE_20
, WLAN_PHY_HT_20_SS
, 6500, /* 6.5 Mb */
56 0, 2, 3, 8, 24, 8, 24, 3216 },
57 { TRUE_20
, TRUE_20
, WLAN_PHY_HT_20_SS
, 13000, /* 13 Mb */
59 2, 4, 3, 9, 25, 9, 25, 6434 },
60 { TRUE_20
, TRUE_20
, WLAN_PHY_HT_20_SS
, 19500, /* 19.5 Mb */
62 2, 6, 3, 10, 26, 10, 26, 9650 },
63 { TRUE_20
, TRUE_20
, WLAN_PHY_HT_20_SS
, 26000, /* 26 Mb */
65 4, 10, 3, 11, 27, 11, 27, 12868 },
66 { TRUE_20
, TRUE_20
, WLAN_PHY_HT_20_SS
, 39000, /* 39 Mb */
68 4, 14, 3, 12, 28, 12, 28, 19304 },
69 { FALSE
, TRUE_20
, WLAN_PHY_HT_20_SS
, 52000, /* 52 Mb */
71 4, 20, 3, 13, 29, 13, 29, 25740 },
72 { FALSE
, TRUE_20
, WLAN_PHY_HT_20_SS
, 58500, /* 58.5 Mb */
74 4, 23, 3, 14, 30, 14, 30, 28956 },
75 { FALSE
, TRUE_20
, WLAN_PHY_HT_20_SS
, 65000, /* 65 Mb */
77 4, 25, 3, 15, 31, 15, 32, 32180 },
78 { FALSE
, FALSE
, WLAN_PHY_HT_20_DS
, 13000, /* 13 Mb */
80 8, 0, 2, 3, 16, 33, 16, 33, 6430 },
81 { FALSE
, FALSE
, WLAN_PHY_HT_20_DS
, 26000, /* 26 Mb */
83 2, 4, 3, 17, 34, 17, 34, 12860 },
84 { FALSE
, FALSE
, WLAN_PHY_HT_20_DS
, 39000, /* 39 Mb */
85 36600, 0x8a, 0x00, 10,
86 2, 6, 3, 18, 35, 18, 35, 19300 },
87 { TRUE_20
, FALSE
, WLAN_PHY_HT_20_DS
, 52000, /* 52 Mb */
88 48100, 0x8b, 0x00, 11,
89 4, 10, 3, 19, 36, 19, 36, 25736 },
90 { TRUE_20
, FALSE
, WLAN_PHY_HT_20_DS
, 78000, /* 78 Mb */
91 69500, 0x8c, 0x00, 12,
92 4, 14, 3, 20, 37, 20, 37, 38600 },
93 { TRUE_20
, FALSE
, WLAN_PHY_HT_20_DS
, 104000, /* 104 Mb */
94 89500, 0x8d, 0x00, 13,
95 4, 20, 3, 21, 38, 21, 38, 51472 },
96 { TRUE_20
, FALSE
, WLAN_PHY_HT_20_DS
, 117000, /* 117 Mb */
97 98900, 0x8e, 0x00, 14,
98 4, 23, 3, 22, 39, 22, 39, 57890 },
99 { TRUE_20
, FALSE
, WLAN_PHY_HT_20_DS
, 130000, /* 130 Mb */
100 108300, 0x8f, 0x00, 15,
101 4, 25, 3, 23, 40, 23, 41, 64320 },
102 { TRUE_40
, TRUE_40
, WLAN_PHY_HT_40_SS
, 13500, /* 13.5 Mb */
103 13200, 0x80, 0x00, 0,
104 0, 2, 3, 8, 24, 24, 24, 6684 },
105 { TRUE_40
, TRUE_40
, WLAN_PHY_HT_40_SS
, 27500, /* 27.0 Mb */
106 25900, 0x81, 0x00, 1,
107 2, 4, 3, 9, 25, 25, 25, 13368 },
108 { TRUE_40
, TRUE_40
, WLAN_PHY_HT_40_SS
, 40500, /* 40.5 Mb */
109 38600, 0x82, 0x00, 2,
110 2, 6, 3, 10, 26, 26, 26, 20052 },
111 { TRUE_40
, TRUE_40
, WLAN_PHY_HT_40_SS
, 54000, /* 54 Mb */
112 49800, 0x83, 0x00, 3,
113 4, 10, 3, 11, 27, 27, 27, 26738 },
114 { TRUE_40
, TRUE_40
, WLAN_PHY_HT_40_SS
, 81500, /* 81 Mb */
115 72200, 0x84, 0x00, 4,
116 4, 14, 3, 12, 28, 28, 28, 40104 },
117 { FALSE
, TRUE_40
, WLAN_PHY_HT_40_SS
, 108000, /* 108 Mb */
118 92900, 0x85, 0x00, 5,
119 4, 20, 3, 13, 29, 29, 29, 53476 },
120 { FALSE
, TRUE_40
, WLAN_PHY_HT_40_SS
, 121500, /* 121.5 Mb */
121 102700, 0x86, 0x00, 6,
122 4, 23, 3, 14, 30, 30, 30, 60156 },
123 { FALSE
, TRUE_40
, WLAN_PHY_HT_40_SS
, 135000, /* 135 Mb */
124 112000, 0x87, 0x00, 7,
125 4, 25, 3, 15, 31, 32, 32, 66840 },
126 { FALSE
, TRUE_40
, WLAN_PHY_HT_40_SS_HGI
, 150000, /* 150 Mb */
127 122000, 0x87, 0x00, 7,
128 4, 25, 3, 15, 31, 32, 32, 74200 },
129 { FALSE
, FALSE
, WLAN_PHY_HT_40_DS
, 27000, /* 27 Mb */
130 25800, 0x88, 0x00, 8,
131 0, 2, 3, 16, 33, 33, 33, 13360 },
132 { FALSE
, FALSE
, WLAN_PHY_HT_40_DS
, 54000, /* 54 Mb */
133 49800, 0x89, 0x00, 9,
134 2, 4, 3, 17, 34, 34, 34, 26720 },
135 { FALSE
, FALSE
, WLAN_PHY_HT_40_DS
, 81000, /* 81 Mb */
136 71900, 0x8a, 0x00, 10,
137 2, 6, 3, 18, 35, 35, 35, 40080 },
138 { TRUE_40
, FALSE
, WLAN_PHY_HT_40_DS
, 108000, /* 108 Mb */
139 92500, 0x8b, 0x00, 11,
140 4, 10, 3, 19, 36, 36, 36, 53440 },
141 { TRUE_40
, FALSE
, WLAN_PHY_HT_40_DS
, 162000, /* 162 Mb */
142 130300, 0x8c, 0x00, 12,
143 4, 14, 3, 20, 37, 37, 37, 80160 },
144 { TRUE_40
, FALSE
, WLAN_PHY_HT_40_DS
, 216000, /* 216 Mb */
145 162800, 0x8d, 0x00, 13,
146 4, 20, 3, 21, 38, 38, 38, 106880 },
147 { TRUE_40
, FALSE
, WLAN_PHY_HT_40_DS
, 243000, /* 243 Mb */
148 178200, 0x8e, 0x00, 14,
149 4, 23, 3, 22, 39, 39, 39, 120240 },
150 { TRUE_40
, FALSE
, WLAN_PHY_HT_40_DS
, 270000, /* 270 Mb */
151 192100, 0x8f, 0x00, 15,
152 4, 25, 3, 23, 40, 41, 41, 133600 },
153 { TRUE_40
, FALSE
, WLAN_PHY_HT_40_DS_HGI
, 300000, /* 300 Mb */
154 207000, 0x8f, 0x00, 15,
155 4, 25, 3, 23, 40, 41, 41, 148400 },
157 50, /* probe interval */
158 50, /* rssi reduce interval */
159 WLAN_RC_HT_FLAG
, /* Phy rates allowed initially */
162 /* TRUE_ALL - valid for 20/40/Legacy,
163 * TRUE - Legacy only,
164 * TRUE_20 - HT 20 only,
165 * TRUE_40 - HT 40 only */
167 /* 4ms frame limit not used for NG mode. The values filled
168 * for HT are the 64K max aggregate limit */
170 static struct ath_rate_table ar5416_11ng_ratetable
= {
173 { TRUE_ALL
, TRUE_ALL
, WLAN_PHY_CCK
, 1000, /* 1 Mb */
175 0, 0, 1, 0, 0, 0, 0, 0 },
176 { TRUE_ALL
, TRUE_ALL
, WLAN_PHY_CCK
, 2000, /* 2 Mb */
178 1, 1, 1, 1, 1, 1, 1, 0 },
179 { TRUE_ALL
, TRUE_ALL
, WLAN_PHY_CCK
, 5500, /* 5.5 Mb */
180 4900, 0x19, 0x04, 11,
181 2, 2, 2, 2, 2, 2, 2, 0 },
182 { TRUE_ALL
, TRUE_ALL
, WLAN_PHY_CCK
, 11000, /* 11 Mb */
183 8100, 0x18, 0x04, 22,
184 3, 3, 2, 3, 3, 3, 3, 0 },
185 { FALSE
, FALSE
, WLAN_PHY_OFDM
, 6000, /* 6 Mb */
186 5400, 0x0b, 0x00, 12,
187 4, 2, 1, 4, 4, 4, 4, 0 },
188 { FALSE
, FALSE
, WLAN_PHY_OFDM
, 9000, /* 9 Mb */
189 7800, 0x0f, 0x00, 18,
190 4, 3, 1, 5, 5, 5, 5, 0 },
191 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 12000, /* 12 Mb */
192 10100, 0x0a, 0x00, 24,
193 6, 4, 1, 6, 6, 6, 6, 0 },
194 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 18000, /* 18 Mb */
195 14100, 0x0e, 0x00, 36,
196 6, 6, 2, 7, 7, 7, 7, 0 },
197 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 24000, /* 24 Mb */
198 17700, 0x09, 0x00, 48,
199 8, 10, 3, 8, 8, 8, 8, 0 },
200 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 36000, /* 36 Mb */
201 23700, 0x0d, 0x00, 72,
202 8, 14, 3, 9, 9, 9, 9, 0 },
203 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 48000, /* 48 Mb */
204 27400, 0x08, 0x00, 96,
205 8, 20, 3, 10, 10, 10, 10, 0 },
206 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 54000, /* 54 Mb */
207 30900, 0x0c, 0x00, 108,
208 8, 23, 3, 11, 11, 11, 11, 0 },
209 { FALSE
, FALSE
, WLAN_PHY_HT_20_SS
, 6500, /* 6.5 Mb */
211 4, 2, 3, 12, 28, 12, 28, 3216 },
212 { TRUE_20
, TRUE_20
, WLAN_PHY_HT_20_SS
, 13000, /* 13 Mb */
213 12700, 0x81, 0x00, 1,
214 6, 4, 3, 13, 29, 13, 29, 6434 },
215 { TRUE_20
, TRUE_20
, WLAN_PHY_HT_20_SS
, 19500, /* 19.5 Mb */
216 18800, 0x82, 0x00, 2,
217 6, 6, 3, 14, 30, 14, 30, 9650 },
218 { TRUE_20
, TRUE_20
, WLAN_PHY_HT_20_SS
, 26000, /* 26 Mb */
219 25000, 0x83, 0x00, 3,
220 8, 10, 3, 15, 31, 15, 31, 12868 },
221 { TRUE_20
, TRUE_20
, WLAN_PHY_HT_20_SS
, 39000, /* 39 Mb */
222 36700, 0x84, 0x00, 4,
223 8, 14, 3, 16, 32, 16, 32, 19304 },
224 { FALSE
, TRUE_20
, WLAN_PHY_HT_20_SS
, 52000, /* 52 Mb */
225 48100, 0x85, 0x00, 5,
226 8, 20, 3, 17, 33, 17, 33, 25740 },
227 { FALSE
, TRUE_20
, WLAN_PHY_HT_20_SS
, 58500, /* 58.5 Mb */
228 53500, 0x86, 0x00, 6,
229 8, 23, 3, 18, 34, 18, 34, 28956 },
230 { FALSE
, TRUE_20
, WLAN_PHY_HT_20_SS
, 65000, /* 65 Mb */
231 59000, 0x87, 0x00, 7,
232 8, 25, 3, 19, 35, 19, 36, 32180 },
233 { FALSE
, FALSE
, WLAN_PHY_HT_20_DS
, 13000, /* 13 Mb */
234 12700, 0x88, 0x00, 8,
235 4, 2, 3, 20, 37, 20, 37, 6430 },
236 { FALSE
, FALSE
, WLAN_PHY_HT_20_DS
, 26000, /* 26 Mb */
237 24800, 0x89, 0x00, 9,
238 6, 4, 3, 21, 38, 21, 38, 12860 },
239 { FALSE
, FALSE
, WLAN_PHY_HT_20_DS
, 39000, /* 39 Mb */
240 36600, 0x8a, 0x00, 10,
241 6, 6, 3, 22, 39, 22, 39, 19300 },
242 { TRUE_20
, FALSE
, WLAN_PHY_HT_20_DS
, 52000, /* 52 Mb */
243 48100, 0x8b, 0x00, 11,
244 8, 10, 3, 23, 40, 23, 40, 25736 },
245 { TRUE_20
, FALSE
, WLAN_PHY_HT_20_DS
, 78000, /* 78 Mb */
246 69500, 0x8c, 0x00, 12,
247 8, 14, 3, 24, 41, 24, 41, 38600 },
248 { TRUE_20
, FALSE
, WLAN_PHY_HT_20_DS
, 104000, /* 104 Mb */
249 89500, 0x8d, 0x00, 13,
250 8, 20, 3, 25, 42, 25, 42, 51472 },
251 { TRUE_20
, FALSE
, WLAN_PHY_HT_20_DS
, 117000, /* 117 Mb */
252 98900, 0x8e, 0x00, 14,
253 8, 23, 3, 26, 43, 26, 44, 57890 },
254 { TRUE_20
, FALSE
, WLAN_PHY_HT_20_DS
, 130000, /* 130 Mb */
255 108300, 0x8f, 0x00, 15,
256 8, 25, 3, 27, 44, 27, 45, 64320 },
257 { TRUE_40
, TRUE_40
, WLAN_PHY_HT_40_SS
, 13500, /* 13.5 Mb */
258 13200, 0x80, 0x00, 0,
259 8, 2, 3, 12, 28, 28, 28, 6684 },
260 { TRUE_40
, TRUE_40
, WLAN_PHY_HT_40_SS
, 27500, /* 27.0 Mb */
261 25900, 0x81, 0x00, 1,
262 8, 4, 3, 13, 29, 29, 29, 13368 },
263 { TRUE_40
, TRUE_40
, WLAN_PHY_HT_40_SS
, 40500, /* 40.5 Mb */
264 38600, 0x82, 0x00, 2,
265 8, 6, 3, 14, 30, 30, 30, 20052 },
266 { TRUE_40
, TRUE_40
, WLAN_PHY_HT_40_SS
, 54000, /* 54 Mb */
267 49800, 0x83, 0x00, 3,
268 8, 10, 3, 15, 31, 31, 31, 26738 },
269 { TRUE_40
, TRUE_40
, WLAN_PHY_HT_40_SS
, 81500, /* 81 Mb */
270 72200, 0x84, 0x00, 4,
271 8, 14, 3, 16, 32, 32, 32, 40104 },
272 { FALSE
, TRUE_40
, WLAN_PHY_HT_40_SS
, 108000, /* 108 Mb */
273 92900, 0x85, 0x00, 5,
274 8, 20, 3, 17, 33, 33, 33, 53476 },
275 { FALSE
, TRUE_40
, WLAN_PHY_HT_40_SS
, 121500, /* 121.5 Mb */
276 102700, 0x86, 0x00, 6,
277 8, 23, 3, 18, 34, 34, 34, 60156 },
278 { FALSE
, TRUE_40
, WLAN_PHY_HT_40_SS
, 135000, /* 135 Mb */
279 112000, 0x87, 0x00, 7,
280 8, 23, 3, 19, 35, 36, 36, 66840 },
281 { FALSE
, TRUE_40
, WLAN_PHY_HT_40_SS_HGI
, 150000, /* 150 Mb */
282 122000, 0x87, 0x00, 7,
283 8, 25, 3, 19, 35, 36, 36, 74200 },
284 { FALSE
, FALSE
, WLAN_PHY_HT_40_DS
, 27000, /* 27 Mb */
285 25800, 0x88, 0x00, 8,
286 8, 2, 3, 20, 37, 37, 37, 13360 },
287 { FALSE
, FALSE
, WLAN_PHY_HT_40_DS
, 54000, /* 54 Mb */
288 49800, 0x89, 0x00, 9,
289 8, 4, 3, 21, 38, 38, 38, 26720 },
290 { FALSE
, FALSE
, WLAN_PHY_HT_40_DS
, 81000, /* 81 Mb */
291 71900, 0x8a, 0x00, 10,
292 8, 6, 3, 22, 39, 39, 39, 40080 },
293 { TRUE_40
, FALSE
, WLAN_PHY_HT_40_DS
, 108000, /* 108 Mb */
294 92500, 0x8b, 0x00, 11,
295 8, 10, 3, 23, 40, 40, 40, 53440 },
296 { TRUE_40
, FALSE
, WLAN_PHY_HT_40_DS
, 162000, /* 162 Mb */
297 130300, 0x8c, 0x00, 12,
298 8, 14, 3, 24, 41, 41, 41, 80160 },
299 { TRUE_40
, FALSE
, WLAN_PHY_HT_40_DS
, 216000, /* 216 Mb */
300 162800, 0x8d, 0x00, 13,
301 8, 20, 3, 25, 42, 42, 42, 106880 },
302 { TRUE_40
, FALSE
, WLAN_PHY_HT_40_DS
, 243000, /* 243 Mb */
303 178200, 0x8e, 0x00, 14,
304 8, 23, 3, 26, 43, 43, 43, 120240 },
305 { TRUE_40
, FALSE
, WLAN_PHY_HT_40_DS
, 270000, /* 270 Mb */
306 192100, 0x8f, 0x00, 15,
307 8, 23, 3, 27, 44, 45, 45, 133600 },
308 { TRUE_40
, FALSE
, WLAN_PHY_HT_40_DS_HGI
, 300000, /* 300 Mb */
309 207000, 0x8f, 0x00, 15,
310 8, 25, 3, 27, 44, 45, 45, 148400 },
312 50, /* probe interval */
313 50, /* rssi reduce interval */
314 WLAN_RC_HT_FLAG
, /* Phy rates allowed initially */
317 static struct ath_rate_table ar5416_11a_ratetable
= {
320 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 6000, /* 6 Mb */
321 5400, 0x0b, 0x00, (0x80|12),
323 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 9000, /* 9 Mb */
324 7800, 0x0f, 0x00, 18,
326 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 12000, /* 12 Mb */
327 10000, 0x0a, 0x00, (0x80|24),
329 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 18000, /* 18 Mb */
330 13900, 0x0e, 0x00, 36,
332 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 24000, /* 24 Mb */
333 17300, 0x09, 0x00, (0x80|48),
335 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 36000, /* 36 Mb */
336 23000, 0x0d, 0x00, 72,
338 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 48000, /* 48 Mb */
339 27400, 0x08, 0x00, 96,
341 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 54000, /* 54 Mb */
342 29300, 0x0c, 0x00, 108,
345 50, /* probe interval */
346 50, /* rssi reduce interval */
347 0, /* Phy rates allowed initially */
350 static struct ath_rate_table ar5416_11a_ratetable_Half
= {
353 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 3000, /* 6 Mb */
354 2700, 0x0b, 0x00, (0x80|6),
356 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 4500, /* 9 Mb */
359 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 6000, /* 12 Mb */
360 5000, 0x0a, 0x00, (0x80|12),
362 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 9000, /* 18 Mb */
363 6950, 0x0e, 0x00, 18,
365 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 12000, /* 24 Mb */
366 8650, 0x09, 0x00, (0x80|24),
368 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 18000, /* 36 Mb */
369 11500, 0x0d, 0x00, 36,
371 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 24000, /* 48 Mb */
372 13700, 0x08, 0x00, 48,
374 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 27000, /* 54 Mb */
375 14650, 0x0c, 0x00, 54,
378 50, /* probe interval */
379 50, /* rssi reduce interval */
380 0, /* Phy rates allowed initially */
383 static struct ath_rate_table ar5416_11a_ratetable_Quarter
= {
386 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 1500, /* 6 Mb */
387 1350, 0x0b, 0x00, (0x80|3),
389 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 2250, /* 9 Mb */
392 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 3000, /* 12 Mb */
393 2500, 0x0a, 0x00, (0x80|6),
395 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 4500, /* 18 Mb */
398 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 6000, /* 25 Mb */
399 4325, 0x09, 0x00, (0x80|12),
401 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 9000, /* 36 Mb */
402 5750, 0x0d, 0x00, 18,
404 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 12000, /* 48 Mb */
405 6850, 0x08, 0x00, 24,
407 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 13500, /* 54 Mb */
408 7325, 0x0c, 0x00, 27,
411 50, /* probe interval */
412 50, /* rssi reduce interval */
413 0, /* Phy rates allowed initially */
416 static struct ath_rate_table ar5416_11g_ratetable
= {
419 { TRUE
, TRUE
, WLAN_PHY_CCK
, 1000, /* 1 Mb */
422 { TRUE
, TRUE
, WLAN_PHY_CCK
, 2000, /* 2 Mb */
425 { TRUE
, TRUE
, WLAN_PHY_CCK
, 5500, /* 5.5 Mb */
426 4900, 0x19, 0x04, 11,
428 { TRUE
, TRUE
, WLAN_PHY_CCK
, 11000, /* 11 Mb */
429 8100, 0x18, 0x04, 22,
431 { FALSE
, FALSE
, WLAN_PHY_OFDM
, 6000, /* 6 Mb */
432 5400, 0x0b, 0x00, 12,
434 { FALSE
, FALSE
, WLAN_PHY_OFDM
, 9000, /* 9 Mb */
435 7800, 0x0f, 0x00, 18,
437 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 12000, /* 12 Mb */
438 10000, 0x0a, 0x00, 24,
440 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 18000, /* 18 Mb */
441 13900, 0x0e, 0x00, 36,
443 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 24000, /* 24 Mb */
444 17300, 0x09, 0x00, 48,
446 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 36000, /* 36 Mb */
447 23000, 0x0d, 0x00, 72,
449 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 48000, /* 48 Mb */
450 27400, 0x08, 0x00, 96,
452 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 54000, /* 54 Mb */
453 29300, 0x0c, 0x00, 108,
456 50, /* probe interval */
457 50, /* rssi reduce interval */
458 0, /* Phy rates allowed initially */
461 static struct ath_rate_table ar5416_11b_ratetable
= {
464 { TRUE
, TRUE
, WLAN_PHY_CCK
, 1000, /* 1 Mb */
465 900, 0x1b, 0x00, (0x80|2),
467 { TRUE
, TRUE
, WLAN_PHY_CCK
, 2000, /* 2 Mb */
468 1800, 0x1a, 0x04, (0x80|4),
470 { TRUE
, TRUE
, WLAN_PHY_CCK
, 5500, /* 5.5 Mb */
471 4300, 0x19, 0x04, (0x80|11),
473 { TRUE
, TRUE
, WLAN_PHY_CCK
, 11000, /* 11 Mb */
474 7100, 0x18, 0x04, (0x80|22),
477 100, /* probe interval */
478 100, /* rssi reduce interval */
479 0, /* Phy rates allowed initially */
482 static void ar5416_attach_ratetables(struct ath_rate_softc
*sc
)
485 * Attach rate tables.
487 sc
->hw_rate_table
[WIRELESS_MODE_11b
] = &ar5416_11b_ratetable
;
488 sc
->hw_rate_table
[WIRELESS_MODE_11a
] = &ar5416_11a_ratetable
;
489 sc
->hw_rate_table
[WIRELESS_MODE_11g
] = &ar5416_11g_ratetable
;
491 sc
->hw_rate_table
[WIRELESS_MODE_11NA_HT20
] = &ar5416_11na_ratetable
;
492 sc
->hw_rate_table
[WIRELESS_MODE_11NG_HT20
] = &ar5416_11ng_ratetable
;
493 sc
->hw_rate_table
[WIRELESS_MODE_11NA_HT40PLUS
] =
494 &ar5416_11na_ratetable
;
495 sc
->hw_rate_table
[WIRELESS_MODE_11NA_HT40MINUS
] =
496 &ar5416_11na_ratetable
;
497 sc
->hw_rate_table
[WIRELESS_MODE_11NG_HT40PLUS
] =
498 &ar5416_11ng_ratetable
;
499 sc
->hw_rate_table
[WIRELESS_MODE_11NG_HT40MINUS
] =
500 &ar5416_11ng_ratetable
;
503 static void ar5416_setquarter_ratetable(struct ath_rate_softc
*sc
)
505 sc
->hw_rate_table
[WIRELESS_MODE_11a
] = &ar5416_11a_ratetable_Quarter
;
509 static void ar5416_sethalf_ratetable(struct ath_rate_softc
*sc
)
511 sc
->hw_rate_table
[WIRELESS_MODE_11a
] = &ar5416_11a_ratetable_Half
;
515 static void ar5416_setfull_ratetable(struct ath_rate_softc
*sc
)
517 sc
->hw_rate_table
[WIRELESS_MODE_11a
] = &ar5416_11a_ratetable
;
522 * Return the median of three numbers
524 static inline int8_t median(int8_t a
, int8_t b
, int8_t c
)
543 static void ath_rc_sort_validrates(const struct ath_rate_table
*rate_table
,
544 struct ath_tx_ratectrl
*rate_ctrl
)
546 u_int8_t i
, j
, idx
, idx_next
;
548 for (i
= rate_ctrl
->max_valid_rate
- 1; i
> 0; i
--) {
549 for (j
= 0; j
<= i
-1; j
++) {
551 idx
= rate_ctrl
->valid_rate_index
[j
];
552 idx_next
= rate_ctrl
->valid_rate_index
[j
+1];
554 if (rate_table
->info
[idx
].ratekbps
>
555 rate_table
->info
[idx_next
].ratekbps
) {
557 rate_ctrl
->valid_rate_index
[j
] = idx_next
;
558 rate_ctrl
->valid_rate_index
[j
+1] = idx
;
564 /* Access functions for valid_txrate_mask */
566 static void ath_rc_init_valid_txmask(struct ath_tx_ratectrl
*rate_ctrl
)
570 for (i
= 0; i
< rate_ctrl
->rate_table_size
; i
++)
571 rate_ctrl
->valid_rate_index
[i
] = FALSE
;
574 static inline void ath_rc_set_valid_txmask(struct ath_tx_ratectrl
*rate_ctrl
,
575 u_int8_t index
, int valid_tx_rate
)
577 ASSERT(index
<= rate_ctrl
->rate_table_size
);
578 rate_ctrl
->valid_rate_index
[index
] = valid_tx_rate
? TRUE
: FALSE
;
581 static inline int ath_rc_isvalid_txmask(struct ath_tx_ratectrl
*rate_ctrl
,
584 ASSERT(index
<= rate_ctrl
->rate_table_size
);
585 return rate_ctrl
->valid_rate_index
[index
];
588 /* Iterators for valid_txrate_mask */
589 static inline int ath_rc_get_nextvalid_txrate(
590 const struct ath_rate_table
*rate_table
,
591 struct ath_tx_ratectrl
*rate_ctrl
,
592 u_int8_t cur_valid_txrate
,
597 for (i
= 0; i
< rate_ctrl
->max_valid_rate
- 1; i
++) {
598 if (rate_ctrl
->valid_rate_index
[i
] == cur_valid_txrate
) {
599 *next_idx
= rate_ctrl
->valid_rate_index
[i
+1];
604 /* No more valid rates */
609 /* Return true only for single stream */
611 static int ath_rc_valid_phyrate(u_int32_t phy
, u_int32_t capflag
, int ignore_cw
)
613 if (WLAN_RC_PHY_HT(phy
) & !(capflag
& WLAN_RC_HT_FLAG
))
615 if (WLAN_RC_PHY_DS(phy
) && !(capflag
& WLAN_RC_DS_FLAG
))
617 if (WLAN_RC_PHY_SGI(phy
) && !(capflag
& WLAN_RC_SGI_FLAG
))
619 if (!ignore_cw
&& WLAN_RC_PHY_HT(phy
))
620 if (WLAN_RC_PHY_40(phy
) && !(capflag
& WLAN_RC_40_FLAG
))
622 if (!WLAN_RC_PHY_40(phy
) && (capflag
& WLAN_RC_40_FLAG
))
627 static inline int ath_rc_get_nextlowervalid_txrate(
628 const struct ath_rate_table
*rate_table
,
629 struct ath_tx_ratectrl
*rate_ctrl
,
630 u_int8_t cur_valid_txrate
, u_int8_t
*next_idx
)
634 for (i
= 1; i
< rate_ctrl
->max_valid_rate
; i
++) {
635 if (rate_ctrl
->valid_rate_index
[i
] == cur_valid_txrate
) {
636 *next_idx
= rate_ctrl
->valid_rate_index
[i
-1];
644 * Initialize the Valid Rate Index from valid entries in Rate Table
646 static u_int8_t
ath_rc_sib_init_validrates(struct ath_rate_node
*ath_rc_priv
,
647 const struct ath_rate_table
*rate_table
,
650 struct ath_tx_ratectrl
*rate_ctrl
;
654 rate_ctrl
= (struct ath_tx_ratectrl
*)(ath_rc_priv
);
655 for (i
= 0; i
< rate_table
->rate_cnt
; i
++) {
656 valid
= (ath_rc_priv
->single_stream
?
657 rate_table
->info
[i
].valid_single_stream
:
658 rate_table
->info
[i
].valid
);
660 u_int32_t phy
= rate_table
->info
[i
].phy
;
661 u_int8_t valid_rate_count
= 0;
663 if (!ath_rc_valid_phyrate(phy
, capflag
, FALSE
))
666 valid_rate_count
= rate_ctrl
->valid_phy_ratecnt
[phy
];
668 rate_ctrl
->valid_phy_rateidx
[phy
][valid_rate_count
] = i
;
669 rate_ctrl
->valid_phy_ratecnt
[phy
] += 1;
670 ath_rc_set_valid_txmask(rate_ctrl
, i
, TRUE
);
678 * Initialize the Valid Rate Index from Rate Set
680 static u_int8_t
ath_rc_sib_setvalid_rates(struct ath_rate_node
*ath_rc_priv
,
681 const struct ath_rate_table
*rate_table
,
682 struct ath_rateset
*rateset
,
685 /* XXX: Clean me up and make identation friendly */
686 u_int8_t i
, j
, hi
= 0;
687 struct ath_tx_ratectrl
*rate_ctrl
=
688 (struct ath_tx_ratectrl
*)(ath_rc_priv
);
690 /* Use intersection of working rates and valid rates */
691 for (i
= 0; i
< rateset
->rs_nrates
; i
++) {
692 for (j
= 0; j
< rate_table
->rate_cnt
; j
++) {
693 u_int32_t phy
= rate_table
->info
[j
].phy
;
694 u_int32_t valid
= (ath_rc_priv
->single_stream
?
695 rate_table
->info
[j
].valid_single_stream
:
696 rate_table
->info
[j
].valid
);
698 /* We allow a rate only if its valid and the
699 * capflag matches one of the validity
700 * (TRUE/TRUE_20/TRUE_40) flags */
702 /* XXX: catch the negative of this branch
703 * first and then continue */
704 if (((rateset
->rs_rates
[i
] & 0x7F) ==
705 (rate_table
->info
[j
].dot11rate
& 0x7F)) &&
706 ((valid
& WLAN_RC_CAP_MODE(capflag
)) ==
707 WLAN_RC_CAP_MODE(capflag
)) &&
708 !WLAN_RC_PHY_HT(phy
)) {
710 u_int8_t valid_rate_count
= 0;
712 if (!ath_rc_valid_phyrate(phy
, capflag
, FALSE
))
716 rate_ctrl
->valid_phy_ratecnt
[phy
];
718 rate_ctrl
->valid_phy_rateidx
[phy
]
719 [valid_rate_count
] = j
;
720 rate_ctrl
->valid_phy_ratecnt
[phy
] += 1;
721 ath_rc_set_valid_txmask(rate_ctrl
, j
, TRUE
);
729 static u_int8_t
ath_rc_sib_setvalid_htrates(struct ath_rate_node
*ath_rc_priv
,
730 const struct ath_rate_table
*rate_table
,
731 u_int8_t
*mcs_set
, u_int32_t capflag
)
733 u_int8_t i
, j
, hi
= 0;
734 struct ath_tx_ratectrl
*rate_ctrl
=
735 (struct ath_tx_ratectrl
*)(ath_rc_priv
);
737 /* Use intersection of working rates and valid rates */
738 for (i
= 0; i
< ((struct ath_rateset
*)mcs_set
)->rs_nrates
; i
++) {
739 for (j
= 0; j
< rate_table
->rate_cnt
; j
++) {
740 u_int32_t phy
= rate_table
->info
[j
].phy
;
741 u_int32_t valid
= (ath_rc_priv
->single_stream
?
742 rate_table
->info
[j
].valid_single_stream
:
743 rate_table
->info
[j
].valid
);
745 if (((((struct ath_rateset
*)
746 mcs_set
)->rs_rates
[i
] & 0x7F) !=
747 (rate_table
->info
[j
].dot11rate
& 0x7F)) ||
748 !WLAN_RC_PHY_HT(phy
) ||
749 !WLAN_RC_PHY_HT_VALID(valid
, capflag
))
752 if (!ath_rc_valid_phyrate(phy
, capflag
, FALSE
))
755 rate_ctrl
->valid_phy_rateidx
[phy
]
756 [rate_ctrl
->valid_phy_ratecnt
[phy
]] = j
;
757 rate_ctrl
->valid_phy_ratecnt
[phy
] += 1;
758 ath_rc_set_valid_txmask(rate_ctrl
, j
, TRUE
);
766 * Attach to a device instance. Setup the public definition
767 * of how much per-node space we need and setup the private
768 * phy tables that have rate control parameters.
770 struct ath_rate_softc
*ath_rate_attach(struct ath_hal
*ah
)
772 struct ath_rate_softc
*asc
;
774 /* we are only in user context so we can sleep for memory */
775 asc
= kzalloc(sizeof(struct ath_rate_softc
), GFP_KERNEL
);
779 ar5416_attach_ratetables(asc
);
781 /* Save Maximum TX Trigger Level (used for 11n) */
782 tx_triglevel_max
= ah
->ah_caps
.halTxTrigLevelMax
;
783 /* return alias for ath_rate_softc * */
787 static struct ath_rate_node
*ath_rate_node_alloc(struct ath_vap
*avp
,
788 struct ath_rate_softc
*rsc
,
791 struct ath_rate_node
*anode
;
793 anode
= kzalloc(sizeof(struct ath_rate_node
), gfp
);
802 static void ath_rate_node_free(struct ath_rate_node
*anode
)
808 void ath_rate_detach(struct ath_rate_softc
*asc
)
814 u_int8_t
ath_rate_findrateix(struct ath_softc
*sc
,
817 const struct ath_rate_table
*ratetable
;
818 struct ath_rate_softc
*rsc
= sc
->sc_rc
;
821 ratetable
= rsc
->hw_rate_table
[sc
->sc_curmode
];
823 if (WARN_ON(!ratetable
))
826 for (i
= 0; i
< ratetable
->rate_cnt
; i
++) {
827 if ((ratetable
->info
[i
].dot11rate
& 0x7f) ==
835 * Update rate-control state on a device state change. When
836 * operating as a station this includes associate/reassociate
837 * with an AP. Otherwise this gets called, for example, when
838 * the we transition to run state when operating as an AP.
840 void ath_rate_newstate(struct ath_softc
*sc
, struct ath_vap
*avp
, int up
)
842 struct ath_rate_softc
*asc
= sc
->sc_rc
;
844 /* For half and quarter rate channles use different
847 if (sc
->sc_curchan
.channelFlags
& CHANNEL_HALF
)
848 ar5416_sethalf_ratetable(asc
);
849 else if (sc
->sc_curchan
.channelFlags
& CHANNEL_QUARTER
)
850 ar5416_setquarter_ratetable(asc
);
852 ar5416_setfull_ratetable(asc
);
854 if (avp
->av_config
.av_fixed_rateset
!= IEEE80211_FIXED_RATE_NONE
) {
856 sc
->sc_rixmap
[avp
->av_config
.av_fixed_rateset
& 0xff];
857 /* NB: check the fixed rate exists */
858 if (asc
->fixedrix
== 0xff)
859 asc
->fixedrix
= IEEE80211_FIXED_RATE_NONE
;
861 asc
->fixedrix
= IEEE80211_FIXED_RATE_NONE
;
865 static u_int8_t
ath_rc_ratefind_ht(struct ath_softc
*sc
,
866 struct ath_rate_node
*ath_rc_priv
,
867 const struct ath_rate_table
*rate_table
,
868 int probe_allowed
, int *is_probing
, int is_retry
)
870 u_int32_t dt
, best_thruput
, this_thruput
, now_msec
;
871 u_int8_t rate
, next_rate
, best_rate
, maxindex
, minindex
;
872 int8_t rssi_last
, rssi_reduce
= 0, index
= 0;
873 struct ath_tx_ratectrl
*rate_ctrl
= NULL
;
875 rate_ctrl
= (struct ath_tx_ratectrl
*)(ath_rc_priv
?
876 (ath_rc_priv
) : NULL
);
880 rssi_last
= median(rate_ctrl
->rssi_last
,
881 rate_ctrl
->rssi_last_prev
,
882 rate_ctrl
->rssi_last_prev2
);
885 * Age (reduce) last ack rssi based on how old it is.
886 * The bizarre numbers are so the delta is 160msec,
887 * meaning we divide by 16.
888 * 0msec <= dt <= 25msec: don't derate
889 * 25msec <= dt <= 185msec: derate linearly from 0 to 10dB
890 * 185msec <= dt: derate by 10dB
893 now_msec
= jiffies_to_msecs(jiffies
);
894 dt
= now_msec
- rate_ctrl
->rssi_time
;
899 rssi_reduce
= (u_int8_t
)((dt
- 25) >> 4);
901 /* Now reduce rssi_last by rssi_reduce */
902 if (rssi_last
< rssi_reduce
)
905 rssi_last
-= rssi_reduce
;
908 * Now look up the rate in the rssi table and return it.
909 * If no rates match then we return 0 (lowest rate)
913 maxindex
= rate_ctrl
->max_valid_rate
-1;
916 best_rate
= minindex
;
918 * Try the higher rate first. It will reduce memory moving time
919 * if we have very good channel characteristics.
922 for (index
= maxindex
; index
>= minindex
; index
--) {
925 rate
= rate_ctrl
->valid_rate_index
[index
];
927 if (rate
> rate_ctrl
->rate_max_phy
)
931 * For TCP the average collision rate is around 11%,
932 * so we ignore PERs less than this. This is to
933 * prevent the rate we are currently using (whose
934 * PER might be in the 10-15 range because of TCP
935 * collisions) looking worse than the next lower
936 * rate whose PER has decayed close to 0. If we
937 * used to next lower rate, its PER would grow to
938 * 10-15 and we would be worse off then staying
939 * at the current rate.
941 per_thres
= rate_ctrl
->state
[rate
].per
;
945 this_thruput
= rate_table
->info
[rate
].user_ratekbps
*
948 if (best_thruput
<= this_thruput
) {
949 best_thruput
= this_thruput
;
956 /* if we are retrying for more than half the number
957 * of max retries, use the min rate for the next retry
960 rate
= rate_ctrl
->valid_rate_index
[minindex
];
962 rate_ctrl
->rssi_last_lookup
= rssi_last
;
965 * Must check the actual rate (ratekbps) to account for
966 * non-monoticity of 11g's rate table
969 if (rate
>= rate_ctrl
->rate_max_phy
&& probe_allowed
) {
971 rate
= rate_ctrl
->rate_max_phy
;
973 /* Probe the next allowed phy state */
974 /* FIXME:XXXX Check to make sure ratMax is checked properly */
975 if (ath_rc_get_nextvalid_txrate(rate_table
,
976 rate_ctrl
, rate
, &next_rate
) &&
977 (now_msec
- rate_ctrl
->probe_time
>
978 rate_table
->probe_interval
) &&
979 (rate_ctrl
->hw_maxretry_pktcnt
>= 1)) {
981 rate_ctrl
->probe_rate
= rate
;
982 rate_ctrl
->probe_time
= now_msec
;
983 rate_ctrl
->hw_maxretry_pktcnt
= 0;
989 * Make sure rate is not higher than the allowed maximum.
990 * We should also enforce the min, but I suspect the min is
991 * normally 1 rather than 0 because of the rate 9 vs 6 issue
994 if (rate
> (rate_ctrl
->rate_table_size
- 1))
995 rate
= rate_ctrl
->rate_table_size
- 1;
997 ASSERT((rate_table
->info
[rate
].valid
&& !ath_rc_priv
->single_stream
) ||
998 (rate_table
->info
[rate
].valid_single_stream
&&
999 ath_rc_priv
->single_stream
));
1004 static void ath_rc_rate_set_series(const struct ath_rate_table
*rate_table
,
1005 struct ath_rc_series
*series
, u_int8_t tries
, u_int8_t rix
,
1008 series
->tries
= tries
;
1009 series
->flags
= (rtsctsenable
? ATH_RC_RTSCTS_FLAG
: 0) |
1010 (WLAN_RC_PHY_DS(rate_table
->info
[rix
].phy
) ?
1011 ATH_RC_DS_FLAG
: 0) |
1012 (WLAN_RC_PHY_40(rate_table
->info
[rix
].phy
) ?
1013 ATH_RC_CW40_FLAG
: 0) |
1014 (WLAN_RC_PHY_SGI(rate_table
->info
[rix
].phy
) ?
1015 ATH_RC_SGI_FLAG
: 0);
1017 series
->rix
= rate_table
->info
[rix
].base_index
;
1018 series
->max_4ms_framelen
= rate_table
->info
[rix
].max_4ms_framelen
;
1021 static u_int8_t
ath_rc_rate_getidx(struct ath_softc
*sc
,
1022 struct ath_rate_node
*ath_rc_priv
,
1023 const struct ath_rate_table
*rate_table
,
1024 u_int8_t rix
, u_int16_t stepdown
, u_int16_t min_rate
)
1028 struct ath_tx_ratectrl
*rate_ctrl
=
1029 (struct ath_tx_ratectrl
*)(ath_rc_priv
);
1032 for (j
= RATE_TABLE_SIZE
; j
> 0; j
--) {
1033 if (ath_rc_get_nextlowervalid_txrate(rate_table
,
1034 rate_ctrl
, rix
, &nextindex
))
1040 for (j
= stepdown
; j
> 0; j
--) {
1041 if (ath_rc_get_nextlowervalid_txrate(rate_table
,
1042 rate_ctrl
, rix
, &nextindex
))
1051 static void ath_rc_ratefind(struct ath_softc
*sc
,
1052 struct ath_rate_node
*ath_rc_priv
,
1053 int num_tries
, int num_rates
, unsigned int rcflag
,
1054 struct ath_rc_series series
[], int *is_probe
, int is_retry
)
1056 u_int8_t try_per_rate
= 0, i
= 0, rix
, nrix
;
1057 struct ath_rate_softc
*asc
= (struct ath_rate_softc
*)sc
->sc_rc
;
1058 struct ath_rate_table
*rate_table
;
1061 (struct ath_rate_table
*)asc
->hw_rate_table
[sc
->sc_curmode
];
1062 rix
= ath_rc_ratefind_ht(sc
, ath_rc_priv
, rate_table
,
1063 (rcflag
& ATH_RC_PROBE_ALLOWED
) ? 1 : 0,
1064 is_probe
, is_retry
);
1067 if ((rcflag
& ATH_RC_PROBE_ALLOWED
) && (*is_probe
)) {
1068 /* set one try for probe rates. For the
1069 * probes don't enable rts */
1070 ath_rc_rate_set_series(rate_table
,
1071 &series
[i
++], 1, nrix
, FALSE
);
1073 try_per_rate
= (num_tries
/num_rates
);
1074 /* Get the next tried/allowed rate. No RTS for the next series
1075 * after the probe rate
1077 nrix
= ath_rc_rate_getidx(sc
,
1078 ath_rc_priv
, rate_table
, nrix
, 1, FALSE
);
1079 ath_rc_rate_set_series(rate_table
,
1080 &series
[i
++], try_per_rate
, nrix
, 0);
1082 try_per_rate
= (num_tries
/num_rates
);
1083 /* Set the choosen rate. No RTS for first series entry. */
1084 ath_rc_rate_set_series(rate_table
,
1085 &series
[i
++], try_per_rate
, nrix
, FALSE
);
1088 /* Fill in the other rates for multirate retry */
1089 for ( ; i
< num_rates
; i
++) {
1093 try_num
= ((i
+ 1) == num_rates
) ?
1094 num_tries
- (try_per_rate
* i
) : try_per_rate
;
1095 min_rate
= (((i
+ 1) == num_rates
) &&
1096 (rcflag
& ATH_RC_MINRATE_LASTRATE
)) ? 1 : 0;
1098 nrix
= ath_rc_rate_getidx(sc
, ath_rc_priv
,
1099 rate_table
, nrix
, 1, min_rate
);
1100 /* All other rates in the series have RTS enabled */
1101 ath_rc_rate_set_series(rate_table
,
1102 &series
[i
], try_num
, nrix
, TRUE
);
1106 * NB:Change rate series to enable aggregation when operating
1107 * at lower MCS rates. When first rate in series is MCS2
1108 * in HT40 @ 2.4GHz, series should look like:
1110 * {MCS2, MCS1, MCS0, MCS0}.
1112 * When first rate in series is MCS3 in HT20 @ 2.4GHz, series should
1115 * {MCS3, MCS2, MCS1, MCS1}
1117 * So, set fourth rate in series to be same as third one for
1120 if ((sc
->sc_curmode
== WIRELESS_MODE_11NG_HT20
) ||
1121 (sc
->sc_curmode
== WIRELESS_MODE_11NG_HT40PLUS
) ||
1122 (sc
->sc_curmode
== WIRELESS_MODE_11NG_HT40MINUS
)) {
1123 u_int8_t dot11rate
= rate_table
->info
[rix
].dot11rate
;
1124 u_int8_t phy
= rate_table
->info
[rix
].phy
;
1126 ((dot11rate
== 2 && phy
== WLAN_RC_PHY_HT_40_SS
) ||
1127 (dot11rate
== 3 && phy
== WLAN_RC_PHY_HT_20_SS
))) {
1128 series
[3].rix
= series
[2].rix
;
1129 series
[3].flags
= series
[2].flags
;
1130 series
[3].max_4ms_framelen
= series
[2].max_4ms_framelen
;
1136 * Return the Tx rate series.
1140 void ath_rate_findrate(struct ath_softc
*sc
,
1141 struct ath_rate_node
*ath_rc_priv
,
1144 unsigned int rcflag
,
1145 struct ath_rc_series series
[],
1150 struct ath_vap
*avp
= ath_rc_priv
->avp
;
1152 DPRINTF(sc
, ATH_DEBUG_RATE
, "%s", __func__
);
1153 if (!num_rates
|| !num_tries
)
1156 if (avp
->av_config
.av_fixed_rateset
== IEEE80211_FIXED_RATE_NONE
) {
1157 ath_rc_ratefind(sc
, ath_rc_priv
, num_tries
, num_rates
,
1158 rcflag
, series
, is_probe
, is_retry
);
1164 struct ath_rate_softc
*asc
= ath_rc_priv
->asc
;
1165 struct ath_rate_table
*rate_table
;
1167 rate_table
= (struct ath_rate_table
*)
1168 asc
->hw_rate_table
[sc
->sc_curmode
];
1170 for (idx
= 0; idx
< 4; idx
++) {
1172 u_int8_t series_rix
= 0;
1175 IEEE80211_RATE_IDX_ENTRY(
1176 avp
->av_config
.av_fixed_retryset
, idx
);
1178 mcs
= IEEE80211_RATE_IDX_ENTRY(
1179 avp
->av_config
.av_fixed_rateset
, idx
);
1181 if (idx
== 3 && (mcs
& 0xf0) == 0x70)
1182 mcs
= (mcs
& ~0xf0)|0x80;
1187 flags
= ((ath_rc_priv
->ht_cap
&
1189 ATH_RC_DS_FLAG
: 0) |
1190 ((ath_rc_priv
->ht_cap
&
1192 ATH_RC_CW40_FLAG
: 0) |
1193 ((ath_rc_priv
->ht_cap
&
1195 ((ath_rc_priv
->ht_cap
&
1197 ATH_RC_SGI_FLAG
: 0) : 0);
1199 series
[idx
].rix
= sc
->sc_rixmap
[mcs
];
1200 series_rix
= series
[idx
].rix
;
1202 /* XXX: Give me some cleanup love */
1203 if ((flags
& ATH_RC_CW40_FLAG
) &&
1204 (flags
& ATH_RC_SGI_FLAG
))
1205 rix
= rate_table
->info
[series_rix
].ht_index
;
1206 else if (flags
& ATH_RC_SGI_FLAG
)
1207 rix
= rate_table
->info
[series_rix
].sgi_index
;
1208 else if (flags
& ATH_RC_CW40_FLAG
)
1209 rix
= rate_table
->info
[series_rix
].cw40index
;
1211 rix
= rate_table
->info
[series_rix
].base_index
;
1212 series
[idx
].max_4ms_framelen
=
1213 rate_table
->info
[rix
].max_4ms_framelen
;
1214 series
[idx
].flags
= flags
;
1219 static void ath_rc_update_ht(struct ath_softc
*sc
,
1220 struct ath_rate_node
*ath_rc_priv
,
1221 struct ath_tx_info_priv
*info_priv
,
1222 int tx_rate
, int xretries
, int retries
)
1224 struct ath_tx_ratectrl
*rate_ctrl
;
1225 u_int32_t now_msec
= jiffies_to_msecs(jiffies
);
1226 int state_change
= FALSE
, rate
, count
;
1228 struct ath_rate_softc
*asc
= (struct ath_rate_softc
*)sc
->sc_rc
;
1229 struct ath_rate_table
*rate_table
=
1230 (struct ath_rate_table
*)asc
->hw_rate_table
[sc
->sc_curmode
];
1232 static u_int32_t nretry_to_per_lookup
[10] = {
1248 rate_ctrl
= (struct ath_tx_ratectrl
*)(ath_rc_priv
);
1250 ASSERT(tx_rate
>= 0);
1254 /* To compensate for some imbalance between ctrl and ext. channel */
1256 if (WLAN_RC_PHY_40(rate_table
->info
[tx_rate
].phy
))
1257 info_priv
->tx
.ts_rssi
=
1258 info_priv
->tx
.ts_rssi
< 3? 0: info_priv
->tx
.ts_rssi
- 3;
1260 last_per
= rate_ctrl
->state
[tx_rate
].per
;
1263 /* Update the PER. */
1264 if (xretries
== 1) {
1265 rate_ctrl
->state
[tx_rate
].per
+= 30;
1266 if (rate_ctrl
->state
[tx_rate
].per
> 100)
1267 rate_ctrl
->state
[tx_rate
].per
= 100;
1271 count
= sizeof(nretry_to_per_lookup
) /
1272 sizeof(nretry_to_per_lookup
[0]);
1273 if (retries
>= count
)
1274 retries
= count
- 1;
1275 /* new_PER = 7/8*old_PER + 1/8*(currentPER) */
1276 rate_ctrl
->state
[tx_rate
].per
=
1277 (u_int8_t
)(rate_ctrl
->state
[tx_rate
].per
-
1278 (rate_ctrl
->state
[tx_rate
].per
>> 3) +
1282 /* xretries == 1 or 2 */
1284 if (rate_ctrl
->probe_rate
== tx_rate
)
1285 rate_ctrl
->probe_rate
= 0;
1287 } else { /* xretries == 0 */
1289 /* Update the PER. */
1290 /* Make sure it doesn't index out of array's bounds. */
1291 count
= sizeof(nretry_to_per_lookup
) /
1292 sizeof(nretry_to_per_lookup
[0]);
1293 if (retries
>= count
)
1294 retries
= count
- 1;
1295 if (info_priv
->n_bad_frames
) {
1296 /* new_PER = 7/8*old_PER + 1/8*(currentPER) */
1298 * Assuming that n_frames is not 0. The current PER
1299 * from the retries is 100 * retries / (retries+1),
1300 * since the first retries attempts failed, and the
1301 * next one worked. For the one that worked,
1302 * n_bad_frames subframes out of n_frames wored,
1303 * so the PER for that part is
1304 * 100 * n_bad_frames / n_frames, and it contributes
1305 * 100 * n_bad_frames / (n_frames * (retries+1)) to
1306 * the above PER. The expression below is a
1307 * simplified version of the sum of these two terms.
1309 if (info_priv
->n_frames
> 0)
1310 rate_ctrl
->state
[tx_rate
].per
1312 (rate_ctrl
->state
[tx_rate
].per
-
1313 (rate_ctrl
->state
[tx_rate
].per
>> 3) +
1314 ((100*(retries
*info_priv
->n_frames
+
1315 info_priv
->n_bad_frames
) /
1316 (info_priv
->n_frames
*
1317 (retries
+1))) >> 3));
1319 /* new_PER = 7/8*old_PER + 1/8*(currentPER) */
1321 rate_ctrl
->state
[tx_rate
].per
= (u_int8_t
)
1322 (rate_ctrl
->state
[tx_rate
].per
-
1323 (rate_ctrl
->state
[tx_rate
].per
>> 3) +
1324 (nretry_to_per_lookup
[retries
] >> 3));
1327 rate_ctrl
->rssi_last_prev2
= rate_ctrl
->rssi_last_prev
;
1328 rate_ctrl
->rssi_last_prev
= rate_ctrl
->rssi_last
;
1329 rate_ctrl
->rssi_last
= info_priv
->tx
.ts_rssi
;
1330 rate_ctrl
->rssi_time
= now_msec
;
1333 * If we got at most one retry then increase the max rate if
1334 * this was a probe. Otherwise, ignore the probe.
1337 if (rate_ctrl
->probe_rate
&& rate_ctrl
->probe_rate
== tx_rate
) {
1338 if (retries
> 0 || 2 * info_priv
->n_bad_frames
>
1339 info_priv
->n_frames
) {
1341 * Since we probed with just a single attempt,
1342 * any retries means the probe failed. Also,
1343 * if the attempt worked, but more than half
1344 * the subframes were bad then also consider
1345 * the probe a failure.
1347 rate_ctrl
->probe_rate
= 0;
1349 u_int8_t probe_rate
= 0;
1351 rate_ctrl
->rate_max_phy
= rate_ctrl
->probe_rate
;
1352 probe_rate
= rate_ctrl
->probe_rate
;
1354 if (rate_ctrl
->state
[probe_rate
].per
> 30)
1355 rate_ctrl
->state
[probe_rate
].per
= 20;
1357 rate_ctrl
->probe_rate
= 0;
1360 * Since this probe succeeded, we allow the next
1361 * probe twice as soon. This allows the maxRate
1362 * to move up faster if the probes are
1365 rate_ctrl
->probe_time
= now_msec
-
1366 rate_table
->probe_interval
/ 2;
1372 * Don't update anything. We don't know if
1373 * this was because of collisions or poor signal.
1375 * Later: if rssi_ack is close to
1376 * rate_ctrl->state[txRate].rssi_thres and we see lots
1377 * of retries, then we could increase
1378 * rate_ctrl->state[txRate].rssi_thres.
1380 rate_ctrl
->hw_maxretry_pktcnt
= 0;
1383 * It worked with no retries. First ignore bogus (small)
1386 if (tx_rate
== rate_ctrl
->rate_max_phy
&&
1387 rate_ctrl
->hw_maxretry_pktcnt
< 255) {
1388 rate_ctrl
->hw_maxretry_pktcnt
++;
1391 if (info_priv
->tx
.ts_rssi
>=
1392 rate_table
->info
[tx_rate
].rssi_ack_validmin
) {
1393 /* Average the rssi */
1394 if (tx_rate
!= rate_ctrl
->rssi_sum_rate
) {
1395 rate_ctrl
->rssi_sum_rate
= tx_rate
;
1396 rate_ctrl
->rssi_sum
=
1397 rate_ctrl
->rssi_sum_cnt
= 0;
1400 rate_ctrl
->rssi_sum
+= info_priv
->tx
.ts_rssi
;
1401 rate_ctrl
->rssi_sum_cnt
++;
1403 if (rate_ctrl
->rssi_sum_cnt
> 4) {
1404 int32_t rssi_ackAvg
=
1405 (rate_ctrl
->rssi_sum
+ 2) / 4;
1407 rate_ctrl
->state
[tx_rate
].
1409 int8_t rssi_ack_vmin
=
1410 rate_table
->info
[tx_rate
].
1413 rate_ctrl
->rssi_sum
=
1414 rate_ctrl
->rssi_sum_cnt
= 0;
1416 /* Now reduce the current
1417 * rssi threshold. */
1418 if ((rssi_ackAvg
< rssi_thres
+ 2) &&
1419 (rssi_thres
> rssi_ack_vmin
)) {
1420 rate_ctrl
->state
[tx_rate
].
1424 state_change
= TRUE
;
1434 * If this rate looks bad (high PER) then stop using it for
1435 * a while (except if we are probing).
1437 if (rate_ctrl
->state
[tx_rate
].per
>= 55 && tx_rate
> 0 &&
1438 rate_table
->info
[tx_rate
].ratekbps
<=
1439 rate_table
->info
[rate_ctrl
->rate_max_phy
].ratekbps
) {
1440 ath_rc_get_nextlowervalid_txrate(rate_table
, rate_ctrl
,
1441 (u_int8_t
) tx_rate
, &rate_ctrl
->rate_max_phy
);
1443 /* Don't probe for a little while. */
1444 rate_ctrl
->probe_time
= now_msec
;
1449 * Make sure the rates above this have higher rssi thresholds.
1450 * (Note: Monotonicity is kept within the OFDM rates and
1451 * within the CCK rates. However, no adjustment is
1452 * made to keep the rssi thresholds monotonically
1453 * increasing between the CCK and OFDM rates.)
1455 for (rate
= tx_rate
; rate
<
1456 rate_ctrl
->rate_table_size
- 1; rate
++) {
1457 if (rate_table
->info
[rate
+1].phy
!=
1458 rate_table
->info
[tx_rate
].phy
)
1461 if (rate_ctrl
->state
[rate
].rssi_thres
+
1462 rate_table
->info
[rate
].rssi_ack_deltamin
>
1463 rate_ctrl
->state
[rate
+1].rssi_thres
) {
1464 rate_ctrl
->state
[rate
+1].rssi_thres
=
1465 rate_ctrl
->state
[rate
].
1467 rate_table
->info
[rate
].
1472 /* Make sure the rates below this have lower rssi thresholds. */
1473 for (rate
= tx_rate
- 1; rate
>= 0; rate
--) {
1474 if (rate_table
->info
[rate
].phy
!=
1475 rate_table
->info
[tx_rate
].phy
)
1478 if (rate_ctrl
->state
[rate
].rssi_thres
+
1479 rate_table
->info
[rate
].rssi_ack_deltamin
>
1480 rate_ctrl
->state
[rate
+1].rssi_thres
) {
1481 if (rate_ctrl
->state
[rate
+1].rssi_thres
<
1482 rate_table
->info
[rate
].
1484 rate_ctrl
->state
[rate
].rssi_thres
= 0;
1486 rate_ctrl
->state
[rate
].rssi_thres
=
1487 rate_ctrl
->state
[rate
+1].
1489 rate_table
->info
[rate
].
1493 if (rate_ctrl
->state
[rate
].rssi_thres
<
1494 rate_table
->info
[rate
].
1495 rssi_ack_validmin
) {
1496 rate_ctrl
->state
[rate
].rssi_thres
=
1497 rate_table
->info
[rate
].
1504 /* Make sure the rates below this have lower PER */
1505 /* Monotonicity is kept only for rates below the current rate. */
1506 if (rate_ctrl
->state
[tx_rate
].per
< last_per
) {
1507 for (rate
= tx_rate
- 1; rate
>= 0; rate
--) {
1508 if (rate_table
->info
[rate
].phy
!=
1509 rate_table
->info
[tx_rate
].phy
)
1512 if (rate_ctrl
->state
[rate
].per
>
1513 rate_ctrl
->state
[rate
+1].per
) {
1514 rate_ctrl
->state
[rate
].per
=
1515 rate_ctrl
->state
[rate
+1].per
;
1520 /* Maintain monotonicity for rates above the current rate */
1521 for (rate
= tx_rate
; rate
< rate_ctrl
->rate_table_size
- 1; rate
++) {
1522 if (rate_ctrl
->state
[rate
+1].per
< rate_ctrl
->state
[rate
].per
)
1523 rate_ctrl
->state
[rate
+1].per
=
1524 rate_ctrl
->state
[rate
].per
;
1527 /* Every so often, we reduce the thresholds and
1528 * PER (different for CCK and OFDM). */
1529 if (now_msec
- rate_ctrl
->rssi_down_time
>=
1530 rate_table
->rssi_reduce_interval
) {
1532 for (rate
= 0; rate
< rate_ctrl
->rate_table_size
; rate
++) {
1533 if (rate_ctrl
->state
[rate
].rssi_thres
>
1534 rate_table
->info
[rate
].rssi_ack_validmin
)
1535 rate_ctrl
->state
[rate
].rssi_thres
-= 1;
1537 rate_ctrl
->rssi_down_time
= now_msec
;
1540 /* Every so often, we reduce the thresholds
1541 * and PER (different for CCK and OFDM). */
1542 if (now_msec
- rate_ctrl
->per_down_time
>=
1543 rate_table
->rssi_reduce_interval
) {
1544 for (rate
= 0; rate
< rate_ctrl
->rate_table_size
; rate
++) {
1545 rate_ctrl
->state
[rate
].per
=
1546 7 * rate_ctrl
->state
[rate
].per
/ 8;
1549 rate_ctrl
->per_down_time
= now_msec
;
1554 * This routine is called in rate control callback tx_status() to give
1555 * the status of previous frames.
1557 static void ath_rc_update(struct ath_softc
*sc
,
1558 struct ath_rate_node
*ath_rc_priv
,
1559 struct ath_tx_info_priv
*info_priv
, int final_ts_idx
,
1560 int xretries
, int long_retry
)
1562 struct ath_rate_softc
*asc
= (struct ath_rate_softc
*)sc
->sc_rc
;
1563 struct ath_rate_table
*rate_table
;
1564 struct ath_tx_ratectrl
*rate_ctrl
;
1565 struct ath_rc_series rcs
[4];
1567 u_int32_t series
= 0, rix
;
1569 memcpy(rcs
, info_priv
->rcs
, 4 * sizeof(rcs
[0]));
1570 rate_table
= (struct ath_rate_table
*)
1571 asc
->hw_rate_table
[sc
->sc_curmode
];
1572 rate_ctrl
= (struct ath_tx_ratectrl
*)(ath_rc_priv
);
1573 ASSERT(rcs
[0].tries
!= 0);
1576 * If the first rate is not the final index, there
1577 * are intermediate rate failures to be processed.
1579 if (final_ts_idx
!= 0) {
1581 /* Process intermediate rates that failed.*/
1582 for (series
= 0; series
< final_ts_idx
; series
++) {
1583 if (rcs
[series
].tries
!= 0) {
1584 flags
= rcs
[series
].flags
;
1585 /* If HT40 and we have switched mode from
1586 * 40 to 20 => don't update */
1587 if ((flags
& ATH_RC_CW40_FLAG
) &&
1588 (rate_ctrl
->rc_phy_mode
!=
1589 (flags
& ATH_RC_CW40_FLAG
)))
1591 if ((flags
& ATH_RC_CW40_FLAG
) &&
1592 (flags
& ATH_RC_SGI_FLAG
))
1593 rix
= rate_table
->info
[
1594 rcs
[series
].rix
].ht_index
;
1595 else if (flags
& ATH_RC_SGI_FLAG
)
1596 rix
= rate_table
->info
[
1597 rcs
[series
].rix
].sgi_index
;
1598 else if (flags
& ATH_RC_CW40_FLAG
)
1599 rix
= rate_table
->info
[
1600 rcs
[series
].rix
].cw40index
;
1602 rix
= rate_table
->info
[
1603 rcs
[series
].rix
].base_index
;
1604 ath_rc_update_ht(sc
, ath_rc_priv
,
1612 * Handle the special case of MIMO PS burst, where the second
1613 * aggregate is sent out with only one rate and one try.
1614 * Treating it as an excessive retry penalizes the rate
1617 if (rcs
[0].tries
== 1 && xretries
== 1)
1621 flags
= rcs
[series
].flags
;
1622 /* If HT40 and we have switched mode from 40 to 20 => don't update */
1623 if ((flags
& ATH_RC_CW40_FLAG
) &&
1624 (rate_ctrl
->rc_phy_mode
!= (flags
& ATH_RC_CW40_FLAG
)))
1627 if ((flags
& ATH_RC_CW40_FLAG
) && (flags
& ATH_RC_SGI_FLAG
))
1628 rix
= rate_table
->info
[rcs
[series
].rix
].ht_index
;
1629 else if (flags
& ATH_RC_SGI_FLAG
)
1630 rix
= rate_table
->info
[rcs
[series
].rix
].sgi_index
;
1631 else if (flags
& ATH_RC_CW40_FLAG
)
1632 rix
= rate_table
->info
[rcs
[series
].rix
].cw40index
;
1634 rix
= rate_table
->info
[rcs
[series
].rix
].base_index
;
1636 ath_rc_update_ht(sc
, ath_rc_priv
, info_priv
, rix
,
1637 xretries
, long_retry
);
1642 * Process a tx descriptor for a completed transmit (success or failure).
1645 static void ath_rate_tx_complete(struct ath_softc
*sc
,
1646 struct ath_node
*an
, struct ath_rate_node
*rc_priv
,
1647 struct ath_tx_info_priv
*info_priv
)
1649 int final_ts_idx
= info_priv
->tx
.ts_rateindex
;
1650 int tx_status
= 0, is_underrun
= 0;
1651 struct ath_vap
*avp
;
1654 if ((avp
->av_config
.av_fixed_rateset
!= IEEE80211_FIXED_RATE_NONE
)
1655 || info_priv
->tx
.ts_status
& HAL_TXERR_FILT
)
1658 if (info_priv
->tx
.ts_rssi
> 0) {
1659 ATH_RSSI_LPF(an
->an_chainmask_sel
.tx_avgrssi
,
1660 info_priv
->tx
.ts_rssi
);
1664 * If underrun error is seen assume it as an excessive retry only
1665 * if prefetch trigger level have reached the max (0x3f for 5416)
1666 * Adjust the long retry as if the frame was tried ATH_11N_TXMAXTRY
1667 * times. This affects how ratectrl updates PER for the failed rate.
1669 if (info_priv
->tx
.ts_flags
&
1670 (HAL_TX_DATA_UNDERRUN
| HAL_TX_DELIM_UNDERRUN
) &&
1671 ((sc
->sc_ah
->ah_txTrigLevel
) >= tx_triglevel_max
)) {
1676 if ((info_priv
->tx
.ts_status
& HAL_TXERR_XRETRY
) ||
1677 (info_priv
->tx
.ts_status
& HAL_TXERR_FIFO
))
1680 ath_rc_update(sc
, rc_priv
, info_priv
, final_ts_idx
, tx_status
,
1681 (is_underrun
) ? ATH_11N_TXMAXTRY
1682 :info_priv
->tx
.ts_longretry
);
1687 * Update the SIB's rate control information
1689 * This should be called when the supported rates change
1690 * (e.g. SME operation, wireless mode change)
1692 * It will determine which rates are valid for use.
1694 static void ath_rc_sib_update(struct ath_softc
*sc
,
1695 struct ath_rate_node
*ath_rc_priv
,
1696 u_int32_t capflag
, int keep_state
,
1697 struct ath_rateset
*negotiated_rates
,
1698 struct ath_rateset
*negotiated_htrates
)
1700 struct ath_rate_table
*rate_table
= NULL
;
1701 struct ath_rate_softc
*asc
= (struct ath_rate_softc
*)sc
->sc_rc
;
1702 struct ath_rateset
*rateset
= negotiated_rates
;
1703 u_int8_t
*ht_mcs
= (u_int8_t
*)negotiated_htrates
;
1704 struct ath_tx_ratectrl
*rate_ctrl
= (struct ath_tx_ratectrl
*)
1706 u_int8_t i
, j
, k
, hi
= 0, hthi
= 0;
1708 rate_table
= (struct ath_rate_table
*)
1709 asc
->hw_rate_table
[sc
->sc_curmode
];
1711 /* Initial rate table size. Will change depending
1712 * on the working rate set */
1713 rate_ctrl
->rate_table_size
= MAX_TX_RATE_TBL
;
1715 /* Initialize thresholds according to the global rate table */
1716 for (i
= 0 ; (i
< rate_ctrl
->rate_table_size
) && (!keep_state
); i
++) {
1717 rate_ctrl
->state
[i
].rssi_thres
=
1718 rate_table
->info
[i
].rssi_ack_validmin
;
1719 rate_ctrl
->state
[i
].per
= 0;
1722 /* Determine the valid rates */
1723 ath_rc_init_valid_txmask(rate_ctrl
);
1725 for (i
= 0; i
< WLAN_RC_PHY_MAX
; i
++) {
1726 for (j
= 0; j
< MAX_TX_RATE_PHY
; j
++)
1727 rate_ctrl
->valid_phy_rateidx
[i
][j
] = 0;
1728 rate_ctrl
->valid_phy_ratecnt
[i
] = 0;
1730 rate_ctrl
->rc_phy_mode
= (capflag
& WLAN_RC_40_FLAG
);
1732 /* Set stream capability */
1733 ath_rc_priv
->single_stream
= (capflag
& WLAN_RC_DS_FLAG
) ? 0 : 1;
1735 if (!rateset
->rs_nrates
) {
1736 /* No working rate, just initialize valid rates */
1737 hi
= ath_rc_sib_init_validrates(ath_rc_priv
, rate_table
,
1740 /* Use intersection of working rates and valid rates */
1741 hi
= ath_rc_sib_setvalid_rates(ath_rc_priv
, rate_table
,
1743 if (capflag
& WLAN_RC_HT_FLAG
) {
1744 hthi
= ath_rc_sib_setvalid_htrates(ath_rc_priv
,
1745 rate_table
, ht_mcs
, capflag
);
1747 hi
= A_MAX(hi
, hthi
);
1750 rate_ctrl
->rate_table_size
= hi
+ 1;
1751 rate_ctrl
->rate_max_phy
= 0;
1752 ASSERT(rate_ctrl
->rate_table_size
<= MAX_TX_RATE_TBL
);
1754 for (i
= 0, k
= 0; i
< WLAN_RC_PHY_MAX
; i
++) {
1755 for (j
= 0; j
< rate_ctrl
->valid_phy_ratecnt
[i
]; j
++) {
1756 rate_ctrl
->valid_rate_index
[k
++] =
1757 rate_ctrl
->valid_phy_rateidx
[i
][j
];
1760 if (!ath_rc_valid_phyrate(i
, rate_table
->initial_ratemax
, TRUE
)
1761 || !rate_ctrl
->valid_phy_ratecnt
[i
])
1764 rate_ctrl
->rate_max_phy
= rate_ctrl
->valid_phy_rateidx
[i
][j
-1];
1766 ASSERT(rate_ctrl
->rate_table_size
<= MAX_TX_RATE_TBL
);
1767 ASSERT(k
<= MAX_TX_RATE_TBL
);
1769 rate_ctrl
->max_valid_rate
= k
;
1771 * Some third party vendors don't send the supported rate series in
1772 * order. So sorting to make sure its in order, otherwise our RateFind
1773 * Algo will select wrong rates
1775 ath_rc_sort_validrates(rate_table
, rate_ctrl
);
1776 rate_ctrl
->rate_max_phy
= rate_ctrl
->valid_rate_index
[k
-4];
1780 * Update rate-control state on station associate/reassociate.
1782 static int ath_rate_newassoc(struct ath_softc
*sc
,
1783 struct ath_rate_node
*ath_rc_priv
,
1784 unsigned int capflag
,
1785 struct ath_rateset
*negotiated_rates
,
1786 struct ath_rateset
*negotiated_htrates
)
1790 ath_rc_priv
->ht_cap
=
1791 ((capflag
& ATH_RC_DS_FLAG
) ? WLAN_RC_DS_FLAG
: 0) |
1792 ((capflag
& ATH_RC_SGI_FLAG
) ? WLAN_RC_SGI_FLAG
: 0) |
1793 ((capflag
& ATH_RC_HT_FLAG
) ? WLAN_RC_HT_FLAG
: 0) |
1794 ((capflag
& ATH_RC_CW40_FLAG
) ? WLAN_RC_40_FLAG
: 0);
1796 ath_rc_sib_update(sc
, ath_rc_priv
, ath_rc_priv
->ht_cap
, 0,
1797 negotiated_rates
, negotiated_htrates
);
1803 * This routine is called to initialize the rate control parameters
1804 * in the SIB. It is called initially during system initialization
1805 * or when a station is associated with the AP.
1807 static void ath_rc_sib_init(struct ath_rate_node
*ath_rc_priv
)
1809 struct ath_tx_ratectrl
*rate_ctrl
;
1811 rate_ctrl
= (struct ath_tx_ratectrl
*)(ath_rc_priv
);
1812 rate_ctrl
->rssi_down_time
= jiffies_to_msecs(jiffies
);
1816 static void ath_setup_rates(struct ieee80211_local
*local
, struct sta_info
*sta
)
1819 struct ieee80211_supported_band
*sband
;
1820 struct ieee80211_hw
*hw
= local_to_hw(local
);
1821 struct ath_softc
*sc
= hw
->priv
;
1822 struct ath_rate_node
*rc_priv
= sta
->rate_ctrl_priv
;
1825 DPRINTF(sc
, ATH_DEBUG_RATE
, "%s", __func__
);
1826 sband
= local
->hw
.wiphy
->bands
[local
->hw
.conf
.channel
->band
];
1827 for (i
= 0; i
< sband
->n_bitrates
; i
++) {
1828 if (sta
->supp_rates
[local
->hw
.conf
.channel
->band
] & BIT(i
)) {
1829 rc_priv
->neg_rates
.rs_rates
[j
]
1830 = (sband
->bitrates
[i
].bitrate
* 2) / 10;
1834 rc_priv
->neg_rates
.rs_nrates
= j
;
1837 static void ath_rc_node_update(struct ieee80211_hw
*hw
,
1838 struct ath_rate_node
*rc_priv
)
1840 struct ath_softc
*sc
= hw
->priv
;
1841 u_int32_t capflag
= 0;
1843 if (hw
->conf
.ht_conf
.ht_supported
) {
1844 capflag
|= ATH_RC_HT_FLAG
| ATH_RC_DS_FLAG
;
1845 if (sc
->sc_ht_info
.tx_chan_width
== HAL_HT_MACMODE_2040
)
1846 capflag
|= ATH_RC_CW40_FLAG
;
1849 ath_rate_newassoc(sc
, rc_priv
, capflag
,
1850 &rc_priv
->neg_rates
,
1851 &rc_priv
->neg_ht_rates
);
1855 /* Rate Control callbacks */
1856 static void ath_tx_status(void *priv
, struct net_device
*dev
,
1857 struct sk_buff
*skb
)
1859 struct ath_softc
*sc
= priv
;
1860 struct ath_tx_info_priv
*tx_info_priv
;
1861 struct ath_node
*an
;
1862 struct sta_info
*sta
;
1863 struct ieee80211_local
*local
;
1864 struct ieee80211_tx_info
*tx_info
= IEEE80211_SKB_CB(skb
);
1865 struct ieee80211_hdr
*hdr
;
1868 local
= hw_to_local(sc
->hw
);
1869 hdr
= (struct ieee80211_hdr
*)skb
->data
;
1870 fc
= hdr
->frame_control
;
1871 tx_info_priv
= (struct ath_tx_info_priv
*)tx_info
->driver_data
[0];
1873 spin_lock_bh(&sc
->node_lock
);
1874 an
= ath_node_find(sc
, hdr
->addr1
);
1875 spin_unlock_bh(&sc
->node_lock
);
1877 sta
= sta_info_get(local
, hdr
->addr1
);
1878 if (!an
|| !sta
|| !ieee80211_is_data(fc
)) {
1879 if (tx_info
->driver_data
[0] != NULL
) {
1880 kfree(tx_info
->driver_data
[0]);
1881 tx_info
->driver_data
[0] = NULL
;
1885 if (tx_info
->driver_data
[0] != NULL
) {
1886 ath_rate_tx_complete(sc
, an
, sta
->rate_ctrl_priv
, tx_info_priv
);
1887 kfree(tx_info
->driver_data
[0]);
1888 tx_info
->driver_data
[0] = NULL
;
1892 static void ath_tx_aggr_resp(struct ath_softc
*sc
,
1893 struct sta_info
*sta
,
1894 struct ath_node
*an
,
1897 struct ieee80211_hw
*hw
= sc
->hw
;
1898 struct ieee80211_local
*local
;
1899 struct ath_atx_tid
*txtid
;
1900 struct ieee80211_supported_band
*sband
;
1903 DECLARE_MAC_BUF(mac
);
1908 txtid
= ATH_AN_2_TID(an
, tidno
);
1912 local
= hw_to_local(sc
->hw
);
1913 sband
= hw
->wiphy
->bands
[hw
->conf
.channel
->band
];
1914 buffersize
= IEEE80211_MIN_AMPDU_BUF
<<
1915 sband
->ht_info
.ampdu_factor
; /* FIXME */
1916 state
= sta
->ampdu_mlme
.tid_state_tx
[tidno
];
1918 if (state
& HT_ADDBA_RECEIVED_MSK
) {
1919 txtid
->addba_exchangecomplete
= 1;
1920 txtid
->addba_exchangeinprogress
= 0;
1921 txtid
->baw_size
= buffersize
;
1923 DPRINTF(sc
, ATH_DEBUG_AGGR
,
1924 "%s: Resuming tid, buffersize: %d\n",
1928 ath_tx_resume_tid(sc
, txtid
);
1932 static void ath_get_rate(void *priv
, struct net_device
*dev
,
1933 struct ieee80211_supported_band
*sband
,
1934 struct sk_buff
*skb
,
1935 struct rate_selection
*sel
)
1937 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)skb
->data
;
1938 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
1939 struct sta_info
*sta
;
1940 struct ath_softc
*sc
= (struct ath_softc
*)priv
;
1941 struct ieee80211_hw
*hw
= sc
->hw
;
1942 struct ath_tx_info_priv
*tx_info_priv
;
1943 struct ath_rate_node
*ath_rc_priv
;
1944 struct ath_node
*an
;
1945 struct ieee80211_tx_info
*tx_info
= IEEE80211_SKB_CB(skb
);
1946 int is_probe
, chk
, ret
;
1948 __le16 fc
= hdr
->frame_control
;
1950 DECLARE_MAC_BUF(mac
);
1952 DPRINTF(sc
, ATH_DEBUG_RATE
, "%s\n", __func__
);
1954 /* allocate driver private area of tx_info */
1955 tx_info
->driver_data
[0] = kzalloc(sizeof(*tx_info_priv
), GFP_ATOMIC
);
1956 ASSERT(tx_info
->driver_data
[0] != NULL
);
1957 tx_info_priv
= (struct ath_tx_info_priv
*)tx_info
->driver_data
[0];
1959 sta
= sta_info_get(local
, hdr
->addr1
);
1960 lowest_idx
= rate_lowest_index(local
, sband
, sta
);
1961 tx_info_priv
->min_rate
= (sband
->bitrates
[lowest_idx
].bitrate
* 2) / 10;
1962 /* lowest rate for management and multicast/broadcast frames */
1963 if (!ieee80211_is_data(fc
) ||
1964 is_multicast_ether_addr(hdr
->addr1
) || !sta
) {
1965 sel
->rate_idx
= lowest_idx
;
1969 ath_rc_priv
= sta
->rate_ctrl_priv
;
1971 /* Find tx rate for unicast frames */
1972 ath_rate_findrate(sc
, ath_rc_priv
,
1973 ATH_11N_TXMAXTRY
, 4,
1974 ATH_RC_PROBE_ALLOWED
,
1978 if (is_probe
== AH_TRUE
)
1979 sel
->probe_idx
= ((struct ath_tx_ratectrl
*)
1980 sta
->rate_ctrl_priv
)->probe_rate
;
1982 /* Ratecontrol sometimes returns invalid rate index */
1983 if (tx_info_priv
->rcs
[0].rix
!= 0xff)
1984 ath_rc_priv
->prev_data_rix
= tx_info_priv
->rcs
[0].rix
;
1986 tx_info_priv
->rcs
[0].rix
= ath_rc_priv
->prev_data_rix
;
1988 sel
->rate_idx
= tx_info_priv
->rcs
[0].rix
;
1990 /* Check if aggregation has to be enabled for this tid */
1992 if (hw
->conf
.ht_conf
.ht_supported
) {
1993 if (ieee80211_is_data_qos(fc
)) {
1994 qc
= ieee80211_get_qos_ctl(hdr
);
1997 spin_lock_bh(&sc
->node_lock
);
1998 an
= ath_node_find(sc
, hdr
->addr1
);
1999 spin_unlock_bh(&sc
->node_lock
);
2002 DPRINTF(sc
, ATH_DEBUG_AGGR
,
2003 "%s: Node not found to "
2004 "init/chk TX aggr\n", __func__
);
2008 chk
= ath_tx_aggr_check(sc
, an
, tid
);
2009 if (chk
== AGGR_REQUIRED
) {
2010 ret
= ieee80211_start_tx_ba_session(hw
,
2013 DPRINTF(sc
, ATH_DEBUG_AGGR
,
2014 "%s: Unable to start tx "
2017 print_mac(mac
, hdr
->addr1
));
2019 DPRINTF(sc
, ATH_DEBUG_AGGR
,
2020 "%s: Started tx aggr for: %s\n",
2022 print_mac(mac
, hdr
->addr1
));
2023 } else if (chk
== AGGR_EXCHANGE_PROGRESS
)
2024 ath_tx_aggr_resp(sc
, sta
, an
, tid
);
2029 static void ath_rate_init(void *priv
, void *priv_sta
,
2030 struct ieee80211_local
*local
,
2031 struct sta_info
*sta
)
2033 struct ieee80211_supported_band
*sband
;
2034 struct ieee80211_hw
*hw
= local_to_hw(local
);
2035 struct ieee80211_conf
*conf
= &local
->hw
.conf
;
2036 struct ath_softc
*sc
= hw
->priv
;
2037 struct hal_channel hchan
;
2040 DPRINTF(sc
, ATH_DEBUG_RATE
, "%s", __func__
);
2042 sband
= local
->hw
.wiphy
->bands
[local
->hw
.conf
.channel
->band
];
2043 sta
->txrate_idx
= rate_lowest_index(local
, sband
, sta
);
2045 hchan
.channel
= conf
->channel
->center_freq
;
2046 hchan
.channelFlags
= ath_chan2flags(conf
->channel
, sc
);
2047 if (ath_set_channel(sc
, &hchan
) < 0)
2048 DPRINTF(sc
, ATH_DEBUG_FATAL
, "%s: Unable to set channel\n",
2050 ath_setup_rates(local
, sta
);
2051 if (conf
->flags
&IEEE80211_CONF_SUPPORT_HT_MODE
) {
2052 for (i
= 0; i
< MCS_SET_SIZE
; i
++) {
2053 if (conf
->ht_conf
.supp_mcs_set
[i
/8] & (1<<(i
%8)))
2054 ((struct ath_rate_node
*)
2055 priv_sta
)->neg_ht_rates
.rs_rates
[j
++] = i
;
2056 if (j
== ATH_RATE_MAX
)
2059 ((struct ath_rate_node
*)priv_sta
)->neg_ht_rates
.rs_nrates
= j
;
2061 ath_rc_node_update(hw
, priv_sta
);
2064 static void ath_rate_clear(void *priv
)
2069 static void *ath_rate_alloc(struct ieee80211_local
*local
)
2071 struct ieee80211_hw
*hw
= local_to_hw(local
);
2072 struct ath_softc
*sc
= hw
->priv
;
2074 DPRINTF(sc
, ATH_DEBUG_RATE
, "%s", __func__
);
2075 return local
->hw
.priv
;
2078 static void ath_rate_free(void *priv
)
2083 static void *ath_rate_alloc_sta(void *priv
, gfp_t gfp
)
2085 struct ath_softc
*sc
= priv
;
2086 struct ath_vap
*avp
= sc
->sc_vaps
[0];
2087 struct ath_rate_node
*rate_priv
;
2089 DPRINTF(sc
, ATH_DEBUG_RATE
, "%s", __func__
);
2090 rate_priv
= ath_rate_node_alloc(avp
, sc
->sc_rc
, gfp
);
2092 DPRINTF(sc
, ATH_DEBUG_FATAL
, "%s:Unable to allocate"
2093 "private rate control structure", __func__
);
2096 ath_rc_sib_init(rate_priv
);
2100 static void ath_rate_free_sta(void *priv
, void *priv_sta
)
2102 struct ath_rate_node
*rate_priv
= priv_sta
;
2103 struct ath_softc
*sc
= priv
;
2105 DPRINTF(sc
, ATH_DEBUG_RATE
, "%s", __func__
);
2106 ath_rate_node_free(rate_priv
);
2109 static struct rate_control_ops ath_rate_ops
= {
2111 .name
= "ath9k_rate_control",
2112 .tx_status
= ath_tx_status
,
2113 .get_rate
= ath_get_rate
,
2114 .rate_init
= ath_rate_init
,
2115 .clear
= ath_rate_clear
,
2116 .alloc
= ath_rate_alloc
,
2117 .free
= ath_rate_free
,
2118 .alloc_sta
= ath_rate_alloc_sta
,
2119 .free_sta
= ath_rate_free_sta
2122 int ath_rate_control_register(void)
2124 return ieee80211_rate_control_register(&ath_rate_ops
);
2127 void ath_rate_control_unregister(void)
2129 ieee80211_rate_control_unregister(&ath_rate_ops
);