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