1 files changed, 134 insertions, 64 deletions

diff --git a/drivers/net/wireless/iwlwifi/mvm/power.c b/drivers/net/wireless/iwlwifi/mvm/power.c
index e7ca965a89b8..4e7c9f245846 100644
--- a/drivers/net/wireless/iwlwifi/mvm/power.c
+++ b/drivers/net/wireless/iwlwifi/mvm/power.c
@@ -75,8 +75,8 @@
 
 #define POWER_KEEP_ALIVE_PERIOD_SEC    25
 
-static int iwl_mvm_beacon_filter_send_cmd(struct iwl_mvm *mvm,
-                                          struct iwl_beacon_filter_cmd *cmd)
+int iwl_mvm_beacon_filter_send_cmd(struct iwl_mvm *mvm,
+                                   struct iwl_beacon_filter_cmd *cmd)
 {
         int ret;
 
@@ -85,52 +85,60 @@ static int iwl_mvm_beacon_filter_send_cmd(struct iwl_mvm *mvm,
 
         if (!ret) {
                 IWL_DEBUG_POWER(mvm, "ba_enable_beacon_abort is: %d\n",
-                                cmd->ba_enable_beacon_abort);
+                                le32_to_cpu(cmd->ba_enable_beacon_abort));
                 IWL_DEBUG_POWER(mvm, "ba_escape_timer is: %d\n",
-                                cmd->ba_escape_timer);
+                                le32_to_cpu(cmd->ba_escape_timer));
                 IWL_DEBUG_POWER(mvm, "bf_debug_flag is: %d\n",
-                                cmd->bf_debug_flag);
+                                le32_to_cpu(cmd->bf_debug_flag));
                 IWL_DEBUG_POWER(mvm, "bf_enable_beacon_filter is: %d\n",
-                                cmd->bf_enable_beacon_filter);
+                                le32_to_cpu(cmd->bf_enable_beacon_filter));
                 IWL_DEBUG_POWER(mvm, "bf_energy_delta is: %d\n",
-                                cmd->bf_energy_delta);
+                                le32_to_cpu(cmd->bf_energy_delta));
                 IWL_DEBUG_POWER(mvm, "bf_escape_timer is: %d\n",
-                                cmd->bf_escape_timer);
+                                le32_to_cpu(cmd->bf_escape_timer));
                 IWL_DEBUG_POWER(mvm, "bf_roaming_energy_delta is: %d\n",
-                                cmd->bf_roaming_energy_delta);
+                                le32_to_cpu(cmd->bf_roaming_energy_delta));
                 IWL_DEBUG_POWER(mvm, "bf_roaming_state is: %d\n",
-                                cmd->bf_roaming_state);
-                IWL_DEBUG_POWER(mvm, "bf_temperature_delta is: %d\n",
-                                cmd->bf_temperature_delta);
+                                le32_to_cpu(cmd->bf_roaming_state));
+                IWL_DEBUG_POWER(mvm, "bf_temp_threshold is: %d\n",
+                                le32_to_cpu(cmd->bf_temp_threshold));
+                IWL_DEBUG_POWER(mvm, "bf_temp_fast_filter is: %d\n",
+                                le32_to_cpu(cmd->bf_temp_fast_filter));
+                IWL_DEBUG_POWER(mvm, "bf_temp_slow_filter is: %d\n",
+                                le32_to_cpu(cmd->bf_temp_slow_filter));
         }
         return ret;
 }
 
-static int iwl_mvm_update_beacon_abort(struct iwl_mvm *mvm,
-                                       struct ieee80211_vif *vif, bool enable)
+int iwl_mvm_update_beacon_abort(struct iwl_mvm *mvm,
+                                struct ieee80211_vif *vif, bool enable)
 {
         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
         struct iwl_beacon_filter_cmd cmd = {
                 IWL_BF_CMD_CONFIG_DEFAULTS,
-                .bf_enable_beacon_filter = 1,
-                .ba_enable_beacon_abort = enable,
+                .bf_enable_beacon_filter = cpu_to_le32(1),
+                .ba_enable_beacon_abort = cpu_to_le32(enable),
         };
 
         if (!mvmvif->bf_enabled)
                 return 0;
 
+        if (mvm->cur_ucode == IWL_UCODE_WOWLAN)
+                cmd.ba_escape_timer = cpu_to_le32(IWL_BA_ESCAPE_TIMER_D3);
+
         iwl_mvm_beacon_filter_debugfs_parameters(vif, &cmd);
         return iwl_mvm_beacon_filter_send_cmd(mvm, &cmd);
 }
 
 static void iwl_mvm_power_log(struct iwl_mvm *mvm,
-                              struct iwl_powertable_cmd *cmd)
+                              struct iwl_mac_power_cmd *cmd)
 {
         IWL_DEBUG_POWER(mvm,
-                        "Sending power table command for power level %d, flags = 0x%X\n",
-                        iwlmvm_mod_params.power_scheme,
+                        "Sending power table command on mac id 0x%X for power level %d, flags = 0x%X\n",
+                        cmd->id_and_color, iwlmvm_mod_params.power_scheme,
                         le16_to_cpu(cmd->flags));
-        IWL_DEBUG_POWER(mvm, "Keep alive = %u sec\n", cmd->keep_alive_seconds);
+        IWL_DEBUG_POWER(mvm, "Keep alive = %u sec\n",
+                        le16_to_cpu(cmd->keep_alive_seconds));
 
         if (cmd->flags & cpu_to_le16(POWER_FLAGS_POWER_MANAGEMENT_ENA_MSK)) {
                 IWL_DEBUG_POWER(mvm, "Rx timeout = %u usec\n",
@@ -139,15 +147,16 @@ static void iwl_mvm_power_log(struct iwl_mvm *mvm,
                                 le32_to_cpu(cmd->tx_data_timeout));
                 if (cmd->flags & cpu_to_le16(POWER_FLAGS_SKIP_OVER_DTIM_MSK))
                         IWL_DEBUG_POWER(mvm, "DTIM periods to skip = %u\n",
-                                        le32_to_cpu(cmd->skip_dtim_periods));
+                                        cmd->skip_dtim_periods);
                 if (cmd->flags & cpu_to_le16(POWER_FLAGS_LPRX_ENA_MSK))
                         IWL_DEBUG_POWER(mvm, "LP RX RSSI threshold = %u\n",
-                                        le32_to_cpu(cmd->lprx_rssi_threshold));
+                                        cmd->lprx_rssi_threshold);
         }
 }
 
-void iwl_mvm_power_build_cmd(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
-                             struct iwl_powertable_cmd *cmd)
+static void iwl_mvm_power_build_cmd(struct iwl_mvm *mvm,
+                                    struct ieee80211_vif *vif,
+                                    struct iwl_mac_power_cmd *cmd)
 {
         struct ieee80211_hw *hw = mvm->hw;
         struct ieee80211_chanctx_conf *chanctx_conf;
@@ -158,19 +167,26 @@ void iwl_mvm_power_build_cmd(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
         struct iwl_mvm_vif *mvmvif __maybe_unused =
                 iwl_mvm_vif_from_mac80211(vif);
 
+        cmd->id_and_color = cpu_to_le32(FW_CMD_ID_AND_COLOR(mvmvif->id,
+                                                            mvmvif->color));
+        dtimper = hw->conf.ps_dtim_period ?: 1;
+
         /*
          * Regardless of power management state the driver must set
          * keep alive period. FW will use it for sending keep alive NDPs
-         * immediately after association.
+         * immediately after association. Check that keep alive period
+         * is at least 3 * DTIM
          */
-        cmd->keep_alive_seconds = POWER_KEEP_ALIVE_PERIOD_SEC;
+        dtimper_msec = dtimper * vif->bss_conf.beacon_int;
+        keep_alive = max_t(int, 3 * dtimper_msec,
+                           MSEC_PER_SEC * POWER_KEEP_ALIVE_PERIOD_SEC);
+        keep_alive = DIV_ROUND_UP(keep_alive, MSEC_PER_SEC);
+        cmd->keep_alive_seconds = cpu_to_le16(keep_alive);
 
         if (iwlmvm_mod_params.power_scheme == IWL_POWER_SCHEME_CAM)
                 return;
 
         cmd->flags |= cpu_to_le16(POWER_FLAGS_POWER_SAVE_ENA_MSK);
-        if (!vif->bss_conf.assoc)
-                cmd->flags |= cpu_to_le16(POWER_FLAGS_POWER_MANAGEMENT_ENA_MSK);
 
 #ifdef CONFIG_IWLWIFI_DEBUGFS
         if (mvmvif->dbgfs_pm.mask & MVM_DEBUGFS_PM_DISABLE_POWER_OFF &&
@@ -186,12 +202,9 @@ void iwl_mvm_power_build_cmd(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
             (vif->bss_conf.beacon_rate->bitrate == 10 ||
              vif->bss_conf.beacon_rate->bitrate == 60)) {
                 cmd->flags |= cpu_to_le16(POWER_FLAGS_LPRX_ENA_MSK);
-                cmd->lprx_rssi_threshold =
-                        cpu_to_le32(POWER_LPRX_RSSI_THRESHOLD);
+                cmd->lprx_rssi_threshold = POWER_LPRX_RSSI_THRESHOLD;
         }
 
-        dtimper = hw->conf.ps_dtim_period ?: 1;
-
         /* Check if radar detection is required on current channel */
         rcu_read_lock();
         chanctx_conf = rcu_dereference(vif->chanctx_conf);
@@ -207,27 +220,25 @@ void iwl_mvm_power_build_cmd(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
             (iwlmvm_mod_params.power_scheme == IWL_POWER_SCHEME_LP ||
              mvm->cur_ucode == IWL_UCODE_WOWLAN)) {
                 cmd->flags |= cpu_to_le16(POWER_FLAGS_SKIP_OVER_DTIM_MSK);
-                cmd->skip_dtim_periods = cpu_to_le32(3);
+                cmd->skip_dtim_periods = 3;
         }
 
-        /* Check that keep alive period is at least 3 * DTIM */
-        dtimper_msec = dtimper * vif->bss_conf.beacon_int;
-        keep_alive = max_t(int, 3 * dtimper_msec,
-                           MSEC_PER_SEC * cmd->keep_alive_seconds);
-        keep_alive = DIV_ROUND_UP(keep_alive, MSEC_PER_SEC);
-        cmd->keep_alive_seconds = keep_alive;
-
         if (mvm->cur_ucode != IWL_UCODE_WOWLAN) {
-                cmd->rx_data_timeout = cpu_to_le32(100 * USEC_PER_MSEC);
-                cmd->tx_data_timeout = cpu_to_le32(100 * USEC_PER_MSEC);
+                cmd->rx_data_timeout =
+                        cpu_to_le32(IWL_MVM_DEFAULT_PS_RX_DATA_TIMEOUT);
+                cmd->tx_data_timeout =
+                        cpu_to_le32(IWL_MVM_DEFAULT_PS_TX_DATA_TIMEOUT);
         } else {
-                cmd->rx_data_timeout = cpu_to_le32(10 * USEC_PER_MSEC);
-                cmd->tx_data_timeout = cpu_to_le32(10 * USEC_PER_MSEC);
+                cmd->rx_data_timeout =
+                        cpu_to_le32(IWL_MVM_WOWLAN_PS_RX_DATA_TIMEOUT);
+                cmd->tx_data_timeout =
+                        cpu_to_le32(IWL_MVM_WOWLAN_PS_TX_DATA_TIMEOUT);
         }
 
 #ifdef CONFIG_IWLWIFI_DEBUGFS
         if (mvmvif->dbgfs_pm.mask & MVM_DEBUGFS_PM_KEEP_ALIVE)
-                cmd->keep_alive_seconds = mvmvif->dbgfs_pm.keep_alive_seconds;
+                cmd->keep_alive_seconds =
+                        cpu_to_le16(mvmvif->dbgfs_pm.keep_alive_seconds);
         if (mvmvif->dbgfs_pm.mask & MVM_DEBUGFS_PM_SKIP_OVER_DTIM) {
                 if (mvmvif->dbgfs_pm.skip_over_dtim)
                         cmd->flags |=
@@ -243,8 +254,7 @@ void iwl_mvm_power_build_cmd(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
                 cmd->tx_data_timeout =
                         cpu_to_le32(mvmvif->dbgfs_pm.tx_data_timeout);
         if (mvmvif->dbgfs_pm.mask & MVM_DEBUGFS_PM_SKIP_DTIM_PERIODS)
-                cmd->skip_dtim_periods =
-                        cpu_to_le32(mvmvif->dbgfs_pm.skip_dtim_periods);
+                cmd->skip_dtim_periods = mvmvif->dbgfs_pm.skip_dtim_periods;
         if (mvmvif->dbgfs_pm.mask & MVM_DEBUGFS_PM_LPRX_ENA) {
                 if (mvmvif->dbgfs_pm.lprx_ena)
                         cmd->flags |= cpu_to_le16(POWER_FLAGS_LPRX_ENA_MSK);
@@ -252,16 +262,16 @@ void iwl_mvm_power_build_cmd(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
                         cmd->flags &= cpu_to_le16(~POWER_FLAGS_LPRX_ENA_MSK);
         }
         if (mvmvif->dbgfs_pm.mask & MVM_DEBUGFS_PM_LPRX_RSSI_THRESHOLD)
-                cmd->lprx_rssi_threshold =
-                        cpu_to_le32(mvmvif->dbgfs_pm.lprx_rssi_threshold);
+                cmd->lprx_rssi_threshold = mvmvif->dbgfs_pm.lprx_rssi_threshold;
 #endif /* CONFIG_IWLWIFI_DEBUGFS */
 }
 
-int iwl_mvm_power_update_mode(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
+static int iwl_mvm_power_mac_update_mode(struct iwl_mvm *mvm,
+                                         struct ieee80211_vif *vif)
 {
         int ret;
         bool ba_enable;
-        struct iwl_powertable_cmd cmd = {};
+        struct iwl_mac_power_cmd cmd = {};
 
         if (vif->type != NL80211_IFTYPE_STATION || vif->p2p)
                 return 0;
@@ -280,7 +290,7 @@ int iwl_mvm_power_update_mode(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
         iwl_mvm_power_build_cmd(mvm, vif, &cmd);
         iwl_mvm_power_log(mvm, &cmd);
 
-        ret = iwl_mvm_send_cmd_pdu(mvm, POWER_TABLE_CMD, CMD_SYNC,
+        ret = iwl_mvm_send_cmd_pdu(mvm, MAC_PM_POWER_TABLE, CMD_SYNC,
                                    sizeof(cmd), &cmd);
         if (ret)
                 return ret;
@@ -291,15 +301,19 @@ int iwl_mvm_power_update_mode(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
         return iwl_mvm_update_beacon_abort(mvm, vif, ba_enable);
 }
 
-int iwl_mvm_power_disable(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
+static int iwl_mvm_power_mac_disable(struct iwl_mvm *mvm,
+                                     struct ieee80211_vif *vif)
 {
-        struct iwl_powertable_cmd cmd = {};
+        struct iwl_mac_power_cmd cmd = {};
         struct iwl_mvm_vif *mvmvif __maybe_unused =
                 iwl_mvm_vif_from_mac80211(vif);
 
         if (vif->type != NL80211_IFTYPE_STATION || vif->p2p)
                 return 0;
 
+        cmd.id_and_color = cpu_to_le32(FW_CMD_ID_AND_COLOR(mvmvif->id,
+                                                           mvmvif->color));
+
         if (iwlmvm_mod_params.power_scheme != IWL_POWER_SCHEME_CAM)
                 cmd.flags |= cpu_to_le16(POWER_FLAGS_POWER_SAVE_ENA_MSK);
 
@@ -310,11 +324,50 @@ int iwl_mvm_power_disable(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
 #endif
         iwl_mvm_power_log(mvm, &cmd);
 
-        return iwl_mvm_send_cmd_pdu(mvm, POWER_TABLE_CMD, CMD_ASYNC,
+        return iwl_mvm_send_cmd_pdu(mvm, MAC_PM_POWER_TABLE, CMD_ASYNC,
                                     sizeof(cmd), &cmd);
 }
 
 #ifdef CONFIG_IWLWIFI_DEBUGFS
+static int iwl_mvm_power_mac_dbgfs_read(struct iwl_mvm *mvm,
+                                        struct ieee80211_vif *vif, char *buf,
+                                        int bufsz)
+{
+        struct iwl_mac_power_cmd cmd = {};
+        int pos = 0;
+
+        iwl_mvm_power_build_cmd(mvm, vif, &cmd);
+
+        pos += scnprintf(buf+pos, bufsz-pos, "disable_power_off = %d\n",
+                         (cmd.flags &
+                         cpu_to_le16(POWER_FLAGS_POWER_SAVE_ENA_MSK)) ?
+                         0 : 1);
+        pos += scnprintf(buf+pos, bufsz-pos, "skip_dtim_periods = %d\n",
+                         cmd.skip_dtim_periods);
+        pos += scnprintf(buf+pos, bufsz-pos, "power_scheme = %d\n",
+                         iwlmvm_mod_params.power_scheme);
+        pos += scnprintf(buf+pos, bufsz-pos, "flags = 0x%x\n",
+                         le16_to_cpu(cmd.flags));
+        pos += scnprintf(buf+pos, bufsz-pos, "keep_alive = %d\n",
+                         le16_to_cpu(cmd.keep_alive_seconds));
+
+        if (cmd.flags & cpu_to_le16(POWER_FLAGS_POWER_MANAGEMENT_ENA_MSK)) {
+                pos += scnprintf(buf+pos, bufsz-pos, "skip_over_dtim = %d\n",
+                                 (cmd.flags &
+                                 cpu_to_le16(POWER_FLAGS_SKIP_OVER_DTIM_MSK)) ?
+                                 1 : 0);
+                pos += scnprintf(buf+pos, bufsz-pos, "rx_data_timeout = %d\n",
+                                 le32_to_cpu(cmd.rx_data_timeout));
+                pos += scnprintf(buf+pos, bufsz-pos, "tx_data_timeout = %d\n",
+                                 le32_to_cpu(cmd.tx_data_timeout));
+                if (cmd.flags & cpu_to_le16(POWER_FLAGS_LPRX_ENA_MSK))
+                        pos += scnprintf(buf+pos, bufsz-pos,
+                                         "lprx_rssi_threshold = %d\n",
+                                         cmd.lprx_rssi_threshold);
+        }
+        return pos;
+}
+
 void
 iwl_mvm_beacon_filter_debugfs_parameters(struct ieee80211_vif *vif,
                                          struct iwl_beacon_filter_cmd *cmd)
@@ -323,22 +376,30 @@ iwl_mvm_beacon_filter_debugfs_parameters(struct ieee80211_vif *vif,
         struct iwl_dbgfs_bf *dbgfs_bf = &mvmvif->dbgfs_bf;
 
         if (dbgfs_bf->mask & MVM_DEBUGFS_BF_ENERGY_DELTA)
-                cmd->bf_energy_delta = dbgfs_bf->bf_energy_delta;
+                cmd->bf_energy_delta = cpu_to_le32(dbgfs_bf->bf_energy_delta);
         if (dbgfs_bf->mask & MVM_DEBUGFS_BF_ROAMING_ENERGY_DELTA)
                 cmd->bf_roaming_energy_delta =
-                                 dbgfs_bf->bf_roaming_energy_delta;
+                                cpu_to_le32(dbgfs_bf->bf_roaming_energy_delta);
         if (dbgfs_bf->mask & MVM_DEBUGFS_BF_ROAMING_STATE)
-                cmd->bf_roaming_state = dbgfs_bf->bf_roaming_state;
-        if (dbgfs_bf->mask & MVM_DEBUGFS_BF_TEMPERATURE_DELTA)
-                cmd->bf_temperature_delta = dbgfs_bf->bf_temperature_delta;
+                cmd->bf_roaming_state = cpu_to_le32(dbgfs_bf->bf_roaming_state);
+        if (dbgfs_bf->mask & MVM_DEBUGFS_BF_TEMP_THRESHOLD)
+                cmd->bf_temp_threshold =
+                                cpu_to_le32(dbgfs_bf->bf_temp_threshold);
+        if (dbgfs_bf->mask & MVM_DEBUGFS_BF_TEMP_FAST_FILTER)
+                cmd->bf_temp_fast_filter =
+                                cpu_to_le32(dbgfs_bf->bf_temp_fast_filter);
+        if (dbgfs_bf->mask & MVM_DEBUGFS_BF_TEMP_SLOW_FILTER)
+                cmd->bf_temp_slow_filter =
+                                cpu_to_le32(dbgfs_bf->bf_temp_slow_filter);
         if (dbgfs_bf->mask & MVM_DEBUGFS_BF_DEBUG_FLAG)
-                cmd->bf_debug_flag = dbgfs_bf->bf_debug_flag;
+                cmd->bf_debug_flag = cpu_to_le32(dbgfs_bf->bf_debug_flag);
         if (dbgfs_bf->mask & MVM_DEBUGFS_BF_ESCAPE_TIMER)
                 cmd->bf_escape_timer = cpu_to_le32(dbgfs_bf->bf_escape_timer);
         if (dbgfs_bf->mask & MVM_DEBUGFS_BA_ESCAPE_TIMER)
                 cmd->ba_escape_timer = cpu_to_le32(dbgfs_bf->ba_escape_timer);
         if (dbgfs_bf->mask & MVM_DEBUGFS_BA_ENABLE_BEACON_ABORT)
-                cmd->ba_enable_beacon_abort = dbgfs_bf->ba_enable_beacon_abort;
+                cmd->ba_enable_beacon_abort =
+                                cpu_to_le32(dbgfs_bf->ba_enable_beacon_abort);
 }
 #endif
 
@@ -348,7 +409,7 @@ int iwl_mvm_enable_beacon_filter(struct iwl_mvm *mvm,
         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
         struct iwl_beacon_filter_cmd cmd = {
                 IWL_BF_CMD_CONFIG_DEFAULTS,
-                .bf_enable_beacon_filter = 1,
+                .bf_enable_beacon_filter = cpu_to_le32(1),
         };
         int ret;
 
@@ -372,7 +433,8 @@ int iwl_mvm_disable_beacon_filter(struct iwl_mvm *mvm,
         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
         int ret;
 
-        if (vif->type != NL80211_IFTYPE_STATION || vif->p2p)
+        if (!(mvm->fw->ucode_capa.flags & IWL_UCODE_TLV_FLAGS_BF_UPDATED) ||
+            vif->type != NL80211_IFTYPE_STATION || vif->p2p)
                 return 0;
 
         ret = iwl_mvm_beacon_filter_send_cmd(mvm, &cmd);
@@ -382,3 +444,11 @@ int iwl_mvm_disable_beacon_filter(struct iwl_mvm *mvm,
 
         return ret;
 }
+
+const struct iwl_mvm_power_ops pm_mac_ops = {
+        .power_update_mode = iwl_mvm_power_mac_update_mode,
+        .power_disable = iwl_mvm_power_mac_disable,
+#ifdef CONFIG_IWLWIFI_DEBUGFS
+        .power_dbgfs_read = iwl_mvm_power_mac_dbgfs_read,
+#endif
+};