Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1 | /****************************************************************************** |
| 2 | * |
Emmanuel Grumbach | 51368bf | 2013-12-30 13:15:54 +0200 | [diff] [blame] | 3 | * Copyright(c) 2005 - 2014 Intel Corporation. All rights reserved. |
Johannes Berg | 8b4139d | 2014-07-24 14:05:26 +0200 | [diff] [blame] | 4 | * Copyright(c) 2013 - 2014 Intel Mobile Communications GmbH |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 5 | * |
| 6 | * This program is free software; you can redistribute it and/or modify it |
| 7 | * under the terms of version 2 of the GNU General Public License as |
| 8 | * published by the Free Software Foundation. |
| 9 | * |
| 10 | * This program is distributed in the hope that it will be useful, but WITHOUT |
| 11 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| 12 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for |
| 13 | * more details. |
| 14 | * |
| 15 | * You should have received a copy of the GNU General Public License along with |
| 16 | * this program; if not, write to the Free Software Foundation, Inc., |
| 17 | * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA |
| 18 | * |
| 19 | * The full GNU General Public License is included in this distribution in the |
| 20 | * file called LICENSE. |
| 21 | * |
| 22 | * Contact Information: |
| 23 | * Intel Linux Wireless <ilw@linux.intel.com> |
| 24 | * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497 |
| 25 | * |
| 26 | *****************************************************************************/ |
| 27 | #include <linux/kernel.h> |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 28 | #include <linux/skbuff.h> |
| 29 | #include <linux/slab.h> |
| 30 | #include <net/mac80211.h> |
| 31 | |
| 32 | #include <linux/netdevice.h> |
| 33 | #include <linux/etherdevice.h> |
| 34 | #include <linux/delay.h> |
| 35 | |
| 36 | #include <linux/workqueue.h> |
| 37 | #include "rs.h" |
| 38 | #include "fw-api.h" |
| 39 | #include "sta.h" |
| 40 | #include "iwl-op-mode.h" |
| 41 | #include "mvm.h" |
Eyal Shapira | 1e9c62f | 2015-01-28 14:44:06 +0200 | [diff] [blame] | 42 | #include "debugfs.h" |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 43 | |
| 44 | #define RS_NAME "iwl-mvm-rs" |
| 45 | |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 46 | #define IWL_RATE_MAX_WINDOW 62 /* # tx in history window */ |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 47 | |
Eyal Shapira | 834437d | 2014-12-17 15:38:58 +0200 | [diff] [blame] | 48 | /* Calculations of success ratio are done in fixed point where 12800 is 100%. |
| 49 | * Use this macro when dealing with thresholds consts set as a percentage |
| 50 | */ |
| 51 | #define RS_PERCENT(x) (128 * x) |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 52 | |
| 53 | static u8 rs_ht_to_legacy[] = { |
Eyal Shapira | da87d7d | 2013-11-28 12:27:03 +0200 | [diff] [blame] | 54 | [IWL_RATE_MCS_0_INDEX] = IWL_RATE_6M_INDEX, |
| 55 | [IWL_RATE_MCS_1_INDEX] = IWL_RATE_9M_INDEX, |
| 56 | [IWL_RATE_MCS_2_INDEX] = IWL_RATE_12M_INDEX, |
| 57 | [IWL_RATE_MCS_3_INDEX] = IWL_RATE_18M_INDEX, |
| 58 | [IWL_RATE_MCS_4_INDEX] = IWL_RATE_24M_INDEX, |
| 59 | [IWL_RATE_MCS_5_INDEX] = IWL_RATE_36M_INDEX, |
| 60 | [IWL_RATE_MCS_6_INDEX] = IWL_RATE_48M_INDEX, |
| 61 | [IWL_RATE_MCS_7_INDEX] = IWL_RATE_54M_INDEX, |
| 62 | [IWL_RATE_MCS_8_INDEX] = IWL_RATE_54M_INDEX, |
| 63 | [IWL_RATE_MCS_9_INDEX] = IWL_RATE_54M_INDEX, |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 64 | }; |
| 65 | |
| 66 | static const u8 ant_toggle_lookup[] = { |
Eliad Peller | ef4394b | 2013-07-16 18:07:20 +0300 | [diff] [blame] | 67 | [ANT_NONE] = ANT_NONE, |
| 68 | [ANT_A] = ANT_B, |
| 69 | [ANT_B] = ANT_C, |
| 70 | [ANT_AB] = ANT_BC, |
| 71 | [ANT_C] = ANT_A, |
| 72 | [ANT_AC] = ANT_AB, |
| 73 | [ANT_BC] = ANT_AC, |
| 74 | [ANT_ABC] = ANT_ABC, |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 75 | }; |
| 76 | |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 77 | #define IWL_DECLARE_RATE_INFO(r, s, rp, rn) \ |
| 78 | [IWL_RATE_##r##M_INDEX] = { IWL_RATE_##r##M_PLCP, \ |
| 79 | IWL_RATE_HT_SISO_MCS_##s##_PLCP, \ |
| 80 | IWL_RATE_HT_MIMO2_MCS_##s##_PLCP, \ |
| 81 | IWL_RATE_VHT_SISO_MCS_##s##_PLCP, \ |
| 82 | IWL_RATE_VHT_MIMO2_MCS_##s##_PLCP,\ |
| 83 | IWL_RATE_##rp##M_INDEX, \ |
Eyal Shapira | ab055ce | 2013-08-04 13:10:31 +0300 | [diff] [blame] | 84 | IWL_RATE_##rn##M_INDEX } |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 85 | |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 86 | #define IWL_DECLARE_MCS_RATE(s) \ |
| 87 | [IWL_RATE_MCS_##s##_INDEX] = { IWL_RATE_INVM_PLCP, \ |
| 88 | IWL_RATE_HT_SISO_MCS_##s##_PLCP, \ |
| 89 | IWL_RATE_HT_MIMO2_MCS_##s##_PLCP, \ |
| 90 | IWL_RATE_VHT_SISO_MCS_##s##_PLCP, \ |
| 91 | IWL_RATE_VHT_MIMO2_MCS_##s##_PLCP, \ |
| 92 | IWL_RATE_INVM_INDEX, \ |
| 93 | IWL_RATE_INVM_INDEX } |
| 94 | |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 95 | /* |
| 96 | * Parameter order: |
Eyal Shapira | ab055ce | 2013-08-04 13:10:31 +0300 | [diff] [blame] | 97 | * rate, ht rate, prev rate, next rate |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 98 | * |
| 99 | * If there isn't a valid next or previous rate then INV is used which |
| 100 | * maps to IWL_RATE_INVALID |
| 101 | * |
| 102 | */ |
| 103 | static const struct iwl_rs_rate_info iwl_rates[IWL_RATE_COUNT] = { |
Eyal Shapira | ab055ce | 2013-08-04 13:10:31 +0300 | [diff] [blame] | 104 | IWL_DECLARE_RATE_INFO(1, INV, INV, 2), /* 1mbps */ |
| 105 | IWL_DECLARE_RATE_INFO(2, INV, 1, 5), /* 2mbps */ |
| 106 | IWL_DECLARE_RATE_INFO(5, INV, 2, 11), /*5.5mbps */ |
| 107 | IWL_DECLARE_RATE_INFO(11, INV, 9, 12), /* 11mbps */ |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 108 | IWL_DECLARE_RATE_INFO(6, 0, 5, 11), /* 6mbps ; MCS 0 */ |
| 109 | IWL_DECLARE_RATE_INFO(9, INV, 6, 11), /* 9mbps */ |
| 110 | IWL_DECLARE_RATE_INFO(12, 1, 11, 18), /* 12mbps ; MCS 1 */ |
| 111 | IWL_DECLARE_RATE_INFO(18, 2, 12, 24), /* 18mbps ; MCS 2 */ |
| 112 | IWL_DECLARE_RATE_INFO(24, 3, 18, 36), /* 24mbps ; MCS 3 */ |
| 113 | IWL_DECLARE_RATE_INFO(36, 4, 24, 48), /* 36mbps ; MCS 4 */ |
| 114 | IWL_DECLARE_RATE_INFO(48, 5, 36, 54), /* 48mbps ; MCS 5 */ |
| 115 | IWL_DECLARE_RATE_INFO(54, 6, 48, INV), /* 54mbps ; MCS 6 */ |
| 116 | IWL_DECLARE_MCS_RATE(7), /* MCS 7 */ |
| 117 | IWL_DECLARE_MCS_RATE(8), /* MCS 8 */ |
| 118 | IWL_DECLARE_MCS_RATE(9), /* MCS 9 */ |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 119 | }; |
| 120 | |
Eyal Shapira | 4e4b815 | 2013-12-11 00:55:36 +0200 | [diff] [blame] | 121 | enum rs_action { |
| 122 | RS_ACTION_STAY = 0, |
| 123 | RS_ACTION_DOWNSCALE = -1, |
| 124 | RS_ACTION_UPSCALE = 1, |
| 125 | }; |
| 126 | |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 127 | enum rs_column_mode { |
| 128 | RS_INVALID = 0, |
| 129 | RS_LEGACY, |
| 130 | RS_SISO, |
| 131 | RS_MIMO2, |
| 132 | }; |
| 133 | |
Eyal Shapira | fd7dbee | 2014-04-06 04:39:23 +0300 | [diff] [blame] | 134 | #define MAX_NEXT_COLUMNS 7 |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 135 | #define MAX_COLUMN_CHECKS 3 |
| 136 | |
Eyal Shapira | 0b8d17f | 2015-02-02 15:21:27 +0200 | [diff] [blame] | 137 | struct rs_tx_column; |
| 138 | |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 139 | typedef bool (*allow_column_func_t) (struct iwl_mvm *mvm, |
| 140 | struct ieee80211_sta *sta, |
Eyal Shapira | 0b8d17f | 2015-02-02 15:21:27 +0200 | [diff] [blame] | 141 | struct iwl_scale_tbl_info *tbl, |
| 142 | const struct rs_tx_column *next_col); |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 143 | |
| 144 | struct rs_tx_column { |
| 145 | enum rs_column_mode mode; |
| 146 | u8 ant; |
| 147 | bool sgi; |
| 148 | enum rs_column next_columns[MAX_NEXT_COLUMNS]; |
| 149 | allow_column_func_t checks[MAX_COLUMN_CHECKS]; |
| 150 | }; |
| 151 | |
Emmanuel Grumbach | 219fb66 | 2014-10-30 11:59:40 +0200 | [diff] [blame] | 152 | static bool rs_ant_allow(struct iwl_mvm *mvm, struct ieee80211_sta *sta, |
Eyal Shapira | 0b8d17f | 2015-02-02 15:21:27 +0200 | [diff] [blame] | 153 | struct iwl_scale_tbl_info *tbl, |
| 154 | const struct rs_tx_column *next_col) |
Emmanuel Grumbach | 219fb66 | 2014-10-30 11:59:40 +0200 | [diff] [blame] | 155 | { |
Eyal Shapira | 0b8d17f | 2015-02-02 15:21:27 +0200 | [diff] [blame] | 156 | return iwl_mvm_bt_coex_is_ant_avail(mvm, next_col->ant); |
Emmanuel Grumbach | 219fb66 | 2014-10-30 11:59:40 +0200 | [diff] [blame] | 157 | } |
| 158 | |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 159 | static bool rs_mimo_allow(struct iwl_mvm *mvm, struct ieee80211_sta *sta, |
Eyal Shapira | 0b8d17f | 2015-02-02 15:21:27 +0200 | [diff] [blame] | 160 | struct iwl_scale_tbl_info *tbl, |
| 161 | const struct rs_tx_column *next_col) |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 162 | { |
Eyal Shapira | 7ac4a50 | 2015-02-01 21:46:00 +0200 | [diff] [blame] | 163 | struct iwl_mvm_sta *mvmsta; |
| 164 | struct iwl_mvm_vif *mvmvif; |
| 165 | |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 166 | if (!sta->ht_cap.ht_supported) |
| 167 | return false; |
| 168 | |
| 169 | if (sta->smps_mode == IEEE80211_SMPS_STATIC) |
| 170 | return false; |
| 171 | |
Moshe Harel | a054427 | 2014-12-08 21:13:14 +0200 | [diff] [blame] | 172 | if (num_of_ant(iwl_mvm_get_valid_tx_ant(mvm)) < 2) |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 173 | return false; |
| 174 | |
| 175 | if (!iwl_mvm_bt_coex_is_mimo_allowed(mvm, sta)) |
| 176 | return false; |
| 177 | |
Eyal Shapira | 7ac4a50 | 2015-02-01 21:46:00 +0200 | [diff] [blame] | 178 | mvmsta = iwl_mvm_sta_from_mac80211(sta); |
| 179 | mvmvif = iwl_mvm_vif_from_mac80211(mvmsta->vif); |
| 180 | if (iwl_mvm_vif_low_latency(mvmvif) && mvmsta->vif->p2p) |
| 181 | return false; |
| 182 | |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 183 | return true; |
| 184 | } |
| 185 | |
| 186 | static bool rs_siso_allow(struct iwl_mvm *mvm, struct ieee80211_sta *sta, |
Eyal Shapira | 0b8d17f | 2015-02-02 15:21:27 +0200 | [diff] [blame] | 187 | struct iwl_scale_tbl_info *tbl, |
| 188 | const struct rs_tx_column *next_col) |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 189 | { |
| 190 | if (!sta->ht_cap.ht_supported) |
| 191 | return false; |
| 192 | |
| 193 | return true; |
| 194 | } |
| 195 | |
| 196 | static bool rs_sgi_allow(struct iwl_mvm *mvm, struct ieee80211_sta *sta, |
Eyal Shapira | 0b8d17f | 2015-02-02 15:21:27 +0200 | [diff] [blame] | 197 | struct iwl_scale_tbl_info *tbl, |
| 198 | const struct rs_tx_column *next_col) |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 199 | { |
| 200 | struct rs_rate *rate = &tbl->rate; |
| 201 | struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap; |
| 202 | struct ieee80211_sta_vht_cap *vht_cap = &sta->vht_cap; |
| 203 | |
| 204 | if (is_ht20(rate) && (ht_cap->cap & |
| 205 | IEEE80211_HT_CAP_SGI_20)) |
| 206 | return true; |
| 207 | if (is_ht40(rate) && (ht_cap->cap & |
| 208 | IEEE80211_HT_CAP_SGI_40)) |
| 209 | return true; |
| 210 | if (is_ht80(rate) && (vht_cap->cap & |
| 211 | IEEE80211_VHT_CAP_SHORT_GI_80)) |
| 212 | return true; |
| 213 | |
| 214 | return false; |
| 215 | } |
| 216 | |
| 217 | static const struct rs_tx_column rs_tx_columns[] = { |
| 218 | [RS_COLUMN_LEGACY_ANT_A] = { |
| 219 | .mode = RS_LEGACY, |
| 220 | .ant = ANT_A, |
| 221 | .next_columns = { |
| 222 | RS_COLUMN_LEGACY_ANT_B, |
| 223 | RS_COLUMN_SISO_ANT_A, |
Eyal Shapira | 31b2045 | 2014-04-08 17:52:27 +0300 | [diff] [blame] | 224 | RS_COLUMN_MIMO2, |
Eyal Shapira | d8fff91 | 2014-04-06 05:27:36 +0300 | [diff] [blame] | 225 | RS_COLUMN_INVALID, |
| 226 | RS_COLUMN_INVALID, |
Eyal Shapira | fd7dbee | 2014-04-06 04:39:23 +0300 | [diff] [blame] | 227 | RS_COLUMN_INVALID, |
| 228 | RS_COLUMN_INVALID, |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 229 | }, |
Emmanuel Grumbach | 219fb66 | 2014-10-30 11:59:40 +0200 | [diff] [blame] | 230 | .checks = { |
| 231 | rs_ant_allow, |
| 232 | }, |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 233 | }, |
| 234 | [RS_COLUMN_LEGACY_ANT_B] = { |
| 235 | .mode = RS_LEGACY, |
| 236 | .ant = ANT_B, |
| 237 | .next_columns = { |
| 238 | RS_COLUMN_LEGACY_ANT_A, |
| 239 | RS_COLUMN_SISO_ANT_B, |
Eyal Shapira | 31b2045 | 2014-04-08 17:52:27 +0300 | [diff] [blame] | 240 | RS_COLUMN_MIMO2, |
Eyal Shapira | d8fff91 | 2014-04-06 05:27:36 +0300 | [diff] [blame] | 241 | RS_COLUMN_INVALID, |
| 242 | RS_COLUMN_INVALID, |
Eyal Shapira | fd7dbee | 2014-04-06 04:39:23 +0300 | [diff] [blame] | 243 | RS_COLUMN_INVALID, |
| 244 | RS_COLUMN_INVALID, |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 245 | }, |
Emmanuel Grumbach | 219fb66 | 2014-10-30 11:59:40 +0200 | [diff] [blame] | 246 | .checks = { |
| 247 | rs_ant_allow, |
| 248 | }, |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 249 | }, |
| 250 | [RS_COLUMN_SISO_ANT_A] = { |
| 251 | .mode = RS_SISO, |
| 252 | .ant = ANT_A, |
| 253 | .next_columns = { |
| 254 | RS_COLUMN_SISO_ANT_B, |
| 255 | RS_COLUMN_MIMO2, |
| 256 | RS_COLUMN_SISO_ANT_A_SGI, |
Eyal Shapira | fd7dbee | 2014-04-06 04:39:23 +0300 | [diff] [blame] | 257 | RS_COLUMN_LEGACY_ANT_A, |
| 258 | RS_COLUMN_LEGACY_ANT_B, |
Eyal Shapira | d8fff91 | 2014-04-06 05:27:36 +0300 | [diff] [blame] | 259 | RS_COLUMN_INVALID, |
Eyal Shapira | 31b2045 | 2014-04-08 17:52:27 +0300 | [diff] [blame] | 260 | RS_COLUMN_INVALID, |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 261 | }, |
| 262 | .checks = { |
| 263 | rs_siso_allow, |
Emmanuel Grumbach | 219fb66 | 2014-10-30 11:59:40 +0200 | [diff] [blame] | 264 | rs_ant_allow, |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 265 | }, |
| 266 | }, |
| 267 | [RS_COLUMN_SISO_ANT_B] = { |
| 268 | .mode = RS_SISO, |
| 269 | .ant = ANT_B, |
| 270 | .next_columns = { |
| 271 | RS_COLUMN_SISO_ANT_A, |
| 272 | RS_COLUMN_MIMO2, |
| 273 | RS_COLUMN_SISO_ANT_B_SGI, |
Eyal Shapira | fd7dbee | 2014-04-06 04:39:23 +0300 | [diff] [blame] | 274 | RS_COLUMN_LEGACY_ANT_A, |
| 275 | RS_COLUMN_LEGACY_ANT_B, |
Eyal Shapira | d8fff91 | 2014-04-06 05:27:36 +0300 | [diff] [blame] | 276 | RS_COLUMN_INVALID, |
Eyal Shapira | 31b2045 | 2014-04-08 17:52:27 +0300 | [diff] [blame] | 277 | RS_COLUMN_INVALID, |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 278 | }, |
| 279 | .checks = { |
| 280 | rs_siso_allow, |
Emmanuel Grumbach | 219fb66 | 2014-10-30 11:59:40 +0200 | [diff] [blame] | 281 | rs_ant_allow, |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 282 | }, |
| 283 | }, |
| 284 | [RS_COLUMN_SISO_ANT_A_SGI] = { |
| 285 | .mode = RS_SISO, |
| 286 | .ant = ANT_A, |
| 287 | .sgi = true, |
| 288 | .next_columns = { |
| 289 | RS_COLUMN_SISO_ANT_B_SGI, |
| 290 | RS_COLUMN_MIMO2_SGI, |
| 291 | RS_COLUMN_SISO_ANT_A, |
Eyal Shapira | fd7dbee | 2014-04-06 04:39:23 +0300 | [diff] [blame] | 292 | RS_COLUMN_LEGACY_ANT_A, |
| 293 | RS_COLUMN_LEGACY_ANT_B, |
Eyal Shapira | 31b2045 | 2014-04-08 17:52:27 +0300 | [diff] [blame] | 294 | RS_COLUMN_INVALID, |
| 295 | RS_COLUMN_INVALID, |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 296 | }, |
| 297 | .checks = { |
| 298 | rs_siso_allow, |
Emmanuel Grumbach | 219fb66 | 2014-10-30 11:59:40 +0200 | [diff] [blame] | 299 | rs_ant_allow, |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 300 | rs_sgi_allow, |
| 301 | }, |
| 302 | }, |
| 303 | [RS_COLUMN_SISO_ANT_B_SGI] = { |
| 304 | .mode = RS_SISO, |
| 305 | .ant = ANT_B, |
| 306 | .sgi = true, |
| 307 | .next_columns = { |
| 308 | RS_COLUMN_SISO_ANT_A_SGI, |
| 309 | RS_COLUMN_MIMO2_SGI, |
| 310 | RS_COLUMN_SISO_ANT_B, |
Eyal Shapira | fd7dbee | 2014-04-06 04:39:23 +0300 | [diff] [blame] | 311 | RS_COLUMN_LEGACY_ANT_A, |
| 312 | RS_COLUMN_LEGACY_ANT_B, |
Eyal Shapira | 31b2045 | 2014-04-08 17:52:27 +0300 | [diff] [blame] | 313 | RS_COLUMN_INVALID, |
| 314 | RS_COLUMN_INVALID, |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 315 | }, |
| 316 | .checks = { |
| 317 | rs_siso_allow, |
Emmanuel Grumbach | 219fb66 | 2014-10-30 11:59:40 +0200 | [diff] [blame] | 318 | rs_ant_allow, |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 319 | rs_sgi_allow, |
| 320 | }, |
| 321 | }, |
| 322 | [RS_COLUMN_MIMO2] = { |
| 323 | .mode = RS_MIMO2, |
| 324 | .ant = ANT_AB, |
| 325 | .next_columns = { |
| 326 | RS_COLUMN_SISO_ANT_A, |
| 327 | RS_COLUMN_MIMO2_SGI, |
Eyal Shapira | fd7dbee | 2014-04-06 04:39:23 +0300 | [diff] [blame] | 328 | RS_COLUMN_LEGACY_ANT_A, |
| 329 | RS_COLUMN_LEGACY_ANT_B, |
Eyal Shapira | 31b2045 | 2014-04-08 17:52:27 +0300 | [diff] [blame] | 330 | RS_COLUMN_INVALID, |
| 331 | RS_COLUMN_INVALID, |
| 332 | RS_COLUMN_INVALID, |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 333 | }, |
| 334 | .checks = { |
| 335 | rs_mimo_allow, |
| 336 | }, |
| 337 | }, |
| 338 | [RS_COLUMN_MIMO2_SGI] = { |
| 339 | .mode = RS_MIMO2, |
| 340 | .ant = ANT_AB, |
| 341 | .sgi = true, |
| 342 | .next_columns = { |
| 343 | RS_COLUMN_SISO_ANT_A_SGI, |
| 344 | RS_COLUMN_MIMO2, |
Eyal Shapira | fd7dbee | 2014-04-06 04:39:23 +0300 | [diff] [blame] | 345 | RS_COLUMN_LEGACY_ANT_A, |
| 346 | RS_COLUMN_LEGACY_ANT_B, |
Eyal Shapira | 31b2045 | 2014-04-08 17:52:27 +0300 | [diff] [blame] | 347 | RS_COLUMN_INVALID, |
| 348 | RS_COLUMN_INVALID, |
| 349 | RS_COLUMN_INVALID, |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 350 | }, |
| 351 | .checks = { |
| 352 | rs_mimo_allow, |
| 353 | rs_sgi_allow, |
| 354 | }, |
| 355 | }, |
| 356 | }; |
| 357 | |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 358 | static inline u8 rs_extract_rate(u32 rate_n_flags) |
| 359 | { |
| 360 | /* also works for HT because bits 7:6 are zero there */ |
| 361 | return (u8)(rate_n_flags & RATE_LEGACY_RATE_MSK); |
| 362 | } |
| 363 | |
| 364 | static int iwl_hwrate_to_plcp_idx(u32 rate_n_flags) |
| 365 | { |
| 366 | int idx = 0; |
| 367 | |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 368 | if (rate_n_flags & RATE_MCS_HT_MSK) { |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 369 | idx = rate_n_flags & RATE_HT_MCS_RATE_CODE_MSK; |
| 370 | idx += IWL_RATE_MCS_0_INDEX; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 371 | |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 372 | /* skip 9M not supported in HT*/ |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 373 | if (idx >= IWL_RATE_9M_INDEX) |
| 374 | idx += 1; |
Eyal Shapira | 4e82dd3 | 2013-08-04 23:58:37 +0300 | [diff] [blame] | 375 | if ((idx >= IWL_FIRST_HT_RATE) && (idx <= IWL_LAST_HT_RATE)) |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 376 | return idx; |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 377 | } else if (rate_n_flags & RATE_MCS_VHT_MSK) { |
| 378 | idx = rate_n_flags & RATE_VHT_MCS_RATE_CODE_MSK; |
| 379 | idx += IWL_RATE_MCS_0_INDEX; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 380 | |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 381 | /* skip 9M not supported in VHT*/ |
| 382 | if (idx >= IWL_RATE_9M_INDEX) |
| 383 | idx++; |
| 384 | if ((idx >= IWL_FIRST_VHT_RATE) && (idx <= IWL_LAST_VHT_RATE)) |
| 385 | return idx; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 386 | } else { |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 387 | /* legacy rate format, search for match in table */ |
| 388 | |
| 389 | u8 legacy_rate = rs_extract_rate(rate_n_flags); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 390 | for (idx = 0; idx < ARRAY_SIZE(iwl_rates); idx++) |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 391 | if (iwl_rates[idx].plcp == legacy_rate) |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 392 | return idx; |
| 393 | } |
| 394 | |
Eyal Shapira | 560843f | 2014-01-05 21:04:19 +0200 | [diff] [blame] | 395 | return IWL_RATE_INVALID; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 396 | } |
| 397 | |
| 398 | static void rs_rate_scale_perform(struct iwl_mvm *mvm, |
Eyal Shapira | 1ebc8f2 | 2014-09-14 15:23:23 +0300 | [diff] [blame] | 399 | struct ieee80211_sta *sta, |
| 400 | struct iwl_lq_sta *lq_sta, |
| 401 | int tid); |
Eyal Shapira | 8fc7c58 | 2013-12-04 02:15:46 +0200 | [diff] [blame] | 402 | static void rs_fill_lq_cmd(struct iwl_mvm *mvm, |
| 403 | struct ieee80211_sta *sta, |
| 404 | struct iwl_lq_sta *lq_sta, |
| 405 | const struct rs_rate *initial_rate); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 406 | static void rs_stay_in_table(struct iwl_lq_sta *lq_sta, bool force_search); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 407 | |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 408 | /** |
| 409 | * The following tables contain the expected throughput metrics for all rates |
| 410 | * |
| 411 | * 1, 2, 5.5, 11, 6, 9, 12, 18, 24, 36, 48, 54, 60 MBits |
| 412 | * |
| 413 | * where invalid entries are zeros. |
| 414 | * |
| 415 | * CCK rates are only valid in legacy table and will only be used in G |
| 416 | * (2.4 GHz) band. |
| 417 | */ |
| 418 | |
Johannes Berg | a34529e | 2014-01-20 22:57:21 +0100 | [diff] [blame] | 419 | static const u16 expected_tpt_legacy[IWL_RATE_COUNT] = { |
Eyal Shapira | 4e82dd3 | 2013-08-04 23:58:37 +0300 | [diff] [blame] | 420 | 7, 13, 35, 58, 40, 57, 72, 98, 121, 154, 177, 186, 0, 0, 0 |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 421 | }; |
| 422 | |
Eyal Shapira | 4e82dd3 | 2013-08-04 23:58:37 +0300 | [diff] [blame] | 423 | /* Expected TpT tables. 4 indexes: |
| 424 | * 0 - NGI, 1 - SGI, 2 - AGG+NGI, 3 - AGG+SGI |
| 425 | */ |
Johannes Berg | a34529e | 2014-01-20 22:57:21 +0100 | [diff] [blame] | 426 | static const u16 expected_tpt_siso_20MHz[4][IWL_RATE_COUNT] = { |
Eyal Shapira | 4e82dd3 | 2013-08-04 23:58:37 +0300 | [diff] [blame] | 427 | {0, 0, 0, 0, 42, 0, 76, 102, 124, 159, 183, 193, 202, 216, 0}, |
| 428 | {0, 0, 0, 0, 46, 0, 82, 110, 132, 168, 192, 202, 210, 225, 0}, |
| 429 | {0, 0, 0, 0, 49, 0, 97, 145, 192, 285, 375, 420, 464, 551, 0}, |
| 430 | {0, 0, 0, 0, 54, 0, 108, 160, 213, 315, 415, 465, 513, 608, 0}, |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 431 | }; |
| 432 | |
Johannes Berg | a34529e | 2014-01-20 22:57:21 +0100 | [diff] [blame] | 433 | static const u16 expected_tpt_siso_40MHz[4][IWL_RATE_COUNT] = { |
Eyal Shapira | 4e82dd3 | 2013-08-04 23:58:37 +0300 | [diff] [blame] | 434 | {0, 0, 0, 0, 77, 0, 127, 160, 184, 220, 242, 250, 257, 269, 275}, |
| 435 | {0, 0, 0, 0, 83, 0, 135, 169, 193, 229, 250, 257, 264, 275, 280}, |
| 436 | {0, 0, 0, 0, 101, 0, 199, 295, 389, 570, 744, 828, 911, 1070, 1173}, |
| 437 | {0, 0, 0, 0, 112, 0, 220, 326, 429, 629, 819, 912, 1000, 1173, 1284}, |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 438 | }; |
| 439 | |
Johannes Berg | a34529e | 2014-01-20 22:57:21 +0100 | [diff] [blame] | 440 | static const u16 expected_tpt_siso_80MHz[4][IWL_RATE_COUNT] = { |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 441 | {0, 0, 0, 0, 130, 0, 191, 223, 244, 273, 288, 294, 298, 305, 308}, |
| 442 | {0, 0, 0, 0, 138, 0, 200, 231, 251, 279, 293, 298, 302, 308, 312}, |
| 443 | {0, 0, 0, 0, 217, 0, 429, 634, 834, 1220, 1585, 1760, 1931, 2258, 2466}, |
| 444 | {0, 0, 0, 0, 241, 0, 475, 701, 921, 1343, 1741, 1931, 2117, 2468, 2691}, |
| 445 | }; |
| 446 | |
Johannes Berg | a34529e | 2014-01-20 22:57:21 +0100 | [diff] [blame] | 447 | static const u16 expected_tpt_mimo2_20MHz[4][IWL_RATE_COUNT] = { |
Eyal Shapira | 4e82dd3 | 2013-08-04 23:58:37 +0300 | [diff] [blame] | 448 | {0, 0, 0, 0, 74, 0, 123, 155, 179, 213, 235, 243, 250, 261, 0}, |
| 449 | {0, 0, 0, 0, 81, 0, 131, 164, 187, 221, 242, 250, 256, 267, 0}, |
| 450 | {0, 0, 0, 0, 98, 0, 193, 286, 375, 550, 718, 799, 878, 1032, 0}, |
| 451 | {0, 0, 0, 0, 109, 0, 214, 316, 414, 607, 790, 879, 965, 1132, 0}, |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 452 | }; |
| 453 | |
Johannes Berg | a34529e | 2014-01-20 22:57:21 +0100 | [diff] [blame] | 454 | static const u16 expected_tpt_mimo2_40MHz[4][IWL_RATE_COUNT] = { |
Eyal Shapira | 4e82dd3 | 2013-08-04 23:58:37 +0300 | [diff] [blame] | 455 | {0, 0, 0, 0, 123, 0, 182, 214, 235, 264, 279, 285, 289, 296, 300}, |
| 456 | {0, 0, 0, 0, 131, 0, 191, 222, 242, 270, 284, 289, 293, 300, 303}, |
| 457 | {0, 0, 0, 0, 200, 0, 390, 571, 741, 1067, 1365, 1505, 1640, 1894, 2053}, |
| 458 | {0, 0, 0, 0, 221, 0, 430, 630, 816, 1169, 1490, 1641, 1784, 2053, 2221}, |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 459 | }; |
| 460 | |
Johannes Berg | a34529e | 2014-01-20 22:57:21 +0100 | [diff] [blame] | 461 | static const u16 expected_tpt_mimo2_80MHz[4][IWL_RATE_COUNT] = { |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 462 | {0, 0, 0, 0, 182, 0, 240, 264, 278, 299, 308, 311, 313, 317, 319}, |
| 463 | {0, 0, 0, 0, 190, 0, 247, 269, 282, 302, 310, 313, 315, 319, 320}, |
| 464 | {0, 0, 0, 0, 428, 0, 833, 1215, 1577, 2254, 2863, 3147, 3418, 3913, 4219}, |
| 465 | {0, 0, 0, 0, 474, 0, 920, 1338, 1732, 2464, 3116, 3418, 3705, 4225, 4545}, |
| 466 | }; |
| 467 | |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 468 | /* mbps, mcs */ |
| 469 | static const struct iwl_rate_mcs_info iwl_rate_mcs[IWL_RATE_COUNT] = { |
| 470 | { "1", "BPSK DSSS"}, |
| 471 | { "2", "QPSK DSSS"}, |
| 472 | {"5.5", "BPSK CCK"}, |
| 473 | { "11", "QPSK CCK"}, |
| 474 | { "6", "BPSK 1/2"}, |
| 475 | { "9", "BPSK 1/2"}, |
| 476 | { "12", "QPSK 1/2"}, |
| 477 | { "18", "QPSK 3/4"}, |
| 478 | { "24", "16QAM 1/2"}, |
| 479 | { "36", "16QAM 3/4"}, |
| 480 | { "48", "64QAM 2/3"}, |
| 481 | { "54", "64QAM 3/4"}, |
| 482 | { "60", "64QAM 5/6"}, |
| 483 | }; |
| 484 | |
| 485 | #define MCS_INDEX_PER_STREAM (8) |
| 486 | |
Emmanuel Grumbach | 9d10849 | 2013-12-03 11:50:30 +0200 | [diff] [blame] | 487 | static const char *rs_pretty_ant(u8 ant) |
| 488 | { |
| 489 | static const char * const ant_name[] = { |
| 490 | [ANT_NONE] = "None", |
| 491 | [ANT_A] = "A", |
| 492 | [ANT_B] = "B", |
| 493 | [ANT_AB] = "AB", |
| 494 | [ANT_C] = "C", |
| 495 | [ANT_AC] = "AC", |
| 496 | [ANT_BC] = "BC", |
| 497 | [ANT_ABC] = "ABC", |
| 498 | }; |
| 499 | |
| 500 | if (ant > ANT_ABC) |
| 501 | return "UNKNOWN"; |
| 502 | |
| 503 | return ant_name[ant]; |
| 504 | } |
| 505 | |
| 506 | static const char *rs_pretty_lq_type(enum iwl_table_type type) |
| 507 | { |
| 508 | static const char * const lq_types[] = { |
| 509 | [LQ_NONE] = "NONE", |
| 510 | [LQ_LEGACY_A] = "LEGACY_A", |
| 511 | [LQ_LEGACY_G] = "LEGACY_G", |
| 512 | [LQ_HT_SISO] = "HT SISO", |
| 513 | [LQ_HT_MIMO2] = "HT MIMO", |
| 514 | [LQ_VHT_SISO] = "VHT SISO", |
| 515 | [LQ_VHT_MIMO2] = "VHT MIMO", |
| 516 | }; |
| 517 | |
| 518 | if (type < LQ_NONE || type >= LQ_MAX) |
| 519 | return "UNKNOWN"; |
| 520 | |
| 521 | return lq_types[type]; |
| 522 | } |
| 523 | |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 524 | static inline void rs_dump_rate(struct iwl_mvm *mvm, const struct rs_rate *rate, |
| 525 | const char *prefix) |
| 526 | { |
Eyal Shapira | d8bafea | 2014-10-23 13:58:38 +0300 | [diff] [blame] | 527 | IWL_DEBUG_RATE(mvm, |
Eyal Shapira | 26a2cc0 | 2014-11-05 12:03:59 +0200 | [diff] [blame] | 528 | "%s: (%s: %d) ANT: %s BW: %d SGI: %d LDPC: %d STBC: %d\n", |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 529 | prefix, rs_pretty_lq_type(rate->type), |
| 530 | rate->index, rs_pretty_ant(rate->ant), |
Eyal Shapira | d8bafea | 2014-10-23 13:58:38 +0300 | [diff] [blame] | 531 | rate->bw, rate->sgi, rate->ldpc, rate->stbc); |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 532 | } |
| 533 | |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 534 | static void rs_rate_scale_clear_window(struct iwl_rate_scale_data *window) |
| 535 | { |
| 536 | window->data = 0; |
| 537 | window->success_counter = 0; |
| 538 | window->success_ratio = IWL_INVALID_VALUE; |
| 539 | window->counter = 0; |
| 540 | window->average_tpt = IWL_INVALID_VALUE; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 541 | } |
| 542 | |
Eyal Shapira | b804eeb | 2014-04-06 04:27:06 +0300 | [diff] [blame] | 543 | static void rs_rate_scale_clear_tbl_windows(struct iwl_mvm *mvm, |
| 544 | struct iwl_scale_tbl_info *tbl) |
Eliad Peller | 3ca71f6 | 2014-03-10 16:33:43 +0200 | [diff] [blame] | 545 | { |
| 546 | int i; |
| 547 | |
Eyal Shapira | b804eeb | 2014-04-06 04:27:06 +0300 | [diff] [blame] | 548 | IWL_DEBUG_RATE(mvm, "Clearing up window stats\n"); |
Eliad Peller | 3ca71f6 | 2014-03-10 16:33:43 +0200 | [diff] [blame] | 549 | for (i = 0; i < IWL_RATE_COUNT; i++) |
| 550 | rs_rate_scale_clear_window(&tbl->win[i]); |
Eliad Peller | 2fd647f | 2014-03-13 17:21:36 +0200 | [diff] [blame] | 551 | |
| 552 | for (i = 0; i < ARRAY_SIZE(tbl->tpc_win); i++) |
| 553 | rs_rate_scale_clear_window(&tbl->tpc_win[i]); |
Eliad Peller | 3ca71f6 | 2014-03-10 16:33:43 +0200 | [diff] [blame] | 554 | } |
| 555 | |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 556 | static inline u8 rs_is_valid_ant(u8 valid_antenna, u8 ant_type) |
| 557 | { |
| 558 | return (ant_type & valid_antenna) == ant_type; |
| 559 | } |
| 560 | |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 561 | static int rs_tl_turn_on_agg_for_tid(struct iwl_mvm *mvm, |
| 562 | struct iwl_lq_sta *lq_data, u8 tid, |
| 563 | struct ieee80211_sta *sta) |
| 564 | { |
| 565 | int ret = -EAGAIN; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 566 | |
Emmanuel Grumbach | 44cc429 | 2013-06-18 06:33:49 +0300 | [diff] [blame] | 567 | IWL_DEBUG_HT(mvm, "Starting Tx agg: STA: %pM tid: %d\n", |
| 568 | sta->addr, tid); |
| 569 | ret = ieee80211_start_tx_ba_session(sta, tid, 5000); |
| 570 | if (ret == -EAGAIN) { |
| 571 | /* |
| 572 | * driver and mac80211 is out of sync |
| 573 | * this might be cause by reloading firmware |
| 574 | * stop the tx ba session here |
| 575 | */ |
| 576 | IWL_ERR(mvm, "Fail start Tx agg on tid: %d\n", |
| 577 | tid); |
| 578 | ieee80211_stop_tx_ba_session(sta, tid); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 579 | } |
| 580 | return ret; |
| 581 | } |
| 582 | |
| 583 | static void rs_tl_turn_on_agg(struct iwl_mvm *mvm, u8 tid, |
| 584 | struct iwl_lq_sta *lq_data, |
| 585 | struct ieee80211_sta *sta) |
| 586 | { |
| 587 | if (tid < IWL_MAX_TID_COUNT) |
| 588 | rs_tl_turn_on_agg_for_tid(mvm, lq_data, tid, sta); |
| 589 | else |
| 590 | IWL_ERR(mvm, "tid exceeds max TID count: %d/%d\n", |
| 591 | tid, IWL_MAX_TID_COUNT); |
| 592 | } |
| 593 | |
| 594 | static inline int get_num_of_ant_from_rate(u32 rate_n_flags) |
| 595 | { |
| 596 | return !!(rate_n_flags & RATE_MCS_ANT_A_MSK) + |
| 597 | !!(rate_n_flags & RATE_MCS_ANT_B_MSK) + |
| 598 | !!(rate_n_flags & RATE_MCS_ANT_C_MSK); |
| 599 | } |
| 600 | |
| 601 | /* |
| 602 | * Static function to get the expected throughput from an iwl_scale_tbl_info |
| 603 | * that wraps a NULL pointer check |
| 604 | */ |
| 605 | static s32 get_expected_tpt(struct iwl_scale_tbl_info *tbl, int rs_index) |
| 606 | { |
| 607 | if (tbl->expected_tpt) |
| 608 | return tbl->expected_tpt[rs_index]; |
| 609 | return 0; |
| 610 | } |
| 611 | |
| 612 | /** |
| 613 | * rs_collect_tx_data - Update the success/failure sliding window |
| 614 | * |
| 615 | * We keep a sliding window of the last 62 packets transmitted |
| 616 | * at this rate. window->data contains the bitmask of successful |
| 617 | * packets. |
| 618 | */ |
Eyal Shapira | 834437d | 2014-12-17 15:38:58 +0200 | [diff] [blame] | 619 | static int _rs_collect_tx_data(struct iwl_mvm *mvm, |
| 620 | struct iwl_scale_tbl_info *tbl, |
Eliad Peller | 0bd3c5a | 2014-03-10 16:07:04 +0200 | [diff] [blame] | 621 | int scale_index, int attempts, int successes, |
| 622 | struct iwl_rate_scale_data *window) |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 623 | { |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 624 | static const u64 mask = (((u64)1) << (IWL_RATE_MAX_WINDOW - 1)); |
| 625 | s32 fail_count, tpt; |
| 626 | |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 627 | /* Get expected throughput */ |
| 628 | tpt = get_expected_tpt(tbl, scale_index); |
| 629 | |
| 630 | /* |
| 631 | * Keep track of only the latest 62 tx frame attempts in this rate's |
| 632 | * history window; anything older isn't really relevant any more. |
| 633 | * If we have filled up the sliding window, drop the oldest attempt; |
| 634 | * if the oldest attempt (highest bit in bitmap) shows "success", |
| 635 | * subtract "1" from the success counter (this is the main reason |
| 636 | * we keep these bitmaps!). |
| 637 | */ |
| 638 | while (attempts > 0) { |
| 639 | if (window->counter >= IWL_RATE_MAX_WINDOW) { |
| 640 | /* remove earliest */ |
| 641 | window->counter = IWL_RATE_MAX_WINDOW - 1; |
| 642 | |
| 643 | if (window->data & mask) { |
| 644 | window->data &= ~mask; |
| 645 | window->success_counter--; |
| 646 | } |
| 647 | } |
| 648 | |
| 649 | /* Increment frames-attempted counter */ |
| 650 | window->counter++; |
| 651 | |
| 652 | /* Shift bitmap by one frame to throw away oldest history */ |
| 653 | window->data <<= 1; |
| 654 | |
| 655 | /* Mark the most recent #successes attempts as successful */ |
| 656 | if (successes > 0) { |
| 657 | window->success_counter++; |
| 658 | window->data |= 0x1; |
| 659 | successes--; |
| 660 | } |
| 661 | |
| 662 | attempts--; |
| 663 | } |
| 664 | |
| 665 | /* Calculate current success ratio, avoid divide-by-0! */ |
| 666 | if (window->counter > 0) |
| 667 | window->success_ratio = 128 * (100 * window->success_counter) |
| 668 | / window->counter; |
| 669 | else |
| 670 | window->success_ratio = IWL_INVALID_VALUE; |
| 671 | |
| 672 | fail_count = window->counter - window->success_counter; |
| 673 | |
| 674 | /* Calculate average throughput, if we have enough history. */ |
Eyal Shapira | 834437d | 2014-12-17 15:38:58 +0200 | [diff] [blame] | 675 | if ((fail_count >= IWL_MVM_RS_RATE_MIN_FAILURE_TH) || |
| 676 | (window->success_counter >= IWL_MVM_RS_RATE_MIN_SUCCESS_TH)) |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 677 | window->average_tpt = (window->success_ratio * tpt + 64) / 128; |
| 678 | else |
| 679 | window->average_tpt = IWL_INVALID_VALUE; |
| 680 | |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 681 | return 0; |
| 682 | } |
| 683 | |
Eyal Shapira | 834437d | 2014-12-17 15:38:58 +0200 | [diff] [blame] | 684 | static int rs_collect_tx_data(struct iwl_mvm *mvm, |
| 685 | struct iwl_lq_sta *lq_sta, |
Eyal Shapira | 757cf23b | 2014-03-24 02:12:00 +0200 | [diff] [blame] | 686 | struct iwl_scale_tbl_info *tbl, |
Eliad Peller | 2fd647f | 2014-03-13 17:21:36 +0200 | [diff] [blame] | 687 | int scale_index, int attempts, int successes, |
| 688 | u8 reduced_txp) |
Eliad Peller | 0bd3c5a | 2014-03-10 16:07:04 +0200 | [diff] [blame] | 689 | { |
| 690 | struct iwl_rate_scale_data *window = NULL; |
Eliad Peller | 2fd647f | 2014-03-13 17:21:36 +0200 | [diff] [blame] | 691 | int ret; |
Eliad Peller | 0bd3c5a | 2014-03-10 16:07:04 +0200 | [diff] [blame] | 692 | |
| 693 | if (scale_index < 0 || scale_index >= IWL_RATE_COUNT) |
| 694 | return -EINVAL; |
| 695 | |
Eyal Shapira | 757cf23b | 2014-03-24 02:12:00 +0200 | [diff] [blame] | 696 | if (tbl->column != RS_COLUMN_INVALID) { |
Eyal Shapira | f58220f | 2014-08-16 01:30:30 +0300 | [diff] [blame] | 697 | struct lq_sta_pers *pers = &lq_sta->pers; |
| 698 | |
| 699 | pers->tx_stats[tbl->column][scale_index].total += attempts; |
| 700 | pers->tx_stats[tbl->column][scale_index].success += successes; |
Eyal Shapira | 757cf23b | 2014-03-24 02:12:00 +0200 | [diff] [blame] | 701 | } |
| 702 | |
Eliad Peller | 0bd3c5a | 2014-03-10 16:07:04 +0200 | [diff] [blame] | 703 | /* Select window for current tx bit rate */ |
| 704 | window = &(tbl->win[scale_index]); |
| 705 | |
Eyal Shapira | 834437d | 2014-12-17 15:38:58 +0200 | [diff] [blame] | 706 | ret = _rs_collect_tx_data(mvm, tbl, scale_index, attempts, successes, |
Eliad Peller | 2fd647f | 2014-03-13 17:21:36 +0200 | [diff] [blame] | 707 | window); |
| 708 | if (ret) |
| 709 | return ret; |
| 710 | |
| 711 | if (WARN_ON_ONCE(reduced_txp > TPC_MAX_REDUCTION)) |
| 712 | return -EINVAL; |
| 713 | |
| 714 | window = &tbl->tpc_win[reduced_txp]; |
Eyal Shapira | 834437d | 2014-12-17 15:38:58 +0200 | [diff] [blame] | 715 | return _rs_collect_tx_data(mvm, tbl, scale_index, attempts, successes, |
Eliad Peller | 0bd3c5a | 2014-03-10 16:07:04 +0200 | [diff] [blame] | 716 | window); |
| 717 | } |
| 718 | |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 719 | /* Convert rs_rate object into ucode rate bitmask */ |
| 720 | static u32 ucode_rate_from_rs_rate(struct iwl_mvm *mvm, |
Eyal Shapira | 8fc7c58 | 2013-12-04 02:15:46 +0200 | [diff] [blame] | 721 | struct rs_rate *rate) |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 722 | { |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 723 | u32 ucode_rate = 0; |
| 724 | int index = rate->index; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 725 | |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 726 | ucode_rate |= ((rate->ant << RATE_MCS_ANT_POS) & |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 727 | RATE_MCS_ANT_ABC_MSK); |
| 728 | |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 729 | if (is_legacy(rate)) { |
| 730 | ucode_rate |= iwl_rates[index].plcp; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 731 | if (index >= IWL_FIRST_CCK_RATE && index <= IWL_LAST_CCK_RATE) |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 732 | ucode_rate |= RATE_MCS_CCK_MSK; |
| 733 | return ucode_rate; |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 734 | } |
| 735 | |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 736 | if (is_ht(rate)) { |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 737 | if (index < IWL_FIRST_HT_RATE || index > IWL_LAST_HT_RATE) { |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 738 | IWL_ERR(mvm, "Invalid HT rate index %d\n", index); |
Eyal Shapira | 4e82dd3 | 2013-08-04 23:58:37 +0300 | [diff] [blame] | 739 | index = IWL_LAST_HT_RATE; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 740 | } |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 741 | ucode_rate |= RATE_MCS_HT_MSK; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 742 | |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 743 | if (is_ht_siso(rate)) |
| 744 | ucode_rate |= iwl_rates[index].plcp_ht_siso; |
| 745 | else if (is_ht_mimo2(rate)) |
| 746 | ucode_rate |= iwl_rates[index].plcp_ht_mimo2; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 747 | else |
Eyal Shapira | d972ab3 | 2013-07-28 23:02:45 +0000 | [diff] [blame] | 748 | WARN_ON_ONCE(1); |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 749 | } else if (is_vht(rate)) { |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 750 | if (index < IWL_FIRST_VHT_RATE || index > IWL_LAST_VHT_RATE) { |
| 751 | IWL_ERR(mvm, "Invalid VHT rate index %d\n", index); |
| 752 | index = IWL_LAST_VHT_RATE; |
| 753 | } |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 754 | ucode_rate |= RATE_MCS_VHT_MSK; |
| 755 | if (is_vht_siso(rate)) |
| 756 | ucode_rate |= iwl_rates[index].plcp_vht_siso; |
| 757 | else if (is_vht_mimo2(rate)) |
| 758 | ucode_rate |= iwl_rates[index].plcp_vht_mimo2; |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 759 | else |
| 760 | WARN_ON_ONCE(1); |
| 761 | |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 762 | } else { |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 763 | IWL_ERR(mvm, "Invalid rate->type %d\n", rate->type); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 764 | } |
| 765 | |
Eyal Shapira | d8bafea | 2014-10-23 13:58:38 +0300 | [diff] [blame] | 766 | if (is_siso(rate) && rate->stbc) { |
| 767 | /* To enable STBC we need to set both a flag and ANT_AB */ |
| 768 | ucode_rate |= RATE_MCS_ANT_AB_MSK; |
| 769 | ucode_rate |= RATE_MCS_VHT_STBC_MSK; |
| 770 | } |
| 771 | |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 772 | ucode_rate |= rate->bw; |
| 773 | if (rate->sgi) |
| 774 | ucode_rate |= RATE_MCS_SGI_MSK; |
Eyal Shapira | a3576ff | 2014-08-09 10:57:59 +0300 | [diff] [blame] | 775 | if (rate->ldpc) |
| 776 | ucode_rate |= RATE_MCS_LDPC_MSK; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 777 | |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 778 | return ucode_rate; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 779 | } |
| 780 | |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 781 | /* Convert a ucode rate into an rs_rate object */ |
| 782 | static int rs_rate_from_ucode_rate(const u32 ucode_rate, |
| 783 | enum ieee80211_band band, |
| 784 | struct rs_rate *rate) |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 785 | { |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 786 | u32 ant_msk = ucode_rate & RATE_MCS_ANT_ABC_MSK; |
| 787 | u8 num_of_ant = get_num_of_ant_from_rate(ucode_rate); |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 788 | u8 nss; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 789 | |
Emmanuel Grumbach | 9e898f1 | 2013-12-22 10:55:47 +0200 | [diff] [blame] | 790 | memset(rate, 0, sizeof(*rate)); |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 791 | rate->index = iwl_hwrate_to_plcp_idx(ucode_rate); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 792 | |
Eyal Shapira | 560843f | 2014-01-05 21:04:19 +0200 | [diff] [blame] | 793 | if (rate->index == IWL_RATE_INVALID) |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 794 | return -EINVAL; |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 795 | |
| 796 | rate->ant = (ant_msk >> RATE_MCS_ANT_POS); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 797 | |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 798 | /* Legacy */ |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 799 | if (!(ucode_rate & RATE_MCS_HT_MSK) && |
| 800 | !(ucode_rate & RATE_MCS_VHT_MSK)) { |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 801 | if (num_of_ant == 1) { |
| 802 | if (band == IEEE80211_BAND_5GHZ) |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 803 | rate->type = LQ_LEGACY_A; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 804 | else |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 805 | rate->type = LQ_LEGACY_G; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 806 | } |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 807 | |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 808 | return 0; |
| 809 | } |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 810 | |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 811 | /* HT or VHT */ |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 812 | if (ucode_rate & RATE_MCS_SGI_MSK) |
| 813 | rate->sgi = true; |
Eyal Shapira | a3576ff | 2014-08-09 10:57:59 +0300 | [diff] [blame] | 814 | if (ucode_rate & RATE_MCS_LDPC_MSK) |
| 815 | rate->ldpc = true; |
Eyal Shapira | d8bafea | 2014-10-23 13:58:38 +0300 | [diff] [blame] | 816 | if (ucode_rate & RATE_MCS_VHT_STBC_MSK) |
| 817 | rate->stbc = true; |
Eyal Shapira | ba69d0e | 2015-01-30 01:38:29 +0200 | [diff] [blame] | 818 | if (ucode_rate & RATE_MCS_BF_MSK) |
| 819 | rate->bfer = true; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 820 | |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 821 | rate->bw = ucode_rate & RATE_MCS_CHAN_WIDTH_MSK; |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 822 | |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 823 | if (ucode_rate & RATE_MCS_HT_MSK) { |
| 824 | nss = ((ucode_rate & RATE_HT_MCS_NSS_MSK) >> |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 825 | RATE_HT_MCS_NSS_POS) + 1; |
| 826 | |
| 827 | if (nss == 1) { |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 828 | rate->type = LQ_HT_SISO; |
Eyal Shapira | ba69d0e | 2015-01-30 01:38:29 +0200 | [diff] [blame] | 829 | WARN_ONCE(!rate->stbc && !rate->bfer && num_of_ant != 1, |
| 830 | "stbc %d bfer %d", |
| 831 | rate->stbc, rate->bfer); |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 832 | } else if (nss == 2) { |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 833 | rate->type = LQ_HT_MIMO2; |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 834 | WARN_ON_ONCE(num_of_ant != 2); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 835 | } else { |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 836 | WARN_ON_ONCE(1); |
| 837 | } |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 838 | } else if (ucode_rate & RATE_MCS_VHT_MSK) { |
| 839 | nss = ((ucode_rate & RATE_VHT_MCS_NSS_MSK) >> |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 840 | RATE_VHT_MCS_NSS_POS) + 1; |
| 841 | |
| 842 | if (nss == 1) { |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 843 | rate->type = LQ_VHT_SISO; |
Eyal Shapira | ba69d0e | 2015-01-30 01:38:29 +0200 | [diff] [blame] | 844 | WARN_ONCE(!rate->stbc && !rate->bfer && num_of_ant != 1, |
| 845 | "stbc %d bfer %d", |
| 846 | rate->stbc, rate->bfer); |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 847 | } else if (nss == 2) { |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 848 | rate->type = LQ_VHT_MIMO2; |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 849 | WARN_ON_ONCE(num_of_ant != 2); |
| 850 | } else { |
| 851 | WARN_ON_ONCE(1); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 852 | } |
| 853 | } |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 854 | |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 855 | WARN_ON_ONCE(rate->bw == RATE_MCS_CHAN_WIDTH_160); |
| 856 | WARN_ON_ONCE(rate->bw == RATE_MCS_CHAN_WIDTH_80 && |
| 857 | !is_vht(rate)); |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 858 | |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 859 | return 0; |
| 860 | } |
| 861 | |
| 862 | /* switch to another antenna/antennas and return 1 */ |
| 863 | /* if no other valid antenna found, return 0 */ |
Eyal Shapira | 8fc7c58 | 2013-12-04 02:15:46 +0200 | [diff] [blame] | 864 | static int rs_toggle_antenna(u32 valid_ant, struct rs_rate *rate) |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 865 | { |
| 866 | u8 new_ant_type; |
| 867 | |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 868 | if (!rate->ant || rate->ant > ANT_ABC) |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 869 | return 0; |
| 870 | |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 871 | if (!rs_is_valid_ant(valid_ant, rate->ant)) |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 872 | return 0; |
| 873 | |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 874 | new_ant_type = ant_toggle_lookup[rate->ant]; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 875 | |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 876 | while ((new_ant_type != rate->ant) && |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 877 | !rs_is_valid_ant(valid_ant, new_ant_type)) |
| 878 | new_ant_type = ant_toggle_lookup[new_ant_type]; |
| 879 | |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 880 | if (new_ant_type == rate->ant) |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 881 | return 0; |
| 882 | |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 883 | rate->ant = new_ant_type; |
| 884 | |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 885 | return 1; |
| 886 | } |
| 887 | |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 888 | static u16 rs_get_supported_rates(struct iwl_lq_sta *lq_sta, |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 889 | struct rs_rate *rate) |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 890 | { |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 891 | if (is_legacy(rate)) |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 892 | return lq_sta->active_legacy_rate; |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 893 | else if (is_siso(rate)) |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 894 | return lq_sta->active_siso_rate; |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 895 | else if (is_mimo2(rate)) |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 896 | return lq_sta->active_mimo2_rate; |
| 897 | |
| 898 | WARN_ON_ONCE(1); |
| 899 | return 0; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 900 | } |
| 901 | |
| 902 | static u16 rs_get_adjacent_rate(struct iwl_mvm *mvm, u8 index, u16 rate_mask, |
| 903 | int rate_type) |
| 904 | { |
| 905 | u8 high = IWL_RATE_INVALID; |
| 906 | u8 low = IWL_RATE_INVALID; |
| 907 | |
| 908 | /* 802.11A or ht walks to the next literal adjacent rate in |
| 909 | * the rate table */ |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 910 | if (is_type_a_band(rate_type) || !is_type_legacy(rate_type)) { |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 911 | int i; |
| 912 | u32 mask; |
| 913 | |
| 914 | /* Find the previous rate that is in the rate mask */ |
| 915 | i = index - 1; |
| 916 | for (mask = (1 << i); i >= 0; i--, mask >>= 1) { |
| 917 | if (rate_mask & mask) { |
| 918 | low = i; |
| 919 | break; |
| 920 | } |
| 921 | } |
| 922 | |
| 923 | /* Find the next rate that is in the rate mask */ |
| 924 | i = index + 1; |
| 925 | for (mask = (1 << i); i < IWL_RATE_COUNT; i++, mask <<= 1) { |
| 926 | if (rate_mask & mask) { |
| 927 | high = i; |
| 928 | break; |
| 929 | } |
| 930 | } |
| 931 | |
| 932 | return (high << 8) | low; |
| 933 | } |
| 934 | |
| 935 | low = index; |
| 936 | while (low != IWL_RATE_INVALID) { |
| 937 | low = iwl_rates[low].prev_rs; |
| 938 | if (low == IWL_RATE_INVALID) |
| 939 | break; |
| 940 | if (rate_mask & (1 << low)) |
| 941 | break; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 942 | } |
| 943 | |
| 944 | high = index; |
| 945 | while (high != IWL_RATE_INVALID) { |
| 946 | high = iwl_rates[high].next_rs; |
| 947 | if (high == IWL_RATE_INVALID) |
| 948 | break; |
| 949 | if (rate_mask & (1 << high)) |
| 950 | break; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 951 | } |
| 952 | |
| 953 | return (high << 8) | low; |
| 954 | } |
| 955 | |
Eyal Shapira | e07be6d | 2013-12-09 13:02:56 +0200 | [diff] [blame] | 956 | static inline bool rs_rate_supported(struct iwl_lq_sta *lq_sta, |
| 957 | struct rs_rate *rate) |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 958 | { |
Eyal Shapira | e07be6d | 2013-12-09 13:02:56 +0200 | [diff] [blame] | 959 | return BIT(rate->index) & rs_get_supported_rates(lq_sta, rate); |
| 960 | } |
| 961 | |
| 962 | /* Get the next supported lower rate in the current column. |
| 963 | * Return true if bottom rate in the current column was reached |
| 964 | */ |
| 965 | static bool rs_get_lower_rate_in_column(struct iwl_lq_sta *lq_sta, |
| 966 | struct rs_rate *rate) |
| 967 | { |
| 968 | u8 low; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 969 | u16 high_low; |
Eyal Shapira | e07be6d | 2013-12-09 13:02:56 +0200 | [diff] [blame] | 970 | u16 rate_mask; |
Eliad Peller | ae969af | 2014-06-11 15:51:33 +0300 | [diff] [blame] | 971 | struct iwl_mvm *mvm = lq_sta->pers.drv; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 972 | |
Eyal Shapira | e07be6d | 2013-12-09 13:02:56 +0200 | [diff] [blame] | 973 | rate_mask = rs_get_supported_rates(lq_sta, rate); |
| 974 | high_low = rs_get_adjacent_rate(mvm, rate->index, rate_mask, |
| 975 | rate->type); |
| 976 | low = high_low & 0xff; |
| 977 | |
| 978 | /* Bottom rate of column reached */ |
| 979 | if (low == IWL_RATE_INVALID) |
| 980 | return true; |
| 981 | |
| 982 | rate->index = low; |
| 983 | return false; |
| 984 | } |
| 985 | |
| 986 | /* Get the next rate to use following a column downgrade */ |
| 987 | static void rs_get_lower_rate_down_column(struct iwl_lq_sta *lq_sta, |
| 988 | struct rs_rate *rate) |
| 989 | { |
Eliad Peller | ae969af | 2014-06-11 15:51:33 +0300 | [diff] [blame] | 990 | struct iwl_mvm *mvm = lq_sta->pers.drv; |
Eyal Shapira | e07be6d | 2013-12-09 13:02:56 +0200 | [diff] [blame] | 991 | |
| 992 | if (is_legacy(rate)) { |
| 993 | /* No column to downgrade from Legacy */ |
| 994 | return; |
| 995 | } else if (is_siso(rate)) { |
| 996 | /* Downgrade to Legacy if we were in SISO */ |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 997 | if (lq_sta->band == IEEE80211_BAND_5GHZ) |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 998 | rate->type = LQ_LEGACY_A; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 999 | else |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 1000 | rate->type = LQ_LEGACY_G; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1001 | |
Eyal Shapira | a56db7d | 2013-11-28 12:35:42 +0200 | [diff] [blame] | 1002 | rate->bw = RATE_MCS_CHAN_WIDTH_20; |
Eyal Shapira | e07be6d | 2013-12-09 13:02:56 +0200 | [diff] [blame] | 1003 | |
Emmanuel Grumbach | b800040 | 2014-02-03 22:17:19 +0200 | [diff] [blame] | 1004 | WARN_ON_ONCE(rate->index < IWL_RATE_MCS_0_INDEX || |
Eyal Shapira | e07be6d | 2013-12-09 13:02:56 +0200 | [diff] [blame] | 1005 | rate->index > IWL_RATE_MCS_9_INDEX); |
| 1006 | |
| 1007 | rate->index = rs_ht_to_legacy[rate->index]; |
Eyal Shapira | a3576ff | 2014-08-09 10:57:59 +0300 | [diff] [blame] | 1008 | rate->ldpc = false; |
Eyal Shapira | e07be6d | 2013-12-09 13:02:56 +0200 | [diff] [blame] | 1009 | } else { |
| 1010 | /* Downgrade to SISO with same MCS if in MIMO */ |
| 1011 | rate->type = is_vht_mimo2(rate) ? |
| 1012 | LQ_VHT_SISO : LQ_HT_SISO; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1013 | } |
| 1014 | |
Eyal Shapira | e07be6d | 2013-12-09 13:02:56 +0200 | [diff] [blame] | 1015 | if (num_of_ant(rate->ant) > 1) |
Moshe Harel | a054427 | 2014-12-08 21:13:14 +0200 | [diff] [blame] | 1016 | rate->ant = first_antenna(iwl_mvm_get_valid_tx_ant(mvm)); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1017 | |
Eyal Shapira | e07be6d | 2013-12-09 13:02:56 +0200 | [diff] [blame] | 1018 | /* Relevant in both switching to SISO or Legacy */ |
| 1019 | rate->sgi = false; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1020 | |
Eyal Shapira | e07be6d | 2013-12-09 13:02:56 +0200 | [diff] [blame] | 1021 | if (!rs_rate_supported(lq_sta, rate)) |
| 1022 | rs_get_lower_rate_in_column(lq_sta, rate); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1023 | } |
| 1024 | |
Eyal Shapira | ba69d0e | 2015-01-30 01:38:29 +0200 | [diff] [blame] | 1025 | /* Check if both rates are identical |
| 1026 | * allow_ant_mismatch enables matching a SISO rate on ANT_A or ANT_B |
| 1027 | * with a rate indicating STBC/BFER and ANT_AB. |
| 1028 | */ |
Eyal Shapira | 929e6ed | 2015-01-30 13:40:02 +0200 | [diff] [blame] | 1029 | static inline bool rs_rate_equal(struct rs_rate *a, |
Eyal Shapira | ba69d0e | 2015-01-30 01:38:29 +0200 | [diff] [blame] | 1030 | struct rs_rate *b, |
| 1031 | bool allow_ant_mismatch) |
| 1032 | |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1033 | { |
Eyal Shapira | ba69d0e | 2015-01-30 01:38:29 +0200 | [diff] [blame] | 1034 | bool ant_match = (a->ant == b->ant) && (a->stbc == b->stbc) && |
| 1035 | (a->bfer == b->bfer); |
| 1036 | |
| 1037 | if (allow_ant_mismatch) { |
| 1038 | if (a->stbc || a->bfer) { |
| 1039 | WARN_ONCE(a->ant != ANT_AB, "stbc %d bfer %d ant %d", |
| 1040 | a->stbc, a->bfer, a->ant); |
| 1041 | ant_match |= (b->ant == ANT_A || b->ant == ANT_B); |
| 1042 | } else if (b->stbc || b->bfer) { |
| 1043 | WARN_ONCE(b->ant != ANT_AB, "stbc %d bfer %d ant %d", |
| 1044 | b->stbc, b->bfer, b->ant); |
| 1045 | ant_match |= (a->ant == ANT_A || a->ant == ANT_B); |
| 1046 | } |
| 1047 | } |
| 1048 | |
Eyal Shapira | 929e6ed | 2015-01-30 13:40:02 +0200 | [diff] [blame] | 1049 | return (a->type == b->type) && (a->bw == b->bw) && (a->sgi == b->sgi) && |
Eyal Shapira | ba69d0e | 2015-01-30 01:38:29 +0200 | [diff] [blame] | 1050 | (a->ldpc == b->ldpc) && (a->index == b->index) && ant_match; |
Eyal Shapira | 929e6ed | 2015-01-30 13:40:02 +0200 | [diff] [blame] | 1051 | } |
| 1052 | |
| 1053 | /* Check if both rates share the same column */ |
| 1054 | static inline bool rs_rate_column_match(struct rs_rate *a, |
| 1055 | struct rs_rate *b) |
| 1056 | { |
Eyal Shapira | d8bafea | 2014-10-23 13:58:38 +0300 | [diff] [blame] | 1057 | bool ant_match; |
| 1058 | |
Eyal Shapira | ba69d0e | 2015-01-30 01:38:29 +0200 | [diff] [blame] | 1059 | if (a->stbc || a->bfer) |
Eyal Shapira | d8bafea | 2014-10-23 13:58:38 +0300 | [diff] [blame] | 1060 | ant_match = (b->ant == ANT_A || b->ant == ANT_B); |
| 1061 | else |
| 1062 | ant_match = (a->ant == b->ant); |
| 1063 | |
| 1064 | return (a->type == b->type) && (a->bw == b->bw) && (a->sgi == b->sgi) |
| 1065 | && ant_match; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1066 | } |
| 1067 | |
Eyal Shapira | ad82d8a | 2015-03-08 19:43:41 +0200 | [diff] [blame] | 1068 | static inline enum rs_column rs_get_column_from_rate(struct rs_rate *rate) |
| 1069 | { |
| 1070 | if (is_legacy(rate)) { |
| 1071 | if (rate->ant == ANT_A) |
| 1072 | return RS_COLUMN_LEGACY_ANT_A; |
| 1073 | |
| 1074 | if (rate->ant == ANT_B) |
| 1075 | return RS_COLUMN_LEGACY_ANT_B; |
| 1076 | |
| 1077 | goto err; |
| 1078 | } |
| 1079 | |
| 1080 | if (is_siso(rate)) { |
| 1081 | if (rate->ant == ANT_A || rate->stbc || rate->bfer) |
| 1082 | return rate->sgi ? RS_COLUMN_SISO_ANT_A_SGI : |
| 1083 | RS_COLUMN_SISO_ANT_A; |
| 1084 | |
| 1085 | if (rate->ant == ANT_B) |
| 1086 | return rate->sgi ? RS_COLUMN_SISO_ANT_B_SGI : |
| 1087 | RS_COLUMN_SISO_ANT_B; |
| 1088 | |
| 1089 | goto err; |
| 1090 | } |
| 1091 | |
| 1092 | if (is_mimo(rate)) |
| 1093 | return rate->sgi ? RS_COLUMN_MIMO2_SGI : RS_COLUMN_MIMO2; |
| 1094 | |
| 1095 | err: |
| 1096 | return RS_COLUMN_INVALID; |
| 1097 | } |
| 1098 | |
Eyal Shapira | 1ebc8f2 | 2014-09-14 15:23:23 +0300 | [diff] [blame] | 1099 | static u8 rs_get_tid(struct ieee80211_hdr *hdr) |
| 1100 | { |
| 1101 | u8 tid = IWL_MAX_TID_COUNT; |
| 1102 | |
| 1103 | if (ieee80211_is_data_qos(hdr->frame_control)) { |
| 1104 | u8 *qc = ieee80211_get_qos_ctl(hdr); |
| 1105 | tid = qc[0] & 0xf; |
| 1106 | } |
| 1107 | |
| 1108 | if (unlikely(tid > IWL_MAX_TID_COUNT)) |
| 1109 | tid = IWL_MAX_TID_COUNT; |
| 1110 | |
| 1111 | return tid; |
| 1112 | } |
| 1113 | |
| 1114 | void iwl_mvm_rs_tx_status(struct iwl_mvm *mvm, struct ieee80211_sta *sta, |
| 1115 | int tid, struct ieee80211_tx_info *info) |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1116 | { |
| 1117 | int legacy_success; |
| 1118 | int retries; |
Eyal Shapira | 929e6ed | 2015-01-30 13:40:02 +0200 | [diff] [blame] | 1119 | int i; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1120 | struct iwl_lq_cmd *table; |
Eyal Shapira | 929e6ed | 2015-01-30 13:40:02 +0200 | [diff] [blame] | 1121 | u32 lq_hwrate; |
| 1122 | struct rs_rate lq_rate, tx_resp_rate; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1123 | struct iwl_scale_tbl_info *curr_tbl, *other_tbl, *tmp_tbl; |
Eliad Peller | 2fd647f | 2014-03-13 17:21:36 +0200 | [diff] [blame] | 1124 | u8 reduced_txp = (uintptr_t)info->status.status_driver_data[0]; |
Eyal Shapira | 929e6ed | 2015-01-30 13:40:02 +0200 | [diff] [blame] | 1125 | u32 tx_resp_hwrate = (uintptr_t)info->status.status_driver_data[1]; |
Eyal Shapira | 1ebc8f2 | 2014-09-14 15:23:23 +0300 | [diff] [blame] | 1126 | struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta); |
| 1127 | struct iwl_lq_sta *lq_sta = &mvmsta->lq_sta; |
Eyal Shapira | ba69d0e | 2015-01-30 01:38:29 +0200 | [diff] [blame] | 1128 | bool allow_ant_mismatch = mvm->fw->ucode_capa.api[0] & |
| 1129 | IWL_UCODE_TLV_API_LQ_SS_PARAMS; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1130 | |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1131 | /* Treat uninitialized rate scaling data same as non-existing. */ |
| 1132 | if (!lq_sta) { |
| 1133 | IWL_DEBUG_RATE(mvm, "Station rate scaling not created yet.\n"); |
| 1134 | return; |
Eliad Peller | ae969af | 2014-06-11 15:51:33 +0300 | [diff] [blame] | 1135 | } else if (!lq_sta->pers.drv) { |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1136 | IWL_DEBUG_RATE(mvm, "Rate scaling not initialized yet.\n"); |
| 1137 | return; |
| 1138 | } |
| 1139 | |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1140 | /* This packet was aggregated but doesn't carry status info */ |
| 1141 | if ((info->flags & IEEE80211_TX_CTL_AMPDU) && |
| 1142 | !(info->flags & IEEE80211_TX_STAT_AMPDU)) |
| 1143 | return; |
| 1144 | |
Eyal Shapira | ad82d8a | 2015-03-08 19:43:41 +0200 | [diff] [blame] | 1145 | rs_rate_from_ucode_rate(tx_resp_hwrate, info->band, &tx_resp_rate); |
| 1146 | |
| 1147 | #ifdef CONFIG_MAC80211_DEBUGFS |
| 1148 | /* Disable last tx check if we are debugging with fixed rate but |
| 1149 | * update tx stats */ |
| 1150 | if (lq_sta->pers.dbg_fixed_rate) { |
| 1151 | int index = tx_resp_rate.index; |
| 1152 | enum rs_column column; |
| 1153 | int attempts, success; |
| 1154 | |
| 1155 | column = rs_get_column_from_rate(&tx_resp_rate); |
| 1156 | if (WARN_ONCE(column == RS_COLUMN_INVALID, |
| 1157 | "Can't map rate 0x%x to column", |
| 1158 | tx_resp_hwrate)) |
| 1159 | return; |
| 1160 | |
| 1161 | if (info->flags & IEEE80211_TX_STAT_AMPDU) { |
| 1162 | attempts = info->status.ampdu_len; |
| 1163 | success = info->status.ampdu_ack_len; |
| 1164 | } else { |
| 1165 | attempts = info->status.rates[0].count; |
| 1166 | success = !!(info->flags & IEEE80211_TX_STAT_ACK); |
| 1167 | } |
| 1168 | |
| 1169 | lq_sta->pers.tx_stats[column][index].total += attempts; |
| 1170 | lq_sta->pers.tx_stats[column][index].success += success; |
| 1171 | |
| 1172 | IWL_DEBUG_RATE(mvm, "Fixed rate 0x%x success %d attempts %d\n", |
| 1173 | tx_resp_hwrate, success, attempts); |
| 1174 | return; |
| 1175 | } |
| 1176 | #endif |
| 1177 | |
Eyal Shapira | 87d5e41 | 2014-04-06 18:13:22 +0300 | [diff] [blame] | 1178 | if (time_after(jiffies, |
Eyal Shapira | 834437d | 2014-12-17 15:38:58 +0200 | [diff] [blame] | 1179 | (unsigned long)(lq_sta->last_tx + |
| 1180 | (IWL_MVM_RS_IDLE_TIMEOUT * HZ)))) { |
Johannes Berg | efad21d2 | 2014-11-03 15:51:47 +0100 | [diff] [blame] | 1181 | int t; |
| 1182 | |
Eyal Shapira | 87d5e41 | 2014-04-06 18:13:22 +0300 | [diff] [blame] | 1183 | IWL_DEBUG_RATE(mvm, "Tx idle for too long. reinit rs\n"); |
Johannes Berg | efad21d2 | 2014-11-03 15:51:47 +0100 | [diff] [blame] | 1184 | for (t = 0; t < IWL_MAX_TID_COUNT; t++) |
| 1185 | ieee80211_stop_tx_ba_session(sta, t); |
Eyal Shapira | 87d5e41 | 2014-04-06 18:13:22 +0300 | [diff] [blame] | 1186 | |
Eyal Shapira | 1ebc8f2 | 2014-09-14 15:23:23 +0300 | [diff] [blame] | 1187 | iwl_mvm_rs_rate_init(mvm, sta, info->band, false); |
Eyal Shapira | 87d5e41 | 2014-04-06 18:13:22 +0300 | [diff] [blame] | 1188 | return; |
| 1189 | } |
| 1190 | lq_sta->last_tx = jiffies; |
| 1191 | |
Eyal Shapira | 929e6ed | 2015-01-30 13:40:02 +0200 | [diff] [blame] | 1192 | /* Ignore this Tx frame response if its initial rate doesn't match |
| 1193 | * that of latest Link Quality command. There may be stragglers |
| 1194 | * from a previous Link Quality command, but we're no longer interested |
| 1195 | * in those; they're either from the "active" mode while we're trying |
| 1196 | * to check "search" mode, or a prior "search" mode after we've moved |
| 1197 | * to a new "search" mode (which might become the new "active" mode). |
| 1198 | */ |
| 1199 | table = &lq_sta->lq; |
| 1200 | lq_hwrate = le32_to_cpu(table->rs_table[0]); |
| 1201 | rs_rate_from_ucode_rate(lq_hwrate, info->band, &lq_rate); |
Eyal Shapira | 929e6ed | 2015-01-30 13:40:02 +0200 | [diff] [blame] | 1202 | |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1203 | /* Here we actually compare this rate to the latest LQ command */ |
Eyal Shapira | ba69d0e | 2015-01-30 01:38:29 +0200 | [diff] [blame] | 1204 | if (!rs_rate_equal(&tx_resp_rate, &lq_rate, allow_ant_mismatch)) { |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1205 | IWL_DEBUG_RATE(mvm, |
Eyal Shapira | 929e6ed | 2015-01-30 13:40:02 +0200 | [diff] [blame] | 1206 | "initial tx resp rate 0x%x does not match 0x%x\n", |
| 1207 | tx_resp_hwrate, lq_hwrate); |
| 1208 | |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1209 | /* |
| 1210 | * Since rates mis-match, the last LQ command may have failed. |
| 1211 | * After IWL_MISSED_RATE_MAX mis-matches, resync the uCode with |
| 1212 | * ... driver. |
| 1213 | */ |
| 1214 | lq_sta->missed_rate_counter++; |
Eyal Shapira | 834437d | 2014-12-17 15:38:58 +0200 | [diff] [blame] | 1215 | if (lq_sta->missed_rate_counter > IWL_MVM_RS_MISSED_RATE_MAX) { |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1216 | lq_sta->missed_rate_counter = 0; |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 1217 | IWL_DEBUG_RATE(mvm, |
| 1218 | "Too many rates mismatch. Send sync LQ. rs_state %d\n", |
| 1219 | lq_sta->rs_state); |
Eyal Shapira | 9e68094 | 2013-11-09 00:16:16 +0200 | [diff] [blame] | 1220 | iwl_mvm_send_lq_cmd(mvm, &lq_sta->lq, false); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1221 | } |
| 1222 | /* Regardless, ignore this status info for outdated rate */ |
| 1223 | return; |
| 1224 | } else |
| 1225 | /* Rate did match, so reset the missed_rate_counter */ |
| 1226 | lq_sta->missed_rate_counter = 0; |
| 1227 | |
Eyal Shapira | 26a2cc0 | 2014-11-05 12:03:59 +0200 | [diff] [blame] | 1228 | if (!lq_sta->search_better_tbl) { |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1229 | curr_tbl = &(lq_sta->lq_info[lq_sta->active_tbl]); |
| 1230 | other_tbl = &(lq_sta->lq_info[1 - lq_sta->active_tbl]); |
Eyal Shapira | 26a2cc0 | 2014-11-05 12:03:59 +0200 | [diff] [blame] | 1231 | } else { |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1232 | curr_tbl = &(lq_sta->lq_info[1 - lq_sta->active_tbl]); |
| 1233 | other_tbl = &(lq_sta->lq_info[lq_sta->active_tbl]); |
Eyal Shapira | 26a2cc0 | 2014-11-05 12:03:59 +0200 | [diff] [blame] | 1234 | } |
| 1235 | |
Eyal Shapira | 929e6ed | 2015-01-30 13:40:02 +0200 | [diff] [blame] | 1236 | if (WARN_ON_ONCE(!rs_rate_column_match(&lq_rate, &curr_tbl->rate))) { |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1237 | IWL_DEBUG_RATE(mvm, |
| 1238 | "Neither active nor search matches tx rate\n"); |
| 1239 | tmp_tbl = &(lq_sta->lq_info[lq_sta->active_tbl]); |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 1240 | rs_dump_rate(mvm, &tmp_tbl->rate, "ACTIVE"); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1241 | tmp_tbl = &(lq_sta->lq_info[1 - lq_sta->active_tbl]); |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 1242 | rs_dump_rate(mvm, &tmp_tbl->rate, "SEARCH"); |
Eyal Shapira | 929e6ed | 2015-01-30 13:40:02 +0200 | [diff] [blame] | 1243 | rs_dump_rate(mvm, &lq_rate, "ACTUAL"); |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 1244 | |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1245 | /* |
| 1246 | * no matching table found, let's by-pass the data collection |
| 1247 | * and continue to perform rate scale to find the rate table |
| 1248 | */ |
| 1249 | rs_stay_in_table(lq_sta, true); |
| 1250 | goto done; |
| 1251 | } |
| 1252 | |
| 1253 | /* |
| 1254 | * Updating the frame history depends on whether packets were |
| 1255 | * aggregated. |
| 1256 | * |
| 1257 | * For aggregation, all packets were transmitted at the same rate, the |
| 1258 | * first index into rate scale table. |
| 1259 | */ |
| 1260 | if (info->flags & IEEE80211_TX_STAT_AMPDU) { |
Eyal Shapira | d6bda66 | 2014-11-12 13:30:20 +0200 | [diff] [blame] | 1261 | /* ampdu_ack_len = 0 marks no BA was received. In this case |
| 1262 | * treat it as a single frame loss as we don't want the success |
| 1263 | * ratio to dip too quickly because a BA wasn't received |
| 1264 | */ |
| 1265 | if (info->status.ampdu_ack_len == 0) |
| 1266 | info->status.ampdu_len = 1; |
| 1267 | |
Eyal Shapira | 929e6ed | 2015-01-30 13:40:02 +0200 | [diff] [blame] | 1268 | rs_collect_tx_data(mvm, lq_sta, curr_tbl, lq_rate.index, |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1269 | info->status.ampdu_len, |
Eliad Peller | 2fd647f | 2014-03-13 17:21:36 +0200 | [diff] [blame] | 1270 | info->status.ampdu_ack_len, |
| 1271 | reduced_txp); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1272 | |
| 1273 | /* Update success/fail counts if not searching for new mode */ |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 1274 | if (lq_sta->rs_state == RS_STATE_STAY_IN_COLUMN) { |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1275 | lq_sta->total_success += info->status.ampdu_ack_len; |
| 1276 | lq_sta->total_failed += (info->status.ampdu_len - |
| 1277 | info->status.ampdu_ack_len); |
| 1278 | } |
| 1279 | } else { |
Liad Kaufman | 90cb123 | 2015-03-29 11:39:34 +0300 | [diff] [blame] | 1280 | /* For legacy, update frame history with for each Tx retry. */ |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1281 | retries = info->status.rates[0].count - 1; |
| 1282 | /* HW doesn't send more than 15 retries */ |
| 1283 | retries = min(retries, 15); |
| 1284 | |
| 1285 | /* The last transmission may have been successful */ |
| 1286 | legacy_success = !!(info->flags & IEEE80211_TX_STAT_ACK); |
| 1287 | /* Collect data for each rate used during failed TX attempts */ |
| 1288 | for (i = 0; i <= retries; ++i) { |
Eyal Shapira | 929e6ed | 2015-01-30 13:40:02 +0200 | [diff] [blame] | 1289 | lq_hwrate = le32_to_cpu(table->rs_table[i]); |
| 1290 | rs_rate_from_ucode_rate(lq_hwrate, info->band, |
| 1291 | &lq_rate); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1292 | /* |
| 1293 | * Only collect stats if retried rate is in the same RS |
| 1294 | * table as active/search. |
| 1295 | */ |
Eyal Shapira | 929e6ed | 2015-01-30 13:40:02 +0200 | [diff] [blame] | 1296 | if (rs_rate_column_match(&lq_rate, &curr_tbl->rate)) |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1297 | tmp_tbl = curr_tbl; |
Eyal Shapira | 929e6ed | 2015-01-30 13:40:02 +0200 | [diff] [blame] | 1298 | else if (rs_rate_column_match(&lq_rate, |
| 1299 | &other_tbl->rate)) |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1300 | tmp_tbl = other_tbl; |
Eyal Shapira | 4107dbd | 2013-12-10 12:20:37 +0200 | [diff] [blame] | 1301 | else |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1302 | continue; |
Eyal Shapira | 4107dbd | 2013-12-10 12:20:37 +0200 | [diff] [blame] | 1303 | |
Eyal Shapira | 929e6ed | 2015-01-30 13:40:02 +0200 | [diff] [blame] | 1304 | rs_collect_tx_data(mvm, lq_sta, tmp_tbl, lq_rate.index, |
| 1305 | 1, i < retries ? 0 : legacy_success, |
Eliad Peller | 2fd647f | 2014-03-13 17:21:36 +0200 | [diff] [blame] | 1306 | reduced_txp); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1307 | } |
| 1308 | |
| 1309 | /* Update success/fail counts if not searching for new mode */ |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 1310 | if (lq_sta->rs_state == RS_STATE_STAY_IN_COLUMN) { |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1311 | lq_sta->total_success += legacy_success; |
| 1312 | lq_sta->total_failed += retries + (1 - legacy_success); |
| 1313 | } |
| 1314 | } |
| 1315 | /* The last TX rate is cached in lq_sta; it's set in if/else above */ |
Eyal Shapira | 929e6ed | 2015-01-30 13:40:02 +0200 | [diff] [blame] | 1316 | lq_sta->last_rate_n_flags = lq_hwrate; |
Eliad Peller | 2fd647f | 2014-03-13 17:21:36 +0200 | [diff] [blame] | 1317 | IWL_DEBUG_RATE(mvm, "reduced txpower: %d\n", reduced_txp); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1318 | done: |
| 1319 | /* See if there's a better rate or modulation mode to try. */ |
Emmanuel Grumbach | 8dfc275 | 2014-09-21 13:29:48 +0300 | [diff] [blame] | 1320 | if (sta->supp_rates[info->band]) |
Eyal Shapira | 1ebc8f2 | 2014-09-14 15:23:23 +0300 | [diff] [blame] | 1321 | rs_rate_scale_perform(mvm, sta, lq_sta, tid); |
| 1322 | } |
| 1323 | |
| 1324 | /* |
| 1325 | * mac80211 sends us Tx status |
| 1326 | */ |
| 1327 | static void rs_mac80211_tx_status(void *mvm_r, |
| 1328 | struct ieee80211_supported_band *sband, |
| 1329 | struct ieee80211_sta *sta, void *priv_sta, |
| 1330 | struct sk_buff *skb) |
| 1331 | { |
| 1332 | struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; |
| 1333 | struct iwl_op_mode *op_mode = (struct iwl_op_mode *)mvm_r; |
| 1334 | struct iwl_mvm *mvm = IWL_OP_MODE_GET_MVM(op_mode); |
| 1335 | struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); |
| 1336 | |
Johannes Berg | dcbc17a | 2015-03-10 21:24:34 +0100 | [diff] [blame] | 1337 | if (!iwl_mvm_sta_from_mac80211(sta)->vif) |
| 1338 | return; |
| 1339 | |
Eyal Shapira | 1ebc8f2 | 2014-09-14 15:23:23 +0300 | [diff] [blame] | 1340 | if (!ieee80211_is_data(hdr->frame_control) || |
| 1341 | info->flags & IEEE80211_TX_CTL_NO_ACK) |
| 1342 | return; |
| 1343 | |
| 1344 | iwl_mvm_rs_tx_status(mvm, sta, rs_get_tid(hdr), info); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1345 | } |
| 1346 | |
| 1347 | /* |
| 1348 | * Begin a period of staying with a selected modulation mode. |
| 1349 | * Set "stay_in_tbl" flag to prevent any mode switches. |
| 1350 | * Set frame tx success limits according to legacy vs. high-throughput, |
| 1351 | * and reset overall (spanning all rates) tx success history statistics. |
| 1352 | * These control how long we stay using same modulation mode before |
| 1353 | * searching for a new mode. |
| 1354 | */ |
| 1355 | static void rs_set_stay_in_table(struct iwl_mvm *mvm, u8 is_legacy, |
| 1356 | struct iwl_lq_sta *lq_sta) |
| 1357 | { |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 1358 | IWL_DEBUG_RATE(mvm, "Moving to RS_STATE_STAY_IN_COLUMN\n"); |
| 1359 | lq_sta->rs_state = RS_STATE_STAY_IN_COLUMN; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1360 | if (is_legacy) { |
Eyal Shapira | 834437d | 2014-12-17 15:38:58 +0200 | [diff] [blame] | 1361 | lq_sta->table_count_limit = IWL_MVM_RS_LEGACY_TABLE_COUNT; |
| 1362 | lq_sta->max_failure_limit = IWL_MVM_RS_LEGACY_FAILURE_LIMIT; |
| 1363 | lq_sta->max_success_limit = IWL_MVM_RS_LEGACY_SUCCESS_LIMIT; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1364 | } else { |
Eyal Shapira | 834437d | 2014-12-17 15:38:58 +0200 | [diff] [blame] | 1365 | lq_sta->table_count_limit = IWL_MVM_RS_NON_LEGACY_TABLE_COUNT; |
| 1366 | lq_sta->max_failure_limit = IWL_MVM_RS_NON_LEGACY_FAILURE_LIMIT; |
| 1367 | lq_sta->max_success_limit = IWL_MVM_RS_NON_LEGACY_SUCCESS_LIMIT; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1368 | } |
| 1369 | lq_sta->table_count = 0; |
| 1370 | lq_sta->total_failed = 0; |
| 1371 | lq_sta->total_success = 0; |
| 1372 | lq_sta->flush_timer = jiffies; |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 1373 | lq_sta->visited_columns = 0; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1374 | } |
| 1375 | |
Eyal Shapira | 6a028d9 | 2014-12-07 18:18:27 +0200 | [diff] [blame] | 1376 | static inline int rs_get_max_rate_from_mask(unsigned long rate_mask) |
| 1377 | { |
| 1378 | if (rate_mask) |
| 1379 | return find_last_bit(&rate_mask, BITS_PER_LONG); |
| 1380 | return IWL_RATE_INVALID; |
| 1381 | } |
| 1382 | |
Eyal Shapira | 198266a | 2014-03-31 22:37:39 +0300 | [diff] [blame] | 1383 | static int rs_get_max_allowed_rate(struct iwl_lq_sta *lq_sta, |
| 1384 | const struct rs_tx_column *column) |
| 1385 | { |
| 1386 | switch (column->mode) { |
| 1387 | case RS_LEGACY: |
| 1388 | return lq_sta->max_legacy_rate_idx; |
| 1389 | case RS_SISO: |
| 1390 | return lq_sta->max_siso_rate_idx; |
| 1391 | case RS_MIMO2: |
| 1392 | return lq_sta->max_mimo2_rate_idx; |
| 1393 | default: |
| 1394 | WARN_ON_ONCE(1); |
| 1395 | } |
| 1396 | |
| 1397 | return lq_sta->max_legacy_rate_idx; |
| 1398 | } |
| 1399 | |
Johannes Berg | a34529e | 2014-01-20 22:57:21 +0100 | [diff] [blame] | 1400 | static const u16 *rs_get_expected_tpt_table(struct iwl_lq_sta *lq_sta, |
Eyal Shapira | 198266a | 2014-03-31 22:37:39 +0300 | [diff] [blame] | 1401 | const struct rs_tx_column *column, |
| 1402 | u32 bw) |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1403 | { |
| 1404 | /* Used to choose among HT tables */ |
Johannes Berg | a34529e | 2014-01-20 22:57:21 +0100 | [diff] [blame] | 1405 | const u16 (*ht_tbl_pointer)[IWL_RATE_COUNT]; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1406 | |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 1407 | if (WARN_ON_ONCE(column->mode != RS_LEGACY && |
| 1408 | column->mode != RS_SISO && |
| 1409 | column->mode != RS_MIMO2)) |
| 1410 | return expected_tpt_legacy; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1411 | |
| 1412 | /* Legacy rates have only one table */ |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 1413 | if (column->mode == RS_LEGACY) |
| 1414 | return expected_tpt_legacy; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1415 | |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 1416 | ht_tbl_pointer = expected_tpt_mimo2_20MHz; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1417 | /* Choose among many HT tables depending on number of streams |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 1418 | * (SISO/MIMO2), channel width (20/40/80), SGI, and aggregation |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1419 | * status */ |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 1420 | if (column->mode == RS_SISO) { |
| 1421 | switch (bw) { |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 1422 | case RATE_MCS_CHAN_WIDTH_20: |
| 1423 | ht_tbl_pointer = expected_tpt_siso_20MHz; |
| 1424 | break; |
| 1425 | case RATE_MCS_CHAN_WIDTH_40: |
| 1426 | ht_tbl_pointer = expected_tpt_siso_40MHz; |
| 1427 | break; |
| 1428 | case RATE_MCS_CHAN_WIDTH_80: |
| 1429 | ht_tbl_pointer = expected_tpt_siso_80MHz; |
| 1430 | break; |
| 1431 | default: |
| 1432 | WARN_ON_ONCE(1); |
| 1433 | } |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 1434 | } else if (column->mode == RS_MIMO2) { |
| 1435 | switch (bw) { |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 1436 | case RATE_MCS_CHAN_WIDTH_20: |
| 1437 | ht_tbl_pointer = expected_tpt_mimo2_20MHz; |
| 1438 | break; |
| 1439 | case RATE_MCS_CHAN_WIDTH_40: |
| 1440 | ht_tbl_pointer = expected_tpt_mimo2_40MHz; |
| 1441 | break; |
| 1442 | case RATE_MCS_CHAN_WIDTH_80: |
| 1443 | ht_tbl_pointer = expected_tpt_mimo2_80MHz; |
| 1444 | break; |
| 1445 | default: |
| 1446 | WARN_ON_ONCE(1); |
| 1447 | } |
| 1448 | } else { |
| 1449 | WARN_ON_ONCE(1); |
Eyal Shapira | d972ab3 | 2013-07-28 23:02:45 +0000 | [diff] [blame] | 1450 | } |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1451 | |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 1452 | if (!column->sgi && !lq_sta->is_agg) /* Normal */ |
| 1453 | return ht_tbl_pointer[0]; |
| 1454 | else if (column->sgi && !lq_sta->is_agg) /* SGI */ |
| 1455 | return ht_tbl_pointer[1]; |
| 1456 | else if (!column->sgi && lq_sta->is_agg) /* AGG */ |
| 1457 | return ht_tbl_pointer[2]; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1458 | else /* AGG+SGI */ |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 1459 | return ht_tbl_pointer[3]; |
| 1460 | } |
| 1461 | |
| 1462 | static void rs_set_expected_tpt_table(struct iwl_lq_sta *lq_sta, |
| 1463 | struct iwl_scale_tbl_info *tbl) |
| 1464 | { |
| 1465 | struct rs_rate *rate = &tbl->rate; |
| 1466 | const struct rs_tx_column *column = &rs_tx_columns[tbl->column]; |
| 1467 | |
| 1468 | tbl->expected_tpt = rs_get_expected_tpt_table(lq_sta, column, rate->bw); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1469 | } |
| 1470 | |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1471 | static s32 rs_get_best_rate(struct iwl_mvm *mvm, |
| 1472 | struct iwl_lq_sta *lq_sta, |
| 1473 | struct iwl_scale_tbl_info *tbl, /* "search" */ |
Eyal Shapira | 8076351 | 2014-04-09 04:31:44 +0300 | [diff] [blame] | 1474 | unsigned long rate_mask, s8 index) |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1475 | { |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1476 | struct iwl_scale_tbl_info *active_tbl = |
| 1477 | &(lq_sta->lq_info[lq_sta->active_tbl]); |
Eyal Shapira | 8076351 | 2014-04-09 04:31:44 +0300 | [diff] [blame] | 1478 | s32 success_ratio = active_tbl->win[index].success_ratio; |
| 1479 | u16 expected_current_tpt = active_tbl->expected_tpt[index]; |
Johannes Berg | a34529e | 2014-01-20 22:57:21 +0100 | [diff] [blame] | 1480 | const u16 *tpt_tbl = tbl->expected_tpt; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1481 | u16 high_low; |
Eyal Shapira | 8076351 | 2014-04-09 04:31:44 +0300 | [diff] [blame] | 1482 | u32 target_tpt; |
| 1483 | int rate_idx; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1484 | |
Eyal Shapira | 834437d | 2014-12-17 15:38:58 +0200 | [diff] [blame] | 1485 | if (success_ratio > IWL_MVM_RS_SR_NO_DECREASE) { |
Eyal Shapira | 8076351 | 2014-04-09 04:31:44 +0300 | [diff] [blame] | 1486 | target_tpt = 100 * expected_current_tpt; |
| 1487 | IWL_DEBUG_RATE(mvm, |
| 1488 | "SR %d high. Find rate exceeding EXPECTED_CURRENT %d\n", |
| 1489 | success_ratio, target_tpt); |
| 1490 | } else { |
| 1491 | target_tpt = lq_sta->last_tpt; |
| 1492 | IWL_DEBUG_RATE(mvm, |
| 1493 | "SR %d not thag good. Find rate exceeding ACTUAL_TPT %d\n", |
| 1494 | success_ratio, target_tpt); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1495 | } |
| 1496 | |
Eyal Shapira | 8076351 | 2014-04-09 04:31:44 +0300 | [diff] [blame] | 1497 | rate_idx = find_first_bit(&rate_mask, BITS_PER_LONG); |
| 1498 | |
| 1499 | while (rate_idx != IWL_RATE_INVALID) { |
| 1500 | if (target_tpt < (100 * tpt_tbl[rate_idx])) |
| 1501 | break; |
| 1502 | |
| 1503 | high_low = rs_get_adjacent_rate(mvm, rate_idx, rate_mask, |
| 1504 | tbl->rate.type); |
| 1505 | |
| 1506 | rate_idx = (high_low >> 8) & 0xff; |
| 1507 | } |
| 1508 | |
| 1509 | IWL_DEBUG_RATE(mvm, "Best rate found %d target_tp %d expected_new %d\n", |
| 1510 | rate_idx, target_tpt, |
| 1511 | rate_idx != IWL_RATE_INVALID ? |
| 1512 | 100 * tpt_tbl[rate_idx] : IWL_INVALID_VALUE); |
| 1513 | |
| 1514 | return rate_idx; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1515 | } |
| 1516 | |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 1517 | static u32 rs_bw_from_sta_bw(struct ieee80211_sta *sta) |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 1518 | { |
| 1519 | if (sta->bandwidth >= IEEE80211_STA_RX_BW_80) |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 1520 | return RATE_MCS_CHAN_WIDTH_80; |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 1521 | else if (sta->bandwidth >= IEEE80211_STA_RX_BW_40) |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 1522 | return RATE_MCS_CHAN_WIDTH_40; |
| 1523 | |
| 1524 | return RATE_MCS_CHAN_WIDTH_20; |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 1525 | } |
| 1526 | |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1527 | /* |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1528 | * Check whether we should continue using same modulation mode, or |
| 1529 | * begin search for a new mode, based on: |
| 1530 | * 1) # tx successes or failures while using this mode |
| 1531 | * 2) # times calling this function |
| 1532 | * 3) elapsed time in this mode (not used, for now) |
| 1533 | */ |
| 1534 | static void rs_stay_in_table(struct iwl_lq_sta *lq_sta, bool force_search) |
| 1535 | { |
| 1536 | struct iwl_scale_tbl_info *tbl; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1537 | int active_tbl; |
| 1538 | int flush_interval_passed = 0; |
| 1539 | struct iwl_mvm *mvm; |
| 1540 | |
Eliad Peller | ae969af | 2014-06-11 15:51:33 +0300 | [diff] [blame] | 1541 | mvm = lq_sta->pers.drv; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1542 | active_tbl = lq_sta->active_tbl; |
| 1543 | |
| 1544 | tbl = &(lq_sta->lq_info[active_tbl]); |
| 1545 | |
| 1546 | /* If we've been disallowing search, see if we should now allow it */ |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 1547 | if (lq_sta->rs_state == RS_STATE_STAY_IN_COLUMN) { |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1548 | /* Elapsed time using current modulation mode */ |
| 1549 | if (lq_sta->flush_timer) |
| 1550 | flush_interval_passed = |
| 1551 | time_after(jiffies, |
| 1552 | (unsigned long)(lq_sta->flush_timer + |
Eyal Shapira | 834437d | 2014-12-17 15:38:58 +0200 | [diff] [blame] | 1553 | (IWL_MVM_RS_STAY_IN_COLUMN_TIMEOUT * HZ))); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1554 | |
| 1555 | /* |
| 1556 | * Check if we should allow search for new modulation mode. |
| 1557 | * If many frames have failed or succeeded, or we've used |
| 1558 | * this same modulation for a long time, allow search, and |
| 1559 | * reset history stats that keep track of whether we should |
| 1560 | * allow a new search. Also (below) reset all bitmaps and |
| 1561 | * stats in active history. |
| 1562 | */ |
| 1563 | if (force_search || |
| 1564 | (lq_sta->total_failed > lq_sta->max_failure_limit) || |
| 1565 | (lq_sta->total_success > lq_sta->max_success_limit) || |
| 1566 | ((!lq_sta->search_better_tbl) && |
| 1567 | (lq_sta->flush_timer) && (flush_interval_passed))) { |
| 1568 | IWL_DEBUG_RATE(mvm, |
| 1569 | "LQ: stay is expired %d %d %d\n", |
| 1570 | lq_sta->total_failed, |
| 1571 | lq_sta->total_success, |
| 1572 | flush_interval_passed); |
| 1573 | |
| 1574 | /* Allow search for new mode */ |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 1575 | lq_sta->rs_state = RS_STATE_SEARCH_CYCLE_STARTED; |
| 1576 | IWL_DEBUG_RATE(mvm, |
| 1577 | "Moving to RS_STATE_SEARCH_CYCLE_STARTED\n"); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1578 | lq_sta->total_failed = 0; |
| 1579 | lq_sta->total_success = 0; |
| 1580 | lq_sta->flush_timer = 0; |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 1581 | /* mark the current column as visited */ |
| 1582 | lq_sta->visited_columns = BIT(tbl->column); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1583 | /* |
| 1584 | * Else if we've used this modulation mode enough repetitions |
| 1585 | * (regardless of elapsed time or success/failure), reset |
| 1586 | * history bitmaps and rate-specific stats for all rates in |
| 1587 | * active table. |
| 1588 | */ |
| 1589 | } else { |
| 1590 | lq_sta->table_count++; |
| 1591 | if (lq_sta->table_count >= |
| 1592 | lq_sta->table_count_limit) { |
| 1593 | lq_sta->table_count = 0; |
| 1594 | |
| 1595 | IWL_DEBUG_RATE(mvm, |
| 1596 | "LQ: stay in table clear win\n"); |
Eyal Shapira | b804eeb | 2014-04-06 04:27:06 +0300 | [diff] [blame] | 1597 | rs_rate_scale_clear_tbl_windows(mvm, tbl); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1598 | } |
| 1599 | } |
| 1600 | |
| 1601 | /* If transitioning to allow "search", reset all history |
| 1602 | * bitmaps and stats in active table (this will become the new |
| 1603 | * "search" table). */ |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 1604 | if (lq_sta->rs_state == RS_STATE_SEARCH_CYCLE_STARTED) { |
Eyal Shapira | b804eeb | 2014-04-06 04:27:06 +0300 | [diff] [blame] | 1605 | rs_rate_scale_clear_tbl_windows(mvm, tbl); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1606 | } |
| 1607 | } |
| 1608 | } |
| 1609 | |
| 1610 | /* |
| 1611 | * setup rate table in uCode |
| 1612 | */ |
| 1613 | static void rs_update_rate_tbl(struct iwl_mvm *mvm, |
Emmanuel Grumbach | 9145d15 | 2013-07-18 08:45:41 +0300 | [diff] [blame] | 1614 | struct ieee80211_sta *sta, |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1615 | struct iwl_lq_sta *lq_sta, |
Eyal Shapira | 7b9d74e | 2015-03-29 18:38:07 +0300 | [diff] [blame] | 1616 | struct iwl_scale_tbl_info *tbl) |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1617 | { |
Eyal Shapira | 7b9d74e | 2015-03-29 18:38:07 +0300 | [diff] [blame] | 1618 | rs_fill_lq_cmd(mvm, sta, lq_sta, &tbl->rate); |
Eyal Shapira | 9e68094 | 2013-11-09 00:16:16 +0200 | [diff] [blame] | 1619 | iwl_mvm_send_lq_cmd(mvm, &lq_sta->lq, false); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 1620 | } |
| 1621 | |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 1622 | static enum rs_column rs_get_next_column(struct iwl_mvm *mvm, |
| 1623 | struct iwl_lq_sta *lq_sta, |
| 1624 | struct ieee80211_sta *sta, |
| 1625 | struct iwl_scale_tbl_info *tbl) |
| 1626 | { |
Eyal Shapira | 198266a | 2014-03-31 22:37:39 +0300 | [diff] [blame] | 1627 | int i, j, max_rate; |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 1628 | enum rs_column next_col_id; |
| 1629 | const struct rs_tx_column *curr_col = &rs_tx_columns[tbl->column]; |
| 1630 | const struct rs_tx_column *next_col; |
| 1631 | allow_column_func_t allow_func; |
Moshe Harel | a054427 | 2014-12-08 21:13:14 +0200 | [diff] [blame] | 1632 | u8 valid_ants = iwl_mvm_get_valid_tx_ant(mvm); |
Johannes Berg | a34529e | 2014-01-20 22:57:21 +0100 | [diff] [blame] | 1633 | const u16 *expected_tpt_tbl; |
Eyal Shapira | 198266a | 2014-03-31 22:37:39 +0300 | [diff] [blame] | 1634 | u16 tpt, max_expected_tpt; |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 1635 | |
| 1636 | for (i = 0; i < MAX_NEXT_COLUMNS; i++) { |
| 1637 | next_col_id = curr_col->next_columns[i]; |
| 1638 | |
| 1639 | if (next_col_id == RS_COLUMN_INVALID) |
| 1640 | continue; |
| 1641 | |
| 1642 | if (lq_sta->visited_columns & BIT(next_col_id)) { |
| 1643 | IWL_DEBUG_RATE(mvm, "Skip already visited column %d\n", |
| 1644 | next_col_id); |
| 1645 | continue; |
| 1646 | } |
| 1647 | |
| 1648 | next_col = &rs_tx_columns[next_col_id]; |
| 1649 | |
| 1650 | if (!rs_is_valid_ant(valid_ants, next_col->ant)) { |
| 1651 | IWL_DEBUG_RATE(mvm, |
| 1652 | "Skip column %d as ANT config isn't supported by chip. valid_ants 0x%x column ant 0x%x\n", |
| 1653 | next_col_id, valid_ants, next_col->ant); |
| 1654 | continue; |
| 1655 | } |
| 1656 | |
| 1657 | for (j = 0; j < MAX_COLUMN_CHECKS; j++) { |
| 1658 | allow_func = next_col->checks[j]; |
Eyal Shapira | 0b8d17f | 2015-02-02 15:21:27 +0200 | [diff] [blame] | 1659 | if (allow_func && !allow_func(mvm, sta, tbl, next_col)) |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 1660 | break; |
| 1661 | } |
| 1662 | |
| 1663 | if (j != MAX_COLUMN_CHECKS) { |
| 1664 | IWL_DEBUG_RATE(mvm, |
| 1665 | "Skip column %d: not allowed (check %d failed)\n", |
| 1666 | next_col_id, j); |
| 1667 | |
| 1668 | continue; |
| 1669 | } |
| 1670 | |
| 1671 | tpt = lq_sta->last_tpt / 100; |
| 1672 | expected_tpt_tbl = rs_get_expected_tpt_table(lq_sta, next_col, |
Eyal Shapira | 049e0c3 | 2014-05-01 01:28:48 +0300 | [diff] [blame] | 1673 | rs_bw_from_sta_bw(sta)); |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 1674 | if (WARN_ON_ONCE(!expected_tpt_tbl)) |
| 1675 | continue; |
| 1676 | |
Eyal Shapira | 198266a | 2014-03-31 22:37:39 +0300 | [diff] [blame] | 1677 | max_rate = rs_get_max_allowed_rate(lq_sta, next_col); |
Eyal Shapira | 6a028d9 | 2014-12-07 18:18:27 +0200 | [diff] [blame] | 1678 | if (max_rate == IWL_RATE_INVALID) { |
| 1679 | IWL_DEBUG_RATE(mvm, |
| 1680 | "Skip column %d: no rate is allowed in this column\n", |
| 1681 | next_col_id); |
Eyal Shapira | 198266a | 2014-03-31 22:37:39 +0300 | [diff] [blame] | 1682 | continue; |
Eyal Shapira | 6a028d9 | 2014-12-07 18:18:27 +0200 | [diff] [blame] | 1683 | } |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 1684 | |
Eyal Shapira | 198266a | 2014-03-31 22:37:39 +0300 | [diff] [blame] | 1685 | max_expected_tpt = expected_tpt_tbl[max_rate]; |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 1686 | if (tpt >= max_expected_tpt) { |
| 1687 | IWL_DEBUG_RATE(mvm, |
| 1688 | "Skip column %d: can't beat current TPT. Max expected %d current %d\n", |
| 1689 | next_col_id, max_expected_tpt, tpt); |
| 1690 | continue; |
| 1691 | } |
| 1692 | |
Eyal Shapira | 198266a | 2014-03-31 22:37:39 +0300 | [diff] [blame] | 1693 | IWL_DEBUG_RATE(mvm, |
| 1694 | "Found potential column %d. Max expected %d current %d\n", |
| 1695 | next_col_id, max_expected_tpt, tpt); |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 1696 | break; |
| 1697 | } |
| 1698 | |
| 1699 | if (i == MAX_NEXT_COLUMNS) |
| 1700 | return RS_COLUMN_INVALID; |
| 1701 | |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 1702 | return next_col_id; |
| 1703 | } |
| 1704 | |
| 1705 | static int rs_switch_to_column(struct iwl_mvm *mvm, |
| 1706 | struct iwl_lq_sta *lq_sta, |
| 1707 | struct ieee80211_sta *sta, |
| 1708 | enum rs_column col_id) |
| 1709 | { |
| 1710 | struct iwl_scale_tbl_info *tbl = &(lq_sta->lq_info[lq_sta->active_tbl]); |
| 1711 | struct iwl_scale_tbl_info *search_tbl = |
| 1712 | &(lq_sta->lq_info[(1 - lq_sta->active_tbl)]); |
| 1713 | struct rs_rate *rate = &search_tbl->rate; |
| 1714 | const struct rs_tx_column *column = &rs_tx_columns[col_id]; |
| 1715 | const struct rs_tx_column *curr_column = &rs_tx_columns[tbl->column]; |
| 1716 | u32 sz = (sizeof(struct iwl_scale_tbl_info) - |
| 1717 | (sizeof(struct iwl_rate_scale_data) * IWL_RATE_COUNT)); |
Eyal Shapira | 8076351 | 2014-04-09 04:31:44 +0300 | [diff] [blame] | 1718 | unsigned long rate_mask = 0; |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 1719 | u32 rate_idx = 0; |
| 1720 | |
| 1721 | memcpy(search_tbl, tbl, sz); |
| 1722 | |
| 1723 | rate->sgi = column->sgi; |
| 1724 | rate->ant = column->ant; |
| 1725 | |
| 1726 | if (column->mode == RS_LEGACY) { |
| 1727 | if (lq_sta->band == IEEE80211_BAND_5GHZ) |
| 1728 | rate->type = LQ_LEGACY_A; |
| 1729 | else |
| 1730 | rate->type = LQ_LEGACY_G; |
| 1731 | |
Eyal Shapira | d8bafea | 2014-10-23 13:58:38 +0300 | [diff] [blame] | 1732 | rate->bw = RATE_MCS_CHAN_WIDTH_20; |
| 1733 | rate->ldpc = false; |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 1734 | rate_mask = lq_sta->active_legacy_rate; |
| 1735 | } else if (column->mode == RS_SISO) { |
| 1736 | rate->type = lq_sta->is_vht ? LQ_VHT_SISO : LQ_HT_SISO; |
| 1737 | rate_mask = lq_sta->active_siso_rate; |
| 1738 | } else if (column->mode == RS_MIMO2) { |
| 1739 | rate->type = lq_sta->is_vht ? LQ_VHT_MIMO2 : LQ_HT_MIMO2; |
| 1740 | rate_mask = lq_sta->active_mimo2_rate; |
| 1741 | } else { |
| 1742 | WARN_ON_ONCE("Bad column mode"); |
| 1743 | } |
| 1744 | |
Eyal Shapira | d8bafea | 2014-10-23 13:58:38 +0300 | [diff] [blame] | 1745 | if (column->mode != RS_LEGACY) { |
| 1746 | rate->bw = rs_bw_from_sta_bw(sta); |
| 1747 | rate->ldpc = lq_sta->ldpc; |
| 1748 | } |
| 1749 | |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 1750 | search_tbl->column = col_id; |
| 1751 | rs_set_expected_tpt_table(lq_sta, search_tbl); |
| 1752 | |
Eyal Shapira | 75d3e2d | 2014-01-07 18:19:35 +0200 | [diff] [blame] | 1753 | lq_sta->visited_columns |= BIT(col_id); |
| 1754 | |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 1755 | /* Get the best matching rate if we're changing modes. e.g. |
| 1756 | * SISO->MIMO, LEGACY->SISO, MIMO->SISO |
| 1757 | */ |
| 1758 | if (curr_column->mode != column->mode) { |
| 1759 | rate_idx = rs_get_best_rate(mvm, lq_sta, search_tbl, |
| 1760 | rate_mask, rate->index); |
| 1761 | |
| 1762 | if ((rate_idx == IWL_RATE_INVALID) || |
| 1763 | !(BIT(rate_idx) & rate_mask)) { |
| 1764 | IWL_DEBUG_RATE(mvm, |
| 1765 | "can not switch with index %d" |
Eyal Shapira | 8076351 | 2014-04-09 04:31:44 +0300 | [diff] [blame] | 1766 | " rate mask %lx\n", |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 1767 | rate_idx, rate_mask); |
| 1768 | |
| 1769 | goto err; |
| 1770 | } |
| 1771 | |
| 1772 | rate->index = rate_idx; |
| 1773 | } |
| 1774 | |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 1775 | IWL_DEBUG_RATE(mvm, "Switched to column %d: Index %d\n", |
| 1776 | col_id, rate->index); |
| 1777 | |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 1778 | return 0; |
| 1779 | |
| 1780 | err: |
| 1781 | rate->type = LQ_NONE; |
| 1782 | return -1; |
| 1783 | } |
| 1784 | |
Eyal Shapira | 4e4b815 | 2013-12-11 00:55:36 +0200 | [diff] [blame] | 1785 | static enum rs_action rs_get_rate_action(struct iwl_mvm *mvm, |
| 1786 | struct iwl_scale_tbl_info *tbl, |
| 1787 | s32 sr, int low, int high, |
| 1788 | int current_tpt, |
| 1789 | int low_tpt, int high_tpt) |
| 1790 | { |
| 1791 | enum rs_action action = RS_ACTION_STAY; |
| 1792 | |
Eyal Shapira | 834437d | 2014-12-17 15:38:58 +0200 | [diff] [blame] | 1793 | if ((sr <= RS_PERCENT(IWL_MVM_RS_SR_FORCE_DECREASE)) || |
| 1794 | (current_tpt == 0)) { |
Eyal Shapira | 4e4b815 | 2013-12-11 00:55:36 +0200 | [diff] [blame] | 1795 | IWL_DEBUG_RATE(mvm, |
Eyal Shapira | e53839e | 2014-04-06 02:42:18 +0300 | [diff] [blame] | 1796 | "Decrease rate because of low SR\n"); |
| 1797 | return RS_ACTION_DOWNSCALE; |
| 1798 | } |
| 1799 | |
| 1800 | if ((low_tpt == IWL_INVALID_VALUE) && |
| 1801 | (high_tpt == IWL_INVALID_VALUE) && |
| 1802 | (high != IWL_RATE_INVALID)) { |
| 1803 | IWL_DEBUG_RATE(mvm, |
| 1804 | "No data about high/low rates. Increase rate\n"); |
| 1805 | return RS_ACTION_UPSCALE; |
| 1806 | } |
| 1807 | |
| 1808 | if ((high_tpt == IWL_INVALID_VALUE) && |
| 1809 | (high != IWL_RATE_INVALID) && |
| 1810 | (low_tpt != IWL_INVALID_VALUE) && |
| 1811 | (low_tpt < current_tpt)) { |
| 1812 | IWL_DEBUG_RATE(mvm, |
| 1813 | "No data about high rate and low rate is worse. Increase rate\n"); |
| 1814 | return RS_ACTION_UPSCALE; |
| 1815 | } |
| 1816 | |
| 1817 | if ((high_tpt != IWL_INVALID_VALUE) && |
| 1818 | (high_tpt > current_tpt)) { |
| 1819 | IWL_DEBUG_RATE(mvm, |
| 1820 | "Higher rate is better. Increate rate\n"); |
| 1821 | return RS_ACTION_UPSCALE; |
| 1822 | } |
| 1823 | |
| 1824 | if ((low_tpt != IWL_INVALID_VALUE) && |
| 1825 | (high_tpt != IWL_INVALID_VALUE) && |
| 1826 | (low_tpt < current_tpt) && |
| 1827 | (high_tpt < current_tpt)) { |
| 1828 | IWL_DEBUG_RATE(mvm, |
| 1829 | "Both high and low are worse. Maintain rate\n"); |
| 1830 | return RS_ACTION_STAY; |
| 1831 | } |
| 1832 | |
| 1833 | if ((low_tpt != IWL_INVALID_VALUE) && |
| 1834 | (low_tpt > current_tpt)) { |
| 1835 | IWL_DEBUG_RATE(mvm, |
| 1836 | "Lower rate is better\n"); |
Eyal Shapira | 4e4b815 | 2013-12-11 00:55:36 +0200 | [diff] [blame] | 1837 | action = RS_ACTION_DOWNSCALE; |
Eyal Shapira | e53839e | 2014-04-06 02:42:18 +0300 | [diff] [blame] | 1838 | goto out; |
| 1839 | } |
| 1840 | |
| 1841 | if ((low_tpt == IWL_INVALID_VALUE) && |
| 1842 | (low != IWL_RATE_INVALID)) { |
| 1843 | IWL_DEBUG_RATE(mvm, |
| 1844 | "No data about lower rate\n"); |
| 1845 | action = RS_ACTION_DOWNSCALE; |
| 1846 | goto out; |
| 1847 | } |
| 1848 | |
| 1849 | IWL_DEBUG_RATE(mvm, "Maintain rate\n"); |
| 1850 | |
| 1851 | out: |
| 1852 | if ((action == RS_ACTION_DOWNSCALE) && (low != IWL_RATE_INVALID)) { |
Eyal Shapira | 834437d | 2014-12-17 15:38:58 +0200 | [diff] [blame] | 1853 | if (sr >= RS_PERCENT(IWL_MVM_RS_SR_NO_DECREASE)) { |
Eyal Shapira | 4e4b815 | 2013-12-11 00:55:36 +0200 | [diff] [blame] | 1854 | IWL_DEBUG_RATE(mvm, |
Eyal Shapira | e53839e | 2014-04-06 02:42:18 +0300 | [diff] [blame] | 1855 | "SR is above NO DECREASE. Avoid downscale\n"); |
Eyal Shapira | 4e4b815 | 2013-12-11 00:55:36 +0200 | [diff] [blame] | 1856 | action = RS_ACTION_STAY; |
Eyal Shapira | e53839e | 2014-04-06 02:42:18 +0300 | [diff] [blame] | 1857 | } else if (current_tpt > (100 * tbl->expected_tpt[low])) { |
| 1858 | IWL_DEBUG_RATE(mvm, |
| 1859 | "Current TPT is higher than max expected in low rate. Avoid downscale\n"); |
| 1860 | action = RS_ACTION_STAY; |
| 1861 | } else { |
| 1862 | IWL_DEBUG_RATE(mvm, "Decrease rate\n"); |
Eyal Shapira | 4e4b815 | 2013-12-11 00:55:36 +0200 | [diff] [blame] | 1863 | } |
| 1864 | } |
| 1865 | |
Eyal Shapira | 4e4b815 | 2013-12-11 00:55:36 +0200 | [diff] [blame] | 1866 | return action; |
| 1867 | } |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 1868 | |
Eyal Shapira | d8bafea | 2014-10-23 13:58:38 +0300 | [diff] [blame] | 1869 | static bool rs_stbc_allow(struct iwl_mvm *mvm, struct ieee80211_sta *sta, |
| 1870 | struct iwl_lq_sta *lq_sta) |
| 1871 | { |
Eyal Shapira | d8bafea | 2014-10-23 13:58:38 +0300 | [diff] [blame] | 1872 | /* Our chip supports Tx STBC and the peer is an HT/VHT STA which |
| 1873 | * supports STBC of at least 1*SS |
| 1874 | */ |
Eyal Shapira | 3d44eeb | 2015-01-16 22:37:04 +0200 | [diff] [blame] | 1875 | if (!lq_sta->stbc_capable) |
Eyal Shapira | d8bafea | 2014-10-23 13:58:38 +0300 | [diff] [blame] | 1876 | return false; |
| 1877 | |
Eyal Shapira | d8bafea | 2014-10-23 13:58:38 +0300 | [diff] [blame] | 1878 | if (!iwl_mvm_bt_coex_is_mimo_allowed(mvm, sta)) |
| 1879 | return false; |
| 1880 | |
| 1881 | return true; |
| 1882 | } |
| 1883 | |
Eliad Peller | 2fd647f | 2014-03-13 17:21:36 +0200 | [diff] [blame] | 1884 | static void rs_get_adjacent_txp(struct iwl_mvm *mvm, int index, |
| 1885 | int *weaker, int *stronger) |
| 1886 | { |
Eyal Shapira | 834437d | 2014-12-17 15:38:58 +0200 | [diff] [blame] | 1887 | *weaker = index + IWL_MVM_RS_TPC_TX_POWER_STEP; |
Eliad Peller | 2fd647f | 2014-03-13 17:21:36 +0200 | [diff] [blame] | 1888 | if (*weaker > TPC_MAX_REDUCTION) |
| 1889 | *weaker = TPC_INVALID; |
| 1890 | |
Eyal Shapira | 834437d | 2014-12-17 15:38:58 +0200 | [diff] [blame] | 1891 | *stronger = index - IWL_MVM_RS_TPC_TX_POWER_STEP; |
Eliad Peller | 2fd647f | 2014-03-13 17:21:36 +0200 | [diff] [blame] | 1892 | if (*stronger < 0) |
| 1893 | *stronger = TPC_INVALID; |
| 1894 | } |
| 1895 | |
Eyal Shapira | 1e9551d | 2014-04-21 21:33:17 +0300 | [diff] [blame] | 1896 | static bool rs_tpc_allowed(struct iwl_mvm *mvm, struct ieee80211_vif *vif, |
| 1897 | struct rs_rate *rate, enum ieee80211_band band) |
Eliad Peller | 2fd647f | 2014-03-13 17:21:36 +0200 | [diff] [blame] | 1898 | { |
| 1899 | int index = rate->index; |
Eyal Shapira | 1e9551d | 2014-04-21 21:33:17 +0300 | [diff] [blame] | 1900 | bool cam = (iwlmvm_mod_params.power_scheme == IWL_POWER_SCHEME_CAM); |
| 1901 | bool sta_ps_disabled = (vif->type == NL80211_IFTYPE_STATION && |
| 1902 | !vif->bss_conf.ps); |
Eliad Peller | 2fd647f | 2014-03-13 17:21:36 +0200 | [diff] [blame] | 1903 | |
Eyal Shapira | 1e9551d | 2014-04-21 21:33:17 +0300 | [diff] [blame] | 1904 | IWL_DEBUG_RATE(mvm, "cam: %d sta_ps_disabled %d\n", |
| 1905 | cam, sta_ps_disabled); |
Eliad Peller | 2fd647f | 2014-03-13 17:21:36 +0200 | [diff] [blame] | 1906 | /* |
| 1907 | * allow tpc only if power management is enabled, or bt coex |
| 1908 | * activity grade allows it and we are on 2.4Ghz. |
| 1909 | */ |
Eyal Shapira | 1e9551d | 2014-04-21 21:33:17 +0300 | [diff] [blame] | 1910 | if ((cam || sta_ps_disabled) && |
Eliad Peller | 2fd647f | 2014-03-13 17:21:36 +0200 | [diff] [blame] | 1911 | !iwl_mvm_bt_coex_is_tpc_allowed(mvm, band)) |
| 1912 | return false; |
| 1913 | |
| 1914 | IWL_DEBUG_RATE(mvm, "check rate, table type: %d\n", rate->type); |
| 1915 | if (is_legacy(rate)) |
| 1916 | return index == IWL_RATE_54M_INDEX; |
| 1917 | if (is_ht(rate)) |
| 1918 | return index == IWL_RATE_MCS_7_INDEX; |
| 1919 | if (is_vht(rate)) |
| 1920 | return index == IWL_RATE_MCS_7_INDEX || |
| 1921 | index == IWL_RATE_MCS_8_INDEX || |
| 1922 | index == IWL_RATE_MCS_9_INDEX; |
| 1923 | |
| 1924 | WARN_ON_ONCE(1); |
| 1925 | return false; |
| 1926 | } |
| 1927 | |
| 1928 | enum tpc_action { |
| 1929 | TPC_ACTION_STAY, |
| 1930 | TPC_ACTION_DECREASE, |
| 1931 | TPC_ACTION_INCREASE, |
| 1932 | TPC_ACTION_NO_RESTIRCTION, |
| 1933 | }; |
| 1934 | |
| 1935 | static enum tpc_action rs_get_tpc_action(struct iwl_mvm *mvm, |
| 1936 | s32 sr, int weak, int strong, |
| 1937 | int current_tpt, |
| 1938 | int weak_tpt, int strong_tpt) |
| 1939 | { |
| 1940 | /* stay until we have valid tpt */ |
| 1941 | if (current_tpt == IWL_INVALID_VALUE) { |
| 1942 | IWL_DEBUG_RATE(mvm, "no current tpt. stay.\n"); |
| 1943 | return TPC_ACTION_STAY; |
| 1944 | } |
| 1945 | |
| 1946 | /* Too many failures, increase txp */ |
Eyal Shapira | 834437d | 2014-12-17 15:38:58 +0200 | [diff] [blame] | 1947 | if (sr <= RS_PERCENT(IWL_MVM_RS_TPC_SR_FORCE_INCREASE) || |
| 1948 | current_tpt == 0) { |
Eliad Peller | 2fd647f | 2014-03-13 17:21:36 +0200 | [diff] [blame] | 1949 | IWL_DEBUG_RATE(mvm, "increase txp because of weak SR\n"); |
| 1950 | return TPC_ACTION_NO_RESTIRCTION; |
| 1951 | } |
| 1952 | |
| 1953 | /* try decreasing first if applicable */ |
| 1954 | if (weak != TPC_INVALID) { |
| 1955 | if (weak_tpt == IWL_INVALID_VALUE && |
| 1956 | (strong_tpt == IWL_INVALID_VALUE || |
| 1957 | current_tpt >= strong_tpt)) { |
| 1958 | IWL_DEBUG_RATE(mvm, |
| 1959 | "no weak txp measurement. decrease txp\n"); |
| 1960 | return TPC_ACTION_DECREASE; |
| 1961 | } |
| 1962 | |
| 1963 | if (weak_tpt > current_tpt) { |
| 1964 | IWL_DEBUG_RATE(mvm, |
| 1965 | "lower txp has better tpt. decrease txp\n"); |
| 1966 | return TPC_ACTION_DECREASE; |
| 1967 | } |
| 1968 | } |
| 1969 | |
| 1970 | /* next, increase if needed */ |
Eyal Shapira | 834437d | 2014-12-17 15:38:58 +0200 | [diff] [blame] | 1971 | if (sr < RS_PERCENT(IWL_MVM_RS_TPC_SR_NO_INCREASE) && |
| 1972 | strong != TPC_INVALID) { |
Eliad Peller | 2fd647f | 2014-03-13 17:21:36 +0200 | [diff] [blame] | 1973 | if (weak_tpt == IWL_INVALID_VALUE && |
| 1974 | strong_tpt != IWL_INVALID_VALUE && |
| 1975 | current_tpt < strong_tpt) { |
| 1976 | IWL_DEBUG_RATE(mvm, |
| 1977 | "higher txp has better tpt. increase txp\n"); |
| 1978 | return TPC_ACTION_INCREASE; |
| 1979 | } |
| 1980 | |
| 1981 | if (weak_tpt < current_tpt && |
| 1982 | (strong_tpt == IWL_INVALID_VALUE || |
| 1983 | strong_tpt > current_tpt)) { |
| 1984 | IWL_DEBUG_RATE(mvm, |
| 1985 | "lower txp has worse tpt. increase txp\n"); |
| 1986 | return TPC_ACTION_INCREASE; |
| 1987 | } |
| 1988 | } |
| 1989 | |
| 1990 | IWL_DEBUG_RATE(mvm, "no need to increase or decrease txp - stay\n"); |
| 1991 | return TPC_ACTION_STAY; |
| 1992 | } |
| 1993 | |
| 1994 | static bool rs_tpc_perform(struct iwl_mvm *mvm, |
| 1995 | struct ieee80211_sta *sta, |
| 1996 | struct iwl_lq_sta *lq_sta, |
| 1997 | struct iwl_scale_tbl_info *tbl) |
| 1998 | { |
Johannes Berg | 9d8ce6a | 2014-12-23 16:02:40 +0100 | [diff] [blame] | 1999 | struct iwl_mvm_sta *mvm_sta = iwl_mvm_sta_from_mac80211(sta); |
Eliad Peller | 2fd647f | 2014-03-13 17:21:36 +0200 | [diff] [blame] | 2000 | struct ieee80211_vif *vif = mvm_sta->vif; |
| 2001 | struct ieee80211_chanctx_conf *chanctx_conf; |
| 2002 | enum ieee80211_band band; |
| 2003 | struct iwl_rate_scale_data *window; |
| 2004 | struct rs_rate *rate = &tbl->rate; |
| 2005 | enum tpc_action action; |
| 2006 | s32 sr; |
| 2007 | u8 cur = lq_sta->lq.reduced_tpc; |
| 2008 | int current_tpt; |
| 2009 | int weak, strong; |
| 2010 | int weak_tpt = IWL_INVALID_VALUE, strong_tpt = IWL_INVALID_VALUE; |
| 2011 | |
Eliad Peller | 9a75b3d | 2014-03-13 17:15:04 +0200 | [diff] [blame] | 2012 | #ifdef CONFIG_MAC80211_DEBUGFS |
Eliad Peller | ae969af | 2014-06-11 15:51:33 +0300 | [diff] [blame] | 2013 | if (lq_sta->pers.dbg_fixed_txp_reduction <= TPC_MAX_REDUCTION) { |
Johannes Berg | 3c6acb6 | 2014-05-07 11:47:53 +0200 | [diff] [blame] | 2014 | IWL_DEBUG_RATE(mvm, "fixed tpc: %d\n", |
Eliad Peller | ae969af | 2014-06-11 15:51:33 +0300 | [diff] [blame] | 2015 | lq_sta->pers.dbg_fixed_txp_reduction); |
| 2016 | lq_sta->lq.reduced_tpc = lq_sta->pers.dbg_fixed_txp_reduction; |
| 2017 | return cur != lq_sta->pers.dbg_fixed_txp_reduction; |
Eliad Peller | 9a75b3d | 2014-03-13 17:15:04 +0200 | [diff] [blame] | 2018 | } |
| 2019 | #endif |
| 2020 | |
Eliad Peller | 2fd647f | 2014-03-13 17:21:36 +0200 | [diff] [blame] | 2021 | rcu_read_lock(); |
| 2022 | chanctx_conf = rcu_dereference(vif->chanctx_conf); |
| 2023 | if (WARN_ON(!chanctx_conf)) |
| 2024 | band = IEEE80211_NUM_BANDS; |
| 2025 | else |
| 2026 | band = chanctx_conf->def.chan->band; |
| 2027 | rcu_read_unlock(); |
| 2028 | |
Eyal Shapira | 1e9551d | 2014-04-21 21:33:17 +0300 | [diff] [blame] | 2029 | if (!rs_tpc_allowed(mvm, vif, rate, band)) { |
Eliad Peller | 2fd647f | 2014-03-13 17:21:36 +0200 | [diff] [blame] | 2030 | IWL_DEBUG_RATE(mvm, |
Johannes Berg | 3c6acb6 | 2014-05-07 11:47:53 +0200 | [diff] [blame] | 2031 | "tpc is not allowed. remove txp restrictions\n"); |
Eliad Peller | 2fd647f | 2014-03-13 17:21:36 +0200 | [diff] [blame] | 2032 | lq_sta->lq.reduced_tpc = TPC_NO_REDUCTION; |
| 2033 | return cur != TPC_NO_REDUCTION; |
| 2034 | } |
| 2035 | |
| 2036 | rs_get_adjacent_txp(mvm, cur, &weak, &strong); |
| 2037 | |
| 2038 | /* Collect measured throughputs for current and adjacent rates */ |
| 2039 | window = tbl->tpc_win; |
| 2040 | sr = window[cur].success_ratio; |
| 2041 | current_tpt = window[cur].average_tpt; |
| 2042 | if (weak != TPC_INVALID) |
| 2043 | weak_tpt = window[weak].average_tpt; |
| 2044 | if (strong != TPC_INVALID) |
| 2045 | strong_tpt = window[strong].average_tpt; |
| 2046 | |
| 2047 | IWL_DEBUG_RATE(mvm, |
| 2048 | "(TPC: %d): cur_tpt %d SR %d weak %d strong %d weak_tpt %d strong_tpt %d\n", |
| 2049 | cur, current_tpt, sr, weak, strong, |
| 2050 | weak_tpt, strong_tpt); |
| 2051 | |
| 2052 | action = rs_get_tpc_action(mvm, sr, weak, strong, |
| 2053 | current_tpt, weak_tpt, strong_tpt); |
| 2054 | |
| 2055 | /* override actions if we are on the edge */ |
| 2056 | if (weak == TPC_INVALID && action == TPC_ACTION_DECREASE) { |
Johannes Berg | 3c6acb6 | 2014-05-07 11:47:53 +0200 | [diff] [blame] | 2057 | IWL_DEBUG_RATE(mvm, "already in lowest txp, stay\n"); |
Eliad Peller | 2fd647f | 2014-03-13 17:21:36 +0200 | [diff] [blame] | 2058 | action = TPC_ACTION_STAY; |
| 2059 | } else if (strong == TPC_INVALID && |
| 2060 | (action == TPC_ACTION_INCREASE || |
| 2061 | action == TPC_ACTION_NO_RESTIRCTION)) { |
Johannes Berg | 3c6acb6 | 2014-05-07 11:47:53 +0200 | [diff] [blame] | 2062 | IWL_DEBUG_RATE(mvm, "already in highest txp, stay\n"); |
Eliad Peller | 2fd647f | 2014-03-13 17:21:36 +0200 | [diff] [blame] | 2063 | action = TPC_ACTION_STAY; |
| 2064 | } |
| 2065 | |
| 2066 | switch (action) { |
| 2067 | case TPC_ACTION_DECREASE: |
| 2068 | lq_sta->lq.reduced_tpc = weak; |
| 2069 | return true; |
| 2070 | case TPC_ACTION_INCREASE: |
| 2071 | lq_sta->lq.reduced_tpc = strong; |
| 2072 | return true; |
| 2073 | case TPC_ACTION_NO_RESTIRCTION: |
| 2074 | lq_sta->lq.reduced_tpc = TPC_NO_REDUCTION; |
| 2075 | return true; |
| 2076 | case TPC_ACTION_STAY: |
| 2077 | /* do nothing */ |
| 2078 | break; |
| 2079 | } |
| 2080 | return false; |
| 2081 | } |
| 2082 | |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2083 | /* |
| 2084 | * Do rate scaling and search for new modulation mode. |
| 2085 | */ |
| 2086 | static void rs_rate_scale_perform(struct iwl_mvm *mvm, |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2087 | struct ieee80211_sta *sta, |
Eyal Shapira | 1ebc8f2 | 2014-09-14 15:23:23 +0300 | [diff] [blame] | 2088 | struct iwl_lq_sta *lq_sta, |
| 2089 | int tid) |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2090 | { |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2091 | int low = IWL_RATE_INVALID; |
| 2092 | int high = IWL_RATE_INVALID; |
| 2093 | int index; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2094 | struct iwl_rate_scale_data *window = NULL; |
| 2095 | int current_tpt = IWL_INVALID_VALUE; |
| 2096 | int low_tpt = IWL_INVALID_VALUE; |
| 2097 | int high_tpt = IWL_INVALID_VALUE; |
| 2098 | u32 fail_count; |
Eyal Shapira | 4e4b815 | 2013-12-11 00:55:36 +0200 | [diff] [blame] | 2099 | enum rs_action scale_action = RS_ACTION_STAY; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2100 | u16 rate_mask; |
| 2101 | u8 update_lq = 0; |
| 2102 | struct iwl_scale_tbl_info *tbl, *tbl1; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2103 | u8 active_tbl = 0; |
| 2104 | u8 done_search = 0; |
| 2105 | u16 high_low; |
| 2106 | s32 sr; |
Eyal Shapira | 9d015a0 | 2013-11-21 01:12:11 +0200 | [diff] [blame] | 2107 | u8 prev_agg = lq_sta->is_agg; |
Johannes Berg | 9d8ce6a | 2014-12-23 16:02:40 +0100 | [diff] [blame] | 2108 | struct iwl_mvm_sta *sta_priv = iwl_mvm_sta_from_mac80211(sta); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2109 | struct iwl_mvm_tid_data *tid_data; |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 2110 | struct rs_rate *rate; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2111 | |
Eyal Shapira | efed664 | 2014-09-14 15:58:53 +0300 | [diff] [blame] | 2112 | lq_sta->is_agg = !!sta_priv->agg_tids; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2113 | |
| 2114 | /* |
| 2115 | * Select rate-scale / modulation-mode table to work with in |
| 2116 | * the rest of this function: "search" if searching for better |
| 2117 | * modulation mode, or "active" if doing rate scaling within a mode. |
| 2118 | */ |
| 2119 | if (!lq_sta->search_better_tbl) |
| 2120 | active_tbl = lq_sta->active_tbl; |
| 2121 | else |
| 2122 | active_tbl = 1 - lq_sta->active_tbl; |
| 2123 | |
| 2124 | tbl = &(lq_sta->lq_info[active_tbl]); |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 2125 | rate = &tbl->rate; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2126 | |
Eyal Shapira | 9d015a0 | 2013-11-21 01:12:11 +0200 | [diff] [blame] | 2127 | if (prev_agg != lq_sta->is_agg) { |
| 2128 | IWL_DEBUG_RATE(mvm, |
| 2129 | "Aggregation changed: prev %d current %d. Update expected TPT table\n", |
| 2130 | prev_agg, lq_sta->is_agg); |
| 2131 | rs_set_expected_tpt_table(lq_sta, tbl); |
Eyal Shapira | b804eeb | 2014-04-06 04:27:06 +0300 | [diff] [blame] | 2132 | rs_rate_scale_clear_tbl_windows(mvm, tbl); |
Eyal Shapira | 9d015a0 | 2013-11-21 01:12:11 +0200 | [diff] [blame] | 2133 | } |
| 2134 | |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2135 | /* current tx rate */ |
| 2136 | index = lq_sta->last_txrate_idx; |
| 2137 | |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2138 | /* rates available for this association, and for modulation mode */ |
Eyal Shapira | a8ff14f | 2013-11-23 01:30:44 +0200 | [diff] [blame] | 2139 | rate_mask = rs_get_supported_rates(lq_sta, rate); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2140 | |
Eyal Shapira | ca6f38f | 2013-12-09 11:14:11 +0200 | [diff] [blame] | 2141 | if (!(BIT(index) & rate_mask)) { |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2142 | IWL_ERR(mvm, "Current Rate is not valid\n"); |
| 2143 | if (lq_sta->search_better_tbl) { |
| 2144 | /* revert to active table if search table is not valid*/ |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 2145 | rate->type = LQ_NONE; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2146 | lq_sta->search_better_tbl = 0; |
| 2147 | tbl = &(lq_sta->lq_info[lq_sta->active_tbl]); |
Eyal Shapira | 7b9d74e | 2015-03-29 18:38:07 +0300 | [diff] [blame] | 2148 | rs_update_rate_tbl(mvm, sta, lq_sta, tbl); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2149 | } |
| 2150 | return; |
| 2151 | } |
| 2152 | |
| 2153 | /* Get expected throughput table and history window for current rate */ |
| 2154 | if (!tbl->expected_tpt) { |
| 2155 | IWL_ERR(mvm, "tbl->expected_tpt is NULL\n"); |
| 2156 | return; |
| 2157 | } |
| 2158 | |
Eyal Shapira | 2536e7c | 2014-08-31 02:33:33 +0300 | [diff] [blame] | 2159 | /* TODO: handle rate_idx_mask and rate_idx_mcs_mask */ |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2160 | window = &(tbl->win[index]); |
| 2161 | |
| 2162 | /* |
| 2163 | * If there is not enough history to calculate actual average |
| 2164 | * throughput, keep analyzing results of more tx frames, without |
| 2165 | * changing rate or mode (bypass most of the rest of this function). |
| 2166 | * Set up new rate table in uCode only if old rate is not supported |
| 2167 | * in current association (use new rate found above). |
| 2168 | */ |
| 2169 | fail_count = window->counter - window->success_counter; |
Eyal Shapira | 834437d | 2014-12-17 15:38:58 +0200 | [diff] [blame] | 2170 | if ((fail_count < IWL_MVM_RS_RATE_MIN_FAILURE_TH) && |
| 2171 | (window->success_counter < IWL_MVM_RS_RATE_MIN_SUCCESS_TH)) { |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2172 | IWL_DEBUG_RATE(mvm, |
Eyal Shapira | 4d30ee8 | 2013-11-20 01:45:38 +0200 | [diff] [blame] | 2173 | "(%s: %d): Test Window: succ %d total %d\n", |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 2174 | rs_pretty_lq_type(rate->type), |
Eyal Shapira | 4d30ee8 | 2013-11-20 01:45:38 +0200 | [diff] [blame] | 2175 | index, window->success_counter, window->counter); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2176 | |
| 2177 | /* Can't calculate this yet; not enough history */ |
| 2178 | window->average_tpt = IWL_INVALID_VALUE; |
| 2179 | |
| 2180 | /* Should we stay with this modulation mode, |
| 2181 | * or search for a new one? */ |
| 2182 | rs_stay_in_table(lq_sta, false); |
| 2183 | |
| 2184 | goto out; |
| 2185 | } |
| 2186 | /* Else we have enough samples; calculate estimate of |
| 2187 | * actual average throughput */ |
| 2188 | if (window->average_tpt != ((window->success_ratio * |
| 2189 | tbl->expected_tpt[index] + 64) / 128)) { |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2190 | window->average_tpt = ((window->success_ratio * |
| 2191 | tbl->expected_tpt[index] + 64) / 128); |
| 2192 | } |
| 2193 | |
| 2194 | /* If we are searching for better modulation mode, check success. */ |
| 2195 | if (lq_sta->search_better_tbl) { |
| 2196 | /* If good success, continue using the "search" mode; |
| 2197 | * no need to send new link quality command, since we're |
| 2198 | * continuing to use the setup that we've been trying. */ |
| 2199 | if (window->average_tpt > lq_sta->last_tpt) { |
| 2200 | IWL_DEBUG_RATE(mvm, |
Eyal Shapira | 4d30ee8 | 2013-11-20 01:45:38 +0200 | [diff] [blame] | 2201 | "SWITCHING TO NEW TABLE SR: %d " |
| 2202 | "cur-tpt %d old-tpt %d\n", |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2203 | window->success_ratio, |
| 2204 | window->average_tpt, |
| 2205 | lq_sta->last_tpt); |
| 2206 | |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2207 | /* Swap tables; "search" becomes "active" */ |
| 2208 | lq_sta->active_tbl = active_tbl; |
| 2209 | current_tpt = window->average_tpt; |
| 2210 | /* Else poor success; go back to mode in "active" table */ |
| 2211 | } else { |
| 2212 | IWL_DEBUG_RATE(mvm, |
Eyal Shapira | 4d30ee8 | 2013-11-20 01:45:38 +0200 | [diff] [blame] | 2213 | "GOING BACK TO THE OLD TABLE: SR %d " |
| 2214 | "cur-tpt %d old-tpt %d\n", |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2215 | window->success_ratio, |
| 2216 | window->average_tpt, |
| 2217 | lq_sta->last_tpt); |
| 2218 | |
| 2219 | /* Nullify "search" table */ |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 2220 | rate->type = LQ_NONE; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2221 | |
| 2222 | /* Revert to "active" table */ |
| 2223 | active_tbl = lq_sta->active_tbl; |
| 2224 | tbl = &(lq_sta->lq_info[active_tbl]); |
| 2225 | |
| 2226 | /* Revert to "active" rate and throughput info */ |
Eyal Shapira | 8fc7c58 | 2013-12-04 02:15:46 +0200 | [diff] [blame] | 2227 | index = tbl->rate.index; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2228 | current_tpt = lq_sta->last_tpt; |
| 2229 | |
| 2230 | /* Need to set up a new rate table in uCode */ |
| 2231 | update_lq = 1; |
| 2232 | } |
| 2233 | |
| 2234 | /* Either way, we've made a decision; modulation mode |
| 2235 | * search is done, allow rate adjustment next time. */ |
| 2236 | lq_sta->search_better_tbl = 0; |
| 2237 | done_search = 1; /* Don't switch modes below! */ |
| 2238 | goto lq_update; |
| 2239 | } |
| 2240 | |
| 2241 | /* (Else) not in search of better modulation mode, try for better |
| 2242 | * starting rate, while staying in this mode. */ |
Eyal Shapira | ca6f38f | 2013-12-09 11:14:11 +0200 | [diff] [blame] | 2243 | high_low = rs_get_adjacent_rate(mvm, index, rate_mask, rate->type); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2244 | low = high_low & 0xff; |
| 2245 | high = (high_low >> 8) & 0xff; |
| 2246 | |
Eyal Shapira | 2536e7c | 2014-08-31 02:33:33 +0300 | [diff] [blame] | 2247 | /* TODO: handle rate_idx_mask and rate_idx_mcs_mask */ |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2248 | |
| 2249 | sr = window->success_ratio; |
| 2250 | |
| 2251 | /* Collect measured throughputs for current and adjacent rates */ |
| 2252 | current_tpt = window->average_tpt; |
| 2253 | if (low != IWL_RATE_INVALID) |
| 2254 | low_tpt = tbl->win[low].average_tpt; |
| 2255 | if (high != IWL_RATE_INVALID) |
| 2256 | high_tpt = tbl->win[high].average_tpt; |
| 2257 | |
Eyal Shapira | 4d30ee8 | 2013-11-20 01:45:38 +0200 | [diff] [blame] | 2258 | IWL_DEBUG_RATE(mvm, |
| 2259 | "(%s: %d): cur_tpt %d SR %d low %d high %d low_tpt %d high_tpt %d\n", |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 2260 | rs_pretty_lq_type(rate->type), index, current_tpt, sr, |
| 2261 | low, high, low_tpt, high_tpt); |
Eyal Shapira | 4d30ee8 | 2013-11-20 01:45:38 +0200 | [diff] [blame] | 2262 | |
Eyal Shapira | 4e4b815 | 2013-12-11 00:55:36 +0200 | [diff] [blame] | 2263 | scale_action = rs_get_rate_action(mvm, tbl, sr, low, high, |
| 2264 | current_tpt, low_tpt, high_tpt); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2265 | |
Eyal Shapira | 393b9e5 | 2013-11-13 16:46:19 +0200 | [diff] [blame] | 2266 | /* Force a search in case BT doesn't like us being in MIMO */ |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 2267 | if (is_mimo(rate) && |
Eyal Shapira | 393b9e5 | 2013-11-13 16:46:19 +0200 | [diff] [blame] | 2268 | !iwl_mvm_bt_coex_is_mimo_allowed(mvm, sta)) { |
Eyal Shapira | 4d30ee8 | 2013-11-20 01:45:38 +0200 | [diff] [blame] | 2269 | IWL_DEBUG_RATE(mvm, |
| 2270 | "BT Coex forbids MIMO. Search for new config\n"); |
Emmanuel Grumbach | 36946ce | 2013-05-28 23:12:47 +0300 | [diff] [blame] | 2271 | rs_stay_in_table(lq_sta, true); |
| 2272 | goto lq_update; |
| 2273 | } |
| 2274 | |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2275 | switch (scale_action) { |
Eyal Shapira | 4e4b815 | 2013-12-11 00:55:36 +0200 | [diff] [blame] | 2276 | case RS_ACTION_DOWNSCALE: |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2277 | /* Decrease starting rate, update uCode's rate table */ |
| 2278 | if (low != IWL_RATE_INVALID) { |
| 2279 | update_lq = 1; |
| 2280 | index = low; |
Eyal Shapira | 4d30ee8 | 2013-11-20 01:45:38 +0200 | [diff] [blame] | 2281 | } else { |
| 2282 | IWL_DEBUG_RATE(mvm, |
| 2283 | "At the bottom rate. Can't decrease\n"); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2284 | } |
| 2285 | |
| 2286 | break; |
Eyal Shapira | 4e4b815 | 2013-12-11 00:55:36 +0200 | [diff] [blame] | 2287 | case RS_ACTION_UPSCALE: |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2288 | /* Increase starting rate, update uCode's rate table */ |
| 2289 | if (high != IWL_RATE_INVALID) { |
| 2290 | update_lq = 1; |
| 2291 | index = high; |
Eyal Shapira | 4d30ee8 | 2013-11-20 01:45:38 +0200 | [diff] [blame] | 2292 | } else { |
| 2293 | IWL_DEBUG_RATE(mvm, |
| 2294 | "At the top rate. Can't increase\n"); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2295 | } |
| 2296 | |
| 2297 | break; |
Eyal Shapira | 4e4b815 | 2013-12-11 00:55:36 +0200 | [diff] [blame] | 2298 | case RS_ACTION_STAY: |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2299 | /* No change */ |
Eyal Shapira | e6c8d60 | 2014-04-21 21:49:08 +0300 | [diff] [blame] | 2300 | if (lq_sta->rs_state == RS_STATE_STAY_IN_COLUMN) |
| 2301 | update_lq = rs_tpc_perform(mvm, sta, lq_sta, tbl); |
Eliad Peller | 2fd647f | 2014-03-13 17:21:36 +0200 | [diff] [blame] | 2302 | break; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2303 | default: |
| 2304 | break; |
| 2305 | } |
| 2306 | |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2307 | lq_update: |
| 2308 | /* Replace uCode's rate table for the destination station. */ |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 2309 | if (update_lq) { |
| 2310 | tbl->rate.index = index; |
Eyal Shapira | 7b9d74e | 2015-03-29 18:38:07 +0300 | [diff] [blame] | 2311 | rs_update_rate_tbl(mvm, sta, lq_sta, tbl); |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 2312 | } |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2313 | |
| 2314 | rs_stay_in_table(lq_sta, false); |
| 2315 | |
| 2316 | /* |
| 2317 | * Search for new modulation mode if we're: |
| 2318 | * 1) Not changing rates right now |
| 2319 | * 2) Not just finishing up a search |
| 2320 | * 3) Allowing a new search |
| 2321 | */ |
| 2322 | if (!update_lq && !done_search && |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 2323 | lq_sta->rs_state == RS_STATE_SEARCH_CYCLE_STARTED |
| 2324 | && window->counter) { |
| 2325 | enum rs_column next_column; |
| 2326 | |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2327 | /* Save current throughput to compare with "search" throughput*/ |
| 2328 | lq_sta->last_tpt = current_tpt; |
| 2329 | |
Eyal Shapira | 4d30ee8 | 2013-11-20 01:45:38 +0200 | [diff] [blame] | 2330 | IWL_DEBUG_RATE(mvm, |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 2331 | "Start Search: update_lq %d done_search %d rs_state %d win->counter %d\n", |
| 2332 | update_lq, done_search, lq_sta->rs_state, |
Eyal Shapira | 4d30ee8 | 2013-11-20 01:45:38 +0200 | [diff] [blame] | 2333 | window->counter); |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 2334 | |
| 2335 | next_column = rs_get_next_column(mvm, lq_sta, sta, tbl); |
| 2336 | if (next_column != RS_COLUMN_INVALID) { |
| 2337 | int ret = rs_switch_to_column(mvm, lq_sta, sta, |
| 2338 | next_column); |
| 2339 | if (!ret) |
| 2340 | lq_sta->search_better_tbl = 1; |
| 2341 | } else { |
| 2342 | IWL_DEBUG_RATE(mvm, |
| 2343 | "No more columns to explore in search cycle. Go to RS_STATE_SEARCH_CYCLE_ENDED\n"); |
| 2344 | lq_sta->rs_state = RS_STATE_SEARCH_CYCLE_ENDED; |
| 2345 | } |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2346 | |
| 2347 | /* If new "search" mode was selected, set up in uCode table */ |
| 2348 | if (lq_sta->search_better_tbl) { |
| 2349 | /* Access the "search" table, clear its history. */ |
| 2350 | tbl = &(lq_sta->lq_info[(1 - lq_sta->active_tbl)]); |
Eyal Shapira | b804eeb | 2014-04-06 04:27:06 +0300 | [diff] [blame] | 2351 | rs_rate_scale_clear_tbl_windows(mvm, tbl); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2352 | |
| 2353 | /* Use new "search" start rate */ |
Eyal Shapira | 8fc7c58 | 2013-12-04 02:15:46 +0200 | [diff] [blame] | 2354 | index = tbl->rate.index; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2355 | |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 2356 | rs_dump_rate(mvm, &tbl->rate, |
| 2357 | "Switch to SEARCH TABLE:"); |
Eyal Shapira | 7b9d74e | 2015-03-29 18:38:07 +0300 | [diff] [blame] | 2358 | rs_update_rate_tbl(mvm, sta, lq_sta, tbl); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2359 | } else { |
| 2360 | done_search = 1; |
| 2361 | } |
| 2362 | } |
| 2363 | |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 2364 | if (done_search && lq_sta->rs_state == RS_STATE_SEARCH_CYCLE_ENDED) { |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2365 | /* If the "active" (non-search) mode was legacy, |
| 2366 | * and we've tried switching antennas, |
| 2367 | * but we haven't been able to try HT modes (not available), |
| 2368 | * stay with best antenna legacy modulation for a while |
| 2369 | * before next round of mode comparisons. */ |
| 2370 | tbl1 = &(lq_sta->lq_info[lq_sta->active_tbl]); |
Eyal Shapira | fd7dbee | 2014-04-06 04:39:23 +0300 | [diff] [blame] | 2371 | if (is_legacy(&tbl1->rate)) { |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2372 | IWL_DEBUG_RATE(mvm, "LQ: STAY in legacy table\n"); |
Eyal Shapira | fd7dbee | 2014-04-06 04:39:23 +0300 | [diff] [blame] | 2373 | |
| 2374 | if (tid != IWL_MAX_TID_COUNT) { |
| 2375 | tid_data = &sta_priv->tid_data[tid]; |
| 2376 | if (tid_data->state != IWL_AGG_OFF) { |
| 2377 | IWL_DEBUG_RATE(mvm, |
| 2378 | "Stop aggregation on tid %d\n", |
| 2379 | tid); |
| 2380 | ieee80211_stop_tx_ba_session(sta, tid); |
| 2381 | } |
| 2382 | } |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2383 | rs_set_stay_in_table(mvm, 1, lq_sta); |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 2384 | } else { |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2385 | /* If we're in an HT mode, and all 3 mode switch actions |
| 2386 | * have been tried and compared, stay in this best modulation |
| 2387 | * mode for a while before next round of mode comparisons. */ |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2388 | if ((lq_sta->last_tpt > IWL_AGG_TPT_THREHOLD) && |
| 2389 | (lq_sta->tx_agg_tid_en & (1 << tid)) && |
| 2390 | (tid != IWL_MAX_TID_COUNT)) { |
| 2391 | tid_data = &sta_priv->tid_data[tid]; |
| 2392 | if (tid_data->state == IWL_AGG_OFF) { |
| 2393 | IWL_DEBUG_RATE(mvm, |
| 2394 | "try to aggregate tid %d\n", |
| 2395 | tid); |
| 2396 | rs_tl_turn_on_agg(mvm, tid, |
| 2397 | lq_sta, sta); |
| 2398 | } |
| 2399 | } |
| 2400 | rs_set_stay_in_table(mvm, 0, lq_sta); |
| 2401 | } |
| 2402 | } |
| 2403 | |
| 2404 | out: |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2405 | lq_sta->last_txrate_idx = index; |
| 2406 | } |
| 2407 | |
Eyal Shapira | 361dbec | 2014-08-13 00:31:13 +0300 | [diff] [blame] | 2408 | struct rs_init_rate_info { |
| 2409 | s8 rssi; |
| 2410 | u8 rate_idx; |
| 2411 | }; |
| 2412 | |
| 2413 | static const struct rs_init_rate_info rs_init_rates_24ghz[] = { |
| 2414 | { -60, IWL_RATE_54M_INDEX }, |
| 2415 | { -64, IWL_RATE_48M_INDEX }, |
| 2416 | { -68, IWL_RATE_36M_INDEX }, |
| 2417 | { -80, IWL_RATE_24M_INDEX }, |
| 2418 | { -84, IWL_RATE_18M_INDEX }, |
| 2419 | { -85, IWL_RATE_12M_INDEX }, |
| 2420 | { -86, IWL_RATE_11M_INDEX }, |
| 2421 | { -88, IWL_RATE_5M_INDEX }, |
| 2422 | { -90, IWL_RATE_2M_INDEX }, |
| 2423 | { S8_MIN, IWL_RATE_1M_INDEX }, |
| 2424 | }; |
| 2425 | |
| 2426 | static const struct rs_init_rate_info rs_init_rates_5ghz[] = { |
| 2427 | { -60, IWL_RATE_54M_INDEX }, |
| 2428 | { -64, IWL_RATE_48M_INDEX }, |
| 2429 | { -72, IWL_RATE_36M_INDEX }, |
| 2430 | { -80, IWL_RATE_24M_INDEX }, |
| 2431 | { -84, IWL_RATE_18M_INDEX }, |
| 2432 | { -85, IWL_RATE_12M_INDEX }, |
| 2433 | { -87, IWL_RATE_9M_INDEX }, |
| 2434 | { S8_MIN, IWL_RATE_6M_INDEX }, |
| 2435 | }; |
| 2436 | |
| 2437 | /* Choose an initial legacy rate and antenna to use based on the RSSI |
| 2438 | * of last Rx |
| 2439 | */ |
| 2440 | static void rs_get_initial_rate(struct iwl_mvm *mvm, |
| 2441 | struct iwl_lq_sta *lq_sta, |
| 2442 | enum ieee80211_band band, |
| 2443 | struct rs_rate *rate) |
| 2444 | { |
| 2445 | int i, nentries; |
| 2446 | s8 best_rssi = S8_MIN; |
| 2447 | u8 best_ant = ANT_NONE; |
Moshe Harel | a054427 | 2014-12-08 21:13:14 +0200 | [diff] [blame] | 2448 | u8 valid_tx_ant = iwl_mvm_get_valid_tx_ant(mvm); |
Eyal Shapira | 361dbec | 2014-08-13 00:31:13 +0300 | [diff] [blame] | 2449 | const struct rs_init_rate_info *initial_rates; |
| 2450 | |
| 2451 | for (i = 0; i < ARRAY_SIZE(lq_sta->pers.chain_signal); i++) { |
| 2452 | if (!(lq_sta->pers.chains & BIT(i))) |
| 2453 | continue; |
| 2454 | |
| 2455 | if (lq_sta->pers.chain_signal[i] > best_rssi) { |
| 2456 | best_rssi = lq_sta->pers.chain_signal[i]; |
| 2457 | best_ant = BIT(i); |
| 2458 | } |
| 2459 | } |
| 2460 | |
| 2461 | IWL_DEBUG_RATE(mvm, "Best ANT: %s Best RSSI: %d\n", |
| 2462 | rs_pretty_ant(best_ant), best_rssi); |
| 2463 | |
| 2464 | if (best_ant != ANT_A && best_ant != ANT_B) |
| 2465 | rate->ant = first_antenna(valid_tx_ant); |
| 2466 | else |
| 2467 | rate->ant = best_ant; |
| 2468 | |
| 2469 | rate->sgi = false; |
| 2470 | rate->ldpc = false; |
| 2471 | rate->bw = RATE_MCS_CHAN_WIDTH_20; |
| 2472 | |
| 2473 | rate->index = find_first_bit(&lq_sta->active_legacy_rate, |
| 2474 | BITS_PER_LONG); |
| 2475 | |
| 2476 | if (band == IEEE80211_BAND_5GHZ) { |
| 2477 | rate->type = LQ_LEGACY_A; |
| 2478 | initial_rates = rs_init_rates_5ghz; |
| 2479 | nentries = ARRAY_SIZE(rs_init_rates_5ghz); |
| 2480 | } else { |
| 2481 | rate->type = LQ_LEGACY_G; |
| 2482 | initial_rates = rs_init_rates_24ghz; |
| 2483 | nentries = ARRAY_SIZE(rs_init_rates_24ghz); |
| 2484 | } |
| 2485 | |
| 2486 | if (IWL_MVM_RS_RSSI_BASED_INIT_RATE) { |
| 2487 | for (i = 0; i < nentries; i++) { |
| 2488 | int rate_idx = initial_rates[i].rate_idx; |
| 2489 | if ((best_rssi >= initial_rates[i].rssi) && |
| 2490 | (BIT(rate_idx) & lq_sta->active_legacy_rate)) { |
| 2491 | rate->index = rate_idx; |
| 2492 | break; |
| 2493 | } |
| 2494 | } |
| 2495 | } |
| 2496 | |
| 2497 | IWL_DEBUG_RATE(mvm, "rate_idx %d ANT %s\n", rate->index, |
| 2498 | rs_pretty_ant(rate->ant)); |
| 2499 | } |
| 2500 | |
| 2501 | /* Save info about RSSI of last Rx */ |
| 2502 | void rs_update_last_rssi(struct iwl_mvm *mvm, |
| 2503 | struct iwl_lq_sta *lq_sta, |
| 2504 | struct ieee80211_rx_status *rx_status) |
| 2505 | { |
| 2506 | lq_sta->pers.chains = rx_status->chains; |
| 2507 | lq_sta->pers.chain_signal[0] = rx_status->chain_signal[0]; |
| 2508 | lq_sta->pers.chain_signal[1] = rx_status->chain_signal[1]; |
| 2509 | lq_sta->pers.chain_signal[2] = rx_status->chain_signal[2]; |
| 2510 | } |
| 2511 | |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2512 | /** |
| 2513 | * rs_initialize_lq - Initialize a station's hardware rate table |
| 2514 | * |
| 2515 | * The uCode's station table contains a table of fallback rates |
| 2516 | * for automatic fallback during transmission. |
| 2517 | * |
| 2518 | * NOTE: This sets up a default set of values. These will be replaced later |
| 2519 | * if the driver's iwl-agn-rs rate scaling algorithm is used, instead of |
| 2520 | * rc80211_simple. |
| 2521 | * |
| 2522 | * NOTE: Run REPLY_ADD_STA command to set up station table entry, before |
| 2523 | * calling this function (which runs REPLY_TX_LINK_QUALITY_CMD, |
| 2524 | * which requires station table entry to exist). |
| 2525 | */ |
| 2526 | static void rs_initialize_lq(struct iwl_mvm *mvm, |
| 2527 | struct ieee80211_sta *sta, |
| 2528 | struct iwl_lq_sta *lq_sta, |
Eyal Shapira | b87c217 | 2013-11-09 23:37:55 +0200 | [diff] [blame] | 2529 | enum ieee80211_band band, |
| 2530 | bool init) |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2531 | { |
| 2532 | struct iwl_scale_tbl_info *tbl; |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 2533 | struct rs_rate *rate; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2534 | u8 active_tbl = 0; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2535 | |
| 2536 | if (!sta || !lq_sta) |
| 2537 | return; |
| 2538 | |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2539 | if (!lq_sta->search_better_tbl) |
| 2540 | active_tbl = lq_sta->active_tbl; |
| 2541 | else |
| 2542 | active_tbl = 1 - lq_sta->active_tbl; |
| 2543 | |
| 2544 | tbl = &(lq_sta->lq_info[active_tbl]); |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 2545 | rate = &tbl->rate; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2546 | |
Eyal Shapira | 361dbec | 2014-08-13 00:31:13 +0300 | [diff] [blame] | 2547 | rs_get_initial_rate(mvm, lq_sta, band, rate); |
| 2548 | lq_sta->last_txrate_idx = rate->index; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2549 | |
Eyal Shapira | b3b06a3 | 2013-11-24 21:30:13 +0200 | [diff] [blame] | 2550 | WARN_ON_ONCE(rate->ant != ANT_A && rate->ant != ANT_B); |
| 2551 | if (rate->ant == ANT_A) |
| 2552 | tbl->column = RS_COLUMN_LEGACY_ANT_A; |
| 2553 | else |
| 2554 | tbl->column = RS_COLUMN_LEGACY_ANT_B; |
| 2555 | |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2556 | rs_set_expected_tpt_table(lq_sta, tbl); |
Eyal Shapira | 80e9e5c | 2013-12-23 16:26:41 +0200 | [diff] [blame] | 2557 | rs_fill_lq_cmd(mvm, sta, lq_sta, rate); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2558 | /* TODO restore station should remember the lq cmd */ |
Eyal Shapira | b87c217 | 2013-11-09 23:37:55 +0200 | [diff] [blame] | 2559 | iwl_mvm_send_lq_cmd(mvm, &lq_sta->lq, init); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2560 | } |
| 2561 | |
| 2562 | static void rs_get_rate(void *mvm_r, struct ieee80211_sta *sta, void *mvm_sta, |
| 2563 | struct ieee80211_tx_rate_control *txrc) |
| 2564 | { |
| 2565 | struct sk_buff *skb = txrc->skb; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2566 | struct iwl_op_mode *op_mode __maybe_unused = |
| 2567 | (struct iwl_op_mode *)mvm_r; |
| 2568 | struct iwl_mvm *mvm __maybe_unused = IWL_OP_MODE_GET_MVM(op_mode); |
| 2569 | struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); |
| 2570 | struct iwl_lq_sta *lq_sta = mvm_sta; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2571 | |
Johannes Berg | dcbc17a | 2015-03-10 21:24:34 +0100 | [diff] [blame] | 2572 | if (sta && !iwl_mvm_sta_from_mac80211(sta)->vif) { |
| 2573 | /* if vif isn't initialized mvm doesn't know about |
| 2574 | * this station, so don't do anything with the it |
| 2575 | */ |
| 2576 | sta = NULL; |
| 2577 | mvm_sta = NULL; |
| 2578 | } |
| 2579 | |
Eyal Shapira | 2536e7c | 2014-08-31 02:33:33 +0300 | [diff] [blame] | 2580 | /* TODO: handle rate_idx_mask and rate_idx_mcs_mask */ |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2581 | |
| 2582 | /* Treat uninitialized rate scaling data same as non-existing. */ |
Eliad Peller | ae969af | 2014-06-11 15:51:33 +0300 | [diff] [blame] | 2583 | if (lq_sta && !lq_sta->pers.drv) { |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2584 | IWL_DEBUG_RATE(mvm, "Rate scaling not initialized yet.\n"); |
| 2585 | mvm_sta = NULL; |
| 2586 | } |
| 2587 | |
| 2588 | /* Send management frames and NO_ACK data using lowest rate. */ |
| 2589 | if (rate_control_send_low(sta, mvm_sta, txrc)) |
| 2590 | return; |
| 2591 | |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 2592 | iwl_mvm_hwrate_to_tx_rate(lq_sta->last_rate_n_flags, |
| 2593 | info->band, &info->control.rates[0]); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2594 | |
Moshe Benji | 622ebe9 | 2013-06-03 19:27:16 +0300 | [diff] [blame] | 2595 | info->control.rates[0].count = 1; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2596 | } |
| 2597 | |
| 2598 | static void *rs_alloc_sta(void *mvm_rate, struct ieee80211_sta *sta, |
| 2599 | gfp_t gfp) |
| 2600 | { |
Johannes Berg | 9d8ce6a | 2014-12-23 16:02:40 +0100 | [diff] [blame] | 2601 | struct iwl_mvm_sta *sta_priv = iwl_mvm_sta_from_mac80211(sta); |
Eliad Peller | ae969af | 2014-06-11 15:51:33 +0300 | [diff] [blame] | 2602 | struct iwl_op_mode *op_mode = (struct iwl_op_mode *)mvm_rate; |
| 2603 | struct iwl_mvm *mvm = IWL_OP_MODE_GET_MVM(op_mode); |
| 2604 | struct iwl_lq_sta *lq_sta = &sta_priv->lq_sta; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2605 | |
| 2606 | IWL_DEBUG_RATE(mvm, "create station rate scale window\n"); |
| 2607 | |
Eliad Peller | ae969af | 2014-06-11 15:51:33 +0300 | [diff] [blame] | 2608 | lq_sta->pers.drv = mvm; |
| 2609 | #ifdef CONFIG_MAC80211_DEBUGFS |
| 2610 | lq_sta->pers.dbg_fixed_rate = 0; |
| 2611 | lq_sta->pers.dbg_fixed_txp_reduction = TPC_INVALID; |
Eyal Shapira | 878985ce | 2015-02-02 12:14:54 +0200 | [diff] [blame] | 2612 | lq_sta->pers.ss_force = RS_SS_FORCE_NONE; |
Eliad Peller | ae969af | 2014-06-11 15:51:33 +0300 | [diff] [blame] | 2613 | #endif |
Eyal Shapira | 361dbec | 2014-08-13 00:31:13 +0300 | [diff] [blame] | 2614 | lq_sta->pers.chains = 0; |
| 2615 | memset(lq_sta->pers.chain_signal, 0, sizeof(lq_sta->pers.chain_signal)); |
Eliad Peller | ae969af | 2014-06-11 15:51:33 +0300 | [diff] [blame] | 2616 | |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2617 | return &sta_priv->lq_sta; |
| 2618 | } |
| 2619 | |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 2620 | static int rs_vht_highest_rx_mcs_index(struct ieee80211_sta_vht_cap *vht_cap, |
| 2621 | int nss) |
| 2622 | { |
| 2623 | u16 rx_mcs = le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map) & |
| 2624 | (0x3 << (2 * (nss - 1))); |
| 2625 | rx_mcs >>= (2 * (nss - 1)); |
| 2626 | |
| 2627 | if (rx_mcs == IEEE80211_VHT_MCS_SUPPORT_0_7) |
| 2628 | return IWL_RATE_MCS_7_INDEX; |
| 2629 | else if (rx_mcs == IEEE80211_VHT_MCS_SUPPORT_0_8) |
| 2630 | return IWL_RATE_MCS_8_INDEX; |
| 2631 | else if (rx_mcs == IEEE80211_VHT_MCS_SUPPORT_0_9) |
| 2632 | return IWL_RATE_MCS_9_INDEX; |
| 2633 | |
| 2634 | WARN_ON_ONCE(rx_mcs != IEEE80211_VHT_MCS_NOT_SUPPORTED); |
| 2635 | return -1; |
| 2636 | } |
| 2637 | |
Eyal Shapira | 750a1b4 | 2013-11-09 22:48:56 +0200 | [diff] [blame] | 2638 | static void rs_vht_set_enabled_rates(struct ieee80211_sta *sta, |
| 2639 | struct ieee80211_sta_vht_cap *vht_cap, |
| 2640 | struct iwl_lq_sta *lq_sta) |
| 2641 | { |
| 2642 | int i; |
| 2643 | int highest_mcs = rs_vht_highest_rx_mcs_index(vht_cap, 1); |
| 2644 | |
| 2645 | if (highest_mcs >= IWL_RATE_MCS_0_INDEX) { |
| 2646 | for (i = IWL_RATE_MCS_0_INDEX; i <= highest_mcs; i++) { |
| 2647 | if (i == IWL_RATE_9M_INDEX) |
| 2648 | continue; |
| 2649 | |
Eyal Shapira | 271518a | 2013-11-09 23:25:06 +0200 | [diff] [blame] | 2650 | /* VHT MCS9 isn't valid for 20Mhz for NSS=1,2 */ |
| 2651 | if (i == IWL_RATE_MCS_9_INDEX && |
| 2652 | sta->bandwidth == IEEE80211_STA_RX_BW_20) |
| 2653 | continue; |
| 2654 | |
Eyal Shapira | 750a1b4 | 2013-11-09 22:48:56 +0200 | [diff] [blame] | 2655 | lq_sta->active_siso_rate |= BIT(i); |
| 2656 | } |
| 2657 | } |
| 2658 | |
Eyal Shapira | ecc90e7 | 2013-11-09 23:31:38 +0200 | [diff] [blame] | 2659 | if (sta->rx_nss < 2) |
| 2660 | return; |
| 2661 | |
Eyal Shapira | 750a1b4 | 2013-11-09 22:48:56 +0200 | [diff] [blame] | 2662 | highest_mcs = rs_vht_highest_rx_mcs_index(vht_cap, 2); |
| 2663 | if (highest_mcs >= IWL_RATE_MCS_0_INDEX) { |
| 2664 | for (i = IWL_RATE_MCS_0_INDEX; i <= highest_mcs; i++) { |
| 2665 | if (i == IWL_RATE_9M_INDEX) |
| 2666 | continue; |
| 2667 | |
Eyal Shapira | 271518a | 2013-11-09 23:25:06 +0200 | [diff] [blame] | 2668 | /* VHT MCS9 isn't valid for 20Mhz for NSS=1,2 */ |
| 2669 | if (i == IWL_RATE_MCS_9_INDEX && |
| 2670 | sta->bandwidth == IEEE80211_STA_RX_BW_20) |
| 2671 | continue; |
| 2672 | |
Eyal Shapira | 750a1b4 | 2013-11-09 22:48:56 +0200 | [diff] [blame] | 2673 | lq_sta->active_mimo2_rate |= BIT(i); |
| 2674 | } |
| 2675 | } |
| 2676 | } |
| 2677 | |
Johannes Berg | 2f15a82 | 2015-01-21 18:05:04 +0100 | [diff] [blame] | 2678 | static void rs_ht_init(struct iwl_mvm *mvm, |
| 2679 | struct ieee80211_sta *sta, |
| 2680 | struct iwl_lq_sta *lq_sta, |
| 2681 | struct ieee80211_sta_ht_cap *ht_cap) |
| 2682 | { |
| 2683 | /* active_siso_rate mask includes 9 MBits (bit 5), |
| 2684 | * and CCK (bits 0-3), supp_rates[] does not; |
| 2685 | * shift to convert format, force 9 MBits off. |
| 2686 | */ |
| 2687 | lq_sta->active_siso_rate = ht_cap->mcs.rx_mask[0] << 1; |
| 2688 | lq_sta->active_siso_rate |= ht_cap->mcs.rx_mask[0] & 0x1; |
| 2689 | lq_sta->active_siso_rate &= ~((u16)0x2); |
| 2690 | lq_sta->active_siso_rate <<= IWL_FIRST_OFDM_RATE; |
| 2691 | |
| 2692 | lq_sta->active_mimo2_rate = ht_cap->mcs.rx_mask[1] << 1; |
| 2693 | lq_sta->active_mimo2_rate |= ht_cap->mcs.rx_mask[1] & 0x1; |
| 2694 | lq_sta->active_mimo2_rate &= ~((u16)0x2); |
| 2695 | lq_sta->active_mimo2_rate <<= IWL_FIRST_OFDM_RATE; |
| 2696 | |
| 2697 | if (mvm->cfg->ht_params->ldpc && |
| 2698 | (ht_cap->cap & IEEE80211_HT_CAP_LDPC_CODING)) |
| 2699 | lq_sta->ldpc = true; |
| 2700 | |
| 2701 | if (mvm->cfg->ht_params->stbc && |
| 2702 | (num_of_ant(iwl_mvm_get_valid_tx_ant(mvm)) > 1) && |
| 2703 | (ht_cap->cap & IEEE80211_HT_CAP_RX_STBC)) |
Eyal Shapira | 3d44eeb | 2015-01-16 22:37:04 +0200 | [diff] [blame] | 2704 | lq_sta->stbc_capable = true; |
Johannes Berg | 2f15a82 | 2015-01-21 18:05:04 +0100 | [diff] [blame] | 2705 | |
| 2706 | lq_sta->is_vht = false; |
| 2707 | } |
| 2708 | |
| 2709 | static void rs_vht_init(struct iwl_mvm *mvm, |
| 2710 | struct ieee80211_sta *sta, |
| 2711 | struct iwl_lq_sta *lq_sta, |
| 2712 | struct ieee80211_sta_vht_cap *vht_cap) |
| 2713 | { |
| 2714 | rs_vht_set_enabled_rates(sta, vht_cap, lq_sta); |
| 2715 | |
| 2716 | if (mvm->cfg->ht_params->ldpc && |
| 2717 | (vht_cap->cap & IEEE80211_VHT_CAP_RXLDPC)) |
| 2718 | lq_sta->ldpc = true; |
| 2719 | |
| 2720 | if (mvm->cfg->ht_params->stbc && |
| 2721 | (num_of_ant(iwl_mvm_get_valid_tx_ant(mvm)) > 1) && |
| 2722 | (vht_cap->cap & IEEE80211_VHT_CAP_RXSTBC_MASK)) |
Eyal Shapira | 3d44eeb | 2015-01-16 22:37:04 +0200 | [diff] [blame] | 2723 | lq_sta->stbc_capable = true; |
| 2724 | |
| 2725 | if ((mvm->fw->ucode_capa.capa[0] & IWL_UCODE_TLV_CAPA_BEAMFORMER) && |
| 2726 | (num_of_ant(iwl_mvm_get_valid_tx_ant(mvm)) > 1) && |
| 2727 | (vht_cap->cap & IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE)) |
| 2728 | lq_sta->bfer_capable = true; |
Johannes Berg | 2f15a82 | 2015-01-21 18:05:04 +0100 | [diff] [blame] | 2729 | |
| 2730 | lq_sta->is_vht = true; |
| 2731 | } |
| 2732 | |
Eyal Shapira | 5fc0f76 | 2014-01-28 01:35:32 +0200 | [diff] [blame] | 2733 | #ifdef CONFIG_IWLWIFI_DEBUGFS |
Johannes Berg | 2f15a82 | 2015-01-21 18:05:04 +0100 | [diff] [blame] | 2734 | static void iwl_mvm_reset_frame_stats(struct iwl_mvm *mvm) |
Eyal Shapira | 5fc0f76 | 2014-01-28 01:35:32 +0200 | [diff] [blame] | 2735 | { |
| 2736 | spin_lock_bh(&mvm->drv_stats_lock); |
Johannes Berg | 2f15a82 | 2015-01-21 18:05:04 +0100 | [diff] [blame] | 2737 | memset(&mvm->drv_rx_stats, 0, sizeof(mvm->drv_rx_stats)); |
Eyal Shapira | 5fc0f76 | 2014-01-28 01:35:32 +0200 | [diff] [blame] | 2738 | spin_unlock_bh(&mvm->drv_stats_lock); |
| 2739 | } |
| 2740 | |
Johannes Berg | 2f15a82 | 2015-01-21 18:05:04 +0100 | [diff] [blame] | 2741 | void iwl_mvm_update_frame_stats(struct iwl_mvm *mvm, u32 rate, bool agg) |
Eyal Shapira | 5fc0f76 | 2014-01-28 01:35:32 +0200 | [diff] [blame] | 2742 | { |
| 2743 | u8 nss = 0, mcs = 0; |
| 2744 | |
| 2745 | spin_lock(&mvm->drv_stats_lock); |
| 2746 | |
| 2747 | if (agg) |
Johannes Berg | 2f15a82 | 2015-01-21 18:05:04 +0100 | [diff] [blame] | 2748 | mvm->drv_rx_stats.agg_frames++; |
Eyal Shapira | 5fc0f76 | 2014-01-28 01:35:32 +0200 | [diff] [blame] | 2749 | |
Johannes Berg | 2f15a82 | 2015-01-21 18:05:04 +0100 | [diff] [blame] | 2750 | mvm->drv_rx_stats.success_frames++; |
Eyal Shapira | 5fc0f76 | 2014-01-28 01:35:32 +0200 | [diff] [blame] | 2751 | |
| 2752 | switch (rate & RATE_MCS_CHAN_WIDTH_MSK) { |
| 2753 | case RATE_MCS_CHAN_WIDTH_20: |
Johannes Berg | 2f15a82 | 2015-01-21 18:05:04 +0100 | [diff] [blame] | 2754 | mvm->drv_rx_stats.bw_20_frames++; |
Eyal Shapira | 5fc0f76 | 2014-01-28 01:35:32 +0200 | [diff] [blame] | 2755 | break; |
| 2756 | case RATE_MCS_CHAN_WIDTH_40: |
Johannes Berg | 2f15a82 | 2015-01-21 18:05:04 +0100 | [diff] [blame] | 2757 | mvm->drv_rx_stats.bw_40_frames++; |
Eyal Shapira | 5fc0f76 | 2014-01-28 01:35:32 +0200 | [diff] [blame] | 2758 | break; |
| 2759 | case RATE_MCS_CHAN_WIDTH_80: |
Johannes Berg | 2f15a82 | 2015-01-21 18:05:04 +0100 | [diff] [blame] | 2760 | mvm->drv_rx_stats.bw_80_frames++; |
Eyal Shapira | 5fc0f76 | 2014-01-28 01:35:32 +0200 | [diff] [blame] | 2761 | break; |
| 2762 | default: |
| 2763 | WARN_ONCE(1, "bad BW. rate 0x%x", rate); |
| 2764 | } |
| 2765 | |
| 2766 | if (rate & RATE_MCS_HT_MSK) { |
Johannes Berg | 2f15a82 | 2015-01-21 18:05:04 +0100 | [diff] [blame] | 2767 | mvm->drv_rx_stats.ht_frames++; |
Eyal Shapira | 5fc0f76 | 2014-01-28 01:35:32 +0200 | [diff] [blame] | 2768 | mcs = rate & RATE_HT_MCS_RATE_CODE_MSK; |
| 2769 | nss = ((rate & RATE_HT_MCS_NSS_MSK) >> RATE_HT_MCS_NSS_POS) + 1; |
| 2770 | } else if (rate & RATE_MCS_VHT_MSK) { |
Johannes Berg | 2f15a82 | 2015-01-21 18:05:04 +0100 | [diff] [blame] | 2771 | mvm->drv_rx_stats.vht_frames++; |
Eyal Shapira | 5fc0f76 | 2014-01-28 01:35:32 +0200 | [diff] [blame] | 2772 | mcs = rate & RATE_VHT_MCS_RATE_CODE_MSK; |
| 2773 | nss = ((rate & RATE_VHT_MCS_NSS_MSK) >> |
| 2774 | RATE_VHT_MCS_NSS_POS) + 1; |
| 2775 | } else { |
Johannes Berg | 2f15a82 | 2015-01-21 18:05:04 +0100 | [diff] [blame] | 2776 | mvm->drv_rx_stats.legacy_frames++; |
Eyal Shapira | 5fc0f76 | 2014-01-28 01:35:32 +0200 | [diff] [blame] | 2777 | } |
| 2778 | |
| 2779 | if (nss == 1) |
Johannes Berg | 2f15a82 | 2015-01-21 18:05:04 +0100 | [diff] [blame] | 2780 | mvm->drv_rx_stats.siso_frames++; |
Eyal Shapira | 5fc0f76 | 2014-01-28 01:35:32 +0200 | [diff] [blame] | 2781 | else if (nss == 2) |
Johannes Berg | 2f15a82 | 2015-01-21 18:05:04 +0100 | [diff] [blame] | 2782 | mvm->drv_rx_stats.mimo2_frames++; |
Eyal Shapira | 5fc0f76 | 2014-01-28 01:35:32 +0200 | [diff] [blame] | 2783 | |
| 2784 | if (rate & RATE_MCS_SGI_MSK) |
Johannes Berg | 2f15a82 | 2015-01-21 18:05:04 +0100 | [diff] [blame] | 2785 | mvm->drv_rx_stats.sgi_frames++; |
Eyal Shapira | 5fc0f76 | 2014-01-28 01:35:32 +0200 | [diff] [blame] | 2786 | else |
Johannes Berg | 2f15a82 | 2015-01-21 18:05:04 +0100 | [diff] [blame] | 2787 | mvm->drv_rx_stats.ngi_frames++; |
Eyal Shapira | 5fc0f76 | 2014-01-28 01:35:32 +0200 | [diff] [blame] | 2788 | |
Johannes Berg | 2f15a82 | 2015-01-21 18:05:04 +0100 | [diff] [blame] | 2789 | mvm->drv_rx_stats.last_rates[mvm->drv_rx_stats.last_frame_idx] = rate; |
| 2790 | mvm->drv_rx_stats.last_frame_idx = |
| 2791 | (mvm->drv_rx_stats.last_frame_idx + 1) % |
| 2792 | ARRAY_SIZE(mvm->drv_rx_stats.last_rates); |
Eyal Shapira | 5fc0f76 | 2014-01-28 01:35:32 +0200 | [diff] [blame] | 2793 | |
| 2794 | spin_unlock(&mvm->drv_stats_lock); |
| 2795 | } |
| 2796 | #endif |
| 2797 | |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2798 | /* |
| 2799 | * Called after adding a new station to initialize rate scaling |
| 2800 | */ |
| 2801 | void iwl_mvm_rs_rate_init(struct iwl_mvm *mvm, struct ieee80211_sta *sta, |
Eyal Shapira | b87c217 | 2013-11-09 23:37:55 +0200 | [diff] [blame] | 2802 | enum ieee80211_band band, bool init) |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2803 | { |
| 2804 | int i, j; |
| 2805 | struct ieee80211_hw *hw = mvm->hw; |
| 2806 | struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap; |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 2807 | struct ieee80211_sta_vht_cap *vht_cap = &sta->vht_cap; |
Johannes Berg | 9d8ce6a | 2014-12-23 16:02:40 +0100 | [diff] [blame] | 2808 | struct iwl_mvm_sta *sta_priv = iwl_mvm_sta_from_mac80211(sta); |
| 2809 | struct iwl_lq_sta *lq_sta = &sta_priv->lq_sta; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2810 | struct ieee80211_supported_band *sband; |
| 2811 | unsigned long supp; /* must be unsigned long for for_each_set_bit */ |
| 2812 | |
Eliad Peller | ae969af | 2014-06-11 15:51:33 +0300 | [diff] [blame] | 2813 | /* clear all non-persistent lq data */ |
| 2814 | memset(lq_sta, 0, offsetof(typeof(*lq_sta), pers)); |
Eyal Shapira | b87c217 | 2013-11-09 23:37:55 +0200 | [diff] [blame] | 2815 | |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2816 | sband = hw->wiphy->bands[band]; |
| 2817 | |
| 2818 | lq_sta->lq.sta_id = sta_priv->sta_id; |
| 2819 | |
| 2820 | for (j = 0; j < LQ_SIZE; j++) |
Eyal Shapira | b804eeb | 2014-04-06 04:27:06 +0300 | [diff] [blame] | 2821 | rs_rate_scale_clear_tbl_windows(mvm, &lq_sta->lq_info[j]); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2822 | |
| 2823 | lq_sta->flush_timer = 0; |
Eyal Shapira | 87d5e41 | 2014-04-06 18:13:22 +0300 | [diff] [blame] | 2824 | lq_sta->last_tx = jiffies; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2825 | |
| 2826 | IWL_DEBUG_RATE(mvm, |
| 2827 | "LQ: *** rate scale station global init for station %d ***\n", |
| 2828 | sta_priv->sta_id); |
| 2829 | /* TODO: what is a good starting rate for STA? About middle? Maybe not |
| 2830 | * the lowest or the highest rate.. Could consider using RSSI from |
| 2831 | * previous packets? Need to have IEEE 802.1X auth succeed immediately |
| 2832 | * after assoc.. */ |
| 2833 | |
Eyal Shapira | 834437d | 2014-12-17 15:38:58 +0200 | [diff] [blame] | 2834 | lq_sta->missed_rate_counter = IWL_MVM_RS_MISSED_RATE_MAX; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2835 | lq_sta->band = sband->band; |
| 2836 | /* |
| 2837 | * active legacy rates as per supported rates bitmap |
| 2838 | */ |
| 2839 | supp = sta->supp_rates[sband->band]; |
| 2840 | lq_sta->active_legacy_rate = 0; |
| 2841 | for_each_set_bit(i, &supp, BITS_PER_LONG) |
| 2842 | lq_sta->active_legacy_rate |= BIT(sband->bitrates[i].hw_value); |
| 2843 | |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 2844 | /* TODO: should probably account for rx_highest for both HT/VHT */ |
Eyal Shapira | 2c59d80 | 2015-01-16 11:01:51 +0200 | [diff] [blame] | 2845 | if (!vht_cap || !vht_cap->vht_supported) |
| 2846 | rs_ht_init(mvm, sta, lq_sta, ht_cap); |
| 2847 | else |
| 2848 | rs_vht_init(mvm, sta, lq_sta, vht_cap); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2849 | |
Emmanuel Grumbach | afe08e1 | 2015-01-05 09:48:54 +0200 | [diff] [blame] | 2850 | if (IWL_MVM_RS_DISABLE_P2P_MIMO && sta_priv->vif->p2p) |
Eyal Shapira | dc574e5 | 2014-09-17 13:56:29 +0300 | [diff] [blame] | 2851 | lq_sta->active_mimo2_rate = 0; |
| 2852 | |
Eyal Shapira | 6a028d9 | 2014-12-07 18:18:27 +0200 | [diff] [blame] | 2853 | lq_sta->max_legacy_rate_idx = |
| 2854 | rs_get_max_rate_from_mask(lq_sta->active_legacy_rate); |
| 2855 | lq_sta->max_siso_rate_idx = |
| 2856 | rs_get_max_rate_from_mask(lq_sta->active_siso_rate); |
| 2857 | lq_sta->max_mimo2_rate_idx = |
| 2858 | rs_get_max_rate_from_mask(lq_sta->active_mimo2_rate); |
Eyal Shapira | 198266a | 2014-03-31 22:37:39 +0300 | [diff] [blame] | 2859 | |
Eyal Shapira | a3576ff | 2014-08-09 10:57:59 +0300 | [diff] [blame] | 2860 | IWL_DEBUG_RATE(mvm, |
Eyal Shapira | 3d44eeb | 2015-01-16 22:37:04 +0200 | [diff] [blame] | 2861 | "LEGACY=%lX SISO=%lX MIMO2=%lX VHT=%d LDPC=%d STBC=%d BFER=%d\n", |
Eyal Shapira | 198266a | 2014-03-31 22:37:39 +0300 | [diff] [blame] | 2862 | lq_sta->active_legacy_rate, |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2863 | lq_sta->active_siso_rate, |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 2864 | lq_sta->active_mimo2_rate, |
Eyal Shapira | 3d44eeb | 2015-01-16 22:37:04 +0200 | [diff] [blame] | 2865 | lq_sta->is_vht, lq_sta->ldpc, lq_sta->stbc_capable, |
| 2866 | lq_sta->bfer_capable); |
Eyal Shapira | 198266a | 2014-03-31 22:37:39 +0300 | [diff] [blame] | 2867 | IWL_DEBUG_RATE(mvm, "MAX RATE: LEGACY=%d SISO=%d MIMO2=%d\n", |
| 2868 | lq_sta->max_legacy_rate_idx, |
| 2869 | lq_sta->max_siso_rate_idx, |
| 2870 | lq_sta->max_mimo2_rate_idx); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2871 | |
| 2872 | /* These values will be overridden later */ |
| 2873 | lq_sta->lq.single_stream_ant_msk = |
Moshe Harel | a054427 | 2014-12-08 21:13:14 +0200 | [diff] [blame] | 2874 | first_antenna(iwl_mvm_get_valid_tx_ant(mvm)); |
Eyal Shapira | 809bccf | 2013-11-28 02:25:24 +0200 | [diff] [blame] | 2875 | lq_sta->lq.dual_stream_ant_msk = ANT_AB; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2876 | |
| 2877 | /* as default allow aggregation for all tids */ |
| 2878 | lq_sta->tx_agg_tid_en = IWL_AGG_ALL_TID; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2879 | lq_sta->is_agg = 0; |
Eyal Shapira | 5fc0f76 | 2014-01-28 01:35:32 +0200 | [diff] [blame] | 2880 | #ifdef CONFIG_IWLWIFI_DEBUGFS |
Johannes Berg | 2f15a82 | 2015-01-21 18:05:04 +0100 | [diff] [blame] | 2881 | iwl_mvm_reset_frame_stats(mvm); |
Eyal Shapira | 5fc0f76 | 2014-01-28 01:35:32 +0200 | [diff] [blame] | 2882 | #endif |
Eyal Shapira | b87c217 | 2013-11-09 23:37:55 +0200 | [diff] [blame] | 2883 | rs_initialize_lq(mvm, sta, lq_sta, band, init); |
| 2884 | } |
| 2885 | |
| 2886 | static void rs_rate_update(void *mvm_r, |
| 2887 | struct ieee80211_supported_band *sband, |
| 2888 | struct cfg80211_chan_def *chandef, |
| 2889 | struct ieee80211_sta *sta, void *priv_sta, |
| 2890 | u32 changed) |
| 2891 | { |
| 2892 | u8 tid; |
| 2893 | struct iwl_op_mode *op_mode = |
| 2894 | (struct iwl_op_mode *)mvm_r; |
| 2895 | struct iwl_mvm *mvm = IWL_OP_MODE_GET_MVM(op_mode); |
| 2896 | |
Johannes Berg | dcbc17a | 2015-03-10 21:24:34 +0100 | [diff] [blame] | 2897 | if (!iwl_mvm_sta_from_mac80211(sta)->vif) |
| 2898 | return; |
| 2899 | |
Eyal Shapira | b87c217 | 2013-11-09 23:37:55 +0200 | [diff] [blame] | 2900 | /* Stop any ongoing aggregations as rs starts off assuming no agg */ |
| 2901 | for (tid = 0; tid < IWL_MAX_TID_COUNT; tid++) |
| 2902 | ieee80211_stop_tx_ba_session(sta, tid); |
| 2903 | |
| 2904 | iwl_mvm_rs_rate_init(mvm, sta, sband->band, false); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2905 | } |
| 2906 | |
Eyal Shapira | 8fc7c58 | 2013-12-04 02:15:46 +0200 | [diff] [blame] | 2907 | #ifdef CONFIG_MAC80211_DEBUGFS |
| 2908 | static void rs_build_rates_table_from_fixed(struct iwl_mvm *mvm, |
| 2909 | struct iwl_lq_cmd *lq_cmd, |
| 2910 | enum ieee80211_band band, |
| 2911 | u32 ucode_rate) |
| 2912 | { |
| 2913 | struct rs_rate rate; |
| 2914 | int i; |
| 2915 | int num_rates = ARRAY_SIZE(lq_cmd->rs_table); |
| 2916 | __le32 ucode_rate_le32 = cpu_to_le32(ucode_rate); |
Emmanuel Grumbach | 7ceb98a | 2014-07-28 12:59:45 +0300 | [diff] [blame] | 2917 | u8 ant = (ucode_rate & RATE_MCS_ANT_ABC_MSK) >> RATE_MCS_ANT_POS; |
Eyal Shapira | 8fc7c58 | 2013-12-04 02:15:46 +0200 | [diff] [blame] | 2918 | |
| 2919 | for (i = 0; i < num_rates; i++) |
| 2920 | lq_cmd->rs_table[i] = ucode_rate_le32; |
| 2921 | |
| 2922 | rs_rate_from_ucode_rate(ucode_rate, band, &rate); |
| 2923 | |
| 2924 | if (is_mimo(&rate)) |
| 2925 | lq_cmd->mimo_delim = num_rates - 1; |
| 2926 | else |
| 2927 | lq_cmd->mimo_delim = 0; |
Emmanuel Grumbach | 7ceb98a | 2014-07-28 12:59:45 +0300 | [diff] [blame] | 2928 | |
| 2929 | lq_cmd->reduced_tpc = 0; |
| 2930 | |
| 2931 | if (num_of_ant(ant) == 1) |
| 2932 | lq_cmd->single_stream_ant_msk = ant; |
| 2933 | |
| 2934 | lq_cmd->agg_frame_cnt_limit = LINK_QUAL_AGG_FRAME_LIMIT_DEF; |
Eyal Shapira | 8fc7c58 | 2013-12-04 02:15:46 +0200 | [diff] [blame] | 2935 | } |
| 2936 | #endif /* CONFIG_MAC80211_DEBUGFS */ |
| 2937 | |
Eyal Shapira | e07be6d | 2013-12-09 13:02:56 +0200 | [diff] [blame] | 2938 | static void rs_fill_rates_for_column(struct iwl_mvm *mvm, |
| 2939 | struct iwl_lq_sta *lq_sta, |
| 2940 | struct rs_rate *rate, |
| 2941 | __le32 *rs_table, int *rs_table_index, |
| 2942 | int num_rates, int num_retries, |
| 2943 | u8 valid_tx_ant, bool toggle_ant) |
| 2944 | { |
| 2945 | int i, j; |
| 2946 | __le32 ucode_rate; |
| 2947 | bool bottom_reached = false; |
| 2948 | int prev_rate_idx = rate->index; |
| 2949 | int end = LINK_QUAL_MAX_RETRY_NUM; |
| 2950 | int index = *rs_table_index; |
| 2951 | |
| 2952 | for (i = 0; i < num_rates && index < end; i++) { |
Eyal Shapira | bd99931 | 2014-12-28 22:12:38 +0200 | [diff] [blame] | 2953 | for (j = 0; j < num_retries && index < end; j++, index++) { |
| 2954 | ucode_rate = cpu_to_le32(ucode_rate_from_rs_rate(mvm, |
| 2955 | rate)); |
Eyal Shapira | e07be6d | 2013-12-09 13:02:56 +0200 | [diff] [blame] | 2956 | rs_table[index] = ucode_rate; |
Eyal Shapira | bd99931 | 2014-12-28 22:12:38 +0200 | [diff] [blame] | 2957 | if (toggle_ant) |
| 2958 | rs_toggle_antenna(valid_tx_ant, rate); |
| 2959 | } |
Eyal Shapira | e07be6d | 2013-12-09 13:02:56 +0200 | [diff] [blame] | 2960 | |
| 2961 | prev_rate_idx = rate->index; |
| 2962 | bottom_reached = rs_get_lower_rate_in_column(lq_sta, rate); |
| 2963 | if (bottom_reached && !is_legacy(rate)) |
| 2964 | break; |
| 2965 | } |
| 2966 | |
Eyal Shapira | bd99931 | 2014-12-28 22:12:38 +0200 | [diff] [blame] | 2967 | if (!bottom_reached && !is_legacy(rate)) |
Eyal Shapira | e07be6d | 2013-12-09 13:02:56 +0200 | [diff] [blame] | 2968 | rate->index = prev_rate_idx; |
| 2969 | |
| 2970 | *rs_table_index = index; |
| 2971 | } |
| 2972 | |
| 2973 | /* Building the rate table is non trivial. When we're in MIMO2/VHT/80Mhz/SGI |
| 2974 | * column the rate table should look like this: |
| 2975 | * |
| 2976 | * rate[0] 0x400D019 VHT | ANT: AB BW: 80Mhz MCS: 9 NSS: 2 SGI |
| 2977 | * rate[1] 0x400D019 VHT | ANT: AB BW: 80Mhz MCS: 9 NSS: 2 SGI |
| 2978 | * rate[2] 0x400D018 VHT | ANT: AB BW: 80Mhz MCS: 8 NSS: 2 SGI |
| 2979 | * rate[3] 0x400D018 VHT | ANT: AB BW: 80Mhz MCS: 8 NSS: 2 SGI |
| 2980 | * rate[4] 0x400D017 VHT | ANT: AB BW: 80Mhz MCS: 7 NSS: 2 SGI |
| 2981 | * rate[5] 0x400D017 VHT | ANT: AB BW: 80Mhz MCS: 7 NSS: 2 SGI |
| 2982 | * rate[6] 0x4005007 VHT | ANT: A BW: 80Mhz MCS: 7 NSS: 1 NGI |
| 2983 | * rate[7] 0x4009006 VHT | ANT: B BW: 80Mhz MCS: 6 NSS: 1 NGI |
| 2984 | * rate[8] 0x4005005 VHT | ANT: A BW: 80Mhz MCS: 5 NSS: 1 NGI |
| 2985 | * rate[9] 0x800B Legacy | ANT: B Rate: 36 Mbps |
| 2986 | * rate[10] 0x4009 Legacy | ANT: A Rate: 24 Mbps |
| 2987 | * rate[11] 0x8007 Legacy | ANT: B Rate: 18 Mbps |
| 2988 | * rate[12] 0x4005 Legacy | ANT: A Rate: 12 Mbps |
| 2989 | * rate[13] 0x800F Legacy | ANT: B Rate: 9 Mbps |
| 2990 | * rate[14] 0x400D Legacy | ANT: A Rate: 6 Mbps |
| 2991 | * rate[15] 0x800D Legacy | ANT: B Rate: 6 Mbps |
| 2992 | */ |
Eyal Shapira | 8fc7c58 | 2013-12-04 02:15:46 +0200 | [diff] [blame] | 2993 | static void rs_build_rates_table(struct iwl_mvm *mvm, |
Eyal Shapira | d8bafea | 2014-10-23 13:58:38 +0300 | [diff] [blame] | 2994 | struct ieee80211_sta *sta, |
Eyal Shapira | 8fc7c58 | 2013-12-04 02:15:46 +0200 | [diff] [blame] | 2995 | struct iwl_lq_sta *lq_sta, |
| 2996 | const struct rs_rate *initial_rate) |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 2997 | { |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 2998 | struct rs_rate rate; |
Eyal Shapira | e07be6d | 2013-12-09 13:02:56 +0200 | [diff] [blame] | 2999 | int num_rates, num_retries, index = 0; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 3000 | u8 valid_tx_ant = 0; |
| 3001 | struct iwl_lq_cmd *lq_cmd = &lq_sta->lq; |
Eyal Shapira | e07be6d | 2013-12-09 13:02:56 +0200 | [diff] [blame] | 3002 | bool toggle_ant = false; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 3003 | |
Emmanuel Grumbach | 9e898f1 | 2013-12-22 10:55:47 +0200 | [diff] [blame] | 3004 | memcpy(&rate, initial_rate, sizeof(rate)); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 3005 | |
Moshe Harel | a054427 | 2014-12-08 21:13:14 +0200 | [diff] [blame] | 3006 | valid_tx_ant = iwl_mvm_get_valid_tx_ant(mvm); |
Eyal Shapira | c5d679a | 2015-01-15 20:22:34 +0200 | [diff] [blame] | 3007 | |
Eyal Shapira | 3d44eeb | 2015-01-16 22:37:04 +0200 | [diff] [blame] | 3008 | /* TODO: remove old API when min FW API hits 14 */ |
| 3009 | if (!(mvm->fw->ucode_capa.api[0] & IWL_UCODE_TLV_API_LQ_SS_PARAMS) && |
| 3010 | rs_stbc_allow(mvm, sta, lq_sta)) |
| 3011 | rate.stbc = true; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 3012 | |
Eyal Shapira | e07be6d | 2013-12-09 13:02:56 +0200 | [diff] [blame] | 3013 | if (is_siso(&rate)) { |
Eyal Shapira | 834437d | 2014-12-17 15:38:58 +0200 | [diff] [blame] | 3014 | num_rates = IWL_MVM_RS_INITIAL_SISO_NUM_RATES; |
| 3015 | num_retries = IWL_MVM_RS_HT_VHT_RETRIES_PER_RATE; |
Eyal Shapira | e07be6d | 2013-12-09 13:02:56 +0200 | [diff] [blame] | 3016 | } else if (is_mimo(&rate)) { |
Eyal Shapira | 834437d | 2014-12-17 15:38:58 +0200 | [diff] [blame] | 3017 | num_rates = IWL_MVM_RS_INITIAL_MIMO_NUM_RATES; |
| 3018 | num_retries = IWL_MVM_RS_HT_VHT_RETRIES_PER_RATE; |
Eyal Shapira | e07be6d | 2013-12-09 13:02:56 +0200 | [diff] [blame] | 3019 | } else { |
Eyal Shapira | 834437d | 2014-12-17 15:38:58 +0200 | [diff] [blame] | 3020 | num_rates = IWL_MVM_RS_INITIAL_LEGACY_NUM_RATES; |
Eyal Shapira | bd99931 | 2014-12-28 22:12:38 +0200 | [diff] [blame] | 3021 | num_retries = IWL_MVM_RS_INITIAL_LEGACY_RETRIES; |
Eyal Shapira | e07be6d | 2013-12-09 13:02:56 +0200 | [diff] [blame] | 3022 | toggle_ant = true; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 3023 | } |
Eyal Shapira | e07be6d | 2013-12-09 13:02:56 +0200 | [diff] [blame] | 3024 | |
| 3025 | rs_fill_rates_for_column(mvm, lq_sta, &rate, lq_cmd->rs_table, &index, |
| 3026 | num_rates, num_retries, valid_tx_ant, |
| 3027 | toggle_ant); |
| 3028 | |
| 3029 | rs_get_lower_rate_down_column(lq_sta, &rate); |
| 3030 | |
| 3031 | if (is_siso(&rate)) { |
Eyal Shapira | 834437d | 2014-12-17 15:38:58 +0200 | [diff] [blame] | 3032 | num_rates = IWL_MVM_RS_SECONDARY_SISO_NUM_RATES; |
| 3033 | num_retries = IWL_MVM_RS_SECONDARY_SISO_RETRIES; |
Eyal Shapira | d9088f6 | 2014-03-25 10:25:44 +0200 | [diff] [blame] | 3034 | lq_cmd->mimo_delim = index; |
Eyal Shapira | e07be6d | 2013-12-09 13:02:56 +0200 | [diff] [blame] | 3035 | } else if (is_legacy(&rate)) { |
Eyal Shapira | 834437d | 2014-12-17 15:38:58 +0200 | [diff] [blame] | 3036 | num_rates = IWL_MVM_RS_SECONDARY_LEGACY_NUM_RATES; |
Eyal Shapira | bd99931 | 2014-12-28 22:12:38 +0200 | [diff] [blame] | 3037 | num_retries = IWL_MVM_RS_SECONDARY_LEGACY_RETRIES; |
Eyal Shapira | e07be6d | 2013-12-09 13:02:56 +0200 | [diff] [blame] | 3038 | } else { |
| 3039 | WARN_ON_ONCE(1); |
| 3040 | } |
| 3041 | |
| 3042 | toggle_ant = true; |
| 3043 | |
| 3044 | rs_fill_rates_for_column(mvm, lq_sta, &rate, lq_cmd->rs_table, &index, |
| 3045 | num_rates, num_retries, valid_tx_ant, |
| 3046 | toggle_ant); |
| 3047 | |
| 3048 | rs_get_lower_rate_down_column(lq_sta, &rate); |
| 3049 | |
Eyal Shapira | 834437d | 2014-12-17 15:38:58 +0200 | [diff] [blame] | 3050 | num_rates = IWL_MVM_RS_SECONDARY_LEGACY_NUM_RATES; |
Eyal Shapira | bd99931 | 2014-12-28 22:12:38 +0200 | [diff] [blame] | 3051 | num_retries = IWL_MVM_RS_SECONDARY_LEGACY_RETRIES; |
Eyal Shapira | e07be6d | 2013-12-09 13:02:56 +0200 | [diff] [blame] | 3052 | |
| 3053 | rs_fill_rates_for_column(mvm, lq_sta, &rate, lq_cmd->rs_table, &index, |
| 3054 | num_rates, num_retries, valid_tx_ant, |
| 3055 | toggle_ant); |
| 3056 | |
Eyal Shapira | 8fc7c58 | 2013-12-04 02:15:46 +0200 | [diff] [blame] | 3057 | } |
| 3058 | |
Eyal Shapira | 3d44eeb | 2015-01-16 22:37:04 +0200 | [diff] [blame] | 3059 | struct rs_bfer_active_iter_data { |
| 3060 | struct ieee80211_sta *exclude_sta; |
| 3061 | struct iwl_mvm_sta *bfer_mvmsta; |
| 3062 | }; |
| 3063 | |
| 3064 | static void rs_bfer_active_iter(void *_data, |
| 3065 | struct ieee80211_sta *sta) |
| 3066 | { |
| 3067 | struct rs_bfer_active_iter_data *data = _data; |
| 3068 | struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta); |
| 3069 | struct iwl_lq_cmd *lq_cmd = &mvmsta->lq_sta.lq; |
| 3070 | u32 ss_params = le32_to_cpu(lq_cmd->ss_params); |
| 3071 | |
| 3072 | if (sta == data->exclude_sta) |
| 3073 | return; |
| 3074 | |
| 3075 | /* The current sta has BFER allowed */ |
| 3076 | if (ss_params & LQ_SS_BFER_ALLOWED) { |
| 3077 | WARN_ON_ONCE(data->bfer_mvmsta != NULL); |
| 3078 | |
| 3079 | data->bfer_mvmsta = mvmsta; |
| 3080 | } |
| 3081 | } |
| 3082 | |
| 3083 | static int rs_bfer_priority(struct iwl_mvm_sta *sta) |
| 3084 | { |
| 3085 | int prio = -1; |
| 3086 | enum nl80211_iftype viftype = ieee80211_vif_type_p2p(sta->vif); |
| 3087 | |
| 3088 | switch (viftype) { |
| 3089 | case NL80211_IFTYPE_AP: |
| 3090 | case NL80211_IFTYPE_P2P_GO: |
| 3091 | prio = 3; |
| 3092 | break; |
| 3093 | case NL80211_IFTYPE_P2P_CLIENT: |
| 3094 | prio = 2; |
| 3095 | break; |
| 3096 | case NL80211_IFTYPE_STATION: |
| 3097 | prio = 1; |
| 3098 | break; |
| 3099 | default: |
| 3100 | WARN_ONCE(true, "viftype %d sta_id %d", viftype, sta->sta_id); |
| 3101 | prio = -1; |
| 3102 | } |
| 3103 | |
| 3104 | return prio; |
| 3105 | } |
| 3106 | |
| 3107 | /* Returns >0 if sta1 has a higher BFER priority compared to sta2 */ |
| 3108 | static int rs_bfer_priority_cmp(struct iwl_mvm_sta *sta1, |
| 3109 | struct iwl_mvm_sta *sta2) |
| 3110 | { |
| 3111 | int prio1 = rs_bfer_priority(sta1); |
| 3112 | int prio2 = rs_bfer_priority(sta2); |
| 3113 | |
| 3114 | if (prio1 > prio2) |
| 3115 | return 1; |
| 3116 | if (prio1 < prio2) |
| 3117 | return -1; |
| 3118 | return 0; |
| 3119 | } |
| 3120 | |
| 3121 | static void rs_set_lq_ss_params(struct iwl_mvm *mvm, |
| 3122 | struct ieee80211_sta *sta, |
| 3123 | struct iwl_lq_sta *lq_sta, |
| 3124 | const struct rs_rate *initial_rate) |
| 3125 | { |
| 3126 | struct iwl_lq_cmd *lq_cmd = &lq_sta->lq; |
| 3127 | struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta); |
| 3128 | struct rs_bfer_active_iter_data data = { |
| 3129 | .exclude_sta = sta, |
| 3130 | .bfer_mvmsta = NULL, |
| 3131 | }; |
| 3132 | struct iwl_mvm_sta *bfer_mvmsta = NULL; |
| 3133 | u32 ss_params = LQ_SS_PARAMS_VALID; |
| 3134 | |
| 3135 | if (!iwl_mvm_bt_coex_is_mimo_allowed(mvm, sta)) |
| 3136 | goto out; |
| 3137 | |
Eyal Shapira | 878985ce | 2015-02-02 12:14:54 +0200 | [diff] [blame] | 3138 | #ifdef CONFIG_MAC80211_DEBUGFS |
Eyal Shapira | 1e9c62f | 2015-01-28 14:44:06 +0200 | [diff] [blame] | 3139 | /* Check if forcing the decision is configured. |
| 3140 | * Note that SISO is forced by not allowing STBC or BFER |
| 3141 | */ |
Eyal Shapira | 878985ce | 2015-02-02 12:14:54 +0200 | [diff] [blame] | 3142 | if (lq_sta->pers.ss_force == RS_SS_FORCE_STBC) |
Eyal Shapira | 1e9c62f | 2015-01-28 14:44:06 +0200 | [diff] [blame] | 3143 | ss_params |= (LQ_SS_STBC_1SS_ALLOWED | LQ_SS_FORCE); |
Eyal Shapira | 878985ce | 2015-02-02 12:14:54 +0200 | [diff] [blame] | 3144 | else if (lq_sta->pers.ss_force == RS_SS_FORCE_BFER) |
Eyal Shapira | 1e9c62f | 2015-01-28 14:44:06 +0200 | [diff] [blame] | 3145 | ss_params |= (LQ_SS_BFER_ALLOWED | LQ_SS_FORCE); |
| 3146 | |
Eyal Shapira | 878985ce | 2015-02-02 12:14:54 +0200 | [diff] [blame] | 3147 | if (lq_sta->pers.ss_force != RS_SS_FORCE_NONE) { |
Eyal Shapira | 1e9c62f | 2015-01-28 14:44:06 +0200 | [diff] [blame] | 3148 | IWL_DEBUG_RATE(mvm, "Forcing single stream Tx decision %d\n", |
Eyal Shapira | 878985ce | 2015-02-02 12:14:54 +0200 | [diff] [blame] | 3149 | lq_sta->pers.ss_force); |
Eyal Shapira | 1e9c62f | 2015-01-28 14:44:06 +0200 | [diff] [blame] | 3150 | goto out; |
| 3151 | } |
Eyal Shapira | 878985ce | 2015-02-02 12:14:54 +0200 | [diff] [blame] | 3152 | #endif |
Eyal Shapira | 1e9c62f | 2015-01-28 14:44:06 +0200 | [diff] [blame] | 3153 | |
Eyal Shapira | 3d44eeb | 2015-01-16 22:37:04 +0200 | [diff] [blame] | 3154 | if (lq_sta->stbc_capable) |
| 3155 | ss_params |= LQ_SS_STBC_1SS_ALLOWED; |
| 3156 | |
| 3157 | if (!lq_sta->bfer_capable) |
| 3158 | goto out; |
| 3159 | |
| 3160 | ieee80211_iterate_stations_atomic(mvm->hw, |
| 3161 | rs_bfer_active_iter, |
| 3162 | &data); |
| 3163 | bfer_mvmsta = data.bfer_mvmsta; |
| 3164 | |
| 3165 | /* This code is safe as it doesn't run concurrently for different |
| 3166 | * stations. This is guaranteed by the fact that calls to |
| 3167 | * ieee80211_tx_status wouldn't run concurrently for a single HW. |
| 3168 | */ |
| 3169 | if (!bfer_mvmsta) { |
| 3170 | IWL_DEBUG_RATE(mvm, "No sta with BFER allowed found. Allow\n"); |
| 3171 | |
| 3172 | ss_params |= LQ_SS_BFER_ALLOWED; |
| 3173 | goto out; |
| 3174 | } |
| 3175 | |
| 3176 | IWL_DEBUG_RATE(mvm, "Found existing sta %d with BFER activated\n", |
| 3177 | bfer_mvmsta->sta_id); |
| 3178 | |
| 3179 | /* Disallow BFER on another STA if active and we're a higher priority */ |
| 3180 | if (rs_bfer_priority_cmp(mvmsta, bfer_mvmsta) > 0) { |
| 3181 | struct iwl_lq_cmd *bfersta_lq_cmd = &bfer_mvmsta->lq_sta.lq; |
| 3182 | u32 bfersta_ss_params = le32_to_cpu(bfersta_lq_cmd->ss_params); |
| 3183 | |
| 3184 | bfersta_ss_params &= ~LQ_SS_BFER_ALLOWED; |
| 3185 | bfersta_lq_cmd->ss_params = cpu_to_le32(bfersta_ss_params); |
| 3186 | iwl_mvm_send_lq_cmd(mvm, bfersta_lq_cmd, false); |
| 3187 | |
| 3188 | ss_params |= LQ_SS_BFER_ALLOWED; |
| 3189 | IWL_DEBUG_RATE(mvm, |
| 3190 | "Lower priority BFER sta found (%d). Switch BFER\n", |
| 3191 | bfer_mvmsta->sta_id); |
| 3192 | } |
| 3193 | out: |
| 3194 | lq_cmd->ss_params = cpu_to_le32(ss_params); |
| 3195 | } |
| 3196 | |
Eyal Shapira | 8fc7c58 | 2013-12-04 02:15:46 +0200 | [diff] [blame] | 3197 | static void rs_fill_lq_cmd(struct iwl_mvm *mvm, |
| 3198 | struct ieee80211_sta *sta, |
| 3199 | struct iwl_lq_sta *lq_sta, |
| 3200 | const struct rs_rate *initial_rate) |
| 3201 | { |
| 3202 | struct iwl_lq_cmd *lq_cmd = &lq_sta->lq; |
Emmanuel Grumbach | 7ceb98a | 2014-07-28 12:59:45 +0300 | [diff] [blame] | 3203 | struct iwl_mvm_sta *mvmsta; |
| 3204 | struct iwl_mvm_vif *mvmvif; |
| 3205 | |
Eyal Shapira | 834437d | 2014-12-17 15:38:58 +0200 | [diff] [blame] | 3206 | lq_cmd->agg_disable_start_th = IWL_MVM_RS_AGG_DISABLE_START; |
Emmanuel Grumbach | 7ceb98a | 2014-07-28 12:59:45 +0300 | [diff] [blame] | 3207 | lq_cmd->agg_time_limit = |
Eyal Shapira | 834437d | 2014-12-17 15:38:58 +0200 | [diff] [blame] | 3208 | cpu_to_le16(IWL_MVM_RS_AGG_TIME_LIMIT); |
Eyal Shapira | 8fc7c58 | 2013-12-04 02:15:46 +0200 | [diff] [blame] | 3209 | |
| 3210 | #ifdef CONFIG_MAC80211_DEBUGFS |
Eliad Peller | ae969af | 2014-06-11 15:51:33 +0300 | [diff] [blame] | 3211 | if (lq_sta->pers.dbg_fixed_rate) { |
Eyal Shapira | 8fc7c58 | 2013-12-04 02:15:46 +0200 | [diff] [blame] | 3212 | rs_build_rates_table_from_fixed(mvm, lq_cmd, |
| 3213 | lq_sta->band, |
Eliad Peller | ae969af | 2014-06-11 15:51:33 +0300 | [diff] [blame] | 3214 | lq_sta->pers.dbg_fixed_rate); |
Emmanuel Grumbach | 7ceb98a | 2014-07-28 12:59:45 +0300 | [diff] [blame] | 3215 | return; |
| 3216 | } |
Eyal Shapira | 8fc7c58 | 2013-12-04 02:15:46 +0200 | [diff] [blame] | 3217 | #endif |
Emmanuel Grumbach | 7ceb98a | 2014-07-28 12:59:45 +0300 | [diff] [blame] | 3218 | if (WARN_ON_ONCE(!sta || !initial_rate)) |
| 3219 | return; |
Eyal Shapira | 8fc7c58 | 2013-12-04 02:15:46 +0200 | [diff] [blame] | 3220 | |
Eyal Shapira | d8bafea | 2014-10-23 13:58:38 +0300 | [diff] [blame] | 3221 | rs_build_rates_table(mvm, sta, lq_sta, initial_rate); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 3222 | |
Eyal Shapira | 3d44eeb | 2015-01-16 22:37:04 +0200 | [diff] [blame] | 3223 | if (mvm->fw->ucode_capa.api[0] & IWL_UCODE_TLV_API_LQ_SS_PARAMS) |
| 3224 | rs_set_lq_ss_params(mvm, sta, lq_sta, initial_rate); |
| 3225 | |
Emmanuel Grumbach | 7ceb98a | 2014-07-28 12:59:45 +0300 | [diff] [blame] | 3226 | if (num_of_ant(initial_rate->ant) == 1) |
| 3227 | lq_cmd->single_stream_ant_msk = initial_rate->ant; |
| 3228 | |
| 3229 | mvmsta = iwl_mvm_sta_from_mac80211(sta); |
| 3230 | mvmvif = iwl_mvm_vif_from_mac80211(mvmsta->vif); |
| 3231 | |
| 3232 | if (num_of_ant(initial_rate->ant) == 1) |
| 3233 | lq_cmd->single_stream_ant_msk = initial_rate->ant; |
| 3234 | |
| 3235 | lq_cmd->agg_frame_cnt_limit = mvmsta->max_agg_bufsize; |
| 3236 | |
| 3237 | /* |
Sara Sharon | 0d365ae | 2015-03-31 12:24:05 +0300 | [diff] [blame] | 3238 | * In case of low latency, tell the firmware to leave a frame in the |
Emmanuel Grumbach | 7ceb98a | 2014-07-28 12:59:45 +0300 | [diff] [blame] | 3239 | * Tx Fifo so that it can start a transaction in the same TxOP. This |
| 3240 | * basically allows the firmware to send bursts. |
| 3241 | */ |
Eyal Shapira | 9ecd051 | 2014-08-28 02:21:05 +0300 | [diff] [blame] | 3242 | if (iwl_mvm_vif_low_latency(mvmvif)) { |
Emmanuel Grumbach | 7ceb98a | 2014-07-28 12:59:45 +0300 | [diff] [blame] | 3243 | lq_cmd->agg_frame_cnt_limit--; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 3244 | |
Eyal Shapira | 9ecd051 | 2014-08-28 02:21:05 +0300 | [diff] [blame] | 3245 | if (mvm->low_latency_agg_frame_limit) |
| 3246 | lq_cmd->agg_frame_cnt_limit = |
| 3247 | min(lq_cmd->agg_frame_cnt_limit, |
| 3248 | mvm->low_latency_agg_frame_limit); |
| 3249 | } |
| 3250 | |
Emmanuel Grumbach | a4db848 | 2014-07-31 13:58:53 +0300 | [diff] [blame] | 3251 | if (mvmsta->vif->p2p) |
| 3252 | lq_cmd->flags |= LQ_FLAG_USE_RTS_MSK; |
| 3253 | |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 3254 | lq_cmd->agg_time_limit = |
Emmanuel Grumbach | 5b7ff61 | 2014-03-11 19:27:45 +0200 | [diff] [blame] | 3255 | cpu_to_le16(iwl_mvm_coex_agg_time_limit(mvm, sta)); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 3256 | } |
| 3257 | |
| 3258 | static void *rs_alloc(struct ieee80211_hw *hw, struct dentry *debugfsdir) |
| 3259 | { |
| 3260 | return hw->priv; |
| 3261 | } |
| 3262 | /* rate scale requires free function to be implemented */ |
| 3263 | static void rs_free(void *mvm_rate) |
| 3264 | { |
| 3265 | return; |
| 3266 | } |
| 3267 | |
| 3268 | static void rs_free_sta(void *mvm_r, struct ieee80211_sta *sta, |
| 3269 | void *mvm_sta) |
| 3270 | { |
| 3271 | struct iwl_op_mode *op_mode __maybe_unused = mvm_r; |
| 3272 | struct iwl_mvm *mvm __maybe_unused = IWL_OP_MODE_GET_MVM(op_mode); |
| 3273 | |
| 3274 | IWL_DEBUG_RATE(mvm, "enter\n"); |
| 3275 | IWL_DEBUG_RATE(mvm, "leave\n"); |
| 3276 | } |
| 3277 | |
| 3278 | #ifdef CONFIG_MAC80211_DEBUGFS |
Eyal Shapira | 5fc0f76 | 2014-01-28 01:35:32 +0200 | [diff] [blame] | 3279 | int rs_pretty_print_rate(char *buf, const u32 rate) |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 3280 | { |
| 3281 | |
Eyal Shapira | 1a61b34 | 2013-11-09 02:11:46 +0200 | [diff] [blame] | 3282 | char *type, *bw; |
| 3283 | u8 mcs = 0, nss = 0; |
| 3284 | u8 ant = (rate & RATE_MCS_ANT_ABC_MSK) >> RATE_MCS_ANT_POS; |
| 3285 | |
| 3286 | if (!(rate & RATE_MCS_HT_MSK) && |
| 3287 | !(rate & RATE_MCS_VHT_MSK)) { |
| 3288 | int index = iwl_hwrate_to_plcp_idx(rate); |
| 3289 | |
| 3290 | return sprintf(buf, "Legacy | ANT: %s Rate: %s Mbps\n", |
Eyal Shapira | 560843f | 2014-01-05 21:04:19 +0200 | [diff] [blame] | 3291 | rs_pretty_ant(ant), |
| 3292 | index == IWL_RATE_INVALID ? "BAD" : |
| 3293 | iwl_rate_mcs[index].mbps); |
Eyal Shapira | 1a61b34 | 2013-11-09 02:11:46 +0200 | [diff] [blame] | 3294 | } |
| 3295 | |
| 3296 | if (rate & RATE_MCS_VHT_MSK) { |
| 3297 | type = "VHT"; |
| 3298 | mcs = rate & RATE_VHT_MCS_RATE_CODE_MSK; |
| 3299 | nss = ((rate & RATE_VHT_MCS_NSS_MSK) |
| 3300 | >> RATE_VHT_MCS_NSS_POS) + 1; |
| 3301 | } else if (rate & RATE_MCS_HT_MSK) { |
| 3302 | type = "HT"; |
| 3303 | mcs = rate & RATE_HT_MCS_INDEX_MSK; |
| 3304 | } else { |
| 3305 | type = "Unknown"; /* shouldn't happen */ |
| 3306 | } |
| 3307 | |
| 3308 | switch (rate & RATE_MCS_CHAN_WIDTH_MSK) { |
| 3309 | case RATE_MCS_CHAN_WIDTH_20: |
| 3310 | bw = "20Mhz"; |
| 3311 | break; |
| 3312 | case RATE_MCS_CHAN_WIDTH_40: |
| 3313 | bw = "40Mhz"; |
| 3314 | break; |
| 3315 | case RATE_MCS_CHAN_WIDTH_80: |
| 3316 | bw = "80Mhz"; |
| 3317 | break; |
| 3318 | case RATE_MCS_CHAN_WIDTH_160: |
| 3319 | bw = "160Mhz"; |
| 3320 | break; |
| 3321 | default: |
| 3322 | bw = "BAD BW"; |
| 3323 | } |
| 3324 | |
| 3325 | return sprintf(buf, "%s | ANT: %s BW: %s MCS: %d NSS: %d %s%s%s%s%s\n", |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 3326 | type, rs_pretty_ant(ant), bw, mcs, nss, |
Eyal Shapira | 1a61b34 | 2013-11-09 02:11:46 +0200 | [diff] [blame] | 3327 | (rate & RATE_MCS_SGI_MSK) ? "SGI " : "NGI ", |
Emmanuel Grumbach | 7b1dd04 | 2014-02-04 15:32:43 +0200 | [diff] [blame] | 3328 | (rate & RATE_MCS_HT_STBC_MSK) ? "STBC " : "", |
Eyal Shapira | 1a61b34 | 2013-11-09 02:11:46 +0200 | [diff] [blame] | 3329 | (rate & RATE_MCS_LDPC_MSK) ? "LDPC " : "", |
| 3330 | (rate & RATE_MCS_BF_MSK) ? "BF " : "", |
| 3331 | (rate & RATE_MCS_ZLF_MSK) ? "ZLF " : ""); |
| 3332 | } |
| 3333 | |
Eyal Shapira | a0c38b2 | 2013-12-03 18:34:52 +0200 | [diff] [blame] | 3334 | /** |
| 3335 | * Program the device to use fixed rate for frame transmit |
| 3336 | * This is for debugging/testing only |
| 3337 | * once the device start use fixed rate, we need to reload the module |
| 3338 | * to being back the normal operation. |
| 3339 | */ |
| 3340 | static void rs_program_fix_rate(struct iwl_mvm *mvm, |
| 3341 | struct iwl_lq_sta *lq_sta) |
| 3342 | { |
| 3343 | lq_sta->active_legacy_rate = 0x0FFF; /* 1 - 54 MBits, includes CCK */ |
| 3344 | lq_sta->active_siso_rate = 0x1FD0; /* 6 - 60 MBits, no 9, no CCK */ |
| 3345 | lq_sta->active_mimo2_rate = 0x1FD0; /* 6 - 60 MBits, no 9, no CCK */ |
| 3346 | |
| 3347 | IWL_DEBUG_RATE(mvm, "sta_id %d rate 0x%X\n", |
Eliad Peller | ae969af | 2014-06-11 15:51:33 +0300 | [diff] [blame] | 3348 | lq_sta->lq.sta_id, lq_sta->pers.dbg_fixed_rate); |
Eyal Shapira | a0c38b2 | 2013-12-03 18:34:52 +0200 | [diff] [blame] | 3349 | |
Eliad Peller | ae969af | 2014-06-11 15:51:33 +0300 | [diff] [blame] | 3350 | if (lq_sta->pers.dbg_fixed_rate) { |
Emmanuel Grumbach | 7ceb98a | 2014-07-28 12:59:45 +0300 | [diff] [blame] | 3351 | rs_fill_lq_cmd(mvm, NULL, lq_sta, NULL); |
Eliad Peller | ae969af | 2014-06-11 15:51:33 +0300 | [diff] [blame] | 3352 | iwl_mvm_send_lq_cmd(lq_sta->pers.drv, &lq_sta->lq, false); |
Eyal Shapira | a0c38b2 | 2013-12-03 18:34:52 +0200 | [diff] [blame] | 3353 | } |
| 3354 | } |
| 3355 | |
Emmanuel Grumbach | 9d10849 | 2013-12-03 11:50:30 +0200 | [diff] [blame] | 3356 | static ssize_t rs_sta_dbgfs_scale_table_write(struct file *file, |
| 3357 | const char __user *user_buf, size_t count, loff_t *ppos) |
| 3358 | { |
| 3359 | struct iwl_lq_sta *lq_sta = file->private_data; |
| 3360 | struct iwl_mvm *mvm; |
| 3361 | char buf[64]; |
| 3362 | size_t buf_size; |
| 3363 | u32 parsed_rate; |
| 3364 | |
Eliad Peller | ae969af | 2014-06-11 15:51:33 +0300 | [diff] [blame] | 3365 | mvm = lq_sta->pers.drv; |
Emmanuel Grumbach | 9d10849 | 2013-12-03 11:50:30 +0200 | [diff] [blame] | 3366 | memset(buf, 0, sizeof(buf)); |
| 3367 | buf_size = min(count, sizeof(buf) - 1); |
| 3368 | if (copy_from_user(buf, user_buf, buf_size)) |
| 3369 | return -EFAULT; |
| 3370 | |
| 3371 | if (sscanf(buf, "%x", &parsed_rate) == 1) |
Eliad Peller | ae969af | 2014-06-11 15:51:33 +0300 | [diff] [blame] | 3372 | lq_sta->pers.dbg_fixed_rate = parsed_rate; |
Emmanuel Grumbach | 9d10849 | 2013-12-03 11:50:30 +0200 | [diff] [blame] | 3373 | else |
Eliad Peller | ae969af | 2014-06-11 15:51:33 +0300 | [diff] [blame] | 3374 | lq_sta->pers.dbg_fixed_rate = 0; |
Emmanuel Grumbach | 9d10849 | 2013-12-03 11:50:30 +0200 | [diff] [blame] | 3375 | |
| 3376 | rs_program_fix_rate(mvm, lq_sta); |
| 3377 | |
| 3378 | return count; |
| 3379 | } |
| 3380 | |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 3381 | static ssize_t rs_sta_dbgfs_scale_table_read(struct file *file, |
| 3382 | char __user *user_buf, size_t count, loff_t *ppos) |
| 3383 | { |
| 3384 | char *buff; |
| 3385 | int desc = 0; |
| 3386 | int i = 0; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 3387 | ssize_t ret; |
| 3388 | |
| 3389 | struct iwl_lq_sta *lq_sta = file->private_data; |
| 3390 | struct iwl_mvm *mvm; |
| 3391 | struct iwl_scale_tbl_info *tbl = &(lq_sta->lq_info[lq_sta->active_tbl]); |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 3392 | struct rs_rate *rate = &tbl->rate; |
Eyal Shapira | 16c426f | 2015-02-02 12:46:22 +0200 | [diff] [blame] | 3393 | u32 ss_params; |
Eliad Peller | ae969af | 2014-06-11 15:51:33 +0300 | [diff] [blame] | 3394 | mvm = lq_sta->pers.drv; |
Eyal Shapira | 1a61b34 | 2013-11-09 02:11:46 +0200 | [diff] [blame] | 3395 | buff = kmalloc(2048, GFP_KERNEL); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 3396 | if (!buff) |
| 3397 | return -ENOMEM; |
| 3398 | |
| 3399 | desc += sprintf(buff+desc, "sta_id %d\n", lq_sta->lq.sta_id); |
Eyal Shapira | 198266a | 2014-03-31 22:37:39 +0300 | [diff] [blame] | 3400 | desc += sprintf(buff+desc, "failed=%d success=%d rate=0%lX\n", |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 3401 | lq_sta->total_failed, lq_sta->total_success, |
| 3402 | lq_sta->active_legacy_rate); |
| 3403 | desc += sprintf(buff+desc, "fixed rate 0x%X\n", |
Eliad Peller | ae969af | 2014-06-11 15:51:33 +0300 | [diff] [blame] | 3404 | lq_sta->pers.dbg_fixed_rate); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 3405 | desc += sprintf(buff+desc, "valid_tx_ant %s%s%s\n", |
Moshe Harel | a054427 | 2014-12-08 21:13:14 +0200 | [diff] [blame] | 3406 | (iwl_mvm_get_valid_tx_ant(mvm) & ANT_A) ? "ANT_A," : "", |
| 3407 | (iwl_mvm_get_valid_tx_ant(mvm) & ANT_B) ? "ANT_B," : "", |
| 3408 | (iwl_mvm_get_valid_tx_ant(mvm) & ANT_C) ? "ANT_C" : ""); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 3409 | desc += sprintf(buff+desc, "lq type %s\n", |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 3410 | (is_legacy(rate)) ? "legacy" : |
| 3411 | is_vht(rate) ? "VHT" : "HT"); |
| 3412 | if (!is_legacy(rate)) { |
Emmanuel Grumbach | e70fe7e | 2015-03-01 17:18:00 +0200 | [diff] [blame] | 3413 | desc += sprintf(buff + desc, " %s", |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 3414 | (is_siso(rate)) ? "SISO" : "MIMO2"); |
Emmanuel Grumbach | e70fe7e | 2015-03-01 17:18:00 +0200 | [diff] [blame] | 3415 | desc += sprintf(buff + desc, " %s", |
| 3416 | (is_ht20(rate)) ? "20MHz" : |
| 3417 | (is_ht40(rate)) ? "40MHz" : |
| 3418 | (is_ht80(rate)) ? "80Mhz" : "BAD BW"); |
| 3419 | desc += sprintf(buff + desc, " %s %s %s\n", |
| 3420 | (rate->sgi) ? "SGI" : "NGI", |
| 3421 | (rate->ldpc) ? "LDPC" : "BCC", |
| 3422 | (lq_sta->is_agg) ? "AGG on" : ""); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 3423 | } |
| 3424 | desc += sprintf(buff+desc, "last tx rate=0x%X\n", |
| 3425 | lq_sta->last_rate_n_flags); |
| 3426 | desc += sprintf(buff+desc, |
Eyal Shapira | 1a61b34 | 2013-11-09 02:11:46 +0200 | [diff] [blame] | 3427 | "general: flags=0x%X mimo-d=%d s-ant=0x%x d-ant=0x%x\n", |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 3428 | lq_sta->lq.flags, |
| 3429 | lq_sta->lq.mimo_delim, |
| 3430 | lq_sta->lq.single_stream_ant_msk, |
| 3431 | lq_sta->lq.dual_stream_ant_msk); |
| 3432 | |
| 3433 | desc += sprintf(buff+desc, |
| 3434 | "agg: time_limit=%d dist_start_th=%d frame_cnt_limit=%d\n", |
| 3435 | le16_to_cpu(lq_sta->lq.agg_time_limit), |
| 3436 | lq_sta->lq.agg_disable_start_th, |
| 3437 | lq_sta->lq.agg_frame_cnt_limit); |
| 3438 | |
Eliad Peller | 2fd647f | 2014-03-13 17:21:36 +0200 | [diff] [blame] | 3439 | desc += sprintf(buff+desc, "reduced tpc=%d\n", lq_sta->lq.reduced_tpc); |
Eyal Shapira | 16c426f | 2015-02-02 12:46:22 +0200 | [diff] [blame] | 3440 | ss_params = le32_to_cpu(lq_sta->lq.ss_params); |
| 3441 | desc += sprintf(buff+desc, "single stream params: %s%s%s%s\n", |
| 3442 | (ss_params & LQ_SS_PARAMS_VALID) ? |
Eyal Shapira | db7c689 | 2015-03-02 10:35:19 +0200 | [diff] [blame] | 3443 | "VALID" : "INVALID", |
Eyal Shapira | 16c426f | 2015-02-02 12:46:22 +0200 | [diff] [blame] | 3444 | (ss_params & LQ_SS_BFER_ALLOWED) ? |
Eyal Shapira | db7c689 | 2015-03-02 10:35:19 +0200 | [diff] [blame] | 3445 | ", BFER" : "", |
Eyal Shapira | 16c426f | 2015-02-02 12:46:22 +0200 | [diff] [blame] | 3446 | (ss_params & LQ_SS_STBC_1SS_ALLOWED) ? |
Eyal Shapira | db7c689 | 2015-03-02 10:35:19 +0200 | [diff] [blame] | 3447 | ", STBC" : "", |
Eyal Shapira | 16c426f | 2015-02-02 12:46:22 +0200 | [diff] [blame] | 3448 | (ss_params & LQ_SS_FORCE) ? |
Eyal Shapira | db7c689 | 2015-03-02 10:35:19 +0200 | [diff] [blame] | 3449 | ", FORCE" : ""); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 3450 | desc += sprintf(buff+desc, |
| 3451 | "Start idx [0]=0x%x [1]=0x%x [2]=0x%x [3]=0x%x\n", |
| 3452 | lq_sta->lq.initial_rate_index[0], |
| 3453 | lq_sta->lq.initial_rate_index[1], |
| 3454 | lq_sta->lq.initial_rate_index[2], |
| 3455 | lq_sta->lq.initial_rate_index[3]); |
| 3456 | |
| 3457 | for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++) { |
Johannes Berg | cf4ef65 | 2013-12-17 11:34:25 +0100 | [diff] [blame] | 3458 | u32 r = le32_to_cpu(lq_sta->lq.rs_table[i]); |
Eyal Shapira | 1a61b34 | 2013-11-09 02:11:46 +0200 | [diff] [blame] | 3459 | |
Johannes Berg | cf4ef65 | 2013-12-17 11:34:25 +0100 | [diff] [blame] | 3460 | desc += sprintf(buff+desc, " rate[%d] 0x%X ", i, r); |
| 3461 | desc += rs_pretty_print_rate(buff+desc, r); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 3462 | } |
| 3463 | |
| 3464 | ret = simple_read_from_buffer(user_buf, count, ppos, buff, desc); |
| 3465 | kfree(buff); |
| 3466 | return ret; |
| 3467 | } |
| 3468 | |
| 3469 | static const struct file_operations rs_sta_dbgfs_scale_table_ops = { |
| 3470 | .write = rs_sta_dbgfs_scale_table_write, |
| 3471 | .read = rs_sta_dbgfs_scale_table_read, |
| 3472 | .open = simple_open, |
| 3473 | .llseek = default_llseek, |
| 3474 | }; |
| 3475 | static ssize_t rs_sta_dbgfs_stats_table_read(struct file *file, |
| 3476 | char __user *user_buf, size_t count, loff_t *ppos) |
| 3477 | { |
| 3478 | char *buff; |
| 3479 | int desc = 0; |
| 3480 | int i, j; |
| 3481 | ssize_t ret; |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 3482 | struct iwl_scale_tbl_info *tbl; |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 3483 | struct rs_rate *rate; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 3484 | struct iwl_lq_sta *lq_sta = file->private_data; |
| 3485 | |
| 3486 | buff = kmalloc(1024, GFP_KERNEL); |
| 3487 | if (!buff) |
| 3488 | return -ENOMEM; |
| 3489 | |
| 3490 | for (i = 0; i < LQ_SIZE; i++) { |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 3491 | tbl = &(lq_sta->lq_info[i]); |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 3492 | rate = &tbl->rate; |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 3493 | desc += sprintf(buff+desc, |
Eyal Shapira | 6a524f4 | 2013-08-11 20:27:18 +0300 | [diff] [blame] | 3494 | "%s type=%d SGI=%d BW=%s DUP=0\n" |
Eyal Shapira | 8fc7c58 | 2013-12-04 02:15:46 +0200 | [diff] [blame] | 3495 | "index=%d\n", |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 3496 | lq_sta->active_tbl == i ? "*" : "x", |
Eyal Shapira | 5aa3355 | 2013-11-23 01:06:36 +0200 | [diff] [blame] | 3497 | rate->type, |
| 3498 | rate->sgi, |
| 3499 | is_ht20(rate) ? "20Mhz" : |
| 3500 | is_ht40(rate) ? "40Mhz" : |
| 3501 | is_ht80(rate) ? "80Mhz" : "ERR", |
Eyal Shapira | 8fc7c58 | 2013-12-04 02:15:46 +0200 | [diff] [blame] | 3502 | rate->index); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 3503 | for (j = 0; j < IWL_RATE_COUNT; j++) { |
| 3504 | desc += sprintf(buff+desc, |
| 3505 | "counter=%d success=%d %%=%d\n", |
Eyal Shapira | d310e40 | 2013-08-11 18:43:47 +0300 | [diff] [blame] | 3506 | tbl->win[j].counter, |
| 3507 | tbl->win[j].success_counter, |
| 3508 | tbl->win[j].success_ratio); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 3509 | } |
| 3510 | } |
| 3511 | ret = simple_read_from_buffer(user_buf, count, ppos, buff, desc); |
| 3512 | kfree(buff); |
| 3513 | return ret; |
| 3514 | } |
| 3515 | |
| 3516 | static const struct file_operations rs_sta_dbgfs_stats_table_ops = { |
| 3517 | .read = rs_sta_dbgfs_stats_table_read, |
| 3518 | .open = simple_open, |
| 3519 | .llseek = default_llseek, |
| 3520 | }; |
| 3521 | |
Eyal Shapira | 757cf23b | 2014-03-24 02:12:00 +0200 | [diff] [blame] | 3522 | static ssize_t rs_sta_dbgfs_drv_tx_stats_read(struct file *file, |
| 3523 | char __user *user_buf, |
| 3524 | size_t count, loff_t *ppos) |
| 3525 | { |
| 3526 | static const char * const column_name[] = { |
| 3527 | [RS_COLUMN_LEGACY_ANT_A] = "LEGACY_ANT_A", |
| 3528 | [RS_COLUMN_LEGACY_ANT_B] = "LEGACY_ANT_B", |
| 3529 | [RS_COLUMN_SISO_ANT_A] = "SISO_ANT_A", |
| 3530 | [RS_COLUMN_SISO_ANT_B] = "SISO_ANT_B", |
| 3531 | [RS_COLUMN_SISO_ANT_A_SGI] = "SISO_ANT_A_SGI", |
| 3532 | [RS_COLUMN_SISO_ANT_B_SGI] = "SISO_ANT_B_SGI", |
| 3533 | [RS_COLUMN_MIMO2] = "MIMO2", |
| 3534 | [RS_COLUMN_MIMO2_SGI] = "MIMO2_SGI", |
| 3535 | }; |
| 3536 | |
| 3537 | static const char * const rate_name[] = { |
| 3538 | [IWL_RATE_1M_INDEX] = "1M", |
| 3539 | [IWL_RATE_2M_INDEX] = "2M", |
| 3540 | [IWL_RATE_5M_INDEX] = "5.5M", |
| 3541 | [IWL_RATE_11M_INDEX] = "11M", |
| 3542 | [IWL_RATE_6M_INDEX] = "6M|MCS0", |
| 3543 | [IWL_RATE_9M_INDEX] = "9M", |
| 3544 | [IWL_RATE_12M_INDEX] = "12M|MCS1", |
| 3545 | [IWL_RATE_18M_INDEX] = "18M|MCS2", |
| 3546 | [IWL_RATE_24M_INDEX] = "24M|MCS3", |
| 3547 | [IWL_RATE_36M_INDEX] = "36M|MCS4", |
| 3548 | [IWL_RATE_48M_INDEX] = "48M|MCS5", |
| 3549 | [IWL_RATE_54M_INDEX] = "54M|MCS6", |
| 3550 | [IWL_RATE_MCS_7_INDEX] = "MCS7", |
| 3551 | [IWL_RATE_MCS_8_INDEX] = "MCS8", |
| 3552 | [IWL_RATE_MCS_9_INDEX] = "MCS9", |
| 3553 | }; |
| 3554 | |
| 3555 | char *buff, *pos, *endpos; |
| 3556 | int col, rate; |
| 3557 | ssize_t ret; |
| 3558 | struct iwl_lq_sta *lq_sta = file->private_data; |
| 3559 | struct rs_rate_stats *stats; |
| 3560 | static const size_t bufsz = 1024; |
| 3561 | |
| 3562 | buff = kmalloc(bufsz, GFP_KERNEL); |
| 3563 | if (!buff) |
| 3564 | return -ENOMEM; |
| 3565 | |
| 3566 | pos = buff; |
| 3567 | endpos = pos + bufsz; |
| 3568 | |
| 3569 | pos += scnprintf(pos, endpos - pos, "COLUMN,"); |
| 3570 | for (rate = 0; rate < IWL_RATE_COUNT; rate++) |
| 3571 | pos += scnprintf(pos, endpos - pos, "%s,", rate_name[rate]); |
| 3572 | pos += scnprintf(pos, endpos - pos, "\n"); |
| 3573 | |
| 3574 | for (col = 0; col < RS_COLUMN_COUNT; col++) { |
| 3575 | pos += scnprintf(pos, endpos - pos, |
| 3576 | "%s,", column_name[col]); |
| 3577 | |
| 3578 | for (rate = 0; rate < IWL_RATE_COUNT; rate++) { |
Eyal Shapira | f58220f | 2014-08-16 01:30:30 +0300 | [diff] [blame] | 3579 | stats = &(lq_sta->pers.tx_stats[col][rate]); |
Eyal Shapira | 757cf23b | 2014-03-24 02:12:00 +0200 | [diff] [blame] | 3580 | pos += scnprintf(pos, endpos - pos, |
| 3581 | "%llu/%llu,", |
| 3582 | stats->success, |
| 3583 | stats->total); |
| 3584 | } |
| 3585 | pos += scnprintf(pos, endpos - pos, "\n"); |
| 3586 | } |
| 3587 | |
| 3588 | ret = simple_read_from_buffer(user_buf, count, ppos, buff, pos - buff); |
| 3589 | kfree(buff); |
| 3590 | return ret; |
| 3591 | } |
| 3592 | |
| 3593 | static ssize_t rs_sta_dbgfs_drv_tx_stats_write(struct file *file, |
| 3594 | const char __user *user_buf, |
| 3595 | size_t count, loff_t *ppos) |
| 3596 | { |
| 3597 | struct iwl_lq_sta *lq_sta = file->private_data; |
Eyal Shapira | f58220f | 2014-08-16 01:30:30 +0300 | [diff] [blame] | 3598 | memset(lq_sta->pers.tx_stats, 0, sizeof(lq_sta->pers.tx_stats)); |
Eyal Shapira | 757cf23b | 2014-03-24 02:12:00 +0200 | [diff] [blame] | 3599 | |
| 3600 | return count; |
| 3601 | } |
| 3602 | |
| 3603 | static const struct file_operations rs_sta_dbgfs_drv_tx_stats_ops = { |
| 3604 | .read = rs_sta_dbgfs_drv_tx_stats_read, |
| 3605 | .write = rs_sta_dbgfs_drv_tx_stats_write, |
| 3606 | .open = simple_open, |
| 3607 | .llseek = default_llseek, |
| 3608 | }; |
| 3609 | |
Eyal Shapira | 1e9c62f | 2015-01-28 14:44:06 +0200 | [diff] [blame] | 3610 | static ssize_t iwl_dbgfs_ss_force_read(struct file *file, |
| 3611 | char __user *user_buf, |
| 3612 | size_t count, loff_t *ppos) |
| 3613 | { |
| 3614 | struct iwl_lq_sta *lq_sta = file->private_data; |
| 3615 | char buf[12]; |
| 3616 | int bufsz = sizeof(buf); |
| 3617 | int pos = 0; |
| 3618 | static const char * const ss_force_name[] = { |
| 3619 | [RS_SS_FORCE_NONE] = "none", |
| 3620 | [RS_SS_FORCE_STBC] = "stbc", |
| 3621 | [RS_SS_FORCE_BFER] = "bfer", |
| 3622 | [RS_SS_FORCE_SISO] = "siso", |
| 3623 | }; |
| 3624 | |
| 3625 | pos += scnprintf(buf+pos, bufsz-pos, "%s\n", |
Eyal Shapira | 878985ce | 2015-02-02 12:14:54 +0200 | [diff] [blame] | 3626 | ss_force_name[lq_sta->pers.ss_force]); |
Eyal Shapira | 1e9c62f | 2015-01-28 14:44:06 +0200 | [diff] [blame] | 3627 | return simple_read_from_buffer(user_buf, count, ppos, buf, pos); |
| 3628 | } |
| 3629 | |
| 3630 | static ssize_t iwl_dbgfs_ss_force_write(struct iwl_lq_sta *lq_sta, char *buf, |
| 3631 | size_t count, loff_t *ppos) |
| 3632 | { |
| 3633 | struct iwl_mvm *mvm = lq_sta->pers.drv; |
| 3634 | int ret = 0; |
| 3635 | |
| 3636 | if (!strncmp("none", buf, 4)) { |
Eyal Shapira | 878985ce | 2015-02-02 12:14:54 +0200 | [diff] [blame] | 3637 | lq_sta->pers.ss_force = RS_SS_FORCE_NONE; |
Eyal Shapira | 1e9c62f | 2015-01-28 14:44:06 +0200 | [diff] [blame] | 3638 | } else if (!strncmp("siso", buf, 4)) { |
Eyal Shapira | 878985ce | 2015-02-02 12:14:54 +0200 | [diff] [blame] | 3639 | lq_sta->pers.ss_force = RS_SS_FORCE_SISO; |
Eyal Shapira | 1e9c62f | 2015-01-28 14:44:06 +0200 | [diff] [blame] | 3640 | } else if (!strncmp("stbc", buf, 4)) { |
| 3641 | if (lq_sta->stbc_capable) { |
Eyal Shapira | 878985ce | 2015-02-02 12:14:54 +0200 | [diff] [blame] | 3642 | lq_sta->pers.ss_force = RS_SS_FORCE_STBC; |
Eyal Shapira | 1e9c62f | 2015-01-28 14:44:06 +0200 | [diff] [blame] | 3643 | } else { |
| 3644 | IWL_ERR(mvm, |
| 3645 | "can't force STBC. peer doesn't support\n"); |
| 3646 | ret = -EINVAL; |
| 3647 | } |
| 3648 | } else if (!strncmp("bfer", buf, 4)) { |
| 3649 | if (lq_sta->bfer_capable) { |
Eyal Shapira | 878985ce | 2015-02-02 12:14:54 +0200 | [diff] [blame] | 3650 | lq_sta->pers.ss_force = RS_SS_FORCE_BFER; |
Eyal Shapira | 1e9c62f | 2015-01-28 14:44:06 +0200 | [diff] [blame] | 3651 | } else { |
| 3652 | IWL_ERR(mvm, |
| 3653 | "can't force BFER. peer doesn't support\n"); |
| 3654 | ret = -EINVAL; |
| 3655 | } |
| 3656 | } else { |
| 3657 | IWL_ERR(mvm, "valid values none|siso|stbc|bfer\n"); |
| 3658 | ret = -EINVAL; |
| 3659 | } |
| 3660 | return ret ?: count; |
| 3661 | } |
| 3662 | |
| 3663 | #define MVM_DEBUGFS_READ_WRITE_FILE_OPS(name, bufsz) \ |
| 3664 | _MVM_DEBUGFS_READ_WRITE_FILE_OPS(name, bufsz, struct iwl_lq_sta) |
| 3665 | #define MVM_DEBUGFS_ADD_FILE_RS(name, parent, mode) do { \ |
| 3666 | if (!debugfs_create_file(#name, mode, parent, lq_sta, \ |
| 3667 | &iwl_dbgfs_##name##_ops)) \ |
| 3668 | goto err; \ |
| 3669 | } while (0) |
| 3670 | |
| 3671 | MVM_DEBUGFS_READ_WRITE_FILE_OPS(ss_force, 32); |
| 3672 | |
Johannes Berg | dcbc17a | 2015-03-10 21:24:34 +0100 | [diff] [blame] | 3673 | static void rs_add_debugfs(void *mvm, void *priv_sta, struct dentry *dir) |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 3674 | { |
Johannes Berg | dcbc17a | 2015-03-10 21:24:34 +0100 | [diff] [blame] | 3675 | struct iwl_lq_sta *lq_sta = priv_sta; |
| 3676 | struct iwl_mvm_sta *mvmsta; |
| 3677 | |
| 3678 | mvmsta = container_of(lq_sta, struct iwl_mvm_sta, lq_sta); |
| 3679 | |
| 3680 | if (!mvmsta->vif) |
| 3681 | return; |
Eyal Shapira | 1e9c62f | 2015-01-28 14:44:06 +0200 | [diff] [blame] | 3682 | |
Eliad Peller | c6e1faa | 2014-06-15 12:02:20 +0300 | [diff] [blame] | 3683 | debugfs_create_file("rate_scale_table", S_IRUSR | S_IWUSR, dir, |
| 3684 | lq_sta, &rs_sta_dbgfs_scale_table_ops); |
| 3685 | debugfs_create_file("rate_stats_table", S_IRUSR, dir, |
| 3686 | lq_sta, &rs_sta_dbgfs_stats_table_ops); |
| 3687 | debugfs_create_file("drv_tx_stats", S_IRUSR | S_IWUSR, dir, |
| 3688 | lq_sta, &rs_sta_dbgfs_drv_tx_stats_ops); |
| 3689 | debugfs_create_u8("tx_agg_tid_enable", S_IRUSR | S_IWUSR, dir, |
| 3690 | &lq_sta->tx_agg_tid_en); |
| 3691 | debugfs_create_u8("reduced_tpc", S_IRUSR | S_IWUSR, dir, |
| 3692 | &lq_sta->pers.dbg_fixed_txp_reduction); |
Eyal Shapira | 1e9c62f | 2015-01-28 14:44:06 +0200 | [diff] [blame] | 3693 | |
| 3694 | MVM_DEBUGFS_ADD_FILE_RS(ss_force, dir, S_IRUSR | S_IWUSR); |
| 3695 | return; |
| 3696 | err: |
| 3697 | IWL_ERR((struct iwl_mvm *)mvm, "Can't create debugfs entity\n"); |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 3698 | } |
| 3699 | |
| 3700 | static void rs_remove_debugfs(void *mvm, void *mvm_sta) |
| 3701 | { |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 3702 | } |
| 3703 | #endif |
| 3704 | |
| 3705 | /* |
| 3706 | * Initialization of rate scaling information is done by driver after |
| 3707 | * the station is added. Since mac80211 calls this function before a |
| 3708 | * station is added we ignore it. |
| 3709 | */ |
| 3710 | static void rs_rate_init_stub(void *mvm_r, |
Simon Wunderlich | 3de805c | 2013-07-08 16:55:50 +0200 | [diff] [blame] | 3711 | struct ieee80211_supported_band *sband, |
| 3712 | struct cfg80211_chan_def *chandef, |
| 3713 | struct ieee80211_sta *sta, void *mvm_sta) |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 3714 | { |
| 3715 | } |
Johannes Berg | 631ad70 | 2014-01-20 23:29:34 +0100 | [diff] [blame] | 3716 | |
| 3717 | static const struct rate_control_ops rs_mvm_ops = { |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 3718 | .name = RS_NAME, |
Eyal Shapira | 1ebc8f2 | 2014-09-14 15:23:23 +0300 | [diff] [blame] | 3719 | .tx_status = rs_mac80211_tx_status, |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 3720 | .get_rate = rs_get_rate, |
| 3721 | .rate_init = rs_rate_init_stub, |
| 3722 | .alloc = rs_alloc, |
| 3723 | .free = rs_free, |
| 3724 | .alloc_sta = rs_alloc_sta, |
| 3725 | .free_sta = rs_free_sta, |
Eyal Shapira | b87c217 | 2013-11-09 23:37:55 +0200 | [diff] [blame] | 3726 | .rate_update = rs_rate_update, |
Johannes Berg | 8ca151b | 2013-01-24 14:25:36 +0100 | [diff] [blame] | 3727 | #ifdef CONFIG_MAC80211_DEBUGFS |
| 3728 | .add_sta_debugfs = rs_add_debugfs, |
| 3729 | .remove_sta_debugfs = rs_remove_debugfs, |
| 3730 | #endif |
| 3731 | }; |
| 3732 | |
| 3733 | int iwl_mvm_rate_control_register(void) |
| 3734 | { |
| 3735 | return ieee80211_rate_control_register(&rs_mvm_ops); |
| 3736 | } |
| 3737 | |
| 3738 | void iwl_mvm_rate_control_unregister(void) |
| 3739 | { |
| 3740 | ieee80211_rate_control_unregister(&rs_mvm_ops); |
| 3741 | } |
Eytan Lifshitz | 9ee718a | 2013-05-19 19:14:41 +0300 | [diff] [blame] | 3742 | |
| 3743 | /** |
| 3744 | * iwl_mvm_tx_protection - Gets LQ command, change it to enable/disable |
Sara Sharon | 0d365ae | 2015-03-31 12:24:05 +0300 | [diff] [blame] | 3745 | * Tx protection, according to this request and previous requests, |
Eytan Lifshitz | 9ee718a | 2013-05-19 19:14:41 +0300 | [diff] [blame] | 3746 | * and send the LQ command. |
Eytan Lifshitz | 9ee718a | 2013-05-19 19:14:41 +0300 | [diff] [blame] | 3747 | * @mvmsta: The station |
| 3748 | * @enable: Enable Tx protection? |
| 3749 | */ |
Johannes Berg | e126b5d | 2013-06-28 13:39:18 +0200 | [diff] [blame] | 3750 | int iwl_mvm_tx_protection(struct iwl_mvm *mvm, struct iwl_mvm_sta *mvmsta, |
| 3751 | bool enable) |
Eytan Lifshitz | 9ee718a | 2013-05-19 19:14:41 +0300 | [diff] [blame] | 3752 | { |
Johannes Berg | e126b5d | 2013-06-28 13:39:18 +0200 | [diff] [blame] | 3753 | struct iwl_lq_cmd *lq = &mvmsta->lq_sta.lq; |
| 3754 | |
Eytan Lifshitz | 9ee718a | 2013-05-19 19:14:41 +0300 | [diff] [blame] | 3755 | lockdep_assert_held(&mvm->mutex); |
| 3756 | |
| 3757 | if (enable) { |
| 3758 | if (mvmsta->tx_protection == 0) |
Eyal Shapira | d307ec8 | 2013-11-11 19:56:21 +0200 | [diff] [blame] | 3759 | lq->flags |= LQ_FLAG_USE_RTS_MSK; |
Eytan Lifshitz | 9ee718a | 2013-05-19 19:14:41 +0300 | [diff] [blame] | 3760 | mvmsta->tx_protection++; |
| 3761 | } else { |
| 3762 | mvmsta->tx_protection--; |
| 3763 | if (mvmsta->tx_protection == 0) |
Eyal Shapira | d307ec8 | 2013-11-11 19:56:21 +0200 | [diff] [blame] | 3764 | lq->flags &= ~LQ_FLAG_USE_RTS_MSK; |
Eytan Lifshitz | 9ee718a | 2013-05-19 19:14:41 +0300 | [diff] [blame] | 3765 | } |
| 3766 | |
Eyal Shapira | 9e68094 | 2013-11-09 00:16:16 +0200 | [diff] [blame] | 3767 | return iwl_mvm_send_lq_cmd(mvm, lq, false); |
Eytan Lifshitz | 9ee718a | 2013-05-19 19:14:41 +0300 | [diff] [blame] | 3768 | } |