Commit | Line | Data |
---|---|---|
f078f209 LR |
1 | /* |
2 | * Copyright (c) 2004 Video54 Technologies, Inc. | |
3 | * Copyright (c) 2004-2008 Atheros Communications, Inc. | |
4 | * | |
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. | |
8 | * | |
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. | |
16 | */ | |
17 | ||
394cf0a1 | 18 | #include "ath9k.h" |
f078f209 | 19 | |
f078f209 LR |
20 | static struct ath_rate_table ar5416_11na_ratetable = { |
21 | 42, | |
22 | { | |
46d14a58 | 23 | { VALID, VALID, WLAN_RC_PHY_OFDM, 6000, /* 6 Mb */ |
f078f209 LR |
24 | 5400, 0x0b, 0x00, 12, |
25 | 0, 2, 1, 0, 0, 0, 0, 0 }, | |
e8324357 | 26 | { VALID, VALID, WLAN_RC_PHY_OFDM, 9000, /* 9 Mb */ |
f078f209 LR |
27 | 7800, 0x0f, 0x00, 18, |
28 | 0, 3, 1, 1, 1, 1, 1, 0 }, | |
46d14a58 | 29 | { VALID, VALID, WLAN_RC_PHY_OFDM, 12000, /* 12 Mb */ |
f078f209 LR |
30 | 10000, 0x0a, 0x00, 24, |
31 | 2, 4, 2, 2, 2, 2, 2, 0 }, | |
46d14a58 | 32 | { VALID, VALID, WLAN_RC_PHY_OFDM, 18000, /* 18 Mb */ |
f078f209 LR |
33 | 13900, 0x0e, 0x00, 36, |
34 | 2, 6, 2, 3, 3, 3, 3, 0 }, | |
46d14a58 | 35 | { VALID, VALID, WLAN_RC_PHY_OFDM, 24000, /* 24 Mb */ |
f078f209 LR |
36 | 17300, 0x09, 0x00, 48, |
37 | 4, 10, 3, 4, 4, 4, 4, 0 }, | |
46d14a58 | 38 | { VALID, VALID, WLAN_RC_PHY_OFDM, 36000, /* 36 Mb */ |
f078f209 LR |
39 | 23000, 0x0d, 0x00, 72, |
40 | 4, 14, 3, 5, 5, 5, 5, 0 }, | |
46d14a58 | 41 | { VALID, VALID, WLAN_RC_PHY_OFDM, 48000, /* 48 Mb */ |
f078f209 LR |
42 | 27400, 0x08, 0x00, 96, |
43 | 4, 20, 3, 6, 6, 6, 6, 0 }, | |
46d14a58 | 44 | { VALID, VALID, WLAN_RC_PHY_OFDM, 54000, /* 54 Mb */ |
f078f209 LR |
45 | 29300, 0x0c, 0x00, 108, |
46 | 4, 23, 3, 7, 7, 7, 7, 0 }, | |
46d14a58 | 47 | { VALID_20, VALID_20, WLAN_RC_PHY_HT_20_SS, 6500, /* 6.5 Mb */ |
f078f209 LR |
48 | 6400, 0x80, 0x00, 0, |
49 | 0, 2, 3, 8, 24, 8, 24, 3216 }, | |
46d14a58 | 50 | { VALID_20, VALID_20, WLAN_RC_PHY_HT_20_SS, 13000, /* 13 Mb */ |
f078f209 LR |
51 | 12700, 0x81, 0x00, 1, |
52 | 2, 4, 3, 9, 25, 9, 25, 6434 }, | |
46d14a58 | 53 | { VALID_20, VALID_20, WLAN_RC_PHY_HT_20_SS, 19500, /* 19.5 Mb */ |
f078f209 LR |
54 | 18800, 0x82, 0x00, 2, |
55 | 2, 6, 3, 10, 26, 10, 26, 9650 }, | |
46d14a58 | 56 | { VALID_20, VALID_20, WLAN_RC_PHY_HT_20_SS, 26000, /* 26 Mb */ |
f078f209 LR |
57 | 25000, 0x83, 0x00, 3, |
58 | 4, 10, 3, 11, 27, 11, 27, 12868 }, | |
46d14a58 | 59 | { VALID_20, VALID_20, WLAN_RC_PHY_HT_20_SS, 39000, /* 39 Mb */ |
f078f209 LR |
60 | 36700, 0x84, 0x00, 4, |
61 | 4, 14, 3, 12, 28, 12, 28, 19304 }, | |
46d14a58 | 62 | { INVALID, VALID_20, WLAN_RC_PHY_HT_20_SS, 52000, /* 52 Mb */ |
f078f209 LR |
63 | 48100, 0x85, 0x00, 5, |
64 | 4, 20, 3, 13, 29, 13, 29, 25740 }, | |
46d14a58 | 65 | { INVALID, VALID_20, WLAN_RC_PHY_HT_20_SS, 58500, /* 58.5 Mb */ |
f078f209 LR |
66 | 53500, 0x86, 0x00, 6, |
67 | 4, 23, 3, 14, 30, 14, 30, 28956 }, | |
46d14a58 | 68 | { INVALID, VALID_20, WLAN_RC_PHY_HT_20_SS, 65000, /* 65 Mb */ |
f078f209 LR |
69 | 59000, 0x87, 0x00, 7, |
70 | 4, 25, 3, 15, 31, 15, 32, 32180 }, | |
46d14a58 | 71 | { INVALID, INVALID, WLAN_RC_PHY_HT_20_DS, 13000, /* 13 Mb */ |
f078f209 LR |
72 | 12700, 0x88, 0x00, |
73 | 8, 0, 2, 3, 16, 33, 16, 33, 6430 }, | |
46d14a58 | 74 | { INVALID, INVALID, WLAN_RC_PHY_HT_20_DS, 26000, /* 26 Mb */ |
f078f209 LR |
75 | 24800, 0x89, 0x00, 9, |
76 | 2, 4, 3, 17, 34, 17, 34, 12860 }, | |
46d14a58 | 77 | { INVALID, INVALID, WLAN_RC_PHY_HT_20_DS, 39000, /* 39 Mb */ |
f078f209 LR |
78 | 36600, 0x8a, 0x00, 10, |
79 | 2, 6, 3, 18, 35, 18, 35, 19300 }, | |
46d14a58 | 80 | { VALID_20, INVALID, WLAN_RC_PHY_HT_20_DS, 52000, /* 52 Mb */ |
f078f209 LR |
81 | 48100, 0x8b, 0x00, 11, |
82 | 4, 10, 3, 19, 36, 19, 36, 25736 }, | |
46d14a58 | 83 | { VALID_20, INVALID, WLAN_RC_PHY_HT_20_DS, 78000, /* 78 Mb */ |
f078f209 LR |
84 | 69500, 0x8c, 0x00, 12, |
85 | 4, 14, 3, 20, 37, 20, 37, 38600 }, | |
46d14a58 | 86 | { VALID_20, INVALID, WLAN_RC_PHY_HT_20_DS, 104000, /* 104 Mb */ |
f078f209 LR |
87 | 89500, 0x8d, 0x00, 13, |
88 | 4, 20, 3, 21, 38, 21, 38, 51472 }, | |
46d14a58 | 89 | { VALID_20, INVALID, WLAN_RC_PHY_HT_20_DS, 117000, /* 117 Mb */ |
f078f209 LR |
90 | 98900, 0x8e, 0x00, 14, |
91 | 4, 23, 3, 22, 39, 22, 39, 57890 }, | |
46d14a58 | 92 | { VALID_20, INVALID, WLAN_RC_PHY_HT_20_DS, 130000, /* 130 Mb */ |
f078f209 LR |
93 | 108300, 0x8f, 0x00, 15, |
94 | 4, 25, 3, 23, 40, 23, 41, 64320 }, | |
46d14a58 | 95 | { VALID_40, VALID_40, WLAN_RC_PHY_HT_40_SS, 13500, /* 13.5 Mb */ |
f078f209 LR |
96 | 13200, 0x80, 0x00, 0, |
97 | 0, 2, 3, 8, 24, 24, 24, 6684 }, | |
46d14a58 | 98 | { VALID_40, VALID_40, WLAN_RC_PHY_HT_40_SS, 27500, /* 27.0 Mb */ |
f078f209 LR |
99 | 25900, 0x81, 0x00, 1, |
100 | 2, 4, 3, 9, 25, 25, 25, 13368 }, | |
46d14a58 | 101 | { VALID_40, VALID_40, WLAN_RC_PHY_HT_40_SS, 40500, /* 40.5 Mb */ |
f078f209 LR |
102 | 38600, 0x82, 0x00, 2, |
103 | 2, 6, 3, 10, 26, 26, 26, 20052 }, | |
46d14a58 | 104 | { VALID_40, VALID_40, WLAN_RC_PHY_HT_40_SS, 54000, /* 54 Mb */ |
f078f209 LR |
105 | 49800, 0x83, 0x00, 3, |
106 | 4, 10, 3, 11, 27, 27, 27, 26738 }, | |
46d14a58 | 107 | { VALID_40, VALID_40, WLAN_RC_PHY_HT_40_SS, 81500, /* 81 Mb */ |
f078f209 LR |
108 | 72200, 0x84, 0x00, 4, |
109 | 4, 14, 3, 12, 28, 28, 28, 40104 }, | |
46d14a58 | 110 | { INVALID, VALID_40, WLAN_RC_PHY_HT_40_SS, 108000, /* 108 Mb */ |
f078f209 LR |
111 | 92900, 0x85, 0x00, 5, |
112 | 4, 20, 3, 13, 29, 29, 29, 53476 }, | |
46d14a58 | 113 | { INVALID, VALID_40, WLAN_RC_PHY_HT_40_SS, 121500, /* 121.5 Mb */ |
f078f209 LR |
114 | 102700, 0x86, 0x00, 6, |
115 | 4, 23, 3, 14, 30, 30, 30, 60156 }, | |
46d14a58 | 116 | { INVALID, VALID_40, WLAN_RC_PHY_HT_40_SS, 135000, /* 135 Mb */ |
f078f209 LR |
117 | 112000, 0x87, 0x00, 7, |
118 | 4, 25, 3, 15, 31, 32, 32, 66840 }, | |
46d14a58 | 119 | { INVALID, VALID_40, WLAN_RC_PHY_HT_40_SS_HGI, 150000, /* 150 Mb */ |
f078f209 LR |
120 | 122000, 0x87, 0x00, 7, |
121 | 4, 25, 3, 15, 31, 32, 32, 74200 }, | |
46d14a58 | 122 | { INVALID, INVALID, WLAN_RC_PHY_HT_40_DS, 27000, /* 27 Mb */ |
f078f209 LR |
123 | 25800, 0x88, 0x00, 8, |
124 | 0, 2, 3, 16, 33, 33, 33, 13360 }, | |
46d14a58 | 125 | { INVALID, INVALID, WLAN_RC_PHY_HT_40_DS, 54000, /* 54 Mb */ |
f078f209 LR |
126 | 49800, 0x89, 0x00, 9, |
127 | 2, 4, 3, 17, 34, 34, 34, 26720 }, | |
46d14a58 | 128 | { INVALID, INVALID, WLAN_RC_PHY_HT_40_DS, 81000, /* 81 Mb */ |
f078f209 LR |
129 | 71900, 0x8a, 0x00, 10, |
130 | 2, 6, 3, 18, 35, 35, 35, 40080 }, | |
46d14a58 | 131 | { VALID_40, INVALID, WLAN_RC_PHY_HT_40_DS, 108000, /* 108 Mb */ |
f078f209 LR |
132 | 92500, 0x8b, 0x00, 11, |
133 | 4, 10, 3, 19, 36, 36, 36, 53440 }, | |
46d14a58 | 134 | { VALID_40, INVALID, WLAN_RC_PHY_HT_40_DS, 162000, /* 162 Mb */ |
f078f209 LR |
135 | 130300, 0x8c, 0x00, 12, |
136 | 4, 14, 3, 20, 37, 37, 37, 80160 }, | |
46d14a58 | 137 | { VALID_40, INVALID, WLAN_RC_PHY_HT_40_DS, 216000, /* 216 Mb */ |
f078f209 LR |
138 | 162800, 0x8d, 0x00, 13, |
139 | 4, 20, 3, 21, 38, 38, 38, 106880 }, | |
46d14a58 | 140 | { VALID_40, INVALID, WLAN_RC_PHY_HT_40_DS, 243000, /* 243 Mb */ |
f078f209 LR |
141 | 178200, 0x8e, 0x00, 14, |
142 | 4, 23, 3, 22, 39, 39, 39, 120240 }, | |
46d14a58 | 143 | { VALID_40, INVALID, WLAN_RC_PHY_HT_40_DS, 270000, /* 270 Mb */ |
f078f209 LR |
144 | 192100, 0x8f, 0x00, 15, |
145 | 4, 25, 3, 23, 40, 41, 41, 133600 }, | |
46d14a58 | 146 | { VALID_40, INVALID, WLAN_RC_PHY_HT_40_DS_HGI, 300000, /* 300 Mb */ |
f078f209 LR |
147 | 207000, 0x8f, 0x00, 15, |
148 | 4, 25, 3, 23, 40, 41, 41, 148400 }, | |
149 | }, | |
150 | 50, /* probe interval */ | |
151 | 50, /* rssi reduce interval */ | |
152 | WLAN_RC_HT_FLAG, /* Phy rates allowed initially */ | |
153 | }; | |
154 | ||
f078f209 LR |
155 | /* 4ms frame limit not used for NG mode. The values filled |
156 | * for HT are the 64K max aggregate limit */ | |
157 | ||
158 | static struct ath_rate_table ar5416_11ng_ratetable = { | |
159 | 46, | |
160 | { | |
46d14a58 | 161 | { VALID_ALL, VALID_ALL, WLAN_RC_PHY_CCK, 1000, /* 1 Mb */ |
f078f209 LR |
162 | 900, 0x1b, 0x00, 2, |
163 | 0, 0, 1, 0, 0, 0, 0, 0 }, | |
46d14a58 | 164 | { VALID_ALL, VALID_ALL, WLAN_RC_PHY_CCK, 2000, /* 2 Mb */ |
f078f209 LR |
165 | 1900, 0x1a, 0x04, 4, |
166 | 1, 1, 1, 1, 1, 1, 1, 0 }, | |
46d14a58 | 167 | { VALID_ALL, VALID_ALL, WLAN_RC_PHY_CCK, 5500, /* 5.5 Mb */ |
f078f209 LR |
168 | 4900, 0x19, 0x04, 11, |
169 | 2, 2, 2, 2, 2, 2, 2, 0 }, | |
46d14a58 | 170 | { VALID_ALL, VALID_ALL, WLAN_RC_PHY_CCK, 11000, /* 11 Mb */ |
f078f209 LR |
171 | 8100, 0x18, 0x04, 22, |
172 | 3, 3, 2, 3, 3, 3, 3, 0 }, | |
46d14a58 | 173 | { INVALID, INVALID, WLAN_RC_PHY_OFDM, 6000, /* 6 Mb */ |
f078f209 LR |
174 | 5400, 0x0b, 0x00, 12, |
175 | 4, 2, 1, 4, 4, 4, 4, 0 }, | |
46d14a58 | 176 | { INVALID, INVALID, WLAN_RC_PHY_OFDM, 9000, /* 9 Mb */ |
f078f209 LR |
177 | 7800, 0x0f, 0x00, 18, |
178 | 4, 3, 1, 5, 5, 5, 5, 0 }, | |
46d14a58 | 179 | { VALID, VALID, WLAN_RC_PHY_OFDM, 12000, /* 12 Mb */ |
f078f209 LR |
180 | 10100, 0x0a, 0x00, 24, |
181 | 6, 4, 1, 6, 6, 6, 6, 0 }, | |
46d14a58 | 182 | { VALID, VALID, WLAN_RC_PHY_OFDM, 18000, /* 18 Mb */ |
f078f209 LR |
183 | 14100, 0x0e, 0x00, 36, |
184 | 6, 6, 2, 7, 7, 7, 7, 0 }, | |
46d14a58 | 185 | { VALID, VALID, WLAN_RC_PHY_OFDM, 24000, /* 24 Mb */ |
f078f209 LR |
186 | 17700, 0x09, 0x00, 48, |
187 | 8, 10, 3, 8, 8, 8, 8, 0 }, | |
46d14a58 | 188 | { VALID, VALID, WLAN_RC_PHY_OFDM, 36000, /* 36 Mb */ |
f078f209 LR |
189 | 23700, 0x0d, 0x00, 72, |
190 | 8, 14, 3, 9, 9, 9, 9, 0 }, | |
46d14a58 | 191 | { VALID, VALID, WLAN_RC_PHY_OFDM, 48000, /* 48 Mb */ |
f078f209 LR |
192 | 27400, 0x08, 0x00, 96, |
193 | 8, 20, 3, 10, 10, 10, 10, 0 }, | |
46d14a58 | 194 | { VALID, VALID, WLAN_RC_PHY_OFDM, 54000, /* 54 Mb */ |
f078f209 LR |
195 | 30900, 0x0c, 0x00, 108, |
196 | 8, 23, 3, 11, 11, 11, 11, 0 }, | |
46d14a58 | 197 | { INVALID, INVALID, WLAN_RC_PHY_HT_20_SS, 6500, /* 6.5 Mb */ |
f078f209 LR |
198 | 6400, 0x80, 0x00, 0, |
199 | 4, 2, 3, 12, 28, 12, 28, 3216 }, | |
46d14a58 | 200 | { VALID_20, VALID_20, WLAN_RC_PHY_HT_20_SS, 13000, /* 13 Mb */ |
f078f209 LR |
201 | 12700, 0x81, 0x00, 1, |
202 | 6, 4, 3, 13, 29, 13, 29, 6434 }, | |
46d14a58 | 203 | { VALID_20, VALID_20, WLAN_RC_PHY_HT_20_SS, 19500, /* 19.5 Mb */ |
f078f209 LR |
204 | 18800, 0x82, 0x00, 2, |
205 | 6, 6, 3, 14, 30, 14, 30, 9650 }, | |
46d14a58 | 206 | { VALID_20, VALID_20, WLAN_RC_PHY_HT_20_SS, 26000, /* 26 Mb */ |
f078f209 LR |
207 | 25000, 0x83, 0x00, 3, |
208 | 8, 10, 3, 15, 31, 15, 31, 12868 }, | |
46d14a58 | 209 | { VALID_20, VALID_20, WLAN_RC_PHY_HT_20_SS, 39000, /* 39 Mb */ |
f078f209 LR |
210 | 36700, 0x84, 0x00, 4, |
211 | 8, 14, 3, 16, 32, 16, 32, 19304 }, | |
46d14a58 | 212 | { INVALID, VALID_20, WLAN_RC_PHY_HT_20_SS, 52000, /* 52 Mb */ |
f078f209 LR |
213 | 48100, 0x85, 0x00, 5, |
214 | 8, 20, 3, 17, 33, 17, 33, 25740 }, | |
46d14a58 | 215 | { INVALID, VALID_20, WLAN_RC_PHY_HT_20_SS, 58500, /* 58.5 Mb */ |
f078f209 LR |
216 | 53500, 0x86, 0x00, 6, |
217 | 8, 23, 3, 18, 34, 18, 34, 28956 }, | |
46d14a58 | 218 | { INVALID, VALID_20, WLAN_RC_PHY_HT_20_SS, 65000, /* 65 Mb */ |
f078f209 LR |
219 | 59000, 0x87, 0x00, 7, |
220 | 8, 25, 3, 19, 35, 19, 36, 32180 }, | |
46d14a58 | 221 | { INVALID, INVALID, WLAN_RC_PHY_HT_20_DS, 13000, /* 13 Mb */ |
f078f209 LR |
222 | 12700, 0x88, 0x00, 8, |
223 | 4, 2, 3, 20, 37, 20, 37, 6430 }, | |
46d14a58 | 224 | { INVALID, INVALID, WLAN_RC_PHY_HT_20_DS, 26000, /* 26 Mb */ |
f078f209 LR |
225 | 24800, 0x89, 0x00, 9, |
226 | 6, 4, 3, 21, 38, 21, 38, 12860 }, | |
46d14a58 | 227 | { INVALID, INVALID, WLAN_RC_PHY_HT_20_DS, 39000, /* 39 Mb */ |
f078f209 LR |
228 | 36600, 0x8a, 0x00, 10, |
229 | 6, 6, 3, 22, 39, 22, 39, 19300 }, | |
46d14a58 | 230 | { VALID_20, INVALID, WLAN_RC_PHY_HT_20_DS, 52000, /* 52 Mb */ |
f078f209 LR |
231 | 48100, 0x8b, 0x00, 11, |
232 | 8, 10, 3, 23, 40, 23, 40, 25736 }, | |
46d14a58 | 233 | { VALID_20, INVALID, WLAN_RC_PHY_HT_20_DS, 78000, /* 78 Mb */ |
f078f209 LR |
234 | 69500, 0x8c, 0x00, 12, |
235 | 8, 14, 3, 24, 41, 24, 41, 38600 }, | |
46d14a58 | 236 | { VALID_20, INVALID, WLAN_RC_PHY_HT_20_DS, 104000, /* 104 Mb */ |
f078f209 LR |
237 | 89500, 0x8d, 0x00, 13, |
238 | 8, 20, 3, 25, 42, 25, 42, 51472 }, | |
46d14a58 | 239 | { VALID_20, INVALID, WLAN_RC_PHY_HT_20_DS, 117000, /* 117 Mb */ |
f078f209 LR |
240 | 98900, 0x8e, 0x00, 14, |
241 | 8, 23, 3, 26, 43, 26, 44, 57890 }, | |
46d14a58 | 242 | { VALID_20, INVALID, WLAN_RC_PHY_HT_20_DS, 130000, /* 130 Mb */ |
f078f209 LR |
243 | 108300, 0x8f, 0x00, 15, |
244 | 8, 25, 3, 27, 44, 27, 45, 64320 }, | |
46d14a58 | 245 | { VALID_40, VALID_40, WLAN_RC_PHY_HT_40_SS, 13500, /* 13.5 Mb */ |
f078f209 LR |
246 | 13200, 0x80, 0x00, 0, |
247 | 8, 2, 3, 12, 28, 28, 28, 6684 }, | |
46d14a58 | 248 | { VALID_40, VALID_40, WLAN_RC_PHY_HT_40_SS, 27500, /* 27.0 Mb */ |
f078f209 LR |
249 | 25900, 0x81, 0x00, 1, |
250 | 8, 4, 3, 13, 29, 29, 29, 13368 }, | |
46d14a58 | 251 | { VALID_40, VALID_40, WLAN_RC_PHY_HT_40_SS, 40500, /* 40.5 Mb */ |
f078f209 LR |
252 | 38600, 0x82, 0x00, 2, |
253 | 8, 6, 3, 14, 30, 30, 30, 20052 }, | |
46d14a58 | 254 | { VALID_40, VALID_40, WLAN_RC_PHY_HT_40_SS, 54000, /* 54 Mb */ |
f078f209 LR |
255 | 49800, 0x83, 0x00, 3, |
256 | 8, 10, 3, 15, 31, 31, 31, 26738 }, | |
46d14a58 | 257 | { VALID_40, VALID_40, WLAN_RC_PHY_HT_40_SS, 81500, /* 81 Mb */ |
f078f209 LR |
258 | 72200, 0x84, 0x00, 4, |
259 | 8, 14, 3, 16, 32, 32, 32, 40104 }, | |
46d14a58 | 260 | { INVALID, VALID_40, WLAN_RC_PHY_HT_40_SS, 108000, /* 108 Mb */ |
f078f209 LR |
261 | 92900, 0x85, 0x00, 5, |
262 | 8, 20, 3, 17, 33, 33, 33, 53476 }, | |
46d14a58 | 263 | { INVALID, VALID_40, WLAN_RC_PHY_HT_40_SS, 121500, /* 121.5 Mb */ |
f078f209 LR |
264 | 102700, 0x86, 0x00, 6, |
265 | 8, 23, 3, 18, 34, 34, 34, 60156 }, | |
46d14a58 | 266 | { INVALID, VALID_40, WLAN_RC_PHY_HT_40_SS, 135000, /* 135 Mb */ |
f078f209 LR |
267 | 112000, 0x87, 0x00, 7, |
268 | 8, 23, 3, 19, 35, 36, 36, 66840 }, | |
46d14a58 | 269 | { INVALID, VALID_40, WLAN_RC_PHY_HT_40_SS_HGI, 150000, /* 150 Mb */ |
f078f209 LR |
270 | 122000, 0x87, 0x00, 7, |
271 | 8, 25, 3, 19, 35, 36, 36, 74200 }, | |
46d14a58 | 272 | { INVALID, INVALID, WLAN_RC_PHY_HT_40_DS, 27000, /* 27 Mb */ |
f078f209 LR |
273 | 25800, 0x88, 0x00, 8, |
274 | 8, 2, 3, 20, 37, 37, 37, 13360 }, | |
46d14a58 | 275 | { INVALID, INVALID, WLAN_RC_PHY_HT_40_DS, 54000, /* 54 Mb */ |
f078f209 LR |
276 | 49800, 0x89, 0x00, 9, |
277 | 8, 4, 3, 21, 38, 38, 38, 26720 }, | |
46d14a58 | 278 | { INVALID, INVALID, WLAN_RC_PHY_HT_40_DS, 81000, /* 81 Mb */ |
f078f209 LR |
279 | 71900, 0x8a, 0x00, 10, |
280 | 8, 6, 3, 22, 39, 39, 39, 40080 }, | |
46d14a58 | 281 | { VALID_40, INVALID, WLAN_RC_PHY_HT_40_DS, 108000, /* 108 Mb */ |
f078f209 LR |
282 | 92500, 0x8b, 0x00, 11, |
283 | 8, 10, 3, 23, 40, 40, 40, 53440 }, | |
46d14a58 | 284 | { VALID_40, INVALID, WLAN_RC_PHY_HT_40_DS, 162000, /* 162 Mb */ |
f078f209 LR |
285 | 130300, 0x8c, 0x00, 12, |
286 | 8, 14, 3, 24, 41, 41, 41, 80160 }, | |
46d14a58 | 287 | { VALID_40, INVALID, WLAN_RC_PHY_HT_40_DS, 216000, /* 216 Mb */ |
f078f209 LR |
288 | 162800, 0x8d, 0x00, 13, |
289 | 8, 20, 3, 25, 42, 42, 42, 106880 }, | |
46d14a58 | 290 | { VALID_40, INVALID, WLAN_RC_PHY_HT_40_DS, 243000, /* 243 Mb */ |
f078f209 LR |
291 | 178200, 0x8e, 0x00, 14, |
292 | 8, 23, 3, 26, 43, 43, 43, 120240 }, | |
46d14a58 | 293 | { VALID_40, INVALID, WLAN_RC_PHY_HT_40_DS, 270000, /* 270 Mb */ |
f078f209 LR |
294 | 192100, 0x8f, 0x00, 15, |
295 | 8, 23, 3, 27, 44, 45, 45, 133600 }, | |
46d14a58 | 296 | { VALID_40, INVALID, WLAN_RC_PHY_HT_40_DS_HGI, 300000, /* 300 Mb */ |
f078f209 LR |
297 | 207000, 0x8f, 0x00, 15, |
298 | 8, 25, 3, 27, 44, 45, 45, 148400 }, | |
299 | }, | |
300 | 50, /* probe interval */ | |
301 | 50, /* rssi reduce interval */ | |
302 | WLAN_RC_HT_FLAG, /* Phy rates allowed initially */ | |
303 | }; | |
304 | ||
305 | static struct ath_rate_table ar5416_11a_ratetable = { | |
306 | 8, | |
307 | { | |
46d14a58 | 308 | { VALID, VALID, WLAN_RC_PHY_OFDM, 6000, /* 6 Mb */ |
f078f209 LR |
309 | 5400, 0x0b, 0x00, (0x80|12), |
310 | 0, 2, 1, 0, 0 }, | |
46d14a58 | 311 | { VALID, VALID, WLAN_RC_PHY_OFDM, 9000, /* 9 Mb */ |
f078f209 LR |
312 | 7800, 0x0f, 0x00, 18, |
313 | 0, 3, 1, 1, 0 }, | |
46d14a58 | 314 | { VALID, VALID, WLAN_RC_PHY_OFDM, 12000, /* 12 Mb */ |
f078f209 LR |
315 | 10000, 0x0a, 0x00, (0x80|24), |
316 | 2, 4, 2, 2, 0 }, | |
46d14a58 | 317 | { VALID, VALID, WLAN_RC_PHY_OFDM, 18000, /* 18 Mb */ |
f078f209 LR |
318 | 13900, 0x0e, 0x00, 36, |
319 | 2, 6, 2, 3, 0 }, | |
46d14a58 | 320 | { VALID, VALID, WLAN_RC_PHY_OFDM, 24000, /* 24 Mb */ |
f078f209 LR |
321 | 17300, 0x09, 0x00, (0x80|48), |
322 | 4, 10, 3, 4, 0 }, | |
46d14a58 | 323 | { VALID, VALID, WLAN_RC_PHY_OFDM, 36000, /* 36 Mb */ |
f078f209 LR |
324 | 23000, 0x0d, 0x00, 72, |
325 | 4, 14, 3, 5, 0 }, | |
46d14a58 | 326 | { VALID, VALID, WLAN_RC_PHY_OFDM, 48000, /* 48 Mb */ |
f078f209 LR |
327 | 27400, 0x08, 0x00, 96, |
328 | 4, 19, 3, 6, 0 }, | |
46d14a58 | 329 | { VALID, VALID, WLAN_RC_PHY_OFDM, 54000, /* 54 Mb */ |
f078f209 LR |
330 | 29300, 0x0c, 0x00, 108, |
331 | 4, 23, 3, 7, 0 }, | |
332 | }, | |
333 | 50, /* probe interval */ | |
334 | 50, /* rssi reduce interval */ | |
335 | 0, /* Phy rates allowed initially */ | |
336 | }; | |
337 | ||
f078f209 LR |
338 | static struct ath_rate_table ar5416_11g_ratetable = { |
339 | 12, | |
340 | { | |
46d14a58 | 341 | { VALID, VALID, WLAN_RC_PHY_CCK, 1000, /* 1 Mb */ |
f078f209 LR |
342 | 900, 0x1b, 0x00, 2, |
343 | 0, 0, 1, 0, 0 }, | |
46d14a58 | 344 | { VALID, VALID, WLAN_RC_PHY_CCK, 2000, /* 2 Mb */ |
f078f209 LR |
345 | 1900, 0x1a, 0x04, 4, |
346 | 1, 1, 1, 1, 0 }, | |
46d14a58 | 347 | { VALID, VALID, WLAN_RC_PHY_CCK, 5500, /* 5.5 Mb */ |
f078f209 LR |
348 | 4900, 0x19, 0x04, 11, |
349 | 2, 2, 2, 2, 0 }, | |
46d14a58 | 350 | { VALID, VALID, WLAN_RC_PHY_CCK, 11000, /* 11 Mb */ |
f078f209 LR |
351 | 8100, 0x18, 0x04, 22, |
352 | 3, 3, 2, 3, 0 }, | |
46d14a58 | 353 | { INVALID, INVALID, WLAN_RC_PHY_OFDM, 6000, /* 6 Mb */ |
f078f209 LR |
354 | 5400, 0x0b, 0x00, 12, |
355 | 4, 2, 1, 4, 0 }, | |
46d14a58 | 356 | { INVALID, INVALID, WLAN_RC_PHY_OFDM, 9000, /* 9 Mb */ |
f078f209 LR |
357 | 7800, 0x0f, 0x00, 18, |
358 | 4, 3, 1, 5, 0 }, | |
46d14a58 | 359 | { VALID, VALID, WLAN_RC_PHY_OFDM, 12000, /* 12 Mb */ |
f078f209 LR |
360 | 10000, 0x0a, 0x00, 24, |
361 | 6, 4, 1, 6, 0 }, | |
46d14a58 | 362 | { VALID, VALID, WLAN_RC_PHY_OFDM, 18000, /* 18 Mb */ |
f078f209 LR |
363 | 13900, 0x0e, 0x00, 36, |
364 | 6, 6, 2, 7, 0 }, | |
46d14a58 | 365 | { VALID, VALID, WLAN_RC_PHY_OFDM, 24000, /* 24 Mb */ |
f078f209 LR |
366 | 17300, 0x09, 0x00, 48, |
367 | 8, 10, 3, 8, 0 }, | |
46d14a58 | 368 | { VALID, VALID, WLAN_RC_PHY_OFDM, 36000, /* 36 Mb */ |
f078f209 LR |
369 | 23000, 0x0d, 0x00, 72, |
370 | 8, 14, 3, 9, 0 }, | |
46d14a58 | 371 | { VALID, VALID, WLAN_RC_PHY_OFDM, 48000, /* 48 Mb */ |
f078f209 LR |
372 | 27400, 0x08, 0x00, 96, |
373 | 8, 19, 3, 10, 0 }, | |
46d14a58 | 374 | { VALID, VALID, WLAN_RC_PHY_OFDM, 54000, /* 54 Mb */ |
f078f209 LR |
375 | 29300, 0x0c, 0x00, 108, |
376 | 8, 23, 3, 11, 0 }, | |
377 | }, | |
378 | 50, /* probe interval */ | |
379 | 50, /* rssi reduce interval */ | |
380 | 0, /* Phy rates allowed initially */ | |
381 | }; | |
382 | ||
383 | static struct ath_rate_table ar5416_11b_ratetable = { | |
384 | 4, | |
385 | { | |
46d14a58 | 386 | { VALID, VALID, WLAN_RC_PHY_CCK, 1000, /* 1 Mb */ |
f078f209 LR |
387 | 900, 0x1b, 0x00, (0x80|2), |
388 | 0, 0, 1, 0, 0 }, | |
46d14a58 | 389 | { VALID, VALID, WLAN_RC_PHY_CCK, 2000, /* 2 Mb */ |
f078f209 LR |
390 | 1800, 0x1a, 0x04, (0x80|4), |
391 | 1, 1, 1, 1, 0 }, | |
46d14a58 | 392 | { VALID, VALID, WLAN_RC_PHY_CCK, 5500, /* 5.5 Mb */ |
f078f209 LR |
393 | 4300, 0x19, 0x04, (0x80|11), |
394 | 1, 2, 2, 2, 0 }, | |
46d14a58 | 395 | { VALID, VALID, WLAN_RC_PHY_CCK, 11000, /* 11 Mb */ |
f078f209 LR |
396 | 7100, 0x18, 0x04, (0x80|22), |
397 | 1, 4, 100, 3, 0 }, | |
398 | }, | |
399 | 100, /* probe interval */ | |
400 | 100, /* rssi reduce interval */ | |
401 | 0, /* Phy rates allowed initially */ | |
402 | }; | |
403 | ||
f078f209 LR |
404 | static inline int8_t median(int8_t a, int8_t b, int8_t c) |
405 | { | |
406 | if (a >= b) { | |
407 | if (b >= c) | |
408 | return b; | |
409 | else if (a > c) | |
410 | return c; | |
411 | else | |
412 | return a; | |
413 | } else { | |
414 | if (a >= c) | |
415 | return a; | |
416 | else if (b >= c) | |
417 | return c; | |
418 | else | |
419 | return b; | |
420 | } | |
421 | } | |
422 | ||
fe7f4a77 | 423 | static void ath_rc_sort_validrates(struct ath_rate_table *rate_table, |
46d14a58 | 424 | struct ath_rate_priv *ath_rc_priv) |
f078f209 LR |
425 | { |
426 | u8 i, j, idx, idx_next; | |
427 | ||
256b7759 | 428 | for (i = ath_rc_priv->max_valid_rate - 1; i > 0; i--) { |
f078f209 | 429 | for (j = 0; j <= i-1; j++) { |
256b7759 S |
430 | idx = ath_rc_priv->valid_rate_index[j]; |
431 | idx_next = ath_rc_priv->valid_rate_index[j+1]; | |
f078f209 LR |
432 | |
433 | if (rate_table->info[idx].ratekbps > | |
434 | rate_table->info[idx_next].ratekbps) { | |
256b7759 S |
435 | ath_rc_priv->valid_rate_index[j] = idx_next; |
436 | ath_rc_priv->valid_rate_index[j+1] = idx; | |
f078f209 LR |
437 | } |
438 | } | |
439 | } | |
440 | } | |
441 | ||
46d14a58 | 442 | static void ath_rc_init_valid_txmask(struct ath_rate_priv *ath_rc_priv) |
f078f209 LR |
443 | { |
444 | u8 i; | |
445 | ||
256b7759 | 446 | for (i = 0; i < ath_rc_priv->rate_table_size; i++) |
46d14a58 | 447 | ath_rc_priv->valid_rate_index[i] = 0; |
f078f209 LR |
448 | } |
449 | ||
46d14a58 | 450 | static inline void ath_rc_set_valid_txmask(struct ath_rate_priv *ath_rc_priv, |
f078f209 LR |
451 | u8 index, int valid_tx_rate) |
452 | { | |
256b7759 | 453 | ASSERT(index <= ath_rc_priv->rate_table_size); |
46d14a58 | 454 | ath_rc_priv->valid_rate_index[index] = valid_tx_rate ? 1 : 0; |
f078f209 LR |
455 | } |
456 | ||
46d14a58 | 457 | static inline int ath_rc_isvalid_txmask(struct ath_rate_priv *ath_rc_priv, |
f078f209 LR |
458 | u8 index) |
459 | { | |
256b7759 S |
460 | ASSERT(index <= ath_rc_priv->rate_table_size); |
461 | return ath_rc_priv->valid_rate_index[index]; | |
f078f209 LR |
462 | } |
463 | ||
2c5a744d S |
464 | static inline int ath_rc_get_nextvalid_txrate(struct ath_rate_table *rate_table, |
465 | struct ath_rate_priv *ath_rc_priv, | |
466 | u8 cur_valid_txrate, | |
467 | u8 *next_idx) | |
f078f209 LR |
468 | { |
469 | u8 i; | |
470 | ||
256b7759 S |
471 | for (i = 0; i < ath_rc_priv->max_valid_rate - 1; i++) { |
472 | if (ath_rc_priv->valid_rate_index[i] == cur_valid_txrate) { | |
473 | *next_idx = ath_rc_priv->valid_rate_index[i+1]; | |
46d14a58 | 474 | return 1; |
f078f209 LR |
475 | } |
476 | } | |
477 | ||
478 | /* No more valid rates */ | |
479 | *next_idx = 0; | |
2c5a744d | 480 | |
46d14a58 | 481 | return 0; |
f078f209 LR |
482 | } |
483 | ||
484 | /* Return true only for single stream */ | |
485 | ||
486 | static int ath_rc_valid_phyrate(u32 phy, u32 capflag, int ignore_cw) | |
487 | { | |
b657eade | 488 | if (WLAN_RC_PHY_HT(phy) && !(capflag & WLAN_RC_HT_FLAG)) |
46d14a58 | 489 | return 0; |
f078f209 | 490 | if (WLAN_RC_PHY_DS(phy) && !(capflag & WLAN_RC_DS_FLAG)) |
46d14a58 | 491 | return 0; |
f078f209 | 492 | if (WLAN_RC_PHY_SGI(phy) && !(capflag & WLAN_RC_SGI_FLAG)) |
46d14a58 | 493 | return 0; |
f078f209 LR |
494 | if (!ignore_cw && WLAN_RC_PHY_HT(phy)) |
495 | if (WLAN_RC_PHY_40(phy) && !(capflag & WLAN_RC_40_FLAG)) | |
46d14a58 | 496 | return 0; |
f078f209 | 497 | if (!WLAN_RC_PHY_40(phy) && (capflag & WLAN_RC_40_FLAG)) |
46d14a58 S |
498 | return 0; |
499 | return 1; | |
f078f209 LR |
500 | } |
501 | ||
502 | static inline int | |
fe7f4a77 | 503 | ath_rc_get_nextlowervalid_txrate(struct ath_rate_table *rate_table, |
46d14a58 | 504 | struct ath_rate_priv *ath_rc_priv, |
f078f209 LR |
505 | u8 cur_valid_txrate, u8 *next_idx) |
506 | { | |
507 | int8_t i; | |
508 | ||
256b7759 S |
509 | for (i = 1; i < ath_rc_priv->max_valid_rate ; i++) { |
510 | if (ath_rc_priv->valid_rate_index[i] == cur_valid_txrate) { | |
511 | *next_idx = ath_rc_priv->valid_rate_index[i-1]; | |
46d14a58 | 512 | return 1; |
f078f209 LR |
513 | } |
514 | } | |
2c5a744d | 515 | |
46d14a58 | 516 | return 0; |
f078f209 LR |
517 | } |
518 | ||
2c5a744d S |
519 | static u8 ath_rc_init_validrates(struct ath_rate_priv *ath_rc_priv, |
520 | struct ath_rate_table *rate_table, | |
521 | u32 capflag) | |
f078f209 | 522 | { |
f078f209 LR |
523 | u8 i, hi = 0; |
524 | u32 valid; | |
525 | ||
f078f209 LR |
526 | for (i = 0; i < rate_table->rate_cnt; i++) { |
527 | valid = (ath_rc_priv->single_stream ? | |
dc2222a8 S |
528 | rate_table->info[i].valid_single_stream : |
529 | rate_table->info[i].valid); | |
46d14a58 | 530 | if (valid == 1) { |
f078f209 LR |
531 | u32 phy = rate_table->info[i].phy; |
532 | u8 valid_rate_count = 0; | |
533 | ||
46d14a58 | 534 | if (!ath_rc_valid_phyrate(phy, capflag, 0)) |
f078f209 LR |
535 | continue; |
536 | ||
256b7759 | 537 | valid_rate_count = ath_rc_priv->valid_phy_ratecnt[phy]; |
f078f209 | 538 | |
256b7759 S |
539 | ath_rc_priv->valid_phy_rateidx[phy][valid_rate_count] = i; |
540 | ath_rc_priv->valid_phy_ratecnt[phy] += 1; | |
46d14a58 | 541 | ath_rc_set_valid_txmask(ath_rc_priv, i, 1); |
f078f209 LR |
542 | hi = A_MAX(hi, i); |
543 | } | |
544 | } | |
2c5a744d | 545 | |
f078f209 LR |
546 | return hi; |
547 | } | |
548 | ||
2c5a744d S |
549 | static u8 ath_rc_setvalid_rates(struct ath_rate_priv *ath_rc_priv, |
550 | struct ath_rate_table *rate_table, | |
551 | struct ath_rateset *rateset, | |
552 | u32 capflag) | |
f078f209 | 553 | { |
f078f209 | 554 | u8 i, j, hi = 0; |
f078f209 LR |
555 | |
556 | /* Use intersection of working rates and valid rates */ | |
557 | for (i = 0; i < rateset->rs_nrates; i++) { | |
558 | for (j = 0; j < rate_table->rate_cnt; j++) { | |
559 | u32 phy = rate_table->info[j].phy; | |
560 | u32 valid = (ath_rc_priv->single_stream ? | |
561 | rate_table->info[j].valid_single_stream : | |
562 | rate_table->info[j].valid); | |
2c5a744d S |
563 | u8 rate = rateset->rs_rates[i]; |
564 | u8 dot11rate = rate_table->info[j].dot11rate; | |
f078f209 LR |
565 | |
566 | /* We allow a rate only if its valid and the | |
567 | * capflag matches one of the validity | |
46d14a58 | 568 | * (VALID/VALID_20/VALID_40) flags */ |
f078f209 | 569 | |
2c5a744d S |
570 | if (((rate & 0x7F) == (dot11rate & 0x7F)) && |
571 | ((valid & WLAN_RC_CAP_MODE(capflag)) == | |
572 | WLAN_RC_CAP_MODE(capflag)) && | |
573 | !WLAN_RC_PHY_HT(phy)) { | |
f078f209 LR |
574 | u8 valid_rate_count = 0; |
575 | ||
46d14a58 | 576 | if (!ath_rc_valid_phyrate(phy, capflag, 0)) |
f078f209 LR |
577 | continue; |
578 | ||
579 | valid_rate_count = | |
256b7759 | 580 | ath_rc_priv->valid_phy_ratecnt[phy]; |
f078f209 | 581 | |
256b7759 | 582 | ath_rc_priv->valid_phy_rateidx[phy] |
f078f209 | 583 | [valid_rate_count] = j; |
256b7759 | 584 | ath_rc_priv->valid_phy_ratecnt[phy] += 1; |
46d14a58 | 585 | ath_rc_set_valid_txmask(ath_rc_priv, j, 1); |
f078f209 LR |
586 | hi = A_MAX(hi, j); |
587 | } | |
588 | } | |
589 | } | |
2c5a744d | 590 | |
f078f209 LR |
591 | return hi; |
592 | } | |
593 | ||
2c5a744d S |
594 | static u8 ath_rc_setvalid_htrates(struct ath_rate_priv *ath_rc_priv, |
595 | struct ath_rate_table *rate_table, | |
596 | u8 *mcs_set, u32 capflag) | |
f078f209 | 597 | { |
2c5a744d S |
598 | struct ath_rateset *rateset = (struct ath_rateset *)mcs_set; |
599 | ||
f078f209 | 600 | u8 i, j, hi = 0; |
f078f209 LR |
601 | |
602 | /* Use intersection of working rates and valid rates */ | |
2c5a744d | 603 | for (i = 0; i < rateset->rs_nrates; i++) { |
f078f209 LR |
604 | for (j = 0; j < rate_table->rate_cnt; j++) { |
605 | u32 phy = rate_table->info[j].phy; | |
606 | u32 valid = (ath_rc_priv->single_stream ? | |
dc2222a8 S |
607 | rate_table->info[j].valid_single_stream : |
608 | rate_table->info[j].valid); | |
2c5a744d S |
609 | u8 rate = rateset->rs_rates[i]; |
610 | u8 dot11rate = rate_table->info[j].dot11rate; | |
f078f209 | 611 | |
2c5a744d | 612 | if (((rate & 0x7F) != (dot11rate & 0x7F)) || |
dc2222a8 S |
613 | !WLAN_RC_PHY_HT(phy) || |
614 | !WLAN_RC_PHY_HT_VALID(valid, capflag)) | |
f078f209 LR |
615 | continue; |
616 | ||
46d14a58 | 617 | if (!ath_rc_valid_phyrate(phy, capflag, 0)) |
f078f209 LR |
618 | continue; |
619 | ||
256b7759 S |
620 | ath_rc_priv->valid_phy_rateidx[phy] |
621 | [ath_rc_priv->valid_phy_ratecnt[phy]] = j; | |
622 | ath_rc_priv->valid_phy_ratecnt[phy] += 1; | |
46d14a58 | 623 | ath_rc_set_valid_txmask(ath_rc_priv, j, 1); |
f078f209 LR |
624 | hi = A_MAX(hi, j); |
625 | } | |
626 | } | |
f078f209 | 627 | |
2c5a744d | 628 | return hi; |
f078f209 LR |
629 | } |
630 | ||
f078f209 | 631 | static u8 ath_rc_ratefind_ht(struct ath_softc *sc, |
46d14a58 | 632 | struct ath_rate_priv *ath_rc_priv, |
fe7f4a77 | 633 | struct ath_rate_table *rate_table, |
3900898c | 634 | int *is_probing) |
f078f209 LR |
635 | { |
636 | u32 dt, best_thruput, this_thruput, now_msec; | |
637 | u8 rate, next_rate, best_rate, maxindex, minindex; | |
638 | int8_t rssi_last, rssi_reduce = 0, index = 0; | |
f078f209 | 639 | |
46d14a58 | 640 | *is_probing = 0; |
f078f209 | 641 | |
256b7759 S |
642 | rssi_last = median(ath_rc_priv->rssi_last, |
643 | ath_rc_priv->rssi_last_prev, | |
644 | ath_rc_priv->rssi_last_prev2); | |
f078f209 LR |
645 | |
646 | /* | |
647 | * Age (reduce) last ack rssi based on how old it is. | |
648 | * The bizarre numbers are so the delta is 160msec, | |
649 | * meaning we divide by 16. | |
650 | * 0msec <= dt <= 25msec: don't derate | |
651 | * 25msec <= dt <= 185msec: derate linearly from 0 to 10dB | |
652 | * 185msec <= dt: derate by 10dB | |
653 | */ | |
654 | ||
655 | now_msec = jiffies_to_msecs(jiffies); | |
256b7759 | 656 | dt = now_msec - ath_rc_priv->rssi_time; |
f078f209 LR |
657 | |
658 | if (dt >= 185) | |
659 | rssi_reduce = 10; | |
660 | else if (dt >= 25) | |
661 | rssi_reduce = (u8)((dt - 25) >> 4); | |
662 | ||
663 | /* Now reduce rssi_last by rssi_reduce */ | |
664 | if (rssi_last < rssi_reduce) | |
665 | rssi_last = 0; | |
666 | else | |
667 | rssi_last -= rssi_reduce; | |
668 | ||
669 | /* | |
670 | * Now look up the rate in the rssi table and return it. | |
671 | * If no rates match then we return 0 (lowest rate) | |
672 | */ | |
673 | ||
674 | best_thruput = 0; | |
256b7759 | 675 | maxindex = ath_rc_priv->max_valid_rate-1; |
f078f209 LR |
676 | |
677 | minindex = 0; | |
678 | best_rate = minindex; | |
679 | ||
680 | /* | |
681 | * Try the higher rate first. It will reduce memory moving time | |
682 | * if we have very good channel characteristics. | |
683 | */ | |
684 | for (index = maxindex; index >= minindex ; index--) { | |
685 | u8 per_thres; | |
686 | ||
256b7759 S |
687 | rate = ath_rc_priv->valid_rate_index[index]; |
688 | if (rate > ath_rc_priv->rate_max_phy) | |
f078f209 LR |
689 | continue; |
690 | ||
691 | /* | |
692 | * For TCP the average collision rate is around 11%, | |
693 | * so we ignore PERs less than this. This is to | |
694 | * prevent the rate we are currently using (whose | |
695 | * PER might be in the 10-15 range because of TCP | |
696 | * collisions) looking worse than the next lower | |
697 | * rate whose PER has decayed close to 0. If we | |
698 | * used to next lower rate, its PER would grow to | |
699 | * 10-15 and we would be worse off then staying | |
700 | * at the current rate. | |
701 | */ | |
256b7759 | 702 | per_thres = ath_rc_priv->state[rate].per; |
f078f209 LR |
703 | if (per_thres < 12) |
704 | per_thres = 12; | |
705 | ||
706 | this_thruput = rate_table->info[rate].user_ratekbps * | |
707 | (100 - per_thres); | |
708 | ||
709 | if (best_thruput <= this_thruput) { | |
710 | best_thruput = this_thruput; | |
711 | best_rate = rate; | |
712 | } | |
713 | } | |
714 | ||
715 | rate = best_rate; | |
256b7759 | 716 | ath_rc_priv->rssi_last_lookup = rssi_last; |
f078f209 LR |
717 | |
718 | /* | |
719 | * Must check the actual rate (ratekbps) to account for | |
720 | * non-monoticity of 11g's rate table | |
721 | */ | |
722 | ||
3900898c | 723 | if (rate >= ath_rc_priv->rate_max_phy) { |
256b7759 | 724 | rate = ath_rc_priv->rate_max_phy; |
f078f209 LR |
725 | |
726 | /* Probe the next allowed phy state */ | |
f078f209 | 727 | if (ath_rc_get_nextvalid_txrate(rate_table, |
3900898c | 728 | ath_rc_priv, rate, &next_rate) && |
256b7759 | 729 | (now_msec - ath_rc_priv->probe_time > |
f078f209 | 730 | rate_table->probe_interval) && |
256b7759 | 731 | (ath_rc_priv->hw_maxretry_pktcnt >= 1)) { |
f078f209 | 732 | rate = next_rate; |
256b7759 S |
733 | ath_rc_priv->probe_rate = rate; |
734 | ath_rc_priv->probe_time = now_msec; | |
735 | ath_rc_priv->hw_maxretry_pktcnt = 0; | |
46d14a58 | 736 | *is_probing = 1; |
f078f209 LR |
737 | } |
738 | } | |
739 | ||
256b7759 S |
740 | if (rate > (ath_rc_priv->rate_table_size - 1)) |
741 | rate = ath_rc_priv->rate_table_size - 1; | |
f078f209 LR |
742 | |
743 | ASSERT((rate_table->info[rate].valid && !ath_rc_priv->single_stream) || | |
dc2222a8 S |
744 | (rate_table->info[rate].valid_single_stream && |
745 | ath_rc_priv->single_stream)); | |
f078f209 LR |
746 | |
747 | return rate; | |
748 | } | |
749 | ||
c89424df | 750 | static void ath_rc_rate_set_series(struct ath_rate_table *rate_table, |
a8efee4f | 751 | struct ieee80211_tx_rate *rate, |
c89424df | 752 | struct ieee80211_tx_rate_control *txrc, |
2c5a744d | 753 | u8 tries, u8 rix, int rtsctsenable) |
f078f209 | 754 | { |
a8efee4f S |
755 | rate->count = tries; |
756 | rate->idx = rix; | |
757 | ||
c89424df S |
758 | if (txrc->short_preamble) |
759 | rate->flags |= IEEE80211_TX_RC_USE_SHORT_PREAMBLE; | |
760 | if (txrc->rts || rtsctsenable) | |
a8efee4f S |
761 | rate->flags |= IEEE80211_TX_RC_USE_RTS_CTS; |
762 | if (WLAN_RC_PHY_40(rate_table->info[rix].phy)) | |
763 | rate->flags |= IEEE80211_TX_RC_40_MHZ_WIDTH; | |
764 | if (WLAN_RC_PHY_SGI(rate_table->info[rix].phy)) | |
765 | rate->flags |= IEEE80211_TX_RC_SHORT_GI; | |
766 | if (WLAN_RC_PHY_HT(rate_table->info[rix].phy)) | |
767 | rate->flags |= IEEE80211_TX_RC_MCS; | |
f078f209 LR |
768 | } |
769 | ||
c89424df S |
770 | static void ath_rc_rate_set_rtscts(struct ath_softc *sc, |
771 | struct ath_rate_table *rate_table, | |
772 | struct ieee80211_tx_info *tx_info) | |
773 | { | |
774 | struct ieee80211_tx_rate *rates = tx_info->control.rates; | |
775 | int i = 0, rix = 0, cix, enable_g_protection = 0; | |
776 | ||
777 | /* get the cix for the lowest valid rix */ | |
778 | for (i = 3; i >= 0; i--) { | |
779 | if (rates[i].count && (rates[i].idx >= 0)) { | |
780 | rix = rates[i].idx; | |
781 | break; | |
782 | } | |
783 | } | |
784 | cix = rate_table->info[rix].ctrl_rate; | |
785 | ||
786 | /* All protection frames are transmited at 2Mb/s for 802.11g, | |
787 | * otherwise we transmit them at 1Mb/s */ | |
788 | if (sc->hw->conf.channel->band == IEEE80211_BAND_2GHZ && | |
789 | !conf_is_ht(&sc->hw->conf)) | |
790 | enable_g_protection = 1; | |
791 | ||
792 | /* | |
793 | * If 802.11g protection is enabled, determine whether to use RTS/CTS or | |
794 | * just CTS. Note that this is only done for OFDM/HT unicast frames. | |
795 | */ | |
796 | if ((sc->sc_flags & SC_OP_PROTECT_ENABLE) && | |
797 | !(tx_info->flags & IEEE80211_TX_CTL_NO_ACK) && | |
798 | (rate_table->info[rix].phy == WLAN_RC_PHY_OFDM || | |
799 | WLAN_RC_PHY_HT(rate_table->info[rix].phy))) { | |
800 | rates[0].flags |= IEEE80211_TX_RC_USE_CTS_PROTECT; | |
801 | cix = rate_table->info[enable_g_protection].ctrl_rate; | |
802 | } | |
803 | ||
804 | tx_info->control.rts_cts_rate_idx = cix; | |
805 | } | |
806 | ||
f078f209 | 807 | static u8 ath_rc_rate_getidx(struct ath_softc *sc, |
46d14a58 | 808 | struct ath_rate_priv *ath_rc_priv, |
fe7f4a77 | 809 | struct ath_rate_table *rate_table, |
dc2222a8 S |
810 | u8 rix, u16 stepdown, |
811 | u16 min_rate) | |
f078f209 LR |
812 | { |
813 | u32 j; | |
814 | u8 nextindex; | |
f078f209 LR |
815 | |
816 | if (min_rate) { | |
817 | for (j = RATE_TABLE_SIZE; j > 0; j--) { | |
818 | if (ath_rc_get_nextlowervalid_txrate(rate_table, | |
256b7759 | 819 | ath_rc_priv, rix, &nextindex)) |
f078f209 LR |
820 | rix = nextindex; |
821 | else | |
822 | break; | |
823 | } | |
824 | } else { | |
825 | for (j = stepdown; j > 0; j--) { | |
826 | if (ath_rc_get_nextlowervalid_txrate(rate_table, | |
256b7759 | 827 | ath_rc_priv, rix, &nextindex)) |
f078f209 LR |
828 | rix = nextindex; |
829 | else | |
830 | break; | |
831 | } | |
832 | } | |
833 | return rix; | |
834 | } | |
835 | ||
836 | static void ath_rc_ratefind(struct ath_softc *sc, | |
46d14a58 | 837 | struct ath_rate_priv *ath_rc_priv, |
3900898c | 838 | struct ieee80211_tx_rate_control *txrc) |
f078f209 | 839 | { |
f078f209 | 840 | struct ath_rate_table *rate_table; |
3900898c S |
841 | struct sk_buff *skb = txrc->skb; |
842 | struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb); | |
a8efee4f | 843 | struct ieee80211_tx_rate *rates = tx_info->control.rates; |
c89424df S |
844 | struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; |
845 | __le16 fc = hdr->frame_control; | |
3900898c S |
846 | u8 try_per_rate = 0, i = 0, rix, nrix; |
847 | int is_probe = 0; | |
f078f209 | 848 | |
40990ec0 | 849 | rate_table = sc->cur_rate_table; |
3900898c | 850 | rix = ath_rc_ratefind_ht(sc, ath_rc_priv, rate_table, &is_probe); |
f078f209 LR |
851 | nrix = rix; |
852 | ||
3900898c | 853 | if (is_probe) { |
f078f209 LR |
854 | /* set one try for probe rates. For the |
855 | * probes don't enable rts */ | |
c89424df | 856 | ath_rc_rate_set_series(rate_table, &rates[i++], txrc, |
3900898c | 857 | 1, nrix, 0); |
f078f209 | 858 | |
3900898c | 859 | try_per_rate = (ATH_11N_TXMAXTRY/4); |
f078f209 LR |
860 | /* Get the next tried/allowed rate. No RTS for the next series |
861 | * after the probe rate | |
862 | */ | |
3900898c S |
863 | nrix = ath_rc_rate_getidx(sc, ath_rc_priv, |
864 | rate_table, nrix, 1, 0); | |
c89424df | 865 | ath_rc_rate_set_series(rate_table, &rates[i++], txrc, |
3900898c | 866 | try_per_rate, nrix, 0); |
f078f209 | 867 | } else { |
3900898c | 868 | try_per_rate = (ATH_11N_TXMAXTRY/4); |
f078f209 | 869 | /* Set the choosen rate. No RTS for first series entry. */ |
c89424df | 870 | ath_rc_rate_set_series(rate_table, &rates[i++], txrc, |
3900898c | 871 | try_per_rate, nrix, 0); |
f078f209 LR |
872 | } |
873 | ||
874 | /* Fill in the other rates for multirate retry */ | |
3900898c | 875 | for ( ; i < 4; i++) { |
f078f209 LR |
876 | u8 try_num; |
877 | u8 min_rate; | |
878 | ||
3900898c S |
879 | try_num = ((i + 1) == 4) ? |
880 | ATH_11N_TXMAXTRY - (try_per_rate * i) : try_per_rate ; | |
881 | min_rate = (((i + 1) == 4) && 0); | |
f078f209 LR |
882 | |
883 | nrix = ath_rc_rate_getidx(sc, ath_rc_priv, | |
dc2222a8 | 884 | rate_table, nrix, 1, min_rate); |
f078f209 | 885 | /* All other rates in the series have RTS enabled */ |
c89424df | 886 | ath_rc_rate_set_series(rate_table, &rates[i], txrc, |
3900898c | 887 | try_num, nrix, 1); |
f078f209 LR |
888 | } |
889 | ||
890 | /* | |
891 | * NB:Change rate series to enable aggregation when operating | |
892 | * at lower MCS rates. When first rate in series is MCS2 | |
893 | * in HT40 @ 2.4GHz, series should look like: | |
894 | * | |
895 | * {MCS2, MCS1, MCS0, MCS0}. | |
896 | * | |
897 | * When first rate in series is MCS3 in HT20 @ 2.4GHz, series should | |
898 | * look like: | |
899 | * | |
900 | * {MCS3, MCS2, MCS1, MCS1} | |
901 | * | |
902 | * So, set fourth rate in series to be same as third one for | |
903 | * above conditions. | |
904 | */ | |
3706de6f | 905 | if ((sc->hw->conf.channel->band == IEEE80211_BAND_2GHZ) && |
ecf70441 | 906 | (conf_is_ht(&sc->hw->conf))) { |
40990ec0 | 907 | u8 dot11rate = rate_table->info[rix].dot11rate; |
f078f209 LR |
908 | u8 phy = rate_table->info[rix].phy; |
909 | if (i == 4 && | |
910 | ((dot11rate == 2 && phy == WLAN_RC_PHY_HT_40_SS) || | |
dc2222a8 | 911 | (dot11rate == 3 && phy == WLAN_RC_PHY_HT_20_SS))) { |
a8efee4f S |
912 | rates[3].idx = rates[2].idx; |
913 | rates[3].flags = rates[2].flags; | |
f078f209 LR |
914 | } |
915 | } | |
c89424df S |
916 | |
917 | /* | |
918 | * Force hardware to use computed duration for next | |
919 | * fragment by disabling multi-rate retry, which | |
920 | * updates duration based on the multi-rate duration table. | |
921 | * | |
922 | * FIXME: Fix duration | |
923 | */ | |
924 | if (!(tx_info->flags & IEEE80211_TX_CTL_NO_ACK) && | |
925 | (ieee80211_has_morefrags(fc) || | |
926 | (le16_to_cpu(hdr->seq_ctrl) & IEEE80211_SCTL_FRAG))) { | |
927 | rates[1].count = rates[2].count = rates[3].count = 0; | |
928 | rates[1].idx = rates[2].idx = rates[3].idx = 0; | |
929 | rates[0].count = ATH_TXMAXTRY; | |
930 | } | |
931 | ||
932 | /* Setup RTS/CTS */ | |
933 | ath_rc_rate_set_rtscts(sc, rate_table, tx_info); | |
f078f209 LR |
934 | } |
935 | ||
2c5a744d S |
936 | static bool ath_rc_update_per(struct ath_softc *sc, |
937 | struct ath_rate_table *rate_table, | |
938 | struct ath_rate_priv *ath_rc_priv, | |
939 | struct ath_tx_info_priv *tx_info_priv, | |
940 | int tx_rate, int xretries, int retries, | |
941 | u32 now_msec) | |
f078f209 | 942 | { |
2c5a744d S |
943 | bool state_change = false; |
944 | int count; | |
f078f209 | 945 | u8 last_per; |
f078f209 LR |
946 | static u32 nretry_to_per_lookup[10] = { |
947 | 100 * 0 / 1, | |
948 | 100 * 1 / 4, | |
949 | 100 * 1 / 2, | |
950 | 100 * 3 / 4, | |
951 | 100 * 4 / 5, | |
952 | 100 * 5 / 6, | |
953 | 100 * 6 / 7, | |
954 | 100 * 7 / 8, | |
955 | 100 * 8 / 9, | |
956 | 100 * 9 / 10 | |
957 | }; | |
958 | ||
256b7759 | 959 | last_per = ath_rc_priv->state[tx_rate].per; |
f078f209 LR |
960 | |
961 | if (xretries) { | |
f078f209 | 962 | if (xretries == 1) { |
256b7759 S |
963 | ath_rc_priv->state[tx_rate].per += 30; |
964 | if (ath_rc_priv->state[tx_rate].per > 100) | |
965 | ath_rc_priv->state[tx_rate].per = 100; | |
f078f209 LR |
966 | } else { |
967 | /* xretries == 2 */ | |
87c1687d | 968 | count = ARRAY_SIZE(nretry_to_per_lookup); |
f078f209 LR |
969 | if (retries >= count) |
970 | retries = count - 1; | |
2c5a744d | 971 | |
f078f209 | 972 | /* new_PER = 7/8*old_PER + 1/8*(currentPER) */ |
256b7759 | 973 | ath_rc_priv->state[tx_rate].per = |
2c5a744d | 974 | (u8)(last_per - (last_per >> 3) + (100 >> 3)); |
f078f209 LR |
975 | } |
976 | ||
977 | /* xretries == 1 or 2 */ | |
978 | ||
256b7759 S |
979 | if (ath_rc_priv->probe_rate == tx_rate) |
980 | ath_rc_priv->probe_rate = 0; | |
f078f209 | 981 | |
2c5a744d | 982 | } else { /* xretries == 0 */ |
87c1687d | 983 | count = ARRAY_SIZE(nretry_to_per_lookup); |
f078f209 LR |
984 | if (retries >= count) |
985 | retries = count - 1; | |
2c5a744d | 986 | |
46d14a58 | 987 | if (tx_info_priv->n_bad_frames) { |
dc2222a8 | 988 | /* new_PER = 7/8*old_PER + 1/8*(currentPER) |
f078f209 LR |
989 | * Assuming that n_frames is not 0. The current PER |
990 | * from the retries is 100 * retries / (retries+1), | |
991 | * since the first retries attempts failed, and the | |
992 | * next one worked. For the one that worked, | |
993 | * n_bad_frames subframes out of n_frames wored, | |
994 | * so the PER for that part is | |
995 | * 100 * n_bad_frames / n_frames, and it contributes | |
996 | * 100 * n_bad_frames / (n_frames * (retries+1)) to | |
997 | * the above PER. The expression below is a | |
998 | * simplified version of the sum of these two terms. | |
999 | */ | |
2c5a744d S |
1000 | if (tx_info_priv->n_frames > 0) { |
1001 | int n_frames, n_bad_frames; | |
1002 | u8 cur_per, new_per; | |
1003 | ||
1004 | n_bad_frames = retries * tx_info_priv->n_frames + | |
1005 | tx_info_priv->n_bad_frames; | |
1006 | n_frames = tx_info_priv->n_frames * (retries + 1); | |
1007 | cur_per = (100 * n_bad_frames / n_frames) >> 3; | |
1008 | new_per = (u8)(last_per - (last_per >> 3) + cur_per); | |
1009 | ath_rc_priv->state[tx_rate].per = new_per; | |
1010 | } | |
f078f209 | 1011 | } else { |
2c5a744d S |
1012 | ath_rc_priv->state[tx_rate].per = |
1013 | (u8)(last_per - (last_per >> 3) + | |
1014 | (nretry_to_per_lookup[retries] >> 3)); | |
f078f209 LR |
1015 | } |
1016 | ||
256b7759 S |
1017 | ath_rc_priv->rssi_last_prev2 = ath_rc_priv->rssi_last_prev; |
1018 | ath_rc_priv->rssi_last_prev = ath_rc_priv->rssi_last; | |
46d14a58 | 1019 | ath_rc_priv->rssi_last = tx_info_priv->tx.ts_rssi; |
256b7759 | 1020 | ath_rc_priv->rssi_time = now_msec; |
f078f209 LR |
1021 | |
1022 | /* | |
1023 | * If we got at most one retry then increase the max rate if | |
1024 | * this was a probe. Otherwise, ignore the probe. | |
1025 | */ | |
256b7759 | 1026 | if (ath_rc_priv->probe_rate && ath_rc_priv->probe_rate == tx_rate) { |
46d14a58 S |
1027 | if (retries > 0 || 2 * tx_info_priv->n_bad_frames > |
1028 | tx_info_priv->n_frames) { | |
f078f209 LR |
1029 | /* |
1030 | * Since we probed with just a single attempt, | |
1031 | * any retries means the probe failed. Also, | |
1032 | * if the attempt worked, but more than half | |
1033 | * the subframes were bad then also consider | |
1034 | * the probe a failure. | |
1035 | */ | |
256b7759 | 1036 | ath_rc_priv->probe_rate = 0; |
f078f209 LR |
1037 | } else { |
1038 | u8 probe_rate = 0; | |
1039 | ||
2c5a744d S |
1040 | ath_rc_priv->rate_max_phy = |
1041 | ath_rc_priv->probe_rate; | |
256b7759 | 1042 | probe_rate = ath_rc_priv->probe_rate; |
f078f209 | 1043 | |
256b7759 S |
1044 | if (ath_rc_priv->state[probe_rate].per > 30) |
1045 | ath_rc_priv->state[probe_rate].per = 20; | |
f078f209 | 1046 | |
256b7759 | 1047 | ath_rc_priv->probe_rate = 0; |
f078f209 LR |
1048 | |
1049 | /* | |
1050 | * Since this probe succeeded, we allow the next | |
1051 | * probe twice as soon. This allows the maxRate | |
1052 | * to move up faster if the probes are | |
1053 | * succesful. | |
1054 | */ | |
2c5a744d S |
1055 | ath_rc_priv->probe_time = |
1056 | now_msec - rate_table->probe_interval / 2; | |
f078f209 LR |
1057 | } |
1058 | } | |
1059 | ||
1060 | if (retries > 0) { | |
1061 | /* | |
1062 | * Don't update anything. We don't know if | |
1063 | * this was because of collisions or poor signal. | |
1064 | * | |
1065 | * Later: if rssi_ack is close to | |
256b7759 | 1066 | * ath_rc_priv->state[txRate].rssi_thres and we see lots |
f078f209 | 1067 | * of retries, then we could increase |
256b7759 | 1068 | * ath_rc_priv->state[txRate].rssi_thres. |
f078f209 | 1069 | */ |
256b7759 | 1070 | ath_rc_priv->hw_maxretry_pktcnt = 0; |
f078f209 | 1071 | } else { |
2c5a744d S |
1072 | int32_t rssi_ackAvg; |
1073 | int8_t rssi_thres; | |
1074 | int8_t rssi_ack_vmin; | |
1075 | ||
f078f209 LR |
1076 | /* |
1077 | * It worked with no retries. First ignore bogus (small) | |
1078 | * rssi_ack values. | |
1079 | */ | |
256b7759 S |
1080 | if (tx_rate == ath_rc_priv->rate_max_phy && |
1081 | ath_rc_priv->hw_maxretry_pktcnt < 255) { | |
1082 | ath_rc_priv->hw_maxretry_pktcnt++; | |
f078f209 LR |
1083 | } |
1084 | ||
2c5a744d S |
1085 | if (tx_info_priv->tx.ts_rssi < |
1086 | rate_table->info[tx_rate].rssi_ack_validmin) | |
1087 | goto exit; | |
f078f209 | 1088 | |
2c5a744d S |
1089 | /* Average the rssi */ |
1090 | if (tx_rate != ath_rc_priv->rssi_sum_rate) { | |
1091 | ath_rc_priv->rssi_sum_rate = tx_rate; | |
1092 | ath_rc_priv->rssi_sum = | |
1093 | ath_rc_priv->rssi_sum_cnt = 0; | |
1094 | } | |
1095 | ||
1096 | ath_rc_priv->rssi_sum += tx_info_priv->tx.ts_rssi; | |
1097 | ath_rc_priv->rssi_sum_cnt++; | |
1098 | ||
1099 | if (ath_rc_priv->rssi_sum_cnt < 4) | |
1100 | goto exit; | |
1101 | ||
1102 | rssi_ackAvg = | |
1103 | (ath_rc_priv->rssi_sum + 2) / 4; | |
1104 | rssi_thres = | |
1105 | ath_rc_priv->state[tx_rate].rssi_thres; | |
1106 | rssi_ack_vmin = | |
1107 | rate_table->info[tx_rate].rssi_ack_validmin; | |
1108 | ||
1109 | ath_rc_priv->rssi_sum = | |
1110 | ath_rc_priv->rssi_sum_cnt = 0; | |
1111 | ||
1112 | /* Now reduce the current rssi threshold */ | |
1113 | if ((rssi_ackAvg < rssi_thres + 2) && | |
1114 | (rssi_thres > rssi_ack_vmin)) { | |
1115 | ath_rc_priv->state[tx_rate].rssi_thres--; | |
f078f209 | 1116 | } |
2c5a744d S |
1117 | |
1118 | state_change = true; | |
f078f209 LR |
1119 | } |
1120 | } | |
2c5a744d S |
1121 | exit: |
1122 | return state_change; | |
1123 | } | |
1124 | ||
1125 | /* Update PER, RSSI and whatever else that the code thinks it is doing. | |
1126 | If you can make sense of all this, you really need to go out more. */ | |
1127 | ||
1128 | static void ath_rc_update_ht(struct ath_softc *sc, | |
1129 | struct ath_rate_priv *ath_rc_priv, | |
1130 | struct ath_tx_info_priv *tx_info_priv, | |
1131 | int tx_rate, int xretries, int retries) | |
1132 | { | |
1133 | #define CHK_RSSI(rate) \ | |
1134 | ((ath_rc_priv->state[(rate)].rssi_thres + \ | |
1135 | rate_table->info[(rate)].rssi_ack_deltamin) > \ | |
1136 | ath_rc_priv->state[(rate)+1].rssi_thres) | |
1137 | ||
1138 | u32 now_msec = jiffies_to_msecs(jiffies); | |
1139 | int rate; | |
1140 | u8 last_per; | |
1141 | bool state_change = false; | |
40990ec0 | 1142 | struct ath_rate_table *rate_table = sc->cur_rate_table; |
2c5a744d S |
1143 | int size = ath_rc_priv->rate_table_size; |
1144 | ||
1145 | if ((tx_rate < 0) || (tx_rate > rate_table->rate_cnt)) | |
1146 | return; | |
f078f209 | 1147 | |
2c5a744d S |
1148 | /* To compensate for some imbalance between ctrl and ext. channel */ |
1149 | ||
1150 | if (WLAN_RC_PHY_40(rate_table->info[tx_rate].phy)) | |
1151 | tx_info_priv->tx.ts_rssi = | |
1152 | tx_info_priv->tx.ts_rssi < 3 ? 0 : | |
1153 | tx_info_priv->tx.ts_rssi - 3; | |
1154 | ||
1155 | last_per = ath_rc_priv->state[tx_rate].per; | |
1156 | ||
1157 | /* Update PER first */ | |
1158 | state_change = ath_rc_update_per(sc, rate_table, ath_rc_priv, | |
1159 | tx_info_priv, tx_rate, xretries, | |
1160 | retries, now_msec); | |
f078f209 LR |
1161 | |
1162 | /* | |
1163 | * If this rate looks bad (high PER) then stop using it for | |
1164 | * a while (except if we are probing). | |
1165 | */ | |
256b7759 | 1166 | if (ath_rc_priv->state[tx_rate].per >= 55 && tx_rate > 0 && |
dc2222a8 | 1167 | rate_table->info[tx_rate].ratekbps <= |
256b7759 S |
1168 | rate_table->info[ath_rc_priv->rate_max_phy].ratekbps) { |
1169 | ath_rc_get_nextlowervalid_txrate(rate_table, ath_rc_priv, | |
2c5a744d | 1170 | (u8)tx_rate, &ath_rc_priv->rate_max_phy); |
f078f209 LR |
1171 | |
1172 | /* Don't probe for a little while. */ | |
256b7759 | 1173 | ath_rc_priv->probe_time = now_msec; |
f078f209 LR |
1174 | } |
1175 | ||
1176 | if (state_change) { | |
1177 | /* | |
1178 | * Make sure the rates above this have higher rssi thresholds. | |
1179 | * (Note: Monotonicity is kept within the OFDM rates and | |
1180 | * within the CCK rates. However, no adjustment is | |
1181 | * made to keep the rssi thresholds monotonically | |
1182 | * increasing between the CCK and OFDM rates.) | |
1183 | */ | |
2c5a744d | 1184 | for (rate = tx_rate; rate < size - 1; rate++) { |
f078f209 | 1185 | if (rate_table->info[rate+1].phy != |
2c5a744d | 1186 | rate_table->info[tx_rate].phy) |
f078f209 LR |
1187 | break; |
1188 | ||
2c5a744d | 1189 | if (CHK_RSSI(rate)) { |
256b7759 | 1190 | ath_rc_priv->state[rate+1].rssi_thres = |
2c5a744d S |
1191 | ath_rc_priv->state[rate].rssi_thres + |
1192 | rate_table->info[rate].rssi_ack_deltamin; | |
f078f209 LR |
1193 | } |
1194 | } | |
1195 | ||
1196 | /* Make sure the rates below this have lower rssi thresholds. */ | |
1197 | for (rate = tx_rate - 1; rate >= 0; rate--) { | |
1198 | if (rate_table->info[rate].phy != | |
dc2222a8 | 1199 | rate_table->info[tx_rate].phy) |
f078f209 LR |
1200 | break; |
1201 | ||
2c5a744d | 1202 | if (CHK_RSSI(rate)) { |
256b7759 | 1203 | if (ath_rc_priv->state[rate+1].rssi_thres < |
2c5a744d | 1204 | rate_table->info[rate].rssi_ack_deltamin) |
256b7759 | 1205 | ath_rc_priv->state[rate].rssi_thres = 0; |
f078f209 | 1206 | else { |
256b7759 | 1207 | ath_rc_priv->state[rate].rssi_thres = |
2c5a744d S |
1208 | ath_rc_priv->state[rate+1].rssi_thres - |
1209 | rate_table->info[rate].rssi_ack_deltamin; | |
f078f209 LR |
1210 | } |
1211 | ||
256b7759 | 1212 | if (ath_rc_priv->state[rate].rssi_thres < |
2c5a744d | 1213 | rate_table->info[rate].rssi_ack_validmin) { |
256b7759 | 1214 | ath_rc_priv->state[rate].rssi_thres = |
2c5a744d | 1215 | rate_table->info[rate].rssi_ack_validmin; |
f078f209 LR |
1216 | } |
1217 | } | |
1218 | } | |
1219 | } | |
1220 | ||
1221 | /* Make sure the rates below this have lower PER */ | |
1222 | /* Monotonicity is kept only for rates below the current rate. */ | |
256b7759 | 1223 | if (ath_rc_priv->state[tx_rate].per < last_per) { |
f078f209 LR |
1224 | for (rate = tx_rate - 1; rate >= 0; rate--) { |
1225 | if (rate_table->info[rate].phy != | |
dc2222a8 | 1226 | rate_table->info[tx_rate].phy) |
f078f209 LR |
1227 | break; |
1228 | ||
256b7759 S |
1229 | if (ath_rc_priv->state[rate].per > |
1230 | ath_rc_priv->state[rate+1].per) { | |
1231 | ath_rc_priv->state[rate].per = | |
1232 | ath_rc_priv->state[rate+1].per; | |
f078f209 LR |
1233 | } |
1234 | } | |
1235 | } | |
1236 | ||
1237 | /* Maintain monotonicity for rates above the current rate */ | |
2c5a744d S |
1238 | for (rate = tx_rate; rate < size - 1; rate++) { |
1239 | if (ath_rc_priv->state[rate+1].per < | |
1240 | ath_rc_priv->state[rate].per) | |
256b7759 S |
1241 | ath_rc_priv->state[rate+1].per = |
1242 | ath_rc_priv->state[rate].per; | |
f078f209 LR |
1243 | } |
1244 | ||
1245 | /* Every so often, we reduce the thresholds and | |
1246 | * PER (different for CCK and OFDM). */ | |
256b7759 | 1247 | if (now_msec - ath_rc_priv->rssi_down_time >= |
dc2222a8 | 1248 | rate_table->rssi_reduce_interval) { |
f078f209 | 1249 | |
2c5a744d | 1250 | for (rate = 0; rate < size; rate++) { |
256b7759 | 1251 | if (ath_rc_priv->state[rate].rssi_thres > |
dc2222a8 | 1252 | rate_table->info[rate].rssi_ack_validmin) |
256b7759 | 1253 | ath_rc_priv->state[rate].rssi_thres -= 1; |
f078f209 | 1254 | } |
256b7759 | 1255 | ath_rc_priv->rssi_down_time = now_msec; |
f078f209 LR |
1256 | } |
1257 | ||
1258 | /* Every so often, we reduce the thresholds | |
1259 | * and PER (different for CCK and OFDM). */ | |
256b7759 | 1260 | if (now_msec - ath_rc_priv->per_down_time >= |
dc2222a8 | 1261 | rate_table->rssi_reduce_interval) { |
2c5a744d | 1262 | for (rate = 0; rate < size; rate++) { |
256b7759 S |
1263 | ath_rc_priv->state[rate].per = |
1264 | 7 * ath_rc_priv->state[rate].per / 8; | |
f078f209 LR |
1265 | } |
1266 | ||
256b7759 | 1267 | ath_rc_priv->per_down_time = now_msec; |
f078f209 | 1268 | } |
2c5a744d | 1269 | |
9e712790 S |
1270 | ath_debug_stat_retries(sc, tx_rate, xretries, retries, |
1271 | ath_rc_priv->state[tx_rate].per); | |
029bc432 | 1272 | |
2c5a744d S |
1273 | #undef CHK_RSSI |
1274 | } | |
1275 | ||
1276 | static int ath_rc_get_rateindex(struct ath_rate_table *rate_table, | |
1277 | struct ieee80211_tx_rate *rate) | |
1278 | { | |
1279 | int rix; | |
1280 | ||
1281 | if ((rate->flags & IEEE80211_TX_RC_40_MHZ_WIDTH) && | |
1282 | (rate->flags & IEEE80211_TX_RC_SHORT_GI)) | |
1283 | rix = rate_table->info[rate->idx].ht_index; | |
1284 | else if (rate->flags & IEEE80211_TX_RC_SHORT_GI) | |
1285 | rix = rate_table->info[rate->idx].sgi_index; | |
1286 | else if (rate->flags & IEEE80211_TX_RC_40_MHZ_WIDTH) | |
1287 | rix = rate_table->info[rate->idx].cw40index; | |
1288 | else | |
1289 | rix = rate_table->info[rate->idx].base_index; | |
1290 | ||
1291 | return rix; | |
f078f209 LR |
1292 | } |
1293 | ||
46d14a58 S |
1294 | static void ath_rc_tx_status(struct ath_softc *sc, |
1295 | struct ath_rate_priv *ath_rc_priv, | |
1296 | struct ieee80211_tx_info *tx_info, | |
1297 | int final_ts_idx, int xretries, int long_retry) | |
f078f209 | 1298 | { |
46d14a58 | 1299 | struct ath_tx_info_priv *tx_info_priv = ATH_TX_INFO_PRIV(tx_info); |
f078f209 | 1300 | struct ath_rate_table *rate_table; |
a8efee4f | 1301 | struct ieee80211_tx_rate *rates = tx_info->status.rates; |
f078f209 | 1302 | u8 flags; |
2c5a744d | 1303 | u32 i = 0, rix; |
f078f209 | 1304 | |
40990ec0 | 1305 | rate_table = sc->cur_rate_table; |
f078f209 LR |
1306 | |
1307 | /* | |
1308 | * If the first rate is not the final index, there | |
1309 | * are intermediate rate failures to be processed. | |
1310 | */ | |
1311 | if (final_ts_idx != 0) { | |
1312 | /* Process intermediate rates that failed.*/ | |
2c5a744d S |
1313 | for (i = 0; i < final_ts_idx ; i++) { |
1314 | if (rates[i].count != 0 && (rates[i].idx >= 0)) { | |
1315 | flags = rates[i].flags; | |
1316 | ||
f078f209 LR |
1317 | /* If HT40 and we have switched mode from |
1318 | * 40 to 20 => don't update */ | |
2c5a744d | 1319 | |
a8efee4f | 1320 | if ((flags & IEEE80211_TX_RC_40_MHZ_WIDTH) && |
e63835b0 | 1321 | (ath_rc_priv->rc_phy_mode != WLAN_RC_40_FLAG)) |
f078f209 | 1322 | return; |
e63835b0 | 1323 | |
2c5a744d | 1324 | rix = ath_rc_get_rateindex(rate_table, &rates[i]); |
f078f209 | 1325 | ath_rc_update_ht(sc, ath_rc_priv, |
46d14a58 | 1326 | tx_info_priv, rix, |
f078f209 | 1327 | xretries ? 1 : 2, |
2c5a744d | 1328 | rates[i].count); |
f078f209 LR |
1329 | } |
1330 | } | |
1331 | } else { | |
1332 | /* | |
1333 | * Handle the special case of MIMO PS burst, where the second | |
1334 | * aggregate is sent out with only one rate and one try. | |
1335 | * Treating it as an excessive retry penalizes the rate | |
1336 | * inordinately. | |
1337 | */ | |
a8efee4f | 1338 | if (rates[0].count == 1 && xretries == 1) |
f078f209 LR |
1339 | xretries = 2; |
1340 | } | |
1341 | ||
2c5a744d S |
1342 | flags = rates[i].flags; |
1343 | ||
f078f209 | 1344 | /* If HT40 and we have switched mode from 40 to 20 => don't update */ |
a8efee4f | 1345 | if ((flags & IEEE80211_TX_RC_40_MHZ_WIDTH) && |
e63835b0 | 1346 | (ath_rc_priv->rc_phy_mode != WLAN_RC_40_FLAG)) { |
f078f209 | 1347 | return; |
e63835b0 | 1348 | } |
f078f209 | 1349 | |
2c5a744d | 1350 | rix = ath_rc_get_rateindex(rate_table, &rates[i]); |
46d14a58 | 1351 | ath_rc_update_ht(sc, ath_rc_priv, tx_info_priv, rix, |
2c5a744d | 1352 | xretries, long_retry); |
f078f209 LR |
1353 | } |
1354 | ||
e11602b7 S |
1355 | static struct ath_rate_table *ath_choose_rate_table(struct ath_softc *sc, |
1356 | enum ieee80211_band band, | |
1357 | bool is_ht, bool is_cw_40) | |
1358 | { | |
1359 | int mode = 0; | |
1360 | ||
1361 | switch(band) { | |
1362 | case IEEE80211_BAND_2GHZ: | |
1363 | mode = ATH9K_MODE_11G; | |
1364 | if (is_ht) | |
1365 | mode = ATH9K_MODE_11NG_HT20; | |
1366 | if (is_cw_40) | |
1367 | mode = ATH9K_MODE_11NG_HT40PLUS; | |
1368 | break; | |
1369 | case IEEE80211_BAND_5GHZ: | |
1370 | mode = ATH9K_MODE_11A; | |
1371 | if (is_ht) | |
1372 | mode = ATH9K_MODE_11NA_HT20; | |
1373 | if (is_cw_40) | |
1374 | mode = ATH9K_MODE_11NA_HT40PLUS; | |
1375 | break; | |
1376 | default: | |
04bd4638 | 1377 | DPRINTF(sc, ATH_DBG_CONFIG, "Invalid band\n"); |
e11602b7 S |
1378 | return NULL; |
1379 | } | |
1380 | ||
1381 | BUG_ON(mode >= ATH9K_MODE_MAX); | |
1382 | ||
04bd4638 | 1383 | DPRINTF(sc, ATH_DBG_CONFIG, "Choosing rate table for mode: %d\n", mode); |
e11602b7 S |
1384 | return sc->hw_rate_table[mode]; |
1385 | } | |
1386 | ||
5ddfac3b | 1387 | static void ath_rc_init(struct ath_softc *sc, |
46d14a58 | 1388 | struct ath_rate_priv *ath_rc_priv, |
5ddfac3b S |
1389 | struct ieee80211_supported_band *sband, |
1390 | struct ieee80211_sta *sta) | |
f078f209 LR |
1391 | { |
1392 | struct ath_rate_table *rate_table = NULL; | |
5ddfac3b S |
1393 | struct ath_rateset *rateset = &ath_rc_priv->neg_rates; |
1394 | u8 *ht_mcs = (u8 *)&ath_rc_priv->neg_ht_rates; | |
f078f209 | 1395 | u8 i, j, k, hi = 0, hthi = 0; |
8bd1d07f | 1396 | struct ath_hw *ah = sc->sc_ah; |
f078f209 | 1397 | |
e11602b7 | 1398 | /* FIXME: Adhoc */ |
2660b81a S |
1399 | if ((sc->sc_ah->opmode == NL80211_IFTYPE_STATION) || |
1400 | (sc->sc_ah->opmode == NL80211_IFTYPE_ADHOC)) { | |
e11602b7 S |
1401 | bool is_cw_40 = sta->ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40; |
1402 | rate_table = ath_choose_rate_table(sc, sband->band, | |
1403 | sta->ht_cap.ht_supported, | |
1404 | is_cw_40); | |
2660b81a | 1405 | } else if (sc->sc_ah->opmode == NL80211_IFTYPE_AP) { |
3706de6f S |
1406 | /* cur_rate_table would be set on init through config() */ |
1407 | rate_table = sc->cur_rate_table; | |
e11602b7 | 1408 | } |
f078f209 | 1409 | |
e11602b7 S |
1410 | if (!rate_table) { |
1411 | DPRINTF(sc, ATH_DBG_FATAL, "Rate table not initialized\n"); | |
1412 | return; | |
1413 | } | |
5ddfac3b | 1414 | |
e11602b7 | 1415 | if (sta->ht_cap.ht_supported) { |
f8206e05 | 1416 | ath_rc_priv->ht_cap = WLAN_RC_HT_FLAG; |
8bd1d07f SB |
1417 | if (sc->sc_ah->caps.tx_chainmask != 1 && |
1418 | ath9k_hw_getcapability(ah, ATH9K_CAP_DS, 0, NULL)) | |
f8206e05 | 1419 | ath_rc_priv->ht_cap |= WLAN_RC_DS_FLAG; |
5ddfac3b S |
1420 | if (sta->ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) |
1421 | ath_rc_priv->ht_cap |= WLAN_RC_40_FLAG; | |
dd006395 S |
1422 | if (sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_40) |
1423 | ath_rc_priv->ht_cap |= WLAN_RC_SGI_FLAG; | |
5ddfac3b S |
1424 | } |
1425 | ||
f078f209 LR |
1426 | /* Initial rate table size. Will change depending |
1427 | * on the working rate set */ | |
46d14a58 | 1428 | ath_rc_priv->rate_table_size = RATE_TABLE_SIZE; |
f078f209 LR |
1429 | |
1430 | /* Initialize thresholds according to the global rate table */ | |
5ddfac3b | 1431 | for (i = 0 ; i < ath_rc_priv->rate_table_size; i++) { |
256b7759 | 1432 | ath_rc_priv->state[i].rssi_thres = |
f078f209 | 1433 | rate_table->info[i].rssi_ack_validmin; |
256b7759 | 1434 | ath_rc_priv->state[i].per = 0; |
f078f209 LR |
1435 | } |
1436 | ||
1437 | /* Determine the valid rates */ | |
256b7759 | 1438 | ath_rc_init_valid_txmask(ath_rc_priv); |
f078f209 LR |
1439 | |
1440 | for (i = 0; i < WLAN_RC_PHY_MAX; i++) { | |
1441 | for (j = 0; j < MAX_TX_RATE_PHY; j++) | |
256b7759 S |
1442 | ath_rc_priv->valid_phy_rateidx[i][j] = 0; |
1443 | ath_rc_priv->valid_phy_ratecnt[i] = 0; | |
f078f209 | 1444 | } |
5ddfac3b | 1445 | ath_rc_priv->rc_phy_mode = (ath_rc_priv->ht_cap & WLAN_RC_40_FLAG); |
f078f209 LR |
1446 | |
1447 | /* Set stream capability */ | |
5ddfac3b | 1448 | ath_rc_priv->single_stream = (ath_rc_priv->ht_cap & WLAN_RC_DS_FLAG) ? 0 : 1; |
f078f209 LR |
1449 | |
1450 | if (!rateset->rs_nrates) { | |
1451 | /* No working rate, just initialize valid rates */ | |
2c5a744d | 1452 | hi = ath_rc_init_validrates(ath_rc_priv, rate_table, |
c89424df | 1453 | ath_rc_priv->ht_cap); |
f078f209 LR |
1454 | } else { |
1455 | /* Use intersection of working rates and valid rates */ | |
2c5a744d | 1456 | hi = ath_rc_setvalid_rates(ath_rc_priv, rate_table, |
c89424df | 1457 | rateset, ath_rc_priv->ht_cap); |
5ddfac3b | 1458 | if (ath_rc_priv->ht_cap & WLAN_RC_HT_FLAG) { |
2c5a744d | 1459 | hthi = ath_rc_setvalid_htrates(ath_rc_priv, |
c89424df S |
1460 | rate_table, |
1461 | ht_mcs, | |
1462 | ath_rc_priv->ht_cap); | |
f078f209 LR |
1463 | } |
1464 | hi = A_MAX(hi, hthi); | |
1465 | } | |
1466 | ||
256b7759 S |
1467 | ath_rc_priv->rate_table_size = hi + 1; |
1468 | ath_rc_priv->rate_max_phy = 0; | |
46d14a58 | 1469 | ASSERT(ath_rc_priv->rate_table_size <= RATE_TABLE_SIZE); |
f078f209 LR |
1470 | |
1471 | for (i = 0, k = 0; i < WLAN_RC_PHY_MAX; i++) { | |
256b7759 S |
1472 | for (j = 0; j < ath_rc_priv->valid_phy_ratecnt[i]; j++) { |
1473 | ath_rc_priv->valid_rate_index[k++] = | |
1474 | ath_rc_priv->valid_phy_rateidx[i][j]; | |
f078f209 LR |
1475 | } |
1476 | ||
46d14a58 | 1477 | if (!ath_rc_valid_phyrate(i, rate_table->initial_ratemax, 1) |
256b7759 | 1478 | || !ath_rc_priv->valid_phy_ratecnt[i]) |
f078f209 LR |
1479 | continue; |
1480 | ||
256b7759 | 1481 | ath_rc_priv->rate_max_phy = ath_rc_priv->valid_phy_rateidx[i][j-1]; |
f078f209 | 1482 | } |
46d14a58 S |
1483 | ASSERT(ath_rc_priv->rate_table_size <= RATE_TABLE_SIZE); |
1484 | ASSERT(k <= RATE_TABLE_SIZE); | |
f078f209 | 1485 | |
256b7759 | 1486 | ath_rc_priv->max_valid_rate = k; |
256b7759 S |
1487 | ath_rc_sort_validrates(rate_table, ath_rc_priv); |
1488 | ath_rc_priv->rate_max_phy = ath_rc_priv->valid_rate_index[k-4]; | |
40990ec0 | 1489 | sc->cur_rate_table = rate_table; |
f078f209 LR |
1490 | } |
1491 | ||
f078f209 | 1492 | /* Rate Control callbacks */ |
4b7679a5 JB |
1493 | static void ath_tx_status(void *priv, struct ieee80211_supported_band *sband, |
1494 | struct ieee80211_sta *sta, void *priv_sta, | |
f078f209 LR |
1495 | struct sk_buff *skb) |
1496 | { | |
1497 | struct ath_softc *sc = priv; | |
46d14a58 S |
1498 | struct ath_rate_priv *ath_rc_priv = priv_sta; |
1499 | struct ath_tx_info_priv *tx_info_priv = NULL; | |
f078f209 LR |
1500 | struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb); |
1501 | struct ieee80211_hdr *hdr; | |
46d14a58 | 1502 | int final_ts_idx, tx_status = 0, is_underrun = 0; |
f078f209 LR |
1503 | __le16 fc; |
1504 | ||
f078f209 LR |
1505 | hdr = (struct ieee80211_hdr *)skb->data; |
1506 | fc = hdr->frame_control; | |
46d14a58 | 1507 | tx_info_priv = ATH_TX_INFO_PRIV(tx_info); |
46d14a58 | 1508 | final_ts_idx = tx_info_priv->tx.ts_rateindex; |
f078f209 | 1509 | |
ff37e337 | 1510 | if (!priv_sta || !ieee80211_is_data(fc) || |
7ac47010 | 1511 | !tx_info_priv->update_rc) |
46d14a58 | 1512 | goto exit; |
e6a9854b | 1513 | |
46d14a58 S |
1514 | if (tx_info_priv->tx.ts_status & ATH9K_TXERR_FILT) |
1515 | goto exit; | |
e6a9854b | 1516 | |
46d14a58 S |
1517 | /* |
1518 | * If underrun error is seen assume it as an excessive retry only | |
1519 | * if prefetch trigger level have reached the max (0x3f for 5416) | |
1520 | * Adjust the long retry as if the frame was tried ATH_11N_TXMAXTRY | |
1521 | * times. This affects how ratectrl updates PER for the failed rate. | |
1522 | */ | |
1523 | if (tx_info_priv->tx.ts_flags & | |
1524 | (ATH9K_TX_DATA_UNDERRUN | ATH9K_TX_DELIM_UNDERRUN) && | |
2660b81a | 1525 | ((sc->sc_ah->tx_trig_level) >= ath_rc_priv->tx_triglevel_max)) { |
46d14a58 S |
1526 | tx_status = 1; |
1527 | is_underrun = 1; | |
1528 | } | |
1529 | ||
1530 | if ((tx_info_priv->tx.ts_status & ATH9K_TXERR_XRETRY) || | |
1531 | (tx_info_priv->tx.ts_status & ATH9K_TXERR_FIFO)) | |
1532 | tx_status = 1; | |
1533 | ||
1534 | ath_rc_tx_status(sc, ath_rc_priv, tx_info, final_ts_idx, tx_status, | |
1535 | (is_underrun) ? ATH_11N_TXMAXTRY : | |
1536 | tx_info_priv->tx.ts_longretry); | |
1537 | ||
d22b0022 | 1538 | /* Check if aggregation has to be enabled for this tid */ |
d5c232ff VT |
1539 | if (conf_is_ht(&sc->hw->conf) && |
1540 | !(skb->protocol == cpu_to_be16(ETH_P_PAE))) { | |
d22b0022 S |
1541 | if (ieee80211_is_data_qos(fc)) { |
1542 | u8 *qc, tid; | |
1543 | struct ath_node *an; | |
1544 | ||
1545 | qc = ieee80211_get_qos_ctl(hdr); | |
1546 | tid = qc[0] & 0xf; | |
1547 | an = (struct ath_node *)sta->drv_priv; | |
1548 | ||
1549 | if(ath_tx_aggr_check(sc, an, tid)) | |
1550 | ieee80211_start_tx_ba_session(sc->hw, hdr->addr1, tid); | |
1551 | } | |
1552 | } | |
7a7dec65 S |
1553 | |
1554 | ath_debug_stat_rc(sc, skb); | |
46d14a58 | 1555 | exit: |
e6a9854b | 1556 | kfree(tx_info_priv); |
f078f209 LR |
1557 | } |
1558 | ||
e6a9854b JB |
1559 | static void ath_get_rate(void *priv, struct ieee80211_sta *sta, void *priv_sta, |
1560 | struct ieee80211_tx_rate_control *txrc) | |
f078f209 | 1561 | { |
e6a9854b JB |
1562 | struct ieee80211_supported_band *sband = txrc->sband; |
1563 | struct sk_buff *skb = txrc->skb; | |
f078f209 | 1564 | struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; |
3900898c | 1565 | struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb); |
4b7679a5 | 1566 | struct ath_softc *sc = priv; |
46d14a58 | 1567 | struct ath_rate_priv *ath_rc_priv = priv_sta; |
f078f209 | 1568 | __le16 fc = hdr->frame_control; |
f078f209 | 1569 | |
f078f209 | 1570 | /* lowest rate for management and multicast/broadcast frames */ |
f66000f7 JM |
1571 | if (!ieee80211_is_data(fc) || is_multicast_ether_addr(hdr->addr1) || |
1572 | !sta) { | |
a8efee4f S |
1573 | tx_info->control.rates[0].idx = rate_lowest_index(sband, sta); |
1574 | tx_info->control.rates[0].count = | |
1575 | is_multicast_ether_addr(hdr->addr1) ? 1 : ATH_MGT_TXMAXTRY; | |
f078f209 LR |
1576 | return; |
1577 | } | |
1578 | ||
f078f209 | 1579 | /* Find tx rate for unicast frames */ |
3900898c | 1580 | ath_rc_ratefind(sc, ath_rc_priv, txrc); |
f078f209 LR |
1581 | } |
1582 | ||
4b7679a5 JB |
1583 | static void ath_rate_init(void *priv, struct ieee80211_supported_band *sband, |
1584 | struct ieee80211_sta *sta, void *priv_sta) | |
f078f209 | 1585 | { |
4b7679a5 | 1586 | struct ath_softc *sc = priv; |
46d14a58 | 1587 | struct ath_rate_priv *ath_rc_priv = priv_sta; |
f078f209 LR |
1588 | int i, j = 0; |
1589 | ||
7b4d2735 S |
1590 | for (i = 0; i < sband->n_bitrates; i++) { |
1591 | if (sta->supp_rates[sband->band] & BIT(i)) { | |
1592 | ath_rc_priv->neg_rates.rs_rates[j] | |
1593 | = (sband->bitrates[i].bitrate * 2) / 10; | |
1594 | j++; | |
1595 | } | |
1596 | } | |
1597 | ath_rc_priv->neg_rates.rs_nrates = j; | |
f078f209 | 1598 | |
a4510bf8 | 1599 | if (sta->ht_cap.ht_supported) { |
7b4d2735 | 1600 | for (i = 0, j = 0; i < 77; i++) { |
ae5eb026 | 1601 | if (sta->ht_cap.mcs.rx_mask[i/8] & (1<<(i%8))) |
dc2222a8 | 1602 | ath_rc_priv->neg_ht_rates.rs_rates[j++] = i; |
f078f209 LR |
1603 | if (j == ATH_RATE_MAX) |
1604 | break; | |
1605 | } | |
dc2222a8 | 1606 | ath_rc_priv->neg_ht_rates.rs_nrates = j; |
f078f209 | 1607 | } |
7b4d2735 | 1608 | |
5ddfac3b | 1609 | ath_rc_init(sc, priv_sta, sband, sta); |
f078f209 LR |
1610 | } |
1611 | ||
4b7679a5 | 1612 | static void *ath_rate_alloc(struct ieee80211_hw *hw, struct dentry *debugfsdir) |
f078f209 | 1613 | { |
4b7679a5 | 1614 | return hw->priv; |
f078f209 LR |
1615 | } |
1616 | ||
1617 | static void ath_rate_free(void *priv) | |
1618 | { | |
1619 | return; | |
1620 | } | |
1621 | ||
4b7679a5 | 1622 | static void *ath_rate_alloc_sta(void *priv, struct ieee80211_sta *sta, gfp_t gfp) |
f078f209 LR |
1623 | { |
1624 | struct ath_softc *sc = priv; | |
46d14a58 | 1625 | struct ath_rate_priv *rate_priv; |
f078f209 | 1626 | |
46d14a58 | 1627 | rate_priv = kzalloc(sizeof(struct ath_rate_priv), gfp); |
f078f209 | 1628 | if (!rate_priv) { |
dc2222a8 | 1629 | DPRINTF(sc, ATH_DBG_FATAL, |
04bd4638 | 1630 | "Unable to allocate private rc structure\n"); |
f078f209 LR |
1631 | return NULL; |
1632 | } | |
fe60594a | 1633 | |
fe60594a | 1634 | rate_priv->rssi_down_time = jiffies_to_msecs(jiffies); |
2660b81a | 1635 | rate_priv->tx_triglevel_max = sc->sc_ah->caps.tx_triglevel_max; |
dc2222a8 | 1636 | |
f078f209 LR |
1637 | return rate_priv; |
1638 | } | |
1639 | ||
4b7679a5 JB |
1640 | static void ath_rate_free_sta(void *priv, struct ieee80211_sta *sta, |
1641 | void *priv_sta) | |
f078f209 | 1642 | { |
46d14a58 | 1643 | struct ath_rate_priv *rate_priv = priv_sta; |
fe60594a | 1644 | kfree(rate_priv); |
f078f209 LR |
1645 | } |
1646 | ||
1647 | static struct rate_control_ops ath_rate_ops = { | |
1648 | .module = NULL, | |
1649 | .name = "ath9k_rate_control", | |
1650 | .tx_status = ath_tx_status, | |
1651 | .get_rate = ath_get_rate, | |
1652 | .rate_init = ath_rate_init, | |
f078f209 LR |
1653 | .alloc = ath_rate_alloc, |
1654 | .free = ath_rate_free, | |
1655 | .alloc_sta = ath_rate_alloc_sta, | |
4b7679a5 | 1656 | .free_sta = ath_rate_free_sta, |
f078f209 LR |
1657 | }; |
1658 | ||
fe7f4a77 S |
1659 | void ath_rate_attach(struct ath_softc *sc) |
1660 | { | |
1661 | sc->hw_rate_table[ATH9K_MODE_11B] = | |
1662 | &ar5416_11b_ratetable; | |
1663 | sc->hw_rate_table[ATH9K_MODE_11A] = | |
1664 | &ar5416_11a_ratetable; | |
1665 | sc->hw_rate_table[ATH9K_MODE_11G] = | |
1666 | &ar5416_11g_ratetable; | |
1667 | sc->hw_rate_table[ATH9K_MODE_11NA_HT20] = | |
1668 | &ar5416_11na_ratetable; | |
1669 | sc->hw_rate_table[ATH9K_MODE_11NG_HT20] = | |
1670 | &ar5416_11ng_ratetable; | |
1671 | sc->hw_rate_table[ATH9K_MODE_11NA_HT40PLUS] = | |
1672 | &ar5416_11na_ratetable; | |
1673 | sc->hw_rate_table[ATH9K_MODE_11NA_HT40MINUS] = | |
1674 | &ar5416_11na_ratetable; | |
1675 | sc->hw_rate_table[ATH9K_MODE_11NG_HT40PLUS] = | |
1676 | &ar5416_11ng_ratetable; | |
1677 | sc->hw_rate_table[ATH9K_MODE_11NG_HT40MINUS] = | |
1678 | &ar5416_11ng_ratetable; | |
1679 | } | |
1680 | ||
f078f209 LR |
1681 | int ath_rate_control_register(void) |
1682 | { | |
1683 | return ieee80211_rate_control_register(&ath_rate_ops); | |
1684 | } | |
1685 | ||
1686 | void ath_rate_control_unregister(void) | |
1687 | { | |
1688 | ieee80211_rate_control_unregister(&ath_rate_ops); | |
1689 | } |