]> bbs.cooldavid.org Git - net-next-2.6.git/blame - drivers/net/wireless/ath9k/rc.c
git://bbs.cooldavid.org / net-next-2.6.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ath9k: use ieee80211_conf on ath9k_hw_iscal_supported()
[net-next-2.6.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{
b657eade 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
40990ec0 820 rate_table = sc->cur_rate_table;
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 */
3706de6f
S		 877 if ((sc->hw->conf.channel->band == IEEE80211_BAND_2GHZ) &&
878 (sc->hw->conf.ht.enabled)) {
40990ec0 879 u8 dot11rate = rate_table->info[rix].dot11rate;
f078f209
LR		 880 u8 phy = rate_table->info[rix].phy;
881 if (i == 4 &&
882 ((dot11rate == 2 && phy == WLAN_RC_PHY_HT_40_SS) ||
dc2222a8 883 (dot11rate == 3 && phy == WLAN_RC_PHY_HT_20_SS))) {
a8efee4f
S		 884 rates[3].idx = rates[2].idx;
885 rates[3].flags = rates[2].flags;
f078f209
LR		 886 }
887 }
888}
889
2c5a744d
S		 890static bool ath_rc_update_per(struct ath_softc *sc,
891 struct ath_rate_table *rate_table,
892 struct ath_rate_priv *ath_rc_priv,
893 struct ath_tx_info_priv *tx_info_priv,
894 int tx_rate, int xretries, int retries,
895 u32 now_msec)
f078f209 896{
2c5a744d
S		 897 bool state_change = false;
898 int count;
f078f209 899 u8 last_per;
f078f209
LR		 900 static u32 nretry_to_per_lookup[10] = {
901 100 * 0 / 1,
902 100 * 1 / 4,
903 100 * 1 / 2,
904 100 * 3 / 4,
905 100 * 4 / 5,
906 100 * 5 / 6,
907 100 * 6 / 7,
908 100 * 7 / 8,
909 100 * 8 / 9,
910 100 * 9 / 10
911 };
912
256b7759 913 last_per = ath_rc_priv->state[tx_rate].per;
f078f209
LR		 914
915 if (xretries) {
f078f209 916 if (xretries == 1) {
256b7759
S		 917 ath_rc_priv->state[tx_rate].per += 30;
918 if (ath_rc_priv->state[tx_rate].per > 100)
919 ath_rc_priv->state[tx_rate].per = 100;
f078f209
LR		 920 } else {
921 /* xretries == 2 */
87c1687d 922 count = ARRAY_SIZE(nretry_to_per_lookup);
f078f209
LR		 923 if (retries >= count)
924 retries = count - 1;
2c5a744d 925
f078f209 926 /* new_PER = 7/8*old_PER + 1/8*(currentPER) */
256b7759 927 ath_rc_priv->state[tx_rate].per =
2c5a744d 928 (u8)(last_per - (last_per >> 3) + (100 >> 3));
f078f209
LR		 929 }
930
931 /* xretries == 1 or 2 */
932
256b7759
S		 933 if (ath_rc_priv->probe_rate == tx_rate)
934 ath_rc_priv->probe_rate = 0;
f078f209 935
2c5a744d 936 } else { /* xretries == 0 */
87c1687d 937 count = ARRAY_SIZE(nretry_to_per_lookup);
f078f209
LR		 938 if (retries >= count)
939 retries = count - 1;
2c5a744d 940
46d14a58 941 if (tx_info_priv->n_bad_frames) {
dc2222a8 942 /* new_PER = 7/8*old_PER + 1/8*(currentPER)
f078f209
LR		 943 * Assuming that n_frames is not 0. The current PER
944 * from the retries is 100 * retries / (retries+1),
945 * since the first retries attempts failed, and the
946 * next one worked. For the one that worked,
947 * n_bad_frames subframes out of n_frames wored,
948 * so the PER for that part is
949 * 100 * n_bad_frames / n_frames, and it contributes
950 * 100 * n_bad_frames / (n_frames * (retries+1)) to
951 * the above PER. The expression below is a
952 * simplified version of the sum of these two terms.
953 */
2c5a744d
S		 954 if (tx_info_priv->n_frames > 0) {
955 int n_frames, n_bad_frames;
956 u8 cur_per, new_per;
957
958 n_bad_frames = retries * tx_info_priv->n_frames +
959 tx_info_priv->n_bad_frames;
960 n_frames = tx_info_priv->n_frames * (retries + 1);
961 cur_per = (100 * n_bad_frames / n_frames) >> 3;
962 new_per = (u8)(last_per - (last_per >> 3) + cur_per);
963 ath_rc_priv->state[tx_rate].per = new_per;
964 }
f078f209 965 } else {
2c5a744d
S		 966 ath_rc_priv->state[tx_rate].per =
967 (u8)(last_per - (last_per >> 3) +
968 (nretry_to_per_lookup[retries] >> 3));
f078f209
LR		 969 }
970
256b7759
S		 971 ath_rc_priv->rssi_last_prev2 = ath_rc_priv->rssi_last_prev;
972 ath_rc_priv->rssi_last_prev = ath_rc_priv->rssi_last;
46d14a58 973 ath_rc_priv->rssi_last = tx_info_priv->tx.ts_rssi;
256b7759 974 ath_rc_priv->rssi_time = now_msec;
f078f209
LR		 975
976 /*
977 * If we got at most one retry then increase the max rate if
978 * this was a probe. Otherwise, ignore the probe.
979 */
256b7759 980 if (ath_rc_priv->probe_rate && ath_rc_priv->probe_rate == tx_rate) {
46d14a58
S		 981 if (retries > 0 || 2 * tx_info_priv->n_bad_frames >
982 tx_info_priv->n_frames) {
f078f209
LR		 983 /*
984 * Since we probed with just a single attempt,
985 * any retries means the probe failed. Also,
986 * if the attempt worked, but more than half
987 * the subframes were bad then also consider
988 * the probe a failure.
989 */
256b7759 990 ath_rc_priv->probe_rate = 0;
f078f209
LR		 991 } else {
992 u8 probe_rate = 0;
993
2c5a744d
S		 994 ath_rc_priv->rate_max_phy =
995 ath_rc_priv->probe_rate;
256b7759 996 probe_rate = ath_rc_priv->probe_rate;
f078f209 997
256b7759
S		 998 if (ath_rc_priv->state[probe_rate].per > 30)
999 ath_rc_priv->state[probe_rate].per = 20;
f078f209 1000
256b7759 1001 ath_rc_priv->probe_rate = 0;
f078f209
LR		 1002
1003 /*
1004 * Since this probe succeeded, we allow the next
1005 * probe twice as soon. This allows the maxRate
1006 * to move up faster if the probes are
1007 * succesful.
1008 */
2c5a744d
S		 1009 ath_rc_priv->probe_time =
1010 now_msec - rate_table->probe_interval / 2;
f078f209
LR		 1011 }
1012 }
1013
1014 if (retries > 0) {
1015 /*
1016 * Don't update anything. We don't know if
1017 * this was because of collisions or poor signal.
1018 *
1019 * Later: if rssi_ack is close to
256b7759 1020 * ath_rc_priv->state[txRate].rssi_thres and we see lots
f078f209 1021 * of retries, then we could increase
256b7759 1022 * ath_rc_priv->state[txRate].rssi_thres.
f078f209 1023 */
256b7759 1024 ath_rc_priv->hw_maxretry_pktcnt = 0;
f078f209 1025 } else {
2c5a744d
S		 1026 int32_t rssi_ackAvg;
1027 int8_t rssi_thres;
1028 int8_t rssi_ack_vmin;
1029
f078f209
LR		 1030 /*
1031 * It worked with no retries. First ignore bogus (small)
1032 * rssi_ack values.
1033 */
256b7759
S		 1034 if (tx_rate == ath_rc_priv->rate_max_phy &&
1035 ath_rc_priv->hw_maxretry_pktcnt < 255) {
1036 ath_rc_priv->hw_maxretry_pktcnt++;
f078f209
LR		 1037 }
1038
2c5a744d
S		 1039 if (tx_info_priv->tx.ts_rssi <
1040 rate_table->info[tx_rate].rssi_ack_validmin)
1041 goto exit;
f078f209 1042
2c5a744d
S		 1043 /* Average the rssi */
1044 if (tx_rate != ath_rc_priv->rssi_sum_rate) {
1045 ath_rc_priv->rssi_sum_rate = tx_rate;
1046 ath_rc_priv->rssi_sum =
1047 ath_rc_priv->rssi_sum_cnt = 0;
1048 }
1049
1050 ath_rc_priv->rssi_sum += tx_info_priv->tx.ts_rssi;
1051 ath_rc_priv->rssi_sum_cnt++;
1052
1053 if (ath_rc_priv->rssi_sum_cnt < 4)
1054 goto exit;
1055
1056 rssi_ackAvg =
1057 (ath_rc_priv->rssi_sum + 2) / 4;
1058 rssi_thres =
1059 ath_rc_priv->state[tx_rate].rssi_thres;
1060 rssi_ack_vmin =
1061 rate_table->info[tx_rate].rssi_ack_validmin;
1062
1063 ath_rc_priv->rssi_sum =
1064 ath_rc_priv->rssi_sum_cnt = 0;
1065
1066 /* Now reduce the current rssi threshold */
1067 if ((rssi_ackAvg < rssi_thres + 2) &&
1068 (rssi_thres > rssi_ack_vmin)) {
1069 ath_rc_priv->state[tx_rate].rssi_thres--;
f078f209 1070 }
2c5a744d
S		 1071
1072 state_change = true;
f078f209
LR		 1073 }
1074 }
2c5a744d
S		 1075exit:
1076 return state_change;
1077}
1078
1079/* Update PER, RSSI and whatever else that the code thinks it is doing.
1080 If you can make sense of all this, you really need to go out more. */
1081
1082static void ath_rc_update_ht(struct ath_softc *sc,
1083 struct ath_rate_priv *ath_rc_priv,
1084 struct ath_tx_info_priv *tx_info_priv,
1085 int tx_rate, int xretries, int retries)
1086{
1087#define CHK_RSSI(rate) \
1088 ((ath_rc_priv->state[(rate)].rssi_thres + \
1089 rate_table->info[(rate)].rssi_ack_deltamin) > \
1090 ath_rc_priv->state[(rate)+1].rssi_thres)
1091
1092 u32 now_msec = jiffies_to_msecs(jiffies);
1093 int rate;
1094 u8 last_per;
1095 bool state_change = false;
40990ec0 1096 struct ath_rate_table *rate_table = sc->cur_rate_table;
2c5a744d
S		 1097 int size = ath_rc_priv->rate_table_size;
1098
1099 if ((tx_rate < 0) || (tx_rate > rate_table->rate_cnt))
1100 return;
f078f209 1101
2c5a744d
S		 1102 /* To compensate for some imbalance between ctrl and ext. channel */
1103
1104 if (WLAN_RC_PHY_40(rate_table->info[tx_rate].phy))
1105 tx_info_priv->tx.ts_rssi =
1106 tx_info_priv->tx.ts_rssi < 3 ? 0 :
1107 tx_info_priv->tx.ts_rssi - 3;
1108
1109 last_per = ath_rc_priv->state[tx_rate].per;
1110
1111 /* Update PER first */
1112 state_change = ath_rc_update_per(sc, rate_table, ath_rc_priv,
1113 tx_info_priv, tx_rate, xretries,
1114 retries, now_msec);
f078f209
LR		 1115
1116 /*
1117 * If this rate looks bad (high PER) then stop using it for
1118 * a while (except if we are probing).
1119 */
256b7759 1120 if (ath_rc_priv->state[tx_rate].per >= 55 && tx_rate > 0 &&
dc2222a8 1121 rate_table->info[tx_rate].ratekbps <=
256b7759
S		 1122 rate_table->info[ath_rc_priv->rate_max_phy].ratekbps) {
1123 ath_rc_get_nextlowervalid_txrate(rate_table, ath_rc_priv,
2c5a744d 1124 (u8)tx_rate, &ath_rc_priv->rate_max_phy);
f078f209
LR		 1125
1126 /* Don't probe for a little while. */
256b7759 1127 ath_rc_priv->probe_time = now_msec;
f078f209
LR		 1128 }
1129
1130 if (state_change) {
1131 /*
1132 * Make sure the rates above this have higher rssi thresholds.
1133 * (Note: Monotonicity is kept within the OFDM rates and
1134 * within the CCK rates. However, no adjustment is
1135 * made to keep the rssi thresholds monotonically
1136 * increasing between the CCK and OFDM rates.)
1137 */
2c5a744d 1138 for (rate = tx_rate; rate < size - 1; rate++) {
f078f209 1139 if (rate_table->info[rate+1].phy !=
2c5a744d 1140 rate_table->info[tx_rate].phy)
f078f209
LR		 1141 break;
1142
2c5a744d 1143 if (CHK_RSSI(rate)) {
256b7759 1144 ath_rc_priv->state[rate+1].rssi_thres =
2c5a744d
S		 1145 ath_rc_priv->state[rate].rssi_thres +
1146 rate_table->info[rate].rssi_ack_deltamin;
f078f209
LR		 1147 }
1148 }
1149
1150 /* Make sure the rates below this have lower rssi thresholds. */
1151 for (rate = tx_rate - 1; rate >= 0; rate--) {
1152 if (rate_table->info[rate].phy !=
dc2222a8 1153 rate_table->info[tx_rate].phy)
f078f209
LR		 1154 break;
1155
2c5a744d 1156 if (CHK_RSSI(rate)) {
256b7759 1157 if (ath_rc_priv->state[rate+1].rssi_thres <
2c5a744d 1158 rate_table->info[rate].rssi_ack_deltamin)
256b7759 1159 ath_rc_priv->state[rate].rssi_thres = 0;
f078f209 1160 else {
256b7759 1161 ath_rc_priv->state[rate].rssi_thres =
2c5a744d
S		 1162 ath_rc_priv->state[rate+1].rssi_thres -
1163 rate_table->info[rate].rssi_ack_deltamin;
f078f209
LR		 1164 }
1165
256b7759 1166 if (ath_rc_priv->state[rate].rssi_thres <
2c5a744d 1167 rate_table->info[rate].rssi_ack_validmin) {
256b7759 1168 ath_rc_priv->state[rate].rssi_thres =
2c5a744d 1169 rate_table->info[rate].rssi_ack_validmin;
f078f209
LR		 1170 }
1171 }
1172 }
1173 }
1174
1175 /* Make sure the rates below this have lower PER */
1176 /* Monotonicity is kept only for rates below the current rate. */
256b7759 1177 if (ath_rc_priv->state[tx_rate].per < last_per) {
f078f209
LR		 1178 for (rate = tx_rate - 1; rate >= 0; rate--) {
1179 if (rate_table->info[rate].phy !=
dc2222a8 1180 rate_table->info[tx_rate].phy)
f078f209
LR		 1181 break;
1182
256b7759
S		 1183 if (ath_rc_priv->state[rate].per >
1184 ath_rc_priv->state[rate+1].per) {
1185 ath_rc_priv->state[rate].per =
1186 ath_rc_priv->state[rate+1].per;
f078f209
LR		 1187 }
1188 }
1189 }
1190
1191 /* Maintain monotonicity for rates above the current rate */
2c5a744d
S		 1192 for (rate = tx_rate; rate < size - 1; rate++) {
1193 if (ath_rc_priv->state[rate+1].per <
1194 ath_rc_priv->state[rate].per)
256b7759
S		 1195 ath_rc_priv->state[rate+1].per =
1196 ath_rc_priv->state[rate].per;
f078f209
LR		 1197 }
1198
1199 /* Every so often, we reduce the thresholds and
1200 * PER (different for CCK and OFDM). */
256b7759 1201 if (now_msec - ath_rc_priv->rssi_down_time >=
dc2222a8 1202 rate_table->rssi_reduce_interval) {
f078f209 1203
2c5a744d 1204 for (rate = 0; rate < size; rate++) {
256b7759 1205 if (ath_rc_priv->state[rate].rssi_thres >
dc2222a8 1206 rate_table->info[rate].rssi_ack_validmin)
256b7759 1207 ath_rc_priv->state[rate].rssi_thres -= 1;
f078f209 1208 }
256b7759 1209 ath_rc_priv->rssi_down_time = now_msec;
f078f209
LR		 1210 }
1211
1212 /* Every so often, we reduce the thresholds
1213 * and PER (different for CCK and OFDM). */
256b7759 1214 if (now_msec - ath_rc_priv->per_down_time >=
dc2222a8 1215 rate_table->rssi_reduce_interval) {
2c5a744d 1216 for (rate = 0; rate < size; rate++) {
256b7759
S		 1217 ath_rc_priv->state[rate].per =
1218 7 * ath_rc_priv->state[rate].per / 8;
f078f209
LR		 1219 }
1220
256b7759 1221 ath_rc_priv->per_down_time = now_msec;
f078f209 1222 }
2c5a744d
S		 1223
1224#undef CHK_RSSI
1225}
1226
1227static int ath_rc_get_rateindex(struct ath_rate_table *rate_table,
1228 struct ieee80211_tx_rate *rate)
1229{
1230 int rix;
1231
1232 if ((rate->flags & IEEE80211_TX_RC_40_MHZ_WIDTH) &&
1233 (rate->flags & IEEE80211_TX_RC_SHORT_GI))
1234 rix = rate_table->info[rate->idx].ht_index;
1235 else if (rate->flags & IEEE80211_TX_RC_SHORT_GI)
1236 rix = rate_table->info[rate->idx].sgi_index;
1237 else if (rate->flags & IEEE80211_TX_RC_40_MHZ_WIDTH)
1238 rix = rate_table->info[rate->idx].cw40index;
1239 else
1240 rix = rate_table->info[rate->idx].base_index;
1241
1242 return rix;
f078f209
LR		 1243}
1244
46d14a58
S		 1245static void ath_rc_tx_status(struct ath_softc *sc,
1246 struct ath_rate_priv *ath_rc_priv,
1247 struct ieee80211_tx_info *tx_info,
1248 int final_ts_idx, int xretries, int long_retry)
f078f209 1249{
46d14a58 1250 struct ath_tx_info_priv *tx_info_priv = ATH_TX_INFO_PRIV(tx_info);
f078f209 1251 struct ath_rate_table *rate_table;
a8efee4f 1252 struct ieee80211_tx_rate *rates = tx_info->status.rates;
f078f209 1253 u8 flags;
2c5a744d 1254 u32 i = 0, rix;
f078f209 1255
40990ec0 1256 rate_table = sc->cur_rate_table;
f078f209
LR		 1257
1258 /*
1259 * If the first rate is not the final index, there
1260 * are intermediate rate failures to be processed.
1261 */
1262 if (final_ts_idx != 0) {
1263 /* Process intermediate rates that failed.*/
2c5a744d
S		 1264 for (i = 0; i < final_ts_idx ; i++) {
1265 if (rates[i].count != 0 && (rates[i].idx >= 0)) {
1266 flags = rates[i].flags;
1267
f078f209
LR		 1268 /* If HT40 and we have switched mode from
1269 * 40 to 20 => don't update */
2c5a744d 1270
a8efee4f 1271 if ((flags & IEEE80211_TX_RC_40_MHZ_WIDTH) &&
e63835b0 1272 (ath_rc_priv->rc_phy_mode != WLAN_RC_40_FLAG))
f078f209 1273 return;
e63835b0 1274
2c5a744d 1275 rix = ath_rc_get_rateindex(rate_table, &rates[i]);
f078f209 1276 ath_rc_update_ht(sc, ath_rc_priv,
46d14a58 1277 tx_info_priv, rix,
f078f209 1278 xretries ? 1 : 2,
2c5a744d 1279 rates[i].count);
f078f209
LR		 1280 }
1281 }
1282 } else {
1283 /*
1284 * Handle the special case of MIMO PS burst, where the second
1285 * aggregate is sent out with only one rate and one try.
1286 * Treating it as an excessive retry penalizes the rate
1287 * inordinately.
1288 */
a8efee4f 1289 if (rates[0].count == 1 && xretries == 1)
f078f209
LR		 1290 xretries = 2;
1291 }
1292
2c5a744d
S		 1293 flags = rates[i].flags;
1294
f078f209 1295 /* If HT40 and we have switched mode from 40 to 20 => don't update */
a8efee4f 1296 if ((flags & IEEE80211_TX_RC_40_MHZ_WIDTH) &&
e63835b0 1297 (ath_rc_priv->rc_phy_mode != WLAN_RC_40_FLAG)) {
f078f209 1298 return;
e63835b0 1299 }
f078f209 1300
2c5a744d 1301 rix = ath_rc_get_rateindex(rate_table, &rates[i]);
46d14a58 1302 ath_rc_update_ht(sc, ath_rc_priv, tx_info_priv, rix,
2c5a744d 1303 xretries, long_retry);
f078f209
LR		 1304}
1305
e11602b7
S		 1306static struct ath_rate_table *ath_choose_rate_table(struct ath_softc *sc,
1307 enum ieee80211_band band,
1308 bool is_ht, bool is_cw_40)
1309{
1310 int mode = 0;
1311
1312 switch(band) {
1313 case IEEE80211_BAND_2GHZ:
1314 mode = ATH9K_MODE_11G;
1315 if (is_ht)
1316 mode = ATH9K_MODE_11NG_HT20;
1317 if (is_cw_40)
1318 mode = ATH9K_MODE_11NG_HT40PLUS;
1319 break;
1320 case IEEE80211_BAND_5GHZ:
1321 mode = ATH9K_MODE_11A;
1322 if (is_ht)
1323 mode = ATH9K_MODE_11NA_HT20;
1324 if (is_cw_40)
1325 mode = ATH9K_MODE_11NA_HT40PLUS;
1326 break;
1327 default:
04bd4638 1328 DPRINTF(sc, ATH_DBG_CONFIG, "Invalid band\n");
e11602b7
S		 1329 return NULL;
1330 }
1331
1332 BUG_ON(mode >= ATH9K_MODE_MAX);
1333
04bd4638 1334 DPRINTF(sc, ATH_DBG_CONFIG, "Choosing rate table for mode: %d\n", mode);
e11602b7
S		 1335 return sc->hw_rate_table[mode];
1336}
1337
5ddfac3b 1338static void ath_rc_init(struct ath_softc *sc,
46d14a58 1339 struct ath_rate_priv *ath_rc_priv,
5ddfac3b
S		 1340 struct ieee80211_supported_band *sband,
1341 struct ieee80211_sta *sta)
f078f209
LR		 1342{
1343 struct ath_rate_table *rate_table = NULL;
5ddfac3b
S		 1344 struct ath_rateset *rateset = &ath_rc_priv->neg_rates;
1345 u8 *ht_mcs = (u8 *)&ath_rc_priv->neg_ht_rates;
f078f209
LR		 1346 u8 i, j, k, hi = 0, hthi = 0;
1347
e11602b7 1348 /* FIXME: Adhoc */
d97809db
CM		 1349 if ((sc->sc_ah->ah_opmode == NL80211_IFTYPE_STATION) ||
1350 (sc->sc_ah->ah_opmode == NL80211_IFTYPE_ADHOC)) {
e11602b7
S		 1351 bool is_cw_40 = sta->ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40;
1352 rate_table = ath_choose_rate_table(sc, sband->band,
1353 sta->ht_cap.ht_supported,
1354 is_cw_40);
d97809db 1355 } else if (sc->sc_ah->ah_opmode == NL80211_IFTYPE_AP) {
3706de6f
S		 1356 /* cur_rate_table would be set on init through config() */
1357 rate_table = sc->cur_rate_table;
e11602b7 1358 }
f078f209 1359
e11602b7
S		 1360 if (!rate_table) {
1361 DPRINTF(sc, ATH_DBG_FATAL, "Rate table not initialized\n");
1362 return;
1363 }
5ddfac3b 1364
e11602b7 1365 if (sta->ht_cap.ht_supported) {
5ddfac3b
S		 1366 ath_rc_priv->ht_cap = (WLAN_RC_HT_FLAG | WLAN_RC_DS_FLAG);
1367 if (sta->ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40)
1368 ath_rc_priv->ht_cap |= WLAN_RC_40_FLAG;
1369 }
1370
f078f209
LR		 1371 /* Initial rate table size. Will change depending
1372 * on the working rate set */
46d14a58 1373 ath_rc_priv->rate_table_size = RATE_TABLE_SIZE;
f078f209
LR		 1374
1375 /* Initialize thresholds according to the global rate table */
5ddfac3b 1376 for (i = 0 ; i < ath_rc_priv->rate_table_size; i++) {
256b7759 1377 ath_rc_priv->state[i].rssi_thres =
f078f209 1378 rate_table->info[i].rssi_ack_validmin;
256b7759 1379 ath_rc_priv->state[i].per = 0;
f078f209
LR		 1380 }
1381
1382 /* Determine the valid rates */
256b7759 1383 ath_rc_init_valid_txmask(ath_rc_priv);
f078f209
LR		 1384
1385 for (i = 0; i < WLAN_RC_PHY_MAX; i++) {
1386 for (j = 0; j < MAX_TX_RATE_PHY; j++)
256b7759
S		 1387 ath_rc_priv->valid_phy_rateidx[i][j] = 0;
1388 ath_rc_priv->valid_phy_ratecnt[i] = 0;
f078f209 1389 }
5ddfac3b 1390 ath_rc_priv->rc_phy_mode = (ath_rc_priv->ht_cap & WLAN_RC_40_FLAG);
f078f209
LR		 1391
1392 /* Set stream capability */
5ddfac3b 1393 ath_rc_priv->single_stream = (ath_rc_priv->ht_cap & WLAN_RC_DS_FLAG) ? 0 : 1;
f078f209
LR		 1394
1395 if (!rateset->rs_nrates) {
1396 /* No working rate, just initialize valid rates */
2c5a744d 1397 hi = ath_rc_init_validrates(ath_rc_priv, rate_table,
5ddfac3b 1398 ath_rc_priv->ht_cap);
f078f209
LR		 1399 } else {
1400 /* Use intersection of working rates and valid rates */
2c5a744d 1401 hi = ath_rc_setvalid_rates(ath_rc_priv, rate_table,
5ddfac3b
S		 1402 rateset, ath_rc_priv->ht_cap);
1403 if (ath_rc_priv->ht_cap & WLAN_RC_HT_FLAG) {
2c5a744d 1404 hthi = ath_rc_setvalid_htrates(ath_rc_priv,
f078f209
LR		 1405 rate_table,
1406 ht_mcs,
5ddfac3b 1407 ath_rc_priv->ht_cap);
f078f209
LR		 1408 }
1409 hi = A_MAX(hi, hthi);
1410 }
1411
256b7759
S		 1412 ath_rc_priv->rate_table_size = hi + 1;
1413 ath_rc_priv->rate_max_phy = 0;
46d14a58 1414 ASSERT(ath_rc_priv->rate_table_size <= RATE_TABLE_SIZE);
f078f209
LR		 1415
1416 for (i = 0, k = 0; i < WLAN_RC_PHY_MAX; i++) {
256b7759
S		 1417 for (j = 0; j < ath_rc_priv->valid_phy_ratecnt[i]; j++) {
1418 ath_rc_priv->valid_rate_index[k++] =
1419 ath_rc_priv->valid_phy_rateidx[i][j];
f078f209
LR		 1420 }
1421
46d14a58 1422 if (!ath_rc_valid_phyrate(i, rate_table->initial_ratemax, 1)
256b7759 1423 || !ath_rc_priv->valid_phy_ratecnt[i])
f078f209
LR		 1424 continue;
1425
256b7759 1426 ath_rc_priv->rate_max_phy = ath_rc_priv->valid_phy_rateidx[i][j-1];
f078f209 1427 }
46d14a58
S		 1428 ASSERT(ath_rc_priv->rate_table_size <= RATE_TABLE_SIZE);
1429 ASSERT(k <= RATE_TABLE_SIZE);
f078f209 1430
256b7759 1431 ath_rc_priv->max_valid_rate = k;
256b7759
S		 1432 ath_rc_sort_validrates(rate_table, ath_rc_priv);
1433 ath_rc_priv->rate_max_phy = ath_rc_priv->valid_rate_index[k-4];
40990ec0 1434 sc->cur_rate_table = rate_table;
f078f209
LR		 1435}
1436
f078f209 1437/* Rate Control callbacks */
4b7679a5
JB		 1438static void ath_tx_status(void *priv, struct ieee80211_supported_band *sband,
1439 struct ieee80211_sta *sta, void *priv_sta,
f078f209
LR		 1440 struct sk_buff *skb)
1441{
1442 struct ath_softc *sc = priv;
46d14a58
S		 1443 struct ath_rate_priv *ath_rc_priv = priv_sta;
1444 struct ath_tx_info_priv *tx_info_priv = NULL;
f078f209
LR		 1445 struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb);
1446 struct ieee80211_hdr *hdr;
46d14a58 1447 int final_ts_idx, tx_status = 0, is_underrun = 0;
f078f209
LR		 1448 __le16 fc;
1449
f078f209
LR		 1450 hdr = (struct ieee80211_hdr *)skb->data;
1451 fc = hdr->frame_control;
46d14a58 1452 tx_info_priv = ATH_TX_INFO_PRIV(tx_info);
46d14a58 1453 final_ts_idx = tx_info_priv->tx.ts_rateindex;
f078f209 1454
ff37e337 1455 if (!priv_sta || !ieee80211_is_data(fc) ||
7ac47010 1456 !tx_info_priv->update_rc)
46d14a58 1457 goto exit;
e6a9854b 1458
46d14a58
S		 1459 if (tx_info_priv->tx.ts_status & ATH9K_TXERR_FILT)
1460 goto exit;
e6a9854b 1461
46d14a58
S		 1462 /*
1463 * If underrun error is seen assume it as an excessive retry only
1464 * if prefetch trigger level have reached the max (0x3f for 5416)
1465 * Adjust the long retry as if the frame was tried ATH_11N_TXMAXTRY
1466 * times. This affects how ratectrl updates PER for the failed rate.
1467 */
1468 if (tx_info_priv->tx.ts_flags &
1469 (ATH9K_TX_DATA_UNDERRUN | ATH9K_TX_DELIM_UNDERRUN) &&
1470 ((sc->sc_ah->ah_txTrigLevel) >= ath_rc_priv->tx_triglevel_max)) {
1471 tx_status = 1;
1472 is_underrun = 1;
1473 }
1474
1475 if ((tx_info_priv->tx.ts_status & ATH9K_TXERR_XRETRY) ||
1476 (tx_info_priv->tx.ts_status & ATH9K_TXERR_FIFO))
1477 tx_status = 1;
1478
1479 ath_rc_tx_status(sc, ath_rc_priv, tx_info, final_ts_idx, tx_status,
1480 (is_underrun) ? ATH_11N_TXMAXTRY :
1481 tx_info_priv->tx.ts_longretry);
1482
1483exit:
e6a9854b 1484 kfree(tx_info_priv);
f078f209
LR		 1485}
1486
e6a9854b
JB		 1487static void ath_get_rate(void *priv, struct ieee80211_sta *sta, void *priv_sta,
1488 struct ieee80211_tx_rate_control *txrc)
f078f209 1489{
e6a9854b
JB		 1490 struct ieee80211_supported_band *sband = txrc->sband;
1491 struct sk_buff *skb = txrc->skb;
f078f209 1492 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
4b7679a5 1493 struct ath_softc *sc = priv;
f078f209 1494 struct ieee80211_hw *hw = sc->hw;
46d14a58 1495 struct ath_rate_priv *ath_rc_priv = priv_sta;
f078f209 1496 struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb);
46d14a58 1497 int is_probe = 0;
f078f209 1498 __le16 fc = hdr->frame_control;
f078f209 1499
f078f209 1500 /* lowest rate for management and multicast/broadcast frames */
f66000f7
JM		 1501 if (!ieee80211_is_data(fc) || is_multicast_ether_addr(hdr->addr1) ||
1502 !sta) {
a8efee4f
S		 1503 tx_info->control.rates[0].idx = rate_lowest_index(sband, sta);
1504 tx_info->control.rates[0].count =
1505 is_multicast_ether_addr(hdr->addr1) ? 1 : ATH_MGT_TXMAXTRY;
f078f209
LR		 1506 return;
1507 }
1508
f078f209 1509 /* Find tx rate for unicast frames */
46d14a58
S		 1510 ath_rc_ratefind(sc, ath_rc_priv, ATH_11N_TXMAXTRY, 4,
1511 tx_info, &is_probe, false);
f078f209
LR		 1512
1513 /* Check if aggregation has to be enabled for this tid */
ae5eb026 1514 if (hw->conf.ht.enabled) {
f078f209 1515 if (ieee80211_is_data_qos(fc)) {
46d14a58
S		 1516 u8 *qc, tid;
1517 struct ath_node *an;
1518
f078f209
LR		 1519 qc = ieee80211_get_qos_ctl(hdr);
1520 tid = qc[0] & 0xf;
b5aa9bf9 1521 an = (struct ath_node *)sta->drv_priv;
f078f209 1522
ccc75c52
S		 1523 if(ath_tx_aggr_check(sc, an, tid))
1524 ieee80211_start_tx_ba_session(hw, hdr->addr1, tid);
f078f209
LR		 1525 }
1526 }
1527}
1528
4b7679a5
JB		 1529static void ath_rate_init(void *priv, struct ieee80211_supported_band *sband,
1530 struct ieee80211_sta *sta, void *priv_sta)
f078f209 1531{
4b7679a5 1532 struct ath_softc *sc = priv;
46d14a58 1533 struct ath_rate_priv *ath_rc_priv = priv_sta;
f078f209
LR		 1534 int i, j = 0;
1535
7b4d2735
S		 1536 for (i = 0; i < sband->n_bitrates; i++) {
1537 if (sta->supp_rates[sband->band] & BIT(i)) {
1538 ath_rc_priv->neg_rates.rs_rates[j]
1539 = (sband->bitrates[i].bitrate * 2) / 10;
1540 j++;
1541 }
1542 }
1543 ath_rc_priv->neg_rates.rs_nrates = j;
f078f209 1544
a4510bf8 1545 if (sta->ht_cap.ht_supported) {
7b4d2735 1546 for (i = 0, j = 0; i < 77; i++) {
ae5eb026 1547 if (sta->ht_cap.mcs.rx_mask[i/8] & (1<<(i%8)))
dc2222a8 1548 ath_rc_priv->neg_ht_rates.rs_rates[j++] = i;
f078f209
LR		 1549 if (j == ATH_RATE_MAX)
1550 break;
1551 }
dc2222a8 1552 ath_rc_priv->neg_ht_rates.rs_nrates = j;
f078f209 1553 }
7b4d2735 1554
5ddfac3b 1555 ath_rc_init(sc, priv_sta, sband, sta);
f078f209
LR		 1556}
1557
4b7679a5 1558static void *ath_rate_alloc(struct ieee80211_hw *hw, struct dentry *debugfsdir)
f078f209 1559{
4b7679a5 1560 return hw->priv;
f078f209
LR		 1561}
1562
1563static void ath_rate_free(void *priv)
1564{
1565 return;
1566}
1567
4b7679a5 1568static void *ath_rate_alloc_sta(void *priv, struct ieee80211_sta *sta, gfp_t gfp)
f078f209
LR		 1569{
1570 struct ath_softc *sc = priv;
46d14a58 1571 struct ath_rate_priv *rate_priv;
f078f209 1572
46d14a58 1573 rate_priv = kzalloc(sizeof(struct ath_rate_priv), gfp);
f078f209 1574 if (!rate_priv) {
dc2222a8 1575 DPRINTF(sc, ATH_DBG_FATAL,
04bd4638 1576 "Unable to allocate private rc structure\n");
f078f209
LR		 1577 return NULL;
1578 }
fe60594a 1579
fe60594a 1580 rate_priv->rssi_down_time = jiffies_to_msecs(jiffies);
fe7f4a77 1581 rate_priv->tx_triglevel_max = sc->sc_ah->ah_caps.tx_triglevel_max;
dc2222a8 1582
f078f209
LR		 1583 return rate_priv;
1584}
1585
4b7679a5
JB		 1586static void ath_rate_free_sta(void *priv, struct ieee80211_sta *sta,
1587 void *priv_sta)
f078f209 1588{
46d14a58 1589 struct ath_rate_priv *rate_priv = priv_sta;
fe60594a 1590 kfree(rate_priv);
f078f209
LR		 1591}
1592
1593static struct rate_control_ops ath_rate_ops = {
1594 .module = NULL,
1595 .name = "ath9k_rate_control",
1596 .tx_status = ath_tx_status,
1597 .get_rate = ath_get_rate,
1598 .rate_init = ath_rate_init,
f078f209
LR		 1599 .alloc = ath_rate_alloc,
1600 .free = ath_rate_free,
1601 .alloc_sta = ath_rate_alloc_sta,
4b7679a5 1602 .free_sta = ath_rate_free_sta,
f078f209
LR		 1603};
1604
e63835b0
S		 1605static void ath_setup_rate_table(struct ath_softc *sc,
1606 struct ath_rate_table *rate_table)
1607{
1608 int i;
1609
1610 for (i = 0; i < 256; i++)
1611 rate_table->rateCodeToIndex[i] = (u8)-1;
1612
1613 for (i = 0; i < rate_table->rate_cnt; i++) {
1614 u8 code = rate_table->info[i].ratecode;
1615 u8 cix = rate_table->info[i].ctrl_rate;
1616 u8 sh = rate_table->info[i].short_preamble;
1617
1618 rate_table->rateCodeToIndex[code] = i;
1619 rate_table->rateCodeToIndex[code | sh] = i;
1620
1621 rate_table->info[i].lpAckDuration =
1622 ath9k_hw_computetxtime(sc->sc_ah, rate_table,
1623 WLAN_CTRL_FRAME_SIZE,
1624 cix,
1625 false);
1626 rate_table->info[i].spAckDuration =
1627 ath9k_hw_computetxtime(sc->sc_ah, rate_table,
1628 WLAN_CTRL_FRAME_SIZE,
1629 cix,
1630 true);
1631 }
1632}
1633
fe7f4a77
S		 1634void ath_rate_attach(struct ath_softc *sc)
1635{
1636 sc->hw_rate_table[ATH9K_MODE_11B] =
1637 &ar5416_11b_ratetable;
1638 sc->hw_rate_table[ATH9K_MODE_11A] =
1639 &ar5416_11a_ratetable;
1640 sc->hw_rate_table[ATH9K_MODE_11G] =
1641 &ar5416_11g_ratetable;
1642 sc->hw_rate_table[ATH9K_MODE_11NA_HT20] =
1643 &ar5416_11na_ratetable;
1644 sc->hw_rate_table[ATH9K_MODE_11NG_HT20] =
1645 &ar5416_11ng_ratetable;
1646 sc->hw_rate_table[ATH9K_MODE_11NA_HT40PLUS] =
1647 &ar5416_11na_ratetable;
1648 sc->hw_rate_table[ATH9K_MODE_11NA_HT40MINUS] =
1649 &ar5416_11na_ratetable;
1650 sc->hw_rate_table[ATH9K_MODE_11NG_HT40PLUS] =
1651 &ar5416_11ng_ratetable;
1652 sc->hw_rate_table[ATH9K_MODE_11NG_HT40MINUS] =
1653 &ar5416_11ng_ratetable;
e63835b0
S		 1654
1655 ath_setup_rate_table(sc, &ar5416_11b_ratetable);
1656 ath_setup_rate_table(sc, &ar5416_11a_ratetable);
1657 ath_setup_rate_table(sc, &ar5416_11g_ratetable);
1658 ath_setup_rate_table(sc, &ar5416_11na_ratetable);
1659 ath_setup_rate_table(sc, &ar5416_11ng_ratetable);
fe7f4a77
S		 1660}
1661
f078f209
LR		 1662int ath_rate_control_register(void)
1663{
1664 return ieee80211_rate_control_register(&ath_rate_ops);
1665}
1666
1667void ath_rate_control_unregister(void)
1668{
1669 ieee80211_rate_control_unregister(&ath_rate_ops);
1670}
Clone of davem's net-next-2.6 tree