diff --git a/core/wma/src/wma_ocb.c b/core/wma/src/wma_ocb.c
index 818dadc61f21..624912eafc0e 100644
--- a/core/wma/src/wma_ocb.c
+++ b/core/wma/src/wma_ocb.c
@@ -232,191 +232,24 @@ static WLAN_PHY_MODE wma_ocb_freq_to_mode(uint32_t freq)
  */
 int wma_ocb_set_config(tp_wma_handle wma_handle, struct sir_ocb_config *config)
 {
-	int32_t ret;
-	wmi_ocb_set_config_cmd_fixed_param *cmd;
-	wmi_channel *chan;
-	wmi_ocb_channel *ocb_chan;
-	wmi_qos_parameter *qos_param;
-	wmi_dcc_ndl_chan *ndl_chan;
-	wmi_dcc_ndl_active_state_config *ndl_active_config;
-	wmi_ocb_schedule_element *sched_elem;
-	uint8_t *buf_ptr;
-	wmi_buf_t buf;
-	int32_t len;
-	int32_t i, j, active_state_count;
+	int32_t ret, i;
+	uint32_t *ch_mhz;
+	struct ocb_config_param tconfig = {0};
 
-	/*
-	 * Validate the dcc_ndl_chan_list_len and count the number of active
-	 * states. Validate dcc_ndl_active_state_list_len.
-	 */
-	active_state_count = 0;
-	if (config->dcc_ndl_chan_list_len) {
-		if (!config->dcc_ndl_chan_list ||
-			config->dcc_ndl_chan_list_len !=
-			config->channel_count * sizeof(wmi_dcc_ndl_chan)) {
-			WMA_LOGE(FL("NDL channel is invalid. List len: %d"),
-				 config->dcc_ndl_chan_list_len);
-			return -EINVAL;
-		}
+	tconfig.session_id = config->session_id;
+	tconfig.channel_count = config->channel_count;
+	tconfig.schedule_size = config->schedule_size;
+	tconfig.flags = config->flags;
+	tconfig.channels = (struct ocb_config_channel *)config->channels;
+	tconfig.schedule = (struct ocb_config_sched *)config->schedule;
+	tconfig.dcc_ndl_chan_list_len = config->dcc_ndl_chan_list_len;
+	tconfig.dcc_ndl_chan_list = config->dcc_ndl_chan_list;
+	tconfig.dcc_ndl_active_state_list_len = config->dcc_ndl_active_state_list_len;
+	tconfig.dcc_ndl_active_state_list = config->dcc_ndl_active_state_list;
+	ch_mhz = qdf_mem_malloc(sizeof(uint32_t)*config->channel_count);
 
-		for (i = 0, ndl_chan = config->dcc_ndl_chan_list;
-				i < config->channel_count; ++i, ++ndl_chan)
-			active_state_count +=
-				WMI_NDL_NUM_ACTIVE_STATE_GET(ndl_chan);
-
-		if (active_state_count) {
-			if (!config->dcc_ndl_active_state_list ||
-				config->dcc_ndl_active_state_list_len !=
-				active_state_count *
-				sizeof(wmi_dcc_ndl_active_state_config)) {
-				WMA_LOGE(FL("NDL active state is invalid."));
-				return -EINVAL;
-			}
-		}
-	}
-
-	len = sizeof(*cmd) +
-		WMI_TLV_HDR_SIZE + config->channel_count *
-			sizeof(wmi_channel) +
-		WMI_TLV_HDR_SIZE + config->channel_count *
-			sizeof(wmi_ocb_channel) +
-		WMI_TLV_HDR_SIZE + config->channel_count *
-			sizeof(wmi_qos_parameter) * WLAN_MAX_AC +
-		WMI_TLV_HDR_SIZE + config->dcc_ndl_chan_list_len +
-		WMI_TLV_HDR_SIZE + active_state_count *
-			sizeof(wmi_dcc_ndl_active_state_config) +
-		WMI_TLV_HDR_SIZE + config->schedule_size *
-			sizeof(wmi_ocb_schedule_element);
-	buf = wmi_buf_alloc(wma_handle->wmi_handle, len);
-	if (!buf) {
-		WMA_LOGE(FL("wmi_buf_alloc failed"));
-		return -ENOMEM;
-	}
-
-	buf_ptr = (uint8_t *)wmi_buf_data(buf);
-	cmd = (wmi_ocb_set_config_cmd_fixed_param *)buf_ptr;
-	WMITLV_SET_HDR(&cmd->tlv_header,
-		WMITLV_TAG_STRUC_wmi_ocb_set_config_cmd_fixed_param,
-		WMITLV_GET_STRUCT_TLVLEN(wmi_ocb_set_config_cmd_fixed_param));
-	cmd->vdev_id = config->session_id;
-	cmd->channel_count = config->channel_count;
-	cmd->schedule_size = config->schedule_size;
-	cmd->flags = config->flags;
-	buf_ptr += sizeof(*cmd);
-
-	/* Add the wmi_channel info */
-	WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
-		       config->channel_count*sizeof(wmi_channel));
-	buf_ptr += WMI_TLV_HDR_SIZE;
-	for (i = 0; i < config->channel_count; i++) {
-		chan = (wmi_channel *)buf_ptr;
-		WMITLV_SET_HDR(&chan->tlv_header,
-				WMITLV_TAG_STRUC_wmi_channel,
-				WMITLV_GET_STRUCT_TLVLEN(wmi_channel));
-		chan->mhz = config->channels[i].chan_freq;
-		chan->band_center_freq1 = config->channels[i].chan_freq;
-		chan->band_center_freq2 = 0;
-		chan->info = 0;
-
-		WMI_SET_CHANNEL_MODE(chan, wma_ocb_freq_to_mode(chan->mhz));
-		WMI_SET_CHANNEL_MAX_POWER(chan, config->channels[i].max_pwr);
-		WMI_SET_CHANNEL_MIN_POWER(chan, config->channels[i].min_pwr);
-		WMI_SET_CHANNEL_MAX_TX_POWER(chan, config->channels[i].max_pwr);
-		WMI_SET_CHANNEL_REG_POWER(chan, config->channels[i].reg_pwr);
-		WMI_SET_CHANNEL_ANTENNA_MAX(chan,
-					    config->channels[i].antenna_max);
-
-		if (config->channels[i].bandwidth < 10)
-			WMI_SET_CHANNEL_FLAG(chan, WMI_CHAN_FLAG_QUARTER_RATE);
-		else if (config->channels[i].bandwidth < 20)
-			WMI_SET_CHANNEL_FLAG(chan, WMI_CHAN_FLAG_HALF_RATE);
-		buf_ptr += sizeof(*chan);
-	}
-
-	/* Add the wmi_ocb_channel info */
-	WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
-		       config->channel_count*sizeof(wmi_ocb_channel));
-	buf_ptr += WMI_TLV_HDR_SIZE;
-	for (i = 0; i < config->channel_count; i++) {
-		ocb_chan = (wmi_ocb_channel *)buf_ptr;
-		WMITLV_SET_HDR(&ocb_chan->tlv_header,
-			       WMITLV_TAG_STRUC_wmi_ocb_channel,
-			       WMITLV_GET_STRUCT_TLVLEN(wmi_ocb_channel));
-		ocb_chan->bandwidth = config->channels[i].bandwidth;
-		WMI_CHAR_ARRAY_TO_MAC_ADDR(
-					config->channels[i].mac_address.bytes,
-					&ocb_chan->mac_address);
-		buf_ptr += sizeof(*ocb_chan);
-	}
-
-	/* Add the wmi_qos_parameter info */
-	WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
-		config->channel_count * sizeof(wmi_qos_parameter)*WLAN_MAX_AC);
-	buf_ptr += WMI_TLV_HDR_SIZE;
-	/* WLAN_MAX_AC parameters for each channel */
-	for (i = 0; i < config->channel_count; i++) {
-		for (j = 0; j < WLAN_MAX_AC; j++) {
-			qos_param = (wmi_qos_parameter *)buf_ptr;
-			WMITLV_SET_HDR(&qos_param->tlv_header,
-				WMITLV_TAG_STRUC_wmi_qos_parameter,
-				WMITLV_GET_STRUCT_TLVLEN(wmi_qos_parameter));
-			qos_param->aifsn =
-				config->channels[i].qos_params[j].aifsn;
-			qos_param->cwmin =
-				config->channels[i].qos_params[j].cwmin;
-			qos_param->cwmax =
-				config->channels[i].qos_params[j].cwmax;
-			buf_ptr += sizeof(*qos_param);
-		}
-	}
-
-	/* Add the wmi_dcc_ndl_chan (per channel) */
-	WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
-		       config->dcc_ndl_chan_list_len);
-	buf_ptr += WMI_TLV_HDR_SIZE;
-	if (config->dcc_ndl_chan_list_len) {
-		ndl_chan = (wmi_dcc_ndl_chan *)buf_ptr;
-		qdf_mem_copy(ndl_chan, config->dcc_ndl_chan_list,
-			     config->dcc_ndl_chan_list_len);
-		for (i = 0; i < config->channel_count; i++)
-			WMITLV_SET_HDR(&(ndl_chan[i].tlv_header),
-				WMITLV_TAG_STRUC_wmi_dcc_ndl_chan,
-				WMITLV_GET_STRUCT_TLVLEN(wmi_dcc_ndl_chan));
-		buf_ptr += config->dcc_ndl_chan_list_len;
-	}
-
-	/* Add the wmi_dcc_ndl_active_state_config */
-	WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, active_state_count *
-		       sizeof(wmi_dcc_ndl_active_state_config));
-	buf_ptr += WMI_TLV_HDR_SIZE;
-	if (active_state_count) {
-		ndl_active_config = (wmi_dcc_ndl_active_state_config *)buf_ptr;
-		qdf_mem_copy(ndl_active_config,
-			config->dcc_ndl_active_state_list,
-			active_state_count * sizeof(*ndl_active_config));
-		for (i = 0; i < active_state_count; ++i)
-			WMITLV_SET_HDR(&(ndl_active_config[i].tlv_header),
-			  WMITLV_TAG_STRUC_wmi_dcc_ndl_active_state_config,
-			  WMITLV_GET_STRUCT_TLVLEN(
-				wmi_dcc_ndl_active_state_config));
-		buf_ptr += active_state_count *
-			sizeof(*ndl_active_config);
-	}
-
-	/* Add the wmi_ocb_schedule_element info */
-	WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
-		config->schedule_size * sizeof(wmi_ocb_schedule_element));
-	buf_ptr += WMI_TLV_HDR_SIZE;
-	for (i = 0; i < config->schedule_size; i++) {
-		sched_elem = (wmi_ocb_schedule_element *)buf_ptr;
-		WMITLV_SET_HDR(&sched_elem->tlv_header,
-			WMITLV_TAG_STRUC_wmi_ocb_schedule_element,
-			WMITLV_GET_STRUCT_TLVLEN(wmi_ocb_schedule_element));
-		sched_elem->channel_freq = config->schedule[i].chan_freq;
-		sched_elem->total_duration = config->schedule[i].total_duration;
-		sched_elem->guard_interval = config->schedule[i].guard_interval;
-		buf_ptr += sizeof(*sched_elem);
-	}
+	for (i = 0; i < config->channel_count; i++)
+		ch_mhz[i] = wma_ocb_freq_to_mode(config->channels[i].chan_freq);
 
 	/*
 	 * Save the configuration so that it can be used in
@@ -428,18 +261,19 @@ int wma_ocb_set_config(tp_wma_handle wma_handle, struct sir_ocb_config *config)
 		wma_handle->ocb_config_req = copy_sir_ocb_config(config);
 	}
 
-	ret = wmi_unified_cmd_send(wma_handle->wmi_handle, buf, len,
-				   WMI_OCB_SET_CONFIG_CMDID);
+	ret = wmi_unified_ocb_set_config(wma_handle->wmi_handle, &tconfig,
+				     ch_mhz);
 	if (ret != EOK) {
 		if (wma_handle->ocb_config_req) {
 			qdf_mem_free(wma_handle->ocb_config_req);
 			wma_handle->ocb_config_req = NULL;
 		}
-
+		qdf_mem_free(ch_mhz);
 		WMA_LOGE("Failed to set OCB config");
-		wmi_buf_free(buf);
 		return -EIO;
 	}
+	qdf_mem_free(ch_mhz);
+
 	return 0;
 }
 
@@ -471,36 +305,14 @@ int wma_ocb_set_config_event_handler(void *handle, uint8_t *event_buf,
 int wma_ocb_set_utc_time(tp_wma_handle wma_handle, struct sir_ocb_utc *utc)
 {
 	int32_t ret;
-	wmi_ocb_set_utc_time_cmd_fixed_param *cmd;
-	uint8_t *buf_ptr;
-	uint32_t len, i;
-	wmi_buf_t buf;
+	struct ocb_utc_param cmd = {0};
 
-	len = sizeof(*cmd);
-	buf = wmi_buf_alloc(wma_handle->wmi_handle, len);
-	if (!buf) {
-		WMA_LOGE(FL("wmi_buf_alloc failed"));
-		return -ENOMEM;
-	}
-
-	buf_ptr = (uint8_t *)wmi_buf_data(buf);
-	cmd = (wmi_ocb_set_utc_time_cmd_fixed_param *)buf_ptr;
-	WMITLV_SET_HDR(&cmd->tlv_header,
-		WMITLV_TAG_STRUC_wmi_ocb_set_utc_time_cmd_fixed_param,
-		WMITLV_GET_STRUCT_TLVLEN(wmi_ocb_set_utc_time_cmd_fixed_param));
-	cmd->vdev_id = utc->vdev_id;
-
-	for (i = 0; i < SIZE_UTC_TIME; i++)
-		WMI_UTC_TIME_SET(cmd, i, utc->utc_time[i]);
-
-	for (i = 0; i < SIZE_UTC_TIME_ERROR; i++)
-		WMI_TIME_ERROR_SET(cmd, i, utc->time_error[i]);
-
-	ret = wmi_unified_cmd_send(wma_handle->wmi_handle, buf, len,
-				   WMI_OCB_SET_UTC_TIME_CMDID);
+	cmd.vdev_id = utc->vdev_id;
+	qdf_mem_copy(&cmd.utc_time, &utc->utc_time, WMI_SIZE_UTC_TIME);
+	qdf_mem_copy(&cmd.time_error, &utc->time_error, WMI_SIZE_UTC_TIME_ERROR);
+	ret = wmi_unified_ocb_set_utc_time_cmd(wma_handle->wmi_handle, &cmd);
 	if (ret != EOK) {
 		WMA_LOGE(FL("Failed to set OCB UTC time"));
-		wmi_buf_free(buf);
 		return -EIO;
 	}
 
@@ -519,52 +331,20 @@ int wma_ocb_start_timing_advert(tp_wma_handle wma_handle,
 	struct sir_ocb_timing_advert *timing_advert)
 {
 	int32_t ret;
-	wmi_ocb_start_timing_advert_cmd_fixed_param *cmd;
-	uint8_t *buf_ptr;
-	uint32_t len, len_template;
-	wmi_buf_t buf;
+	struct ocb_timing_advert_param cmd = {0};
 
-	len = sizeof(*cmd) +
-		     WMI_TLV_HDR_SIZE;
+	cmd.vdev_id = timing_advert->vdev_id;
+	cmd.repeat_rate = timing_advert->repeat_rate;
+	cmd.chan_freq = timing_advert->chan_freq;
+	cmd.timestamp_offset = timing_advert->timestamp_offset;
+	cmd.time_value_offset = timing_advert->time_value_offset;
+	cmd.template_length = timing_advert->template_length;
+	cmd.template_value = (uint8_t *)timing_advert->template_value;
 
-	len_template = timing_advert->template_length;
-	/* Add padding to the template if needed */
-	if (len_template % 4 != 0)
-		len_template += 4 - (len_template % 4);
-	len += len_template;
-
-	buf = wmi_buf_alloc(wma_handle->wmi_handle, len);
-	if (!buf) {
-		WMA_LOGE(FL("wmi_buf_alloc failed"));
-		return -ENOMEM;
-	}
-
-	buf_ptr = (uint8_t *)wmi_buf_data(buf);
-	cmd = (wmi_ocb_start_timing_advert_cmd_fixed_param *)buf_ptr;
-	WMITLV_SET_HDR(&cmd->tlv_header,
-		WMITLV_TAG_STRUC_wmi_ocb_start_timing_advert_cmd_fixed_param,
-		WMITLV_GET_STRUCT_TLVLEN(
-			wmi_ocb_start_timing_advert_cmd_fixed_param));
-	cmd->vdev_id = timing_advert->vdev_id;
-	cmd->repeat_rate = timing_advert->repeat_rate;
-	cmd->channel_freq = timing_advert->chan_freq;
-	cmd->timestamp_offset = timing_advert->timestamp_offset;
-	cmd->time_value_offset = timing_advert->time_value_offset;
-	cmd->timing_advert_template_length = timing_advert->template_length;
-	buf_ptr += sizeof(*cmd);
-
-	/* Add the timing advert template */
-	WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE,
-		       len_template);
-	qdf_mem_copy(buf_ptr + WMI_TLV_HDR_SIZE,
-		     (uint8_t *)timing_advert->template_value,
-		     timing_advert->template_length);
-
-	ret = wmi_unified_cmd_send(wma_handle->wmi_handle, buf, len,
-				   WMI_OCB_START_TIMING_ADVERT_CMDID);
+	ret = wmi_unified_ocb_start_timing_advert(wma_handle->wmi_handle,
+				   &cmd);
 	if (ret != EOK) {
 		WMA_LOGE(FL("Failed to start OCB timing advert"));
-		wmi_buf_free(buf);
 		return -EIO;
 	}
 
@@ -583,32 +363,14 @@ int wma_ocb_stop_timing_advert(tp_wma_handle wma_handle,
 	struct sir_ocb_timing_advert *timing_advert)
 {
 	int32_t ret;
-	wmi_ocb_stop_timing_advert_cmd_fixed_param *cmd;
-	uint8_t *buf_ptr;
-	uint32_t len;
-	wmi_buf_t buf;
+	struct ocb_timing_advert_param cmd = {0};
 
-	len = sizeof(*cmd);
-	buf = wmi_buf_alloc(wma_handle->wmi_handle, len);
-	if (!buf) {
-		WMA_LOGE(FL("wmi_buf_alloc failed"));
-		return -ENOMEM;
-	}
-
-	buf_ptr = (uint8_t *)wmi_buf_data(buf);
-	cmd = (wmi_ocb_stop_timing_advert_cmd_fixed_param *)buf_ptr;
-	WMITLV_SET_HDR(&cmd->tlv_header,
-		WMITLV_TAG_STRUC_wmi_ocb_stop_timing_advert_cmd_fixed_param,
-		WMITLV_GET_STRUCT_TLVLEN(
-			wmi_ocb_stop_timing_advert_cmd_fixed_param));
-	cmd->vdev_id = timing_advert->vdev_id;
-	cmd->channel_freq = timing_advert->chan_freq;
-
-	ret = wmi_unified_cmd_send(wma_handle->wmi_handle, buf, len,
-				   WMI_OCB_STOP_TIMING_ADVERT_CMDID);
+	cmd.vdev_id = timing_advert->vdev_id;
+	cmd.chan_freq = timing_advert->chan_freq;
+	ret = wmi_unified_ocb_stop_timing_advert(wma_handle->wmi_handle,
+				   &cmd);
 	if (ret != EOK) {
 		WMA_LOGE(FL("Failed to stop OCB timing advert"));
-		wmi_buf_free(buf);
 		return -EIO;
 	}
 
@@ -627,34 +389,12 @@ int wma_ocb_get_tsf_timer(tp_wma_handle wma_handle,
 			  struct sir_ocb_get_tsf_timer *request)
 {
 	QDF_STATUS ret;
-	wmi_ocb_get_tsf_timer_cmd_fixed_param *cmd;
-	uint8_t *buf_ptr;
-	wmi_buf_t buf;
-	int32_t len;
-
-	len = sizeof(*cmd);
-	buf = wmi_buf_alloc(wma_handle->wmi_handle, len);
-	if (!buf) {
-		WMA_LOGE(FL("wmi_buf_alloc failed"));
-		return -ENOMEM;
-	}
-	buf_ptr = (uint8_t *)wmi_buf_data(buf);
-
-	cmd = (wmi_ocb_get_tsf_timer_cmd_fixed_param *)buf_ptr;
-	qdf_mem_zero(cmd, len);
-	WMITLV_SET_HDR(&cmd->tlv_header,
-		WMITLV_TAG_STRUC_wmi_ocb_get_tsf_timer_cmd_fixed_param,
-		WMITLV_GET_STRUCT_TLVLEN(
-			wmi_ocb_get_tsf_timer_cmd_fixed_param));
-	cmd->vdev_id = request->vdev_id;
 
 	/* Send the WMI command */
-	ret = wmi_unified_cmd_send(wma_handle->wmi_handle, buf, len,
-				   WMI_OCB_GET_TSF_TIMER_CMDID);
+	ret = wmi_unified_ocb_get_tsf_timer(wma_handle->wmi_handle, request->vdev_id);
 	/* If there is an error, set the completion event */
 	if (ret != EOK) {
 		WMA_LOGE(FL("Failed to send WMI message: %d"), ret);
-		wmi_buf_free(buf);
 		return -EIO;
 	}
 	return 0;
@@ -712,64 +452,18 @@ int wma_dcc_get_stats(tp_wma_handle wma_handle,
 		      struct sir_dcc_get_stats *get_stats_param)
 {
 	int32_t ret;
-	wmi_dcc_get_stats_cmd_fixed_param *cmd;
-	wmi_dcc_channel_stats_request *channel_stats_array;
-	wmi_buf_t buf;
-	uint8_t *buf_ptr;
-	uint32_t len;
-	uint32_t i;
+	struct dcc_get_stats_param cmd = {0};
 
-	/* Validate the input */
-	if (get_stats_param->request_array_len !=
-	    get_stats_param->channel_count * sizeof(*channel_stats_array)) {
-		WMA_LOGE(FL("Invalid parameter"));
-		return -EINVAL;
-	}
-
-	/* Allocate memory for the WMI command */
-	len = sizeof(*cmd) + WMI_TLV_HDR_SIZE +
-		get_stats_param->request_array_len;
-
-	buf = wmi_buf_alloc(wma_handle->wmi_handle, len);
-	if (!buf) {
-		WMA_LOGE(FL("wmi_buf_alloc failed"));
-		return QDF_STATUS_E_NOMEM;
-	}
-
-	buf_ptr = wmi_buf_data(buf);
-	qdf_mem_zero(buf_ptr, len);
-
-	/* Populate the WMI command */
-	cmd = (wmi_dcc_get_stats_cmd_fixed_param *)buf_ptr;
-	buf_ptr += sizeof(*cmd);
-
-	WMITLV_SET_HDR(&cmd->tlv_header,
-		       WMITLV_TAG_STRUC_wmi_dcc_get_stats_cmd_fixed_param,
-		       WMITLV_GET_STRUCT_TLVLEN(
-			   wmi_dcc_get_stats_cmd_fixed_param));
-	cmd->vdev_id = get_stats_param->vdev_id;
-	cmd->num_channels = get_stats_param->channel_count;
-
-	WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
-		       get_stats_param->request_array_len);
-	buf_ptr += WMI_TLV_HDR_SIZE;
-
-	channel_stats_array = (wmi_dcc_channel_stats_request *)buf_ptr;
-	qdf_mem_copy(channel_stats_array, get_stats_param->request_array,
-		     get_stats_param->request_array_len);
-	for (i = 0; i < cmd->num_channels; i++)
-		WMITLV_SET_HDR(&channel_stats_array[i].tlv_header,
-			WMITLV_TAG_STRUC_wmi_dcc_channel_stats_request,
-			WMITLV_GET_STRUCT_TLVLEN(
-			    wmi_dcc_channel_stats_request));
+	cmd.vdev_id = get_stats_param->vdev_id;
+	cmd.channel_count = get_stats_param->channel_count;
+	cmd.request_array_len = get_stats_param->request_array_len;
+	cmd.request_array = get_stats_param->request_array;
 
 	/* Send the WMI command */
-	ret = wmi_unified_cmd_send(wma_handle->wmi_handle, buf, len,
-				   WMI_DCC_GET_STATS_CMDID);
+	ret = wmi_unified_dcc_get_stats_cmd(wma_handle->wmi_handle, &cmd);
 
 	if (ret != EOK) {
 		WMA_LOGE(FL("Failed to send WMI message: %d"), ret);
-		wmi_buf_free(buf);
 		return -EIO;
 	}
 
@@ -835,39 +529,13 @@ int wma_dcc_clear_stats(tp_wma_handle wma_handle,
 			struct sir_dcc_clear_stats *clear_stats_param)
 {
 	int32_t ret;
-	wmi_dcc_clear_stats_cmd_fixed_param *cmd;
-	wmi_buf_t buf;
-	uint8_t *buf_ptr;
-	uint32_t len;
-
-	/* Allocate memory for the WMI command */
-	len = sizeof(*cmd);
-
-	buf = wmi_buf_alloc(wma_handle->wmi_handle, len);
-	if (!buf) {
-		WMA_LOGE(FL("wmi_buf_alloc failed"));
-		return -ENOMEM;
-	}
-
-	buf_ptr = wmi_buf_data(buf);
-	qdf_mem_zero(buf_ptr, len);
-
-	/* Populate the WMI command */
-	cmd = (wmi_dcc_clear_stats_cmd_fixed_param *)buf_ptr;
-
-	WMITLV_SET_HDR(&cmd->tlv_header,
-		       WMITLV_TAG_STRUC_wmi_dcc_clear_stats_cmd_fixed_param,
-		       WMITLV_GET_STRUCT_TLVLEN(
-			   wmi_dcc_clear_stats_cmd_fixed_param));
-	cmd->vdev_id = clear_stats_param->vdev_id;
-	cmd->dcc_stats_bitmap = clear_stats_param->dcc_stats_bitmap;
 
 	/* Send the WMI command */
-	ret = wmi_unified_cmd_send(wma_handle->wmi_handle, buf, len,
-				   WMI_DCC_CLEAR_STATS_CMDID);
+	ret = wmi_unified_dcc_clear_stats(wma_handle->wmi_handle,
+				   clear_stats_param->vdev_id,
+				   clear_stats_param->dcc_stats_bitmap);
 	if (ret != EOK) {
 		WMA_LOGE(FL("Failed to send the WMI command"));
-		wmi_buf_free(buf);
 		return -EIO;
 	}
 
@@ -885,95 +553,15 @@ int wma_dcc_update_ndl(tp_wma_handle wma_handle,
 		       struct sir_dcc_update_ndl *update_ndl_param)
 {
 	QDF_STATUS qdf_status;
-	wmi_dcc_update_ndl_cmd_fixed_param *cmd;
-	wmi_dcc_ndl_chan *ndl_chan_array;
-	wmi_dcc_ndl_active_state_config *ndl_active_state_array;
-	uint32_t active_state_count;
-	wmi_buf_t buf;
-	uint8_t *buf_ptr;
-	uint32_t len;
-	uint32_t i;
-
-	/* validate the input */
-	if (update_ndl_param->dcc_ndl_chan_list_len !=
-	    update_ndl_param->channel_count * sizeof(*ndl_chan_array)) {
-		WMA_LOGE(FL("Invalid parameter"));
-		return QDF_STATUS_E_INVAL;
-	}
-	active_state_count = 0;
-	ndl_chan_array = update_ndl_param->dcc_ndl_chan_list;
-	for (i = 0; i < update_ndl_param->channel_count; i++)
-		active_state_count +=
-			WMI_NDL_NUM_ACTIVE_STATE_GET(&ndl_chan_array[i]);
-	if (update_ndl_param->dcc_ndl_active_state_list_len !=
-	    active_state_count * sizeof(*ndl_active_state_array)) {
-		WMA_LOGE(FL("Invalid parameter"));
-		return QDF_STATUS_E_INVAL;
-	}
-
-	/* Allocate memory for the WMI command */
-	len = sizeof(*cmd) +
-		WMI_TLV_HDR_SIZE + update_ndl_param->dcc_ndl_chan_list_len +
-		WMI_TLV_HDR_SIZE +
-		update_ndl_param->dcc_ndl_active_state_list_len;
-
-	buf = wmi_buf_alloc(wma_handle->wmi_handle, len);
-	if (!buf) {
-		WMA_LOGE(FL("wmi_buf_alloc failed"));
-		return -ENOMEM;
-	}
-
-	buf_ptr = wmi_buf_data(buf);
-	qdf_mem_zero(buf_ptr, len);
-
-	/* Populate the WMI command */
-	cmd = (wmi_dcc_update_ndl_cmd_fixed_param *)buf_ptr;
-	buf_ptr += sizeof(*cmd);
-
-	WMITLV_SET_HDR(&cmd->tlv_header,
-		       WMITLV_TAG_STRUC_wmi_dcc_update_ndl_cmd_fixed_param,
-		       WMITLV_GET_STRUCT_TLVLEN(
-			   wmi_dcc_update_ndl_cmd_fixed_param));
-	cmd->vdev_id = update_ndl_param->vdev_id;
-	cmd->num_channel = update_ndl_param->channel_count;
-
-	WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
-		       update_ndl_param->dcc_ndl_chan_list_len);
-	buf_ptr += WMI_TLV_HDR_SIZE;
-
-	ndl_chan_array = (wmi_dcc_ndl_chan *)buf_ptr;
-	qdf_mem_copy(ndl_chan_array, update_ndl_param->dcc_ndl_chan_list,
-		     update_ndl_param->dcc_ndl_chan_list_len);
-	for (i = 0; i < cmd->num_channel; i++)
-		WMITLV_SET_HDR(&ndl_chan_array[i].tlv_header,
-			WMITLV_TAG_STRUC_wmi_dcc_ndl_chan,
-			WMITLV_GET_STRUCT_TLVLEN(
-			    wmi_dcc_ndl_chan));
-	buf_ptr += update_ndl_param->dcc_ndl_chan_list_len;
-
-	WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
-		       update_ndl_param->dcc_ndl_active_state_list_len);
-	buf_ptr += WMI_TLV_HDR_SIZE;
-
-	ndl_active_state_array = (wmi_dcc_ndl_active_state_config *) buf_ptr;
-	qdf_mem_copy(ndl_active_state_array,
-		     update_ndl_param->dcc_ndl_active_state_list,
-		     update_ndl_param->dcc_ndl_active_state_list_len);
-	for (i = 0; i < active_state_count; i++) {
-		WMITLV_SET_HDR(&ndl_active_state_array[i].tlv_header,
-			WMITLV_TAG_STRUC_wmi_dcc_ndl_active_state_config,
-			WMITLV_GET_STRUCT_TLVLEN(
-			    wmi_dcc_ndl_active_state_config));
-	}
-	buf_ptr += update_ndl_param->dcc_ndl_active_state_list_len;
+	struct dcc_update_ndl_param *cmd;
 
+	cmd = (struct dcc_update_ndl_param *) update_ndl_param;
 	/* Send the WMI command */
-	qdf_status = wmi_unified_cmd_send(wma_handle->wmi_handle, buf, len,
-				   WMI_DCC_UPDATE_NDL_CMDID);
+	qdf_status = wmi_unified_dcc_update_ndl(wma_handle->wmi_handle,
+				   cmd);
 	/* If there is an error, set the completion event */
 	if (qdf_status) {
 		WMA_LOGE(FL("Failed to send WMI message: %d"), qdf_status);
-		wmi_buf_free(buf);
 		return -EIO;
 	}