rc.c 50.5 KB
Newer Older
1 2
/*
 * Copyright (c) 2004 Video54 Technologies, Inc.
3
 * Copyright (c) 2004-2011 Atheros Communications, Inc.
4 5 6 7 8 9 10 11 12 13 14 15 16 17
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

18
#include <linux/slab.h>
19
#include <linux/export.h>
20

S
Sujith 已提交
21
#include "ath9k.h"
22

23
static const struct ath_rate_table ar5416_11na_ratetable = {
24
	68,
25
	8, /* MCS start */
26
	{
27
		[0] = { RC_L_SDT, WLAN_RC_PHY_OFDM, 6000,
28
			5400, 0, 12, 0, 0, 0, 0 }, /* 6 Mb */
29
		[1] = { RC_L_SDT, WLAN_RC_PHY_OFDM, 9000,
30
			7800,  1, 18, 0, 1, 1, 1 }, /* 9 Mb */
31
		[2] = { RC_L_SDT, WLAN_RC_PHY_OFDM, 12000,
32
			10000, 2, 24, 2, 2, 2, 2 }, /* 12 Mb */
33
		[3] = { RC_L_SDT, WLAN_RC_PHY_OFDM, 18000,
34
			13900, 3, 36, 2, 3, 3, 3 }, /* 18 Mb */
35
		[4] = { RC_L_SDT, WLAN_RC_PHY_OFDM, 24000,
36
			17300, 4, 48, 4, 4, 4, 4 }, /* 24 Mb */
37
		[5] = { RC_L_SDT, WLAN_RC_PHY_OFDM, 36000,
38
			23000, 5, 72, 4, 5, 5, 5 }, /* 36 Mb */
39
		[6] = { RC_L_SDT, WLAN_RC_PHY_OFDM, 48000,
40
			27400, 6, 96, 4, 6, 6, 6 }, /* 48 Mb */
41
		[7] = { RC_L_SDT, WLAN_RC_PHY_OFDM, 54000,
42
			29300, 7, 108, 4, 7, 7, 7 }, /* 54 Mb */
43
		[8] = { RC_HT_SDT_2040, WLAN_RC_PHY_HT_20_SS, 6500,
44
			6400, 0, 0, 0, 38, 8, 38 }, /* 6.5 Mb */
45
		[9] = { RC_HT_SDT_20, WLAN_RC_PHY_HT_20_SS, 13000,
46
			12700, 1, 1, 2, 39, 9, 39 }, /* 13 Mb */
47
		[10] = { RC_HT_SDT_20, WLAN_RC_PHY_HT_20_SS, 19500,
48
			18800, 2, 2, 2, 40, 10, 40 }, /* 19.5 Mb */
49
		[11] = { RC_HT_SD_20, WLAN_RC_PHY_HT_20_SS, 26000,
50
			25000, 3, 3, 4, 41, 11, 41 }, /* 26 Mb */
51
		[12] = { RC_HT_SD_20, WLAN_RC_PHY_HT_20_SS, 39000,
52
			36700, 4, 4, 4, 42, 12, 42 }, /* 39 Mb */
53
		[13] = { RC_HT_S_20, WLAN_RC_PHY_HT_20_SS, 52000,
54
			48100, 5, 5, 4, 43, 13, 43 }, /* 52 Mb */
55
		[14] = { RC_HT_S_20, WLAN_RC_PHY_HT_20_SS, 58500,
56
			53500, 6, 6, 4, 44, 14, 44 }, /* 58.5 Mb */
57
		[15] = { RC_HT_S_20, WLAN_RC_PHY_HT_20_SS, 65000,
58
			59000, 7, 7, 4, 45, 16, 46 }, /* 65 Mb */
59
		[16] = { RC_HT_S_20, WLAN_RC_PHY_HT_20_SS_HGI, 72200,
60
			65400, 7, 7, 4, 45, 16, 46 }, /* 75 Mb */
61
		[17] = { RC_INVALID, WLAN_RC_PHY_HT_20_DS, 13000,
62
			12700, 8, 8, 0, 47, 17, 47 }, /* 13 Mb */
63
		[18] = { RC_HT_T_20, WLAN_RC_PHY_HT_20_DS, 26000,
64
			24800, 9, 9, 2, 48, 18, 48 }, /* 26 Mb */
65
		[19] = { RC_HT_T_20, WLAN_RC_PHY_HT_20_DS, 39000,
66
			36600, 10, 10, 2, 49, 19, 49 }, /* 39 Mb */
67
		[20] = { RC_HT_DT_20, WLAN_RC_PHY_HT_20_DS, 52000,
68
			48100, 11, 11, 4, 50, 20, 50 }, /* 52 Mb */
69
		[21] = { RC_HT_DT_20, WLAN_RC_PHY_HT_20_DS, 78000,
70
			69500, 12, 12, 4, 51, 21, 51 }, /* 78 Mb */
71
		[22] = { RC_HT_DT_20, WLAN_RC_PHY_HT_20_DS, 104000,
72
			89500, 13, 13, 4, 52, 22, 52 }, /* 104 Mb */
73
		[23] = { RC_HT_DT_20, WLAN_RC_PHY_HT_20_DS, 117000,
74
			98900, 14, 14, 4, 53, 23, 53 }, /* 117 Mb */
75
		[24] = { RC_HT_DT_20, WLAN_RC_PHY_HT_20_DS, 130000,
76
			108300, 15, 15, 4, 54, 25, 55 }, /* 130 Mb */
77
		[25] = { RC_HT_DT_20, WLAN_RC_PHY_HT_20_DS_HGI, 144400,
78
			120000, 15, 15, 4, 54, 25, 55 }, /* 144.4 Mb */
79
		[26] = {  RC_INVALID, WLAN_RC_PHY_HT_20_TS, 19500,
80
			17400, 16, 16, 0, 56, 26, 56 }, /* 19.5 Mb */
81
		[27] = {  RC_INVALID, WLAN_RC_PHY_HT_20_TS, 39000,
82
			35100, 17, 17, 2, 57, 27, 57 }, /* 39 Mb */
83
		[28] = {  RC_INVALID, WLAN_RC_PHY_HT_20_TS, 58500,
84
			52600, 18, 18, 2, 58, 28, 58 }, /* 58.5 Mb */
85
		[29] = {  RC_INVALID, WLAN_RC_PHY_HT_20_TS, 78000,
86
			70400, 19, 19, 4, 59, 29, 59 }, /* 78 Mb */
87
		[30] = {  RC_INVALID, WLAN_RC_PHY_HT_20_TS, 117000,
88
			104900, 20, 20, 4, 60, 31, 61 }, /* 117 Mb */
89
		[31] = {  RC_INVALID, WLAN_RC_PHY_HT_20_TS_HGI, 130000,
90
			115800, 20, 20, 4, 60, 31, 61 }, /* 130 Mb*/
91
		[32] = {  RC_HT_T_20, WLAN_RC_PHY_HT_20_TS, 156000,
92
			137200, 21, 21, 4, 62, 33, 63 }, /* 156 Mb */
93
		[33] = {  RC_HT_T_20, WLAN_RC_PHY_HT_20_TS_HGI, 173300,
94
			151100, 21, 21, 4, 62, 33, 63 }, /* 173.3 Mb */
95
		[34] = {  RC_HT_T_20, WLAN_RC_PHY_HT_20_TS, 175500,
96
			152800, 22, 22, 4, 64, 35, 65 }, /* 175.5 Mb */
97
		[35] = {  RC_HT_T_20, WLAN_RC_PHY_HT_20_TS_HGI, 195000,
98
			168400, 22, 22, 4, 64, 35, 65 }, /* 195 Mb*/
99
		[36] = {  RC_HT_T_20, WLAN_RC_PHY_HT_20_TS, 195000,
100
			168400, 23, 23, 4, 66, 37, 67 }, /* 195 Mb */
101
		[37] = {  RC_HT_T_20, WLAN_RC_PHY_HT_20_TS_HGI, 216700,
102
			185000, 23, 23, 4, 66, 37, 67 }, /* 216.7 Mb */
103
		[38] = { RC_HT_SDT_40, WLAN_RC_PHY_HT_40_SS, 13500,
104
			13200, 0, 0, 0, 38, 38, 38 }, /* 13.5 Mb*/
105
		[39] = { RC_HT_SDT_40, WLAN_RC_PHY_HT_40_SS, 27500,
106
			25900, 1, 1, 2, 39, 39, 39 }, /* 27.0 Mb*/
107
		[40] = { RC_HT_SDT_40, WLAN_RC_PHY_HT_40_SS, 40500,
108
			38600, 2, 2, 2, 40, 40, 40 }, /* 40.5 Mb*/
109
		[41] = { RC_HT_SD_40, WLAN_RC_PHY_HT_40_SS, 54000,
110
			49800, 3, 3, 4, 41, 41, 41 }, /* 54 Mb */
111
		[42] = { RC_HT_SD_40, WLAN_RC_PHY_HT_40_SS, 81500,
112
			72200, 4, 4, 4, 42, 42, 42 }, /* 81 Mb */
113
		[43] = { RC_HT_S_40, WLAN_RC_PHY_HT_40_SS, 108000,
114
			92900, 5, 5, 4, 43, 43, 43 }, /* 108 Mb */
115
		[44] = { RC_HT_S_40, WLAN_RC_PHY_HT_40_SS, 121500,
116
			102700, 6, 6, 4, 44, 44, 44 }, /* 121.5 Mb*/
117
		[45] = { RC_HT_S_40, WLAN_RC_PHY_HT_40_SS, 135000,
118
			112000, 7, 7, 4, 45, 46, 46 }, /* 135 Mb */
119
		[46] = { RC_HT_S_40, WLAN_RC_PHY_HT_40_SS_HGI, 150000,
120
			122000, 7, 7, 4, 45, 46, 46 }, /* 150 Mb */
121
		[47] = { RC_INVALID, WLAN_RC_PHY_HT_40_DS, 27000,
122
			25800, 8, 8, 0, 47, 47, 47 }, /* 27 Mb */
123
		[48] = { RC_HT_T_40, WLAN_RC_PHY_HT_40_DS, 54000,
124
			49800, 9, 9, 2, 48, 48, 48 }, /* 54 Mb */
125
		[49] = { RC_HT_T_40, WLAN_RC_PHY_HT_40_DS, 81000,
126
			71900, 10, 10, 2, 49, 49, 49 }, /* 81 Mb */
127
		[50] = { RC_HT_DT_40, WLAN_RC_PHY_HT_40_DS, 108000,
128
			92500, 11, 11, 4, 50, 50, 50 }, /* 108 Mb */
129
		[51] = { RC_HT_DT_40, WLAN_RC_PHY_HT_40_DS, 162000,
130
			130300, 12, 12, 4, 51, 51, 51 }, /* 162 Mb */
131
		[52] = { RC_HT_DT_40, WLAN_RC_PHY_HT_40_DS, 216000,
132
			162800, 13, 13, 4, 52, 52, 52 }, /* 216 Mb */
133
		[53] = { RC_HT_DT_40, WLAN_RC_PHY_HT_40_DS, 243000,
134
			178200, 14, 14, 4, 53, 53, 53 }, /* 243 Mb */
135
		[54] = { RC_HT_DT_40, WLAN_RC_PHY_HT_40_DS, 270000,
136
			192100, 15, 15, 4, 54, 55, 55 }, /* 270 Mb */
137
		[55] = { RC_HT_DT_40, WLAN_RC_PHY_HT_40_DS_HGI, 300000,
138
			207000, 15, 15, 4, 54, 55, 55 }, /* 300 Mb */
139
		[56] = {  RC_INVALID, WLAN_RC_PHY_HT_40_TS, 40500,
140
			36100, 16, 16, 0, 56, 56, 56 }, /* 40.5 Mb */
141
		[57] = {  RC_INVALID, WLAN_RC_PHY_HT_40_TS, 81000,
142
			72900, 17, 17, 2, 57, 57, 57 }, /* 81 Mb */
143
		[58] = {  RC_INVALID, WLAN_RC_PHY_HT_40_TS, 121500,
144
			108300, 18, 18, 2, 58, 58, 58 }, /* 121.5 Mb */
145
		[59] = {  RC_INVALID, WLAN_RC_PHY_HT_40_TS, 162000,
146
			142000, 19, 19, 4, 59, 59, 59 }, /*  162 Mb */
147
		[60] = {  RC_INVALID, WLAN_RC_PHY_HT_40_TS, 243000,
148
			205100, 20, 20, 4, 60, 61, 61 }, /*  243 Mb */
149
		[61] = {  RC_INVALID, WLAN_RC_PHY_HT_40_TS_HGI, 270000,
150
			224700, 20, 20, 4, 60, 61, 61 }, /*  270 Mb */
151
		[62] = {  RC_HT_T_40, WLAN_RC_PHY_HT_40_TS, 324000,
152
			263100, 21, 21, 4, 62, 63, 63 }, /*  324 Mb */
153
		[63] = {  RC_HT_T_40, WLAN_RC_PHY_HT_40_TS_HGI, 360000,
154
			288000, 21, 21, 4, 62, 63, 63 }, /*  360 Mb */
155
		[64] = {  RC_HT_T_40, WLAN_RC_PHY_HT_40_TS, 364500,
156
			290700, 22, 22, 4, 64, 65, 65 }, /* 364.5 Mb */
157
		[65] = {  RC_HT_T_40, WLAN_RC_PHY_HT_40_TS_HGI, 405000,
158
			317200, 22, 22, 4, 64, 65, 65 }, /* 405 Mb */
159
		[66] = {  RC_HT_T_40, WLAN_RC_PHY_HT_40_TS, 405000,
160
			317200, 23, 23, 4, 66, 67, 67 }, /* 405 Mb */
161
		[67] = {  RC_HT_T_40, WLAN_RC_PHY_HT_40_TS_HGI, 450000,
162
			346400, 23, 23, 4, 66, 67, 67 }, /* 450 Mb */
163 164 165 166 167 168 169 170
	},
	50,  /* probe interval */
	WLAN_RC_HT_FLAG,  /* Phy rates allowed initially */
};

/* 4ms frame limit not used for NG mode.  The values filled
 * for HT are the 64K max aggregate limit */

171
static const struct ath_rate_table ar5416_11ng_ratetable = {
172
	72,
173
	12, /* MCS start */
174
	{
175
		[0] = { RC_ALL, WLAN_RC_PHY_CCK, 1000,
176
			900, 0, 2, 0, 0, 0, 0 }, /* 1 Mb */
177
		[1] = { RC_ALL, WLAN_RC_PHY_CCK, 2000,
178
			1900, 1, 4, 1, 1, 1, 1 }, /* 2 Mb */
179
		[2] = { RC_ALL, WLAN_RC_PHY_CCK, 5500,
180
			4900, 2, 11, 2, 2, 2, 2 }, /* 5.5 Mb */
181
		[3] = { RC_ALL, WLAN_RC_PHY_CCK, 11000,
182
			8100, 3, 22, 3, 3, 3, 3 }, /* 11 Mb */
183
		[4] = { RC_INVALID, WLAN_RC_PHY_OFDM, 6000,
184
			5400, 4, 12, 4, 4, 4, 4 }, /* 6 Mb */
185
		[5] = { RC_INVALID, WLAN_RC_PHY_OFDM, 9000,
186
			7800, 5, 18, 4, 5, 5, 5 }, /* 9 Mb */
187
		[6] = { RC_L_SDT, WLAN_RC_PHY_OFDM, 12000,
188
			10100, 6, 24, 6, 6, 6, 6 }, /* 12 Mb */
189
		[7] = { RC_L_SDT, WLAN_RC_PHY_OFDM, 18000,
190
			14100, 7, 36, 6, 7, 7, 7 }, /* 18 Mb */
191
		[8] = { RC_L_SDT, WLAN_RC_PHY_OFDM, 24000,
192
			17700, 8, 48, 8, 8, 8, 8 }, /* 24 Mb */
193
		[9] = { RC_L_SDT, WLAN_RC_PHY_OFDM, 36000,
194
			23700, 9, 72, 8, 9, 9, 9 }, /* 36 Mb */
195
		[10] = { RC_L_SDT, WLAN_RC_PHY_OFDM, 48000,
196
			27400, 10, 96, 8, 10, 10, 10 }, /* 48 Mb */
197
		[11] = { RC_L_SDT, WLAN_RC_PHY_OFDM, 54000,
198
			30900, 11, 108, 8, 11, 11, 11 }, /* 54 Mb */
199
		[12] = { RC_INVALID, WLAN_RC_PHY_HT_20_SS, 6500,
200
			6400, 0, 0, 4, 42, 12, 42 }, /* 6.5 Mb */
201
		[13] = { RC_HT_SDT_20, WLAN_RC_PHY_HT_20_SS, 13000,
202
			12700, 1, 1, 6, 43, 13, 43 }, /* 13 Mb */
203
		[14] = { RC_HT_SDT_20, WLAN_RC_PHY_HT_20_SS, 19500,
204
			18800, 2, 2, 6, 44, 14, 44 }, /* 19.5 Mb*/
205
		[15] = { RC_HT_SD_20, WLAN_RC_PHY_HT_20_SS, 26000,
206
			25000, 3, 3, 8, 45, 15, 45 }, /* 26 Mb */
207
		[16] = { RC_HT_SD_20, WLAN_RC_PHY_HT_20_SS, 39000,
208
			36700, 4, 4, 8, 46, 16, 46 }, /* 39 Mb */
209
		[17] = { RC_HT_S_20, WLAN_RC_PHY_HT_20_SS, 52000,
210
			48100, 5, 5, 8, 47, 17, 47 }, /* 52 Mb */
211
		[18] = { RC_HT_S_20, WLAN_RC_PHY_HT_20_SS, 58500,
212
			53500, 6, 6, 8, 48, 18, 48 }, /* 58.5 Mb */
213
		[19] = { RC_HT_S_20, WLAN_RC_PHY_HT_20_SS, 65000,
214
			59000, 7, 7, 8, 49, 20, 50 }, /* 65 Mb */
215
		[20] = { RC_HT_S_20, WLAN_RC_PHY_HT_20_SS_HGI, 72200,
216
			65400, 7, 7, 8, 49, 20, 50 }, /* 65 Mb*/
217
		[21] = { RC_INVALID, WLAN_RC_PHY_HT_20_DS, 13000,
218
			12700, 8, 8, 4, 51, 21, 51 }, /* 13 Mb */
219
		[22] = { RC_HT_T_20, WLAN_RC_PHY_HT_20_DS, 26000,
220
			24800, 9, 9, 6, 52, 22, 52 }, /* 26 Mb */
221
		[23] = { RC_HT_T_20, WLAN_RC_PHY_HT_20_DS, 39000,
222
			36600, 10, 10, 6, 53, 23, 53 }, /* 39 Mb */
223
		[24] = { RC_HT_DT_20, WLAN_RC_PHY_HT_20_DS, 52000,
224
			48100, 11, 11, 8, 54, 24, 54 }, /* 52 Mb */
225
		[25] = { RC_HT_DT_20, WLAN_RC_PHY_HT_20_DS, 78000,
226
			69500, 12, 12, 8, 55, 25, 55 }, /* 78 Mb */
227
		[26] = { RC_HT_DT_20, WLAN_RC_PHY_HT_20_DS, 104000,
228
			89500, 13, 13, 8, 56, 26, 56 }, /* 104 Mb */
229
		[27] = { RC_HT_DT_20, WLAN_RC_PHY_HT_20_DS, 117000,
230
			98900, 14, 14, 8, 57, 27, 57 }, /* 117 Mb */
231
		[28] = { RC_HT_DT_20, WLAN_RC_PHY_HT_20_DS, 130000,
232
			108300, 15, 15, 8, 58, 29, 59 }, /* 130 Mb */
233
		[29] = { RC_HT_DT_20, WLAN_RC_PHY_HT_20_DS_HGI, 144400,
234
			120000, 15, 15, 8, 58, 29, 59 }, /* 144.4 Mb */
235
		[30] = {  RC_INVALID, WLAN_RC_PHY_HT_20_TS, 19500,
236
			17400, 16, 16, 4, 60, 30, 60 }, /* 19.5 Mb */
237
		[31] = {  RC_INVALID, WLAN_RC_PHY_HT_20_TS, 39000,
238
			35100, 17, 17, 6, 61, 31, 61 }, /* 39 Mb */
239
		[32] = {  RC_INVALID, WLAN_RC_PHY_HT_20_TS, 58500,
240
			52600, 18, 18, 6, 62, 32, 62 }, /* 58.5 Mb */
241
		[33] = {  RC_INVALID, WLAN_RC_PHY_HT_20_TS, 78000,
242
			70400, 19, 19, 8, 63, 33, 63 }, /* 78 Mb */
243
		[34] = {  RC_INVALID, WLAN_RC_PHY_HT_20_TS, 117000,
244
			104900, 20, 20, 8, 64, 35, 65 }, /* 117 Mb */
245
		[35] = {  RC_INVALID, WLAN_RC_PHY_HT_20_TS_HGI, 130000,
246
			115800, 20, 20, 8, 64, 35, 65 }, /* 130 Mb */
247
		[36] = {  RC_HT_T_20, WLAN_RC_PHY_HT_20_TS, 156000,
248
			137200, 21, 21, 8, 66, 37, 67 }, /* 156 Mb */
249
		[37] = {  RC_HT_T_20, WLAN_RC_PHY_HT_20_TS_HGI, 173300,
250
			151100, 21, 21, 8, 66, 37, 67 }, /* 173.3 Mb */
251
		[38] = {  RC_HT_T_20, WLAN_RC_PHY_HT_20_TS, 175500,
252
			152800, 22, 22, 8, 68, 39, 69 }, /* 175.5 Mb */
253
		[39] = {  RC_HT_T_20, WLAN_RC_PHY_HT_20_TS_HGI, 195000,
254
			168400, 22, 22, 8, 68, 39, 69 }, /* 195 Mb */
255
		[40] = {  RC_HT_T_20, WLAN_RC_PHY_HT_20_TS, 195000,
256
			168400, 23, 23, 8, 70, 41, 71 }, /* 195 Mb */
257
		[41] = {  RC_HT_T_20, WLAN_RC_PHY_HT_20_TS_HGI, 216700,
258
			185000, 23, 23, 8, 70, 41, 71 }, /* 216.7 Mb */
259
		[42] = { RC_HT_SDT_40, WLAN_RC_PHY_HT_40_SS, 13500,
260
			13200, 0, 0, 8, 42, 42, 42 }, /* 13.5 Mb */
261
		[43] = { RC_HT_SDT_40, WLAN_RC_PHY_HT_40_SS, 27500,
262
			25900, 1, 1, 8, 43, 43, 43 }, /* 27.0 Mb */
263
		[44] = { RC_HT_SDT_40, WLAN_RC_PHY_HT_40_SS, 40500,
264
			38600, 2, 2, 8, 44, 44, 44 }, /* 40.5 Mb */
265
		[45] = { RC_HT_SD_40, WLAN_RC_PHY_HT_40_SS, 54000,
266
			49800, 3, 3, 8, 45, 45, 45 }, /* 54 Mb */
267
		[46] = { RC_HT_SD_40, WLAN_RC_PHY_HT_40_SS, 81500,
268
			72200, 4, 4, 8, 46, 46, 46 }, /* 81 Mb */
269
		[47] = { RC_HT_S_40 , WLAN_RC_PHY_HT_40_SS, 108000,
270
			92900, 5, 5, 8, 47, 47, 47 }, /* 108 Mb */
271
		[48] = { RC_HT_S_40, WLAN_RC_PHY_HT_40_SS, 121500,
272
			102700, 6, 6, 8, 48, 48, 48 }, /* 121.5 Mb */
273
		[49] = { RC_HT_S_40, WLAN_RC_PHY_HT_40_SS, 135000,
274
			112000, 7, 7, 8, 49, 50, 50 }, /* 135 Mb */
275
		[50] = { RC_HT_S_40, WLAN_RC_PHY_HT_40_SS_HGI, 150000,
276
			122000, 7, 7, 8, 49, 50, 50 }, /* 150 Mb */
277
		[51] = { RC_INVALID, WLAN_RC_PHY_HT_40_DS, 27000,
278
			25800, 8, 8, 8, 51, 51, 51 }, /* 27 Mb */
279
		[52] = { RC_HT_T_40, WLAN_RC_PHY_HT_40_DS, 54000,
280
			49800, 9, 9, 8, 52, 52, 52 }, /* 54 Mb */
281
		[53] = { RC_HT_T_40, WLAN_RC_PHY_HT_40_DS, 81000,
282
			71900, 10, 10, 8, 53, 53, 53 }, /* 81 Mb */
283
		[54] = { RC_HT_DT_40, WLAN_RC_PHY_HT_40_DS, 108000,
284
			92500, 11, 11, 8, 54, 54, 54 }, /* 108 Mb */
285
		[55] = { RC_HT_DT_40, WLAN_RC_PHY_HT_40_DS, 162000,
286
			130300, 12, 12, 8, 55, 55, 55 }, /* 162 Mb */
287
		[56] = { RC_HT_DT_40, WLAN_RC_PHY_HT_40_DS, 216000,
288
			162800, 13, 13, 8, 56, 56, 56 }, /* 216 Mb */
289
		[57] = { RC_HT_DT_40, WLAN_RC_PHY_HT_40_DS, 243000,
290
			178200, 14, 14, 8, 57, 57, 57 }, /* 243 Mb */
291
		[58] = { RC_HT_DT_40, WLAN_RC_PHY_HT_40_DS, 270000,
292
			192100, 15, 15, 8, 58, 59, 59 }, /* 270 Mb */
293
		[59] = { RC_HT_DT_40, WLAN_RC_PHY_HT_40_DS_HGI, 300000,
294
			207000, 15, 15, 8, 58, 59, 59 }, /* 300 Mb */
295
		[60] = {  RC_INVALID, WLAN_RC_PHY_HT_40_TS, 40500,
296
			36100, 16, 16, 8, 60, 60, 60 }, /* 40.5 Mb */
297
		[61] = {  RC_INVALID, WLAN_RC_PHY_HT_40_TS, 81000,
298
			72900, 17, 17, 8, 61, 61, 61 }, /* 81 Mb */
299
		[62] = {  RC_INVALID, WLAN_RC_PHY_HT_40_TS, 121500,
300
			108300, 18, 18, 8, 62, 62, 62 }, /* 121.5 Mb */
301
		[63] = {  RC_INVALID, WLAN_RC_PHY_HT_40_TS, 162000,
302
			142000, 19, 19, 8, 63, 63, 63 }, /* 162 Mb */
303
		[64] = {  RC_INVALID, WLAN_RC_PHY_HT_40_TS, 243000,
304
			205100, 20, 20, 8, 64, 65, 65 }, /* 243 Mb */
305
		[65] = {  RC_INVALID, WLAN_RC_PHY_HT_40_TS_HGI, 270000,
306
			224700, 20, 20, 8, 64, 65, 65 }, /* 270 Mb */
307
		[66] = {  RC_HT_T_40, WLAN_RC_PHY_HT_40_TS, 324000,
308
			263100, 21, 21, 8, 66, 67, 67 }, /* 324 Mb */
309
		[67] = {  RC_HT_T_40, WLAN_RC_PHY_HT_40_TS_HGI, 360000,
310
			288000, 21, 21, 8, 66, 67, 67 }, /* 360 Mb */
311
		[68] = {  RC_HT_T_40, WLAN_RC_PHY_HT_40_TS, 364500,
312
			290700, 22, 22, 8, 68, 69, 69 }, /* 364.5 Mb */
313
		[69] = {  RC_HT_T_40, WLAN_RC_PHY_HT_40_TS_HGI, 405000,
314
			317200, 22, 22, 8, 68, 69, 69 }, /* 405 Mb */
315
		[70] = {  RC_HT_T_40, WLAN_RC_PHY_HT_40_TS, 405000,
316
			317200, 23, 23, 8, 70, 71, 71 }, /* 405 Mb */
317
		[71] = {  RC_HT_T_40, WLAN_RC_PHY_HT_40_TS_HGI, 450000,
318
			346400, 23, 23, 8, 70, 71, 71 }, /* 450 Mb */
319
	},
320 321 322 323
	50,  /* probe interval */
	WLAN_RC_HT_FLAG,  /* Phy rates allowed initially */
};

324
static const struct ath_rate_table ar5416_11a_ratetable = {
325
	8,
326
	0,
327
	{
328
		{ RC_L_SDT, WLAN_RC_PHY_OFDM, 6000, /* 6 Mb */
329
			5400, 0, 12, 0},
330
		{ RC_L_SDT, WLAN_RC_PHY_OFDM, 9000, /* 9 Mb */
331
			7800,  1, 18, 0},
332
		{ RC_L_SDT, WLAN_RC_PHY_OFDM, 12000, /* 12 Mb */
333
			10000, 2, 24, 2},
334
		{ RC_L_SDT, WLAN_RC_PHY_OFDM, 18000, /* 18 Mb */
335
			13900, 3, 36, 2},
336
		{ RC_L_SDT, WLAN_RC_PHY_OFDM, 24000, /* 24 Mb */
337
			17300, 4, 48, 4},
338
		{ RC_L_SDT, WLAN_RC_PHY_OFDM, 36000, /* 36 Mb */
339
			23000, 5, 72, 4},
340
		{ RC_L_SDT, WLAN_RC_PHY_OFDM, 48000, /* 48 Mb */
341
			27400, 6, 96, 4},
342
		{ RC_L_SDT, WLAN_RC_PHY_OFDM, 54000, /* 54 Mb */
343
			29300, 7, 108, 4},
344 345 346 347 348
	},
	50,  /* probe interval */
	0,   /* Phy rates allowed initially */
};

349
static const struct ath_rate_table ar5416_11g_ratetable = {
350
	12,
351
	0,
352
	{
353
		{ RC_L_SDT, WLAN_RC_PHY_CCK, 1000, /* 1 Mb */
354
			900, 0, 2, 0},
355
		{ RC_L_SDT, WLAN_RC_PHY_CCK, 2000, /* 2 Mb */
356
			1900, 1, 4, 1},
357
		{ RC_L_SDT, WLAN_RC_PHY_CCK, 5500, /* 5.5 Mb */
358
			4900, 2, 11, 2},
359
		{ RC_L_SDT, WLAN_RC_PHY_CCK, 11000, /* 11 Mb */
360
			8100, 3, 22, 3},
361
		{ RC_INVALID, WLAN_RC_PHY_OFDM, 6000, /* 6 Mb */
362
			5400, 4, 12, 4},
363
		{ RC_INVALID, WLAN_RC_PHY_OFDM, 9000, /* 9 Mb */
364
			7800, 5, 18, 4},
365
		{ RC_L_SDT, WLAN_RC_PHY_OFDM, 12000, /* 12 Mb */
366
			10000, 6, 24, 6},
367
		{ RC_L_SDT, WLAN_RC_PHY_OFDM, 18000, /* 18 Mb */
368
			13900, 7, 36, 6},
369
		{ RC_L_SDT, WLAN_RC_PHY_OFDM, 24000, /* 24 Mb */
370
			17300, 8, 48, 8},
371
		{ RC_L_SDT, WLAN_RC_PHY_OFDM, 36000, /* 36 Mb */
372
			23000, 9, 72, 8},
373
		{ RC_L_SDT, WLAN_RC_PHY_OFDM, 48000, /* 48 Mb */
374
			27400, 10, 96, 8},
375
		{ RC_L_SDT, WLAN_RC_PHY_OFDM, 54000, /* 54 Mb */
376
			29300, 11, 108, 8},
377 378 379 380 381
	},
	50,  /* probe interval */
	0,   /* Phy rates allowed initially */
};

382
static int ath_rc_get_rateindex(const struct ath_rate_table *rate_table,
383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406
				struct ieee80211_tx_rate *rate)
{
	int rix = 0, i = 0;
	static const int mcs_rix_off[] = { 7, 15, 20, 21, 22, 23 };

	if (!(rate->flags & IEEE80211_TX_RC_MCS))
		return rate->idx;

	while (i < ARRAY_SIZE(mcs_rix_off) && rate->idx > mcs_rix_off[i]) {
		rix++; i++;
	}

	rix += rate->idx + rate_table->mcs_start;

	if ((rate->flags & IEEE80211_TX_RC_40_MHZ_WIDTH) &&
	    (rate->flags & IEEE80211_TX_RC_SHORT_GI))
		rix = rate_table->info[rix].ht_index;
	else if (rate->flags & IEEE80211_TX_RC_SHORT_GI)
		rix = rate_table->info[rix].sgi_index;
	else if (rate->flags & IEEE80211_TX_RC_40_MHZ_WIDTH)
		rix = rate_table->info[rix].cw40index;

	return rix;
}
407

408
static void ath_rc_sort_validrates(const struct ath_rate_table *rate_table,
S
Sujith 已提交
409
				   struct ath_rate_priv *ath_rc_priv)
410 411 412
{
	u8 i, j, idx, idx_next;

413
	for (i = ath_rc_priv->max_valid_rate - 1; i > 0; i--) {
414
		for (j = 0; j <= i-1; j++) {
415 416
			idx = ath_rc_priv->valid_rate_index[j];
			idx_next = ath_rc_priv->valid_rate_index[j+1];
417 418 419

			if (rate_table->info[idx].ratekbps >
				rate_table->info[idx_next].ratekbps) {
420 421
				ath_rc_priv->valid_rate_index[j] = idx_next;
				ath_rc_priv->valid_rate_index[j+1] = idx;
422 423 424 425 426
			}
		}
	}
}

427
static void ath_rc_init_valid_rate_idx(struct ath_rate_priv *ath_rc_priv)
428 429 430
{
	u8 i;

431
	for (i = 0; i < ath_rc_priv->rate_table_size; i++)
S
Sujith 已提交
432
		ath_rc_priv->valid_rate_index[i] = 0;
433 434
}

435
static inline void ath_rc_set_valid_rate_idx(struct ath_rate_priv *ath_rc_priv,
436 437
					   u8 index, int valid_tx_rate)
{
438
	BUG_ON(index > ath_rc_priv->rate_table_size);
439
	ath_rc_priv->valid_rate_index[index] = !!valid_tx_rate;
440 441
}

442 443 444 445 446
static inline
int ath_rc_get_nextvalid_txrate(const struct ath_rate_table *rate_table,
				struct ath_rate_priv *ath_rc_priv,
				u8 cur_valid_txrate,
				u8 *next_idx)
447 448 449
{
	u8 i;

450 451 452
	for (i = 0; i < ath_rc_priv->max_valid_rate - 1; i++) {
		if (ath_rc_priv->valid_rate_index[i] == cur_valid_txrate) {
			*next_idx = ath_rc_priv->valid_rate_index[i+1];
S
Sujith 已提交
453
			return 1;
454 455 456 457 458
		}
	}

	/* No more valid rates */
	*next_idx = 0;
S
Sujith 已提交
459

S
Sujith 已提交
460
	return 0;
461 462 463 464 465 466
}

/* Return true only for single stream */

static int ath_rc_valid_phyrate(u32 phy, u32 capflag, int ignore_cw)
{
467
	if (WLAN_RC_PHY_HT(phy) && !(capflag & WLAN_RC_HT_FLAG))
S
Sujith 已提交
468
		return 0;
469
	if (WLAN_RC_PHY_DS(phy) && !(capflag & WLAN_RC_DS_FLAG))
S
Sujith 已提交
470
		return 0;
471 472
	if (WLAN_RC_PHY_TS(phy) && !(capflag & WLAN_RC_TS_FLAG))
		return 0;
473
	if (WLAN_RC_PHY_SGI(phy) && !(capflag & WLAN_RC_SGI_FLAG))
S
Sujith 已提交
474
		return 0;
475 476
	if (!ignore_cw && WLAN_RC_PHY_HT(phy))
		if (WLAN_RC_PHY_40(phy) && !(capflag & WLAN_RC_40_FLAG))
S
Sujith 已提交
477 478
			return 0;
	return 1;
479 480 481
}

static inline int
482 483 484
ath_rc_get_lower_rix(const struct ath_rate_table *rate_table,
		     struct ath_rate_priv *ath_rc_priv,
		     u8 cur_valid_txrate, u8 *next_idx)
485 486 487
{
	int8_t i;

488 489 490
	for (i = 1; i < ath_rc_priv->max_valid_rate ; i++) {
		if (ath_rc_priv->valid_rate_index[i] == cur_valid_txrate) {
			*next_idx = ath_rc_priv->valid_rate_index[i-1];
S
Sujith 已提交
491
			return 1;
492 493
		}
	}
S
Sujith 已提交
494

S
Sujith 已提交
495
	return 0;
496 497
}

S
Sujith 已提交
498
static u8 ath_rc_init_validrates(struct ath_rate_priv *ath_rc_priv,
499
				 const struct ath_rate_table *rate_table,
S
Sujith 已提交
500
				 u32 capflag)
501 502 503 504
{
	u8 i, hi = 0;

	for (i = 0; i < rate_table->rate_cnt; i++) {
505
		if (rate_table->info[i].rate_flags & RC_LEGACY) {
506 507 508
			u32 phy = rate_table->info[i].phy;
			u8 valid_rate_count = 0;

S
Sujith 已提交
509
			if (!ath_rc_valid_phyrate(phy, capflag, 0))
510 511
				continue;

512
			valid_rate_count = ath_rc_priv->valid_phy_ratecnt[phy];
513

514 515
			ath_rc_priv->valid_phy_rateidx[phy][valid_rate_count] = i;
			ath_rc_priv->valid_phy_ratecnt[phy] += 1;
516
			ath_rc_set_valid_rate_idx(ath_rc_priv, i, 1);
517
			hi = i;
518 519
		}
	}
S
Sujith 已提交
520

521 522 523
	return hi;
}

S
Sujith 已提交
524
static u8 ath_rc_setvalid_rates(struct ath_rate_priv *ath_rc_priv,
525
				const struct ath_rate_table *rate_table,
S
Sujith 已提交
526 527
				struct ath_rateset *rateset,
				u32 capflag)
528 529 530 531 532 533 534
{
	u8 i, j, hi = 0;

	/* Use intersection of working rates and valid rates */
	for (i = 0; i < rateset->rs_nrates; i++) {
		for (j = 0; j < rate_table->rate_cnt; j++) {
			u32 phy = rate_table->info[j].phy;
535
			u16 rate_flags = rate_table->info[j].rate_flags;
S
Sujith 已提交
536 537
			u8 rate = rateset->rs_rates[i];
			u8 dot11rate = rate_table->info[j].dot11rate;
538 539 540

			/* We allow a rate only if its valid and the
			 * capflag matches one of the validity
S
Sujith 已提交
541
			 * (VALID/VALID_20/VALID_40) flags */
542

543
			if ((rate == dot11rate) &&
544 545 546
			    (rate_flags & WLAN_RC_CAP_MODE(capflag)) ==
			    WLAN_RC_CAP_MODE(capflag) &&
			    (rate_flags & WLAN_RC_CAP_STREAM(capflag)) &&
S
Sujith 已提交
547
			    !WLAN_RC_PHY_HT(phy)) {
548 549
				u8 valid_rate_count = 0;

S
Sujith 已提交
550
				if (!ath_rc_valid_phyrate(phy, capflag, 0))
551 552 553
					continue;

				valid_rate_count =
554
					ath_rc_priv->valid_phy_ratecnt[phy];
555

556
				ath_rc_priv->valid_phy_rateidx[phy]
557
					[valid_rate_count] = j;
558
				ath_rc_priv->valid_phy_ratecnt[phy] += 1;
559
				ath_rc_set_valid_rate_idx(ath_rc_priv, j, 1);
560
				hi = max(hi, j);
561 562 563
			}
		}
	}
S
Sujith 已提交
564

565 566 567
	return hi;
}

S
Sujith 已提交
568
static u8 ath_rc_setvalid_htrates(struct ath_rate_priv *ath_rc_priv,
569
				  const struct ath_rate_table *rate_table,
S
Sujith 已提交
570
				  u8 *mcs_set, u32 capflag)
571
{
S
Sujith 已提交
572 573
	struct ath_rateset *rateset = (struct ath_rateset *)mcs_set;

574 575 576
	u8 i, j, hi = 0;

	/* Use intersection of working rates and valid rates */
S
Sujith 已提交
577
	for (i = 0; i < rateset->rs_nrates; i++) {
578 579
		for (j = 0; j < rate_table->rate_cnt; j++) {
			u32 phy = rate_table->info[j].phy;
580
			u16 rate_flags = rate_table->info[j].rate_flags;
S
Sujith 已提交
581 582
			u8 rate = rateset->rs_rates[i];
			u8 dot11rate = rate_table->info[j].dot11rate;
583

584
			if ((rate != dot11rate) || !WLAN_RC_PHY_HT(phy) ||
585 586
			    !(rate_flags & WLAN_RC_CAP_STREAM(capflag)) ||
			    !WLAN_RC_PHY_HT_VALID(rate_flags, capflag))
587 588
				continue;

S
Sujith 已提交
589
			if (!ath_rc_valid_phyrate(phy, capflag, 0))
590 591
				continue;

592 593 594
			ath_rc_priv->valid_phy_rateidx[phy]
				[ath_rc_priv->valid_phy_ratecnt[phy]] = j;
			ath_rc_priv->valid_phy_ratecnt[phy] += 1;
595
			ath_rc_set_valid_rate_idx(ath_rc_priv, j, 1);
596
			hi = max(hi, j);
597 598 599
		}
	}

S
Sujith 已提交
600
	return hi;
601 602
}

603 604 605 606
/* Finds the highest rate index we can use */
static u8 ath_rc_get_highest_rix(struct ath_softc *sc,
			         struct ath_rate_priv *ath_rc_priv,
				 const struct ath_rate_table *rate_table,
607 608
				 int *is_probing,
				 bool legacy)
609
{
610
	u32 best_thruput, this_thruput, now_msec;
611
	u8 rate, next_rate, best_rate, maxindex, minindex;
612
	int8_t index = 0;
613 614

	now_msec = jiffies_to_msecs(jiffies);
615
	*is_probing = 0;
616
	best_thruput = 0;
617
	maxindex = ath_rc_priv->max_valid_rate-1;
618 619 620 621 622 623 624 625 626 627
	minindex = 0;
	best_rate = minindex;

	/*
	 * Try the higher rate first. It will reduce memory moving time
	 * if we have very good channel characteristics.
	 */
	for (index = maxindex; index >= minindex ; index--) {
		u8 per_thres;

628
		rate = ath_rc_priv->valid_rate_index[index];
629 630
		if (legacy && !(rate_table->info[rate].rate_flags & RC_LEGACY))
			continue;
631
		if (rate > ath_rc_priv->rate_max_phy)
632 633 634 635 636 637 638 639 640 641 642 643 644
			continue;

		/*
		 * For TCP the average collision rate is around 11%,
		 * so we ignore PERs less than this.  This is to
		 * prevent the rate we are currently using (whose
		 * PER might be in the 10-15 range because of TCP
		 * collisions) looking worse than the next lower
		 * rate whose PER has decayed close to 0.  If we
		 * used to next lower rate, its PER would grow to
		 * 10-15 and we would be worse off then staying
		 * at the current rate.
		 */
645
		per_thres = ath_rc_priv->per[rate];
646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664
		if (per_thres < 12)
			per_thres = 12;

		this_thruput = rate_table->info[rate].user_ratekbps *
			(100 - per_thres);

		if (best_thruput <= this_thruput) {
			best_thruput = this_thruput;
			best_rate    = rate;
		}
	}

	rate = best_rate;

	/*
	 * Must check the actual rate (ratekbps) to account for
	 * non-monoticity of 11g's rate table
	 */

665
	if (rate >= ath_rc_priv->rate_max_phy) {
666
		rate = ath_rc_priv->rate_max_phy;
667 668 669

		/* Probe the next allowed phy state */
		if (ath_rc_get_nextvalid_txrate(rate_table,
670
					ath_rc_priv, rate, &next_rate) &&
671
		    (now_msec - ath_rc_priv->probe_time >
672
		     rate_table->probe_interval) &&
673
		    (ath_rc_priv->hw_maxretry_pktcnt >= 1)) {
674
			rate = next_rate;
675 676 677
			ath_rc_priv->probe_rate = rate;
			ath_rc_priv->probe_time = now_msec;
			ath_rc_priv->hw_maxretry_pktcnt = 0;
S
Sujith 已提交
678
			*is_probing = 1;
679 680 681
		}
	}

682 683
	if (rate > (ath_rc_priv->rate_table_size - 1))
		rate = ath_rc_priv->rate_table_size - 1;
684

685 686 687 688 689 690
	if (RC_TS_ONLY(rate_table->info[rate].rate_flags) &&
	    (ath_rc_priv->ht_cap & WLAN_RC_TS_FLAG))
		return rate;

	if (RC_DS_OR_LATER(rate_table->info[rate].rate_flags) &&
	    (ath_rc_priv->ht_cap & (WLAN_RC_DS_FLAG | WLAN_RC_TS_FLAG)))
691 692
		return rate;

693
	if (RC_SS_OR_LEGACY(rate_table->info[rate].rate_flags))
694 695 696 697 698 699
		return rate;

	/* This should not happen */
	WARN_ON(1);

	rate = ath_rc_priv->valid_rate_index[0];
700 701 702 703

	return rate;
}

704
static void ath_rc_rate_set_series(const struct ath_rate_table *rate_table,
S
Sujith 已提交
705
				   struct ieee80211_tx_rate *rate,
706
				   struct ieee80211_tx_rate_control *txrc,
S
Sujith 已提交
707
				   u8 tries, u8 rix, int rtsctsenable)
708
{
S
Sujith 已提交
709
	rate->count = tries;
710
	rate->idx = rate_table->info[rix].ratecode;
S
Sujith 已提交
711

712 713 714
	if (txrc->short_preamble)
		rate->flags |= IEEE80211_TX_RC_USE_SHORT_PREAMBLE;
	if (txrc->rts || rtsctsenable)
S
Sujith 已提交
715
		rate->flags |= IEEE80211_TX_RC_USE_RTS_CTS;
716 717

	if (WLAN_RC_PHY_HT(rate_table->info[rix].phy)) {
S
Sujith 已提交
718
		rate->flags |= IEEE80211_TX_RC_MCS;
719 720
		if (WLAN_RC_PHY_40(rate_table->info[rix].phy) &&
		    conf_is_ht40(&txrc->hw->conf))
721 722 723 724
			rate->flags |= IEEE80211_TX_RC_40_MHZ_WIDTH;
		if (WLAN_RC_PHY_SGI(rate_table->info[rix].phy))
			rate->flags |= IEEE80211_TX_RC_SHORT_GI;
	}
725 726
}

727
static void ath_rc_rate_set_rtscts(struct ath_softc *sc,
728
				   const struct ath_rate_table *rate_table,
729 730 731 732 733 734 735 736
				   struct ieee80211_tx_info *tx_info)
{
	struct ieee80211_tx_rate *rates = tx_info->control.rates;
	int i = 0, rix = 0, cix, enable_g_protection = 0;

	/* get the cix for the lowest valid rix */
	for (i = 3; i >= 0; i--) {
		if (rates[i].count && (rates[i].idx >= 0)) {
737
			rix = ath_rc_get_rateindex(rate_table, &rates[i]);
738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762
			break;
		}
	}
	cix = rate_table->info[rix].ctrl_rate;

	/* All protection frames are transmited at 2Mb/s for 802.11g,
	 * otherwise we transmit them at 1Mb/s */
	if (sc->hw->conf.channel->band == IEEE80211_BAND_2GHZ &&
	    !conf_is_ht(&sc->hw->conf))
		enable_g_protection = 1;

	/*
	 * If 802.11g protection is enabled, determine whether to use RTS/CTS or
	 * just CTS.  Note that this is only done for OFDM/HT unicast frames.
	 */
	if ((sc->sc_flags & SC_OP_PROTECT_ENABLE) &&
	    (rate_table->info[rix].phy == WLAN_RC_PHY_OFDM ||
	     WLAN_RC_PHY_HT(rate_table->info[rix].phy))) {
		rates[0].flags |= IEEE80211_TX_RC_USE_CTS_PROTECT;
		cix = rate_table->info[enable_g_protection].ctrl_rate;
	}

	tx_info->control.rts_cts_rate_idx = cix;
}

763 764
static void ath_get_rate(void *priv, struct ieee80211_sta *sta, void *priv_sta,
			 struct ieee80211_tx_rate_control *txrc)
765
{
766 767
	struct ath_softc *sc = priv;
	struct ath_rate_priv *ath_rc_priv = priv_sta;
768
	const struct ath_rate_table *rate_table;
769 770
	struct sk_buff *skb = txrc->skb;
	struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb);
S
Sujith 已提交
771
	struct ieee80211_tx_rate *rates = tx_info->control.rates;
772 773
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
	__le16 fc = hdr->frame_control;
774
	u8 try_per_rate, i = 0, rix, high_rix;
775
	int is_probe = 0;
776

777 778 779
	if (rate_control_send_low(sta, priv_sta, txrc))
		return;

780 781 782 783
	/*
	 * For Multi Rate Retry we use a different number of
	 * retry attempt counts. This ends up looking like this:
	 *
784 785 786 787
	 * MRR[0] = 4
	 * MRR[1] = 4
	 * MRR[2] = 4
	 * MRR[3] = 8
788 789
	 *
	 */
790
	try_per_rate = 4;
791

792
	rate_table = ath_rc_priv->rate_table;
793 794 795
	rix = ath_rc_get_highest_rix(sc, ath_rc_priv, rate_table,
				     &is_probe, false);
	high_rix = rix;
796

797 798 799 800 801 802 803 804 805
	/*
	 * If we're in HT mode and both us and our peer supports LDPC.
	 * We don't need to check our own device's capabilities as our own
	 * ht capabilities would have already been intersected with our peer's.
	 */
	if (conf_is_ht(&sc->hw->conf) &&
	    (sta->ht_cap.cap & IEEE80211_HT_CAP_LDPC_CODING))
		tx_info->flags |= IEEE80211_TX_CTL_LDPC;

806 807 808 809
	if (conf_is_ht(&sc->hw->conf) &&
	    (sta->ht_cap.cap & IEEE80211_HT_CAP_TX_STBC))
		tx_info->flags |= (1 << IEEE80211_TX_CTL_STBC_SHIFT);

810
	if (is_probe) {
811 812
		/* set one try for probe rates. For the
		 * probes don't enable rts */
813
		ath_rc_rate_set_series(rate_table, &rates[i++], txrc,
814
				       1, rix, 0);
815 816 817 818

		/* Get the next tried/allowed rate. No RTS for the next series
		 * after the probe rate
		 */
819
		ath_rc_get_lower_rix(rate_table, ath_rc_priv, rix, &rix);
820
		ath_rc_rate_set_series(rate_table, &rates[i++], txrc,
821
				       try_per_rate, rix, 0);
822 823

		tx_info->flags |= IEEE80211_TX_CTL_RATE_CTRL_PROBE;
824
	} else {
L
Lucas De Marchi 已提交
825
		/* Set the chosen rate. No RTS for first series entry. */
826
		ath_rc_rate_set_series(rate_table, &rates[i++], txrc,
827
				       try_per_rate, rix, 0);
828 829 830
	}

	/* Fill in the other rates for multirate retry */
831
	for ( ; i < 3; i++) {
832

833
		ath_rc_get_lower_rix(rate_table, ath_rc_priv, rix, &rix);
834
		/* All other rates in the series have RTS enabled */
835
		ath_rc_rate_set_series(rate_table, &rates[i], txrc,
836
				       try_per_rate, rix, 1);
837 838
	}

839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856
	/* Use twice the number of tries for the last MRR segment. */
	try_per_rate = 8;

	/*
	 * Use a legacy rate as last retry to ensure that the frame
	 * is tried in both MCS and legacy rates.
	 */
	if ((rates[2].flags & IEEE80211_TX_RC_MCS) &&
	    (!(tx_info->flags & IEEE80211_TX_CTL_AMPDU) ||
	    (ath_rc_priv->per[high_rix] > 45)))
		rix = ath_rc_get_highest_rix(sc, ath_rc_priv, rate_table,
				&is_probe, true);
	else
		ath_rc_get_lower_rix(rate_table, ath_rc_priv, rix, &rix);

	/* All other rates in the series have RTS enabled */
	ath_rc_rate_set_series(rate_table, &rates[i], txrc,
			       try_per_rate, rix, 1);
857 858 859 860 861 862 863 864 865 866 867 868 869 870 871
	/*
	 * NB:Change rate series to enable aggregation when operating
	 * at lower MCS rates. When first rate in series is MCS2
	 * in HT40 @ 2.4GHz, series should look like:
	 *
	 * {MCS2, MCS1, MCS0, MCS0}.
	 *
	 * When first rate in series is MCS3 in HT20 @ 2.4GHz, series should
	 * look like:
	 *
	 * {MCS3, MCS2, MCS1, MCS1}
	 *
	 * So, set fourth rate in series to be same as third one for
	 * above conditions.
	 */
872
	if ((sc->hw->conf.channel->band == IEEE80211_BAND_2GHZ) &&
873
	    (conf_is_ht(&sc->hw->conf))) {
874
		u8 dot11rate = rate_table->info[rix].dot11rate;
875 876 877
		u8 phy = rate_table->info[rix].phy;
		if (i == 4 &&
		    ((dot11rate == 2 && phy == WLAN_RC_PHY_HT_40_SS) ||
S
Sujith 已提交
878
		     (dot11rate == 3 && phy == WLAN_RC_PHY_HT_20_SS))) {
S
Sujith 已提交
879 880
			rates[3].idx = rates[2].idx;
			rates[3].flags = rates[2].flags;
881 882
		}
	}
883 884 885 886 887 888 889 890

	/*
	 * Force hardware to use computed duration for next
	 * fragment by disabling multi-rate retry, which
	 * updates duration based on the multi-rate duration table.
	 *
	 * FIXME: Fix duration
	 */
891 892
	if (ieee80211_has_morefrags(fc) ||
	    (le16_to_cpu(hdr->seq_ctrl) & IEEE80211_SCTL_FRAG)) {
893 894 895 896 897 898 899
		rates[1].count = rates[2].count = rates[3].count = 0;
		rates[1].idx = rates[2].idx = rates[3].idx = 0;
		rates[0].count = ATH_TXMAXTRY;
	}

	/* Setup RTS/CTS */
	ath_rc_rate_set_rtscts(sc, rate_table, tx_info);
900 901
}

902
static void ath_rc_update_per(struct ath_softc *sc,
903
			      const struct ath_rate_table *rate_table,
S
Sujith 已提交
904
			      struct ath_rate_priv *ath_rc_priv,
905
				  struct ieee80211_tx_info *tx_info,
S
Sujith 已提交
906 907
			      int tx_rate, int xretries, int retries,
			      u32 now_msec)
908
{
909
	int count, n_bad_frames;
910
	u8 last_per;
J
Joe Perches 已提交
911
	static const u32 nretry_to_per_lookup[10] = {
912 913 914 915 916 917 918 919 920 921 922 923
		100 * 0 / 1,
		100 * 1 / 4,
		100 * 1 / 2,
		100 * 3 / 4,
		100 * 4 / 5,
		100 * 5 / 6,
		100 * 6 / 7,
		100 * 7 / 8,
		100 * 8 / 9,
		100 * 9 / 10
	};

924
	last_per = ath_rc_priv->per[tx_rate];
925
	n_bad_frames = tx_info->status.ampdu_len - tx_info->status.ampdu_ack_len;
926 927 928

	if (xretries) {
		if (xretries == 1) {
929 930 931
			ath_rc_priv->per[tx_rate] += 30;
			if (ath_rc_priv->per[tx_rate] > 100)
				ath_rc_priv->per[tx_rate] = 100;
932 933
		} else {
			/* xretries == 2 */
934
			count = ARRAY_SIZE(nretry_to_per_lookup);
935 936
			if (retries >= count)
				retries = count - 1;
S
Sujith 已提交
937

938
			/* new_PER = 7/8*old_PER + 1/8*(currentPER) */
939
			ath_rc_priv->per[tx_rate] =
S
Sujith 已提交
940
				(u8)(last_per - (last_per >> 3) + (100 >> 3));
941 942 943 944
		}

		/* xretries == 1 or 2 */

945 946
		if (ath_rc_priv->probe_rate == tx_rate)
			ath_rc_priv->probe_rate = 0;
947

S
Sujith 已提交
948
	} else { /* xretries == 0 */
949
		count = ARRAY_SIZE(nretry_to_per_lookup);
950 951
		if (retries >= count)
			retries = count - 1;
S
Sujith 已提交
952

953
		if (n_bad_frames) {
S
Sujith 已提交
954
			/* new_PER = 7/8*old_PER + 1/8*(currentPER)
955 956 957 958 959 960 961 962 963 964 965
			 * Assuming that n_frames is not 0.  The current PER
			 * from the retries is 100 * retries / (retries+1),
			 * since the first retries attempts failed, and the
			 * next one worked.  For the one that worked,
			 * n_bad_frames subframes out of n_frames wored,
			 * so the PER for that part is
			 * 100 * n_bad_frames / n_frames, and it contributes
			 * 100 * n_bad_frames / (n_frames * (retries+1)) to
			 * the above PER.  The expression below is a
			 * simplified version of the sum of these two terms.
			 */
966 967
			if (tx_info->status.ampdu_len > 0) {
				int n_frames, n_bad_tries;
S
Sujith 已提交
968 969
				u8 cur_per, new_per;

970 971 972 973
				n_bad_tries = retries * tx_info->status.ampdu_len +
					n_bad_frames;
				n_frames = tx_info->status.ampdu_len * (retries + 1);
				cur_per = (100 * n_bad_tries / n_frames) >> 3;
S
Sujith 已提交
974
				new_per = (u8)(last_per - (last_per >> 3) + cur_per);
975
				ath_rc_priv->per[tx_rate] = new_per;
S
Sujith 已提交
976
			}
977
		} else {
978
			ath_rc_priv->per[tx_rate] =
S
Sujith 已提交
979 980
				(u8)(last_per - (last_per >> 3) +
				     (nretry_to_per_lookup[retries] >> 3));
981 982 983 984 985 986 987
		}


		/*
		 * If we got at most one retry then increase the max rate if
		 * this was a probe.  Otherwise, ignore the probe.
		 */
988
		if (ath_rc_priv->probe_rate && ath_rc_priv->probe_rate == tx_rate) {
989
			if (retries > 0 || 2 * n_bad_frames > tx_info->status.ampdu_len) {
990 991 992 993 994 995 996
				/*
				 * Since we probed with just a single attempt,
				 * any retries means the probe failed.  Also,
				 * if the attempt worked, but more than half
				 * the subframes were bad then also consider
				 * the probe a failure.
				 */
997
				ath_rc_priv->probe_rate = 0;
998 999 1000
			} else {
				u8 probe_rate = 0;

S
Sujith 已提交
1001 1002
				ath_rc_priv->rate_max_phy =
					ath_rc_priv->probe_rate;
1003
				probe_rate = ath_rc_priv->probe_rate;
1004

1005 1006
				if (ath_rc_priv->per[probe_rate] > 30)
					ath_rc_priv->per[probe_rate] = 20;
1007

1008
				ath_rc_priv->probe_rate = 0;
1009 1010 1011 1012 1013

				/*
				 * Since this probe succeeded, we allow the next
				 * probe twice as soon.  This allows the maxRate
				 * to move up faster if the probes are
1014
				 * successful.
1015
				 */
S
Sujith 已提交
1016 1017
				ath_rc_priv->probe_time =
					now_msec - rate_table->probe_interval / 2;
1018 1019 1020 1021 1022 1023 1024 1025
			}
		}

		if (retries > 0) {
			/*
			 * Don't update anything.  We don't know if
			 * this was because of collisions or poor signal.
			 */
1026
			ath_rc_priv->hw_maxretry_pktcnt = 0;
1027 1028 1029 1030 1031
		} else {
			/*
			 * It worked with no retries. First ignore bogus (small)
			 * rssi_ack values.
			 */
1032 1033 1034
			if (tx_rate == ath_rc_priv->rate_max_phy &&
			    ath_rc_priv->hw_maxretry_pktcnt < 255) {
				ath_rc_priv->hw_maxretry_pktcnt++;
1035 1036 1037 1038
			}

		}
	}
S
Sujith 已提交
1039 1040
}

1041 1042 1043 1044 1045 1046 1047 1048 1049 1050
static void ath_debug_stat_retries(struct ath_rate_priv *rc, int rix,
				   int xretries, int retries, u8 per)
{
	struct ath_rc_stats *stats = &rc->rcstats[rix];

	stats->xretries += xretries;
	stats->retries += retries;
	stats->per = per;
}

S
Sujith 已提交
1051 1052 1053 1054 1055
/* Update PER, RSSI and whatever else that the code thinks it is doing.
   If you can make sense of all this, you really need to go out more. */

static void ath_rc_update_ht(struct ath_softc *sc,
			     struct ath_rate_priv *ath_rc_priv,
1056
			     struct ieee80211_tx_info *tx_info,
S
Sujith 已提交
1057 1058 1059 1060 1061
			     int tx_rate, int xretries, int retries)
{
	u32 now_msec = jiffies_to_msecs(jiffies);
	int rate;
	u8 last_per;
1062
	const struct ath_rate_table *rate_table = ath_rc_priv->rate_table;
S
Sujith 已提交
1063 1064 1065 1066
	int size = ath_rc_priv->rate_table_size;

	if ((tx_rate < 0) || (tx_rate > rate_table->rate_cnt))
		return;
1067

1068
	last_per = ath_rc_priv->per[tx_rate];
S
Sujith 已提交
1069 1070

	/* Update PER first */
1071 1072 1073
	ath_rc_update_per(sc, rate_table, ath_rc_priv,
			  tx_info, tx_rate, xretries,
			  retries, now_msec);
1074 1075 1076 1077 1078

	/*
	 * If this rate looks bad (high PER) then stop using it for
	 * a while (except if we are probing).
	 */
1079
	if (ath_rc_priv->per[tx_rate] >= 55 && tx_rate > 0 &&
S
Sujith 已提交
1080
	    rate_table->info[tx_rate].ratekbps <=
1081
	    rate_table->info[ath_rc_priv->rate_max_phy].ratekbps) {
1082 1083
		ath_rc_get_lower_rix(rate_table, ath_rc_priv,
				     (u8)tx_rate, &ath_rc_priv->rate_max_phy);
1084 1085

		/* Don't probe for a little while. */
1086
		ath_rc_priv->probe_time = now_msec;
1087 1088 1089 1090
	}

	/* Make sure the rates below this have lower PER */
	/* Monotonicity is kept only for rates below the current rate. */
1091
	if (ath_rc_priv->per[tx_rate] < last_per) {
1092 1093
		for (rate = tx_rate - 1; rate >= 0; rate--) {

1094 1095 1096 1097
			if (ath_rc_priv->per[rate] >
			    ath_rc_priv->per[rate+1]) {
				ath_rc_priv->per[rate] =
					ath_rc_priv->per[rate+1];
1098 1099 1100 1101 1102
			}
		}
	}

	/* Maintain monotonicity for rates above the current rate */
S
Sujith 已提交
1103
	for (rate = tx_rate; rate < size - 1; rate++) {
1104 1105 1106 1107
		if (ath_rc_priv->per[rate+1] <
		    ath_rc_priv->per[rate])
			ath_rc_priv->per[rate+1] =
				ath_rc_priv->per[rate];
1108 1109 1110 1111
	}

	/* Every so often, we reduce the thresholds
	 * and PER (different for CCK and OFDM). */
1112
	if (now_msec - ath_rc_priv->per_down_time >=
1113
	    rate_table->probe_interval) {
S
Sujith 已提交
1114
		for (rate = 0; rate < size; rate++) {
1115 1116
			ath_rc_priv->per[rate] =
				7 * ath_rc_priv->per[rate] / 8;
1117 1118
		}

1119
		ath_rc_priv->per_down_time = now_msec;
1120
	}
S
Sujith 已提交
1121

1122
	ath_debug_stat_retries(ath_rc_priv, tx_rate, xretries, retries,
1123
			       ath_rc_priv->per[tx_rate]);
1124

S
Sujith 已提交
1125 1126
}

1127

S
Sujith 已提交
1128 1129 1130 1131
static void ath_rc_tx_status(struct ath_softc *sc,
			     struct ath_rate_priv *ath_rc_priv,
			     struct ieee80211_tx_info *tx_info,
			     int final_ts_idx, int xretries, int long_retry)
1132
{
1133
	const struct ath_rate_table *rate_table;
S
Sujith 已提交
1134
	struct ieee80211_tx_rate *rates = tx_info->status.rates;
1135
	u8 flags;
S
Sujith 已提交
1136
	u32 i = 0, rix;
1137

1138
	rate_table = ath_rc_priv->rate_table;
1139 1140 1141 1142 1143 1144 1145

	/*
	 * If the first rate is not the final index, there
	 * are intermediate rate failures to be processed.
	 */
	if (final_ts_idx != 0) {
		/* Process intermediate rates that failed.*/
S
Sujith 已提交
1146 1147 1148 1149
		for (i = 0; i < final_ts_idx ; i++) {
			if (rates[i].count != 0 && (rates[i].idx >= 0)) {
				flags = rates[i].flags;

1150 1151
				/* If HT40 and we have switched mode from
				 * 40 to 20 => don't update */
S
Sujith 已提交
1152

S
Sujith 已提交
1153
				if ((flags & IEEE80211_TX_RC_40_MHZ_WIDTH) &&
1154
				    !(ath_rc_priv->ht_cap & WLAN_RC_40_FLAG))
1155
					return;
S
Sujith 已提交
1156

S
Sujith 已提交
1157
				rix = ath_rc_get_rateindex(rate_table, &rates[i]);
1158 1159
				ath_rc_update_ht(sc, ath_rc_priv, tx_info,
						rix, xretries ? 1 : 2,
S
Sujith 已提交
1160
						rates[i].count);
1161 1162 1163 1164 1165 1166 1167 1168 1169
			}
		}
	} else {
		/*
		 * Handle the special case of MIMO PS burst, where the second
		 * aggregate is sent out with only one rate and one try.
		 * Treating it as an excessive retry penalizes the rate
		 * inordinately.
		 */
S
Sujith 已提交
1170
		if (rates[0].count == 1 && xretries == 1)
1171 1172 1173
			xretries = 2;
	}

S
Sujith 已提交
1174 1175
	flags = rates[i].flags;

1176
	/* If HT40 and we have switched mode from 40 to 20 => don't update */
S
Sujith 已提交
1177
	if ((flags & IEEE80211_TX_RC_40_MHZ_WIDTH) &&
1178
	    !(ath_rc_priv->ht_cap & WLAN_RC_40_FLAG))
1179 1180
		return;

S
Sujith 已提交
1181
	rix = ath_rc_get_rateindex(rate_table, &rates[i]);
1182
	ath_rc_update_ht(sc, ath_rc_priv, tx_info, rix, xretries, long_retry);
1183 1184
}

1185 1186 1187
static const
struct ath_rate_table *ath_choose_rate_table(struct ath_softc *sc,
					     enum ieee80211_band band,
1188
					     bool is_ht)
1189
{
1190
	struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1191 1192 1193 1194

	switch(band) {
	case IEEE80211_BAND_2GHZ:
		if (is_ht)
1195 1196
			return &ar5416_11ng_ratetable;
		return &ar5416_11g_ratetable;
1197 1198
	case IEEE80211_BAND_5GHZ:
		if (is_ht)
1199 1200
			return &ar5416_11na_ratetable;
		return &ar5416_11a_ratetable;
1201
	default:
1202
		ath_dbg(common, ATH_DBG_CONFIG, "Invalid band\n");
1203 1204 1205 1206
		return NULL;
	}
}

1207
static void ath_rc_init(struct ath_softc *sc,
S
Sujith 已提交
1208
			struct ath_rate_priv *ath_rc_priv,
1209
			struct ieee80211_supported_band *sband,
1210
			struct ieee80211_sta *sta,
1211
			const struct ath_rate_table *rate_table)
1212
{
1213
	struct ath_rateset *rateset = &ath_rc_priv->neg_rates;
1214
	struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1215
	u8 *ht_mcs = (u8 *)&ath_rc_priv->neg_ht_rates;
1216 1217 1218 1219
	u8 i, j, k, hi = 0, hthi = 0;

	/* Initial rate table size. Will change depending
	 * on the working rate set */
S
Sujith 已提交
1220
	ath_rc_priv->rate_table_size = RATE_TABLE_SIZE;
1221 1222

	/* Initialize thresholds according to the global rate table */
1223
	for (i = 0 ; i < ath_rc_priv->rate_table_size; i++) {
1224
		ath_rc_priv->per[i] = 0;
1225 1226 1227
	}

	/* Determine the valid rates */
1228
	ath_rc_init_valid_rate_idx(ath_rc_priv);
1229 1230 1231

	for (i = 0; i < WLAN_RC_PHY_MAX; i++) {
		for (j = 0; j < MAX_TX_RATE_PHY; j++)
1232 1233
			ath_rc_priv->valid_phy_rateidx[i][j] = 0;
		ath_rc_priv->valid_phy_ratecnt[i] = 0;
1234 1235 1236 1237
	}

	if (!rateset->rs_nrates) {
		/* No working rate, just initialize valid rates */
S
Sujith 已提交
1238
		hi = ath_rc_init_validrates(ath_rc_priv, rate_table,
1239
					    ath_rc_priv->ht_cap);
1240 1241
	} else {
		/* Use intersection of working rates and valid rates */
S
Sujith 已提交
1242
		hi = ath_rc_setvalid_rates(ath_rc_priv, rate_table,
1243
					   rateset, ath_rc_priv->ht_cap);
1244
		if (ath_rc_priv->ht_cap & WLAN_RC_HT_FLAG) {
S
Sujith 已提交
1245
			hthi = ath_rc_setvalid_htrates(ath_rc_priv,
1246 1247 1248
						       rate_table,
						       ht_mcs,
						       ath_rc_priv->ht_cap);
1249
		}
1250
		hi = max(hi, hthi);
1251 1252
	}

1253 1254
	ath_rc_priv->rate_table_size = hi + 1;
	ath_rc_priv->rate_max_phy = 0;
1255
	BUG_ON(ath_rc_priv->rate_table_size > RATE_TABLE_SIZE);
1256 1257

	for (i = 0, k = 0; i < WLAN_RC_PHY_MAX; i++) {
1258 1259 1260
		for (j = 0; j < ath_rc_priv->valid_phy_ratecnt[i]; j++) {
			ath_rc_priv->valid_rate_index[k++] =
				ath_rc_priv->valid_phy_rateidx[i][j];
1261 1262
		}

S
Sujith 已提交
1263
		if (!ath_rc_valid_phyrate(i, rate_table->initial_ratemax, 1)
1264
		    || !ath_rc_priv->valid_phy_ratecnt[i])
1265 1266
			continue;

1267
		ath_rc_priv->rate_max_phy = ath_rc_priv->valid_phy_rateidx[i][j-1];
1268
	}
1269 1270
	BUG_ON(ath_rc_priv->rate_table_size > RATE_TABLE_SIZE);
	BUG_ON(k > RATE_TABLE_SIZE);
1271

1272 1273
	ath_rc_priv->max_valid_rate = k;
	ath_rc_sort_validrates(rate_table, ath_rc_priv);
1274 1275 1276
	ath_rc_priv->rate_max_phy = (k > 4) ?
					ath_rc_priv->valid_rate_index[k-4] :
					ath_rc_priv->valid_rate_index[k-1];
1277
	ath_rc_priv->rate_table = rate_table;
1278

1279 1280 1281
	ath_dbg(common, ATH_DBG_CONFIG,
		"RC Initialized with capabilities: 0x%x\n",
		ath_rc_priv->ht_cap);
1282 1283
}

1284
static u8 ath_rc_build_ht_caps(struct ath_softc *sc, struct ieee80211_sta *sta,
1285
			       bool is_cw40, bool is_sgi)
1286 1287 1288
{
	u8 caps = 0;

1289
	if (sta->ht_cap.ht_supported) {
1290
		caps = WLAN_RC_HT_FLAG;
1291 1292 1293
		if (sta->ht_cap.mcs.rx_mask[1] && sta->ht_cap.mcs.rx_mask[2])
			caps |= WLAN_RC_TS_FLAG | WLAN_RC_DS_FLAG;
		else if (sta->ht_cap.mcs.rx_mask[1])
1294
			caps |= WLAN_RC_DS_FLAG;
1295 1296
		if (is_cw40)
			caps |= WLAN_RC_40_FLAG;
1297
		if (is_sgi)
1298 1299 1300 1301 1302 1303
			caps |= WLAN_RC_SGI_FLAG;
	}

	return caps;
}

1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319
static bool ath_tx_aggr_check(struct ath_softc *sc, struct ath_node *an,
			      u8 tidno)
{
	struct ath_atx_tid *txtid;

	if (!(sc->sc_flags & SC_OP_TXAGGR))
		return false;

	txtid = ATH_AN_2_TID(an, tidno);

	if (!(txtid->state & (AGGR_ADDBA_COMPLETE | AGGR_ADDBA_PROGRESS)))
			return true;
	return false;
}


1320 1321 1322 1323
/***********************************/
/* mac80211 Rate Control callbacks */
/***********************************/

1324 1325 1326 1327 1328 1329 1330 1331 1332
static void ath_debug_stat_rc(struct ath_rate_priv *rc, int final_rate)
{
	struct ath_rc_stats *stats;

	stats = &rc->rcstats[final_rate];
	stats->success++;
}


1333 1334
static void ath_tx_status(void *priv, struct ieee80211_supported_band *sband,
			  struct ieee80211_sta *sta, void *priv_sta,
1335 1336 1337
			  struct sk_buff *skb)
{
	struct ath_softc *sc = priv;
S
Sujith 已提交
1338
	struct ath_rate_priv *ath_rc_priv = priv_sta;
1339 1340
	struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb);
	struct ieee80211_hdr *hdr;
1341
	int final_ts_idx = 0, tx_status = 0;
1342
	int long_retry = 0;
1343
	__le16 fc;
1344
	int i;
1345 1346 1347

	hdr = (struct ieee80211_hdr *)skb->data;
	fc = hdr->frame_control;
1348
	for (i = 0; i < sc->hw->max_rates; i++) {
1349 1350 1351 1352 1353 1354 1355
		struct ieee80211_tx_rate *rate = &tx_info->status.rates[i];
		if (!rate->count)
			break;

		final_ts_idx = i;
		long_retry = rate->count - 1;
	}
1356

1357 1358 1359 1360 1361 1362
	if (!priv_sta || !ieee80211_is_data(fc))
		return;

	/* This packet was aggregated but doesn't carry status info */
	if ((tx_info->flags & IEEE80211_TX_CTL_AMPDU) &&
	    !(tx_info->flags & IEEE80211_TX_STAT_AMPDU))
1363
		return;
1364

1365 1366
	if (tx_info->flags & IEEE80211_TX_STAT_TX_FILTERED)
		return;
1367

1368
	if (!(tx_info->flags & IEEE80211_TX_STAT_ACK))
S
Sujith 已提交
1369 1370 1371
		tx_status = 1;

	ath_rc_tx_status(sc, ath_rc_priv, tx_info, final_ts_idx, tx_status,
1372
			 long_retry);
S
Sujith 已提交
1373

S
Sujith 已提交
1374
	/* Check if aggregation has to be enabled for this tid */
1375 1376
	if (conf_is_ht(&sc->hw->conf) &&
	    !(skb->protocol == cpu_to_be16(ETH_P_PAE))) {
1377 1378
		if (ieee80211_is_data_qos(fc) &&
		    skb_get_queue_mapping(skb) != IEEE80211_AC_VO) {
S
Sujith 已提交
1379 1380 1381 1382 1383 1384 1385 1386
			u8 *qc, tid;
			struct ath_node *an;

			qc = ieee80211_get_qos_ctl(hdr);
			tid = qc[0] & 0xf;
			an = (struct ath_node *)sta->drv_priv;

			if(ath_tx_aggr_check(sc, an, tid))
1387
				ieee80211_start_tx_ba_session(sta, tid, 0);
S
Sujith 已提交
1388 1389
		}
	}
1390

1391 1392 1393
	ath_debug_stat_rc(ath_rc_priv,
		ath_rc_get_rateindex(ath_rc_priv->rate_table,
			&tx_info->status.rates[final_ts_idx]));
1394 1395
}

1396 1397
static void ath_rate_init(void *priv, struct ieee80211_supported_band *sband,
                          struct ieee80211_sta *sta, void *priv_sta)
1398
{
1399
	struct ath_softc *sc = priv;
S
Sujith 已提交
1400
	struct ath_rate_priv *ath_rc_priv = priv_sta;
1401
	const struct ath_rate_table *rate_table;
1402
	bool is_cw40, is_sgi = false;
1403 1404
	int i, j = 0;

S
Sujith 已提交
1405 1406 1407 1408 1409 1410 1411 1412
	for (i = 0; i < sband->n_bitrates; i++) {
		if (sta->supp_rates[sband->band] & BIT(i)) {
			ath_rc_priv->neg_rates.rs_rates[j]
				= (sband->bitrates[i].bitrate * 2) / 10;
			j++;
		}
	}
	ath_rc_priv->neg_rates.rs_nrates = j;
1413

1414
	if (sta->ht_cap.ht_supported) {
S
Sujith 已提交
1415
		for (i = 0, j = 0; i < 77; i++) {
1416
			if (sta->ht_cap.mcs.rx_mask[i/8] & (1<<(i%8)))
S
Sujith 已提交
1417
				ath_rc_priv->neg_ht_rates.rs_rates[j++] = i;
1418 1419 1420
			if (j == ATH_RATE_MAX)
				break;
		}
S
Sujith 已提交
1421
		ath_rc_priv->neg_ht_rates.rs_nrates = j;
1422
	}
S
Sujith 已提交
1423

1424
	is_cw40 = !!(sta->ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40);
1425 1426

	if (is_cw40)
1427
		is_sgi = !!(sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_40);
1428
	else if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_SGI_20)
1429
		is_sgi = !!(sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_20);
1430 1431 1432

	/* Choose rate table first */

1433
	rate_table = ath_choose_rate_table(sc, sband->band,
1434
	                      sta->ht_cap.ht_supported);
1435

1436
	ath_rc_priv->ht_cap = ath_rc_build_ht_caps(sc, sta, is_cw40, is_sgi);
1437 1438 1439 1440 1441
	ath_rc_init(sc, priv_sta, sband, sta, rate_table);
}

static void ath_rate_update(void *priv, struct ieee80211_supported_band *sband,
			    struct ieee80211_sta *sta, void *priv_sta,
1442
			    u32 changed, enum nl80211_channel_type oper_chan_type)
1443 1444 1445
{
	struct ath_softc *sc = priv;
	struct ath_rate_priv *ath_rc_priv = priv_sta;
1446
	const struct ath_rate_table *rate_table = NULL;
1447
	bool oper_cw40 = false, oper_sgi;
1448 1449
	bool local_cw40 = !!(ath_rc_priv->ht_cap & WLAN_RC_40_FLAG);
	bool local_sgi = !!(ath_rc_priv->ht_cap & WLAN_RC_SGI_FLAG);
1450 1451 1452 1453 1454 1455 1456

	/* FIXME: Handle AP mode later when we support CWM */

	if (changed & IEEE80211_RC_HT_CHANGED) {
		if (sc->sc_ah->opmode != NL80211_IFTYPE_STATION)
			return;

1457 1458
		if (oper_chan_type == NL80211_CHAN_HT40MINUS ||
		    oper_chan_type == NL80211_CHAN_HT40PLUS)
1459 1460
			oper_cw40 = true;

1461 1462 1463 1464 1465 1466 1467 1468
		if (oper_cw40)
			oper_sgi = (sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_40) ?
				   true : false;
		else if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_SGI_20)
			oper_sgi = (sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_20) ?
				   true : false;
		else
			oper_sgi = false;
1469

1470
		if ((local_cw40 != oper_cw40) || (local_sgi != oper_sgi)) {
1471
			rate_table = ath_choose_rate_table(sc, sband->band,
1472
						   sta->ht_cap.ht_supported);
1473
			ath_rc_priv->ht_cap = ath_rc_build_ht_caps(sc, sta,
1474
						   oper_cw40, oper_sgi);
1475 1476
			ath_rc_init(sc, priv_sta, sband, sta, rate_table);

1477 1478 1479
			ath_dbg(ath9k_hw_common(sc->sc_ah), ATH_DBG_CONFIG,
				"Operating HT Bandwidth changed to: %d\n",
				sc->hw->conf.channel_type);
1480 1481
		}
	}
1482 1483
}

1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503
#ifdef CONFIG_ATH9K_DEBUGFS

static int ath9k_debugfs_open(struct inode *inode, struct file *file)
{
	file->private_data = inode->i_private;
	return 0;
}

static ssize_t read_file_rcstat(struct file *file, char __user *user_buf,
				size_t count, loff_t *ppos)
{
	struct ath_rate_priv *rc = file->private_data;
	char *buf;
	unsigned int len = 0, max;
	int i = 0;
	ssize_t retval;

	if (rc->rate_table == NULL)
		return 0;

1504
	max = 80 + rc->rate_table_size * 1024 + 1;
1505 1506 1507 1508 1509 1510 1511 1512 1513
	buf = kmalloc(max, GFP_KERNEL);
	if (buf == NULL)
		return -ENOMEM;

	len += sprintf(buf, "%6s %6s %6s "
		       "%10s %10s %10s %10s\n",
		       "HT", "MCS", "Rate",
		       "Success", "Retries", "XRetries", "PER");

1514
	for (i = 0; i < rc->rate_table_size; i++) {
1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571
		u32 ratekbps = rc->rate_table->info[i].ratekbps;
		struct ath_rc_stats *stats = &rc->rcstats[i];
		char mcs[5];
		char htmode[5];
		int used_mcs = 0, used_htmode = 0;

		if (WLAN_RC_PHY_HT(rc->rate_table->info[i].phy)) {
			used_mcs = snprintf(mcs, 5, "%d",
				rc->rate_table->info[i].ratecode);

			if (WLAN_RC_PHY_40(rc->rate_table->info[i].phy))
				used_htmode = snprintf(htmode, 5, "HT40");
			else if (WLAN_RC_PHY_20(rc->rate_table->info[i].phy))
				used_htmode = snprintf(htmode, 5, "HT20");
			else
				used_htmode = snprintf(htmode, 5, "????");
		}

		mcs[used_mcs] = '\0';
		htmode[used_htmode] = '\0';

		len += snprintf(buf + len, max - len,
			"%6s %6s %3u.%d: "
			"%10u %10u %10u %10u\n",
			htmode,
			mcs,
			ratekbps / 1000,
			(ratekbps % 1000) / 100,
			stats->success,
			stats->retries,
			stats->xretries,
			stats->per);
	}

	if (len > max)
		len = max;

	retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
	kfree(buf);
	return retval;
}

static const struct file_operations fops_rcstat = {
	.read = read_file_rcstat,
	.open = ath9k_debugfs_open,
	.owner = THIS_MODULE
};

static void ath_rate_add_sta_debugfs(void *priv, void *priv_sta,
				     struct dentry *dir)
{
	struct ath_rate_priv *rc = priv_sta;
	debugfs_create_file("rc_stats", S_IRUGO, dir, rc, &fops_rcstat);
}

#endif /* CONFIG_ATH9K_DEBUGFS */

1572
static void *ath_rate_alloc(struct ieee80211_hw *hw, struct dentry *debugfsdir)
1573
{
1574
	return hw->priv;
1575 1576 1577 1578 1579 1580 1581
}

static void ath_rate_free(void *priv)
{
	return;
}

1582
static void *ath_rate_alloc_sta(void *priv, struct ieee80211_sta *sta, gfp_t gfp)
1583 1584
{
	struct ath_softc *sc = priv;
S
Sujith 已提交
1585
	struct ath_rate_priv *rate_priv;
1586

S
Sujith 已提交
1587
	rate_priv = kzalloc(sizeof(struct ath_rate_priv), gfp);
1588
	if (!rate_priv) {
1589 1590
		ath_err(ath9k_hw_common(sc->sc_ah),
			"Unable to allocate private rc structure\n");
1591 1592
		return NULL;
	}
1593

1594 1595 1596
	return rate_priv;
}

1597 1598
static void ath_rate_free_sta(void *priv, struct ieee80211_sta *sta,
			      void *priv_sta)
1599
{
S
Sujith 已提交
1600
	struct ath_rate_priv *rate_priv = priv_sta;
1601
	kfree(rate_priv);
1602 1603 1604 1605 1606 1607 1608 1609
}

static struct rate_control_ops ath_rate_ops = {
	.module = NULL,
	.name = "ath9k_rate_control",
	.tx_status = ath_tx_status,
	.get_rate = ath_get_rate,
	.rate_init = ath_rate_init,
1610
	.rate_update = ath_rate_update,
1611 1612 1613
	.alloc = ath_rate_alloc,
	.free = ath_rate_free,
	.alloc_sta = ath_rate_alloc_sta,
1614
	.free_sta = ath_rate_free_sta,
1615 1616 1617
#ifdef CONFIG_ATH9K_DEBUGFS
	.add_sta_debugfs = ath_rate_add_sta_debugfs,
#endif
1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628
};

int ath_rate_control_register(void)
{
	return ieee80211_rate_control_register(&ath_rate_ops);
}

void ath_rate_control_unregister(void)
{
	ieee80211_rate_control_unregister(&ath_rate_ops);
}
新手
引导
客服 返回
顶部