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 /* FIXME: remove this include! */
24 #include "../net/mac80211/rate.h"
26 static u32 tx_triglevel_max
;
28 static struct ath_rate_table ar5416_11na_ratetable
= {
31 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 6000, /* 6 Mb */
33 0, 2, 1, 0, 0, 0, 0, 0 },
34 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 9000, /* 9 Mb */
36 0, 3, 1, 1, 1, 1, 1, 0 },
37 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 12000, /* 12 Mb */
38 10000, 0x0a, 0x00, 24,
39 2, 4, 2, 2, 2, 2, 2, 0 },
40 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 18000, /* 18 Mb */
41 13900, 0x0e, 0x00, 36,
42 2, 6, 2, 3, 3, 3, 3, 0 },
43 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 24000, /* 24 Mb */
44 17300, 0x09, 0x00, 48,
45 4, 10, 3, 4, 4, 4, 4, 0 },
46 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 36000, /* 36 Mb */
47 23000, 0x0d, 0x00, 72,
48 4, 14, 3, 5, 5, 5, 5, 0 },
49 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 48000, /* 48 Mb */
50 27400, 0x08, 0x00, 96,
51 4, 20, 3, 6, 6, 6, 6, 0 },
52 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 54000, /* 54 Mb */
53 29300, 0x0c, 0x00, 108,
54 4, 23, 3, 7, 7, 7, 7, 0 },
55 { TRUE_20
, TRUE_20
, WLAN_PHY_HT_20_SS
, 6500, /* 6.5 Mb */
57 0, 2, 3, 8, 24, 8, 24, 3216 },
58 { TRUE_20
, TRUE_20
, WLAN_PHY_HT_20_SS
, 13000, /* 13 Mb */
60 2, 4, 3, 9, 25, 9, 25, 6434 },
61 { TRUE_20
, TRUE_20
, WLAN_PHY_HT_20_SS
, 19500, /* 19.5 Mb */
63 2, 6, 3, 10, 26, 10, 26, 9650 },
64 { TRUE_20
, TRUE_20
, WLAN_PHY_HT_20_SS
, 26000, /* 26 Mb */
66 4, 10, 3, 11, 27, 11, 27, 12868 },
67 { TRUE_20
, TRUE_20
, WLAN_PHY_HT_20_SS
, 39000, /* 39 Mb */
69 4, 14, 3, 12, 28, 12, 28, 19304 },
70 { FALSE
, TRUE_20
, WLAN_PHY_HT_20_SS
, 52000, /* 52 Mb */
72 4, 20, 3, 13, 29, 13, 29, 25740 },
73 { FALSE
, TRUE_20
, WLAN_PHY_HT_20_SS
, 58500, /* 58.5 Mb */
75 4, 23, 3, 14, 30, 14, 30, 28956 },
76 { FALSE
, TRUE_20
, WLAN_PHY_HT_20_SS
, 65000, /* 65 Mb */
78 4, 25, 3, 15, 31, 15, 32, 32180 },
79 { FALSE
, FALSE
, WLAN_PHY_HT_20_DS
, 13000, /* 13 Mb */
81 8, 0, 2, 3, 16, 33, 16, 33, 6430 },
82 { FALSE
, FALSE
, WLAN_PHY_HT_20_DS
, 26000, /* 26 Mb */
84 2, 4, 3, 17, 34, 17, 34, 12860 },
85 { FALSE
, FALSE
, WLAN_PHY_HT_20_DS
, 39000, /* 39 Mb */
86 36600, 0x8a, 0x00, 10,
87 2, 6, 3, 18, 35, 18, 35, 19300 },
88 { TRUE_20
, FALSE
, WLAN_PHY_HT_20_DS
, 52000, /* 52 Mb */
89 48100, 0x8b, 0x00, 11,
90 4, 10, 3, 19, 36, 19, 36, 25736 },
91 { TRUE_20
, FALSE
, WLAN_PHY_HT_20_DS
, 78000, /* 78 Mb */
92 69500, 0x8c, 0x00, 12,
93 4, 14, 3, 20, 37, 20, 37, 38600 },
94 { TRUE_20
, FALSE
, WLAN_PHY_HT_20_DS
, 104000, /* 104 Mb */
95 89500, 0x8d, 0x00, 13,
96 4, 20, 3, 21, 38, 21, 38, 51472 },
97 { TRUE_20
, FALSE
, WLAN_PHY_HT_20_DS
, 117000, /* 117 Mb */
98 98900, 0x8e, 0x00, 14,
99 4, 23, 3, 22, 39, 22, 39, 57890 },
100 { TRUE_20
, FALSE
, WLAN_PHY_HT_20_DS
, 130000, /* 130 Mb */
101 108300, 0x8f, 0x00, 15,
102 4, 25, 3, 23, 40, 23, 41, 64320 },
103 { TRUE_40
, TRUE_40
, WLAN_PHY_HT_40_SS
, 13500, /* 13.5 Mb */
104 13200, 0x80, 0x00, 0,
105 0, 2, 3, 8, 24, 24, 24, 6684 },
106 { TRUE_40
, TRUE_40
, WLAN_PHY_HT_40_SS
, 27500, /* 27.0 Mb */
107 25900, 0x81, 0x00, 1,
108 2, 4, 3, 9, 25, 25, 25, 13368 },
109 { TRUE_40
, TRUE_40
, WLAN_PHY_HT_40_SS
, 40500, /* 40.5 Mb */
110 38600, 0x82, 0x00, 2,
111 2, 6, 3, 10, 26, 26, 26, 20052 },
112 { TRUE_40
, TRUE_40
, WLAN_PHY_HT_40_SS
, 54000, /* 54 Mb */
113 49800, 0x83, 0x00, 3,
114 4, 10, 3, 11, 27, 27, 27, 26738 },
115 { TRUE_40
, TRUE_40
, WLAN_PHY_HT_40_SS
, 81500, /* 81 Mb */
116 72200, 0x84, 0x00, 4,
117 4, 14, 3, 12, 28, 28, 28, 40104 },
118 { FALSE
, TRUE_40
, WLAN_PHY_HT_40_SS
, 108000, /* 108 Mb */
119 92900, 0x85, 0x00, 5,
120 4, 20, 3, 13, 29, 29, 29, 53476 },
121 { FALSE
, TRUE_40
, WLAN_PHY_HT_40_SS
, 121500, /* 121.5 Mb */
122 102700, 0x86, 0x00, 6,
123 4, 23, 3, 14, 30, 30, 30, 60156 },
124 { FALSE
, TRUE_40
, WLAN_PHY_HT_40_SS
, 135000, /* 135 Mb */
125 112000, 0x87, 0x00, 7,
126 4, 25, 3, 15, 31, 32, 32, 66840 },
127 { FALSE
, TRUE_40
, WLAN_PHY_HT_40_SS_HGI
, 150000, /* 150 Mb */
128 122000, 0x87, 0x00, 7,
129 4, 25, 3, 15, 31, 32, 32, 74200 },
130 { FALSE
, FALSE
, WLAN_PHY_HT_40_DS
, 27000, /* 27 Mb */
131 25800, 0x88, 0x00, 8,
132 0, 2, 3, 16, 33, 33, 33, 13360 },
133 { FALSE
, FALSE
, WLAN_PHY_HT_40_DS
, 54000, /* 54 Mb */
134 49800, 0x89, 0x00, 9,
135 2, 4, 3, 17, 34, 34, 34, 26720 },
136 { FALSE
, FALSE
, WLAN_PHY_HT_40_DS
, 81000, /* 81 Mb */
137 71900, 0x8a, 0x00, 10,
138 2, 6, 3, 18, 35, 35, 35, 40080 },
139 { TRUE_40
, FALSE
, WLAN_PHY_HT_40_DS
, 108000, /* 108 Mb */
140 92500, 0x8b, 0x00, 11,
141 4, 10, 3, 19, 36, 36, 36, 53440 },
142 { TRUE_40
, FALSE
, WLAN_PHY_HT_40_DS
, 162000, /* 162 Mb */
143 130300, 0x8c, 0x00, 12,
144 4, 14, 3, 20, 37, 37, 37, 80160 },
145 { TRUE_40
, FALSE
, WLAN_PHY_HT_40_DS
, 216000, /* 216 Mb */
146 162800, 0x8d, 0x00, 13,
147 4, 20, 3, 21, 38, 38, 38, 106880 },
148 { TRUE_40
, FALSE
, WLAN_PHY_HT_40_DS
, 243000, /* 243 Mb */
149 178200, 0x8e, 0x00, 14,
150 4, 23, 3, 22, 39, 39, 39, 120240 },
151 { TRUE_40
, FALSE
, WLAN_PHY_HT_40_DS
, 270000, /* 270 Mb */
152 192100, 0x8f, 0x00, 15,
153 4, 25, 3, 23, 40, 41, 41, 133600 },
154 { TRUE_40
, FALSE
, WLAN_PHY_HT_40_DS_HGI
, 300000, /* 300 Mb */
155 207000, 0x8f, 0x00, 15,
156 4, 25, 3, 23, 40, 41, 41, 148400 },
158 50, /* probe interval */
159 50, /* rssi reduce interval */
160 WLAN_RC_HT_FLAG
, /* Phy rates allowed initially */
163 /* TRUE_ALL - valid for 20/40/Legacy,
164 * TRUE - Legacy only,
165 * TRUE_20 - HT 20 only,
166 * TRUE_40 - HT 40 only */
168 /* 4ms frame limit not used for NG mode. The values filled
169 * for HT are the 64K max aggregate limit */
171 static struct ath_rate_table ar5416_11ng_ratetable
= {
174 { TRUE_ALL
, TRUE_ALL
, WLAN_PHY_CCK
, 1000, /* 1 Mb */
176 0, 0, 1, 0, 0, 0, 0, 0 },
177 { TRUE_ALL
, TRUE_ALL
, WLAN_PHY_CCK
, 2000, /* 2 Mb */
179 1, 1, 1, 1, 1, 1, 1, 0 },
180 { TRUE_ALL
, TRUE_ALL
, WLAN_PHY_CCK
, 5500, /* 5.5 Mb */
181 4900, 0x19, 0x04, 11,
182 2, 2, 2, 2, 2, 2, 2, 0 },
183 { TRUE_ALL
, TRUE_ALL
, WLAN_PHY_CCK
, 11000, /* 11 Mb */
184 8100, 0x18, 0x04, 22,
185 3, 3, 2, 3, 3, 3, 3, 0 },
186 { FALSE
, FALSE
, WLAN_PHY_OFDM
, 6000, /* 6 Mb */
187 5400, 0x0b, 0x00, 12,
188 4, 2, 1, 4, 4, 4, 4, 0 },
189 { FALSE
, FALSE
, WLAN_PHY_OFDM
, 9000, /* 9 Mb */
190 7800, 0x0f, 0x00, 18,
191 4, 3, 1, 5, 5, 5, 5, 0 },
192 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 12000, /* 12 Mb */
193 10100, 0x0a, 0x00, 24,
194 6, 4, 1, 6, 6, 6, 6, 0 },
195 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 18000, /* 18 Mb */
196 14100, 0x0e, 0x00, 36,
197 6, 6, 2, 7, 7, 7, 7, 0 },
198 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 24000, /* 24 Mb */
199 17700, 0x09, 0x00, 48,
200 8, 10, 3, 8, 8, 8, 8, 0 },
201 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 36000, /* 36 Mb */
202 23700, 0x0d, 0x00, 72,
203 8, 14, 3, 9, 9, 9, 9, 0 },
204 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 48000, /* 48 Mb */
205 27400, 0x08, 0x00, 96,
206 8, 20, 3, 10, 10, 10, 10, 0 },
207 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 54000, /* 54 Mb */
208 30900, 0x0c, 0x00, 108,
209 8, 23, 3, 11, 11, 11, 11, 0 },
210 { FALSE
, FALSE
, WLAN_PHY_HT_20_SS
, 6500, /* 6.5 Mb */
212 4, 2, 3, 12, 28, 12, 28, 3216 },
213 { TRUE_20
, TRUE_20
, WLAN_PHY_HT_20_SS
, 13000, /* 13 Mb */
214 12700, 0x81, 0x00, 1,
215 6, 4, 3, 13, 29, 13, 29, 6434 },
216 { TRUE_20
, TRUE_20
, WLAN_PHY_HT_20_SS
, 19500, /* 19.5 Mb */
217 18800, 0x82, 0x00, 2,
218 6, 6, 3, 14, 30, 14, 30, 9650 },
219 { TRUE_20
, TRUE_20
, WLAN_PHY_HT_20_SS
, 26000, /* 26 Mb */
220 25000, 0x83, 0x00, 3,
221 8, 10, 3, 15, 31, 15, 31, 12868 },
222 { TRUE_20
, TRUE_20
, WLAN_PHY_HT_20_SS
, 39000, /* 39 Mb */
223 36700, 0x84, 0x00, 4,
224 8, 14, 3, 16, 32, 16, 32, 19304 },
225 { FALSE
, TRUE_20
, WLAN_PHY_HT_20_SS
, 52000, /* 52 Mb */
226 48100, 0x85, 0x00, 5,
227 8, 20, 3, 17, 33, 17, 33, 25740 },
228 { FALSE
, TRUE_20
, WLAN_PHY_HT_20_SS
, 58500, /* 58.5 Mb */
229 53500, 0x86, 0x00, 6,
230 8, 23, 3, 18, 34, 18, 34, 28956 },
231 { FALSE
, TRUE_20
, WLAN_PHY_HT_20_SS
, 65000, /* 65 Mb */
232 59000, 0x87, 0x00, 7,
233 8, 25, 3, 19, 35, 19, 36, 32180 },
234 { FALSE
, FALSE
, WLAN_PHY_HT_20_DS
, 13000, /* 13 Mb */
235 12700, 0x88, 0x00, 8,
236 4, 2, 3, 20, 37, 20, 37, 6430 },
237 { FALSE
, FALSE
, WLAN_PHY_HT_20_DS
, 26000, /* 26 Mb */
238 24800, 0x89, 0x00, 9,
239 6, 4, 3, 21, 38, 21, 38, 12860 },
240 { FALSE
, FALSE
, WLAN_PHY_HT_20_DS
, 39000, /* 39 Mb */
241 36600, 0x8a, 0x00, 10,
242 6, 6, 3, 22, 39, 22, 39, 19300 },
243 { TRUE_20
, FALSE
, WLAN_PHY_HT_20_DS
, 52000, /* 52 Mb */
244 48100, 0x8b, 0x00, 11,
245 8, 10, 3, 23, 40, 23, 40, 25736 },
246 { TRUE_20
, FALSE
, WLAN_PHY_HT_20_DS
, 78000, /* 78 Mb */
247 69500, 0x8c, 0x00, 12,
248 8, 14, 3, 24, 41, 24, 41, 38600 },
249 { TRUE_20
, FALSE
, WLAN_PHY_HT_20_DS
, 104000, /* 104 Mb */
250 89500, 0x8d, 0x00, 13,
251 8, 20, 3, 25, 42, 25, 42, 51472 },
252 { TRUE_20
, FALSE
, WLAN_PHY_HT_20_DS
, 117000, /* 117 Mb */
253 98900, 0x8e, 0x00, 14,
254 8, 23, 3, 26, 43, 26, 44, 57890 },
255 { TRUE_20
, FALSE
, WLAN_PHY_HT_20_DS
, 130000, /* 130 Mb */
256 108300, 0x8f, 0x00, 15,
257 8, 25, 3, 27, 44, 27, 45, 64320 },
258 { TRUE_40
, TRUE_40
, WLAN_PHY_HT_40_SS
, 13500, /* 13.5 Mb */
259 13200, 0x80, 0x00, 0,
260 8, 2, 3, 12, 28, 28, 28, 6684 },
261 { TRUE_40
, TRUE_40
, WLAN_PHY_HT_40_SS
, 27500, /* 27.0 Mb */
262 25900, 0x81, 0x00, 1,
263 8, 4, 3, 13, 29, 29, 29, 13368 },
264 { TRUE_40
, TRUE_40
, WLAN_PHY_HT_40_SS
, 40500, /* 40.5 Mb */
265 38600, 0x82, 0x00, 2,
266 8, 6, 3, 14, 30, 30, 30, 20052 },
267 { TRUE_40
, TRUE_40
, WLAN_PHY_HT_40_SS
, 54000, /* 54 Mb */
268 49800, 0x83, 0x00, 3,
269 8, 10, 3, 15, 31, 31, 31, 26738 },
270 { TRUE_40
, TRUE_40
, WLAN_PHY_HT_40_SS
, 81500, /* 81 Mb */
271 72200, 0x84, 0x00, 4,
272 8, 14, 3, 16, 32, 32, 32, 40104 },
273 { FALSE
, TRUE_40
, WLAN_PHY_HT_40_SS
, 108000, /* 108 Mb */
274 92900, 0x85, 0x00, 5,
275 8, 20, 3, 17, 33, 33, 33, 53476 },
276 { FALSE
, TRUE_40
, WLAN_PHY_HT_40_SS
, 121500, /* 121.5 Mb */
277 102700, 0x86, 0x00, 6,
278 8, 23, 3, 18, 34, 34, 34, 60156 },
279 { FALSE
, TRUE_40
, WLAN_PHY_HT_40_SS
, 135000, /* 135 Mb */
280 112000, 0x87, 0x00, 7,
281 8, 23, 3, 19, 35, 36, 36, 66840 },
282 { FALSE
, TRUE_40
, WLAN_PHY_HT_40_SS_HGI
, 150000, /* 150 Mb */
283 122000, 0x87, 0x00, 7,
284 8, 25, 3, 19, 35, 36, 36, 74200 },
285 { FALSE
, FALSE
, WLAN_PHY_HT_40_DS
, 27000, /* 27 Mb */
286 25800, 0x88, 0x00, 8,
287 8, 2, 3, 20, 37, 37, 37, 13360 },
288 { FALSE
, FALSE
, WLAN_PHY_HT_40_DS
, 54000, /* 54 Mb */
289 49800, 0x89, 0x00, 9,
290 8, 4, 3, 21, 38, 38, 38, 26720 },
291 { FALSE
, FALSE
, WLAN_PHY_HT_40_DS
, 81000, /* 81 Mb */
292 71900, 0x8a, 0x00, 10,
293 8, 6, 3, 22, 39, 39, 39, 40080 },
294 { TRUE_40
, FALSE
, WLAN_PHY_HT_40_DS
, 108000, /* 108 Mb */
295 92500, 0x8b, 0x00, 11,
296 8, 10, 3, 23, 40, 40, 40, 53440 },
297 { TRUE_40
, FALSE
, WLAN_PHY_HT_40_DS
, 162000, /* 162 Mb */
298 130300, 0x8c, 0x00, 12,
299 8, 14, 3, 24, 41, 41, 41, 80160 },
300 { TRUE_40
, FALSE
, WLAN_PHY_HT_40_DS
, 216000, /* 216 Mb */
301 162800, 0x8d, 0x00, 13,
302 8, 20, 3, 25, 42, 42, 42, 106880 },
303 { TRUE_40
, FALSE
, WLAN_PHY_HT_40_DS
, 243000, /* 243 Mb */
304 178200, 0x8e, 0x00, 14,
305 8, 23, 3, 26, 43, 43, 43, 120240 },
306 { TRUE_40
, FALSE
, WLAN_PHY_HT_40_DS
, 270000, /* 270 Mb */
307 192100, 0x8f, 0x00, 15,
308 8, 23, 3, 27, 44, 45, 45, 133600 },
309 { TRUE_40
, FALSE
, WLAN_PHY_HT_40_DS_HGI
, 300000, /* 300 Mb */
310 207000, 0x8f, 0x00, 15,
311 8, 25, 3, 27, 44, 45, 45, 148400 },
313 50, /* probe interval */
314 50, /* rssi reduce interval */
315 WLAN_RC_HT_FLAG
, /* Phy rates allowed initially */
318 static struct ath_rate_table ar5416_11a_ratetable
= {
321 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 6000, /* 6 Mb */
322 5400, 0x0b, 0x00, (0x80|12),
324 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 9000, /* 9 Mb */
325 7800, 0x0f, 0x00, 18,
327 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 12000, /* 12 Mb */
328 10000, 0x0a, 0x00, (0x80|24),
330 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 18000, /* 18 Mb */
331 13900, 0x0e, 0x00, 36,
333 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 24000, /* 24 Mb */
334 17300, 0x09, 0x00, (0x80|48),
336 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 36000, /* 36 Mb */
337 23000, 0x0d, 0x00, 72,
339 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 48000, /* 48 Mb */
340 27400, 0x08, 0x00, 96,
342 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 54000, /* 54 Mb */
343 29300, 0x0c, 0x00, 108,
346 50, /* probe interval */
347 50, /* rssi reduce interval */
348 0, /* Phy rates allowed initially */
351 static struct ath_rate_table ar5416_11a_ratetable_Half
= {
354 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 3000, /* 6 Mb */
355 2700, 0x0b, 0x00, (0x80|6),
357 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 4500, /* 9 Mb */
360 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 6000, /* 12 Mb */
361 5000, 0x0a, 0x00, (0x80|12),
363 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 9000, /* 18 Mb */
364 6950, 0x0e, 0x00, 18,
366 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 12000, /* 24 Mb */
367 8650, 0x09, 0x00, (0x80|24),
369 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 18000, /* 36 Mb */
370 11500, 0x0d, 0x00, 36,
372 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 24000, /* 48 Mb */
373 13700, 0x08, 0x00, 48,
375 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 27000, /* 54 Mb */
376 14650, 0x0c, 0x00, 54,
379 50, /* probe interval */
380 50, /* rssi reduce interval */
381 0, /* Phy rates allowed initially */
384 static struct ath_rate_table ar5416_11a_ratetable_Quarter
= {
387 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 1500, /* 6 Mb */
388 1350, 0x0b, 0x00, (0x80|3),
390 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 2250, /* 9 Mb */
393 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 3000, /* 12 Mb */
394 2500, 0x0a, 0x00, (0x80|6),
396 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 4500, /* 18 Mb */
399 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 6000, /* 25 Mb */
400 4325, 0x09, 0x00, (0x80|12),
402 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 9000, /* 36 Mb */
403 5750, 0x0d, 0x00, 18,
405 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 12000, /* 48 Mb */
406 6850, 0x08, 0x00, 24,
408 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 13500, /* 54 Mb */
409 7325, 0x0c, 0x00, 27,
412 50, /* probe interval */
413 50, /* rssi reduce interval */
414 0, /* Phy rates allowed initially */
417 static struct ath_rate_table ar5416_11g_ratetable
= {
420 { TRUE
, TRUE
, WLAN_PHY_CCK
, 1000, /* 1 Mb */
423 { TRUE
, TRUE
, WLAN_PHY_CCK
, 2000, /* 2 Mb */
426 { TRUE
, TRUE
, WLAN_PHY_CCK
, 5500, /* 5.5 Mb */
427 4900, 0x19, 0x04, 11,
429 { TRUE
, TRUE
, WLAN_PHY_CCK
, 11000, /* 11 Mb */
430 8100, 0x18, 0x04, 22,
432 { FALSE
, FALSE
, WLAN_PHY_OFDM
, 6000, /* 6 Mb */
433 5400, 0x0b, 0x00, 12,
435 { FALSE
, FALSE
, WLAN_PHY_OFDM
, 9000, /* 9 Mb */
436 7800, 0x0f, 0x00, 18,
438 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 12000, /* 12 Mb */
439 10000, 0x0a, 0x00, 24,
441 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 18000, /* 18 Mb */
442 13900, 0x0e, 0x00, 36,
444 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 24000, /* 24 Mb */
445 17300, 0x09, 0x00, 48,
447 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 36000, /* 36 Mb */
448 23000, 0x0d, 0x00, 72,
450 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 48000, /* 48 Mb */
451 27400, 0x08, 0x00, 96,
453 { TRUE
, TRUE
, WLAN_PHY_OFDM
, 54000, /* 54 Mb */
454 29300, 0x0c, 0x00, 108,
457 50, /* probe interval */
458 50, /* rssi reduce interval */
459 0, /* Phy rates allowed initially */
462 static struct ath_rate_table ar5416_11b_ratetable
= {
465 { TRUE
, TRUE
, WLAN_PHY_CCK
, 1000, /* 1 Mb */
466 900, 0x1b, 0x00, (0x80|2),
468 { TRUE
, TRUE
, WLAN_PHY_CCK
, 2000, /* 2 Mb */
469 1800, 0x1a, 0x04, (0x80|4),
471 { TRUE
, TRUE
, WLAN_PHY_CCK
, 5500, /* 5.5 Mb */
472 4300, 0x19, 0x04, (0x80|11),
474 { TRUE
, TRUE
, WLAN_PHY_CCK
, 11000, /* 11 Mb */
475 7100, 0x18, 0x04, (0x80|22),
478 100, /* probe interval */
479 100, /* rssi reduce interval */
480 0, /* Phy rates allowed initially */
483 static void ar5416_attach_ratetables(struct ath_rate_softc
*sc
)
486 * Attach rate tables.
488 sc
->hw_rate_table
[ATH9K_MODE_11B
] = &ar5416_11b_ratetable
;
489 sc
->hw_rate_table
[ATH9K_MODE_11A
] = &ar5416_11a_ratetable
;
490 sc
->hw_rate_table
[ATH9K_MODE_11G
] = &ar5416_11g_ratetable
;
492 sc
->hw_rate_table
[ATH9K_MODE_11NA_HT20
] = &ar5416_11na_ratetable
;
493 sc
->hw_rate_table
[ATH9K_MODE_11NG_HT20
] = &ar5416_11ng_ratetable
;
494 sc
->hw_rate_table
[ATH9K_MODE_11NA_HT40PLUS
] =
495 &ar5416_11na_ratetable
;
496 sc
->hw_rate_table
[ATH9K_MODE_11NA_HT40MINUS
] =
497 &ar5416_11na_ratetable
;
498 sc
->hw_rate_table
[ATH9K_MODE_11NG_HT40PLUS
] =
499 &ar5416_11ng_ratetable
;
500 sc
->hw_rate_table
[ATH9K_MODE_11NG_HT40MINUS
] =
501 &ar5416_11ng_ratetable
;
504 static void ar5416_setquarter_ratetable(struct ath_rate_softc
*sc
)
506 sc
->hw_rate_table
[ATH9K_MODE_11A
] = &ar5416_11a_ratetable_Quarter
;
510 static void ar5416_sethalf_ratetable(struct ath_rate_softc
*sc
)
512 sc
->hw_rate_table
[ATH9K_MODE_11A
] = &ar5416_11a_ratetable_Half
;
516 static void ar5416_setfull_ratetable(struct ath_rate_softc
*sc
)
518 sc
->hw_rate_table
[ATH9K_MODE_11A
] = &ar5416_11a_ratetable
;
523 * Return the median of three numbers
525 static inline int8_t median(int8_t a
, int8_t b
, int8_t c
)
544 static void ath_rc_sort_validrates(const struct ath_rate_table
*rate_table
,
545 struct ath_rate_node
*ath_rc_priv
)
547 u8 i
, j
, idx
, idx_next
;
549 for (i
= ath_rc_priv
->max_valid_rate
- 1; i
> 0; i
--) {
550 for (j
= 0; j
<= i
-1; j
++) {
551 idx
= ath_rc_priv
->valid_rate_index
[j
];
552 idx_next
= ath_rc_priv
->valid_rate_index
[j
+1];
554 if (rate_table
->info
[idx
].ratekbps
>
555 rate_table
->info
[idx_next
].ratekbps
) {
556 ath_rc_priv
->valid_rate_index
[j
] = idx_next
;
557 ath_rc_priv
->valid_rate_index
[j
+1] = idx
;
563 /* Access functions for valid_txrate_mask */
565 static void ath_rc_init_valid_txmask(struct ath_rate_node
*ath_rc_priv
)
569 for (i
= 0; i
< ath_rc_priv
->rate_table_size
; i
++)
570 ath_rc_priv
->valid_rate_index
[i
] = FALSE
;
573 static inline void ath_rc_set_valid_txmask(struct ath_rate_node
*ath_rc_priv
,
574 u8 index
, int valid_tx_rate
)
576 ASSERT(index
<= ath_rc_priv
->rate_table_size
);
577 ath_rc_priv
->valid_rate_index
[index
] = valid_tx_rate
? TRUE
: FALSE
;
580 static inline int ath_rc_isvalid_txmask(struct ath_rate_node
*ath_rc_priv
,
583 ASSERT(index
<= ath_rc_priv
->rate_table_size
);
584 return ath_rc_priv
->valid_rate_index
[index
];
587 /* Iterators for valid_txrate_mask */
589 ath_rc_get_nextvalid_txrate(const struct ath_rate_table
*rate_table
,
590 struct ath_rate_node
*ath_rc_priv
,
596 for (i
= 0; i
< ath_rc_priv
->max_valid_rate
- 1; i
++) {
597 if (ath_rc_priv
->valid_rate_index
[i
] == cur_valid_txrate
) {
598 *next_idx
= ath_rc_priv
->valid_rate_index
[i
+1];
603 /* No more valid rates */
608 /* Return true only for single stream */
610 static int ath_rc_valid_phyrate(u32 phy
, u32 capflag
, int ignore_cw
)
612 if (WLAN_RC_PHY_HT(phy
) & !(capflag
& WLAN_RC_HT_FLAG
))
614 if (WLAN_RC_PHY_DS(phy
) && !(capflag
& WLAN_RC_DS_FLAG
))
616 if (WLAN_RC_PHY_SGI(phy
) && !(capflag
& WLAN_RC_SGI_FLAG
))
618 if (!ignore_cw
&& WLAN_RC_PHY_HT(phy
))
619 if (WLAN_RC_PHY_40(phy
) && !(capflag
& WLAN_RC_40_FLAG
))
621 if (!WLAN_RC_PHY_40(phy
) && (capflag
& WLAN_RC_40_FLAG
))
627 ath_rc_get_nextlowervalid_txrate(const struct ath_rate_table
*rate_table
,
628 struct ath_rate_node
*ath_rc_priv
,
629 u8 cur_valid_txrate
, u8
*next_idx
)
633 for (i
= 1; i
< ath_rc_priv
->max_valid_rate
; i
++) {
634 if (ath_rc_priv
->valid_rate_index
[i
] == cur_valid_txrate
) {
635 *next_idx
= ath_rc_priv
->valid_rate_index
[i
-1];
643 * Initialize the Valid Rate Index from valid entries in Rate Table
646 ath_rc_sib_init_validrates(struct ath_rate_node
*ath_rc_priv
,
647 const struct ath_rate_table
*rate_table
,
653 for (i
= 0; i
< rate_table
->rate_cnt
; i
++) {
654 valid
= (ath_rc_priv
->single_stream
?
655 rate_table
->info
[i
].valid_single_stream
:
656 rate_table
->info
[i
].valid
);
658 u32 phy
= rate_table
->info
[i
].phy
;
659 u8 valid_rate_count
= 0;
661 if (!ath_rc_valid_phyrate(phy
, capflag
, FALSE
))
664 valid_rate_count
= ath_rc_priv
->valid_phy_ratecnt
[phy
];
666 ath_rc_priv
->valid_phy_rateidx
[phy
][valid_rate_count
] = i
;
667 ath_rc_priv
->valid_phy_ratecnt
[phy
] += 1;
668 ath_rc_set_valid_txmask(ath_rc_priv
, i
, TRUE
);
676 * Initialize the Valid Rate Index from Rate Set
679 ath_rc_sib_setvalid_rates(struct ath_rate_node
*ath_rc_priv
,
680 const struct ath_rate_table
*rate_table
,
681 struct ath_rateset
*rateset
,
684 /* XXX: Clean me up and make identation friendly */
687 /* Use intersection of working rates and valid rates */
688 for (i
= 0; i
< rateset
->rs_nrates
; i
++) {
689 for (j
= 0; j
< rate_table
->rate_cnt
; j
++) {
690 u32 phy
= rate_table
->info
[j
].phy
;
691 u32 valid
= (ath_rc_priv
->single_stream
?
692 rate_table
->info
[j
].valid_single_stream
:
693 rate_table
->info
[j
].valid
);
695 /* We allow a rate only if its valid and the
696 * capflag matches one of the validity
697 * (TRUE/TRUE_20/TRUE_40) flags */
699 /* XXX: catch the negative of this branch
700 * first and then continue */
701 if (((rateset
->rs_rates
[i
] & 0x7F) ==
702 (rate_table
->info
[j
].dot11rate
& 0x7F)) &&
703 ((valid
& WLAN_RC_CAP_MODE(capflag
)) ==
704 WLAN_RC_CAP_MODE(capflag
)) &&
705 !WLAN_RC_PHY_HT(phy
)) {
707 u8 valid_rate_count
= 0;
709 if (!ath_rc_valid_phyrate(phy
, capflag
, FALSE
))
713 ath_rc_priv
->valid_phy_ratecnt
[phy
];
715 ath_rc_priv
->valid_phy_rateidx
[phy
]
716 [valid_rate_count
] = j
;
717 ath_rc_priv
->valid_phy_ratecnt
[phy
] += 1;
718 ath_rc_set_valid_txmask(ath_rc_priv
, j
, TRUE
);
727 ath_rc_sib_setvalid_htrates(struct ath_rate_node
*ath_rc_priv
,
728 const struct ath_rate_table
*rate_table
,
729 u8
*mcs_set
, u32 capflag
)
733 /* Use intersection of working rates and valid rates */
734 for (i
= 0; i
< ((struct ath_rateset
*)mcs_set
)->rs_nrates
; i
++) {
735 for (j
= 0; j
< rate_table
->rate_cnt
; j
++) {
736 u32 phy
= rate_table
->info
[j
].phy
;
737 u32 valid
= (ath_rc_priv
->single_stream
?
738 rate_table
->info
[j
].valid_single_stream
:
739 rate_table
->info
[j
].valid
);
741 if (((((struct ath_rateset
*)
742 mcs_set
)->rs_rates
[i
] & 0x7F) !=
743 (rate_table
->info
[j
].dot11rate
& 0x7F)) ||
744 !WLAN_RC_PHY_HT(phy
) ||
745 !WLAN_RC_PHY_HT_VALID(valid
, capflag
))
748 if (!ath_rc_valid_phyrate(phy
, capflag
, FALSE
))
751 ath_rc_priv
->valid_phy_rateidx
[phy
]
752 [ath_rc_priv
->valid_phy_ratecnt
[phy
]] = j
;
753 ath_rc_priv
->valid_phy_ratecnt
[phy
] += 1;
754 ath_rc_set_valid_txmask(ath_rc_priv
, j
, TRUE
);
762 * Attach to a device instance. Setup the public definition
763 * of how much per-node space we need and setup the private
764 * phy tables that have rate control parameters.
766 struct ath_rate_softc
*ath_rate_attach(struct ath_hal
*ah
)
768 struct ath_rate_softc
*asc
;
770 /* we are only in user context so we can sleep for memory */
771 asc
= kzalloc(sizeof(struct ath_rate_softc
), GFP_KERNEL
);
775 ar5416_attach_ratetables(asc
);
777 /* Save Maximum TX Trigger Level (used for 11n) */
778 tx_triglevel_max
= ah
->ah_caps
.tx_triglevel_max
;
779 /* return alias for ath_rate_softc * */
783 static struct ath_rate_node
*ath_rate_node_alloc(struct ath_vap
*avp
,
784 struct ath_rate_softc
*rsc
,
787 struct ath_rate_node
*anode
;
789 anode
= kzalloc(sizeof(struct ath_rate_node
), gfp
);
795 avp
->rc_node
= anode
;
800 static void ath_rate_node_free(struct ath_rate_node
*anode
)
806 void ath_rate_detach(struct ath_rate_softc
*asc
)
812 u8
ath_rate_findrateix(struct ath_softc
*sc
,
815 const struct ath_rate_table
*ratetable
;
816 struct ath_rate_softc
*rsc
= sc
->sc_rc
;
819 ratetable
= rsc
->hw_rate_table
[sc
->sc_curmode
];
821 if (WARN_ON(!ratetable
))
824 for (i
= 0; i
< ratetable
->rate_cnt
; i
++) {
825 if ((ratetable
->info
[i
].dot11rate
& 0x7f) == (dot11rate
& 0x7f))
833 * Update rate-control state on a device state change. When
834 * operating as a station this includes associate/reassociate
835 * with an AP. Otherwise this gets called, for example, when
836 * the we transition to run state when operating as an AP.
838 void ath_rate_newstate(struct ath_softc
*sc
, struct ath_vap
*avp
)
840 struct ath_rate_softc
*asc
= sc
->sc_rc
;
842 /* For half and quarter rate channles use different
845 if (sc
->sc_ah
->ah_curchan
->channelFlags
& CHANNEL_HALF
)
846 ar5416_sethalf_ratetable(asc
);
847 else if (sc
->sc_ah
->ah_curchan
->channelFlags
& CHANNEL_QUARTER
)
848 ar5416_setquarter_ratetable(asc
);
850 ar5416_setfull_ratetable(asc
);
852 if (avp
->av_config
.av_fixed_rateset
!= IEEE80211_FIXED_RATE_NONE
) {
854 sc
->sc_rixmap
[avp
->av_config
.av_fixed_rateset
& 0xff];
855 /* NB: check the fixed rate exists */
856 if (asc
->fixedrix
== 0xff)
857 asc
->fixedrix
= IEEE80211_FIXED_RATE_NONE
;
859 asc
->fixedrix
= IEEE80211_FIXED_RATE_NONE
;
863 static u8
ath_rc_ratefind_ht(struct ath_softc
*sc
,
864 struct ath_rate_node
*ath_rc_priv
,
865 const struct ath_rate_table
*rate_table
,
866 int probe_allowed
, int *is_probing
,
869 u32 dt
, best_thruput
, this_thruput
, now_msec
;
870 u8 rate
, next_rate
, best_rate
, maxindex
, minindex
;
871 int8_t rssi_last
, rssi_reduce
= 0, index
= 0;
875 rssi_last
= median(ath_rc_priv
->rssi_last
,
876 ath_rc_priv
->rssi_last_prev
,
877 ath_rc_priv
->rssi_last_prev2
);
880 * Age (reduce) last ack rssi based on how old it is.
881 * The bizarre numbers are so the delta is 160msec,
882 * meaning we divide by 16.
883 * 0msec <= dt <= 25msec: don't derate
884 * 25msec <= dt <= 185msec: derate linearly from 0 to 10dB
885 * 185msec <= dt: derate by 10dB
888 now_msec
= jiffies_to_msecs(jiffies
);
889 dt
= now_msec
- ath_rc_priv
->rssi_time
;
894 rssi_reduce
= (u8
)((dt
- 25) >> 4);
896 /* Now reduce rssi_last by rssi_reduce */
897 if (rssi_last
< rssi_reduce
)
900 rssi_last
-= rssi_reduce
;
903 * Now look up the rate in the rssi table and return it.
904 * If no rates match then we return 0 (lowest rate)
908 maxindex
= ath_rc_priv
->max_valid_rate
-1;
911 best_rate
= minindex
;
914 * Try the higher rate first. It will reduce memory moving time
915 * if we have very good channel characteristics.
917 for (index
= maxindex
; index
>= minindex
; index
--) {
920 rate
= ath_rc_priv
->valid_rate_index
[index
];
921 if (rate
> ath_rc_priv
->rate_max_phy
)
925 * For TCP the average collision rate is around 11%,
926 * so we ignore PERs less than this. This is to
927 * prevent the rate we are currently using (whose
928 * PER might be in the 10-15 range because of TCP
929 * collisions) looking worse than the next lower
930 * rate whose PER has decayed close to 0. If we
931 * used to next lower rate, its PER would grow to
932 * 10-15 and we would be worse off then staying
933 * at the current rate.
935 per_thres
= ath_rc_priv
->state
[rate
].per
;
939 this_thruput
= rate_table
->info
[rate
].user_ratekbps
*
942 if (best_thruput
<= this_thruput
) {
943 best_thruput
= this_thruput
;
950 /* if we are retrying for more than half the number
951 * of max retries, use the min rate for the next retry
954 rate
= ath_rc_priv
->valid_rate_index
[minindex
];
956 ath_rc_priv
->rssi_last_lookup
= rssi_last
;
959 * Must check the actual rate (ratekbps) to account for
960 * non-monoticity of 11g's rate table
963 if (rate
>= ath_rc_priv
->rate_max_phy
&& probe_allowed
) {
964 rate
= ath_rc_priv
->rate_max_phy
;
966 /* Probe the next allowed phy state */
967 /* FIXME:XXXX Check to make sure ratMax is checked properly */
968 if (ath_rc_get_nextvalid_txrate(rate_table
,
969 ath_rc_priv
, rate
, &next_rate
) &&
970 (now_msec
- ath_rc_priv
->probe_time
>
971 rate_table
->probe_interval
) &&
972 (ath_rc_priv
->hw_maxretry_pktcnt
>= 1)) {
974 ath_rc_priv
->probe_rate
= rate
;
975 ath_rc_priv
->probe_time
= now_msec
;
976 ath_rc_priv
->hw_maxretry_pktcnt
= 0;
982 * Make sure rate is not higher than the allowed maximum.
983 * We should also enforce the min, but I suspect the min is
984 * normally 1 rather than 0 because of the rate 9 vs 6 issue
987 if (rate
> (ath_rc_priv
->rate_table_size
- 1))
988 rate
= ath_rc_priv
->rate_table_size
- 1;
990 ASSERT((rate_table
->info
[rate
].valid
&& !ath_rc_priv
->single_stream
) ||
991 (rate_table
->info
[rate
].valid_single_stream
&&
992 ath_rc_priv
->single_stream
));
997 static void ath_rc_rate_set_series(const struct ath_rate_table
*rate_table
,
998 struct ath_rc_series
*series
,
1003 series
->tries
= tries
;
1004 series
->flags
= (rtsctsenable
? ATH_RC_RTSCTS_FLAG
: 0) |
1005 (WLAN_RC_PHY_DS(rate_table
->info
[rix
].phy
) ?
1006 ATH_RC_DS_FLAG
: 0) |
1007 (WLAN_RC_PHY_40(rate_table
->info
[rix
].phy
) ?
1008 ATH_RC_CW40_FLAG
: 0) |
1009 (WLAN_RC_PHY_SGI(rate_table
->info
[rix
].phy
) ?
1010 ATH_RC_SGI_FLAG
: 0);
1012 series
->rix
= rate_table
->info
[rix
].base_index
;
1013 series
->max_4ms_framelen
= rate_table
->info
[rix
].max_4ms_framelen
;
1016 static u8
ath_rc_rate_getidx(struct ath_softc
*sc
,
1017 struct ath_rate_node
*ath_rc_priv
,
1018 const struct ath_rate_table
*rate_table
,
1019 u8 rix
, u16 stepdown
,
1026 for (j
= RATE_TABLE_SIZE
; j
> 0; j
--) {
1027 if (ath_rc_get_nextlowervalid_txrate(rate_table
,
1028 ath_rc_priv
, rix
, &nextindex
))
1034 for (j
= stepdown
; j
> 0; j
--) {
1035 if (ath_rc_get_nextlowervalid_txrate(rate_table
,
1036 ath_rc_priv
, rix
, &nextindex
))
1045 static void ath_rc_ratefind(struct ath_softc
*sc
,
1046 struct ath_rate_node
*ath_rc_priv
,
1047 int num_tries
, int num_rates
, unsigned int rcflag
,
1048 struct ath_rc_series series
[], int *is_probe
,
1051 u8 try_per_rate
= 0, i
= 0, rix
, nrix
;
1052 struct ath_rate_softc
*asc
= (struct ath_rate_softc
*)sc
->sc_rc
;
1053 struct ath_rate_table
*rate_table
;
1056 (struct ath_rate_table
*)asc
->hw_rate_table
[sc
->sc_curmode
];
1057 rix
= ath_rc_ratefind_ht(sc
, ath_rc_priv
, rate_table
,
1058 (rcflag
& ATH_RC_PROBE_ALLOWED
) ? 1 : 0,
1059 is_probe
, is_retry
);
1062 if ((rcflag
& ATH_RC_PROBE_ALLOWED
) && (*is_probe
)) {
1063 /* set one try for probe rates. For the
1064 * probes don't enable rts */
1065 ath_rc_rate_set_series(rate_table
,
1066 &series
[i
++], 1, nrix
, FALSE
);
1068 try_per_rate
= (num_tries
/num_rates
);
1069 /* Get the next tried/allowed rate. No RTS for the next series
1070 * after the probe rate
1072 nrix
= ath_rc_rate_getidx(sc
,
1073 ath_rc_priv
, rate_table
, nrix
, 1, FALSE
);
1074 ath_rc_rate_set_series(rate_table
,
1075 &series
[i
++], try_per_rate
, nrix
, 0);
1077 try_per_rate
= (num_tries
/num_rates
);
1078 /* Set the choosen rate. No RTS for first series entry. */
1079 ath_rc_rate_set_series(rate_table
,
1080 &series
[i
++], try_per_rate
, nrix
, FALSE
);
1083 /* Fill in the other rates for multirate retry */
1084 for ( ; i
< num_rates
; i
++) {
1088 try_num
= ((i
+ 1) == num_rates
) ?
1089 num_tries
- (try_per_rate
* i
) : try_per_rate
;
1090 min_rate
= (((i
+ 1) == num_rates
) &&
1091 (rcflag
& ATH_RC_MINRATE_LASTRATE
)) ? 1 : 0;
1093 nrix
= ath_rc_rate_getidx(sc
, ath_rc_priv
,
1094 rate_table
, nrix
, 1, min_rate
);
1095 /* All other rates in the series have RTS enabled */
1096 ath_rc_rate_set_series(rate_table
,
1097 &series
[i
], try_num
, nrix
, TRUE
);
1101 * NB:Change rate series to enable aggregation when operating
1102 * at lower MCS rates. When first rate in series is MCS2
1103 * in HT40 @ 2.4GHz, series should look like:
1105 * {MCS2, MCS1, MCS0, MCS0}.
1107 * When first rate in series is MCS3 in HT20 @ 2.4GHz, series should
1110 * {MCS3, MCS2, MCS1, MCS1}
1112 * So, set fourth rate in series to be same as third one for
1115 if ((sc
->sc_curmode
== ATH9K_MODE_11NG_HT20
) ||
1116 (sc
->sc_curmode
== ATH9K_MODE_11NG_HT40PLUS
) ||
1117 (sc
->sc_curmode
== ATH9K_MODE_11NG_HT40MINUS
)) {
1118 u8 dot11rate
= rate_table
->info
[rix
].dot11rate
;
1119 u8 phy
= rate_table
->info
[rix
].phy
;
1121 ((dot11rate
== 2 && phy
== WLAN_RC_PHY_HT_40_SS
) ||
1122 (dot11rate
== 3 && phy
== WLAN_RC_PHY_HT_20_SS
))) {
1123 series
[3].rix
= series
[2].rix
;
1124 series
[3].flags
= series
[2].flags
;
1125 series
[3].max_4ms_framelen
= series
[2].max_4ms_framelen
;
1131 * Return the Tx rate series.
1133 static void ath_rate_findrate(struct ath_softc
*sc
,
1134 struct ath_rate_node
*ath_rc_priv
,
1137 unsigned int rcflag
,
1138 struct ath_rc_series series
[],
1142 struct ath_vap
*avp
= ath_rc_priv
->avp
;
1144 DPRINTF(sc
, ATH_DBG_RATE
, "%s\n", __func__
);
1146 if (!num_rates
|| !num_tries
)
1149 if (avp
->av_config
.av_fixed_rateset
== IEEE80211_FIXED_RATE_NONE
) {
1150 ath_rc_ratefind(sc
, ath_rc_priv
, num_tries
, num_rates
,
1151 rcflag
, series
, is_probe
, is_retry
);
1157 struct ath_rate_softc
*asc
= ath_rc_priv
->asc
;
1158 struct ath_rate_table
*rate_table
;
1160 rate_table
= (struct ath_rate_table
*)
1161 asc
->hw_rate_table
[sc
->sc_curmode
];
1163 for (idx
= 0; idx
< 4; idx
++) {
1167 series
[idx
].tries
= IEEE80211_RATE_IDX_ENTRY(
1168 avp
->av_config
.av_fixed_retryset
, idx
);
1170 mcs
= IEEE80211_RATE_IDX_ENTRY(
1171 avp
->av_config
.av_fixed_rateset
, idx
);
1173 if (idx
== 3 && (mcs
& 0xf0) == 0x70)
1174 mcs
= (mcs
& ~0xf0)|0x80;
1179 flags
= ((ath_rc_priv
->ht_cap
&
1181 ATH_RC_DS_FLAG
: 0) |
1182 ((ath_rc_priv
->ht_cap
&
1184 ATH_RC_CW40_FLAG
: 0) |
1185 ((ath_rc_priv
->ht_cap
&
1187 ((ath_rc_priv
->ht_cap
&
1189 ATH_RC_SGI_FLAG
: 0) : 0);
1191 series
[idx
].rix
= sc
->sc_rixmap
[mcs
];
1192 series_rix
= series
[idx
].rix
;
1194 /* XXX: Give me some cleanup love */
1195 if ((flags
& ATH_RC_CW40_FLAG
) &&
1196 (flags
& ATH_RC_SGI_FLAG
))
1197 rix
= rate_table
->info
[series_rix
].ht_index
;
1198 else if (flags
& ATH_RC_SGI_FLAG
)
1199 rix
= rate_table
->info
[series_rix
].sgi_index
;
1200 else if (flags
& ATH_RC_CW40_FLAG
)
1201 rix
= rate_table
->info
[series_rix
].cw40index
;
1203 rix
= rate_table
->info
[series_rix
].base_index
;
1204 series
[idx
].max_4ms_framelen
=
1205 rate_table
->info
[rix
].max_4ms_framelen
;
1206 series
[idx
].flags
= flags
;
1211 static void ath_rc_update_ht(struct ath_softc
*sc
,
1212 struct ath_rate_node
*ath_rc_priv
,
1213 struct ath_tx_info_priv
*info_priv
,
1214 int tx_rate
, int xretries
, int retries
)
1216 u32 now_msec
= jiffies_to_msecs(jiffies
);
1217 int state_change
= FALSE
, rate
, count
;
1219 struct ath_rate_softc
*asc
= (struct ath_rate_softc
*)sc
->sc_rc
;
1220 struct ath_rate_table
*rate_table
=
1221 (struct ath_rate_table
*)asc
->hw_rate_table
[sc
->sc_curmode
];
1223 static u32 nretry_to_per_lookup
[10] = {
1239 ASSERT(tx_rate
>= 0);
1243 /* To compensate for some imbalance between ctrl and ext. channel */
1245 if (WLAN_RC_PHY_40(rate_table
->info
[tx_rate
].phy
))
1246 info_priv
->tx
.ts_rssi
=
1247 info_priv
->tx
.ts_rssi
< 3 ? 0 :
1248 info_priv
->tx
.ts_rssi
- 3;
1250 last_per
= ath_rc_priv
->state
[tx_rate
].per
;
1253 /* Update the PER. */
1254 if (xretries
== 1) {
1255 ath_rc_priv
->state
[tx_rate
].per
+= 30;
1256 if (ath_rc_priv
->state
[tx_rate
].per
> 100)
1257 ath_rc_priv
->state
[tx_rate
].per
= 100;
1260 count
= ARRAY_SIZE(nretry_to_per_lookup
);
1261 if (retries
>= count
)
1262 retries
= count
- 1;
1263 /* new_PER = 7/8*old_PER + 1/8*(currentPER) */
1264 ath_rc_priv
->state
[tx_rate
].per
=
1265 (u8
)(ath_rc_priv
->state
[tx_rate
].per
-
1266 (ath_rc_priv
->state
[tx_rate
].per
>> 3) +
1270 /* xretries == 1 or 2 */
1272 if (ath_rc_priv
->probe_rate
== tx_rate
)
1273 ath_rc_priv
->probe_rate
= 0;
1275 } else { /* xretries == 0 */
1276 /* Update the PER. */
1277 /* Make sure it doesn't index out of array's bounds. */
1278 count
= ARRAY_SIZE(nretry_to_per_lookup
);
1279 if (retries
>= count
)
1280 retries
= count
- 1;
1281 if (info_priv
->n_bad_frames
) {
1282 /* new_PER = 7/8*old_PER + 1/8*(currentPER)
1283 * Assuming that n_frames is not 0. The current PER
1284 * from the retries is 100 * retries / (retries+1),
1285 * since the first retries attempts failed, and the
1286 * next one worked. For the one that worked,
1287 * n_bad_frames subframes out of n_frames wored,
1288 * so the PER for that part is
1289 * 100 * n_bad_frames / n_frames, and it contributes
1290 * 100 * n_bad_frames / (n_frames * (retries+1)) to
1291 * the above PER. The expression below is a
1292 * simplified version of the sum of these two terms.
1294 if (info_priv
->n_frames
> 0)
1295 ath_rc_priv
->state
[tx_rate
].per
1297 (ath_rc_priv
->state
[tx_rate
].per
-
1298 (ath_rc_priv
->state
[tx_rate
].per
>> 3) +
1299 ((100*(retries
*info_priv
->n_frames
+
1300 info_priv
->n_bad_frames
) /
1301 (info_priv
->n_frames
*
1302 (retries
+1))) >> 3));
1304 /* new_PER = 7/8*old_PER + 1/8*(currentPER) */
1306 ath_rc_priv
->state
[tx_rate
].per
= (u8
)
1307 (ath_rc_priv
->state
[tx_rate
].per
-
1308 (ath_rc_priv
->state
[tx_rate
].per
>> 3) +
1309 (nretry_to_per_lookup
[retries
] >> 3));
1312 ath_rc_priv
->rssi_last_prev2
= ath_rc_priv
->rssi_last_prev
;
1313 ath_rc_priv
->rssi_last_prev
= ath_rc_priv
->rssi_last
;
1314 ath_rc_priv
->rssi_last
= info_priv
->tx
.ts_rssi
;
1315 ath_rc_priv
->rssi_time
= now_msec
;
1318 * If we got at most one retry then increase the max rate if
1319 * this was a probe. Otherwise, ignore the probe.
1322 if (ath_rc_priv
->probe_rate
&& ath_rc_priv
->probe_rate
== tx_rate
) {
1323 if (retries
> 0 || 2 * info_priv
->n_bad_frames
>
1324 info_priv
->n_frames
) {
1326 * Since we probed with just a single attempt,
1327 * any retries means the probe failed. Also,
1328 * if the attempt worked, but more than half
1329 * the subframes were bad then also consider
1330 * the probe a failure.
1332 ath_rc_priv
->probe_rate
= 0;
1336 ath_rc_priv
->rate_max_phy
= ath_rc_priv
->probe_rate
;
1337 probe_rate
= ath_rc_priv
->probe_rate
;
1339 if (ath_rc_priv
->state
[probe_rate
].per
> 30)
1340 ath_rc_priv
->state
[probe_rate
].per
= 20;
1342 ath_rc_priv
->probe_rate
= 0;
1345 * Since this probe succeeded, we allow the next
1346 * probe twice as soon. This allows the maxRate
1347 * to move up faster if the probes are
1350 ath_rc_priv
->probe_time
= now_msec
-
1351 rate_table
->probe_interval
/ 2;
1357 * Don't update anything. We don't know if
1358 * this was because of collisions or poor signal.
1360 * Later: if rssi_ack is close to
1361 * ath_rc_priv->state[txRate].rssi_thres and we see lots
1362 * of retries, then we could increase
1363 * ath_rc_priv->state[txRate].rssi_thres.
1365 ath_rc_priv
->hw_maxretry_pktcnt
= 0;
1368 * It worked with no retries. First ignore bogus (small)
1371 if (tx_rate
== ath_rc_priv
->rate_max_phy
&&
1372 ath_rc_priv
->hw_maxretry_pktcnt
< 255) {
1373 ath_rc_priv
->hw_maxretry_pktcnt
++;
1376 if (info_priv
->tx
.ts_rssi
>=
1377 rate_table
->info
[tx_rate
].rssi_ack_validmin
) {
1378 /* Average the rssi */
1379 if (tx_rate
!= ath_rc_priv
->rssi_sum_rate
) {
1380 ath_rc_priv
->rssi_sum_rate
= tx_rate
;
1381 ath_rc_priv
->rssi_sum
=
1382 ath_rc_priv
->rssi_sum_cnt
= 0;
1385 ath_rc_priv
->rssi_sum
+= info_priv
->tx
.ts_rssi
;
1386 ath_rc_priv
->rssi_sum_cnt
++;
1388 if (ath_rc_priv
->rssi_sum_cnt
> 4) {
1389 int32_t rssi_ackAvg
=
1390 (ath_rc_priv
->rssi_sum
+ 2) / 4;
1392 ath_rc_priv
->state
[tx_rate
].
1394 int8_t rssi_ack_vmin
=
1395 rate_table
->info
[tx_rate
].
1398 ath_rc_priv
->rssi_sum
=
1399 ath_rc_priv
->rssi_sum_cnt
= 0;
1401 /* Now reduce the current
1402 * rssi threshold. */
1403 if ((rssi_ackAvg
< rssi_thres
+ 2) &&
1404 (rssi_thres
> rssi_ack_vmin
)) {
1405 ath_rc_priv
->state
[tx_rate
].
1409 state_change
= TRUE
;
1418 * If this rate looks bad (high PER) then stop using it for
1419 * a while (except if we are probing).
1421 if (ath_rc_priv
->state
[tx_rate
].per
>= 55 && tx_rate
> 0 &&
1422 rate_table
->info
[tx_rate
].ratekbps
<=
1423 rate_table
->info
[ath_rc_priv
->rate_max_phy
].ratekbps
) {
1424 ath_rc_get_nextlowervalid_txrate(rate_table
, ath_rc_priv
,
1425 (u8
) tx_rate
, &ath_rc_priv
->rate_max_phy
);
1427 /* Don't probe for a little while. */
1428 ath_rc_priv
->probe_time
= now_msec
;
1433 * Make sure the rates above this have higher rssi thresholds.
1434 * (Note: Monotonicity is kept within the OFDM rates and
1435 * within the CCK rates. However, no adjustment is
1436 * made to keep the rssi thresholds monotonically
1437 * increasing between the CCK and OFDM rates.)
1439 for (rate
= tx_rate
; rate
<
1440 ath_rc_priv
->rate_table_size
- 1; rate
++) {
1441 if (rate_table
->info
[rate
+1].phy
!=
1442 rate_table
->info
[tx_rate
].phy
)
1445 if (ath_rc_priv
->state
[rate
].rssi_thres
+
1446 rate_table
->info
[rate
].rssi_ack_deltamin
>
1447 ath_rc_priv
->state
[rate
+1].rssi_thres
) {
1448 ath_rc_priv
->state
[rate
+1].rssi_thres
=
1449 ath_rc_priv
->state
[rate
].
1451 rate_table
->info
[rate
].
1456 /* Make sure the rates below this have lower rssi thresholds. */
1457 for (rate
= tx_rate
- 1; rate
>= 0; rate
--) {
1458 if (rate_table
->info
[rate
].phy
!=
1459 rate_table
->info
[tx_rate
].phy
)
1462 if (ath_rc_priv
->state
[rate
].rssi_thres
+
1463 rate_table
->info
[rate
].rssi_ack_deltamin
>
1464 ath_rc_priv
->state
[rate
+1].rssi_thres
) {
1465 if (ath_rc_priv
->state
[rate
+1].rssi_thres
<
1466 rate_table
->info
[rate
].
1468 ath_rc_priv
->state
[rate
].rssi_thres
= 0;
1470 ath_rc_priv
->state
[rate
].rssi_thres
=
1471 ath_rc_priv
->state
[rate
+1].
1473 rate_table
->info
[rate
].
1477 if (ath_rc_priv
->state
[rate
].rssi_thres
<
1478 rate_table
->info
[rate
].
1479 rssi_ack_validmin
) {
1480 ath_rc_priv
->state
[rate
].rssi_thres
=
1481 rate_table
->info
[rate
].
1488 /* Make sure the rates below this have lower PER */
1489 /* Monotonicity is kept only for rates below the current rate. */
1490 if (ath_rc_priv
->state
[tx_rate
].per
< last_per
) {
1491 for (rate
= tx_rate
- 1; rate
>= 0; rate
--) {
1492 if (rate_table
->info
[rate
].phy
!=
1493 rate_table
->info
[tx_rate
].phy
)
1496 if (ath_rc_priv
->state
[rate
].per
>
1497 ath_rc_priv
->state
[rate
+1].per
) {
1498 ath_rc_priv
->state
[rate
].per
=
1499 ath_rc_priv
->state
[rate
+1].per
;
1504 /* Maintain monotonicity for rates above the current rate */
1505 for (rate
= tx_rate
; rate
< ath_rc_priv
->rate_table_size
- 1; rate
++) {
1506 if (ath_rc_priv
->state
[rate
+1].per
< ath_rc_priv
->state
[rate
].per
)
1507 ath_rc_priv
->state
[rate
+1].per
=
1508 ath_rc_priv
->state
[rate
].per
;
1511 /* Every so often, we reduce the thresholds and
1512 * PER (different for CCK and OFDM). */
1513 if (now_msec
- ath_rc_priv
->rssi_down_time
>=
1514 rate_table
->rssi_reduce_interval
) {
1516 for (rate
= 0; rate
< ath_rc_priv
->rate_table_size
; rate
++) {
1517 if (ath_rc_priv
->state
[rate
].rssi_thres
>
1518 rate_table
->info
[rate
].rssi_ack_validmin
)
1519 ath_rc_priv
->state
[rate
].rssi_thres
-= 1;
1521 ath_rc_priv
->rssi_down_time
= now_msec
;
1524 /* Every so often, we reduce the thresholds
1525 * and PER (different for CCK and OFDM). */
1526 if (now_msec
- ath_rc_priv
->per_down_time
>=
1527 rate_table
->rssi_reduce_interval
) {
1528 for (rate
= 0; rate
< ath_rc_priv
->rate_table_size
; rate
++) {
1529 ath_rc_priv
->state
[rate
].per
=
1530 7 * ath_rc_priv
->state
[rate
].per
/ 8;
1533 ath_rc_priv
->per_down_time
= now_msec
;
1538 * This routine is called in rate control callback tx_status() to give
1539 * the status of previous frames.
1541 static void ath_rc_update(struct ath_softc
*sc
,
1542 struct ath_rate_node
*ath_rc_priv
,
1543 struct ath_tx_info_priv
*info_priv
, int final_ts_idx
,
1544 int xretries
, int long_retry
)
1546 struct ath_rate_softc
*asc
= (struct ath_rate_softc
*)sc
->sc_rc
;
1547 struct ath_rate_table
*rate_table
;
1548 struct ath_rc_series rcs
[4];
1550 u32 series
= 0, rix
;
1552 memcpy(rcs
, info_priv
->rcs
, 4 * sizeof(rcs
[0]));
1553 rate_table
= (struct ath_rate_table
*)
1554 asc
->hw_rate_table
[sc
->sc_curmode
];
1555 ASSERT(rcs
[0].tries
!= 0);
1558 * If the first rate is not the final index, there
1559 * are intermediate rate failures to be processed.
1561 if (final_ts_idx
!= 0) {
1562 /* Process intermediate rates that failed.*/
1563 for (series
= 0; series
< final_ts_idx
; series
++) {
1564 if (rcs
[series
].tries
!= 0) {
1565 flags
= rcs
[series
].flags
;
1566 /* If HT40 and we have switched mode from
1567 * 40 to 20 => don't update */
1568 if ((flags
& ATH_RC_CW40_FLAG
) &&
1569 (ath_rc_priv
->rc_phy_mode
!=
1570 (flags
& ATH_RC_CW40_FLAG
)))
1572 if ((flags
& ATH_RC_CW40_FLAG
) &&
1573 (flags
& ATH_RC_SGI_FLAG
))
1574 rix
= rate_table
->info
[
1575 rcs
[series
].rix
].ht_index
;
1576 else if (flags
& ATH_RC_SGI_FLAG
)
1577 rix
= rate_table
->info
[
1578 rcs
[series
].rix
].sgi_index
;
1579 else if (flags
& ATH_RC_CW40_FLAG
)
1580 rix
= rate_table
->info
[
1581 rcs
[series
].rix
].cw40index
;
1583 rix
= rate_table
->info
[
1584 rcs
[series
].rix
].base_index
;
1585 ath_rc_update_ht(sc
, ath_rc_priv
,
1593 * Handle the special case of MIMO PS burst, where the second
1594 * aggregate is sent out with only one rate and one try.
1595 * Treating it as an excessive retry penalizes the rate
1598 if (rcs
[0].tries
== 1 && xretries
== 1)
1602 flags
= rcs
[series
].flags
;
1603 /* If HT40 and we have switched mode from 40 to 20 => don't update */
1604 if ((flags
& ATH_RC_CW40_FLAG
) &&
1605 (ath_rc_priv
->rc_phy_mode
!= (flags
& ATH_RC_CW40_FLAG
)))
1608 if ((flags
& ATH_RC_CW40_FLAG
) && (flags
& ATH_RC_SGI_FLAG
))
1609 rix
= rate_table
->info
[rcs
[series
].rix
].ht_index
;
1610 else if (flags
& ATH_RC_SGI_FLAG
)
1611 rix
= rate_table
->info
[rcs
[series
].rix
].sgi_index
;
1612 else if (flags
& ATH_RC_CW40_FLAG
)
1613 rix
= rate_table
->info
[rcs
[series
].rix
].cw40index
;
1615 rix
= rate_table
->info
[rcs
[series
].rix
].base_index
;
1617 ath_rc_update_ht(sc
, ath_rc_priv
, info_priv
, rix
,
1618 xretries
, long_retry
);
1622 * Process a tx descriptor for a completed transmit (success or failure).
1624 static void ath_rate_tx_complete(struct ath_softc
*sc
,
1625 struct ath_node
*an
,
1626 struct ath_rate_node
*rc_priv
,
1627 struct ath_tx_info_priv
*info_priv
)
1629 int final_ts_idx
= info_priv
->tx
.ts_rateindex
;
1630 int tx_status
= 0, is_underrun
= 0;
1631 struct ath_vap
*avp
;
1634 if ((avp
->av_config
.av_fixed_rateset
!= IEEE80211_FIXED_RATE_NONE
) ||
1635 (info_priv
->tx
.ts_status
& ATH9K_TXERR_FILT
))
1638 if (info_priv
->tx
.ts_rssi
> 0) {
1639 ATH_RSSI_LPF(an
->an_chainmask_sel
.tx_avgrssi
,
1640 info_priv
->tx
.ts_rssi
);
1644 * If underrun error is seen assume it as an excessive retry only
1645 * if prefetch trigger level have reached the max (0x3f for 5416)
1646 * Adjust the long retry as if the frame was tried ATH_11N_TXMAXTRY
1647 * times. This affects how ratectrl updates PER for the failed rate.
1649 if (info_priv
->tx
.ts_flags
&
1650 (ATH9K_TX_DATA_UNDERRUN
| ATH9K_TX_DELIM_UNDERRUN
) &&
1651 ((sc
->sc_ah
->ah_txTrigLevel
) >= tx_triglevel_max
)) {
1656 if ((info_priv
->tx
.ts_status
& ATH9K_TXERR_XRETRY
) ||
1657 (info_priv
->tx
.ts_status
& ATH9K_TXERR_FIFO
))
1660 ath_rc_update(sc
, rc_priv
, info_priv
, final_ts_idx
, tx_status
,
1661 (is_underrun
) ? ATH_11N_TXMAXTRY
:
1662 info_priv
->tx
.ts_longretry
);
1666 * Update the SIB's rate control information
1668 * This should be called when the supported rates change
1669 * (e.g. SME operation, wireless mode change)
1671 * It will determine which rates are valid for use.
1673 static void ath_rc_sib_update(struct ath_softc
*sc
,
1674 struct ath_rate_node
*ath_rc_priv
,
1675 u32 capflag
, int keep_state
,
1676 struct ath_rateset
*negotiated_rates
,
1677 struct ath_rateset
*negotiated_htrates
)
1679 struct ath_rate_table
*rate_table
= NULL
;
1680 struct ath_rate_softc
*asc
= (struct ath_rate_softc
*)sc
->sc_rc
;
1681 struct ath_rateset
*rateset
= negotiated_rates
;
1682 u8
*ht_mcs
= (u8
*)negotiated_htrates
;
1683 u8 i
, j
, k
, hi
= 0, hthi
= 0;
1685 rate_table
= (struct ath_rate_table
*)
1686 asc
->hw_rate_table
[sc
->sc_curmode
];
1688 /* Initial rate table size. Will change depending
1689 * on the working rate set */
1690 ath_rc_priv
->rate_table_size
= MAX_TX_RATE_TBL
;
1692 /* Initialize thresholds according to the global rate table */
1693 for (i
= 0 ; (i
< ath_rc_priv
->rate_table_size
) && (!keep_state
); i
++) {
1694 ath_rc_priv
->state
[i
].rssi_thres
=
1695 rate_table
->info
[i
].rssi_ack_validmin
;
1696 ath_rc_priv
->state
[i
].per
= 0;
1699 /* Determine the valid rates */
1700 ath_rc_init_valid_txmask(ath_rc_priv
);
1702 for (i
= 0; i
< WLAN_RC_PHY_MAX
; i
++) {
1703 for (j
= 0; j
< MAX_TX_RATE_PHY
; j
++)
1704 ath_rc_priv
->valid_phy_rateidx
[i
][j
] = 0;
1705 ath_rc_priv
->valid_phy_ratecnt
[i
] = 0;
1707 ath_rc_priv
->rc_phy_mode
= (capflag
& WLAN_RC_40_FLAG
);
1709 /* Set stream capability */
1710 ath_rc_priv
->single_stream
= (capflag
& WLAN_RC_DS_FLAG
) ? 0 : 1;
1712 if (!rateset
->rs_nrates
) {
1713 /* No working rate, just initialize valid rates */
1714 hi
= ath_rc_sib_init_validrates(ath_rc_priv
, rate_table
,
1717 /* Use intersection of working rates and valid rates */
1718 hi
= ath_rc_sib_setvalid_rates(ath_rc_priv
, rate_table
,
1720 if (capflag
& WLAN_RC_HT_FLAG
) {
1721 hthi
= ath_rc_sib_setvalid_htrates(ath_rc_priv
,
1726 hi
= A_MAX(hi
, hthi
);
1729 ath_rc_priv
->rate_table_size
= hi
+ 1;
1730 ath_rc_priv
->rate_max_phy
= 0;
1731 ASSERT(ath_rc_priv
->rate_table_size
<= MAX_TX_RATE_TBL
);
1733 for (i
= 0, k
= 0; i
< WLAN_RC_PHY_MAX
; i
++) {
1734 for (j
= 0; j
< ath_rc_priv
->valid_phy_ratecnt
[i
]; j
++) {
1735 ath_rc_priv
->valid_rate_index
[k
++] =
1736 ath_rc_priv
->valid_phy_rateidx
[i
][j
];
1739 if (!ath_rc_valid_phyrate(i
, rate_table
->initial_ratemax
, TRUE
)
1740 || !ath_rc_priv
->valid_phy_ratecnt
[i
])
1743 ath_rc_priv
->rate_max_phy
= ath_rc_priv
->valid_phy_rateidx
[i
][j
-1];
1745 ASSERT(ath_rc_priv
->rate_table_size
<= MAX_TX_RATE_TBL
);
1746 ASSERT(k
<= MAX_TX_RATE_TBL
);
1748 ath_rc_priv
->max_valid_rate
= k
;
1750 * Some third party vendors don't send the supported rate series in
1751 * order. So sorting to make sure its in order, otherwise our RateFind
1752 * Algo will select wrong rates
1754 ath_rc_sort_validrates(rate_table
, ath_rc_priv
);
1755 ath_rc_priv
->rate_max_phy
= ath_rc_priv
->valid_rate_index
[k
-4];
1759 * Update rate-control state on station associate/reassociate.
1761 static int ath_rate_newassoc(struct ath_softc
*sc
,
1762 struct ath_rate_node
*ath_rc_priv
,
1763 unsigned int capflag
,
1764 struct ath_rateset
*negotiated_rates
,
1765 struct ath_rateset
*negotiated_htrates
)
1769 ath_rc_priv
->ht_cap
=
1770 ((capflag
& ATH_RC_DS_FLAG
) ? WLAN_RC_DS_FLAG
: 0) |
1771 ((capflag
& ATH_RC_SGI_FLAG
) ? WLAN_RC_SGI_FLAG
: 0) |
1772 ((capflag
& ATH_RC_HT_FLAG
) ? WLAN_RC_HT_FLAG
: 0) |
1773 ((capflag
& ATH_RC_CW40_FLAG
) ? WLAN_RC_40_FLAG
: 0);
1775 ath_rc_sib_update(sc
, ath_rc_priv
, ath_rc_priv
->ht_cap
, 0,
1776 negotiated_rates
, negotiated_htrates
);
1782 * This routine is called to initialize the rate control parameters
1783 * in the SIB. It is called initially during system initialization
1784 * or when a station is associated with the AP.
1786 static void ath_rc_sib_init(struct ath_rate_node
*ath_rc_priv
)
1788 ath_rc_priv
->rssi_down_time
= jiffies_to_msecs(jiffies
);
1792 static void ath_setup_rates(struct ath_softc
*sc
,
1793 struct ieee80211_supported_band
*sband
,
1794 struct ieee80211_sta
*sta
,
1795 struct ath_rate_node
*rc_priv
)
1800 DPRINTF(sc
, ATH_DBG_RATE
, "%s\n", __func__
);
1802 for (i
= 0; i
< sband
->n_bitrates
; i
++) {
1803 if (sta
->supp_rates
[sband
->band
] & BIT(i
)) {
1804 rc_priv
->neg_rates
.rs_rates
[j
]
1805 = (sband
->bitrates
[i
].bitrate
* 2) / 10;
1809 rc_priv
->neg_rates
.rs_nrates
= j
;
1812 void ath_rc_node_update(struct ieee80211_hw
*hw
, struct ath_rate_node
*rc_priv
)
1814 struct ath_softc
*sc
= hw
->priv
;
1817 if (hw
->conf
.ht
.enabled
) {
1818 capflag
|= ATH_RC_HT_FLAG
| ATH_RC_DS_FLAG
;
1819 if (sc
->sc_ht_info
.tx_chan_width
== ATH9K_HT_MACMODE_2040
)
1820 capflag
|= ATH_RC_CW40_FLAG
;
1823 ath_rate_newassoc(sc
, rc_priv
, capflag
,
1824 &rc_priv
->neg_rates
,
1825 &rc_priv
->neg_ht_rates
);
1829 /* Rate Control callbacks */
1830 static void ath_tx_status(void *priv
, struct ieee80211_supported_band
*sband
,
1831 struct ieee80211_sta
*sta
, void *priv_sta
,
1832 struct sk_buff
*skb
)
1834 struct ath_softc
*sc
= priv
;
1835 struct ath_tx_info_priv
*tx_info_priv
;
1836 struct ath_node
*an
;
1837 struct ieee80211_tx_info
*tx_info
= IEEE80211_SKB_CB(skb
);
1838 struct ieee80211_hdr
*hdr
;
1841 hdr
= (struct ieee80211_hdr
*)skb
->data
;
1842 fc
= hdr
->frame_control
;
1843 /* XXX: UGLY HACK!! */
1844 tx_info_priv
= (struct ath_tx_info_priv
*)tx_info
->control
.vif
;
1846 an
= (struct ath_node
*)sta
->drv_priv
;
1848 if (tx_info_priv
== NULL
)
1851 if (an
&& priv_sta
&& ieee80211_is_data(fc
))
1852 ath_rate_tx_complete(sc
, an
, priv_sta
, tx_info_priv
);
1854 kfree(tx_info_priv
);
1855 tx_info
->control
.vif
= NULL
;
1858 static void ath_get_rate(void *priv
, struct ieee80211_sta
*sta
, void *priv_sta
,
1859 struct ieee80211_tx_rate_control
*txrc
)
1861 struct ieee80211_supported_band
*sband
= txrc
->sband
;
1862 struct sk_buff
*skb
= txrc
->skb
;
1863 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)skb
->data
;
1864 struct ath_softc
*sc
= priv
;
1865 struct ieee80211_hw
*hw
= sc
->hw
;
1866 struct ath_tx_info_priv
*tx_info_priv
;
1867 struct ath_rate_node
*ath_rc_priv
= priv_sta
;
1868 struct ath_node
*an
;
1869 struct ieee80211_tx_info
*tx_info
= IEEE80211_SKB_CB(skb
);
1870 int is_probe
= FALSE
;
1872 __le16 fc
= hdr
->frame_control
;
1875 DPRINTF(sc
, ATH_DBG_RATE
, "%s\n", __func__
);
1877 /* allocate driver private area of tx_info, XXX: UGLY HACK! */
1878 tx_info
->control
.vif
= kzalloc(sizeof(*tx_info_priv
), GFP_ATOMIC
);
1879 tx_info_priv
= (struct ath_tx_info_priv
*)tx_info
->control
.vif
;
1880 ASSERT(tx_info_priv
!= NULL
);
1882 lowest_idx
= rate_lowest_index(sband
, sta
);
1883 tx_info_priv
->min_rate
= (sband
->bitrates
[lowest_idx
].bitrate
* 2) / 10;
1884 /* lowest rate for management and multicast/broadcast frames */
1885 if (!ieee80211_is_data(fc
) ||
1886 is_multicast_ether_addr(hdr
->addr1
) || !sta
) {
1887 tx_info
->control
.rates
[0].idx
= lowest_idx
;
1891 /* Find tx rate for unicast frames */
1892 ath_rate_findrate(sc
, ath_rc_priv
,
1893 ATH_11N_TXMAXTRY
, 4,
1894 ATH_RC_PROBE_ALLOWED
,
1900 sel
->probe_idx
= ath_rc_priv
->tx_ratectrl
.probe_rate
;
1903 /* Ratecontrol sometimes returns invalid rate index */
1904 if (tx_info_priv
->rcs
[0].rix
!= 0xff)
1905 ath_rc_priv
->prev_data_rix
= tx_info_priv
->rcs
[0].rix
;
1907 tx_info_priv
->rcs
[0].rix
= ath_rc_priv
->prev_data_rix
;
1909 tx_info
->control
.rates
[0].idx
= tx_info_priv
->rcs
[0].rix
;
1911 /* Check if aggregation has to be enabled for this tid */
1913 if (hw
->conf
.ht
.enabled
) {
1914 if (ieee80211_is_data_qos(fc
)) {
1915 qc
= ieee80211_get_qos_ctl(hdr
);
1917 an
= (struct ath_node
*)sta
->drv_priv
;
1919 if(ath_tx_aggr_check(sc
, an
, tid
))
1920 ieee80211_start_tx_ba_session(hw
, hdr
->addr1
, tid
);
1925 static void ath_rate_init(void *priv
, struct ieee80211_supported_band
*sband
,
1926 struct ieee80211_sta
*sta
, void *priv_sta
)
1928 struct ath_softc
*sc
= priv
;
1929 struct ath_rate_node
*ath_rc_priv
= priv_sta
;
1932 DPRINTF(sc
, ATH_DBG_RATE
, "%s\n", __func__
);
1934 ath_setup_rates(sc
, sband
, sta
, ath_rc_priv
);
1935 if (sta
->ht_cap
.ht_supported
) {
1936 for (i
= 0; i
< 77; i
++) {
1937 if (sta
->ht_cap
.mcs
.rx_mask
[i
/8] & (1<<(i
%8)))
1938 ath_rc_priv
->neg_ht_rates
.rs_rates
[j
++] = i
;
1939 if (j
== ATH_RATE_MAX
)
1942 ath_rc_priv
->neg_ht_rates
.rs_nrates
= j
;
1944 ath_rc_node_update(sc
->hw
, priv_sta
);
1947 static void *ath_rate_alloc(struct ieee80211_hw
*hw
, struct dentry
*debugfsdir
)
1949 struct ath_softc
*sc
= hw
->priv
;
1951 DPRINTF(sc
, ATH_DBG_RATE
, "%s\n", __func__
);
1955 static void ath_rate_free(void *priv
)
1960 static void *ath_rate_alloc_sta(void *priv
, struct ieee80211_sta
*sta
, gfp_t gfp
)
1962 struct ieee80211_vif
*vif
;
1963 struct ath_softc
*sc
= priv
;
1964 struct ath_vap
*avp
;
1965 struct ath_rate_node
*rate_priv
;
1967 DPRINTF(sc
, ATH_DBG_RATE
, "%s\n", __func__
);
1969 vif
= sc
->sc_vaps
[0];
1972 avp
= (void *)vif
->drv_priv
;
1974 rate_priv
= ath_rate_node_alloc(avp
, sc
->sc_rc
, gfp
);
1976 DPRINTF(sc
, ATH_DBG_FATAL
,
1977 "%s: Unable to allocate private rc structure\n",
1981 ath_rc_sib_init(rate_priv
);
1986 static void ath_rate_free_sta(void *priv
, struct ieee80211_sta
*sta
,
1989 struct ath_rate_node
*rate_priv
= priv_sta
;
1990 struct ath_softc
*sc
= priv
;
1992 DPRINTF(sc
, ATH_DBG_RATE
, "%s", __func__
);
1993 ath_rate_node_free(rate_priv
);
1996 static struct rate_control_ops ath_rate_ops
= {
1998 .name
= "ath9k_rate_control",
1999 .tx_status
= ath_tx_status
,
2000 .get_rate
= ath_get_rate
,
2001 .rate_init
= ath_rate_init
,
2002 .alloc
= ath_rate_alloc
,
2003 .free
= ath_rate_free
,
2004 .alloc_sta
= ath_rate_alloc_sta
,
2005 .free_sta
= ath_rate_free_sta
,
2008 int ath_rate_control_register(void)
2010 return ieee80211_rate_control_register(&ath_rate_ops
);
2013 void ath_rate_control_unregister(void)
2015 ieee80211_rate_control_unregister(&ath_rate_ops
);