1/* 2 * Copyright (c) 2004 Video54 Technologies, Inc. 3 * Copyright (c) 2004-2009 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 18#include <linux/slab.h> 19 20#include "ath9k.h" 21 22static const struct ath_rate_table ar5416_11na_ratetable = { 23 68, 24 8, /* MCS start */ 25 { 26 [0] = { RC_L_SDT, WLAN_RC_PHY_OFDM, 6000, 27 5400, 0, 12, 0, 0, 0, 0 }, /* 6 Mb */ 28 [1] = { RC_L_SDT, WLAN_RC_PHY_OFDM, 9000, 29 7800, 1, 18, 0, 1, 1, 1 }, /* 9 Mb */ 30 [2] = { RC_L_SDT, WLAN_RC_PHY_OFDM, 12000, 31 10000, 2, 24, 2, 2, 2, 2 }, /* 12 Mb */ 32 [3] = { RC_L_SDT, WLAN_RC_PHY_OFDM, 18000, 33 13900, 3, 36, 2, 3, 3, 3 }, /* 18 Mb */ 34 [4] = { RC_L_SDT, WLAN_RC_PHY_OFDM, 24000, 35 17300, 4, 48, 4, 4, 4, 4 }, /* 24 Mb */ 36 [5] = { RC_L_SDT, WLAN_RC_PHY_OFDM, 36000, 37 23000, 5, 72, 4, 5, 5, 5 }, /* 36 Mb */ 38 [6] = { RC_L_SDT, WLAN_RC_PHY_OFDM, 48000, 39 27400, 6, 96, 4, 6, 6, 6 }, /* 48 Mb */ 40 [7] = { RC_L_SDT, WLAN_RC_PHY_OFDM, 54000, 41 29300, 7, 108, 4, 7, 7, 7 }, /* 54 Mb */ 42 [8] = { RC_HT_SDT_2040, WLAN_RC_PHY_HT_20_SS, 6500, 43 6400, 0, 0, 0, 38, 8, 38 }, /* 6.5 Mb */ 44 [9] = { RC_HT_SDT_20, WLAN_RC_PHY_HT_20_SS, 13000, 45 12700, 1, 1, 2, 39, 9, 39 }, /* 13 Mb */ 46 [10] = { RC_HT_SDT_20, WLAN_RC_PHY_HT_20_SS, 19500, 47 18800, 2, 2, 2, 40, 10, 40 }, /* 19.5 Mb */ 48 [11] = { RC_HT_SD_20, WLAN_RC_PHY_HT_20_SS, 26000, 49 25000, 3, 3, 4, 41, 11, 41 }, /* 26 Mb */ 50 [12] = { RC_HT_SD_20, WLAN_RC_PHY_HT_20_SS, 39000, 51 36700, 4, 4, 4, 42, 12, 42 }, /* 39 Mb */ 52 [13] = { RC_HT_S_20, WLAN_RC_PHY_HT_20_SS, 52000, 53 48100, 5, 5, 4, 43, 13, 43 }, /* 52 Mb */ 54 [14] = { RC_HT_S_20, WLAN_RC_PHY_HT_20_SS, 58500, 55 53500, 6, 6, 4, 44, 14, 44 }, /* 58.5 Mb */ 56 [15] = { RC_HT_S_20, WLAN_RC_PHY_HT_20_SS, 65000, 57 59000, 7, 7, 4, 45, 16, 46 }, /* 65 Mb */ 58 [16] = { RC_HT_S_20, WLAN_RC_PHY_HT_20_SS_HGI, 72200, 59 65400, 7, 7, 4, 45, 16, 46 }, /* 75 Mb */ 60 [17] = { RC_INVALID, WLAN_RC_PHY_HT_20_DS, 13000, 61 12700, 8, 8, 0, 47, 17, 47 }, /* 13 Mb */ 62 [18] = { RC_HT_T_20, WLAN_RC_PHY_HT_20_DS, 26000, 63 24800, 9, 9, 2, 48, 18, 48 }, /* 26 Mb */ 64 [19] = { RC_HT_T_20, WLAN_RC_PHY_HT_20_DS, 39000, 65 36600, 10, 10, 2, 49, 19, 49 }, /* 39 Mb */ 66 [20] = { RC_HT_DT_20, WLAN_RC_PHY_HT_20_DS, 52000, 67 48100, 11, 11, 4, 50, 20, 50 }, /* 52 Mb */ 68 [21] = { RC_HT_DT_20, WLAN_RC_PHY_HT_20_DS, 78000, 69 69500, 12, 12, 4, 51, 21, 51 }, /* 78 Mb */ 70 [22] = { RC_HT_DT_20, WLAN_RC_PHY_HT_20_DS, 104000, 71 89500, 13, 13, 4, 52, 22, 52 }, /* 104 Mb */ 72 [23] = { RC_HT_DT_20, WLAN_RC_PHY_HT_20_DS, 117000, 73 98900, 14, 14, 4, 53, 23, 53 }, /* 117 Mb */ 74 [24] = { RC_HT_DT_20, WLAN_RC_PHY_HT_20_DS, 130000, 75 108300, 15, 15, 4, 54, 25, 55 }, /* 130 Mb */ 76 [25] = { RC_HT_DT_20, WLAN_RC_PHY_HT_20_DS_HGI, 144400, 77 120000, 15, 15, 4, 54, 25, 55 }, /* 144.4 Mb */ 78 [26] = { RC_INVALID, WLAN_RC_PHY_HT_20_TS, 19500, 79 17400, 16, 16, 0, 56, 26, 56 }, /* 19.5 Mb */ 80 [27] = { RC_INVALID, WLAN_RC_PHY_HT_20_TS, 39000, 81 35100, 17, 17, 2, 57, 27, 57 }, /* 39 Mb */ 82 [28] = { RC_INVALID, WLAN_RC_PHY_HT_20_TS, 58500, 83 52600, 18, 18, 2, 58, 28, 58 }, /* 58.5 Mb */ 84 [29] = { RC_INVALID, WLAN_RC_PHY_HT_20_TS, 78000, 85 70400, 19, 19, 4, 59, 29, 59 }, /* 78 Mb */ 86 [30] = { RC_INVALID, WLAN_RC_PHY_HT_20_TS, 117000, 87 104900, 20, 20, 4, 60, 31, 61 }, /* 117 Mb */ 88 [31] = { RC_INVALID, WLAN_RC_PHY_HT_20_TS_HGI, 130000, 89 115800, 20, 20, 4, 60, 31, 61 }, /* 130 Mb*/ 90 [32] = { RC_HT_T_20, WLAN_RC_PHY_HT_20_TS, 156000, 91 137200, 21, 21, 4, 62, 33, 63 }, /* 156 Mb */ 92 [33] = { RC_HT_T_20, WLAN_RC_PHY_HT_20_TS_HGI, 173300, 93 151100, 21, 21, 4, 62, 33, 63 }, /* 173.3 Mb */ 94 [34] = { RC_HT_T_20, WLAN_RC_PHY_HT_20_TS, 175500, 95 152800, 22, 22, 4, 64, 35, 65 }, /* 175.5 Mb */ 96 [35] = { RC_HT_T_20, WLAN_RC_PHY_HT_20_TS_HGI, 195000, 97 168400, 22, 22, 4, 64, 35, 65 }, /* 195 Mb*/ 98 [36] = { RC_HT_T_20, WLAN_RC_PHY_HT_20_TS, 195000, 99 168400, 23, 23, 4, 66, 37, 67 }, /* 195 Mb */ 100 [37] = { RC_HT_T_20, WLAN_RC_PHY_HT_20_TS_HGI, 216700, 101 185000, 23, 23, 4, 66, 37, 67 }, /* 216.7 Mb */ 102 [38] = { RC_HT_SDT_40, WLAN_RC_PHY_HT_40_SS, 13500, 103 13200, 0, 0, 0, 38, 38, 38 }, /* 13.5 Mb*/ 104 [39] = { RC_HT_SDT_40, WLAN_RC_PHY_HT_40_SS, 27500, 105 25900, 1, 1, 2, 39, 39, 39 }, /* 27.0 Mb*/ 106 [40] = { RC_HT_SDT_40, WLAN_RC_PHY_HT_40_SS, 40500, 107 38600, 2, 2, 2, 40, 40, 40 }, /* 40.5 Mb*/ 108 [41] = { RC_HT_SD_40, WLAN_RC_PHY_HT_40_SS, 54000, 109 49800, 3, 3, 4, 41, 41, 41 }, /* 54 Mb */ 110 [42] = { RC_HT_SD_40, WLAN_RC_PHY_HT_40_SS, 81500, 111 72200, 4, 4, 4, 42, 42, 42 }, /* 81 Mb */ 112 [43] = { RC_HT_S_40, WLAN_RC_PHY_HT_40_SS, 108000, 113 92900, 5, 5, 4, 43, 43, 43 }, /* 108 Mb */ 114 [44] = { RC_HT_S_40, WLAN_RC_PHY_HT_40_SS, 121500, 115 102700, 6, 6, 4, 44, 44, 44 }, /* 121.5 Mb*/ 116 [45] = { RC_HT_S_40, WLAN_RC_PHY_HT_40_SS, 135000, 117 112000, 7, 7, 4, 45, 46, 46 }, /* 135 Mb */ 118 [46] = { RC_HT_S_40, WLAN_RC_PHY_HT_40_SS_HGI, 150000, 119 122000, 7, 7, 4, 45, 46, 46 }, /* 150 Mb */ 120 [47] = { RC_INVALID, WLAN_RC_PHY_HT_40_DS, 27000, 121 25800, 8, 8, 0, 47, 47, 47 }, /* 27 Mb */ 122 [48] = { RC_HT_T_40, WLAN_RC_PHY_HT_40_DS, 54000, 123 49800, 9, 9, 2, 48, 48, 48 }, /* 54 Mb */ 124 [49] = { RC_HT_T_40, WLAN_RC_PHY_HT_40_DS, 81000, 125 71900, 10, 10, 2, 49, 49, 49 }, /* 81 Mb */ 126 [50] = { RC_HT_DT_40, WLAN_RC_PHY_HT_40_DS, 108000, 127 92500, 11, 11, 4, 50, 50, 50 }, /* 108 Mb */ 128 [51] = { RC_HT_DT_40, WLAN_RC_PHY_HT_40_DS, 162000, 129 130300, 12, 12, 4, 51, 51, 51 }, /* 162 Mb */ 130 [52] = { RC_HT_DT_40, WLAN_RC_PHY_HT_40_DS, 216000, 131 162800, 13, 13, 4, 52, 52, 52 }, /* 216 Mb */ 132 [53] = { RC_HT_DT_40, WLAN_RC_PHY_HT_40_DS, 243000, 133 178200, 14, 14, 4, 53, 53, 53 }, /* 243 Mb */ 134 [54] = { RC_HT_DT_40, WLAN_RC_PHY_HT_40_DS, 270000, 135 192100, 15, 15, 4, 54, 55, 55 }, /* 270 Mb */ 136 [55] = { RC_HT_DT_40, WLAN_RC_PHY_HT_40_DS_HGI, 300000, 137 207000, 15, 15, 4, 54, 55, 55 }, /* 300 Mb */ 138 [56] = { RC_INVALID, WLAN_RC_PHY_HT_40_TS, 40500, 139 36100, 16, 16, 0, 56, 56, 56 }, /* 40.5 Mb */ 140 [57] = { RC_INVALID, WLAN_RC_PHY_HT_40_TS, 81000, 141 72900, 17, 17, 2, 57, 57, 57 }, /* 81 Mb */ 142 [58] = { RC_INVALID, WLAN_RC_PHY_HT_40_TS, 121500, 143 108300, 18, 18, 2, 58, 58, 58 }, /* 121.5 Mb */ 144 [59] = { RC_INVALID, WLAN_RC_PHY_HT_40_TS, 162000, 145 142000, 19, 19, 4, 59, 59, 59 }, /* 162 Mb */ 146 [60] = { RC_INVALID, WLAN_RC_PHY_HT_40_TS, 243000, 147 205100, 20, 20, 4, 60, 61, 61 }, /* 243 Mb */ 148 [61] = { RC_INVALID, WLAN_RC_PHY_HT_40_TS_HGI, 270000, 149 224700, 20, 20, 4, 60, 61, 61 }, /* 270 Mb */ 150 [62] = { RC_HT_T_40, WLAN_RC_PHY_HT_40_TS, 324000, 151 263100, 21, 21, 4, 62, 63, 63 }, /* 324 Mb */ 152 [63] = { RC_HT_T_40, WLAN_RC_PHY_HT_40_TS_HGI, 360000, 153 288000, 21, 21, 4, 62, 63, 63 }, /* 360 Mb */ 154 [64] = { RC_HT_T_40, WLAN_RC_PHY_HT_40_TS, 364500, 155 290700, 22, 22, 4, 64, 65, 65 }, /* 364.5 Mb */ 156 [65] = { RC_HT_T_40, WLAN_RC_PHY_HT_40_TS_HGI, 405000, 157 317200, 22, 22, 4, 64, 65, 65 }, /* 405 Mb */ 158 [66] = { RC_HT_T_40, WLAN_RC_PHY_HT_40_TS, 405000, 159 317200, 23, 23, 4, 66, 67, 67 }, /* 405 Mb */ 160 [67] = { RC_HT_T_40, WLAN_RC_PHY_HT_40_TS_HGI, 450000, 161 346400, 23, 23, 4, 66, 67, 67 }, /* 450 Mb */ 162 }, 163 50, /* probe interval */ 164 WLAN_RC_HT_FLAG, /* Phy rates allowed initially */ 165}; 166 167/* 4ms frame limit not used for NG mode. The values filled 168 * for HT are the 64K max aggregate limit */ 169 170static const struct ath_rate_table ar5416_11ng_ratetable = { 171 72, 172 12, /* MCS start */ 173 { 174 [0] = { RC_ALL, WLAN_RC_PHY_CCK, 1000, 175 900, 0, 2, 0, 0, 0, 0 }, /* 1 Mb */ 176 [1] = { RC_ALL, WLAN_RC_PHY_CCK, 2000, 177 1900, 1, 4, 1, 1, 1, 1 }, /* 2 Mb */ 178 [2] = { RC_ALL, WLAN_RC_PHY_CCK, 5500, 179 4900, 2, 11, 2, 2, 2, 2 }, /* 5.5 Mb */ 180 [3] = { RC_ALL, WLAN_RC_PHY_CCK, 11000, 181 8100, 3, 22, 3, 3, 3, 3 }, /* 11 Mb */ 182 [4] = { RC_INVALID, WLAN_RC_PHY_OFDM, 6000, 183 5400, 4, 12, 4, 4, 4, 4 }, /* 6 Mb */ 184 [5] = { RC_INVALID, WLAN_RC_PHY_OFDM, 9000, 185 7800, 5, 18, 4, 5, 5, 5 }, /* 9 Mb */ 186 [6] = { RC_L_SDT, WLAN_RC_PHY_OFDM, 12000, 187 10100, 6, 24, 6, 6, 6, 6 }, /* 12 Mb */ 188 [7] = { RC_L_SDT, WLAN_RC_PHY_OFDM, 18000, 189 14100, 7, 36, 6, 7, 7, 7 }, /* 18 Mb */ 190 [8] = { RC_L_SDT, WLAN_RC_PHY_OFDM, 24000, 191 17700, 8, 48, 8, 8, 8, 8 }, /* 24 Mb */ 192 [9] = { RC_L_SDT, WLAN_RC_PHY_OFDM, 36000, 193 23700, 9, 72, 8, 9, 9, 9 }, /* 36 Mb */ 194 [10] = { RC_L_SDT, WLAN_RC_PHY_OFDM, 48000, 195 27400, 10, 96, 8, 10, 10, 10 }, /* 48 Mb */ 196 [11] = { RC_L_SDT, WLAN_RC_PHY_OFDM, 54000, 197 30900, 11, 108, 8, 11, 11, 11 }, /* 54 Mb */ 198 [12] = { RC_INVALID, WLAN_RC_PHY_HT_20_SS, 6500, 199 6400, 0, 0, 4, 42, 12, 42 }, /* 6.5 Mb */ 200 [13] = { RC_HT_SDT_20, WLAN_RC_PHY_HT_20_SS, 13000, 201 12700, 1, 1, 6, 43, 13, 43 }, /* 13 Mb */ 202 [14] = { RC_HT_SDT_20, WLAN_RC_PHY_HT_20_SS, 19500, 203 18800, 2, 2, 6, 44, 14, 44 }, /* 19.5 Mb*/ 204 [15] = { RC_HT_SD_20, WLAN_RC_PHY_HT_20_SS, 26000, 205 25000, 3, 3, 8, 45, 15, 45 }, /* 26 Mb */ 206 [16] = { RC_HT_SD_20, WLAN_RC_PHY_HT_20_SS, 39000, 207 36700, 4, 4, 8, 46, 16, 46 }, /* 39 Mb */ 208 [17] = { RC_HT_S_20, WLAN_RC_PHY_HT_20_SS, 52000, 209 48100, 5, 5, 8, 47, 17, 47 }, /* 52 Mb */ 210 [18] = { RC_HT_S_20, WLAN_RC_PHY_HT_20_SS, 58500, 211 53500, 6, 6, 8, 48, 18, 48 }, /* 58.5 Mb */ 212 [19] = { RC_HT_S_20, WLAN_RC_PHY_HT_20_SS, 65000, 213 59000, 7, 7, 8, 49, 20, 50 }, /* 65 Mb */ 214 [20] = { RC_HT_S_20, WLAN_RC_PHY_HT_20_SS_HGI, 72200, 215 65400, 7, 7, 8, 49, 20, 50 }, /* 65 Mb*/ 216 [21] = { RC_INVALID, WLAN_RC_PHY_HT_20_DS, 13000, 217 12700, 8, 8, 4, 51, 21, 51 }, /* 13 Mb */ 218 [22] = { RC_HT_T_20, WLAN_RC_PHY_HT_20_DS, 26000, 219 24800, 9, 9, 6, 52, 22, 52 }, /* 26 Mb */ 220 [23] = { RC_HT_T_20, WLAN_RC_PHY_HT_20_DS, 39000, 221 36600, 10, 10, 6, 53, 23, 53 }, /* 39 Mb */ 222 [24] = { RC_HT_DT_20, WLAN_RC_PHY_HT_20_DS, 52000, 223 48100, 11, 11, 8, 54, 24, 54 }, /* 52 Mb */ 224 [25] = { RC_HT_DT_20, WLAN_RC_PHY_HT_20_DS, 78000, 225 69500, 12, 12, 8, 55, 25, 55 }, /* 78 Mb */ 226 [26] = { RC_HT_DT_20, WLAN_RC_PHY_HT_20_DS, 104000, 227 89500, 13, 13, 8, 56, 26, 56 }, /* 104 Mb */ 228 [27] = { RC_HT_DT_20, WLAN_RC_PHY_HT_20_DS, 117000, 229 98900, 14, 14, 8, 57, 27, 57 }, /* 117 Mb */ 230 [28] = { RC_HT_DT_20, WLAN_RC_PHY_HT_20_DS, 130000, 231 108300, 15, 15, 8, 58, 29, 59 }, /* 130 Mb */ 232 [29] = { RC_HT_DT_20, WLAN_RC_PHY_HT_20_DS_HGI, 144400, 233 120000, 15, 15, 8, 58, 29, 59 }, /* 144.4 Mb */ 234 [30] = { RC_INVALID, WLAN_RC_PHY_HT_20_TS, 19500, 235 17400, 16, 16, 4, 60, 30, 60 }, /* 19.5 Mb */ 236 [31] = { RC_INVALID, WLAN_RC_PHY_HT_20_TS, 39000, 237 35100, 17, 17, 6, 61, 31, 61 }, /* 39 Mb */ 238 [32] = { RC_INVALID, WLAN_RC_PHY_HT_20_TS, 58500, 239 52600, 18, 18, 6, 62, 32, 62 }, /* 58.5 Mb */ 240 [33] = { RC_INVALID, WLAN_RC_PHY_HT_20_TS, 78000, 241 70400, 19, 19, 8, 63, 33, 63 }, /* 78 Mb */ 242 [34] = { RC_INVALID, WLAN_RC_PHY_HT_20_TS, 117000, 243 104900, 20, 20, 8, 64, 35, 65 }, /* 117 Mb */ 244 [35] = { RC_INVALID, WLAN_RC_PHY_HT_20_TS_HGI, 130000, 245 115800, 20, 20, 8, 64, 35, 65 }, /* 130 Mb */ 246 [36] = { RC_HT_T_20, WLAN_RC_PHY_HT_20_TS, 156000, 247 137200, 21, 21, 8, 66, 37, 67 }, /* 156 Mb */ 248 [37] = { RC_HT_T_20, WLAN_RC_PHY_HT_20_TS_HGI, 173300, 249 151100, 21, 21, 8, 66, 37, 67 }, /* 173.3 Mb */ 250 [38] = { RC_HT_T_20, WLAN_RC_PHY_HT_20_TS, 175500, 251 152800, 22, 22, 8, 68, 39, 69 }, /* 175.5 Mb */ 252 [39] = { RC_HT_T_20, WLAN_RC_PHY_HT_20_TS_HGI, 195000, 253 168400, 22, 22, 8, 68, 39, 69 }, /* 195 Mb */ 254 [40] = { RC_HT_T_20, WLAN_RC_PHY_HT_20_TS, 195000, 255 168400, 23, 23, 8, 70, 41, 71 }, /* 195 Mb */ 256 [41] = { RC_HT_T_20, WLAN_RC_PHY_HT_20_TS_HGI, 216700, 257 185000, 23, 23, 8, 70, 41, 71 }, /* 216.7 Mb */ 258 [42] = { RC_HT_SDT_40, WLAN_RC_PHY_HT_40_SS, 13500, 259 13200, 0, 0, 8, 42, 42, 42 }, /* 13.5 Mb */ 260 [43] = { RC_HT_SDT_40, WLAN_RC_PHY_HT_40_SS, 27500, 261 25900, 1, 1, 8, 43, 43, 43 }, /* 27.0 Mb */ 262 [44] = { RC_HT_SDT_40, WLAN_RC_PHY_HT_40_SS, 40500, 263 38600, 2, 2, 8, 44, 44, 44 }, /* 40.5 Mb */ 264 [45] = { RC_HT_SD_40, WLAN_RC_PHY_HT_40_SS, 54000, 265 49800, 3, 3, 8, 45, 45, 45 }, /* 54 Mb */ 266 [46] = { RC_HT_SD_40, WLAN_RC_PHY_HT_40_SS, 81500, 267 72200, 4, 4, 8, 46, 46, 46 }, /* 81 Mb */ 268 [47] = { RC_HT_S_40 , WLAN_RC_PHY_HT_40_SS, 108000, 269 92900, 5, 5, 8, 47, 47, 47 }, /* 108 Mb */ 270 [48] = { RC_HT_S_40, WLAN_RC_PHY_HT_40_SS, 121500, 271 102700, 6, 6, 8, 48, 48, 48 }, /* 121.5 Mb */ 272 [49] = { RC_HT_S_40, WLAN_RC_PHY_HT_40_SS, 135000, 273 112000, 7, 7, 8, 49, 50, 50 }, /* 135 Mb */ 274 [50] = { RC_HT_S_40, WLAN_RC_PHY_HT_40_SS_HGI, 150000, 275 122000, 7, 7, 8, 49, 50, 50 }, /* 150 Mb */ 276 [51] = { RC_INVALID, WLAN_RC_PHY_HT_40_DS, 27000, 277 25800, 8, 8, 8, 51, 51, 51 }, /* 27 Mb */ 278 [52] = { RC_HT_T_40, WLAN_RC_PHY_HT_40_DS, 54000, 279 49800, 9, 9, 8, 52, 52, 52 }, /* 54 Mb */ 280 [53] = { RC_HT_T_40, WLAN_RC_PHY_HT_40_DS, 81000, 281 71900, 10, 10, 8, 53, 53, 53 }, /* 81 Mb */ 282 [54] = { RC_HT_DT_40, WLAN_RC_PHY_HT_40_DS, 108000, 283 92500, 11, 11, 8, 54, 54, 54 }, /* 108 Mb */ 284 [55] = { RC_HT_DT_40, WLAN_RC_PHY_HT_40_DS, 162000, 285 130300, 12, 12, 8, 55, 55, 55 }, /* 162 Mb */ 286 [56] = { RC_HT_DT_40, WLAN_RC_PHY_HT_40_DS, 216000, 287 162800, 13, 13, 8, 56, 56, 56 }, /* 216 Mb */ 288 [57] = { RC_HT_DT_40, WLAN_RC_PHY_HT_40_DS, 243000, 289 178200, 14, 14, 8, 57, 57, 57 }, /* 243 Mb */ 290 [58] = { RC_HT_DT_40, WLAN_RC_PHY_HT_40_DS, 270000, 291 192100, 15, 15, 8, 58, 59, 59 }, /* 270 Mb */ 292 [59] = { RC_HT_DT_40, WLAN_RC_PHY_HT_40_DS_HGI, 300000, 293 207000, 15, 15, 8, 58, 59, 59 }, /* 300 Mb */ 294 [60] = { RC_INVALID, WLAN_RC_PHY_HT_40_TS, 40500, 295 36100, 16, 16, 8, 60, 60, 60 }, /* 40.5 Mb */ 296 [61] = { RC_INVALID, WLAN_RC_PHY_HT_40_TS, 81000, 297 72900, 17, 17, 8, 61, 61, 61 }, /* 81 Mb */ 298 [62] = { RC_INVALID, WLAN_RC_PHY_HT_40_TS, 121500, 299 108300, 18, 18, 8, 62, 62, 62 }, /* 121.5 Mb */ 300 [63] = { RC_INVALID, WLAN_RC_PHY_HT_40_TS, 162000, 301 142000, 19, 19, 8, 63, 63, 63 }, /* 162 Mb */ 302 [64] = { RC_INVALID, WLAN_RC_PHY_HT_40_TS, 243000, 303 205100, 20, 20, 8, 64, 65, 65 }, /* 243 Mb */ 304 [65] = { RC_INVALID, WLAN_RC_PHY_HT_40_TS_HGI, 270000, 305 224700, 20, 20, 8, 64, 65, 65 }, /* 170 Mb */ 306 [66] = { RC_HT_T_40, WLAN_RC_PHY_HT_40_TS, 324000, 307 263100, 21, 21, 8, 66, 67, 67 }, /* 324 Mb */ 308 [67] = { RC_HT_T_40, WLAN_RC_PHY_HT_40_TS_HGI, 360000, 309 288000, 21, 21, 8, 66, 67, 67 }, /* 360 Mb */ 310 [68] = { RC_HT_T_40, WLAN_RC_PHY_HT_40_TS, 364500, 311 290700, 22, 22, 8, 68, 69, 69 }, /* 364.5 Mb */ 312 [69] = { RC_HT_T_40, WLAN_RC_PHY_HT_40_TS_HGI, 405000, 313 317200, 22, 22, 8, 68, 69, 69 }, /* 405 Mb */ 314 [70] = { RC_HT_T_40, WLAN_RC_PHY_HT_40_TS, 405000, 315 317200, 23, 23, 8, 70, 71, 71 }, /* 405 Mb */ 316 [71] = { RC_HT_T_40, WLAN_RC_PHY_HT_40_TS_HGI, 450000, 317 346400, 23, 23, 8, 70, 71, 71 }, /* 450 Mb */ 318 }, 319 50, /* probe interval */ 320 WLAN_RC_HT_FLAG, /* Phy rates allowed initially */ 321}; 322 323static const struct ath_rate_table ar5416_11a_ratetable = { 324 8, 325 0, 326 { 327 { RC_L_SDT, WLAN_RC_PHY_OFDM, 6000, /* 6 Mb */ 328 5400, 0, 12, 0}, 329 { RC_L_SDT, WLAN_RC_PHY_OFDM, 9000, /* 9 Mb */ 330 7800, 1, 18, 0}, 331 { RC_L_SDT, WLAN_RC_PHY_OFDM, 12000, /* 12 Mb */ 332 10000, 2, 24, 2}, 333 { RC_L_SDT, WLAN_RC_PHY_OFDM, 18000, /* 18 Mb */ 334 13900, 3, 36, 2}, 335 { RC_L_SDT, WLAN_RC_PHY_OFDM, 24000, /* 24 Mb */ 336 17300, 4, 48, 4}, 337 { RC_L_SDT, WLAN_RC_PHY_OFDM, 36000, /* 36 Mb */ 338 23000, 5, 72, 4}, 339 { RC_L_SDT, WLAN_RC_PHY_OFDM, 48000, /* 48 Mb */ 340 27400, 6, 96, 4}, 341 { RC_L_SDT, WLAN_RC_PHY_OFDM, 54000, /* 54 Mb */ 342 29300, 7, 108, 4}, 343 }, 344 50, /* probe interval */ 345 0, /* Phy rates allowed initially */ 346}; 347 348static const struct ath_rate_table ar5416_11g_ratetable = { 349 12, 350 0, 351 { 352 { RC_L_SDT, WLAN_RC_PHY_CCK, 1000, /* 1 Mb */ 353 900, 0, 2, 0}, 354 { RC_L_SDT, WLAN_RC_PHY_CCK, 2000, /* 2 Mb */ 355 1900, 1, 4, 1}, 356 { RC_L_SDT, WLAN_RC_PHY_CCK, 5500, /* 5.5 Mb */ 357 4900, 2, 11, 2}, 358 { RC_L_SDT, WLAN_RC_PHY_CCK, 11000, /* 11 Mb */ 359 8100, 3, 22, 3}, 360 { RC_INVALID, WLAN_RC_PHY_OFDM, 6000, /* 6 Mb */ 361 5400, 4, 12, 4}, 362 { RC_INVALID, WLAN_RC_PHY_OFDM, 9000, /* 9 Mb */ 363 7800, 5, 18, 4}, 364 { RC_L_SDT, WLAN_RC_PHY_OFDM, 12000, /* 12 Mb */ 365 10000, 6, 24, 6}, 366 { RC_L_SDT, WLAN_RC_PHY_OFDM, 18000, /* 18 Mb */ 367 13900, 7, 36, 6}, 368 { RC_L_SDT, WLAN_RC_PHY_OFDM, 24000, /* 24 Mb */ 369 17300, 8, 48, 8}, 370 { RC_L_SDT, WLAN_RC_PHY_OFDM, 36000, /* 36 Mb */ 371 23000, 9, 72, 8}, 372 { RC_L_SDT, WLAN_RC_PHY_OFDM, 48000, /* 48 Mb */ 373 27400, 10, 96, 8}, 374 { RC_L_SDT, WLAN_RC_PHY_OFDM, 54000, /* 54 Mb */ 375 29300, 11, 108, 8}, 376 }, 377 50, /* probe interval */ 378 0, /* Phy rates allowed initially */ 379}; 380 381static const struct ath_rate_table *hw_rate_table[ATH9K_MODE_MAX] = { 382 [ATH9K_MODE_11A] = &ar5416_11a_ratetable, 383 [ATH9K_MODE_11G] = &ar5416_11g_ratetable, 384 [ATH9K_MODE_11NA_HT20] = &ar5416_11na_ratetable, 385 [ATH9K_MODE_11NG_HT20] = &ar5416_11ng_ratetable, 386 [ATH9K_MODE_11NA_HT40PLUS] = &ar5416_11na_ratetable, 387 [ATH9K_MODE_11NA_HT40MINUS] = &ar5416_11na_ratetable, 388 [ATH9K_MODE_11NG_HT40PLUS] = &ar5416_11ng_ratetable, 389 [ATH9K_MODE_11NG_HT40MINUS] = &ar5416_11ng_ratetable, 390}; 391 392static int ath_rc_get_rateindex(const struct ath_rate_table *rate_table, 393 struct ieee80211_tx_rate *rate); 394 395static inline int8_t median(int8_t a, int8_t b, int8_t c) 396{ 397 if (a >= b) { 398 if (b >= c) 399 return b; 400 else if (a > c) 401 return c; 402 else 403 return a; 404 } else { 405 if (a >= c) 406 return a; 407 else if (b >= c) 408 return c; 409 else 410 return b; 411 } 412} 413 414static void ath_rc_sort_validrates(const struct ath_rate_table *rate_table, 415 struct ath_rate_priv *ath_rc_priv) 416{ 417 u8 i, j, idx, idx_next; 418 419 for (i = ath_rc_priv->max_valid_rate - 1; i > 0; i--) { 420 for (j = 0; j <= i-1; j++) { 421 idx = ath_rc_priv->valid_rate_index[j]; 422 idx_next = ath_rc_priv->valid_rate_index[j+1]; 423 424 if (rate_table->info[idx].ratekbps > 425 rate_table->info[idx_next].ratekbps) { 426 ath_rc_priv->valid_rate_index[j] = idx_next; 427 ath_rc_priv->valid_rate_index[j+1] = idx; 428 } 429 } 430 } 431} 432 433static void ath_rc_init_valid_txmask(struct ath_rate_priv *ath_rc_priv) 434{ 435 u8 i; 436 437 for (i = 0; i < ath_rc_priv->rate_table_size; i++) 438 ath_rc_priv->valid_rate_index[i] = 0; 439} 440 441static inline void ath_rc_set_valid_txmask(struct ath_rate_priv *ath_rc_priv, 442 u8 index, int valid_tx_rate) 443{ 444 BUG_ON(index > ath_rc_priv->rate_table_size); 445 ath_rc_priv->valid_rate_index[index] = !!valid_tx_rate; 446} 447 448static inline 449int ath_rc_get_nextvalid_txrate(const struct ath_rate_table *rate_table, 450 struct ath_rate_priv *ath_rc_priv, 451 u8 cur_valid_txrate, 452 u8 *next_idx) 453{ 454 u8 i; 455 456 for (i = 0; i < ath_rc_priv->max_valid_rate - 1; i++) { 457 if (ath_rc_priv->valid_rate_index[i] == cur_valid_txrate) { 458 *next_idx = ath_rc_priv->valid_rate_index[i+1]; 459 return 1; 460 } 461 } 462 463 /* No more valid rates */ 464 *next_idx = 0; 465 466 return 0; 467} 468 469/* Return true only for single stream */ 470 471static int ath_rc_valid_phyrate(u32 phy, u32 capflag, int ignore_cw) 472{ 473 if (WLAN_RC_PHY_HT(phy) && !(capflag & WLAN_RC_HT_FLAG)) 474 return 0; 475 if (WLAN_RC_PHY_DS(phy) && !(capflag & WLAN_RC_DS_FLAG)) 476 return 0; 477 if (WLAN_RC_PHY_TS(phy) && !(capflag & WLAN_RC_TS_FLAG)) 478 return 0; 479 if (WLAN_RC_PHY_SGI(phy) && !(capflag & WLAN_RC_SGI_FLAG)) 480 return 0; 481 if (!ignore_cw && WLAN_RC_PHY_HT(phy)) 482 if (WLAN_RC_PHY_40(phy) && !(capflag & WLAN_RC_40_FLAG)) 483 return 0; 484 return 1; 485} 486 487static inline int 488ath_rc_get_lower_rix(const struct ath_rate_table *rate_table, 489 struct ath_rate_priv *ath_rc_priv, 490 u8 cur_valid_txrate, u8 *next_idx) 491{ 492 int8_t i; 493 494 for (i = 1; i < ath_rc_priv->max_valid_rate ; i++) { 495 if (ath_rc_priv->valid_rate_index[i] == cur_valid_txrate) { 496 *next_idx = ath_rc_priv->valid_rate_index[i-1]; 497 return 1; 498 } 499 } 500 501 return 0; 502} 503 504static u8 ath_rc_init_validrates(struct ath_rate_priv *ath_rc_priv, 505 const struct ath_rate_table *rate_table, 506 u32 capflag) 507{ 508 u8 i, hi = 0; 509 510 for (i = 0; i < rate_table->rate_cnt; i++) { 511 if (rate_table->info[i].rate_flags & RC_LEGACY) { 512 u32 phy = rate_table->info[i].phy; 513 u8 valid_rate_count = 0; 514 515 if (!ath_rc_valid_phyrate(phy, capflag, 0)) 516 continue; 517 518 valid_rate_count = ath_rc_priv->valid_phy_ratecnt[phy]; 519 520 ath_rc_priv->valid_phy_rateidx[phy][valid_rate_count] = i; 521 ath_rc_priv->valid_phy_ratecnt[phy] += 1; 522 ath_rc_set_valid_txmask(ath_rc_priv, i, 1); 523 hi = i; 524 } 525 } 526 527 return hi; 528} 529 530static u8 ath_rc_setvalid_rates(struct ath_rate_priv *ath_rc_priv, 531 const struct ath_rate_table *rate_table, 532 struct ath_rateset *rateset, 533 u32 capflag) 534{ 535 u8 i, j, hi = 0; 536 537 /* Use intersection of working rates and valid rates */ 538 for (i = 0; i < rateset->rs_nrates; i++) { 539 for (j = 0; j < rate_table->rate_cnt; j++) { 540 u32 phy = rate_table->info[j].phy; 541 u16 rate_flags = rate_table->info[j].rate_flags; 542 u8 rate = rateset->rs_rates[i]; 543 u8 dot11rate = rate_table->info[j].dot11rate; 544 545 /* We allow a rate only if its valid and the 546 * capflag matches one of the validity 547 * (VALID/VALID_20/VALID_40) flags */ 548 549 if ((rate == dot11rate) && 550 (rate_flags & WLAN_RC_CAP_MODE(capflag)) == 551 WLAN_RC_CAP_MODE(capflag) && 552 (rate_flags & WLAN_RC_CAP_STREAM(capflag)) && 553 !WLAN_RC_PHY_HT(phy)) { 554 u8 valid_rate_count = 0; 555 556 if (!ath_rc_valid_phyrate(phy, capflag, 0)) 557 continue; 558 559 valid_rate_count = 560 ath_rc_priv->valid_phy_ratecnt[phy]; 561 562 ath_rc_priv->valid_phy_rateidx[phy] 563 [valid_rate_count] = j; 564 ath_rc_priv->valid_phy_ratecnt[phy] += 1; 565 ath_rc_set_valid_txmask(ath_rc_priv, j, 1); 566 hi = A_MAX(hi, j); 567 } 568 } 569 } 570 571 return hi; 572} 573 574static u8 ath_rc_setvalid_htrates(struct ath_rate_priv *ath_rc_priv, 575 const struct ath_rate_table *rate_table, 576 u8 *mcs_set, u32 capflag) 577{ 578 struct ath_rateset *rateset = (struct ath_rateset *)mcs_set; 579 580 u8 i, j, hi = 0; 581 582 /* Use intersection of working rates and valid rates */ 583 for (i = 0; i < rateset->rs_nrates; i++) { 584 for (j = 0; j < rate_table->rate_cnt; j++) { 585 u32 phy = rate_table->info[j].phy; 586 u16 rate_flags = rate_table->info[j].rate_flags; 587 u8 rate = rateset->rs_rates[i]; 588 u8 dot11rate = rate_table->info[j].dot11rate; 589 590 if ((rate != dot11rate) || !WLAN_RC_PHY_HT(phy) || 591 !(rate_flags & WLAN_RC_CAP_STREAM(capflag)) || 592 !WLAN_RC_PHY_HT_VALID(rate_flags, capflag)) 593 continue; 594 595 if (!ath_rc_valid_phyrate(phy, capflag, 0)) 596 continue; 597 598 ath_rc_priv->valid_phy_rateidx[phy] 599 [ath_rc_priv->valid_phy_ratecnt[phy]] = j; 600 ath_rc_priv->valid_phy_ratecnt[phy] += 1; 601 ath_rc_set_valid_txmask(ath_rc_priv, j, 1); 602 hi = A_MAX(hi, j); 603 } 604 } 605 606 return hi; 607} 608 609/* Finds the highest rate index we can use */ 610static u8 ath_rc_get_highest_rix(struct ath_softc *sc, 611 struct ath_rate_priv *ath_rc_priv, 612 const struct ath_rate_table *rate_table, 613 int *is_probing) 614{ 615 u32 best_thruput, this_thruput, now_msec; 616 u8 rate, next_rate, best_rate, maxindex, minindex; 617 int8_t index = 0; 618 619 now_msec = jiffies_to_msecs(jiffies); 620 *is_probing = 0; 621 best_thruput = 0; 622 maxindex = ath_rc_priv->max_valid_rate-1; 623 minindex = 0; 624 best_rate = minindex; 625 626 /* 627 * Try the higher rate first. It will reduce memory moving time 628 * if we have very good channel characteristics. 629 */ 630 for (index = maxindex; index >= minindex ; index--) { 631 u8 per_thres; 632 633 rate = ath_rc_priv->valid_rate_index[index]; 634 if (rate > ath_rc_priv->rate_max_phy) 635 continue; 636 637 /* 638 * For TCP the average collision rate is around 11%, 639 * so we ignore PERs less than this. This is to 640 * prevent the rate we are currently using (whose 641 * PER might be in the 10-15 range because of TCP 642 * collisions) looking worse than the next lower 643 * rate whose PER has decayed close to 0. If we 644 * used to next lower rate, its PER would grow to 645 * 10-15 and we would be worse off then staying 646 * at the current rate. 647 */ 648 per_thres = ath_rc_priv->per[rate]; 649 if (per_thres < 12) 650 per_thres = 12; 651 652 this_thruput = rate_table->info[rate].user_ratekbps * 653 (100 - per_thres); 654 655 if (best_thruput <= this_thruput) { 656 best_thruput = this_thruput; 657 best_rate = rate; 658 } 659 } 660 661 rate = best_rate; 662 663 /* 664 * Must check the actual rate (ratekbps) to account for 665 * non-monoticity of 11g's rate table 666 */ 667 668 if (rate >= ath_rc_priv->rate_max_phy) { 669 rate = ath_rc_priv->rate_max_phy; 670 671 /* Probe the next allowed phy state */ 672 if (ath_rc_get_nextvalid_txrate(rate_table, 673 ath_rc_priv, rate, &next_rate) && 674 (now_msec - ath_rc_priv->probe_time > 675 rate_table->probe_interval) && 676 (ath_rc_priv->hw_maxretry_pktcnt >= 1)) { 677 rate = next_rate; 678 ath_rc_priv->probe_rate = rate; 679 ath_rc_priv->probe_time = now_msec; 680 ath_rc_priv->hw_maxretry_pktcnt = 0; 681 *is_probing = 1; 682 } 683 } 684 685 if (rate > (ath_rc_priv->rate_table_size - 1)) 686 rate = ath_rc_priv->rate_table_size - 1; 687 688 if (RC_TS_ONLY(rate_table->info[rate].rate_flags) && 689 (ath_rc_priv->ht_cap & WLAN_RC_TS_FLAG)) 690 return rate; 691 692 if (RC_DS_OR_LATER(rate_table->info[rate].rate_flags) && 693 (ath_rc_priv->ht_cap & (WLAN_RC_DS_FLAG | WLAN_RC_TS_FLAG))) 694 return rate; 695 696 if (RC_SS_OR_LEGACY(rate_table->info[rate].rate_flags)) 697 return rate; 698 699 /* This should not happen */ 700 WARN_ON(1); 701 702 rate = ath_rc_priv->valid_rate_index[0]; 703 704 return rate; 705} 706 707static void ath_rc_rate_set_series(const struct ath_rate_table *rate_table, 708 struct ieee80211_tx_rate *rate, 709 struct ieee80211_tx_rate_control *txrc, 710 u8 tries, u8 rix, int rtsctsenable) 711{ 712 rate->count = tries; 713 rate->idx = rate_table->info[rix].ratecode; 714 715 if (txrc->short_preamble) 716 rate->flags |= IEEE80211_TX_RC_USE_SHORT_PREAMBLE; 717 if (txrc->rts || rtsctsenable) 718 rate->flags |= IEEE80211_TX_RC_USE_RTS_CTS; 719 720 if (WLAN_RC_PHY_HT(rate_table->info[rix].phy)) { 721 rate->flags |= IEEE80211_TX_RC_MCS; 722 if (WLAN_RC_PHY_40(rate_table->info[rix].phy)) 723 rate->flags |= IEEE80211_TX_RC_40_MHZ_WIDTH; 724 if (WLAN_RC_PHY_SGI(rate_table->info[rix].phy)) 725 rate->flags |= IEEE80211_TX_RC_SHORT_GI; 726 } 727} 728 729static void ath_rc_rate_set_rtscts(struct ath_softc *sc, 730 const struct ath_rate_table *rate_table, 731 struct ieee80211_tx_info *tx_info) 732{ 733 struct ieee80211_tx_rate *rates = tx_info->control.rates; 734 int i = 0, rix = 0, cix, enable_g_protection = 0; 735 736 /* get the cix for the lowest valid rix */ 737 for (i = 3; i >= 0; i--) { 738 if (rates[i].count && (rates[i].idx >= 0)) { 739 rix = ath_rc_get_rateindex(rate_table, &rates[i]); 740 break; 741 } 742 } 743 cix = rate_table->info[rix].ctrl_rate; 744 745 /* All protection frames are transmited at 2Mb/s for 802.11g, 746 * otherwise we transmit them at 1Mb/s */ 747 if (sc->hw->conf.channel->band == IEEE80211_BAND_2GHZ && 748 !conf_is_ht(&sc->hw->conf)) 749 enable_g_protection = 1; 750 751 /* 752 * If 802.11g protection is enabled, determine whether to use RTS/CTS or 753 * just CTS. Note that this is only done for OFDM/HT unicast frames. 754 */ 755 if ((sc->sc_flags & SC_OP_PROTECT_ENABLE) && 756 (rate_table->info[rix].phy == WLAN_RC_PHY_OFDM || 757 WLAN_RC_PHY_HT(rate_table->info[rix].phy))) { 758 rates[0].flags |= IEEE80211_TX_RC_USE_CTS_PROTECT; 759 cix = rate_table->info[enable_g_protection].ctrl_rate; 760 } 761 762 tx_info->control.rts_cts_rate_idx = cix; 763} 764 765static void ath_get_rate(void *priv, struct ieee80211_sta *sta, void *priv_sta, 766 struct ieee80211_tx_rate_control *txrc) 767{ 768 struct ath_softc *sc = priv; 769 struct ath_rate_priv *ath_rc_priv = priv_sta; 770 const struct ath_rate_table *rate_table; 771 struct sk_buff *skb = txrc->skb; 772 struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb); 773 struct ieee80211_tx_rate *rates = tx_info->control.rates; 774 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 775 __le16 fc = hdr->frame_control; 776 u8 try_per_rate, i = 0, rix; 777 int is_probe = 0; 778 779 if (rate_control_send_low(sta, priv_sta, txrc)) 780 return; 781 782 /* 783 * For Multi Rate Retry we use a different number of 784 * retry attempt counts. This ends up looking like this: 785 * 786 * MRR[0] = 4 787 * MRR[1] = 4 788 * MRR[2] = 4 789 * MRR[3] = 8 790 * 791 */ 792 try_per_rate = 4; 793 794 rate_table = sc->cur_rate_table; 795 rix = ath_rc_get_highest_rix(sc, ath_rc_priv, rate_table, &is_probe); 796 797 /* 798 * If we're in HT mode and both us and our peer supports LDPC. 799 * We don't need to check our own device's capabilities as our own 800 * ht capabilities would have already been intersected with our peer's. 801 */ 802 if (conf_is_ht(&sc->hw->conf) && 803 (sta->ht_cap.cap & IEEE80211_HT_CAP_LDPC_CODING)) 804 tx_info->flags |= IEEE80211_TX_CTL_LDPC; 805 806 if (conf_is_ht(&sc->hw->conf) && 807 (sta->ht_cap.cap & IEEE80211_HT_CAP_TX_STBC)) 808 tx_info->flags |= (1 << IEEE80211_TX_CTL_STBC_SHIFT); 809 810 if (is_probe) { 811 /* set one try for probe rates. For the 812 * probes don't enable rts */ 813 ath_rc_rate_set_series(rate_table, &rates[i++], txrc, 814 1, rix, 0); 815 816 /* Get the next tried/allowed rate. No RTS for the next series 817 * after the probe rate 818 */ 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 { 825 /* Set the choosen 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 < 4; i++) { 832 /* Use twice the number of tries for the last MRR segment. */ 833 if (i + 1 == 4) 834 try_per_rate = 8; 835 836 ath_rc_get_lower_rix(rate_table, ath_rc_priv, rix, &rix); 837 /* All other rates in the series have RTS enabled */ 838 ath_rc_rate_set_series(rate_table, &rates[i], txrc, 839 try_per_rate, rix, 1); 840 } 841 842 /* 843 * NB:Change rate series to enable aggregation when operating 844 * at lower MCS rates. When first rate in series is MCS2 845 * in HT40 @ 2.4GHz, series should look like: 846 * 847 * {MCS2, MCS1, MCS0, MCS0}. 848 * 849 * When first rate in series is MCS3 in HT20 @ 2.4GHz, series should 850 * look like: 851 * 852 * {MCS3, MCS2, MCS1, MCS1} 853 * 854 * So, set fourth rate in series to be same as third one for 855 * above conditions. 856 */ 857 if ((sc->hw->conf.channel->band == IEEE80211_BAND_2GHZ) && 858 (conf_is_ht(&sc->hw->conf))) { 859 u8 dot11rate = rate_table->info[rix].dot11rate; 860 u8 phy = rate_table->info[rix].phy; 861 if (i == 4 && 862 ((dot11rate == 2 && phy == WLAN_RC_PHY_HT_40_SS) || 863 (dot11rate == 3 && phy == WLAN_RC_PHY_HT_20_SS))) { 864 rates[3].idx = rates[2].idx; 865 rates[3].flags = rates[2].flags; 866 } 867 } 868 869 if (ieee80211_has_morefrags(fc) || 870 (le16_to_cpu(hdr->seq_ctrl) & IEEE80211_SCTL_FRAG)) { 871 rates[1].count = rates[2].count = rates[3].count = 0; 872 rates[1].idx = rates[2].idx = rates[3].idx = 0; 873 rates[0].count = ATH_TXMAXTRY; 874 } 875 876 /* Setup RTS/CTS */ 877 ath_rc_rate_set_rtscts(sc, rate_table, tx_info); 878} 879 880static bool ath_rc_update_per(struct ath_softc *sc, 881 const struct ath_rate_table *rate_table, 882 struct ath_rate_priv *ath_rc_priv, 883 struct ieee80211_tx_info *tx_info, 884 int tx_rate, int xretries, int retries, 885 u32 now_msec) 886{ 887 bool state_change = false; 888 int count, n_bad_frames; 889 u8 last_per; 890 static u32 nretry_to_per_lookup[10] = { 891 100 * 0 / 1, 892 100 * 1 / 4, 893 100 * 1 / 2, 894 100 * 3 / 4, 895 100 * 4 / 5, 896 100 * 5 / 6, 897 100 * 6 / 7, 898 100 * 7 / 8, 899 100 * 8 / 9, 900 100 * 9 / 10 901 }; 902 903 last_per = ath_rc_priv->per[tx_rate]; 904 n_bad_frames = tx_info->status.ampdu_len - tx_info->status.ampdu_ack_len; 905 906 if (xretries) { 907 if (xretries == 1) { 908 ath_rc_priv->per[tx_rate] += 30; 909 if (ath_rc_priv->per[tx_rate] > 100) 910 ath_rc_priv->per[tx_rate] = 100; 911 } else { 912 /* xretries == 2 */ 913 count = ARRAY_SIZE(nretry_to_per_lookup); 914 if (retries >= count) 915 retries = count - 1; 916 917 /* new_PER = 7/8*old_PER + 1/8*(currentPER) */ 918 ath_rc_priv->per[tx_rate] = 919 (u8)(last_per - (last_per >> 3) + (100 >> 3)); 920 } 921 922 /* xretries == 1 or 2 */ 923 924 if (ath_rc_priv->probe_rate == tx_rate) 925 ath_rc_priv->probe_rate = 0; 926 927 } else { /* xretries == 0 */ 928 count = ARRAY_SIZE(nretry_to_per_lookup); 929 if (retries >= count) 930 retries = count - 1; 931 932 if (n_bad_frames) { 933 /* new_PER = 7/8*old_PER + 1/8*(currentPER) 934 * Assuming that n_frames is not 0. The current PER 935 * from the retries is 100 * retries / (retries+1), 936 * since the first retries attempts failed, and the 937 * next one worked. For the one that worked, 938 * n_bad_frames subframes out of n_frames wored, 939 * so the PER for that part is 940 * 100 * n_bad_frames / n_frames, and it contributes 941 * 100 * n_bad_frames / (n_frames * (retries+1)) to 942 * the above PER. The expression below is a 943 * simplified version of the sum of these two terms. 944 */ 945 if (tx_info->status.ampdu_len > 0) { 946 int n_frames, n_bad_tries; 947 u8 cur_per, new_per; 948 949 n_bad_tries = retries * tx_info->status.ampdu_len + 950 n_bad_frames; 951 n_frames = tx_info->status.ampdu_len * (retries + 1); 952 cur_per = (100 * n_bad_tries / n_frames) >> 3; 953 new_per = (u8)(last_per - (last_per >> 3) + cur_per); 954 ath_rc_priv->per[tx_rate] = new_per; 955 } 956 } else { 957 ath_rc_priv->per[tx_rate] = 958 (u8)(last_per - (last_per >> 3) + 959 (nretry_to_per_lookup[retries] >> 3)); 960 } 961 962 963 /* 964 * If we got at most one retry then increase the max rate if 965 * this was a probe. Otherwise, ignore the probe. 966 */ 967 if (ath_rc_priv->probe_rate && ath_rc_priv->probe_rate == tx_rate) { 968 if (retries > 0 || 2 * n_bad_frames > tx_info->status.ampdu_len) { 969 /* 970 * Since we probed with just a single attempt, 971 * any retries means the probe failed. Also, 972 * if the attempt worked, but more than half 973 * the subframes were bad then also consider 974 * the probe a failure. 975 */ 976 ath_rc_priv->probe_rate = 0; 977 } else { 978 u8 probe_rate = 0; 979 980 ath_rc_priv->rate_max_phy = 981 ath_rc_priv->probe_rate; 982 probe_rate = ath_rc_priv->probe_rate; 983 984 if (ath_rc_priv->per[probe_rate] > 30) 985 ath_rc_priv->per[probe_rate] = 20; 986 987 ath_rc_priv->probe_rate = 0; 988 989 /* 990 * Since this probe succeeded, we allow the next 991 * probe twice as soon. This allows the maxRate 992 * to move up faster if the probes are 993 * successful. 994 */ 995 ath_rc_priv->probe_time = 996 now_msec - rate_table->probe_interval / 2; 997 } 998 } 999 1000 if (retries > 0) { 1001 /* 1002 * Don't update anything. We don't know if 1003 * this was because of collisions or poor signal. 1004 */ 1005 ath_rc_priv->hw_maxretry_pktcnt = 0; 1006 } else { 1007 /* 1008 * It worked with no retries. First ignore bogus (small) 1009 * rssi_ack values. 1010 */ 1011 if (tx_rate == ath_rc_priv->rate_max_phy && 1012 ath_rc_priv->hw_maxretry_pktcnt < 255) { 1013 ath_rc_priv->hw_maxretry_pktcnt++; 1014 } 1015 1016 } 1017 } 1018 1019 return state_change; 1020} 1021 1022/* Update PER, RSSI and whatever else that the code thinks it is doing. 1023 If you can make sense of all this, you really need to go out more. */ 1024 1025static void ath_rc_update_ht(struct ath_softc *sc, 1026 struct ath_rate_priv *ath_rc_priv, 1027 struct ieee80211_tx_info *tx_info, 1028 int tx_rate, int xretries, int retries) 1029{ 1030 u32 now_msec = jiffies_to_msecs(jiffies); 1031 int rate; 1032 u8 last_per; 1033 bool state_change = false; 1034 const struct ath_rate_table *rate_table = sc->cur_rate_table; 1035 int size = ath_rc_priv->rate_table_size; 1036 1037 if ((tx_rate < 0) || (tx_rate > rate_table->rate_cnt)) 1038 return; 1039 1040 last_per = ath_rc_priv->per[tx_rate]; 1041 1042 /* Update PER first */ 1043 state_change = ath_rc_update_per(sc, rate_table, ath_rc_priv, 1044 tx_info, tx_rate, xretries, 1045 retries, now_msec); 1046 1047 /* 1048 * If this rate looks bad (high PER) then stop using it for 1049 * a while (except if we are probing). 1050 */ 1051 if (ath_rc_priv->per[tx_rate] >= 55 && tx_rate > 0 && 1052 rate_table->info[tx_rate].ratekbps <= 1053 rate_table->info[ath_rc_priv->rate_max_phy].ratekbps) { 1054 ath_rc_get_lower_rix(rate_table, ath_rc_priv, 1055 (u8)tx_rate, &ath_rc_priv->rate_max_phy); 1056 1057 /* Don't probe for a little while. */ 1058 ath_rc_priv->probe_time = now_msec; 1059 } 1060 1061 /* Make sure the rates below this have lower PER */ 1062 /* Monotonicity is kept only for rates below the current rate. */ 1063 if (ath_rc_priv->per[tx_rate] < last_per) { 1064 for (rate = tx_rate - 1; rate >= 0; rate--) { 1065 1066 if (ath_rc_priv->per[rate] > 1067 ath_rc_priv->per[rate+1]) { 1068 ath_rc_priv->per[rate] = 1069 ath_rc_priv->per[rate+1]; 1070 } 1071 } 1072 } 1073 1074 /* Maintain monotonicity for rates above the current rate */ 1075 for (rate = tx_rate; rate < size - 1; rate++) { 1076 if (ath_rc_priv->per[rate+1] < 1077 ath_rc_priv->per[rate]) 1078 ath_rc_priv->per[rate+1] = 1079 ath_rc_priv->per[rate]; 1080 } 1081 1082 /* Every so often, we reduce the thresholds 1083 * and PER (different for CCK and OFDM). */ 1084 if (now_msec - ath_rc_priv->per_down_time >= 1085 rate_table->probe_interval) { 1086 for (rate = 0; rate < size; rate++) { 1087 ath_rc_priv->per[rate] = 1088 7 * ath_rc_priv->per[rate] / 8; 1089 } 1090 1091 ath_rc_priv->per_down_time = now_msec; 1092 } 1093 1094 ath_debug_stat_retries(sc, tx_rate, xretries, retries, 1095 ath_rc_priv->per[tx_rate]); 1096 1097} 1098 1099static int ath_rc_get_rateindex(const struct ath_rate_table *rate_table, 1100 struct ieee80211_tx_rate *rate) 1101{ 1102 int rix = 0, i = 0; 1103 int mcs_rix_off[] = { 7, 15, 20, 21, 22, 23 }; 1104 1105 if (!(rate->flags & IEEE80211_TX_RC_MCS)) 1106 return rate->idx; 1107 1108 while (rate->idx > mcs_rix_off[i] && 1109 i < sizeof(mcs_rix_off)/sizeof(int)) { 1110 rix++; i++; 1111 } 1112 1113 rix += rate->idx + rate_table->mcs_start; 1114 1115 if ((rate->flags & IEEE80211_TX_RC_40_MHZ_WIDTH) && 1116 (rate->flags & IEEE80211_TX_RC_SHORT_GI)) 1117 rix = rate_table->info[rix].ht_index; 1118 else if (rate->flags & IEEE80211_TX_RC_SHORT_GI) 1119 rix = rate_table->info[rix].sgi_index; 1120 else if (rate->flags & IEEE80211_TX_RC_40_MHZ_WIDTH) 1121 rix = rate_table->info[rix].cw40index; 1122 1123 return rix; 1124} 1125 1126static void ath_rc_tx_status(struct ath_softc *sc, 1127 struct ath_rate_priv *ath_rc_priv, 1128 struct ieee80211_tx_info *tx_info, 1129 int final_ts_idx, int xretries, int long_retry) 1130{ 1131 const struct ath_rate_table *rate_table; 1132 struct ieee80211_tx_rate *rates = tx_info->status.rates; 1133 u8 flags; 1134 u32 i = 0, rix; 1135 1136 rate_table = sc->cur_rate_table; 1137 1138 /* 1139 * If the first rate is not the final index, there 1140 * are intermediate rate failures to be processed. 1141 */ 1142 if (final_ts_idx != 0) { 1143 /* Process intermediate rates that failed.*/ 1144 for (i = 0; i < final_ts_idx ; i++) { 1145 if (rates[i].count != 0 && (rates[i].idx >= 0)) { 1146 flags = rates[i].flags; 1147 1148 /* If HT40 and we have switched mode from 1149 * 40 to 20 => don't update */ 1150 1151 if ((flags & IEEE80211_TX_RC_40_MHZ_WIDTH) && 1152 !(ath_rc_priv->ht_cap & WLAN_RC_40_FLAG)) 1153 return; 1154 1155 rix = ath_rc_get_rateindex(rate_table, &rates[i]); 1156 ath_rc_update_ht(sc, ath_rc_priv, tx_info, 1157 rix, xretries ? 1 : 2, 1158 rates[i].count); 1159 } 1160 } 1161 } else { 1162 /* 1163 * Handle the special case of MIMO PS burst, where the second 1164 * aggregate is sent out with only one rate and one try. 1165 * Treating it as an excessive retry penalizes the rate 1166 * inordinately. 1167 */ 1168 if (rates[0].count == 1 && xretries == 1) 1169 xretries = 2; 1170 } 1171 1172 flags = rates[i].flags; 1173 1174 /* If HT40 and we have switched mode from 40 to 20 => don't update */ 1175 if ((flags & IEEE80211_TX_RC_40_MHZ_WIDTH) && 1176 !(ath_rc_priv->ht_cap & WLAN_RC_40_FLAG)) 1177 return; 1178 1179 rix = ath_rc_get_rateindex(rate_table, &rates[i]); 1180 ath_rc_update_ht(sc, ath_rc_priv, tx_info, rix, xretries, long_retry); 1181} 1182 1183static const 1184struct ath_rate_table *ath_choose_rate_table(struct ath_softc *sc, 1185 enum ieee80211_band band, 1186 bool is_ht, 1187 bool is_cw_40) 1188{ 1189 int mode = 0; 1190 struct ath_common *common = ath9k_hw_common(sc->sc_ah); 1191 1192 switch(band) { 1193 case IEEE80211_BAND_2GHZ: 1194 mode = ATH9K_MODE_11G; 1195 if (is_ht) 1196 mode = ATH9K_MODE_11NG_HT20; 1197 if (is_cw_40) 1198 mode = ATH9K_MODE_11NG_HT40PLUS; 1199 break; 1200 case IEEE80211_BAND_5GHZ: 1201 mode = ATH9K_MODE_11A; 1202 if (is_ht) 1203 mode = ATH9K_MODE_11NA_HT20; 1204 if (is_cw_40) 1205 mode = ATH9K_MODE_11NA_HT40PLUS; 1206 break; 1207 default: 1208 ath_print(common, ATH_DBG_CONFIG, "Invalid band\n"); 1209 return NULL; 1210 } 1211 1212 BUG_ON(mode >= ATH9K_MODE_MAX); 1213 1214 ath_print(common, ATH_DBG_CONFIG, 1215 "Choosing rate table for mode: %d\n", mode); 1216 1217 sc->cur_rate_mode = mode; 1218 return hw_rate_table[mode]; 1219} 1220 1221static void ath_rc_init(struct ath_softc *sc, 1222 struct ath_rate_priv *ath_rc_priv, 1223 struct ieee80211_supported_band *sband, 1224 struct ieee80211_sta *sta, 1225 const struct ath_rate_table *rate_table) 1226{ 1227 struct ath_rateset *rateset = &ath_rc_priv->neg_rates; 1228 struct ath_common *common = ath9k_hw_common(sc->sc_ah); 1229 u8 *ht_mcs = (u8 *)&ath_rc_priv->neg_ht_rates; 1230 u8 i, j, k, hi = 0, hthi = 0; 1231 1232 /* Initial rate table size. Will change depending 1233 * on the working rate set */ 1234 ath_rc_priv->rate_table_size = RATE_TABLE_SIZE; 1235 1236 /* Initialize thresholds according to the global rate table */ 1237 for (i = 0 ; i < ath_rc_priv->rate_table_size; i++) { 1238 ath_rc_priv->per[i] = 0; 1239 } 1240 1241 /* Determine the valid rates */ 1242 ath_rc_init_valid_txmask(ath_rc_priv); 1243 1244 for (i = 0; i < WLAN_RC_PHY_MAX; i++) { 1245 for (j = 0; j < MAX_TX_RATE_PHY; j++) 1246 ath_rc_priv->valid_phy_rateidx[i][j] = 0; 1247 ath_rc_priv->valid_phy_ratecnt[i] = 0; 1248 } 1249 1250 if (!rateset->rs_nrates) { 1251 /* No working rate, just initialize valid rates */ 1252 hi = ath_rc_init_validrates(ath_rc_priv, rate_table, 1253 ath_rc_priv->ht_cap); 1254 } else { 1255 /* Use intersection of working rates and valid rates */ 1256 hi = ath_rc_setvalid_rates(ath_rc_priv, rate_table, 1257 rateset, ath_rc_priv->ht_cap); 1258 if (ath_rc_priv->ht_cap & WLAN_RC_HT_FLAG) { 1259 hthi = ath_rc_setvalid_htrates(ath_rc_priv, 1260 rate_table, 1261 ht_mcs, 1262 ath_rc_priv->ht_cap); 1263 } 1264 hi = A_MAX(hi, hthi); 1265 } 1266 1267 ath_rc_priv->rate_table_size = hi + 1; 1268 ath_rc_priv->rate_max_phy = 0; 1269 BUG_ON(ath_rc_priv->rate_table_size > RATE_TABLE_SIZE); 1270 1271 for (i = 0, k = 0; i < WLAN_RC_PHY_MAX; i++) { 1272 for (j = 0; j < ath_rc_priv->valid_phy_ratecnt[i]; j++) { 1273 ath_rc_priv->valid_rate_index[k++] = 1274 ath_rc_priv->valid_phy_rateidx[i][j]; 1275 } 1276 1277 if (!ath_rc_valid_phyrate(i, rate_table->initial_ratemax, 1) 1278 || !ath_rc_priv->valid_phy_ratecnt[i]) 1279 continue; 1280 1281 ath_rc_priv->rate_max_phy = ath_rc_priv->valid_phy_rateidx[i][j-1]; 1282 } 1283 BUG_ON(ath_rc_priv->rate_table_size > RATE_TABLE_SIZE); 1284 BUG_ON(k > RATE_TABLE_SIZE); 1285 1286 ath_rc_priv->max_valid_rate = k; 1287 ath_rc_sort_validrates(rate_table, ath_rc_priv); 1288 ath_rc_priv->rate_max_phy = ath_rc_priv->valid_rate_index[k-4]; 1289 sc->cur_rate_table = rate_table; 1290 1291 ath_print(common, ATH_DBG_CONFIG, 1292 "RC Initialized with capabilities: 0x%x\n", 1293 ath_rc_priv->ht_cap); 1294} 1295 1296static u8 ath_rc_build_ht_caps(struct ath_softc *sc, struct ieee80211_sta *sta, 1297 bool is_cw40, bool is_sgi) 1298{ 1299 u8 caps = 0; 1300 1301 if (sta->ht_cap.ht_supported) { 1302 caps = WLAN_RC_HT_FLAG; 1303 if (sta->ht_cap.mcs.rx_mask[1] && sta->ht_cap.mcs.rx_mask[2]) 1304 caps |= WLAN_RC_TS_FLAG | WLAN_RC_DS_FLAG; 1305 else if (sta->ht_cap.mcs.rx_mask[1]) 1306 caps |= WLAN_RC_DS_FLAG; 1307 if (is_cw40) 1308 caps |= WLAN_RC_40_FLAG; 1309 if (is_sgi) 1310 caps |= WLAN_RC_SGI_FLAG; 1311 } 1312 1313 return caps; 1314} 1315 1316/***********************************/ 1317/* mac80211 Rate Control callbacks */ 1318/***********************************/ 1319 1320static void ath_tx_status(void *priv, struct ieee80211_supported_band *sband, 1321 struct ieee80211_sta *sta, void *priv_sta, 1322 struct sk_buff *skb) 1323{ 1324 struct ath_softc *sc = priv; 1325 struct ath_rate_priv *ath_rc_priv = priv_sta; 1326 struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb); 1327 struct ieee80211_hdr *hdr; 1328 int final_ts_idx = 0, tx_status = 0, is_underrun = 0; 1329 int long_retry = 0; 1330 __le16 fc; 1331 int i; 1332 1333 hdr = (struct ieee80211_hdr *)skb->data; 1334 fc = hdr->frame_control; 1335 for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) { 1336 struct ieee80211_tx_rate *rate = &tx_info->status.rates[i]; 1337 if (!rate->count) 1338 break; 1339 1340 final_ts_idx = i; 1341 long_retry = rate->count - 1; 1342 } 1343 1344 if (!priv_sta || !ieee80211_is_data(fc)) 1345 return; 1346 1347 /* This packet was aggregated but doesn't carry status info */ 1348 if ((tx_info->flags & IEEE80211_TX_CTL_AMPDU) && 1349 !(tx_info->flags & IEEE80211_TX_STAT_AMPDU)) 1350 return; 1351 1352 if (tx_info->flags & IEEE80211_TX_STAT_TX_FILTERED) 1353 return; 1354 1355 if (!(tx_info->flags & IEEE80211_TX_STAT_AMPDU)) { 1356 tx_info->status.ampdu_ack_len = 1357 (tx_info->flags & IEEE80211_TX_STAT_ACK ? 1 : 0); 1358 tx_info->status.ampdu_len = 1; 1359 } 1360 1361 /* 1362 * If an underrun error is seen assume it as an excessive retry only 1363 * if max frame trigger level has been reached (2 KB for singel stream, 1364 * and 4 KB for dual stream). Adjust the long retry as if the frame was 1365 * tried hw->max_rate_tries times to affect how ratectrl updates PER for 1366 * the failed rate. In case of congestion on the bus penalizing these 1367 * type of underruns should help hardware actually transmit new frames 1368 * successfully by eventually preferring slower rates. This itself 1369 * should also alleviate congestion on the bus. 1370 */ 1371 if ((tx_info->pad[0] & ATH_TX_INFO_UNDERRUN) && 1372 (sc->sc_ah->tx_trig_level >= ath_rc_priv->tx_triglevel_max)) { 1373 tx_status = 1; 1374 is_underrun = 1; 1375 } 1376 1377 if (tx_info->pad[0] & ATH_TX_INFO_XRETRY) 1378 tx_status = 1; 1379 1380 ath_rc_tx_status(sc, ath_rc_priv, tx_info, final_ts_idx, tx_status, 1381 (is_underrun) ? sc->hw->max_rate_tries : long_retry); 1382 1383 /* Check if aggregation has to be enabled for this tid */ 1384 if (conf_is_ht(&sc->hw->conf) && 1385 !(skb->protocol == cpu_to_be16(ETH_P_PAE))) { 1386 if (ieee80211_is_data_qos(fc)) { 1387 u8 *qc, tid; 1388 struct ath_node *an; 1389 1390 qc = ieee80211_get_qos_ctl(hdr); 1391 tid = qc[0] & 0xf; 1392 an = (struct ath_node *)sta->drv_priv; 1393 1394 if(ath_tx_aggr_check(sc, an, tid)) 1395 ieee80211_start_tx_ba_session(sta, tid); 1396 } 1397 } 1398 1399 ath_debug_stat_rc(sc, ath_rc_get_rateindex(sc->cur_rate_table, 1400 &tx_info->status.rates[final_ts_idx])); 1401} 1402 1403static void ath_rate_init(void *priv, struct ieee80211_supported_band *sband, 1404 struct ieee80211_sta *sta, void *priv_sta) 1405{ 1406 struct ath_softc *sc = priv; 1407 struct ath_rate_priv *ath_rc_priv = priv_sta; 1408 const struct ath_rate_table *rate_table; 1409 bool is_cw40, is_sgi = false; 1410 int i, j = 0; 1411 1412 for (i = 0; i < sband->n_bitrates; i++) { 1413 if (sta->supp_rates[sband->band] & BIT(i)) { 1414 ath_rc_priv->neg_rates.rs_rates[j] 1415 = (sband->bitrates[i].bitrate * 2) / 10; 1416 j++; 1417 } 1418 } 1419 ath_rc_priv->neg_rates.rs_nrates = j; 1420 1421 if (sta->ht_cap.ht_supported) { 1422 for (i = 0, j = 0; i < 77; i++) { 1423 if (sta->ht_cap.mcs.rx_mask[i/8] & (1<<(i%8))) 1424 ath_rc_priv->neg_ht_rates.rs_rates[j++] = i; 1425 if (j == ATH_RATE_MAX) 1426 break; 1427 } 1428 ath_rc_priv->neg_ht_rates.rs_nrates = j; 1429 } 1430 1431 is_cw40 = sta->ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40; 1432 1433 if (is_cw40) 1434 is_sgi = sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_40; 1435 else if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_SGI_20) 1436 is_sgi = sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_20; 1437 1438 /* Choose rate table first */ 1439 1440 if ((sc->sc_ah->opmode == NL80211_IFTYPE_STATION) || 1441 (sc->sc_ah->opmode == NL80211_IFTYPE_MESH_POINT) || 1442 (sc->sc_ah->opmode == NL80211_IFTYPE_ADHOC)) { 1443 rate_table = ath_choose_rate_table(sc, sband->band, 1444 sta->ht_cap.ht_supported, is_cw40); 1445 } else { 1446 rate_table = hw_rate_table[sc->cur_rate_mode]; 1447 } 1448 1449 ath_rc_priv->ht_cap = ath_rc_build_ht_caps(sc, sta, is_cw40, is_sgi); 1450 ath_rc_init(sc, priv_sta, sband, sta, rate_table); 1451} 1452 1453static void ath_rate_update(void *priv, struct ieee80211_supported_band *sband, 1454 struct ieee80211_sta *sta, void *priv_sta, 1455 u32 changed, enum nl80211_channel_type oper_chan_type) 1456{ 1457 struct ath_softc *sc = priv; 1458 struct ath_rate_priv *ath_rc_priv = priv_sta; 1459 const struct ath_rate_table *rate_table = NULL; 1460 bool oper_cw40 = false, oper_sgi; 1461 bool local_cw40 = (ath_rc_priv->ht_cap & WLAN_RC_40_FLAG) ? 1462 true : false; 1463 bool local_sgi = (ath_rc_priv->ht_cap & WLAN_RC_SGI_FLAG) ? 1464 true : false; 1465 1466 1467 if (changed & IEEE80211_RC_HT_CHANGED) { 1468 if (sc->sc_ah->opmode != NL80211_IFTYPE_STATION) 1469 return; 1470 1471 if (oper_chan_type == NL80211_CHAN_HT40MINUS || 1472 oper_chan_type == NL80211_CHAN_HT40PLUS) 1473 oper_cw40 = true; 1474 1475 if (oper_cw40) 1476 oper_sgi = (sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_40) ? 1477 true : false; 1478 else if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_SGI_20) 1479 oper_sgi = (sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_20) ? 1480 true : false; 1481 else 1482 oper_sgi = false; 1483 1484 if ((local_cw40 != oper_cw40) || (local_sgi != oper_sgi)) { 1485 rate_table = ath_choose_rate_table(sc, sband->band, 1486 sta->ht_cap.ht_supported, 1487 oper_cw40); 1488 ath_rc_priv->ht_cap = ath_rc_build_ht_caps(sc, sta, 1489 oper_cw40, oper_sgi); 1490 ath_rc_init(sc, priv_sta, sband, sta, rate_table); 1491 1492 ath_print(ath9k_hw_common(sc->sc_ah), ATH_DBG_CONFIG, 1493 "Operating HT Bandwidth changed to: %d\n", 1494 sc->hw->conf.channel_type); 1495 sc->cur_rate_table = hw_rate_table[sc->cur_rate_mode]; 1496 } 1497 } 1498} 1499 1500static void *ath_rate_alloc(struct ieee80211_hw *hw, struct dentry *debugfsdir) 1501{ 1502 struct ath_wiphy *aphy = hw->priv; 1503 return aphy->sc; 1504} 1505 1506static void ath_rate_free(void *priv) 1507{ 1508 return; 1509} 1510 1511static void *ath_rate_alloc_sta(void *priv, struct ieee80211_sta *sta, gfp_t gfp) 1512{ 1513 struct ath_softc *sc = priv; 1514 struct ath_rate_priv *rate_priv; 1515 1516 rate_priv = kzalloc(sizeof(struct ath_rate_priv), gfp); 1517 if (!rate_priv) { 1518 ath_print(ath9k_hw_common(sc->sc_ah), ATH_DBG_FATAL, 1519 "Unable to allocate private rc structure\n"); 1520 return NULL; 1521 } 1522 1523 rate_priv->tx_triglevel_max = sc->sc_ah->caps.tx_triglevel_max; 1524 1525 return rate_priv; 1526} 1527 1528static void ath_rate_free_sta(void *priv, struct ieee80211_sta *sta, 1529 void *priv_sta) 1530{ 1531 struct ath_rate_priv *rate_priv = priv_sta; 1532 kfree(rate_priv); 1533} 1534 1535static struct rate_control_ops ath_rate_ops = { 1536 .module = NULL, 1537 .name = "ath9k_rate_control", 1538 .tx_status = ath_tx_status, 1539 .get_rate = ath_get_rate, 1540 .rate_init = ath_rate_init, 1541 .rate_update = ath_rate_update, 1542 .alloc = ath_rate_alloc, 1543 .free = ath_rate_free, 1544 .alloc_sta = ath_rate_alloc_sta, 1545 .free_sta = ath_rate_free_sta, 1546}; 1547 1548int ath_rate_control_register(void) 1549{ 1550 return ieee80211_rate_control_register(&ath_rate_ops); 1551} 1552 1553void ath_rate_control_unregister(void) 1554{ 1555 ieee80211_rate_control_unregister(&ath_rate_ops); 1556} 1557