Merge "qcacmn: add useful debug prints"

dp/wifi3.0/dp_main.c

@@ -3710,7 +3710,8 @@ void dp_aggregate_vdev_stats(struct dp_vdev *vdev)
 			peer->stats.tx.last_ack_rssi;
 	}
 
-	soc->cdp_soc.ol_ops->update_dp_stats(vdev->pdev->osif_pdev,
+	if (soc->cdp_soc.ol_ops->update_dp_stats)
+		soc->cdp_soc.ol_ops->update_dp_stats(vdev->pdev->osif_pdev,
 			&vdev->stats, vdev->vdev_id, UPDATE_VDEV_STATS);
 }
 

qdf/Kbuild

@@ -26,7 +26,8 @@ INCS += -I$(obj)/$(HOST_CMN_CONVG_PTT)/inc \
         -I$(obj)/$(HOST_CMN_CONVG_LOGGING)/inc \
         -I$(obj)/$(DEPTH)/cmn_dev/utils/host_diag_log/inc \
         -I$(obj)/$(DEPTH)/cmn_dev/utils/host_diag_log/src \
-        -I$(obj)/$(DEPTH)/cmn_dev/utils/ptt/inc
+        -I$(obj)/$(DEPTH)/cmn_dev/utils/ptt/inc \
+        -I$(obj)/$(DEPTH)/cmn_dev/pld_stub/inc
 
 obj-m += qdf.o
 

umac/cmn_services/crypto/src/wlan_crypto_ccmp.c

@@ -237,8 +237,8 @@ const struct wlan_crypto_cipher ccmp_cipher_table = {
 	"AES-CCM",
 	WLAN_CRYPTO_CIPHER_AES_CCM,
 	WLAN_CRYPTO_IV_LEN + WLAN_CRYPTO_KEYID_LEN + WLAN_CRYPTO_EXT_IV_LEN,
-	WLAN_CRYPTO_MIC_LEN,
 	0,
+	WLAN_CRYPTO_MIC_LEN,
 	128,
 	ccmp_setkey,
 	ccmp_encap,
@@ -252,8 +252,8 @@ const struct wlan_crypto_cipher ccmp256_cipher_table = {
 	"AES-CCM256",
 	WLAN_CRYPTO_CIPHER_AES_CCM_256,
 	WLAN_CRYPTO_IV_LEN + WLAN_CRYPTO_KEYID_LEN + WLAN_CRYPTO_EXT_IV_LEN,
-	WLAN_CRYPTO_MIC256_LEN,
 	0,
+	WLAN_CRYPTO_MIC256_LEN,
 	256,
 	ccmp_setkey,
 	ccmp_encap,
@@ -267,8 +267,8 @@ const struct wlan_crypto_cipher gcmp_cipher_table = {
 	"AES-GCM",
 	WLAN_CRYPTO_CIPHER_AES_GCM,
 	WLAN_CRYPTO_IV_LEN + WLAN_CRYPTO_KEYID_LEN + WLAN_CRYPTO_EXT_IV_LEN,
-	WLAN_CRYPTO_MIC_LEN,
 	0,
+	WLAN_CRYPTO_MIC_LEN,
 	128,
 	ccmp_setkey,
 	ccmp_encap,
@@ -282,8 +282,8 @@ const struct wlan_crypto_cipher gcmp256_cipher_table = {
 	"AES-GCM256",
 	WLAN_CRYPTO_CIPHER_AES_GCM_256,
 	WLAN_CRYPTO_IV_LEN + WLAN_CRYPTO_KEYID_LEN + WLAN_CRYPTO_EXT_IV_LEN,
-	WLAN_CRYPTO_MIC256_LEN,
 	0,
+	WLAN_CRYPTO_MIC256_LEN,
 	256,
 	ccmp_setkey,
 	ccmp_encap,

umac/cmn_services/obj_mgr/src/wlan_objmgr_psoc_obj.c

@@ -812,9 +812,9 @@ QDF_STATUS wlan_objmgr_psoc_vdev_attach(struct wlan_objmgr_psoc *psoc,
 		 * The map is two DWORDS(32 bits), so, map_index
 		 * adjust_ix derived based on the id value
 		 */
-		if (id == ((map_index+1)*map_entry_size)) {
-			adjust_ix = map_index*map_entry_size;
+		if (id == ((map_index + 1) * map_entry_size)) {
 			map_index++;
+			adjust_ix = map_index * map_entry_size;
 		}
 	}
 	/* If no free slot, return failure */

umac/global_umac_dispatcher/lmac_if/inc/wlan_lmac_if_def.h

@@ -604,6 +604,8 @@ struct wlan_lmac_if_reg_rx_ops {
 			enum dfs_reg *dfs_reg);
 	QDF_STATUS (*reg_ch_avoid_event_handler)(struct wlan_objmgr_psoc *psoc,
 			struct ch_avoid_ind_type *ch_avoid_ind);
+	uint32_t (*reg_freq_to_chan)(struct wlan_objmgr_pdev *pdev,
+			uint32_t freq);
 };
 
 #ifdef CONVERGED_P2P_ENABLE

umac/global_umac_dispatcher/lmac_if/src/wlan_lmac_if.c

@@ -211,6 +211,9 @@ static void wlan_lmac_if_umac_reg_rx_ops_register(
 
 	rx_ops->reg_rx_ops.reg_ch_avoid_event_handler =
 		tgt_reg_process_ch_avoid_event;
+
+	rx_ops->reg_rx_ops.reg_freq_to_chan =
+		wlan_reg_freq_to_chan;
 }
 
 #ifdef CONVERGED_P2P_ENABLE

umac/regulatory/core/src/reg_services.c

@@ -1750,7 +1750,7 @@ static void reg_populate_band_channels(enum channel_enum start_chan,
 				       enum channel_enum end_chan,
 				       struct cur_reg_rule *rule_start_ptr,
 				       uint32_t num_reg_rules,
-				       uint16_t min_bw,
+				       uint16_t min_reg_bw,
 				       struct regulatory_channel *mas_chan_list)
 {
 	struct cur_reg_rule *found_rule_ptr;
@@ -1759,19 +1759,23 @@ static void reg_populate_band_channels(enum channel_enum start_chan,
 	enum channel_enum chan_enum;
 	uint32_t rule_num, bw;
 	uint16_t max_bw;
+	uint16_t min_bw;
 
 	for (chan_enum = start_chan; chan_enum <= end_chan; chan_enum++) {
 		found_rule_ptr = NULL;
 
 		max_bw = QDF_MIN((uint16_t)20, channel_map[chan_enum].max_bw);
-		min_bw = QDF_MAX(min_bw, channel_map[chan_enum].min_bw);
+		min_bw = QDF_MAX(min_reg_bw, channel_map[chan_enum].min_bw);
 
-		for (bw = max_bw; ((bw >= min_bw) && (NULL == found_rule_ptr));
-		     bw = bw/2) {
+		if (channel_map[chan_enum].chan_num == INVALID_CHANNEL_NUM)
+			continue;
+
+		for (bw = max_bw; bw >= min_bw; bw = bw/2) {
 			for (rule_num = 0, cur_rule_ptr =
 				     rule_start_ptr;
 			     rule_num < num_reg_rules;
 			     cur_rule_ptr++, rule_num++) {
+
 				if ((cur_rule_ptr->start_freq <=
 				     mas_chan_list[chan_enum].center_freq -
 				     bw/2) &&
@@ -1782,11 +1786,13 @@ static void reg_populate_band_channels(enum channel_enum start_chan,
 					break;
 				}
 			}
-			break;
+			if (found_rule_ptr)
+				break;
 		}
 
 		if (found_rule_ptr) {
 			mas_chan_list[chan_enum].max_bw = bw;
+
 			reg_fill_channel_info(chan_enum, found_rule_ptr,
 					      mas_chan_list, min_bw);
 		}
@@ -2610,6 +2616,12 @@ QDF_STATUS reg_process_master_chan_list(struct cur_regulatory_info
 					   reg_rule_5g, num_5g_reg_rules,
 					   min_bw_5g, mas_chan_list);
 
+	if (num_5g_reg_rules != 0)
+		reg_populate_band_channels(MIN_49GHZ_CHANNEL,
+					MAX_49GHZ_CHANNEL,
+					reg_rule_5g, num_5g_reg_rules,
+					min_bw_5g, mas_chan_list);
+
 	soc_reg->cc_src = SOURCE_DRIVER;
 	if (soc_reg->new_user_ctry_pending == true) {
 		soc_reg->new_user_ctry_pending = false;

umac/regulatory/core/src/reg_services.h

@@ -47,6 +47,15 @@
 	((chan_num >= REG_MIN_24GHZ_CH_NUM) &&	\
 	 (chan_num <= REG_MAX_24GHZ_CH_NUM))
 
+#ifndef CONFIG_LEGACY_CHAN_ENUM
+#define REG_MIN_49GHZ_CH_FREQ channel_map[MIN_49GHZ_CHANNEL].center_freq
+#define REG_MAX_49GHZ_CH_FREQ channel_map[MAX_49GHZ_CHANNEL].center_freq
+
+#define REG_IS_49GHZ_FREQ(freq) \
+	((freq >= REG_MIN_49GHZ_CH_FREQ) &&   \
+	(freq <= REG_MAX_49GHZ_CH_FREQ))
+#endif
+
 #define REG_IS_5GHZ_CH(chan_num) \
 	((chan_num >= REG_MIN_5GHZ_CH_NUM) &&	\
 	 (chan_num <= REG_MAX_5GHZ_CH_NUM))

umac/regulatory/dispatcher/inc/reg_services_public_struct.h

@@ -170,6 +170,10 @@ enum channel_enum {
 	MAX_24GHZ_CHANNEL = CHAN_ENUM_14,
 	NUM_24GHZ_CHANNELS = (MAX_24GHZ_CHANNEL - MIN_24GHZ_CHANNEL + 1),
 
+	MIN_49GHZ_CHANNEL = INVALID_CHANNEL_NUM,
+	MAX_49GHZ_CHANNEL = INVALID_CHANNEL_NUM - 1,
+	NUM_49GHZ_CHANNELS = MAX_49GHZ_CHANNEL - MIN_49GHZ_CHANNEL + 1,
+
 	MIN_5GHZ_CHANNEL = CHAN_ENUM_36,
 	MAX_5GHZ_CHANNEL = CHAN_ENUM_184,
 	NUM_5GHZ_CHANNELS = (MAX_5GHZ_CHANNEL - MIN_5GHZ_CHANNEL + 1),
@@ -389,6 +393,10 @@ enum channel_enum {
 	MAX_24GHZ_CHANNEL = CHAN_ENUM_2484,
 	NUM_24GHZ_CHANNELS = (MAX_24GHZ_CHANNEL - MIN_24GHZ_CHANNEL + 1),
 
+	MIN_49GHZ_CHANNEL = CHAN_ENUM_4912,
+	MAX_49GHZ_CHANNEL = CHAN_ENUM_5080,
+	NUM_49GHZ_CHANNELS = (MAX_49GHZ_CHANNEL - MIN_49GHZ_CHANNEL + 1),
+
 	MIN_5GHZ_CHANNEL = CHAN_ENUM_5180,
 	MAX_5GHZ_CHANNEL = CHAN_ENUM_5920,
 	NUM_5GHZ_CHANNELS = (MAX_5GHZ_CHANNEL - MIN_5GHZ_CHANNEL + 1),

umac/regulatory/dispatcher/inc/wlan_reg_services_api.h

@@ -41,6 +41,10 @@
 #define WLAN_REG_IS_5GHZ_CH(chan) REG_IS_5GHZ_CH(chan)
 #define WLAN_REG_IS_11P_CH(chan) REG_IS_11P_CH(chan)
 
+#ifndef CONFIG_LEGACY_CHAN_ENUM
+#define WLAN_REG_IS_49GHZ_FREQ(freq) REG_IS_49GHZ_FREQ(freq)
+#endif
+
 #define WLAN_REG_CH_NUM(ch_enum) REG_CH_NUM(ch_enum)
 #define WLAN_REG_CH_TO_FREQ(ch_enum) REG_CH_TO_FREQ(ch_enum)
 

utils/nlink/src/wlan_nlink_srv.c

@@ -493,22 +493,17 @@ int nl_srv_bcast(struct sk_buff *skb, int mcgroup_id, int app_id)
 	struct nlmsghdr *nlh = (struct nlmsghdr *)skb->data;
 	void *msg = NLMSG_DATA(nlh);
 	uint32_t msg_len = nlmsg_len(nlh);
-	uint8_t *tempbuf;
 	int status;
 
-	tempbuf = (uint8_t *)qdf_mem_malloc(msg_len);
-	qdf_mem_copy(tempbuf, msg, msg_len);
-	status = send_msg_to_cld80211(mcgroup_id, 0, app_id, tempbuf, msg_len);
+	status = send_msg_to_cld80211(mcgroup_id, 0, app_id, msg, msg_len);
 	if (status) {
 		QDF_TRACE(QDF_MODULE_ID_HDD, QDF_TRACE_LEVEL_ERROR,
 			"send msg to cld80211 fails for app id %d", app_id);
 		dev_kfree_skb(skb);
-		qdf_mem_free(tempbuf);
 		return -EPERM;
 	}
 
 	dev_kfree_skb(skb);
-	qdf_mem_free(tempbuf);
 	return 0;
 }
 qdf_export_symbol(nl_srv_bcast);
@@ -534,23 +529,18 @@ int nl_srv_ucast(struct sk_buff *skb, int dst_pid, int flag,
 	struct nlmsghdr *nlh = (struct nlmsghdr *)skb->data;
 	void *msg = NLMSG_DATA(nlh);
 	uint32_t msg_len = nlmsg_len(nlh);
-	uint8_t *tempbuf;
 	int status;
 
-	tempbuf = (uint8_t *)qdf_mem_malloc(msg_len);
-	qdf_mem_copy(tempbuf, msg, msg_len);
 	status = send_msg_to_cld80211(mcgroup_id, dst_pid, app_id,
-					tempbuf, msg_len);
+					msg, msg_len);
 	if (status) {
 		QDF_TRACE(QDF_MODULE_ID_HDD, QDF_TRACE_LEVEL_ERROR,
 			"send msg to cld80211 fails for app id %d", app_id);
 		dev_kfree_skb(skb);
-		qdf_mem_free(tempbuf);
 		return -EPERM;
 	}
 
 	dev_kfree_skb(skb);
-	qdf_mem_free(tempbuf);
 	return 0;
 }
 #else

utils/pktlog/linux_ac.c

@@ -1003,7 +1003,8 @@ static inline unsigned long pktlog_get_fault_address(struct vm_fault *vmf)
 }
 #endif /* KERNEL_VERSION(4, 10, 0) */
 
-static int pktlog_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
+static int
+pktlog_fault_handler(struct vm_area_struct *vma, struct vm_fault *vmf)
 {
 	unsigned long address = pktlog_get_fault_address(vmf);
 
@@ -1018,8 +1019,20 @@ static int pktlog_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
 	return 0;
 }
 
+#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 10, 0)
+static int pktlog_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
+{
+	return pktlog_fault_handler(vma, vmf);
+}
+#else
+static int pktlog_fault(struct vm_fault *vmf)
+{
+	return pktlog_fault_handler(vmf->vma, vmf);
+}
+#endif
+
 static struct vm_operations_struct pktlog_vmops = {
-	open:  pktlog_vopen,
+	open: pktlog_vopen,
 	close:pktlog_vclose,
 	fault:pktlog_fault,
 };

wmi/inc/wmi_unified_api.h

@@ -292,6 +292,15 @@ void wmi_set_is_wow_bus_suspended(wmi_unified_t wmi_handle, A_BOOL val);
  */
 void wmi_tag_crash_inject(wmi_unified_t wmi_handle, A_BOOL flag);
 
+/**
+ * WMI API to set target assert
+ * @param wmi_handle: 	handle to WMI.
+ * @param val:		target assert config value.
+ *
+ * Return: 		none.
+ */
+void wmi_set_tgt_assert(wmi_unified_t wmi_handle, bool val);
+
 /**
  * generic function to block unified WMI command
  * @param wmi_handle      : handle to WMI.

wmi/inc/wmi_unified_param.h

@@ -609,6 +609,24 @@ struct mac_ssid {
 	uint8_t mac_ssid[WMI_MAC_MAX_SSID_LENGTH];
 } qdf_packed;
 
+/**
+ * enum wmi_bcn_tx_rate_code - beacon tx rate code
+ */
+enum wmi_bcn_tx_rate_code {
+	WMI_BCN_TX_RATE_CODE_1_M = 0x43,
+	WMI_BCN_TX_RATE_CODE_2_M = 0x42,
+	WMI_BCN_TX_RATE_CODE_5_5_M = 0x41,
+	WMI_BCN_TX_RATE_CODE_6_M = 0x03,
+	WMI_BCN_TX_RATE_CODE_9_M = 0x07,
+	WMI_BCN_TX_RATE_CODE_11M = 0x40,
+	WMI_BCN_TX_RATE_CODE_12_M = 0x02,
+	WMI_BCN_TX_RATE_CODE_18_M = 0x06,
+	WMI_BCN_TX_RATE_CODE_24_M = 0x01,
+	WMI_BCN_TX_RATE_CODE_36_M = 0x05,
+	WMI_BCN_TX_RATE_CODE_48_M = 0x00,
+	WMI_BCN_TX_RATE_CODE_54_M = 0x04,
+};
+
 /**
  * struct vdev_start_params - vdev start cmd parameter
  * @vdev_id: vdev id
@@ -643,6 +661,7 @@ struct mac_ssid {
  * @dot11_mode: Phy mode (VHT20/VHT80...)
  * @disable_hw_ack: Disable hw ack if chan is dfs channel for cac
  * @channel_param: Channel params required by target.
+ * @bcn_tx_rate_code: Beacon tx rate code.
  * @ldpc_rx_enabled: Enable/Disable LDPC RX for this vdev
  */
 struct vdev_start_params {
@@ -677,6 +696,7 @@ struct vdev_start_params {
 	uint8_t disable_hw_ack;
 	struct channel_param channel;
 #endif
+	enum wmi_bcn_tx_rate_code bcn_tx_rate_code;
 	bool ldpc_rx_enabled;
 };
 
@@ -1976,6 +1996,8 @@ struct roam_offload_scan_params {
  * @dense_min_aps_cnt: dense roam minimum APs
  * @initial_dense_status: dense status detected by host
  * @traffic_threshold: dense roam RSSI threshold
+ * @bg_scan_bad_rssi_thresh: Bad RSSI threshold to perform bg scan
+ * @bg_scan_client_bitmap: Bitmap used to identify the client scans to snoop
  */
 struct roam_offload_scan_rssi_params {
 	int8_t rssi_thresh;
@@ -1999,6 +2021,8 @@ struct roam_offload_scan_rssi_params {
 	int initial_dense_status;
 	int traffic_threshold;
 	int32_t rssi_thresh_offset_5g;
+	int8_t bg_scan_bad_rssi_thresh;
+	uint32_t bg_scan_client_bitmap;
 };
 
 /**

wmi/inc/wmi_unified_priv.h

@@ -1438,6 +1438,7 @@ struct wmi_unified {
 #endif
 	qdf_atomic_t is_wow_bus_suspended;
 	bool tag_crash_inject;
+	bool tgt_force_assert_enable;
 	enum wmi_target_type target_type;
 	struct wmi_rx_ops rx_ops;
 	struct wmi_ops *ops;

wmi/src/wmi_unified.c

@@ -3013,6 +3013,11 @@ void wmi_set_is_wow_bus_suspended(wmi_unified_t wmi_handle, A_BOOL val)
 	qdf_atomic_set(&wmi_handle->is_wow_bus_suspended, val);
 }
 
+void wmi_set_tgt_assert(wmi_unified_t wmi_handle, bool val)
+{
+	wmi_handle->tgt_force_assert_enable = val;
+}
+
 #ifndef CONFIG_MCL
 /**
  * API to flush all the previous packets  associated with the wmi endpoint

wmi/src/wmi_unified_tlv.c

@@ -104,8 +104,8 @@ static QDF_STATUS send_vdev_create_cmd_tlv(wmi_unified_t wmi_handle,
 	cmd->num_cfg_txrx_streams = num_bands;
 	copy_vdev_create_pdev_id(wmi_handle, cmd, param);
 	WMI_CHAR_ARRAY_TO_MAC_ADDR(macaddr, &cmd->vdev_macaddr);
-	WMI_LOGD("%s: ID = %d VAP Addr = %02x:%02x:%02x:%02x:%02x:%02x",
-		 __func__, param->if_id,
+	WMI_LOGD("%s: ID = %d[pdev:%d] VAP Addr = %02x:%02x:%02x:%02x:%02x:%02x",
+		 __func__, param->if_id, cmd->pdev_id,
 		 macaddr[0], macaddr[1], macaddr[2],
 		 macaddr[3], macaddr[4], macaddr[5]);
 	buf_ptr = (uint8_t *)cmd + sizeof(*cmd);
@@ -343,6 +343,10 @@ static QDF_STATUS send_vdev_start_cmd_tlv(wmi_unified_t wmi_handle,
 	cmd->beacon_interval = req->beacon_intval;
 	cmd->dtim_period = req->dtim_period;
 
+	cmd->bcn_tx_rate = req->bcn_tx_rate_code;
+	if (req->bcn_tx_rate_code)
+		cmd->flags |= WMI_UNIFIED_VDEV_START_BCN_TX_RATE_PRESENT;
+
 	if (!req->is_restart) {
 		cmd->beacon_interval = req->beacon_intval;
 		cmd->dtim_period = req->dtim_period;
@@ -5905,6 +5909,7 @@ static QDF_STATUS send_roam_scan_offload_rssi_thresh_cmd_tlv(wmi_unified_t wmi_h
 	wmi_roam_scan_extended_threshold_param *ext_thresholds = NULL;
 	wmi_roam_earlystop_rssi_thres_param *early_stop_thresholds = NULL;
 	wmi_roam_dense_thres_param *dense_thresholds = NULL;
+	wmi_roam_bg_scan_roaming_param *bg_scan_params = NULL;
 
 	len = sizeof(wmi_roam_scan_rssi_threshold_fixed_param);
 	len += WMI_TLV_HDR_SIZE; /* TLV for ext_thresholds*/
@@ -5913,6 +5918,8 @@ static QDF_STATUS send_roam_scan_offload_rssi_thresh_cmd_tlv(wmi_unified_t wmi_h
 	len += sizeof(wmi_roam_earlystop_rssi_thres_param);
 	len += WMI_TLV_HDR_SIZE; /* TLV for dense thresholds*/
 	len += sizeof(wmi_roam_dense_thres_param);
+	len += WMI_TLV_HDR_SIZE; /* TLV for BG Scan*/
+	len += sizeof(wmi_roam_bg_scan_roaming_param);
 	buf = wmi_buf_alloc(wmi_handle, len);
 	if (!buf) {
 		WMI_LOGE("%s : wmi_buf_alloc failed", __func__);
@@ -5995,6 +6002,20 @@ static QDF_STATUS send_roam_scan_offload_rssi_thresh_cmd_tlv(wmi_unified_t wmi_h
 			WMITLV_GET_STRUCT_TLVLEN
 			(wmi_roam_dense_thres_param));
 
+	buf_ptr += sizeof(wmi_roam_dense_thres_param);
+	WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
+			 sizeof(wmi_roam_bg_scan_roaming_param));
+	buf_ptr += WMI_TLV_HDR_SIZE;
+	bg_scan_params = (wmi_roam_bg_scan_roaming_param *) buf_ptr;
+	bg_scan_params->roam_bg_scan_bad_rssi_thresh =
+		roam_req->bg_scan_bad_rssi_thresh;
+	bg_scan_params->roam_bg_scan_client_bitmap =
+		roam_req->bg_scan_client_bitmap;
+	WMITLV_SET_HDR(&bg_scan_params->tlv_header,
+			WMITLV_TAG_STRUC_wmi_roam_bg_scan_roaming_param,
+			WMITLV_GET_STRUCT_TLVLEN
+			(wmi_roam_bg_scan_roaming_param));
+
 	status = wmi_unified_cmd_send(wmi_handle, buf,
 				      len, WMI_ROAM_SCAN_RSSI_THRESHOLD);
 	if (QDF_IS_STATUS_ERROR(status)) {