drivers/net/wireless/intel/iwlwifi/mvm/phy-ctxt.c

   1 // SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
   2 /*
   3  * Copyright (C) 2012-2014, 2018-2023 Intel Corporation
   4  * Copyright (C) 2013-2014 Intel Mobile Communications GmbH
   5  * Copyright (C) 2017 Intel Deutschland GmbH
   6  */
   7 #include <net/mac80211.h>
   8 #include "fw-api.h"
   9 #include "mvm.h"
  10
  11 /* Maps the driver specific channel width definition to the fw values */
  12 u8 iwl_mvm_get_channel_width(struct cfg80211_chan_def *chandef)
  13 {
  14         switch (chandef->width) {
  15         case NL80211_CHAN_WIDTH_20_NOHT:
  16         case NL80211_CHAN_WIDTH_20:
  17                 return IWL_PHY_CHANNEL_MODE20;
  18         case NL80211_CHAN_WIDTH_40:
  19                 return IWL_PHY_CHANNEL_MODE40;
  20         case NL80211_CHAN_WIDTH_80:
  21                 return IWL_PHY_CHANNEL_MODE80;
  22         case NL80211_CHAN_WIDTH_160:
  23                 return IWL_PHY_CHANNEL_MODE160;
  24         case NL80211_CHAN_WIDTH_320:
  25                 return IWL_PHY_CHANNEL_MODE320;
  26         default:
  27                 WARN(1, "Invalid channel width=%u", chandef->width);
  28                 return IWL_PHY_CHANNEL_MODE20;
  29         }
  30 }
  31
  32 /*
  33  * Maps the driver specific control channel position (relative to the center
  34  * freq) definitions to the the fw values
  35  */
  36 u8 iwl_mvm_get_ctrl_pos(struct cfg80211_chan_def *chandef)
  37 {
  38         int offs = chandef->chan->center_freq - chandef->center_freq1;
  39         int abs_offs = abs(offs);
  40         u8 ret;
  41
  42         if (offs == 0) {
  43                 /*
  44                  * The FW is expected to check the control channel position only
  45                  * when in HT/VHT and the channel width is not 20MHz. Return
  46                  * this value as the default one.
  47                  */
  48                 return 0;
  49         }
  50
  51         /* this results in a value 0-7, i.e. fitting into 0b0111 */
  52         ret = (abs_offs - 10) / 20;
  53         /*
  54          * But we need the value to be in 0b1011 because 0b0100 is
  55          * IWL_PHY_CTRL_POS_ABOVE, so shift bit 2 up to land in
  56          * IWL_PHY_CTRL_POS_OFFS_EXT (0b1000)
  57          */
  58         ret = (ret & IWL_PHY_CTRL_POS_OFFS_MSK) |
  59               ((ret & BIT(2)) << 1);
  60         /* and add the above bit */
  61         ret |= (offs > 0) * IWL_PHY_CTRL_POS_ABOVE;
  62
  63         return ret;
  64 }
  65
  66 /*
  67  * Construct the generic fields of the PHY context command
  68  */
  69 static void iwl_mvm_phy_ctxt_cmd_hdr(struct iwl_mvm_phy_ctxt *ctxt,
  70                                      struct iwl_phy_context_cmd *cmd,
  71                                      u32 action)
  72 {
  73         cmd->id_and_color = cpu_to_le32(FW_CMD_ID_AND_COLOR(ctxt->id,
  74                                                             ctxt->color));
  75         cmd->action = cpu_to_le32(action);
  76 }
  77
  78 static void iwl_mvm_phy_ctxt_set_rxchain(struct iwl_mvm *mvm,
  79                                          struct iwl_mvm_phy_ctxt *ctxt,
  80                                          __le32 *rxchain_info,
  81                                          u8 chains_static,
  82                                          u8 chains_dynamic)
  83 {
  84         u8 active_cnt, idle_cnt;
  85
  86         /* Set rx the chains */
  87         idle_cnt = chains_static;
  88         active_cnt = chains_dynamic;
  89
  90         /* In scenarios where we only ever use a single-stream rates,
  91          * i.e. legacy 11b/g/a associations, single-stream APs or even
  92          * static SMPS, enable both chains to get diversity, improving
  93          * the case where we're far enough from the AP that attenuation
  94          * between the two antennas is sufficiently different to impact
  95          * performance.
  96          */
  97         if (active_cnt == 1 && iwl_mvm_rx_diversity_allowed(mvm, ctxt)) {
  98                 idle_cnt = 2;
  99                 active_cnt = 2;
 100         }
 101
 102         /*
 103          * If the firmware requested it, then we know that it supports
 104          * getting zero for the values to indicate "use one, but pick
 105          * which one yourself", which means it can dynamically pick one
 106          * that e.g. has better RSSI.
 107          */
 108         if (mvm->fw_static_smps_request && active_cnt == 1 && idle_cnt == 1) {
 109                 idle_cnt = 0;
 110                 active_cnt = 0;
 111         }
 112
 113         *rxchain_info = cpu_to_le32(iwl_mvm_get_valid_rx_ant(mvm) <<
 114                                         PHY_RX_CHAIN_VALID_POS);
 115         *rxchain_info |= cpu_to_le32(idle_cnt << PHY_RX_CHAIN_CNT_POS);
 116         *rxchain_info |= cpu_to_le32(active_cnt <<
 117                                          PHY_RX_CHAIN_MIMO_CNT_POS);
 118 #ifdef CONFIG_IWLWIFI_DEBUGFS
 119         if (unlikely(mvm->dbgfs_rx_phyinfo))
 120                 *rxchain_info = cpu_to_le32(mvm->dbgfs_rx_phyinfo);
 121 #endif
 122 }
 123
 124 /*
 125  * Add the phy configuration to the PHY context command
 126  */
 127 static void iwl_mvm_phy_ctxt_cmd_data_v1(struct iwl_mvm *mvm,
 128                                          struct iwl_mvm_phy_ctxt *ctxt,
 129                                          struct iwl_phy_context_cmd_v1 *cmd,
 130                                          struct cfg80211_chan_def *chandef,
 131                                          u8 chains_static, u8 chains_dynamic)
 132 {
 133         struct iwl_phy_context_cmd_tail *tail =
 134                 iwl_mvm_chan_info_cmd_tail(mvm, &cmd->ci);
 135
 136         /* Set the channel info data */
 137         iwl_mvm_set_chan_info_chandef(mvm, &cmd->ci, chandef);
 138
 139         iwl_mvm_phy_ctxt_set_rxchain(mvm, ctxt, &tail->rxchain_info,
 140                                      chains_static, chains_dynamic);
 141
 142         tail->txchain_info = cpu_to_le32(iwl_mvm_get_valid_tx_ant(mvm));
 143 }
 144
 145 /*
 146  * Add the phy configuration to the PHY context command
 147  */
 148 static void iwl_mvm_phy_ctxt_cmd_data(struct iwl_mvm *mvm,
 149                                       struct iwl_mvm_phy_ctxt *ctxt,
 150                                       struct iwl_phy_context_cmd *cmd,
 151                                       struct cfg80211_chan_def *chandef,
 152                                       u8 chains_static, u8 chains_dynamic)
 153 {
 154         cmd->lmac_id = cpu_to_le32(iwl_mvm_get_lmac_id(mvm,
 155                                                        chandef->chan->band));
 156
 157         /* Set the channel info data */
 158         iwl_mvm_set_chan_info_chandef(mvm, &cmd->ci, chandef);
 159
 160         /* we only support RLC command version 2 */
 161         if (iwl_fw_lookup_cmd_ver(mvm->fw, WIDE_ID(DATA_PATH_GROUP, RLC_CONFIG_CMD), 0) < 2)
 162                 iwl_mvm_phy_ctxt_set_rxchain(mvm, ctxt, &cmd->rxchain_info,
 163                                              chains_static, chains_dynamic);
 164 }
 165
 166 int iwl_mvm_phy_send_rlc(struct iwl_mvm *mvm, struct iwl_mvm_phy_ctxt *ctxt,
 167                          u8 chains_static, u8 chains_dynamic)
 168 {
 169         struct iwl_rlc_config_cmd cmd = {
 170                 .phy_id = cpu_to_le32(ctxt->id),
 171         };
 172
 173         if (ctxt->rlc_disabled)
 174                 return 0;
 175
 176         if (iwl_fw_lookup_cmd_ver(mvm->fw, WIDE_ID(DATA_PATH_GROUP,
 177                                                    RLC_CONFIG_CMD), 0) < 2)
 178                 return 0;
 179
 180         BUILD_BUG_ON(IWL_RLC_CHAIN_INFO_DRIVER_FORCE !=
 181                      PHY_RX_CHAIN_DRIVER_FORCE_MSK);
 182         BUILD_BUG_ON(IWL_RLC_CHAIN_INFO_VALID !=
 183                      PHY_RX_CHAIN_VALID_MSK);
 184         BUILD_BUG_ON(IWL_RLC_CHAIN_INFO_FORCE !=
 185                      PHY_RX_CHAIN_FORCE_SEL_MSK);
 186         BUILD_BUG_ON(IWL_RLC_CHAIN_INFO_FORCE_MIMO !=
 187                      PHY_RX_CHAIN_FORCE_MIMO_SEL_MSK);
 188         BUILD_BUG_ON(IWL_RLC_CHAIN_INFO_COUNT != PHY_RX_CHAIN_CNT_MSK);
 189         BUILD_BUG_ON(IWL_RLC_CHAIN_INFO_MIMO_COUNT !=
 190                      PHY_RX_CHAIN_MIMO_CNT_MSK);
 191
 192         iwl_mvm_phy_ctxt_set_rxchain(mvm, ctxt, &cmd.rlc.rx_chain_info,
 193                                      chains_static, chains_dynamic);
 194
 195         return iwl_mvm_send_cmd_pdu(mvm, iwl_cmd_id(RLC_CONFIG_CMD,
 196                                                     DATA_PATH_GROUP, 2),
 197                                     0, sizeof(cmd), &cmd);
 198 }
 199
 200 /*
 201  * Send a command to apply the current phy configuration. The command is send
 202  * only if something in the configuration changed: in case that this is the
 203  * first time that the phy configuration is applied or in case that the phy
 204  * configuration changed from the previous apply.
 205  */
 206 static int iwl_mvm_phy_ctxt_apply(struct iwl_mvm *mvm,
 207                                   struct iwl_mvm_phy_ctxt *ctxt,
 208                                   struct cfg80211_chan_def *chandef,
 209                                   u8 chains_static, u8 chains_dynamic,
 210                                   u32 action)
 211 {
 212         int ret;
 213         int ver = iwl_fw_lookup_cmd_ver(mvm->fw, PHY_CONTEXT_CMD, 1);
 214
 215         if (ver == 3 || ver == 4) {
 216                 struct iwl_phy_context_cmd cmd = {};
 217
 218                 /* Set the command header fields */
 219                 iwl_mvm_phy_ctxt_cmd_hdr(ctxt, &cmd, action);
 220
 221                 /* Set the command data */
 222                 iwl_mvm_phy_ctxt_cmd_data(mvm, ctxt, &cmd, chandef,
 223                                           chains_static,
 224                                           chains_dynamic);
 225
 226                 ret = iwl_mvm_send_cmd_pdu(mvm, PHY_CONTEXT_CMD,
 227                                            0, sizeof(cmd), &cmd);
 228         } else if (ver < 3) {
 229                 struct iwl_phy_context_cmd_v1 cmd = {};
 230                 u16 len = sizeof(cmd) - iwl_mvm_chan_info_padding(mvm);
 231
 232                 /* Set the command header fields */
 233                 iwl_mvm_phy_ctxt_cmd_hdr(ctxt,
 234                                          (struct iwl_phy_context_cmd *)&cmd,
 235                                          action);
 236
 237                 /* Set the command data */
 238                 iwl_mvm_phy_ctxt_cmd_data_v1(mvm, ctxt, &cmd, chandef,
 239                                              chains_static,
 240                                              chains_dynamic);
 241                 ret = iwl_mvm_send_cmd_pdu(mvm, PHY_CONTEXT_CMD,
 242                                            0, len, &cmd);
 243         } else {
 244                 IWL_ERR(mvm, "PHY ctxt cmd error ver %d not supported\n", ver);
 245                 return -EOPNOTSUPP;
 246         }
 247
 248
 249         if (ret) {
 250                 IWL_ERR(mvm, "PHY ctxt cmd error. ret=%d\n", ret);
 251                 return ret;
 252         }
 253
 254         if (action != FW_CTXT_ACTION_REMOVE)
 255                 return iwl_mvm_phy_send_rlc(mvm, ctxt, chains_static,
 256                                             chains_dynamic);
 257
 258         return 0;
 259 }
 260
 261 /*
 262  * Send a command to add a PHY context based on the current HW configuration.
 263  */
 264 int iwl_mvm_phy_ctxt_add(struct iwl_mvm *mvm, struct iwl_mvm_phy_ctxt *ctxt,
 265                          struct cfg80211_chan_def *chandef,
 266                          u8 chains_static, u8 chains_dynamic)
 267 {
 268         WARN_ON(!test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status) &&
 269                 ctxt->ref);
 270         lockdep_assert_held(&mvm->mutex);
 271
 272         ctxt->channel = chandef->chan;
 273         ctxt->width = chandef->width;
 274         ctxt->center_freq1 = chandef->center_freq1;
 275
 276         return iwl_mvm_phy_ctxt_apply(mvm, ctxt, chandef,
 277                                       chains_static, chains_dynamic,
 278                                       FW_CTXT_ACTION_ADD);
 279 }
 280
 281 /*
 282  * Update the number of references to the given PHY context. This is valid only
 283  * in case the PHY context was already created, i.e., its reference count > 0.
 284  */
 285 void iwl_mvm_phy_ctxt_ref(struct iwl_mvm *mvm, struct iwl_mvm_phy_ctxt *ctxt)
 286 {
 287         lockdep_assert_held(&mvm->mutex);
 288         ctxt->ref++;
 289 }
 290
 291 /*
 292  * Send a command to modify the PHY context based on the current HW
 293  * configuration. Note that the function does not check that the configuration
 294  * changed.
 295  */
 296 int iwl_mvm_phy_ctxt_changed(struct iwl_mvm *mvm, struct iwl_mvm_phy_ctxt *ctxt,
 297                              struct cfg80211_chan_def *chandef,
 298                              u8 chains_static, u8 chains_dynamic)
 299 {
 300         enum iwl_ctxt_action action = FW_CTXT_ACTION_MODIFY;
 301
 302         lockdep_assert_held(&mvm->mutex);
 303
 304         if (iwl_fw_lookup_cmd_ver(mvm->fw, WIDE_ID(DATA_PATH_GROUP, RLC_CONFIG_CMD), 0) >= 2 &&
 305             ctxt->channel == chandef->chan &&
 306             ctxt->width == chandef->width &&
 307             ctxt->center_freq1 == chandef->center_freq1)
 308                 return iwl_mvm_phy_send_rlc(mvm, ctxt, chains_static,
 309                                             chains_dynamic);
 310
 311         if (fw_has_capa(&mvm->fw->ucode_capa,
 312                         IWL_UCODE_TLV_CAPA_BINDING_CDB_SUPPORT) &&
 313             ctxt->channel->band != chandef->chan->band) {
 314                 int ret;
 315
 316                 /* ... remove it here ...*/
 317                 ret = iwl_mvm_phy_ctxt_apply(mvm, ctxt, chandef,
 318                                              chains_static, chains_dynamic,
 319                                              FW_CTXT_ACTION_REMOVE);
 320                 if (ret)
 321                         return ret;
 322
 323                 /* ... and proceed to add it again */
 324                 action = FW_CTXT_ACTION_ADD;
 325         }
 326
 327         ctxt->channel = chandef->chan;
 328         ctxt->width = chandef->width;
 329         ctxt->center_freq1 = chandef->center_freq1;
 330
 331         return iwl_mvm_phy_ctxt_apply(mvm, ctxt, chandef,
 332                                       chains_static, chains_dynamic,
 333                                       action);
 334 }
 335
 336 void iwl_mvm_phy_ctxt_unref(struct iwl_mvm *mvm, struct iwl_mvm_phy_ctxt *ctxt)
 337 {
 338         lockdep_assert_held(&mvm->mutex);
 339
 340         if (WARN_ON_ONCE(!ctxt))
 341                 return;
 342
 343         ctxt->ref--;
 344
 345         /*
 346          * Move unused phy's to a default channel. When the phy is moved the,
 347          * fw will cleanup immediate quiet bit if it was previously set,
 348          * otherwise we might not be able to reuse this phy.
 349          */
 350         if (ctxt->ref == 0) {
 351                 struct ieee80211_channel *chan = NULL;
 352                 struct cfg80211_chan_def chandef;
 353                 struct ieee80211_supported_band *sband;
 354                 enum nl80211_band band;
 355                 int channel;
 356
 357                 for (band = NL80211_BAND_2GHZ; band < NUM_NL80211_BANDS; band++) {
 358                         sband = mvm->hw->wiphy->bands[band];
 359
 360                         if (!sband)
 361                                 continue;
 362
 363                         for (channel = 0; channel < sband->n_channels; channel++)
 364                                 if (!(sband->channels[channel].flags &
 365                                                 IEEE80211_CHAN_DISABLED)) {
 366                                         chan = &sband->channels[channel];
 367                                         break;
 368                                 }
 369
 370                         if (chan)
 371                                 break;
 372                 }
 373
 374                 if (WARN_ON(!chan))
 375                         return;
 376
 377                 cfg80211_chandef_create(&chandef, chan, NL80211_CHAN_NO_HT);
 378                 iwl_mvm_phy_ctxt_changed(mvm, ctxt, &chandef, 1, 1);
 379         }
 380 }
 381
 382 static void iwl_mvm_binding_iterator(void *_data, u8 *mac,
 383                                      struct ieee80211_vif *vif)
 384 {
 385         unsigned long *data = _data;
 386         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 387
 388         if (!mvmvif->deflink.phy_ctxt)
 389                 return;
 390
 391         if (vif->type == NL80211_IFTYPE_STATION ||
 392             vif->type == NL80211_IFTYPE_AP)
 393                 __set_bit(mvmvif->deflink.phy_ctxt->id, data);
 394 }
 395
 396 int iwl_mvm_phy_ctx_count(struct iwl_mvm *mvm)
 397 {
 398         unsigned long phy_ctxt_counter = 0;
 399
 400         ieee80211_iterate_active_interfaces_atomic(mvm->hw,
 401                                                    IEEE80211_IFACE_ITER_NORMAL,
 402                                                    iwl_mvm_binding_iterator,
 403                                                    &phy_ctxt_counter);
 404
 405         return hweight8(phy_ctxt_counter);
 406 }