qcacld-3.0: Trigger wide band scan as per OPTIE of chan load req

AP can send channel width and related information via below OPIE:
1. Wide Bandwidth Channel Switch (Subelement ID 163)
2. Bandwidth Indication (Subelement ID 164)

Trigger wide band scan as per values present for above IEs present
in channel load request.

Change-Id: I013389972f0f72395488a2405e4b0dcbff39dd42
CRs-Fixed: 3629109

components/mlme/core/inc/wlan_mlme_main.h

@@ -1218,6 +1218,7 @@ QDF_STATUS wlan_mlme_get_bssid_vdev_id(struct wlan_objmgr_pdev *pdev,
  * @req: pointer to scan request
  * @scan_ch_width: Channel width for which to trigger a wide band scan
  * @scan_freq: frequency for which to trigger a wide band RRM scan
+ * @cen320_freq: 320 MHz center freq
  *
  * Return: QDF_STATUS
  */
@@ -1225,7 +1226,8 @@ QDF_STATUS
 mlme_update_freq_in_scan_start_req(struct wlan_objmgr_vdev *vdev,
 				   struct scan_start_request *req,
 				   enum phy_ch_width scan_ch_width,
-				   qdf_freq_t scan_freq);
+				   qdf_freq_t scan_freq,
+				   qdf_freq_t cen320_freq);
 
 /**
  * wlan_get_operation_chan_freq() - get operating chan freq of

components/mlme/core/src/wlan_mlme_main.c

@@ -388,39 +388,63 @@ wlan_scan_get_scan_phy_mode(struct wlan_objmgr_vdev *vdev, qdf_freq_t op_freq,
 	return scan_phymode;
 }
 
+#ifdef WLAN_FEATURE_11BE
+/**
+ * mlme_get_scan_phy_mode_for_chan_load() - get scan phymode from ch width
+ * @scan_ch_width: channel width
+ *
+ * Return: enum scan_phy_mode
+ */
+static enum scan_phy_mode
+mlme_get_scan_phy_mode_for_chan_load(enum phy_ch_width scan_ch_width)
+{
+	enum scan_phy_mode scan_phymode = SCAN_PHY_MODE_UNKNOWN;
+
+	switch (scan_ch_width) {
+	case CH_WIDTH_20MHZ:
+		scan_phymode = SCAN_PHY_MODE_11BE_EHT20;
+		break;
+	case CH_WIDTH_40MHZ:
+		scan_phymode = SCAN_PHY_MODE_11BE_EHT40;
+		break;
+	case CH_WIDTH_80MHZ:
+		scan_phymode = SCAN_PHY_MODE_11BE_EHT80;
+		break;
+	case CH_WIDTH_160MHZ:
+		scan_phymode = SCAN_PHY_MODE_11BE_EHT160;
+		break;
+	default:
+		mlme_debug("Invalid scan_ch_width:%d", scan_ch_width);
+		break;
+	}
+
+	return scan_phymode;
+}
+#else
+static inline enum scan_phy_mode
+mlme_get_scan_phy_mode_for_chan_load(enum phy_ch_width scan_ch_width)
+{
+	return SCAN_PHY_MODE_UNKNOWN;
+}
+#endif
+
 QDF_STATUS
 mlme_update_freq_in_scan_start_req(struct wlan_objmgr_vdev *vdev,
 				   struct scan_start_request *req,
 				   enum phy_ch_width scan_ch_width,
-				   qdf_freq_t scan_freq)
+				   qdf_freq_t scan_freq,
+				   qdf_freq_t cen320_freq)
 {
 	const struct bonded_channel_freq *range;
 	uint8_t num_chan;
 	qdf_freq_t op_freq, center_20_freq, start_freq, end_freq;
-	qdf_freq_t cen320_freq = 0;
 	enum scan_phy_mode phymode = SCAN_PHY_MODE_UNKNOWN;
-	uint8_t vdev_id;
-	struct wlan_channel *des_chan;
-	struct mlme_legacy_priv *mlme_priv;
+	uint8_t vdev_id = vdev->vdev_objmgr.vdev_id;
 
-	vdev_id = vdev->vdev_objmgr.vdev_id;
-
-	mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev);
-	if (!mlme_priv)
-		return QDF_STATUS_E_FAILURE;
-
-	if (scan_freq != INVALID_CHANNEL) {
+	if (scan_freq != INVALID_CHANNEL)
 		op_freq = scan_freq;
-	} else {
-		des_chan = wlan_vdev_mlme_get_des_chan(vdev);
-		if (!des_chan) {
-			mlme_debug("null des chan");
-			return QDF_STATUS_E_FAILURE;
-		}
-		op_freq = des_chan->ch_freq;
-		/* Set center_freq1 to center frequency of complete 320MHz */
-		cen320_freq = mlme_priv->connect_info.assoc_chan_info.cen320_freq;
-	}
+	else
+		op_freq = wlan_get_operation_chan_freq(vdev);
 
 	mlme_debug("vdev %d :op_freq:%d, cen320_freq:%d, scan_ch_width: %d",
 		   vdev_id, op_freq, cen320_freq, scan_ch_width);
@@ -463,7 +487,11 @@ mlme_update_freq_in_scan_start_req(struct wlan_objmgr_vdev *vdev,
 		num_chan += 1;
 		req->scan_req.chan_list.num_chan = num_chan;
 	} else {
-		phymode = wlan_scan_get_scan_phy_mode(vdev, op_freq, vdev_id);
+		if (scan_freq != INVALID_CHANNEL)
+			phymode = mlme_get_scan_phy_mode_for_chan_load(scan_ch_width);
+		else
+			phymode = wlan_scan_get_scan_phy_mode(vdev, op_freq, vdev_id);
+
 		if (phymode == SCAN_PHY_MODE_UNKNOWN) {
 			mlme_debug("vdev %d : invalid scan phymode for freq %d",
 				   vdev_id, op_freq);
@@ -623,6 +651,16 @@ mlme_fill_freq_in_wide_scan_start_request(struct wlan_objmgr_vdev *vdev,
 	struct mlme_legacy_priv *mlme_priv;
 	enum phy_ch_width associated_ch_width;
 	QDF_STATUS status;
+	struct wlan_channel *des_chan;
+	qdf_freq_t cen320_freq = 0;
+
+	des_chan = wlan_vdev_mlme_get_des_chan(vdev);
+	if (!des_chan) {
+		mlme_debug("null des chan");
+		return QDF_STATUS_E_FAILURE;
+	}
+	/* Set center_freq1 to center frequency of complete 320MHz */
+	cen320_freq = des_chan->ch_cfreq2;
 
 	req->scan_req.chan_list.num_chan = 0;
 
@@ -648,7 +686,8 @@ mlme_fill_freq_in_wide_scan_start_request(struct wlan_objmgr_vdev *vdev,
 
 	status = mlme_update_freq_in_scan_start_req(vdev, req,
 						    associated_ch_width,
-						    INVALID_CHANNEL);
+						    INVALID_CHANNEL,
+						    cen320_freq);
 	if (QDF_IS_STATUS_ERROR(status))
 		return QDF_STATUS_E_FAILURE;
 

core/mac/src/pe/include/rrm_global.h

@@ -52,6 +52,49 @@ struct sir_channel_info {
 	uint32_t chan_freq;
 };
 
+/**
+ * struct rrm_reporting - Contains info for rrm_ reporting IE present in
+ * channel load request received from AP
+ * @reporting_condition: reporting condition
+ * @threshold: threshold value to report channel load request
+ */
+struct rrm_reporting {
+	uint8_t reporting_condition;
+	uint8_t threshold;
+};
+
+/**
+ * struct bw_ind_element - Contains info for Bandwidth Indication IE
+ * present in channel load request received from AP
+ * @s_bw_ind_element: to check Bandwidth Indication optional IE present
+ * @channel_width: channel width
+ * @ccfi0: center channel frequency index segment 0
+ * @ccfi1: center channel frequency index segment 1
+ * @center_chan_freq: center freq segment  for 320 MHz request
+ */
+struct bw_ind_element {
+	bool is_bw_ind_element;
+	uint8_t channel_width;
+	uint8_t ccfi0;
+	uint8_t ccfi1;
+	qdf_freq_t center_freq;
+};
+
+/**
+ * struct wide_bw_chan_switch - Contains info for Wide Bandwidth Channel
+ * Switch IE present in channel load request received from AP
+ * @is_wide_bw_chan_switch: to check Bandwidth Indication optional IE present
+ * @channel_width: channel width
+ * @center_chan_freq0: center freq segment 0 for till 160 MHz request
+ * @center_chan_freq1: center freq segment 1 for till 160 MHz request
+ */
+struct wide_bw_chan_switch {
+	uint8_t is_wide_bw_chan_switch;
+	uint8_t channel_width;
+	uint8_t center_chan_freq0;
+	uint8_t center_chan_freq1;
+};
+
 /**
  * struct ch_load_ind - Contains info for channel load request received from AP
  * @message_type: message type eWNI_SME_CHAN_LOAD_REQ_IND
@@ -64,6 +107,8 @@ struct sir_channel_info {
  * @channel: channel number
  * @randomization_intv: Random interval in ms
  * @meas_duration: measurement duration in ms
+ * @bw_ind: Info for bandwidth indication IE
+ * @wide_bw: Info for wide bandwidth channel switch IE
  */
 struct ch_load_ind {
 	uint16_t message_type;
@@ -76,11 +121,13 @@ struct ch_load_ind {
 	uint8_t channel;
 	uint16_t randomization_intv;
 	uint16_t meas_duration;
+	struct bw_ind_element bw_ind;
+	struct wide_bw_chan_switch wide_bw;
 };
 
 /**
  * struct chan_load_xmit_ind - Contains info for channel load xmit indication
- * @message_type: message type eWNI_SME_CHAN_LOAD_REPORT_RESP_XMIT_IND
+ * @messageType: message type eWNI_SME_CHAN_LOAD_REPORT_RESP_XMIT_IND
  * @length: size of struct chan_load_req_ind
  * @measurement_idx: measurement index for channel load request
  * @peer_addr: MAC address of the BSS

core/mac/src/pe/lim/lim_process_action_frame.c

@@ -1129,6 +1129,9 @@ __lim_process_radio_measure_request(struct mac_context *mac, uint8_t *pRxPacketI
 		 QDF_MAC_ADDR_REF(pe_session->bssId),
 		 QDF_MAC_ADDR_REF(pe_session->self_mac_addr));
 
+	pe_debug("RX RRM - type %hu, sub type %hu, seq num[%d]",
+		 pHdr->fc.type, pHdr->fc.subType, curr_seq_num);
+
 	rrm_process_radio_measurement_request(mac, pe_session->bssId, frm,
 					      pe_session);
 err:

core/mac/src/pe/rrm/rrm_api.c

@@ -2055,18 +2055,64 @@ rrm_process_channel_load_req(struct mac_context *mac,
 {
 	struct scheduler_msg msg = {0};
 	struct ch_load_ind *load_ind;
-	uint8_t op_class, channel, reporting_condition;
+	struct bw_ind_element bw_ind;
+	struct wide_bw_chan_switch wide_bw;
+	struct rrm_reporting rrm_report;
+	uint8_t op_class, channel;
 	uint16_t randomization_intv, meas_duration, max_meas_duration;
-	bool present;
+	bool is_rrm_reporting, is_wide_bw_chan_switch;
 	uint8_t country[WNI_CFG_COUNTRY_CODE_LEN];
 	qdf_freq_t chan_freq;
-	bool is_freq_enabled;
+	bool is_freq_enabled, is_bw_ind;
+
+	is_rrm_reporting = chan_load_req->measurement_request.channel_load.rrm_reporting.present;
+	is_wide_bw_chan_switch = chan_load_req->measurement_request.channel_load.wide_bw_chan_switch.present;
+	is_bw_ind = chan_load_req->measurement_request.channel_load.bw_indication.present;
+
+	pe_debug("RX:[802.11 CH_LOAD] vdev: %d, is_rrm_reporting: %d, is_wide_bw_chan_switch: %d, is_bw_ind: %d",
+		 pe_session->vdev_id, is_rrm_reporting, is_wide_bw_chan_switch,
+		 is_bw_ind);
+
+	if (is_rrm_reporting) {
+		rrm_report.threshold = chan_load_req->measurement_request.channel_load.rrm_reporting.threshold;
+		rrm_report.reporting_condition = chan_load_req->measurement_request.channel_load.rrm_reporting.reporting_condition;
+		pe_debug("RX:[802.11 CH_LOAD] threshold:%d reporting_c:%d",
+			 rrm_report.threshold, rrm_report.reporting_condition);
+		if (rrm_report.reporting_condition != 0) {
+			pe_debug("RX:[802.11 CH_LOAD]: Dropping req");
+			return eRRM_INCAPABLE;
+		}
+	}
 
-	present = chan_load_req->measurement_request.channel_load.rrm_reporting.present;
-	reporting_condition = chan_load_req->measurement_request.channel_load.rrm_reporting.reporting_condition;
-	if (present && reporting_condition != 0) {
-		pe_err("Dropping req: Reporting condition is not zero");
-		return eRRM_INCAPABLE;
+	if (is_bw_ind) {
+		bw_ind.is_bw_ind_element = true;
+		bw_ind.channel_width = chan_load_req->measurement_request.channel_load.bw_indication.channel_width;
+		bw_ind.ccfi0 = chan_load_req->measurement_request.channel_load.bw_indication.ccfs0;
+		bw_ind.ccfi1 = chan_load_req->measurement_request.channel_load.bw_indication.ccfs1;
+		bw_ind.center_freq = wlan_reg_compute_6g_center_freq_from_cfi(bw_ind.ccfi0);
+		pe_debug("RX:[802.11 CH_LOAD] chan_width:%d ccfs0:%d, ccfs1:%d, center_freq:%d",
+			 bw_ind.channel_width, bw_ind.ccfi0,
+			 bw_ind.ccfi1, bw_ind.center_freq);
+
+		if (bw_ind.channel_width == 0 || !bw_ind.ccfi0 ||
+		    bw_ind.channel_width < CH_WIDTH_320MHZ || !bw_ind.center_freq) {
+			pe_debug("Dropping req: invalid is_bw_ind_element IE");
+			return eRRM_REFUSED;
+		}
+	} else if (is_wide_bw_chan_switch) {
+		wide_bw.channel_width = chan_load_req->measurement_request.channel_load.wide_bw_chan_switch.new_chan_width;
+		wide_bw.center_chan_freq0 = chan_load_req->measurement_request.channel_load.wide_bw_chan_switch.new_center_chan_freq0;
+		wide_bw.center_chan_freq1 = chan_load_req->measurement_request.channel_load.wide_bw_chan_switch.new_center_chan_freq1;
+		pe_debug("RX:[802.11 CH_LOAD] cw:%d ccf0:%d, ccf1:%d",
+			 wide_bw.channel_width, wide_bw.center_chan_freq0,
+			 wide_bw.center_chan_freq1);
+		if (wide_bw.channel_width < CH_WIDTH_20MHZ ||
+		    bw_ind.channel_width >= CH_WIDTH_320MHZ) {
+			pe_debug("Dropping req: invalid wide_bw IE");
+			return eRRM_REFUSED;
+		}
+	} else {
+		pe_debug("IE(s) are NULL in channel load request");
 	}
 
 	op_class = chan_load_req->measurement_request.channel_load.op_class;
@@ -2076,6 +2122,7 @@ rrm_process_channel_load_req(struct mac_context *mac,
 	randomization_intv =
 	     chan_load_req->measurement_request.channel_load.randomization_intv;
 	max_meas_duration = rrm_get_max_meas_duration(mac, pe_session);
+
 	if (max_meas_duration < meas_duration) {
 		if (chan_load_req->durationMandatory) {
 			pe_nofl_err("RX:[802.11 CH_LOAD] Dropping the req: duration mandatory & max duration > meas duration");
@@ -2083,12 +2130,14 @@ rrm_process_channel_load_req(struct mac_context *mac,
 		}
 		meas_duration = max_meas_duration;
 	}
+
 	pe_debug("RX:[802.11 CH_LOAD] vdev :%d, seq:%d Token:%d op_c:%d ch:%d meas_dur:%d, rand intv: %d, max_dur:%d",
 		 pe_session->vdev_id,
 		 mac->rrm.rrmPEContext.prev_rrm_report_seq_num,
 		 chan_load_req->measurement_token, op_class,
 		 channel, meas_duration, randomization_intv,
 		 max_meas_duration);
+
 	if (!meas_duration || meas_duration > RRM_SCAN_MAX_DWELL_TIME)
 		return eRRM_REFUSED;
 
@@ -2136,6 +2185,26 @@ rrm_process_channel_load_req(struct mac_context *mac,
 	load_ind->op_class = op_class;
 	load_ind->meas_duration = meas_duration;
 	curr_req->token = chan_load_req->measurement_token;
+
+	if (is_wide_bw_chan_switch) {
+		load_ind->wide_bw.is_wide_bw_chan_switch = true;
+		load_ind->wide_bw.channel_width = wide_bw.channel_width;
+		load_ind->wide_bw.center_chan_freq0 = wide_bw.center_chan_freq0;
+		load_ind->wide_bw.center_chan_freq1 = wide_bw.center_chan_freq1;
+	} else {
+		load_ind->wide_bw.channel_width = CH_WIDTH_INVALID;
+	}
+
+	if (bw_ind.is_bw_ind_element) {
+		load_ind->bw_ind.is_bw_ind_element = true;
+		load_ind->bw_ind.channel_width = bw_ind.channel_width;
+		load_ind->bw_ind.ccfi0 = bw_ind.ccfi0;
+		load_ind->bw_ind.ccfi1 = bw_ind.ccfi1;
+		load_ind->bw_ind.center_freq = bw_ind.center_freq;
+	} else {
+		load_ind->bw_ind.is_bw_ind_element = false;
+	}
+
 	/* Send request to SME. */
 	msg.type = eWNI_SME_CHAN_LOAD_REQ_IND;
 	msg.bodyptr = load_ind;

core/sme/inc/sme_rrm_internal.h

@@ -75,10 +75,14 @@ enum rrm_measurement_type {
  * enum channel_load_req_info: channel load request info
  * @channel: channel for which the host receives the channel load req from AP
  * @rrm_scan_tsf: to store jiffies for RRM scan to process chan load req
+ * @bw_ind: Contains info for Bandwidth Indication IE
+ * @wide_bw: Contains info for Wide Bandwidth Channel IE
  */
 struct channel_load_req_info {
 	uint8_t channel;
 	qdf_time_t rrm_scan_tsf;
+	struct bw_ind_element bw_ind;
+	struct wide_bw_chan_switch wide_bw;
 };
 
 typedef struct sRrmSMEContext {

core/sme/src/rrm/sme_rrm.c

@@ -1134,11 +1134,14 @@ sme_rrm_fill_freq_list_for_channel_load(struct mac_context *mac_ctx,
 					struct wlan_objmgr_vdev *vdev,
 					struct scan_start_request *req)
 {
-	uint16_t chan_space = 0;
+	struct bw_ind_element *bw_ind;
+	struct wide_bw_chan_switch *wide_bw;
+	uint16_t c_space = 0;
 	uint8_t country_code[REG_ALPHA2_LEN + 1];
 	enum phy_ch_width chan_width = CH_WIDTH_INVALID;
 	qdf_freq_t scan_freq;
 	uint8_t channel = sme_rrm_ctx->chan_load_req_info.channel;
+	qdf_freq_t cen320_freq = 0;
 
 	rrm_get_country_code_from_connected_profile(mac_ctx,
 						    wlan_vdev_get_id(vdev),
@@ -1153,42 +1156,56 @@ sme_rrm_fill_freq_list_for_channel_load(struct mac_context *mac_ctx,
 		return QDF_STATUS_E_INVAL;
 	}
 
-	if (wlan_reg_is_6ghz_op_class(mac_ctx->pdev, sme_rrm_ctx->regClass))
-		chan_space = wlan_reg_get_op_class_width
-			(mac_ctx->pdev, sme_rrm_ctx->regClass, true);
-	else
-		chan_space = wlan_reg_dmn_get_chanwidth_from_opclass_auto(
-							country_code, channel,
+	bw_ind = &sme_rrm_ctx->chan_load_req_info.bw_ind;
+	wide_bw = &sme_rrm_ctx->chan_load_req_info.wide_bw;
+
+	if (bw_ind->is_bw_ind_element) {
+		chan_width = bw_ind->channel_width;
+		cen320_freq = bw_ind->center_freq;
+	} else if (wide_bw->is_wide_bw_chan_switch){
+		chan_width = wide_bw->channel_width;
+	} else {
+		if (wlan_reg_is_6ghz_op_class(mac_ctx->pdev,
+					      sme_rrm_ctx->regClass))
+			c_space =
+			    wlan_reg_get_op_class_width(mac_ctx->pdev,
+							sme_rrm_ctx->regClass,
+							true);
+		else
+			c_space = wlan_reg_dmn_get_chanwidth_from_opclass_auto(
+							country_code,
+							channel,
 							sme_rrm_ctx->regClass);
 
-	sme_debug("opclass: %d, channel: %d freq:%d, country code %c%c 0x%x, chan_space:%d",
-		  sme_rrm_ctx->regClass, channel, scan_freq,
-		  country_code[0], country_code[1], country_code[2],
-		  chan_space);
+		sme_debug("op: %d, ch: %d freq:%d, cc %c%c 0x%x, c_space:%d",
+			  sme_rrm_ctx->regClass, channel, scan_freq,
+			  country_code[0], country_code[1], country_code[2],
+			  c_space);
 
-	switch (chan_space) {
-	case 320:
-		fallthrough;
-	case 160:
-		chan_width = CH_WIDTH_160MHZ;
-		break;
-	case 80:
-		chan_width = CH_WIDTH_80MHZ;
-		break;
-	case 40:
-		chan_width = CH_WIDTH_40MHZ;
-		break;
-	case 20:
-	case 25:
-		chan_width = CH_WIDTH_20MHZ;
-		break;
-	default:
-		sme_err("invalid chan_space: %d", chan_space);
-		return QDF_STATUS_E_FAILURE;
+		switch (c_space) {
+		case 320:
+			fallthrough;
+		case 160:
+			chan_width = CH_WIDTH_160MHZ;
+			break;
+		case 80:
+			chan_width = CH_WIDTH_80MHZ;
+			break;
+		case 40:
+			chan_width = CH_WIDTH_40MHZ;
+			break;
+		case 20:
+		case 25:
+			chan_width = CH_WIDTH_20MHZ;
+			break;
+		default:
+			sme_err("invalid chan_space: %d", c_space);
+			return QDF_STATUS_E_FAILURE;
+		}
 	}
 
 	return mlme_update_freq_in_scan_start_req(vdev, req, chan_width,
-						  scan_freq);
+						  scan_freq, cen320_freq);
 }
 
 /**
@@ -1299,7 +1316,6 @@ static QDF_STATUS sme_rrm_process_chan_load_req_ind(struct mac_context *mac,
 {
 	struct ch_load_ind *chan_load;
 	tpRrmSMEContext sme_rrm_ctx;
-	uint32_t num_chan = 0;
 	tpRrmPEContext rrm_ctx;
 
 	chan_load = (struct ch_load_ind *)msg_buf;
@@ -1307,7 +1323,7 @@ static QDF_STATUS sme_rrm_process_chan_load_req_ind(struct mac_context *mac,
 	rrm_ctx = &mac->rrm.rrmPEContext;
 	qdf_mem_copy(sme_rrm_ctx->sessionBssId.bytes,
 		     chan_load->peer_addr.bytes, sizeof(struct qdf_mac_addr));
-	sme_rrm_ctx->channelList.numOfChannels = num_chan;
+
 	sme_rrm_ctx->token = chan_load->dialog_token;
 	sme_rrm_ctx->regClass = chan_load->op_class;
 	sme_rrm_ctx->randnIntvl = QDF_MAX(chan_load->randomization_intv,
@@ -1318,13 +1334,24 @@ static QDF_STATUS sme_rrm_process_chan_load_req_ind(struct mac_context *mac,
 		     SIR_ESE_MAX_MEAS_IE_REQS);
 	sme_rrm_ctx->measurement_type = RRM_CHANNEL_LOAD;
 	sme_rrm_ctx->chan_load_req_info.channel = chan_load->channel;
-	sme_debug("idx:%d, token: %d randnIntvl: %d meas_duration %d, rrm_ctx dur %d reg_class: %d, type: %d, channel: %d",
+
+	qdf_mem_copy(&sme_rrm_ctx->chan_load_req_info.bw_ind,
+			&chan_load->bw_ind,
+			sizeof(sme_rrm_ctx->chan_load_req_info.bw_ind));
+	qdf_mem_copy(&sme_rrm_ctx->chan_load_req_info.wide_bw,
+			&chan_load->wide_bw,
+			sizeof(sme_rrm_ctx->chan_load_req_info.wide_bw));
+
+	sme_debug("idx:%d, token: %d randnIntvl: %d meas_duration %d, rrm_ctx dur %d reg_class: %d, type: %d, channel: %d, [bw_ind cw:%d, ccfs0:%d], [wide_bw cw:%d]",
 		  chan_load->measurement_idx, sme_rrm_ctx->token,
 		  sme_rrm_ctx->randnIntvl,
 		  chan_load->meas_duration,
 		  sme_rrm_ctx->duration[0], sme_rrm_ctx->regClass,
 		  sme_rrm_ctx->measurement_type,
-		  sme_rrm_ctx->chan_load_req_info.channel);
+		  sme_rrm_ctx->chan_load_req_info.channel,
+		  sme_rrm_ctx->chan_load_req_info.bw_ind.channel_width,
+		  sme_rrm_ctx->chan_load_req_info.bw_ind.center_freq,
+		  sme_rrm_ctx->chan_load_req_info.wide_bw.channel_width);
 
 	return sme_rrm_issue_chan_load_measurement_scan(mac,
 						chan_load->measurement_idx);