diff --git a/os_if/linux/spectral/src/wlan_cfg80211_spectral.c b/os_if/linux/spectral/src/wlan_cfg80211_spectral.c
index b0fe82399f..330a1ccf7f 100644
--- a/os_if/linux/spectral/src/wlan_cfg80211_spectral.c
+++ b/os_if/linux/spectral/src/wlan_cfg80211_spectral.c
@@ -107,185 +107,6 @@ static void wlan_spectral_intit_config(struct spectral_config *config_req)
 	config_req->ss_chn_mask =        SPECTRAL_PHYERR_PARAM_NOVAL;
 }
 
-static int wlan_spectral_set_config(struct wlan_objmgr_pdev *pdev,
-				    struct spectral_config *config_req)
-{
-	int status;
-
-	status = ucfg_spectral_control(pdev,
-				       SPECTRAL_SET_CONFIG,
-				       config_req,
-				       sizeof(struct spectral_config),
-				       NULL,
-				       NULL);
-	if (status < 0)
-		return -EINVAL;
-
-	return 0;
-}
-
-static int wlan_spectral_set_debug_level(struct wlan_objmgr_pdev *pdev,
-					 uint32_t spectral_dbg_level)
-{
-	int status;
-
-	status = ucfg_spectral_control(pdev,
-				       SPECTRAL_SET_DEBUG_LEVEL,
-				       &spectral_dbg_level,
-				       sizeof(uint32_t),
-				       NULL,
-				       NULL);
-	if (status < 0)
-		return -EINVAL;
-
-	return 0;
-}
-
-static int wlan_spectral_get_debug_level(struct wlan_objmgr_pdev *pdev,
-					 uint32_t *spectral_dbg_level)
-{
-	int status;
-	uint32_t outsize;
-
-	outsize = sizeof(uint32_t);
-	status = ucfg_spectral_control(pdev,
-				       SPECTRAL_GET_DEBUG_LEVEL,
-				       NULL,
-				       0,
-				       spectral_dbg_level,
-				       &outsize);
-	if (status < 0)
-		return -EINVAL;
-
-	return 0;
-}
-
-static int wlan_spectral_get_config(struct wlan_objmgr_pdev *pdev,
-				    struct spectral_config *config_req)
-{
-	int status;
-	uint32_t outsize;
-
-	outsize = sizeof(struct spectral_config);
-	status = ucfg_spectral_control(pdev,
-				       SPECTRAL_GET_CONFIG,
-				       NULL,
-				       0,
-				       config_req,
-				       &outsize);
-	if (status < 0)
-		return -EINVAL;
-
-	return 0;
-}
-
-static int wlan_spectral_get_cap(struct wlan_objmgr_pdev *pdev,
-				 struct spectral_caps *spectral_cap)
-{
-	int status;
-	uint32_t outsize;
-
-	outsize = sizeof(struct spectral_caps);
-	status = ucfg_spectral_control(pdev,
-				       SPECTRAL_GET_CAPABILITY_INFO,
-				       NULL,
-				       0,
-				       spectral_cap,
-				       &outsize);
-	if (status < 0)
-		return -EINVAL;
-
-	return 0;
-}
-
-static int wlan_spectral_get_diag_stats(
-		struct wlan_objmgr_pdev *pdev,
-		struct spectral_diag_stats *spectral_diag)
-{
-	int status;
-	uint32_t outsize;
-
-	outsize = sizeof(struct spectral_diag_stats);
-	status = ucfg_spectral_control(pdev,
-				       SPECTRAL_GET_DIAG_STATS,
-				       NULL,
-				       0,
-				       spectral_diag,
-				       &outsize);
-	if (status < 0)
-		return -EINVAL;
-
-	return 0;
-}
-
-static int wlan_spectral_scan_get_status(
-		struct wlan_objmgr_pdev *pdev,
-		struct spectral_scan_state *sscan_state)
-{
-	uint32_t is_active;
-	uint32_t is_enabled;
-	int status;
-	uint32_t outsize;
-
-	outsize = sizeof(uint32_t);
-	status = ucfg_spectral_control(pdev,
-				       SPECTRAL_IS_ACTIVE,
-				       NULL,
-				       0,
-				       &is_active,
-				       &outsize);
-	if (status < 0)
-		return -EINVAL;
-
-	sscan_state->is_active = is_active;
-
-	outsize = sizeof(uint32_t);
-	status = ucfg_spectral_control(pdev,
-				       SPECTRAL_IS_ENABLED,
-				       NULL,
-				       0,
-				       &is_enabled,
-				       &outsize);
-	if (status < 0)
-		return -EINVAL;
-
-	sscan_state->is_enabled = is_enabled;
-
-	return 0;
-}
-
-static int wlan_start_spectral_scan(struct wlan_objmgr_pdev *pdev)
-{
-	int status;
-
-	status = ucfg_spectral_control(pdev,
-				       SPECTRAL_ACTIVATE_SCAN,
-				       NULL,
-				       0,
-				       NULL,
-				       NULL);
-	if (status < 0)
-		return -EINVAL;
-
-	return 0;
-}
-
-static int wlan_stop_spectral_scan(struct wlan_objmgr_pdev *pdev)
-{
-	int status;
-
-	status = ucfg_spectral_control(pdev,
-				       SPECTRAL_STOP_SCAN,
-				       NULL,
-				       0,
-				       NULL,
-				       NULL);
-	if (status < 0)
-		return -EINVAL;
-
-	return 0;
-}
-
 int wlan_cfg80211_spectral_scan_config_and_start(struct wiphy *wiphy,
 						 struct wlan_objmgr_pdev *pdev,
 						 const void *data,
@@ -298,6 +119,8 @@ int wlan_cfg80211_spectral_scan_config_and_start(struct wiphy *wiphy,
 	struct sk_buff *skb;
 	uint32_t spectral_dbg_level;
 	uint32_t scan_req_type = 0;
+	struct spectral_cp_request sscan_req;
+	enum spectral_scan_mode sscan_mode = SPECTRAL_SCAN_MODE_NORMAL;
 
 	if (wlan_cfg80211_nla_parse(
 			tb,
@@ -394,9 +217,11 @@ int wlan_cfg80211_spectral_scan_config_and_start(struct wiphy *wiphy,
 	if (tb[QCA_WLAN_VENDOR_ATTR_SPECTRAL_SCAN_CONFIG_DEBUG_LEVEL]) {
 		spectral_dbg_level = nla_get_u32(tb
 		   [QCA_WLAN_VENDOR_ATTR_SPECTRAL_SCAN_CONFIG_DEBUG_LEVEL]);
-		status = wlan_spectral_set_debug_level(pdev,
-						       spectral_dbg_level);
-		if (QDF_STATUS_SUCCESS != status)
+		sscan_req.ss_mode = sscan_mode;
+		sscan_req.debug_req.spectral_dbg_level = spectral_dbg_level;
+		sscan_req.req_id = SPECTRAL_SET_DEBUG_LEVEL;
+		status = ucfg_spectral_control(pdev, &sscan_req);
+		if (QDF_IS_STATUS_ERROR(status))
 			return -EINVAL;
 	}
 
@@ -405,14 +230,21 @@ int wlan_cfg80211_spectral_scan_config_and_start(struct wiphy *wiphy,
 		   [QCA_WLAN_VENDOR_ATTR_SPECTRAL_SCAN_REQUEST_TYPE]);
 
 	if (CONFIG_REQUESTED(scan_req_type)) {
-		status = wlan_spectral_set_config(pdev, &config_req);
-		if (QDF_STATUS_SUCCESS != status)
+		sscan_req.ss_mode = sscan_mode;
+		sscan_req.req_id = SPECTRAL_SET_CONFIG;
+		qdf_mem_copy(&sscan_req.config_req.sscan_config, &config_req,
+			     qdf_min(sizeof(sscan_req.config_req.sscan_config),
+				     sizeof(config_req)));
+		status = ucfg_spectral_control(pdev, &sscan_req);
+		if (QDF_IS_STATUS_ERROR(status))
 			return -EINVAL;
 	}
 
 	if (SCAN_REQUESTED(scan_req_type)) {
-		status = wlan_start_spectral_scan(pdev);
-		if (QDF_STATUS_SUCCESS != status)
+		sscan_req.ss_mode = sscan_mode;
+		sscan_req.req_id = SPECTRAL_ACTIVATE_SCAN;
+		status = ucfg_spectral_control(pdev, &sscan_req);
+		if (QDF_IS_STATUS_ERROR(status))
 			return -EINVAL;
 	}
 
@@ -442,10 +274,15 @@ int wlan_cfg80211_spectral_scan_stop(struct wiphy *wiphy,
 				     int data_len)
 {
 	QDF_STATUS status;
+	struct spectral_cp_request sscan_req;
+	enum spectral_scan_mode sscan_mode = SPECTRAL_SCAN_MODE_NORMAL;
 
-	status = wlan_stop_spectral_scan(pdev);
-	if (QDF_STATUS_SUCCESS != status)
+	sscan_req.ss_mode = sscan_mode;
+	sscan_req.req_id = SPECTRAL_STOP_SCAN;
+	status = ucfg_spectral_control(pdev, &sscan_req);
+	if (QDF_IS_STATUS_ERROR(status))
 		return -EINVAL;
+
 	return 0;
 }
 
@@ -454,12 +291,14 @@ int wlan_cfg80211_spectral_scan_get_config(struct wiphy *wiphy,
 					   const void *data,
 					   int data_len)
 {
-	struct spectral_config config_buf;
+	struct spectral_config *sconfig;
 	uint32_t spectral_dbg_level;
 	struct sk_buff *skb;
+	struct spectral_cp_request sscan_req;
+	enum spectral_scan_mode sscan_mode = SPECTRAL_SCAN_MODE_NORMAL;
+	QDF_STATUS status;
+
 
-	wlan_spectral_get_config(pdev, &config_buf);
-	wlan_spectral_get_debug_level(pdev, &spectral_dbg_level);
 
 	skb = cfg80211_vendor_cmd_alloc_reply_skb(wiphy, (21 * sizeof(u32)) +
 		NLA_HDRLEN + NLMSG_HDRLEN);
@@ -468,68 +307,80 @@ int wlan_cfg80211_spectral_scan_get_config(struct wiphy *wiphy,
 		return -ENOMEM;
 	}
 
+	sscan_req.ss_mode = sscan_mode;
+	sscan_req.req_id = SPECTRAL_GET_CONFIG;
+	status = ucfg_spectral_control(pdev, &sscan_req);
+	sconfig = &sscan_req.config_req.sscan_config;
 	if (nla_put_u32(skb,
 			QCA_WLAN_VENDOR_ATTR_SPECTRAL_SCAN_CONFIG_SCAN_COUNT,
-			config_buf.ss_count) ||
+			sconfig->ss_count) ||
 	    nla_put_u32(skb,
 			QCA_WLAN_VENDOR_ATTR_SPECTRAL_SCAN_CONFIG_SCAN_PERIOD,
-			config_buf.ss_period) ||
+			sconfig->ss_period) ||
 	    nla_put_u32(skb,
 			QCA_WLAN_VENDOR_ATTR_SPECTRAL_SCAN_CONFIG_PRIORITY,
-			config_buf.ss_spectral_pri) ||
+			sconfig->ss_spectral_pri) ||
 	    nla_put_u32(skb,
 			QCA_WLAN_VENDOR_ATTR_SPECTRAL_SCAN_CONFIG_FFT_SIZE,
-			config_buf.ss_fft_size) ||
+			sconfig->ss_fft_size) ||
 	    nla_put_u32(skb,
 			QCA_WLAN_VENDOR_ATTR_SPECTRAL_SCAN_CONFIG_GC_ENA,
-			config_buf.ss_gc_ena) ||
+			sconfig->ss_gc_ena) ||
 	    nla_put_u32(skb,
 			QCA_WLAN_VENDOR_ATTR_SPECTRAL_SCAN_CONFIG_RESTART_ENA,
-			config_buf.ss_restart_ena) ||
+			sconfig->ss_restart_ena) ||
 	    nla_put_u32(
 		skb,
 		QCA_WLAN_VENDOR_ATTR_SPECTRAL_SCAN_CONFIG_NOISE_FLOOR_REF,
-		config_buf.ss_noise_floor_ref) ||
+		sconfig->ss_noise_floor_ref) ||
 	    nla_put_u32(skb,
 			QCA_WLAN_VENDOR_ATTR_SPECTRAL_SCAN_CONFIG_INIT_DELAY,
-			config_buf.ss_init_delay) ||
+			sconfig->ss_init_delay) ||
 	    nla_put_u32(skb,
 			QCA_WLAN_VENDOR_ATTR_SPECTRAL_SCAN_CONFIG_NB_TONE_THR,
-			config_buf.ss_nb_tone_thr) ||
+			sconfig->ss_nb_tone_thr) ||
 	    nla_put_u32(skb,
 			QCA_WLAN_VENDOR_ATTR_SPECTRAL_SCAN_CONFIG_STR_BIN_THR,
-			config_buf.ss_str_bin_thr) ||
+			sconfig->ss_str_bin_thr) ||
 	    nla_put_u32(skb,
 			QCA_WLAN_VENDOR_ATTR_SPECTRAL_SCAN_CONFIG_WB_RPT_MODE,
-			config_buf.ss_wb_rpt_mode) ||
+			sconfig->ss_wb_rpt_mode) ||
 	    nla_put_u32(skb,
 			QCA_WLAN_VENDOR_ATTR_SPECTRAL_SCAN_CONFIG_RSSI_RPT_MODE,
-			config_buf.ss_rssi_rpt_mode) ||
+			sconfig->ss_rssi_rpt_mode) ||
 	    nla_put_u32(skb,
 			QCA_WLAN_VENDOR_ATTR_SPECTRAL_SCAN_CONFIG_RSSI_THR,
-			config_buf.ss_rssi_thr) ||
+			sconfig->ss_rssi_thr) ||
 	    nla_put_u32(skb,
 			QCA_WLAN_VENDOR_ATTR_SPECTRAL_SCAN_CONFIG_PWR_FORMAT,
-			config_buf.ss_pwr_format) ||
+			sconfig->ss_pwr_format) ||
 	    nla_put_u32(skb,
 			QCA_WLAN_VENDOR_ATTR_SPECTRAL_SCAN_CONFIG_RPT_MODE,
-			config_buf.ss_rpt_mode) ||
+			sconfig->ss_rpt_mode) ||
 	    nla_put_u32(skb,
 			QCA_WLAN_VENDOR_ATTR_SPECTRAL_SCAN_CONFIG_BIN_SCALE,
-			config_buf.ss_bin_scale) ||
+			sconfig->ss_bin_scale) ||
 	    nla_put_u32(skb,
 			QCA_WLAN_VENDOR_ATTR_SPECTRAL_SCAN_CONFIG_DBM_ADJ,
-			config_buf.ss_dbm_adj) ||
+			sconfig->ss_dbm_adj) ||
 	    nla_put_u32(skb,
 			QCA_WLAN_VENDOR_ATTR_SPECTRAL_SCAN_CONFIG_CHN_MASK,
-			config_buf.ss_chn_mask) ||
+			sconfig->ss_chn_mask) ||
 	    nla_put_u32(skb,
 			QCA_WLAN_VENDOR_ATTR_SPECTRAL_SCAN_CONFIG_FFT_PERIOD,
-			config_buf.ss_fft_period) ||
+			sconfig->ss_fft_period) ||
 	    nla_put_u32(skb,
 			QCA_WLAN_VENDOR_ATTR_SPECTRAL_SCAN_CONFIG_SHORT_REPORT,
-			config_buf.ss_short_report) ||
-	    nla_put_u32(skb,
+			sconfig->ss_short_report)) {
+		kfree_skb(skb);
+		return -EINVAL;
+	}
+
+	sscan_req.ss_mode = sscan_mode;
+	sscan_req.req_id = SPECTRAL_GET_DEBUG_LEVEL;
+	status = ucfg_spectral_control(pdev, &sscan_req);
+	spectral_dbg_level = sscan_req.debug_req.spectral_dbg_level;
+	if (nla_put_u32(skb,
 			QCA_WLAN_VENDOR_ATTR_SPECTRAL_SCAN_CONFIG_DEBUG_LEVEL,
 			spectral_dbg_level)) {
 		kfree_skb(skb);
@@ -545,10 +396,16 @@ int wlan_cfg80211_spectral_scan_get_cap(struct wiphy *wiphy,
 					const void *data,
 					int data_len)
 {
-	struct spectral_caps spectral_cap;
+	struct spectral_caps *scaps;
 	struct sk_buff *skb;
+	struct spectral_cp_request sscan_req;
+	enum spectral_scan_mode sscan_mode = SPECTRAL_SCAN_MODE_NORMAL;
+	QDF_STATUS status;
 
-	wlan_spectral_get_cap(pdev, &spectral_cap);
+	sscan_req.ss_mode = sscan_mode;
+	sscan_req.req_id = SPECTRAL_GET_CAPABILITY_INFO;
+	status = ucfg_spectral_control(pdev, &sscan_req);
+	scaps = &sscan_req.caps_req.sscan_caps;
 
 	skb = cfg80211_vendor_cmd_alloc_reply_skb(wiphy, 10 * sizeof(u32) +
 		NLA_HDRLEN + NLMSG_HDRLEN);
@@ -557,24 +414,24 @@ int wlan_cfg80211_spectral_scan_get_cap(struct wiphy *wiphy,
 		return -ENOMEM;
 	}
 
-	if (spectral_cap.phydiag_cap)
+	if (scaps->phydiag_cap)
 		if (nla_put_flag(
 			skb,
 			QCA_WLAN_VENDOR_ATTR_SPECTRAL_SCAN_CAP_PHYDIAG))
 			goto fail;
 
-	if (spectral_cap.radar_cap)
+	if (scaps->radar_cap)
 		if (nla_put_flag(skb,
 				 QCA_WLAN_VENDOR_ATTR_SPECTRAL_SCAN_CAP_RADAR))
 			goto fail;
 
-	if (spectral_cap.spectral_cap)
+	if (scaps->spectral_cap)
 		if (nla_put_flag(
 			skb,
 			QCA_WLAN_VENDOR_ATTR_SPECTRAL_SCAN_CAP_SPECTRAL))
 			goto fail;
 
-	if (spectral_cap.advncd_spectral_cap)
+	if (scaps->advncd_spectral_cap)
 		if (nla_put_flag(
 		skb,
 		QCA_WLAN_VENDOR_ATTR_SPECTRAL_SCAN_CAP_ADVANCED_SPECTRAL))
@@ -582,38 +439,38 @@ int wlan_cfg80211_spectral_scan_get_cap(struct wiphy *wiphy,
 
 	if (nla_put_u32(skb,
 			QCA_WLAN_VENDOR_ATTR_SPECTRAL_SCAN_CAP_HW_GEN,
-			spectral_cap.hw_gen))
+			scaps->hw_gen))
 		goto fail;
 
-	if (spectral_cap.is_scaling_params_populated) {
+	if (scaps->is_scaling_params_populated) {
 		if (nla_put_u16(
 			skb,
 			QCA_WLAN_VENDOR_ATTR_SPECTRAL_SCAN_CAP_FORMULA_ID,
-			spectral_cap.formula_id))
+			scaps->formula_id))
 			goto fail;
 
 		if (nla_put_u16(
 			skb,
 			QCA_WLAN_VENDOR_ATTR_SPECTRAL_SCAN_CAP_LOW_LEVEL_OFFSET,
-			spectral_cap.low_level_offset))
+			scaps->low_level_offset))
 			goto fail;
 
 		if (nla_put_u16(
 		       skb,
 		       QCA_WLAN_VENDOR_ATTR_SPECTRAL_SCAN_CAP_HIGH_LEVEL_OFFSET,
-		       spectral_cap.high_level_offset))
+		       scaps->high_level_offset))
 			goto fail;
 
 		if (nla_put_u16(
 			skb,
 			QCA_WLAN_VENDOR_ATTR_SPECTRAL_SCAN_CAP_RSSI_THR,
-			spectral_cap.rssi_thr))
+			scaps->rssi_thr))
 			goto fail;
 
 		if (nla_put_u8(
 		    skb,
 		    QCA_WLAN_VENDOR_ATTR_SPECTRAL_SCAN_CAP_DEFAULT_AGC_MAX_GAIN,
-		    spectral_cap.default_agc_max_gain))
+		    scaps->default_agc_max_gain))
 			goto fail;
 	}
 
@@ -631,10 +488,16 @@ int wlan_cfg80211_spectral_scan_get_diag_stats(struct wiphy *wiphy,
 					       const void *data,
 					       int data_len)
 {
-	struct spectral_diag_stats spetcral_diag;
+	struct spectral_diag_stats *spetcral_diag;
 	struct sk_buff *skb;
+	struct spectral_cp_request sscan_req;
+	enum spectral_scan_mode sscan_mode = SPECTRAL_SCAN_MODE_NORMAL;
+	QDF_STATUS status;
 
-	wlan_spectral_get_diag_stats(pdev, &spetcral_diag);
+	sscan_req.ss_mode = sscan_mode;
+	sscan_req.req_id = SPECTRAL_GET_DIAG_STATS;
+	status = ucfg_spectral_control(pdev, &sscan_req);
+	spetcral_diag = &sscan_req.diag_req.sscan_diag;
 
 	skb = cfg80211_vendor_cmd_alloc_reply_skb(wiphy, 5 * sizeof(u64) +
 		NLA_HDRLEN + NLMSG_HDRLEN);
@@ -646,23 +509,23 @@ int wlan_cfg80211_spectral_scan_get_diag_stats(struct wiphy *wiphy,
 	if (wlan_cfg80211_nla_put_u64(
 		skb,
 		QCA_WLAN_VENDOR_ATTR_SPECTRAL_SCAN_DIAG_SIG_MISMATCH,
-		spetcral_diag.spectral_mismatch) ||
+		spetcral_diag->spectral_mismatch) ||
 	    wlan_cfg80211_nla_put_u64(
 		skb,
 		QCA_WLAN_VENDOR_ATTR_SPECTRAL_SCAN_DIAG_SEC80_SFFT_INSUFFLEN,
-		spetcral_diag.spectral_sec80_sfft_insufflen) ||
+		spetcral_diag->spectral_sec80_sfft_insufflen) ||
 	    wlan_cfg80211_nla_put_u64(
 		skb,
 		QCA_WLAN_VENDOR_ATTR_SPECTRAL_SCAN_DIAG_NOSEC80_SFFT,
-		spetcral_diag.spectral_no_sec80_sfft) ||
+		spetcral_diag->spectral_no_sec80_sfft) ||
 	    wlan_cfg80211_nla_put_u64(
 		skb,
 		QCA_WLAN_VENDOR_ATTR_SPECTRAL_SCAN_DIAG_VHTSEG1ID_MISMATCH,
-		spetcral_diag.spectral_vhtseg1id_mismatch) ||
+		spetcral_diag->spectral_vhtseg1id_mismatch) ||
 	    wlan_cfg80211_nla_put_u64(
 		skb,
 		QCA_WLAN_VENDOR_ATTR_SPECTRAL_SCAN_DIAG_VHTSEG2ID_MISMATCH,
-		spetcral_diag.spectral_vhtseg2id_mismatch)) {
+		spetcral_diag->spectral_vhtseg2id_mismatch)) {
 		kfree_skb(skb);
 		return -EINVAL;
 	}
@@ -678,6 +541,9 @@ int wlan_cfg80211_spectral_scan_get_status(struct wiphy *wiphy,
 {
 	struct spectral_scan_state sscan_state = { 0 };
 	struct sk_buff *skb;
+	struct spectral_cp_request sscan_req;
+	enum spectral_scan_mode sscan_mode = SPECTRAL_SCAN_MODE_NORMAL;
+	QDF_STATUS status;
 
 	skb = cfg80211_vendor_cmd_alloc_reply_skb(wiphy, 2 * sizeof(u32) +
 		NLA_HDRLEN + NLMSG_HDRLEN);
@@ -686,7 +552,16 @@ int wlan_cfg80211_spectral_scan_get_status(struct wiphy *wiphy,
 		return -ENOMEM;
 	}
 
-	wlan_spectral_scan_get_status(pdev, &sscan_state);
+	/* Sending a request and extracting response from it has to be atomic */
+	sscan_req.ss_mode = sscan_mode;
+	sscan_req.req_id = SPECTRAL_IS_ACTIVE;
+	status = ucfg_spectral_control(pdev, &sscan_req);
+	sscan_state.is_active = sscan_req.status_req.is_active;
+
+	sscan_req.ss_mode = sscan_mode;
+	sscan_req.req_id = SPECTRAL_IS_ENABLED;
+	status = ucfg_spectral_control(pdev, &sscan_req);
+	sscan_state.is_enabled = sscan_req.status_req.is_enabled;
 
 	if (sscan_state.is_enabled)
 		if (nla_put_flag(
diff --git a/spectral/core/spectral_cmn_api_i.h b/spectral/core/spectral_cmn_api_i.h
index ed66871d52..a4dd515981 100644
--- a/spectral/core/spectral_cmn_api_i.h
+++ b/spectral/core/spectral_cmn_api_i.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2018 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2017-2019 The Linux Foundation. All rights reserved.
  *
  *
  * Permission to use, copy, modify, and/or distribute this software for
@@ -85,12 +85,8 @@ QDF_STATUS wlan_spectral_pdev_obj_destroy_handler(struct wlan_objmgr_pdev *pdev,
 /**
  * spectral_control_cmn()- common handler for demultiplexing requests from
  *                         higher layer
- * @pdev:    reference to global pdev object
- * @id:      spectral config command id
- * @indata:  reference to input data
- * @insize:  input data size
- * @outdata: reference to output data
- * @outsize: reference to output data size
+ * @pdev:      reference to global pdev object
+ * @sscan_req: pointer to Spectral scan request
  *
  * This function processes the spectral config command
  * and appropriate handlers are invoked.
@@ -98,9 +94,7 @@ QDF_STATUS wlan_spectral_pdev_obj_destroy_handler(struct wlan_objmgr_pdev *pdev,
  * Return: 0 success else failure
  */
 int spectral_control_cmn(struct wlan_objmgr_pdev *pdev,
-			 u_int id,
-			 void *indata,
-			 uint32_t insize, void *outdata, uint32_t *outsize);
+			 struct spectral_cp_request *sscan_req);
 
 /**
  * spectral_control_ol(): Offload handler for demultiplexing requests from
diff --git a/spectral/core/spectral_common.c b/spectral/core/spectral_common.c
index 66604fd526..cfb0cfb90a 100644
--- a/spectral/core/spectral_common.c
+++ b/spectral/core/spectral_common.c
@@ -113,9 +113,7 @@ spectral_register_cfg80211_handlers(struct wlan_objmgr_pdev *pdev)
 
 int
 spectral_control_cmn(struct wlan_objmgr_pdev *pdev,
-		     u_int id,
-		     void *indata,
-		     uint32_t insize, void *outdata, uint32_t *outsize)
+		     struct spectral_cp_request *sscan_req)
 {
 	int error = 0;
 	int temp_debug;
@@ -138,15 +136,10 @@ spectral_control_cmn(struct wlan_objmgr_pdev *pdev,
 		goto bad;
 	}
 
-	switch (id) {
+	switch (sscan_req->req_id) {
 	case SPECTRAL_SET_CONFIG:
 		{
-			if (insize < sizeof(struct spectral_config) ||
-			    !indata) {
-				error = -EINVAL;
-				break;
-			}
-			sp_in = (struct spectral_config *)indata;
+			sp_in = &sscan_req->config_req.sscan_config;
 			if (sp_in->ss_count !=
 			    SPECTRAL_PHYERR_PARAM_NOVAL) {
 				if (sc->sptrlc_set_spectral_config(
@@ -345,14 +338,8 @@ spectral_control_cmn(struct wlan_objmgr_pdev *pdev,
 
 	case SPECTRAL_GET_CONFIG:
 		{
-			if (!outdata || !outsize ||
-			    (*outsize < sizeof(struct spectral_config))) {
-				error = -EINVAL;
-				break;
-			}
-			*outsize = sizeof(struct spectral_config);
 			sc->sptrlc_get_spectral_config(pdev, &sp_out);
-			spectralparams = (struct spectral_config *)outdata;
+			spectralparams = &sscan_req->config_req.sscan_config;
 			spectralparams->ss_fft_period = sp_out.ss_fft_period;
 			spectralparams->ss_period = sp_out.ss_period;
 			spectralparams->ss_count = sp_out.ss_count;
@@ -382,51 +369,29 @@ spectral_control_cmn(struct wlan_objmgr_pdev *pdev,
 
 	case SPECTRAL_IS_ACTIVE:
 		{
-			if (!outdata || !outsize ||
-			    *outsize < sizeof(uint32_t)) {
-				error = -EINVAL;
-				break;
-			}
-			*outsize = sizeof(uint32_t);
-			*((uint32_t *)outdata) =
-			    (uint32_t)sc->sptrlc_is_spectral_active(pdev);
+			sscan_req->status_req.is_active =
+				(bool)sc->sptrlc_is_spectral_active(pdev);
 		}
 		break;
 
 	case SPECTRAL_IS_ENABLED:
 		{
-			if (!outdata || !outsize ||
-			    *outsize < sizeof(uint32_t)) {
-				error = -EINVAL;
-				break;
-			}
-			*outsize = sizeof(uint32_t);
-			*((uint32_t *)outdata) =
-			    (uint32_t)sc->sptrlc_is_spectral_enabled(pdev);
+			sscan_req->status_req.is_enabled =
+				(bool)sc->sptrlc_is_spectral_enabled(pdev);
 		}
 		break;
 
 	case SPECTRAL_SET_DEBUG_LEVEL:
 		{
-			if (insize < sizeof(uint32_t) || !indata) {
-				error = -EINVAL;
-				break;
-			}
-			temp_debug = *(uint32_t *)indata;
+			temp_debug = sscan_req->debug_req.spectral_dbg_level;
 			sc->sptrlc_set_debug_level(pdev, temp_debug);
 		}
 		break;
 
 	case SPECTRAL_GET_DEBUG_LEVEL:
 		{
-			if (!outdata || !outsize ||
-			    *outsize < sizeof(uint32_t)) {
-				error = -EINVAL;
-				break;
-			}
-			*outsize = sizeof(uint32_t);
-			*((uint32_t *)outdata) =
-			    (uint32_t)sc->sptrlc_get_debug_level(pdev);
+			sscan_req->debug_req.spectral_dbg_level =
+				(uint32_t)sc->sptrlc_get_debug_level(pdev);
 		}
 		break;
 
@@ -444,25 +409,19 @@ spectral_control_cmn(struct wlan_objmgr_pdev *pdev,
 
 	case SPECTRAL_GET_CAPABILITY_INFO:
 		{
-			if (!outdata || !outsize ||
-			    *outsize < sizeof(struct spectral_caps)) {
-				error = -EINVAL;
-				break;
-			}
-			*outsize = sizeof(struct spectral_caps);
-			sc->sptrlc_get_spectral_capinfo(pdev, outdata);
+			struct spectral_caps *caps;
+
+			caps  = &sscan_req->caps_req.sscan_caps;
+			sc->sptrlc_get_spectral_capinfo(pdev, caps);
 		}
 		break;
 
 	case SPECTRAL_GET_DIAG_STATS:
 		{
-			if (!outdata || !outsize ||
-			    (*outsize < sizeof(struct spectral_diag_stats))) {
-				error = -EINVAL;
-				break;
-			}
-			*outsize = sizeof(struct spectral_diag_stats);
-			sc->sptrlc_get_spectral_diagstats(pdev, outdata);
+			struct spectral_diag_stats *diag;
+
+			diag  = &sscan_req->diag_req.sscan_diag;
+			sc->sptrlc_get_spectral_diagstats(pdev, diag);
 		}
 		break;
 
@@ -477,13 +436,8 @@ spectral_control_cmn(struct wlan_objmgr_pdev *pdev,
 			chan_width = spectral_vdev_get_ch_width(vdev);
 			wlan_objmgr_vdev_release_ref(vdev, WLAN_SPECTRAL_ID);
 
-			if (!outdata || !outsize ||
-			    *outsize < sizeof(chan_width)) {
-				error = -EINVAL;
-				break;
-			}
-			*outsize = sizeof(chan_width);
-			*((uint32_t *)outdata) = (uint32_t)chan_width;
+			sscan_req->chan_width_req.chan_width =
+							(uint32_t)chan_width;
 		}
 		break;
 
diff --git a/spectral/core/spectral_defs_i.h b/spectral/core/spectral_defs_i.h
index a90df27f9d..1867352d5a 100644
--- a/spectral/core/spectral_defs_i.h
+++ b/spectral/core/spectral_defs_i.h
@@ -123,9 +123,7 @@ struct spectral_context {
 	struct wlan_objmgr_psoc *psoc_obj;
 	struct spectral_legacy_cbacks legacy_cbacks;
 	int (*sptrlc_spectral_control)(struct wlan_objmgr_pdev *pdev,
-				       u_int id, void *indata,
-				       uint32_t insize, void *outdata,
-				       uint32_t *outsize);
+				       struct spectral_cp_request *sscan_req);
 	int (*sptrlc_ucfg_phyerr_config)(struct wlan_objmgr_pdev *pdev,
 					 void *ad);
 	void * (*sptrlc_pdev_spectral_init)(struct wlan_objmgr_pdev *pdev);
diff --git a/spectral/dispatcher/inc/wlan_spectral_public_structs.h b/spectral/dispatcher/inc/wlan_spectral_public_structs.h
index f12f3537ca..ffa053b188 100644
--- a/spectral/dispatcher/inc/wlan_spectral_public_structs.h
+++ b/spectral/dispatcher/inc/wlan_spectral_public_structs.h
@@ -187,6 +187,20 @@ enum spectral_capability_type {
 	SPECTRAL_CAP_ADVNCD_SPECTRAL_SCAN,
 };
 
+/**
+ * enum spectral_cp_error_code - Spectral control path response code
+ * @SPECTRAL_SCAN_RESP_ERR_PARAM_UNSUPPORTED: parameter unsupported
+ * @SPECTRAL_SCAN_RESP_ERR_MODE_UNSUPPORTED: mode unsupported
+ * @SPECTRAL_SCAN_RESP_ERR_PARAM_INVALID_VALUE: invalid parameter value
+ * @SPECTRAL_SCAN_RESP_ERR_PARAM_NOT_INITIALIZED: parameter uninitialized
+ */
+enum spectral_cp_error_code {
+	SPECTRAL_SCAN_ERR_PARAM_UNSUPPORTED,
+	SPECTRAL_SCAN_ERR_MODE_UNSUPPORTED,
+	SPECTRAL_SCAN_ERR_PARAM_INVALID_VALUE,
+	SPECTRAL_SCAN_ERR_PARAM_NOT_INITIALIZED,
+};
+
 /**
  * struct spectral_chan_stats - channel status info
  * @cycle_count:         Cycle count
@@ -257,6 +271,97 @@ struct spectral_nl_cb {
 	void (*free_nbuff)(struct wlan_objmgr_pdev *pdev);
 };
 
+/**
+ * struct spectral_scan_config_request - Config request
+ * @sscan_config: Spectral parameters
+ * @sscan_err_code: Spectral scan error code
+ */
+struct spectral_scan_config_request {
+	struct spectral_config sscan_config;
+	enum spectral_cp_error_code sscan_err_code;
+};
+
+/**
+ * struct spectral_scan_action_request - Action request
+ * @sscan_err_code: Spectral scan error code
+ */
+struct spectral_scan_action_request {
+	enum spectral_cp_error_code sscan_err_code;
+};
+
+/**
+ * struct spectral_scan_get_caps_request - Get caps request
+ * @sscan_caps: Spectral capabilities
+ * @sscan_err_code: Spectral scan error code
+ */
+struct spectral_scan_get_caps_request {
+	struct spectral_caps sscan_caps;
+	enum spectral_cp_error_code sscan_err_code;
+};
+
+/**
+ * struct spectral_scan_get_diag_request - Get diag request
+ * @sscan_diag: Spectral diag stats
+ * @sscan_err_code: Spectral scan error code
+ */
+struct spectral_scan_get_diag_request {
+	struct spectral_diag_stats sscan_diag;
+	enum spectral_cp_error_code sscan_err_code;
+};
+
+/**
+ * struct spectral_scan_get_chan_width_request - Get channel width request
+ * @chan_width: Channel width
+ * @sscan_err_code: Spectral scan error code
+ */
+struct spectral_scan_get_chan_width_request {
+	uint32_t chan_width;
+	enum spectral_cp_error_code sscan_err_code;
+};
+
+/**
+ * struct spectral_scan_get_status_request - Get status request
+ * @is_active: is Spectral scan active
+ * @is_enabled: is Spectral scan enabled
+ * @sscan_err_code: Spectral scan error code
+ */
+struct spectral_scan_get_status_request {
+	bool is_active;
+	bool is_enabled;
+	enum spectral_cp_error_code sscan_err_code;
+};
+
+/**
+ * struct spectral_scan_debug_request - Get/set debug level request
+ * @spectral_dbg_level: Spectral debug level
+ * @sscan_err_code: Spectral scan error code
+ */
+struct spectral_scan_debug_request {
+	uint32_t spectral_dbg_level;
+	enum spectral_cp_error_code sscan_err_code;
+};
+
+/**
+ * struct spectral_cp_request - Spectral control path request
+ *                              Creating request and extracting response has to
+ *                              be atomic.
+ * @ss_mode: Spectral scan mode
+ * @req_id: Request identifier
+ */
+struct spectral_cp_request {
+	enum spectral_scan_mode ss_mode;
+	uint8_t req_id;
+	union {
+		struct spectral_scan_config_request config_req;
+		struct spectral_scan_action_request action_req;
+		struct spectral_scan_get_caps_request caps_req;
+		struct spectral_scan_get_diag_request diag_req;
+		struct spectral_scan_get_chan_width_request chan_width_req;
+		struct spectral_scan_get_status_request status_req;
+		struct spectral_scan_debug_request debug_req;
+	};
+};
+
 #ifndef __KERNEL__
 
 static inline int16_t
diff --git a/spectral/dispatcher/inc/wlan_spectral_tgt_api.h b/spectral/dispatcher/inc/wlan_spectral_tgt_api.h
index ba3b33ef18..3e9af9dc84 100644
--- a/spectral/dispatcher/inc/wlan_spectral_tgt_api.h
+++ b/spectral/dispatcher/inc/wlan_spectral_tgt_api.h
@@ -37,12 +37,8 @@ void *tgt_get_target_handle(struct wlan_objmgr_pdev *pdev);
 
 /**
  * tgt_spectral_control()- handler for demultiplexing requests from higher layer
- * @pdev:    reference to global pdev object
- * @id:      spectral config command id
- * @indata:  reference to input data
- * @insize:  input data size
- * @outdata: reference to output data
- * @outsize: output data size
+ * @pdev:      reference to global pdev object
+ * @sscan_req: pointer to Spectral scan request
  *
  * This function processes the spectral config command
  * and appropriate handlers are invoked.
@@ -50,8 +46,7 @@ void *tgt_get_target_handle(struct wlan_objmgr_pdev *pdev);
  * Return: 0 success else failure
  */
 int tgt_spectral_control(struct wlan_objmgr_pdev *pdev,
-			 u_int id, void *indata, u_int32_t insize,
-			 void *outdata, u_int32_t *outsize);
+			 struct spectral_cp_request *sscan_req);
 
 /**
  * tgt_pdev_spectral_init() - implementation for spectral init
diff --git a/spectral/dispatcher/inc/wlan_spectral_ucfg_api.h b/spectral/dispatcher/inc/wlan_spectral_ucfg_api.h
index 264cce0b6f..66128b5ec1 100644
--- a/spectral/dispatcher/inc/wlan_spectral_ucfg_api.h
+++ b/spectral/dispatcher/inc/wlan_spectral_ucfg_api.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2018 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2017-2019 The Linux Foundation. All rights reserved.
  *
  *
  * Permission to use, copy, modify, and/or distribute this software for
@@ -28,20 +28,14 @@
 /**
  * ucfg_spectral_control() - Carry out Spectral control operations
  * @pdev: Pointer to pdev
- * @id: Spectral operation ID
- * @indata: Pointer to input data
- * @insize: Size of indata buffer
- * @outdata: Pointer to buffer where the output should be stored
- * @outsize: Size of outdata buffer
+ * @sscan_req: spectral related control request
  *
  * Carry out Spectral specific UCFG control get/set operations
  *
  * Return: 0 on success, negative value on failure
  */
-int ucfg_spectral_control(struct wlan_objmgr_pdev *pdev,
-			  u_int id,
-			  void *indata,
-			  uint32_t insize, void *outdata, uint32_t *outsize);
+QDF_STATUS ucfg_spectral_control(struct wlan_objmgr_pdev *pdev,
+				 struct spectral_cp_request *sscan_req);
 
 /**
  * ucfg_spectral_scan_set_ppid() - configure pid of spectral tool
@@ -55,4 +49,29 @@ int ucfg_spectral_control(struct wlan_objmgr_pdev *pdev,
 void ucfg_spectral_scan_set_ppid(struct wlan_objmgr_pdev *pdev,
 					uint32_t ppid);
 
+/**
+ * ucfg_spectral_create_cp_req() - Create Spectral control path request
+ * @sscan_req: Pointer to Spectral scan request
+ * @indata: pointer input data
+ * @insize: Size of input data
+ *
+ * Create Spectral control path request structure
+ *
+ * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_FAILURE on failure
+ */
+QDF_STATUS ucfg_spectral_create_cp_req(struct spectral_cp_request *sscan_req,
+				       void *indata, u_int32_t insize);
+
+/**
+ * ucfg_spectral_create_cp_req() - Extract response from Spectral CP request
+ * @sscan_req: Pointer to Spectral scan request
+ * @outdata: pointer output data
+ * @outsize: Size of output data
+ *
+ * Extract response from Spectral control path request
+ *
+ * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_FAILURE on failure
+ */
+QDF_STATUS ucfg_spectral_extract_response(struct spectral_cp_request *sscan_req,
+					  void *outdata, u_int32_t *outsize);
 #endif /* _WLAN_SPECTRAL_UCFG_API_H_ */
diff --git a/spectral/dispatcher/src/wlan_spectral_tgt_api.c b/spectral/dispatcher/src/wlan_spectral_tgt_api.c
index 48b0a2426f..4649b0985e 100644
--- a/spectral/dispatcher/src/wlan_spectral_tgt_api.c
+++ b/spectral/dispatcher/src/wlan_spectral_tgt_api.c
@@ -49,9 +49,7 @@ tgt_get_target_handle(struct wlan_objmgr_pdev *pdev)
 int
 tgt_spectral_control(
 	struct wlan_objmgr_pdev *pdev,
-	u_int id,
-	void *indata,
-	u_int32_t insize, void *outdata, u_int32_t *outsize)
+	struct spectral_cp_request *sscan_req)
 {
 	struct spectral_context *sc;
 
@@ -64,7 +62,7 @@ tgt_spectral_control(
 		spectral_err("spectral context is NULL!");
 		return -EPERM;
 	}
-	return spectral_control_cmn(pdev, id, indata, insize, outdata, outsize);
+	return spectral_control_cmn(pdev, sscan_req);
 }
 
 void *
diff --git a/spectral/dispatcher/src/wlan_spectral_ucfg_api.c b/spectral/dispatcher/src/wlan_spectral_ucfg_api.c
index 017e433140..eefe2bea60 100644
--- a/spectral/dispatcher/src/wlan_spectral_ucfg_api.c
+++ b/spectral/dispatcher/src/wlan_spectral_ucfg_api.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2018 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2017-2019 The Linux Foundation. All rights reserved.
  *
  *
  * Permission to use, copy, modify, and/or distribute this software for
@@ -23,11 +23,9 @@
 #include <qdf_module.h>
 #include <cfg_ucfg_api.h>
 
-int
+QDF_STATUS
 ucfg_spectral_control(struct wlan_objmgr_pdev *pdev,
-		      u_int id,
-		      void *indata,
-		      uint32_t insize, void *outdata, uint32_t *outsize)
+		      struct spectral_cp_request *sscan_req)
 {
 	struct spectral_context *sc;
 
@@ -47,9 +45,7 @@ ucfg_spectral_control(struct wlan_objmgr_pdev *pdev,
 		return -EPERM;
 	}
 
-	return sc->sptrlc_spectral_control(pdev,
-					   id,
-					   indata, insize, outdata, outsize);
+	return sc->sptrlc_spectral_control(pdev, sscan_req);
 }
 qdf_export_symbol(ucfg_spectral_control);
 
@@ -72,3 +68,152 @@ void ucfg_spectral_scan_set_ppid(struct wlan_objmgr_pdev *pdev, uint32_t ppid)
 
 	return;
 }
+
+QDF_STATUS ucfg_spectral_create_cp_req(struct spectral_cp_request *sscan_req,
+				       void *indata, u_int32_t insize)
+{
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
+
+	switch (sscan_req->req_id) {
+	case SPECTRAL_SET_CONFIG:
+		{
+			if (insize < sizeof(struct spectral_config) ||
+			    !indata) {
+				status = QDF_STATUS_E_FAILURE;
+				goto bad;
+			}
+			qdf_mem_copy(&sscan_req->config_req.sscan_config,
+				     indata,
+				     sizeof(struct spectral_config));
+		}
+		break;
+
+	case SPECTRAL_SET_DEBUG_LEVEL:
+		{
+			if (insize < sizeof(uint32_t) || !indata) {
+				status = QDF_STATUS_E_FAILURE;
+				goto bad;
+			}
+			sscan_req->debug_req.spectral_dbg_level =
+							*(uint32_t *)indata;
+		}
+		break;
+
+	default:
+		break;
+	}
+
+bad:
+	return status;
+}
+
+qdf_export_symbol(ucfg_spectral_create_cp_req);
+
+QDF_STATUS ucfg_spectral_extract_response(struct spectral_cp_request *sscan_req,
+					  void *outdata, u_int32_t *outsize)
+{
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
+
+	switch (sscan_req->req_id) {
+	case SPECTRAL_GET_CONFIG:
+		{
+			if (!outdata || !outsize ||
+			    (*outsize < sizeof(struct spectral_config))) {
+				status = QDF_STATUS_E_FAILURE;
+				goto bad;
+			}
+			*outsize = sizeof(struct spectral_config);
+			qdf_mem_copy(outdata,
+				     &sscan_req->config_req.sscan_config,
+				     sizeof(struct spectral_config));
+		}
+		break;
+
+	case SPECTRAL_IS_ACTIVE:
+		{
+			if (!outdata || !outsize ||
+			    *outsize < sizeof(uint32_t)) {
+				status = QDF_STATUS_E_FAILURE;
+				goto bad;
+			}
+			*outsize = sizeof(uint32_t);
+			*((uint32_t *)outdata) =
+				sscan_req->status_req.is_active;
+		}
+		break;
+
+	case SPECTRAL_IS_ENABLED:
+		{
+			if (!outdata || !outsize ||
+			    *outsize < sizeof(uint32_t)) {
+				status = QDF_STATUS_E_FAILURE;
+				goto bad;
+			}
+			*outsize = sizeof(uint32_t);
+			*((uint32_t *)outdata) =
+				sscan_req->status_req.is_enabled;
+		}
+		break;
+
+	case SPECTRAL_GET_DEBUG_LEVEL:
+		{
+			if (!outdata || !outsize ||
+			    *outsize < sizeof(uint32_t)) {
+				status = QDF_STATUS_E_FAILURE;
+				goto bad;
+			}
+			*outsize = sizeof(uint32_t);
+			*((uint32_t *)outdata) =
+				sscan_req->debug_req.spectral_dbg_level;
+		}
+		break;
+
+	case SPECTRAL_GET_CAPABILITY_INFO:
+		{
+			if (!outdata || !outsize ||
+			    *outsize < sizeof(struct spectral_caps)) {
+				status = QDF_STATUS_E_FAILURE;
+				goto bad;
+			}
+			*outsize = sizeof(struct spectral_caps);
+			qdf_mem_copy(outdata, &sscan_req->caps_req.sscan_caps,
+				     sizeof(struct spectral_caps));
+		}
+		break;
+
+	case SPECTRAL_GET_DIAG_STATS:
+		{
+			if (!outdata || !outsize ||
+			    (*outsize < sizeof(struct spectral_diag_stats))) {
+				status = QDF_STATUS_E_FAILURE;
+				goto bad;
+			}
+			*outsize = sizeof(struct spectral_diag_stats);
+			qdf_mem_copy(outdata, &sscan_req->diag_req.sscan_diag,
+				     sizeof(struct spectral_diag_stats));
+		}
+		break;
+
+	case SPECTRAL_GET_CHAN_WIDTH:
+		{
+			if (!outdata || !outsize ||
+			    *outsize < sizeof(uint32_t)) {
+				status = QDF_STATUS_E_FAILURE;
+				goto bad;
+			}
+			*outsize = sizeof(uint32_t);
+			*((uint32_t *)outdata) =
+				sscan_req->chan_width_req.chan_width;
+		}
+		break;
+
+	default:
+		break;
+	}
+
+bad:
+	return status;
+}
+
+qdf_export_symbol(ucfg_spectral_extract_response);
+