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