qcacld-3.0: Add support for Channel load request frame

As per new requirement, to improve Wi-Fi Roaming behavior
DUT should support channel load request received as part
of rrm measurement.

The Channel Load request/report pair returns the channel
utilization measurement to AP as observed by the measuring
STA.

Change-Id: Idf1b5581222e1fbed3426d94edd8768234ff6a43
CRs-Fixed: 3580180

components/mlme/core/inc/wlan_mlme_main.h

@@ -1159,6 +1159,22 @@ QDF_STATUS wlan_mlme_get_bssid_vdev_id(struct wlan_objmgr_pdev *pdev,
 				       uint8_t vdev_id,
 				       struct qdf_mac_addr *bss_peer_mac);
 
+/**
+ * mlme_update_freq_in_scan_start_req() - Fill frequencies in wide
+ * band scan req for mlo connection
+ * @vdev: vdev common object
+ * @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
+ *
+ * Return: QDF_STATUS
+ */
+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);
+
 /**
  * wlan_get_operation_chan_freq() - get operating chan freq of
  * given vdev

components/mlme/core/src/wlan_mlme_main.c

@@ -362,19 +362,11 @@ wlan_scan_get_scan_phy_mode(struct wlan_objmgr_vdev *vdev, qdf_freq_t op_freq,
 	return scan_phymode;
 }
 
-/**
- * mlme_update_freq_in_scan_start_req() - Fill frequencies in wide
- * band scan req for mlo connection
- * @vdev: vdev common object
- * @req: pointer to scan request
- * @associated_ch_width: channel width at the time of initial connection
- *
- * Return: QDF_STATUS
- */
-static QDF_STATUS
+QDF_STATUS
 mlme_update_freq_in_scan_start_req(struct wlan_objmgr_vdev *vdev,
 				   struct scan_start_request *req,
-				   enum phy_ch_width associated_ch_width)
+				   enum phy_ch_width scan_ch_width,
+				   qdf_freq_t scan_freq)
 {
 	const struct bonded_channel_freq *range;
 	uint8_t num_chan;
@@ -383,14 +375,18 @@ mlme_update_freq_in_scan_start_req(struct wlan_objmgr_vdev *vdev,
 	uint8_t vdev_id;
 
 	vdev_id = vdev->vdev_objmgr.vdev_id;
-	op_freq = wlan_get_operation_chan_freq(vdev);
 
-	mlme_debug("vdev %d : fill ch list for op_freq:%d, assoc_ch_width: %d",
-		   vdev_id, op_freq, associated_ch_width);
+	if (scan_freq != INVALID_CHANNEL)
+		op_freq = scan_freq;
+	else
+		op_freq = wlan_get_operation_chan_freq(vdev);
+
+	mlme_debug("vdev %d : fill ch list for op_freq:%d, scan_ch_width: %d",
+		   vdev_id, op_freq, scan_ch_width);
 
-	if (associated_ch_width == CH_WIDTH_320MHZ) {
+	if (scan_ch_width == CH_WIDTH_320MHZ) {
 		range = wlan_reg_get_bonded_chan_entry(op_freq,
-						       associated_ch_width, 0);
+						       scan_ch_width, 0);
 		if (!range) {
 			mlme_debug("vdev %d : range is null for freq %d",
 				   vdev_id, op_freq);
@@ -494,7 +490,8 @@ mlme_fill_freq_in_mlo_wide_band_scan_start_req(struct wlan_objmgr_vdev *vdev,
 			}
 
 			status = mlme_update_freq_in_scan_start_req(mlo_vdev,
-						req, associated_ch_width);
+						req, associated_ch_width,
+						INVALID_CHANNEL);
 			if (QDF_IS_STATUS_ERROR(status))
 				return QDF_STATUS_E_FAILURE;
 		}
@@ -552,7 +549,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);
+						    associated_ch_width,
+						    INVALID_CHANNEL);
 	if (QDF_IS_STATUS_ERROR(status))
 		return QDF_STATUS_E_FAILURE;
 

core/mac/inc/wni_api.h

@@ -85,8 +85,8 @@ enum eWniMsgTypes {
 	eWNI_SME_NEIGHBOR_REPORT_IND = SIR_SME_MSG_TYPES_BEGIN + 44,
 	eWNI_SME_BEACON_REPORT_REQ_IND = SIR_SME_MSG_TYPES_BEGIN + 45,
 	eWNI_SME_BEACON_REPORT_RESP_XMIT_IND = SIR_SME_MSG_TYPES_BEGIN + 46,
+	eWNI_SME_CHAN_LOAD_REQ_IND = SIR_SME_MSG_TYPES_BEGIN + 47,
 
-	/* unused SIR_SME_MSG_TYPES_BEGIN + 47, */
 	/* unused SIR_SME_MSG_TYPES_BEGIN + 48, */
 	eWNI_SME_FT_AGGR_QOS_REQ = SIR_SME_MSG_TYPES_BEGIN + 52,
 	eWNI_SME_FT_AGGR_QOS_RSP = SIR_SME_MSG_TYPES_BEGIN + 53,

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

@@ -1,6 +1,6 @@
 /*
  * Copyright (c) 2011-2012, 2014-2020 The Linux Foundation. All rights reserved.
- * Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
+ * Copyright (c) 2022-2023 Qualcomm Innovation Center, Inc. All rights reserved.
  *
  * Permission to use, copy, modify, and/or distribute this software for
  * any purpose with or without fee is hereby granted, provided that the
@@ -52,6 +52,32 @@ struct sir_channel_info {
 	uint32_t chan_freq;
 };
 
+/**
+ * struct ch_load_ind - Contains info for channel load request received from AP
+ * @message_type: message type eWNI_SME_CHAN_LOAD_REQ_IND
+ * @length: size of struct chan_load_req_ind
+ * @measurement_idx: measurement index for channel load request
+ * @peer_addr: connected peer mac address
+ * @dialog_token: dialog token
+ * @msg_source: message source of type enum tRrmMsgReqSource
+ * @op_class: regulatory class
+ * @channel: channel number
+ * @randomization_intv: Random interval in ms
+ * @meas_duration: measurement duration in ms
+ */
+struct ch_load_ind {
+	uint16_t message_type;
+	uint16_t length;
+	uint8_t measurement_idx;
+	struct qdf_mac_addr peer_addr;
+	uint16_t dialog_token;
+	tRrmMsgReqSource msg_source;
+	uint8_t op_class;
+	uint8_t channel;
+	uint16_t randomization_intv;
+	uint16_t meas_duration;
+};
+
 typedef struct sSirBeaconReportReqInd {
 	uint16_t messageType;   /* eWNI_SME_BEACON_REPORT_REQ_IND */
 	uint16_t length;

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

@@ -46,6 +46,9 @@
 #include "wlan_lmac_if_def.h"
 #include "wlan_reg_services_api.h"
 
+/* Max passive scan dwell for wide band rrm scan, in milliseconds */
+#define RRM_SCAN_MAX_DWELL_TIME 110
+
 /* -------------------------------------------------------------------- */
 /**
  * rrm_cache_mgmt_tx_power
@@ -609,6 +612,47 @@ wlan_diag_log_beacon_rpt_req_event(uint8_t token, uint8_t mode,
 
 #define ABS(x)      ((x < 0) ? -x : x)
 /* -------------------------------------------------------------------- */
+/**
+ * rrm_get_max_meas_duration() - calculate max measurement duration for a
+ * rrm req
+ * @mac: global mac context
+ * @pe_session: per vdev pe context
+ *
+ * Return: max measurement duration
+ */
+static uint16_t rrm_get_max_meas_duration(struct mac_context *mac,
+					  struct pe_session *pe_session)
+{
+	int8_t max_dur;
+	uint16_t max_meas_dur, sign;
+
+	/*
+	 * The logic here is to check the measurement duration passed in the
+	 * beacon request. Following are the cases handled.
+	 * Case 1: If measurement duration received in the beacon request is
+	 * greater than the max measurement duration advertised in the RRM
+	 * capabilities(Assoc Req), and Duration Mandatory bit is set to 1,
+	 * REFUSE the beacon request.
+	 * Case 2: If measurement duration received in the beacon request is
+	 * greater than the max measurement duration advertised in the RRM
+	 * capabilities(Assoc Req), and Duration Mandatory bit is set to 0,
+	 * perform measurement for the duration advertised in the
+	 * RRM capabilities
+	 * maxMeasurementDuration = 2^(nonOperatingChanMax - 4) * BeaconInterval
+	 */
+	max_dur = mac->rrm.rrmPEContext.rrmEnabledCaps.nonOperatingChanMax - 4;
+	sign = (max_dur < 0) ? 1 : 0;
+	max_dur = (1L << ABS(max_dur));
+	if (!sign)
+		max_meas_dur =
+			max_dur * pe_session->beaconParams.beaconInterval;
+	else
+		max_meas_dur =
+			pe_session->beaconParams.beaconInterval / max_dur;
+
+	return max_meas_dur;
+}
+
 /**
  * rrm_process_beacon_report_req
  *
@@ -635,8 +679,6 @@ rrm_process_beacon_report_req(struct mac_context *mac,
 	tpSirBeaconReportReqInd psbrr;
 	uint8_t num_rpt, idx_rpt;
 	uint16_t measDuration, maxMeasduration;
-	int8_t maxDuration;
-	uint8_t sign;
 	tDot11fIEAPChannelReport *ie_ap_chan_rpt;
 	uint8_t tmp_idx, buf_left, buf_cons;
 	uint16_t ch_ctr = 0;
@@ -650,9 +692,8 @@ rrm_process_beacon_report_req(struct mac_context *mac,
 		return eRRM_INCAPABLE;
 	}
 
-	if (pBeaconReq->measurement_request.Beacon.BeaconReporting.present &&
-	    (pBeaconReq->measurement_request.Beacon.BeaconReporting.
-	     reportingCondition != 0)) {
+	if (pBeaconReq->measurement_request.Beacon.rrm_reporting.present &&
+	    (pBeaconReq->measurement_request.Beacon.rrm_reporting.reporting_condition != 0)) {
 		/* Repeated measurement is not supported. This means number of repetitions should be zero.(Already checked) */
 		/* All test case in VoWifi(as of version 0.36)  use zero for number of repetitions. */
 		/* Beacon reporting should not be included in request if number of repetitons is zero. */
@@ -662,33 +703,14 @@ rrm_process_beacon_report_req(struct mac_context *mac,
 		return eRRM_INCAPABLE;
 	}
 
-	/* The logic here is to check the measurement duration passed in the beacon request. Following are the cases handled.
-	   Case 1: If measurement duration received in the beacon request is greater than the max measurement duration advertised
-	   in the RRM capabilities(Assoc Req), and Duration Mandatory bit is set to 1, REFUSE the beacon request
-	   Case 2: If measurement duration received in the beacon request is greater than the max measurement duration advertised
-	   in the RRM capabilities(Assoc Req), and Duration Mandatory bit is set to 0, perform measurement for
-	   the duration advertised in the RRM capabilities
-
-	   maxMeasurementDuration = 2^(nonOperatingChanMax - 4) * BeaconInterval
-	 */
-	maxDuration =
-		mac->rrm.rrmPEContext.rrmEnabledCaps.nonOperatingChanMax - 4;
-	sign = (maxDuration < 0) ? 1 : 0;
-	maxDuration = (1L << ABS(maxDuration));
-	if (!sign)
-		maxMeasduration =
-			maxDuration * pe_session->beaconParams.beaconInterval;
-	else
-		maxMeasduration =
-			pe_session->beaconParams.beaconInterval / maxDuration;
-
+	maxMeasduration = rrm_get_max_meas_duration(mac, pe_session);
 	if( pBeaconReq->measurement_request.Beacon.meas_mode ==
 	   eSIR_PASSIVE_SCAN)
 		maxMeasduration += 10;
 
 	measDuration = pBeaconReq->measurement_request.Beacon.meas_duration;
 
-	pe_nofl_info("RX: [802.11 BCN_RPT] seq:%d SSID:" QDF_SSID_FMT " BSSID:" QDF_MAC_ADDR_FMT " Token:%d op_class:%d ch:%d meas_mode:%d meas_duration:%d max_dur: %d sign: %d max_meas_dur: %d",
+	pe_nofl_info("RX: [802.11 BCN_RPT] seq:%d SSID:" QDF_SSID_FMT " BSSID:" QDF_MAC_ADDR_FMT " Token:%d op_class:%d ch:%d meas_mode:%d meas_duration:%d max_meas_dur: %d",
 		     mac->rrm.rrmPEContext.prev_rrm_report_seq_num,
 		     QDF_SSID_REF(
 			pBeaconReq->measurement_request.Beacon.SSID.num_ssid,
@@ -699,7 +721,7 @@ rrm_process_beacon_report_req(struct mac_context *mac,
 		     pBeaconReq->measurement_request.Beacon.regClass,
 		     pBeaconReq->measurement_request.Beacon.channel,
 		     pBeaconReq->measurement_request.Beacon.meas_mode,
-		     measDuration, maxDuration, sign, maxMeasduration);
+		     measDuration, maxMeasduration);
 
 	req_mode = (pBeaconReq->parallel << 0) | (pBeaconReq->enable << 1) |
 		   (pBeaconReq->request << 2) | (pBeaconReq->report << 3) |
@@ -1371,6 +1393,193 @@ QDF_STATUS rrm_process_beacon_req(struct mac_context *mac_ctx, tSirMacAddr peer,
 	return QDF_STATUS_SUCCESS;
 }
 
+
+/**
+ * rrm_process_channel_load_req() - process channel load request from AP
+ * @mac: global mac context
+ * @pe_session: per-vdev PE context
+ * @curr_req: current measurement req in progress
+ * @peer: Macaddress of the peer requesting the radio measurement
+ * @chan_load_req: channel load request received from AP
+ *
+ * return tRrmRetStatus
+ */
+static tRrmRetStatus
+rrm_process_channel_load_req(struct mac_context *mac,
+			     struct pe_session *pe_session,
+			     tpRRMReq curr_req, tSirMacAddr peer,
+			     tDot11fIEMeasurementRequest *chan_load_req)
+{
+	struct scheduler_msg msg = {0};
+	struct ch_load_ind *load_ind;
+	uint8_t op_class, channel, reporting_condition;
+	uint16_t randomization_intv, meas_duration, max_meas_duration;
+	bool present;
+
+	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;
+	}
+
+	op_class = chan_load_req->measurement_request.channel_load.op_class;
+	channel = chan_load_req->measurement_request.channel_load.channel;
+	meas_duration =
+		chan_load_req->measurement_request.channel_load.meas_duration;
+	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");
+			return eRRM_REFUSED;
+		} else {
+			meas_duration = max_meas_duration;
+		}
+	}
+	pe_debug("RX:[802.11 CH_LOAD] seq:%d Token:%d op_c:%d ch:%d meas_dur:%d, rand intv: %d, max_dur:%d",
+		 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;
+
+	/* Prepare the request to send to SME. */
+	load_ind = qdf_mem_malloc(sizeof(struct ch_load_ind));
+	if (!load_ind)
+		return eRRM_FAILURE;
+
+	qdf_mem_copy(load_ind->peer_addr.bytes, peer,
+		     sizeof(struct qdf_mac_addr));
+	load_ind->message_type = eWNI_SME_CHAN_LOAD_REQ_IND;
+	load_ind->length = sizeof(struct ch_load_ind);
+	load_ind->dialog_token = chan_load_req->measurement_token;
+	load_ind->msg_source = eRRM_MSG_SOURCE_11K;
+	load_ind->randomization_intv = SYS_TU_TO_MS(randomization_intv);
+	load_ind->measurement_idx = curr_req->measurement_idx;
+	load_ind->channel = channel;
+	load_ind->op_class = op_class;
+	load_ind->meas_duration = meas_duration;
+	curr_req->token = chan_load_req->measurement_token;
+	/* Send request to SME. */
+	msg.type = eWNI_SME_CHAN_LOAD_REQ_IND;
+	msg.bodyptr = load_ind;
+	MTRACE(mac_trace(mac, TRACE_CODE_TX_SME_MSG,
+			 pe_session->vdev_id, msg.type));
+	lim_sys_process_mmh_msg_api(mac, &msg);
+	return eRRM_SUCCESS;
+}
+
+/**
+ * rrm_process_chan_load_request_failure() - process channel load request
+ * in case of failure
+ * @mac: global mac context
+ * @pe_session: per-vdev PE context
+ * @peer: peer mac address
+ * @status:failure status of channel load request
+ * @index: request index
+ *
+ * return none
+ */
+static void
+rrm_process_chan_load_request_failure(struct mac_context *mac,
+				      struct pe_session *pe_session,
+				      tSirMacAddr peer,
+				      tRrmRetStatus status, uint8_t index)
+{
+	tpSirMacRadioMeasureReport report = NULL;
+	tpRRMReq curr_req = mac->rrm.rrmPEContext.pCurrentReq[index];
+
+	if (!curr_req) {
+		pe_debug("Current request is NULL");
+		goto cleanup;
+	}
+	report = qdf_mem_malloc(sizeof(tSirMacRadioMeasureReport));
+	if (!report)
+		goto cleanup;
+	report->token = curr_req->token;
+	report->type = SIR_MAC_RRM_CHANNEL_LOAD_TYPE;
+	pe_debug("vdev:%d measurement index:%d status %d token %d",
+		 pe_session->vdev_id, index, status, report->token);
+	switch (status) {
+	case eRRM_REFUSED:
+	case eRRM_FAILURE:
+		report->refused = 1;
+		break;
+	case eRRM_INCAPABLE:
+		report->incapable = 1;
+		break;
+	default:
+		goto free;
+	}
+
+	lim_send_radio_measure_report_action_frame(mac, curr_req->dialog_token,
+						   1, true, report, peer,
+						   pe_session);
+free:
+	qdf_mem_free(report);
+cleanup:
+	rrm_cleanup(mac, index);
+}
+
+/**
+ * rrm_process_chan_load_req() - process channel load request
+ * @mac_ctx: Global pointer to MAC context
+ * @session_entry: session entry
+ * @report: Pointer to radio measurement report
+ * @rrm_req: Array of Measurement request IEs
+ * @peer: mac address of the peer requesting the radio measurement
+ * @num_report: No.of reports
+ * @index: Index for Measurement request
+ *
+ * Update structure sRRMReq and struct chan_load_req_ind and pass it to
+ * rrm_process_channel_load_req().
+ *
+ * Return: QDF_STATUS
+ */
+static QDF_STATUS
+rrm_process_chan_load_req(struct mac_context *mac_ctx,
+			  struct pe_session *session_entry,
+			  tpSirMacRadioMeasureReport *report,
+			  tDot11fRadioMeasurementRequest *rrm_req,
+			  tSirMacAddr peer, uint8_t *num_report, int index)
+{
+	tRrmRetStatus rrm_status = eRRM_SUCCESS;
+	tpRRMReq curr_req;
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
+
+	if (index  >= MAX_MEASUREMENT_REQUEST) {
+		status = rrm_reject_req(report, rrm_req, num_report, index,
+			       rrm_req->MeasurementRequest[0].measurement_type);
+		return status;
+	}
+
+	curr_req = qdf_mem_malloc(sizeof(*curr_req));
+	if (!curr_req) {
+		mac_ctx->rrm.rrmPEContext.pCurrentReq[index] = NULL;
+		return QDF_STATUS_E_NOMEM;
+	}
+
+	curr_req->dialog_token = rrm_req->DialogToken.token;
+	curr_req->token =
+		rrm_req->MeasurementRequest[index].measurement_token;
+	curr_req->measurement_idx = index;
+	mac_ctx->rrm.rrmPEContext.pCurrentReq[index] = curr_req;
+	mac_ctx->rrm.rrmPEContext.num_active_request++;
+	pe_debug("Processing channel load req index: %d num_active_req:%d",
+		 index, mac_ctx->rrm.rrmPEContext.num_active_request);
+	rrm_status = rrm_process_channel_load_req(mac_ctx, session_entry,
+				curr_req, peer,
+				&rrm_req->MeasurementRequest[index]);
+	if (eRRM_SUCCESS != rrm_status)
+		rrm_process_chan_load_request_failure(mac_ctx, session_entry,
+						      peer, rrm_status, index);
+
+	return QDF_STATUS_SUCCESS;
+}
+
 /**
  * update_rrm_report() - Set incapable bit
  * @mac_ctx: Global pointer to MAC context
@@ -1532,6 +1741,16 @@ rrm_process_radio_measurement_request(struct mac_context *mac_ctx,
 
 	for (i = 0; i < rrm_req->num_MeasurementRequest; i++) {
 		switch (rrm_req->MeasurementRequest[i].measurement_type) {
+		case SIR_MAC_RRM_CHANNEL_LOAD_TYPE:
+			/* Process channel load request */
+			status = rrm_process_chan_load_req(mac_ctx,
+							   session_entry,
+							   &report,
+							   rrm_req, peer,
+							   &num_report, i);
+			if (QDF_IS_STATUS_ERROR(status))
+				return status;
+			break;
 		case SIR_MAC_RRM_BEACON_TYPE:
 			/* Process beacon request. */
 			status = rrm_process_beacon_req(mac_ctx, peer,

core/mac/src/sys/legacy/src/utils/src/mac_trace.c

@@ -215,6 +215,7 @@ uint8_t *mac_trace_get_sme_msg_string(uint16_t sme_msg)
 		CASE_RETURN_STRING(eWNI_SME_NEIGHBOR_REPORT_IND);
 		CASE_RETURN_STRING(eWNI_SME_BEACON_REPORT_REQ_IND);
 		CASE_RETURN_STRING(eWNI_SME_BEACON_REPORT_RESP_XMIT_IND);
+		CASE_RETURN_STRING(eWNI_SME_CHAN_LOAD_REQ_IND);
 		CASE_RETURN_STRING(eWNI_SME_FT_AGGR_QOS_REQ);
 		CASE_RETURN_STRING(eWNI_SME_FT_AGGR_QOS_RSP);
 #if defined FEATURE_WLAN_ESE

core/sme/inc/sme_rrm_internal.h

@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2011-2012, 2014-2018, 2020 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2023 Qualcomm Innovation Center, Inc. All rights reserved.
  *
  * Permission to use, copy, modify, and/or distribute this software for
  * any purpose with or without fee is hereby granted, provided that the
@@ -60,11 +61,33 @@ typedef struct sRrmNeighborRequestControlInfo {
 	tRrmNeighborRspCallbackInfo neighborRspCallbackInfo;
 } tRrmNeighborRequestControlInfo, *tpRrmNeighborRequestControlInfo;
 
+/**
+ * enum rrm_measurement_type: measurement type
+ * @RRM_CHANNEL_LOAD: measurement type for channel load req
+ * @RRM_BEACON_REPORT: measurement type for beacon report request
+ */
+enum rrm_measurement_type {
+	RRM_CHANNEL_LOAD = 0,
+	RRM_BEACON_REPORT = 1,
+};
+
+/**
+ * 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
+ */
+struct channel_load_req_info {
+	uint8_t channel;
+	qdf_time_t rrm_scan_tsf;
+};
+
 typedef struct sRrmSMEContext {
 	uint16_t token;
 	struct qdf_mac_addr sessionBssId;
 	uint8_t regClass;
 	uint8_t measurement_idx;
+	enum rrm_measurement_type measurement_type;
+	struct channel_load_req_info chan_load_req_info;
 	/* list of all channels to be measured. */
 	tCsrChannelInfo channelList;
 	uint8_t currentIndex;

core/sme/src/common/sme_api.c

@@ -2696,6 +2696,7 @@ QDF_STATUS sme_process_msg(struct mac_context *mac, struct scheduler_msg *pMsg)
 		break;
 	case eWNI_SME_NEIGHBOR_REPORT_IND:
 	case eWNI_SME_BEACON_REPORT_REQ_IND:
+	case eWNI_SME_CHAN_LOAD_REQ_IND:
 		if (pMsg->bodyptr) {
 			status = sme_rrm_msg_processor(mac, pMsg->type,
 						       pMsg->bodyptr);

core/sme/src/rrm/sme_rrm.c

@@ -1057,6 +1057,213 @@ static uint8_t *sme_rrm_get_meas_mode_string(uint8_t meas_mode)
 	}
 }
 
+/**
+ * sme_rrm_fill_freq_list_for_channel_load() : Trigger wide band scan request
+ * to measure channel load
+ * @mac_ctx: global mac structure
+ * @sme_rrm_ctx: pointer to sme rrm context structure
+ * @vdev: vdev common object
+ * @req: scan request config
+ *
+ * Return : QDF_STATUS
+ */
+static QDF_STATUS
+sme_rrm_fill_freq_list_for_channel_load(struct mac_context *mac_ctx,
+					tpRrmSMEContext sme_rrm_ctx,
+					struct wlan_objmgr_vdev *vdev,
+					struct scan_start_request *req)
+{
+	uint16_t chan_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;
+
+	rrm_get_country_code_from_connected_profile(mac_ctx,
+						    wlan_vdev_get_id(vdev),
+						    country_code);
+	scan_freq = wlan_reg_country_chan_opclass_to_freq(mac_ctx->pdev,
+							  country_code,
+							  channel,
+							  sme_rrm_ctx->regClass,
+							  false);
+	if (!scan_freq) {
+		sme_debug("invalid scan freq");
+		return QDF_STATUS_E_INVAL;
+	}
+
+	sme_debug("opclass: %d, channel: %d freq:%d, country code %c%c 0x%x",
+		  sme_rrm_ctx->regClass, channel, scan_freq,
+		  country_code[0], country_code[1], country_code[2]);
+	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,
+							sme_rrm_ctx->regClass);
+	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;
+	}
+
+	return mlme_update_freq_in_scan_start_req(vdev, req, chan_width,
+						  scan_freq);
+}
+
+/**
+ * sme_rrm_issue_chan_load_measurement_scan() : Trigger wide band scan request
+ * to measure channel load
+ * @mac_ctx: global mac structure
+ * @idx: measurement request index
+ *
+ * Return : QDF_STATUS
+ */
+static QDF_STATUS
+sme_rrm_issue_chan_load_measurement_scan(struct mac_context *mac_ctx,
+					 uint8_t idx)
+{
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
+	tpRrmSMEContext sme_rrm_ctx = &mac_ctx->rrm.rrmSmeContext[idx];
+	uint32_t max_chan_time;
+	struct scan_start_request *req;
+	struct wlan_objmgr_vdev *vdev;
+	uint32_t vdev_id;
+
+	status = csr_roam_get_session_id_from_bssid(mac_ctx,
+						    &sme_rrm_ctx->sessionBssId,
+						    &vdev_id);
+	if (QDF_IS_STATUS_ERROR(status)) {
+		sme_err("sme session ID not found for bssid "QDF_MAC_ADDR_FMT"",
+			QDF_MAC_ADDR_REF(sme_rrm_ctx->sessionBssId.bytes));
+		goto send_ind;
+	}
+
+	vdev = wlan_objmgr_get_vdev_by_id_from_psoc(mac_ctx->psoc, vdev_id,
+						    WLAN_LEGACY_SME_ID);
+	if (!vdev) {
+		sme_err("VDEV is null %d", vdev_id);
+		status = QDF_STATUS_E_INVAL;
+		goto send_ind;
+	}
+
+	req = qdf_mem_malloc(sizeof(*req));
+	if (!req) {
+		status = QDF_STATUS_E_NOMEM;
+		goto error_handle;
+	}
+
+	status = wlan_scan_init_default_params(vdev, req);
+	if (QDF_IS_STATUS_ERROR(status))
+		goto error_handle;
+
+	req->scan_req.scan_id = wlan_scan_get_scan_id(mac_ctx->psoc);
+	sme_rrm_ctx->scan_id = req->scan_req.scan_id;
+	req->scan_req.vdev_id = wlan_vdev_get_id(vdev);
+	req->scan_req.scan_req_id = sme_rrm_ctx->req_id;
+	req->scan_req.scan_f_passive = true;
+	max_chan_time = sme_rrm_ctx->duration[0];
+	req->scan_req.dwell_time_passive = max_chan_time;
+	req->scan_req.dwell_time_passive_6g = max_chan_time;
+	req->scan_req.adaptive_dwell_time_mode = SCAN_DWELL_MODE_STATIC;
+	req->scan_req.scan_type = SCAN_TYPE_RRM;
+	req->scan_req.scan_f_wide_band = true;
+	/*
+	 * FW report CCA busy for each possible 20Mhz subbands of the
+	 * wideband scan channel if below flag is true
+	 */
+	req->scan_req.scan_f_report_cca_busy_for_each_20mhz = true;
+
+	status = sme_rrm_fill_freq_list_for_channel_load(mac_ctx, sme_rrm_ctx,
+							 vdev, req);
+	if (QDF_IS_STATUS_ERROR(status))
+		goto error_handle;
+	sme_debug("vdev:%d, rrm_idx:%d scan_id:%d num chan: %d dwell_time: %d",
+		  req->scan_req.vdev_id, sme_rrm_ctx->measurement_idx,
+		  sme_rrm_ctx->scan_id,
+		  req->scan_req.chan_list.num_chan,
+		  req->scan_req.dwell_time_passive);
+	/* store jiffies to send it in channel load report */
+	sme_rrm_ctx->chan_load_req_info.rrm_scan_tsf =
+				(uint32_t)qdf_system_ticks();
+	status = wlan_scan_start(req);
+	if (QDF_IS_STATUS_ERROR(status))
+		goto error_handle;
+
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_SME_ID);
+	return status;
+error_handle:
+	qdf_mem_free(req);
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_SME_ID);
+send_ind:
+	//TODO: Send channel load report xmit indication and free current req
+	return status;
+}
+
+/**
+ * sme_rrm_process_chan_load_req_ind() -Process beacon report request
+ * @mac: Global Mac structure
+ * @msg_buf: a pointer to a buffer that maps to various structures base
+ * on the message type.The beginning of the buffer can always
+ * map to tSirSmeRsp.
+ *
+ * This is called to process the channel load report request from peer AP
+ * forwarded through PE .
+ *
+ * Return : QDF_STATUS_SUCCESS - Validation is successful.
+ */
+static QDF_STATUS sme_rrm_process_chan_load_req_ind(struct mac_context *mac,
+						    void *msg_buf)
+{
+	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;
+	sme_rrm_ctx = &mac->rrm.rrmSmeContext[chan_load->measurement_idx];
+	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,
+			mac->rrm.rrmConfig.max_randn_interval);
+	sme_rrm_ctx->currentIndex = 0;
+	qdf_mem_copy((uint8_t *)&sme_rrm_ctx->duration,
+		     (uint8_t *)&chan_load->meas_duration,
+		     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",
+		  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);
+
+	return sme_rrm_issue_chan_load_measurement_scan(mac,
+						chan_load->measurement_idx);
+}
+
 /**
  * sme_rrm_process_beacon_report_req_ind() -Process beacon report request
  * @mac:- Global Mac structure
@@ -1655,6 +1862,10 @@ QDF_STATUS sme_rrm_msg_processor(struct mac_context *mac, uint16_t msg_type,
 		sme_rrm_process_beacon_report_req_ind(mac, msg_buf);
 		break;
 
+	case eWNI_SME_CHAN_LOAD_REQ_IND:
+		sme_rrm_process_chan_load_req_ind(mac, msg_buf);
+		break;
+
 	default:
 		sme_err("Unknown msg type: %d", msg_type);
 		break;