qcacld: wlan: complete IBSS Power Save Support

Add Ibss power save support from host side.

Change-Id: I32f527eb78c54ffe142c437bb04009f196ef98a7
CRs-Fixed: 675512

8 files changed, 741 insertions, 10 deletions

diff --git a/CORE/HDD/inc/wlan_hdd_cfg.h b/CORE/HDD/inc/wlan_hdd_cfg.h
index 6899de25653a..62f1cbb45c5d 100644
--- a/CORE/HDD/inc/wlan_hdd_cfg.h
+++ b/CORE/HDD/inc/wlan_hdd_cfg.h
@@ -2379,9 +2379,68 @@ This feature requires the dependent cfg.ini "gRoamPrefer5GHz" set to 1 */
 
 #define CFG_IBSS_ATIM_WIN_SIZE_NAME                "gIbssATIMWinSize"
 #define CFG_IBSS_ATIM_WIN_SIZE_MIN                 (0)
-#define CFG_IBSS_ATIM_WIN_SIZE_MAX                 (20)
+#define CFG_IBSS_ATIM_WIN_SIZE_MAX                 (50)
 #define CFG_IBSS_ATIM_WIN_SIZE_DEFAULT             (0)
 
+/*
+ * Indicates if IBSS Power Save is
+ * supported or not. When not allowed,
+ * IBSS station has to stay awake all
+ * the time and should never set PM=1
+ * in its transmitted frames. This
+ * parameter is meaningful/valid only
+ * when gIbssATIMWinSize is non-zero
+ */
+#define CFG_IBSS_IS_POWER_SAVE_ALLOWED_NAME        "gIbssIsPowerSaveAllowed"
+#define CFG_IBSS_IS_POWER_SAVE_ALLOWED_MIN         (0)
+#define CFG_IBSS_IS_POWER_SAVE_ALLOWED_MAX         (1)
+#define CFG_IBSS_IS_POWER_SAVE_ALLOWED_DEFAULT     (1)
+
+/*
+ * Indicates if IBSS Power Collapse
+ * is allowed or not.
+ */
+#define CFG_IBSS_IS_POWER_COLLAPSE_ALLOWED_NAME    "gIbssIsPowerCollapseAllowed"
+#define CFG_IBSS_IS_POWER_COLLAPSE_ALLOWED_MIN     (0)
+#define CFG_IBSS_IS_POWER_COLLAPSE_ALLOWED_MAX     (1)
+#define CFG_IBSS_IS_POWER_COLLAPSE_ALLOWED_DEFAULT (1)
+
+/*
+ * This parameter indicates whether IBSS station
+ * can exit power save mode and enter power active
+ * state whenever there is a TX/RX activity.
+ */
+#define CFG_IBSS_AWAKE_ON_TX_RX_NAME               "gIbssAwakeOnTxRx"
+#define CFG_IBSS_AWAKE_ON_TX_RX_MIN                (0)
+#define CFG_IBSS_AWAKE_ON_TX_RX_MAX                (1)
+#define CFG_IBSS_AWAKE_ON_TX_RX_DEFAULT            (0)
+
+/*
+ * In IBSS mode if Awake on TX/RX activity is enabled
+ * Ibss Inactivity parameter indicates the data
+ * inactivity time in number of beacon intervals
+ * after which IBSS station re-inters power save
+ * by sending Null frame with PM=1
+ */
+#define CFG_IBSS_INACTIVITY_TIME_NAME              "gIbssInactivityTime"
+#define CFG_IBSS_INACTIVITY_TIME_MIN               (1)
+#define CFG_IBSS_INACTIVITY_TIME_MAX               (10)
+#define CFG_IBSS_INACTIVITY_TIME_DEFAULT           (1)
+
+/*
+ * In IBSS mode Tx Service Period Inactivity
+ * time in msecs indicates the time after
+ * which TX Service Period is terminated by
+ * sending a Qos Null frame with EOSP.
+ * If value is 0, TX SP is terminated with the
+ * last buffered packet itself instead of waiting
+ * for the inactivity
+ */
+#define CFG_IBSS_TXSP_END_INACTIVITY_NAME          "gIbssTxSpEndInactivityTime"
+#define CFG_IBSS_TXSP_END_INACTIVITY_MIN           (0)
+#define CFG_IBSS_TXSP_END_INACTIVITY_MAX           (100)
+#define CFG_IBSS_TXSP_END_INACTIVITY_DEFAULT       (0)
+
 #define CFG_SAP_MAX_NO_PEERS                       "gSoftApMaxPeers"
 #define CFG_SAP_MAX_NO_PEERS_MIN                   (1)
 #define CFG_SAP_MAX_NO_PEERS_MAX                   (32)
@@ -2966,7 +3025,15 @@ typedef struct
    v_U8_t                      isAmsduSupportInAMPDU;
    v_U8_t                      nSelect5GHzMargin;
    v_U8_t                      isCoalesingInIBSSAllowed;
-   v_U8_t                      ibssATIMWinSize;
+
+   /* IBSS Power Save related parameters */
+   v_U32_t                     ibssATIMWinSize;
+   v_U8_t                      isIbssPowerSaveAllowed;
+   v_U8_t                      isIbssPowerCollapseAllowed;
+   v_U8_t                      isIbssAwakeOnTxRx;
+   v_U32_t                     ibssInactivityCount;
+   v_U32_t                     ibssTxSpEndInactivityTime;
+
    v_BOOL_t                    enableTCPChkSumOffld;
    v_BOOL_t                    enableIPChecksumOffload;
    v_BOOL_t                    enablePowersaveOffload;
diff --git a/CORE/HDD/inc/wlan_hdd_main.h b/CORE/HDD/inc/wlan_hdd_main.h
index adc0499fc38f..4b7084fd05cc 100644
--- a/CORE/HDD/inc/wlan_hdd_main.h
+++ b/CORE/HDD/inc/wlan_hdd_main.h
@@ -1551,6 +1551,7 @@ VOS_STATUS hdd_disable_bmps_imps(hdd_context_t *pHddCtx, tANI_U8 session_type);
 #ifdef QCA_WIFI_2_0
 void wlan_hdd_cfg80211_update_wiphy_caps(struct wiphy *wiphy);
 #endif
+VOS_STATUS hdd_setIbssPowerSaveParams(hdd_adapter_t *pAdapter);
 void wlan_hdd_cfg80211_update_reg_info(struct wiphy *wiphy);
 VOS_STATUS wlan_hdd_restart_driver(hdd_context_t *pHddCtx);
 void hdd_exchange_version_and_caps(hdd_context_t *pHddCtx);
diff --git a/CORE/HDD/src/wlan_hdd_cfg.c b/CORE/HDD/src/wlan_hdd_cfg.c
index 784f8d9e8395..42426031484d 100644
--- a/CORE/HDD/src/wlan_hdd_cfg.c
+++ b/CORE/HDD/src/wlan_hdd_cfg.c
@@ -3198,6 +3198,41 @@ REG_TABLE_ENTRY g_registry_table[] =
                  CFG_SAP_MAX_NO_PEERS_MIN,
                  CFG_SAP_MAX_NO_PEERS_MAX),
 
+   REG_VARIABLE( CFG_IBSS_IS_POWER_SAVE_ALLOWED_NAME , WLAN_PARAM_Integer,
+                 hdd_config_t, isIbssPowerSaveAllowed,
+                 VAR_FLAGS_OPTIONAL | VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT,
+                 CFG_IBSS_IS_POWER_SAVE_ALLOWED_DEFAULT,
+                 CFG_IBSS_IS_POWER_SAVE_ALLOWED_MIN,
+                 CFG_IBSS_IS_POWER_SAVE_ALLOWED_MAX ),
+
+   REG_VARIABLE( CFG_IBSS_IS_POWER_COLLAPSE_ALLOWED_NAME , WLAN_PARAM_Integer,
+                 hdd_config_t, isIbssPowerCollapseAllowed,
+                 VAR_FLAGS_OPTIONAL | VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT,
+                 CFG_IBSS_IS_POWER_COLLAPSE_ALLOWED_DEFAULT,
+                 CFG_IBSS_IS_POWER_COLLAPSE_ALLOWED_MIN,
+                 CFG_IBSS_IS_POWER_COLLAPSE_ALLOWED_MAX ),
+
+   REG_VARIABLE( CFG_IBSS_AWAKE_ON_TX_RX_NAME , WLAN_PARAM_Integer,
+                 hdd_config_t, isIbssAwakeOnTxRx,
+                 VAR_FLAGS_OPTIONAL | VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT,
+                 CFG_IBSS_AWAKE_ON_TX_RX_DEFAULT,
+                 CFG_IBSS_AWAKE_ON_TX_RX_MIN,
+                 CFG_IBSS_AWAKE_ON_TX_RX_MAX ),
+
+   REG_VARIABLE( CFG_IBSS_INACTIVITY_TIME_NAME, WLAN_PARAM_Integer,
+                 hdd_config_t, ibssInactivityCount,
+                 VAR_FLAGS_OPTIONAL | VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT,
+                 CFG_IBSS_INACTIVITY_TIME_DEFAULT,
+                 CFG_IBSS_INACTIVITY_TIME_MIN,
+                 CFG_IBSS_INACTIVITY_TIME_MAX ),
+
+   REG_VARIABLE( CFG_IBSS_TXSP_END_INACTIVITY_NAME, WLAN_PARAM_Integer,
+                 hdd_config_t, ibssTxSpEndInactivityTime,
+                 VAR_FLAGS_OPTIONAL | VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT,
+                 CFG_IBSS_TXSP_END_INACTIVITY_DEFAULT,
+                 CFG_IBSS_TXSP_END_INACTIVITY_MIN,
+                 CFG_IBSS_TXSP_END_INACTIVITY_MAX ),
+
 #ifndef QCA_WIFI_ISOC
    REG_VARIABLE( CFG_THERMAL_TEMP_MIN_LEVEL0_NAME, WLAN_PARAM_Integer,
                  hdd_config_t, thermalTempMinLevel0,
@@ -3995,6 +4030,11 @@ static void print_hdd_cfg(hdd_context_t *pHddCtx)
   VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [nSelect5GHzMargin] Value = [%u] ",pHddCtx->cfg_ini->nSelect5GHzMargin);
   VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [gCoalesingInIBSS] Value = [%u] ",pHddCtx->cfg_ini->isCoalesingInIBSSAllowed);
   VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [gIbssATIMWinSize] Value = [%u] ",pHddCtx->cfg_ini->ibssATIMWinSize);
+  VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [gIbssIsPowerSaveAllowed] Value = [%u] ",pHddCtx->cfg_ini->isIbssPowerSaveAllowed);
+  VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [gIbssIsPowerCollapseAllowed] Value = [%u] ",pHddCtx->cfg_ini->isIbssPowerCollapseAllowed);
+  VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [gIbssAwakeOnTxRx] Value = [%u] ",pHddCtx->cfg_ini->isIbssAwakeOnTxRx);
+  VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [gIbssInactivityTime] Value = [%u] ",pHddCtx->cfg_ini->ibssInactivityCount);
+  VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [gIbssTxSpEndInactivityTime] Value = [%u] ",pHddCtx->cfg_ini->ibssTxSpEndInactivityTime);
   VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [fDfsPhyerrFilterOffload] Value = [%u] ",pHddCtx->cfg_ini->fDfsPhyerrFilterOffload);
 
 #ifdef IPA_OFFLOAD
diff --git a/CORE/HDD/src/wlan_hdd_cfg80211.c b/CORE/HDD/src/wlan_hdd_cfg80211.c
index dcccbca95f31..12ce1e904a8d 100644
--- a/CORE/HDD/src/wlan_hdd_cfg80211.c
+++ b/CORE/HDD/src/wlan_hdd_cfg80211.c
@@ -6202,6 +6202,20 @@ int wlan_hdd_cfg80211_connect_start( hdd_adapter_t  *pAdapter,
         }
         if ( (WLAN_HDD_IBSS == pAdapter->device_mode) && operatingChannel)
         {
+            /*
+             * Need to post the IBSS power save parameters
+             * to WMA. WMA will configure this parameters
+             * to firmware if power save is enabled by the
+             * firmware.
+             */
+            status = hdd_setIbssPowerSaveParams(pAdapter);
+
+            if (VOS_STATUS_SUCCESS != status)
+            {
+                hddLog(VOS_TRACE_LEVEL_ERROR,
+                       "%s: Set IBSS Power Save Params Failed", __func__);
+                return -EINVAL;
+            }
             hdd_select_cbmode(pAdapter,operatingChannel);
         }
 
diff --git a/CORE/HDD/src/wlan_hdd_main.c b/CORE/HDD/src/wlan_hdd_main.c
index 418376128839..ef7392956183 100755
--- a/CORE/HDD/src/wlan_hdd_main.c
+++ b/CORE/HDD/src/wlan_hdd_main.c
@@ -133,6 +133,7 @@ void hdd_ch_avoid_cb(void *hdd_context,void *indi_param);
 #elif defined(HIF_SDIO)
 #include "if_ath_sdio.h"
 #endif
+#include "wma.h"
 #endif
 
 #ifdef MODULE
@@ -990,6 +991,107 @@ void hdd_checkandupdate_dfssetting( hdd_adapter_t *pAdapter, char *country_code)
 
 }
 
+/**---------------------------------------------------------------------------
+
+  \brief hdd_setIbssPowerSaveParams - update IBSS Power Save params to WMA.
+
+  This function sets the IBSS power save config parameters to WMA
+  which will send it to firmware if FW supports IBSS power save
+  before vdev start.
+
+  \param  - hdd_adapter_t Hdd adapter.
+
+  \return - VOS_STATUS VOS_STATUS_SUCCESS on Success and VOS_STATUS_E_FAILURE
+            on failure.
+
+  --------------------------------------------------------------------------*/
+VOS_STATUS hdd_setIbssPowerSaveParams(hdd_adapter_t *pAdapter)
+{
+    VOS_STATUS ret;
+    hdd_context_t *pHddCtx = WLAN_HDD_GET_CTX( pAdapter );
+
+    if (pHddCtx == NULL)
+    {
+        VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,
+                   "%s: HDD context is null", __func__);
+        return VOS_STATUS_E_FAILURE;
+    }
+
+    ret = process_wma_set_command((int)pAdapter->sessionId,
+                             (int)WMA_VDEV_IBSS_SET_ATIM_WINDOW_SIZE,
+                             (int)pHddCtx->cfg_ini->ibssATIMWinSize,
+                             VDEV_CMD);
+    if (VOS_STATUS_SUCCESS != ret)
+    {
+        hddLog(VOS_TRACE_LEVEL_ERROR,
+               "%s: WMA_VDEV_IBSS_SET_ATIM_WINDOW_SIZE failed %d",
+               __func__, ret);
+        return VOS_STATUS_E_FAILURE;
+    }
+
+    ret = process_wma_set_command((int)pAdapter->sessionId,
+                             (int)WMA_VDEV_IBSS_SET_POWER_SAVE_ALLOWED,
+                             (int)pHddCtx->cfg_ini->isIbssPowerSaveAllowed,
+                             VDEV_CMD);
+    if (VOS_STATUS_SUCCESS != ret)
+    {
+        hddLog(VOS_TRACE_LEVEL_ERROR,
+               "%s: WMA_VDEV_IBSS_SET_POWER_SAVE_ALLOWED failed %d",
+               __func__, ret);
+        return VOS_STATUS_E_FAILURE;
+    }
+
+    ret = process_wma_set_command((int)pAdapter->sessionId,
+                             (int)WMA_VDEV_IBSS_SET_POWER_COLLAPSE_ALLOWED,
+                             (int)pHddCtx->cfg_ini->isIbssPowerCollapseAllowed,
+                             VDEV_CMD);
+    if (VOS_STATUS_SUCCESS != ret)
+    {
+        hddLog(VOS_TRACE_LEVEL_ERROR,
+               "%s: WMA_VDEV_IBSS_SET_POWER_COLLAPSE_ALLOWED failed %d",
+               __func__, ret);
+        return VOS_STATUS_E_FAILURE;
+    }
+
+    ret = process_wma_set_command((int)pAdapter->sessionId,
+                             (int)WMA_VDEV_IBSS_SET_AWAKE_ON_TX_RX,
+                             (int)pHddCtx->cfg_ini->isIbssAwakeOnTxRx,
+                             VDEV_CMD);
+    if (VOS_STATUS_SUCCESS != ret)
+    {
+        hddLog(VOS_TRACE_LEVEL_ERROR,
+               "%s: WMA_VDEV_IBSS_SET_AWAKE_ON_TX_RX failed %d",
+               __func__, ret);
+        return VOS_STATUS_E_FAILURE;
+    }
+
+    ret = process_wma_set_command((int)pAdapter->sessionId,
+                             (int)WMA_VDEV_IBSS_SET_INACTIVITY_TIME,
+                             (int)pHddCtx->cfg_ini->ibssInactivityCount,
+                             VDEV_CMD);
+    if (VOS_STATUS_SUCCESS != ret)
+    {
+        hddLog(VOS_TRACE_LEVEL_ERROR,
+               "%s: WMA_VDEV_IBSS_SET_INACTIVITY_TIME failed %d",
+               __func__, ret);
+        return VOS_STATUS_E_FAILURE;
+    }
+
+    ret = process_wma_set_command((int)pAdapter->sessionId,
+                             (int)WMA_VDEV_IBSS_SET_TXSP_END_INACTIVITY_TIME,
+                             (int)pHddCtx->cfg_ini->ibssTxSpEndInactivityTime,
+                             VDEV_CMD);
+    if (VOS_STATUS_SUCCESS != ret)
+    {
+        hddLog(VOS_TRACE_LEVEL_ERROR,
+               "%s: WMA_VDEV_IBSS_SET_TXSP_END_INACTIVITY_TIME failed %d",
+               __func__, ret);
+        return VOS_STATUS_E_FAILURE;
+    }
+
+    return ret;
+}
+
 #ifdef FEATURE_WLAN_BATCH_SCAN
 
 /**---------------------------------------------------------------------------
diff --git a/CORE/SERVICES/WMA/wma.c b/CORE/SERVICES/WMA/wma.c
index 4a2a73347a15..d10a612daefa 100644
--- a/CORE/SERVICES/WMA/wma.c
+++ b/CORE/SERVICES/WMA/wma.c
@@ -8022,9 +8022,58 @@ static int32_t wma_set_priv_cfg(tp_wma_handle wma_handle,
 						);
 	}
 		break;
+	case WMA_VDEV_IBSS_SET_ATIM_WINDOW_SIZE:
+	{
+		wma_handle->wma_ibss_power_save_params.atimWindowLength =
+					privcmd->param_value;
+		WMA_LOGD("%s: IBSS power save ATIM Window = %d", __func__,
+			wma_handle->wma_ibss_power_save_params.atimWindowLength);
+	}
+		break;
+	case WMA_VDEV_IBSS_SET_POWER_SAVE_ALLOWED:
+	{
+		wma_handle->wma_ibss_power_save_params.isPowerSaveAllowed =
+					privcmd->param_value;
+		WMA_LOGD("%s: IBSS is Power Save Allowed = %d", __func__,
+			wma_handle->wma_ibss_power_save_params.isPowerSaveAllowed);
+	}
+		break;
+	case WMA_VDEV_IBSS_SET_POWER_COLLAPSE_ALLOWED:
+	{
+		wma_handle->wma_ibss_power_save_params.isPowerCollapseAllowed =
+					privcmd->param_value;
+		WMA_LOGD("%s: IBSS is Power Collapse Allowed = %d", __func__,
+			wma_handle->wma_ibss_power_save_params.isPowerCollapseAllowed);
+	}
+		break;
+	case WMA_VDEV_IBSS_SET_AWAKE_ON_TX_RX:
+	{
+		wma_handle->wma_ibss_power_save_params.isAwakeonTxRxEnabled =
+					privcmd->param_value;
+		WMA_LOGD("%s: IBSS Power Save Awake on Tx/Rx Enabled = %d", __func__,
+			wma_handle->wma_ibss_power_save_params.isAwakeonTxRxEnabled);
+	}
+		break;
+	case WMA_VDEV_IBSS_SET_INACTIVITY_TIME:
+	{
+		wma_handle->wma_ibss_power_save_params.inactivityCount =
+					privcmd->param_value;
+		WMA_LOGD("%s: IBSS Power Save Data Inactivity Count = %d", __func__,
+			wma_handle->wma_ibss_power_save_params.inactivityCount);
+	}
+		break;
+	case WMA_VDEV_IBSS_SET_TXSP_END_INACTIVITY_TIME:
+	{
+		wma_handle->wma_ibss_power_save_params.txSPEndInactivityTime =
+					privcmd->param_value;
+		WMA_LOGD("%s: IBSS Power Save Transmit EOSP inactivity time out = %d",
+			__func__,
+			wma_handle->wma_ibss_power_save_params.txSPEndInactivityTime);
+	}
+		break;
 	default:
 		WMA_LOGE("Invalid wma config command id:%d",
-			 privcmd->param_id);
+			privcmd->param_id);
 		ret = -EINVAL;
 	}
 	return ret;
@@ -9209,6 +9258,68 @@ send_fail_resp:
 }
 
 #ifdef QCA_IBSS_SUPPORT
+static VOS_STATUS
+wma_set_ibss_pwrsave_params(tp_wma_handle wma, u_int8_t vdev_id)
+{
+	int ret;
+
+	ret = wmi_unified_vdev_set_param_send(wma->wmi_handle, vdev_id,
+				WMI_VDEV_PARAM_ATIM_WINDOW_LENGTH,
+				wma->wma_ibss_power_save_params.atimWindowLength);
+	if (ret < 0) {
+		WMA_LOGE("Failed to set WMI_VDEV_PARAM_ATIM_WINDOW_LENGTH ret = %d",
+				ret);
+		return VOS_STATUS_E_FAILURE;
+	}
+
+	ret = wmi_unified_vdev_set_param_send(wma->wmi_handle, vdev_id,
+				WMI_VDEV_PARAM_IS_IBSS_POWER_SAVE_ALLOWED,
+				wma->wma_ibss_power_save_params.isPowerSaveAllowed);
+	if (ret < 0) {
+		WMA_LOGE("Failed, set WMI_VDEV_PARAM_IS_IBSS_POWER_SAVE_ALLOWED ret=%d",
+				ret);
+		return VOS_STATUS_E_FAILURE;
+	}
+
+	ret = wmi_unified_vdev_set_param_send(wma->wmi_handle, vdev_id,
+				WMI_VDEV_PARAM_IS_POWER_COLLAPSE_ALLOWED,
+				wma->wma_ibss_power_save_params.isPowerCollapseAllowed);
+	if (ret < 0) {
+		WMA_LOGE("Failed, set WMI_VDEV_PARAM_IS_POWER_COLLAPSE_ALLOWED ret=%d",
+				ret);
+		return VOS_STATUS_E_FAILURE;
+	}
+
+	ret = wmi_unified_vdev_set_param_send(wma->wmi_handle, vdev_id,
+				WMI_VDEV_PARAM_IS_AWAKE_ON_TXRX_ENABLED,
+				wma->wma_ibss_power_save_params.isAwakeonTxRxEnabled);
+	if (ret < 0) {
+		WMA_LOGE("Failed, set WMI_VDEV_PARAM_IS_AWAKE_ON_TXRX_ENABLED ret=%d",
+				ret);
+		return VOS_STATUS_E_FAILURE;
+	}
+
+	ret = wmi_unified_vdev_set_param_send(wma->wmi_handle, vdev_id,
+				WMI_VDEV_PARAM_INACTIVITY_CNT,
+				wma->wma_ibss_power_save_params.inactivityCount);
+	if (ret < 0) {
+		WMA_LOGE("Failed, set WMI_VDEV_PARAM_INACTIVITY_CNT ret=%d",
+				ret);
+		return VOS_STATUS_E_FAILURE;
+	}
+
+	ret = wmi_unified_vdev_set_param_send(wma->wmi_handle, vdev_id,
+				WMI_VDEV_PARAM_TXSP_END_INACTIVITY_TIME_MS,
+				wma->wma_ibss_power_save_params.txSPEndInactivityTime);
+	if (ret < 0) {
+		WMA_LOGE("Failed, set WMI_VDEV_PARAM_TXSP_END_INACTIVITY_TIME_MS ret=%d",
+				ret);
+		return VOS_STATUS_E_FAILURE;
+	}
+
+	return VOS_STATUS_SUCCESS;
+}
+
 static void wma_add_bss_ibss_mode(tp_wma_handle wma, tpAddBssParams add_bss)
 {
 	ol_txrx_pdev_handle pdev;
@@ -9321,6 +9432,21 @@ static void wma_add_bss_ibss_mode(tp_wma_handle wma, tpAddBssParams add_bss)
 
 	add_bss->staContext.staIdx = ol_txrx_local_peer_id(peer);
 
+	/*
+	 * If IBSS Power Save is supported by firmware
+	 * set the IBSS power save params to firmware.
+	 */
+	if (WMI_SERVICE_IS_ENABLED(wma->wmi_service_bitmap,
+            WMI_SERVICE_IBSS_PWRSAVE)) {
+		status = wma_set_ibss_pwrsave_params(wma, vdev_id);
+		if (status != VOS_STATUS_SUCCESS) {
+			WMA_LOGE("%s: Failed to Set IBSS Power Save Params to firmware",
+				__func__);
+			goto peer_cleanup;
+		}
+	}
+
+
 	vos_mem_zero(&req, sizeof(req));
 	req.vdev_id = vdev_id;
 	req.chan = add_bss->currentOperChannel;
diff --git a/CORE/SERVICES/WMA/wma.h b/CORE/SERVICES/WMA/wma.h
index b2d2f865be2d..747607f5856a 100644
--- a/CORE/SERVICES/WMA/wma.h
+++ b/CORE/SERVICES/WMA/wma.h
@@ -515,6 +515,15 @@ typedef struct {
 }scan_timer_info;
 
 typedef struct {
+	u_int32_t atimWindowLength;
+	u_int32_t isPowerSaveAllowed;
+	u_int32_t isPowerCollapseAllowed;
+	u_int32_t isAwakeonTxRxEnabled;
+	u_int32_t inactivityCount;
+	u_int32_t txSPEndInactivityTime;
+}ibss_power_save_params;
+
+typedef struct {
 	void *wmi_handle;
 	void *htc_handle;
 	void *vos_context;
@@ -642,6 +651,10 @@ typedef struct {
 
 	u_int8_t dfs_phyerr_filter_offload;
 	v_BOOL_t suitable_ap_hb_failure;
+
+	/* IBSS Power Save config Parameters */
+	ibss_power_save_params wma_ibss_power_save_params;
+
 }t_wma_handle, *tp_wma_handle;
 
 struct wma_target_cap {
@@ -1259,13 +1272,22 @@ typedef struct {
  * does not involve sending a wmi command.
  */
 enum wma_cfg_cmd_id {
-       WMA_VDEV_TXRX_FWSTATS_ENABLE_CMDID = WMI_CMDID_MAX,
-       WMA_VDEV_TXRX_FWSTATS_RESET_CMDID,
-       /* Set time latency and time quota for MCC home channels */
-       WMA_VDEV_MCC_SET_TIME_LATENCY,
-       WMA_VDEV_MCC_SET_TIME_QUOTA,
-       /* Add any new command before this */
-       WMA_CMD_ID_MAX
+	WMA_VDEV_TXRX_FWSTATS_ENABLE_CMDID = WMI_CMDID_MAX,
+	WMA_VDEV_TXRX_FWSTATS_RESET_CMDID,
+	/* Set time latency and time quota for MCC home channels */
+	WMA_VDEV_MCC_SET_TIME_LATENCY,
+	WMA_VDEV_MCC_SET_TIME_QUOTA,
+
+	/* IBSS Power Save Parameters */
+	WMA_VDEV_IBSS_SET_ATIM_WINDOW_SIZE,
+	WMA_VDEV_IBSS_SET_POWER_SAVE_ALLOWED,
+	WMA_VDEV_IBSS_SET_POWER_COLLAPSE_ALLOWED,
+	WMA_VDEV_IBSS_SET_AWAKE_ON_TX_RX,
+	WMA_VDEV_IBSS_SET_INACTIVITY_TIME,
+	WMA_VDEV_IBSS_SET_TXSP_END_INACTIVITY_TIME,
+
+	/* Add any new command before this */
+	WMA_CMD_ID_MAX
 };
 
 typedef struct wma_trigger_uapsd_params
diff --git a/CORE/UTILS/FWLOG/dbglog_host.c b/CORE/UTILS/FWLOG/dbglog_host.c
index ff2e54688386..40cca65393ee 100644
--- a/CORE/UTILS/FWLOG/dbglog_host.c
+++ b/CORE/UTILS/FWLOG/dbglog_host.c
@@ -143,6 +143,8 @@ const char *dbglog_get_module_str(A_UINT32 module_id)
         return "P2P";
     case WLAN_MODULE_WOW:
         return "WoW";
+    case WLAN_MODULE_IBSS_PWRSAVE:
+        return "IBSS PS";
     default:
         return "UNKNOWN";
     }
@@ -1123,6 +1125,34 @@ char * DBG_MSG_ARR[WLAN_MODULE_ID_MAX][MAX_DBG_MSGS] =
     {
 	    /* WLAN_MODULE_NAN */
     },
+    {
+       /* WLAN_MODULE_IBSS_PWRSAVE */
+       "IBSS_PS_DBGID_DEFINITION_START",
+       "IBSS_PS_DBGID_PEER_CREATE",
+       "IBSS_PS_DBGID_PEER_DELETE",
+       "IBSS_PS_DBGID_VDEV_CREATE",
+       "IBSS_PS_DBGID_VDEV_DELETE",
+       "IBSS_PS_DBGID_VDEV_EVENT",
+       "IBSS_PS_DBGID_PEER_EVENT",
+       "IBSS_PS_DBGID_DELIVER_CAB",
+       "IBSS_PS_DBGID_DELIVER_UC_DATA",
+       "IBSS_PS_DBGID_DELIVER_UC_DATA_ERROR",
+       "IBSS_PS_DBGID_UC_INACTIVITY_TMR_RESTART",
+       "IBSS_PS_DBGID_MC_INACTIVITY_TMR_RESTART",
+       "IBSS_PS_DBGID_NULL_TX_COMPLETION",
+       "IBSS_PS_DBGID_ATIM_TIMER_START",
+       "IBSS_PS_DBGID_UC_ATIM_SEND",
+       "IBSS_PS_DBGID_BC_ATIM_SEND",
+       "IBSS_PS_DBGID_UC_TIMEOUT",
+       "IBSS_PS_DBGID_PWR_COLLAPSE_ALLOWED",
+       "IBSS_PS_DBGID_PWR_COLLAPSE_NOT_ALLOWED",
+       "IBSS_PS_DBGID_SET_PARAM",
+       "IBSS_PS_DBGID_HOST_TX_PAUSE",
+       "IBSS_PS_DBGID_HOST_TX_UNPAUSE",
+       "IBSS_PS_DBGID_PS_DESC_BIN_HWM",
+       "IBSS_PS_DBGID_PS_DESC_BIN_LWM",
+       "IBSS_PS_DBGID_PS_KICKOUT_PEER",
+    },
 };
 
 int dbglog_module_log_enable(wmi_unified_t  wmi_handle, A_UINT32 mod_id,
@@ -1983,6 +2013,333 @@ dbglog_sta_powersave_print_handler(
 
     return TRUE;
 }
+/* IBSS PS sub modules */
+enum wlan_ibss_ps_sub_module {
+    WLAN_IBSS_PS_SUB_MODULE_IBSS_NW_SM = 0,
+    WLAN_IBSS_PS_SUB_MODULE_IBSS_SELF_PS = 1,
+    WLAN_IBSS_PS_SUB_MODULE_IBSS_PEER_PS = 2,
+    WLAN_IBSS_PS_SUB_MODULE_MAX = 3,
+};
+
+#define WLAN_IBSS_PS_SUB_MODULE_OFFSET  0x1E
+
+A_BOOL
+dbglog_ibss_powersave_print_handler(
+        A_UINT32 mod_id,
+        A_UINT16 vap_id,
+        A_UINT32 dbg_id,
+        A_UINT32 timestamp,
+        A_UINT16 numargs,
+        A_UINT32 *args)
+{
+    static const char *nw_states[] = {
+        "WAIT_FOR_TBTT",
+        "ATIM_WINDOW_PRE_BCN",
+        "ATIM_WINDOW_POST_BCN",
+        "OUT_OF_ATIM_WINDOW",
+    };
+
+    static const char *ps_states[] = {
+        "ACTIVE",
+        "SLEEP_TX_SEND",
+        "SLEEP_DOZE_PAUSE_PENDING",
+        "SLEEP_DOZE",
+        "SLEEP_AWAKE",
+        "ACTIVE_TX_SEND",
+    };
+
+    static const char *peer_ps_states[] = {
+        "ACTIVE",
+        "SLEEP_AWAKE",
+        "SLEEP_DOZE",
+        "PS_UNKNOWN",
+    };
+
+    static const char *events[] = {
+        "START",
+        "STOP",
+        "SWBA",
+        "TBTT",
+        "TX_BCN_CMP",
+        "SEND_COMPLETE",
+        "SEND_N_COMPLETE",
+        "PRE_SEND",
+        "RX",
+        "UC_INACTIVITY_TIMEOUT",
+        "BC_INACTIVITY_TIMEOUT",
+        "ATIM_WINDOW_BEGIN",
+        "ATIM_WINDOW_END",
+        "HWQ_EMPTY",
+        "UC_ATIM_RCVD",
+        "TRAFFIC_EXCHANGE_DONE",
+        "POWER_SAVE_STATE_CHANGE",
+        "NEW_PEER_JOIN",
+        "IBSS_VDEV_PAUSE",
+        "IBSS_VDEV_UNPAUSE",
+        "PS_STATE_CHANGE"
+    };
+
+    enum wlan_ibss_ps_sub_module sub_module;
+
+    switch (dbg_id) {
+    case DBGLOG_DBGID_SM_FRAMEWORK_PROXY_DBGLOG_MSG:
+        sub_module = (args[1] >> WLAN_IBSS_PS_SUB_MODULE_OFFSET) & 0x3;
+        switch(sub_module)
+        {
+            case WLAN_IBSS_PS_SUB_MODULE_IBSS_NW_SM:
+                dbglog_sm_print(timestamp, vap_id, numargs, args, "IBSS PS NW",
+                                nw_states, ARRAY_LENGTH(nw_states), events,
+                                ARRAY_LENGTH(events));
+                break;
+            case WLAN_IBSS_PS_SUB_MODULE_IBSS_SELF_PS:
+                dbglog_sm_print(timestamp, vap_id, numargs, args,
+                                "IBSS PS Self", ps_states, ARRAY_LENGTH(ps_states),
+                                events, ARRAY_LENGTH(events));
+                break;
+            case WLAN_IBSS_PS_SUB_MODULE_IBSS_PEER_PS:
+                dbglog_sm_print(timestamp, vap_id, numargs, args,
+                                "IBSS PS Peer", peer_ps_states,
+                                 ARRAY_LENGTH(peer_ps_states), events,
+                                 ARRAY_LENGTH(events));
+                break;
+            default:
+                break;
+        }
+        break;
+    case IBSS_PS_DBGID_PEER_CREATE:
+        if (numargs == 2) {
+            dbglog_printf(timestamp, vap_id,
+                          "IBSS PS: peer alloc failed for peer ID:%u", args[0]);
+        } else if (numargs == 1) {
+                   dbglog_printf(timestamp, vap_id,
+                                 "IBSS PS: create peer ID=%u", args[0]);
+        }
+        break;
+    case IBSS_PS_DBGID_PEER_DELETE:
+        if (numargs == 4) {
+            dbglog_printf(timestamp, vap_id,
+                "IBSS PS: delete peer ID=%u num_peers:%d num_sleeping_peers:%d ps_enabled_for_this_peer:%d",
+                          args[0], args[1], args[2], args[3]);
+        }
+        break;
+    case IBSS_PS_DBGID_VDEV_CREATE:
+        if (numargs == 1) {
+            dbglog_printf(timestamp, vap_id,
+                          "IBSS PS: vdev alloc failed",
+                          args[0]);
+        } else if (numargs == 0) {
+                   dbglog_printf(timestamp, vap_id,
+                                 "IBSS PS: vdev created");
+        }
+        break;
+    case IBSS_PS_DBGID_VDEV_DELETE:
+        dbglog_printf(timestamp, vap_id, "IBSS PS: vdev deleted");
+        break;
+
+    case IBSS_PS_DBGID_VDEV_EVENT:
+        if (numargs == 1) {
+           if (args[0] == 5) {
+               dbglog_printf(timestamp, vap_id,
+                             "IBSS PS: vdev event for peer add");
+           } else if (args[0] == 7) {
+                      dbglog_printf(timestamp, vap_id,
+                                    "IBSS PS: vdev event for peer delete");
+            }
+            else {
+                     dbglog_printf(timestamp, vap_id,
+                                   "IBSS PS: vdev event %u", args[0]);
+            }
+        }
+        break;
+
+    case IBSS_PS_DBGID_PEER_EVENT:
+        if (numargs == 4) {
+            if (args[0] == 0xFFFF) {
+                dbglog_printf(timestamp, vap_id,
+                              "IBSS PS: pre_send for peer:%u peer_type:%u sm_event_mask:%0x",
+                              args[1], args[3], args[2]);
+            } else if (args[0] == 0x20000) {
+                dbglog_printf(timestamp, vap_id,
+                              "IBSS PS: send_complete for peer:%u peer_type:%u sm_event_mask:%0x",
+                              args[1], args[3], args[2]);
+            } else if (args[0] == 0x10) {
+                dbglog_printf(timestamp, vap_id,
+                              "IBSS PS: send_n_complete for peer:%u peer_type:%u sm_event_mask:%0x",
+                              args[1], args[3], args[2]);
+            } else if (args[0] == 0x40) {
+                dbglog_printf(timestamp, vap_id,
+                              "IBSS PS: rx event for peer:%u peer_type:%u sm_event_mask:%0x",
+                              args[1], args[3], args[2]);
+            } else if (args[0] == 0x4) {
+                dbglog_printf(timestamp, vap_id,
+                              "IBSS PS: hw_q_empty for peer:%u peer_type:%u sm_event_mask:%0x",
+                              args[1], args[3], args[2]);
+            }
+        }
+        break;
+
+    case IBSS_PS_DBGID_DELIVER_CAB:
+        if (numargs == 4) {
+            dbglog_printf(timestamp, vap_id,
+                          "IBSS PS: Deliver CAB n_mpdu:%d send_flags:%0x tid_cur:%d q_depth_for_other_tid:%d",
+                          args[0], args[1], args[2], args[3]);
+        }
+        break;
+
+    case IBSS_PS_DBGID_DELIVER_UC_DATA:
+        if (numargs == 4) {
+            dbglog_printf(timestamp, vap_id,
+                          "IBSS PS: Deliver UC data peer:%d tid:%d n_mpdu:%d send_flags:%0x",
+                          args[0], args[1], args[2], args[3]);
+        }
+        break;
+
+    case IBSS_PS_DBGID_DELIVER_UC_DATA_ERROR:
+        if (numargs == 4) {
+            dbglog_printf(timestamp, vap_id,
+                          "IBSS PS: Deliver UC data error peer:%d tid:%d allowed_tidmask:%0x, pending_tidmap:%0x",
+                          args[0], args[1], args[2], args[3]);
+        }
+        break;
+
+    case IBSS_PS_DBGID_UC_INACTIVITY_TMR_RESTART:
+        if (numargs == 2) {
+            dbglog_printf(timestamp, vap_id,
+                          "IBSS PS: UC timer restart peer:%d timer_val:%0x",
+                          args[0], args[1]);
+        }
+        break;
+
+    case IBSS_PS_DBGID_MC_INACTIVITY_TMR_RESTART:
+        if (numargs == 1) {
+            dbglog_printf(timestamp, vap_id,
+                          "IBSS PS: MC timer restart timer_val:%0x",
+                          args[0]);
+        }
+        break;
+
+    case IBSS_PS_DBGID_NULL_TX_COMPLETION:
+        if (numargs == 3) {
+            dbglog_printf(timestamp, vap_id,
+                          "IBSS PS: null tx completion peer:%d tx_completion_status:%d flags:%0x",
+                          args[0], args[1], args[2]);
+        }
+        break;
+
+    case IBSS_PS_DBGID_ATIM_TIMER_START:
+        if (numargs == 4) {
+            dbglog_printf(timestamp, vap_id,
+                          "IBSS PS: ATIM timer start tsf:%0x %0x tbtt:%0x %0x",
+                          args[0], args[1], args[2], args[3]);
+        }
+        break;
+
+    case IBSS_PS_DBGID_UC_ATIM_SEND:
+        if (numargs == 2) {
+            dbglog_printf(timestamp, vap_id,
+                          "IBSS PS: Send ATIM to peer:%d",
+                          args[1]);
+        } else if (numargs == 1) {
+                   dbglog_printf(timestamp, vap_id,
+                                 "IBSS PS: no peers to send UC ATIM",
+                                 args[1]);
+        }
+        break;
+
+    case IBSS_PS_DBGID_BC_ATIM_SEND:
+        if (numargs == 2) {
+            dbglog_printf(timestamp, vap_id,
+                          "IBSS PS: MC Data, num_of_peers:%d mc_atim_sent:%d",
+                          args[1], args[0]);
+        }
+        break;
+
+    case IBSS_PS_DBGID_UC_TIMEOUT:
+        if (numargs == 2) {
+            dbglog_printf(timestamp, vap_id,
+                          "IBSS PS: UC timeout for peer:%d send_null:%d",
+                          args[0], args[1]);
+        }
+        break;
+
+    case IBSS_PS_DBGID_PWR_COLLAPSE_ALLOWED:
+        dbglog_printf(timestamp, vap_id, "IBSS PS: allow power collapse");
+        break;
+
+    case IBSS_PS_DBGID_PWR_COLLAPSE_NOT_ALLOWED:
+        if (numargs == 0) {
+            dbglog_printf(timestamp, vap_id,
+                           "IBSS PS: power collapse not allowed by INI");
+        } else if (numargs == 3) {
+                  if (args[0] == 2) {
+                      dbglog_printf(timestamp, vap_id,
+                                    "IBSS PS: power collapse not allowed, non-zero qdepth %d %d",
+                                    args[1], args[2]);
+                  } else if (args[0] == 3) {
+                             dbglog_printf(timestamp, vap_id,
+                                           "IBSS PS: power collapse not allowed by peer:%d peer_flags:%0x",
+                                           args[1], args[2]);
+                  }
+        } else if (numargs == 5) {
+                   dbglog_printf(timestamp, vap_id,
+                                 "IBSS PS: power collapse not allowed by state m/c nw_cur_state:%d nw_next_state:%d ps_cur_state:%d flags:%0x",
+                                 args[1], args[2], args[3], args[4]);
+        }
+        break;
+
+    case IBSS_PS_DBGID_SET_PARAM:
+        if (numargs == 2) {
+            dbglog_printf(timestamp, vap_id,
+                          "IBSS PS: Set Param ID:%0x Value:%0x",
+                          args[0], args[1]);
+        }
+        break;
+
+    case IBSS_PS_DBGID_HOST_TX_PAUSE:
+        if (numargs == 1) {
+            dbglog_printf(timestamp, vap_id,
+                          "IBSS PS: Pausing host, vdev_map:%0x",
+                          args[0]);
+        }
+        break;
+
+    case IBSS_PS_DBGID_HOST_TX_UNPAUSE:
+        if (numargs == 1) {
+            dbglog_printf(timestamp, vap_id,
+                          "IBSS PS: Unpausing host, vdev_map:%0x",
+                          args[0]);
+        }
+        break;
+    case IBSS_PS_DBGID_PS_DESC_BIN_LWM:
+        if (numargs == 1) {
+            dbglog_printf(timestamp, vap_id,
+                          "IBSS PS: LWM, vdev_map:%0x",
+                          args[0]);
+        }
+        break;
+
+    case IBSS_PS_DBGID_PS_DESC_BIN_HWM:
+        if (numargs == 1) {
+            dbglog_printf(timestamp, vap_id,
+                          "IBSS PS: HWM, vdev_map:%0x",
+                          args[0]);
+        }
+        break;
+
+    case IBSS_PS_DBGID_PS_KICKOUT_PEER:
+        if (numargs == 3) {
+            dbglog_printf(timestamp, vap_id,
+                          "IBSS PS: Kickout peer id:%d atim_fail_cnt:%d status:%d",
+                          args[0], args[1], args[2]);
+        }
+        break;
+
+    default:
+        return FALSE;
+    }
+
+    return TRUE;
+}
 
 A_BOOL dbglog_ratectrl_print_handler(
         A_UINT32 mod_id,
@@ -3490,6 +3847,8 @@ dbglog_init(wmi_unified_t wmi_handle)
     dbglog_reg_modprint(WLAN_MODULE_STA_SMPS, dbglog_smps_print_handler);
     dbglog_reg_modprint(WLAN_MODULE_P2P, dbglog_p2p_print_handler);
     dbglog_reg_modprint(WLAN_MODULE_PCIELP, dbglog_pcielp_print_handler);
+    dbglog_reg_modprint(WLAN_MODULE_IBSS_PWRSAVE,
+                        dbglog_ibss_powersave_print_handler);
 
     /* Register handler for F3 or debug messages */
     res = wmi_unified_register_event_handler(wmi_handle, WMI_DEBUG_MESG_EVENTID,