qcacmn: Replace A_UINT with appropriate types

There are instances of use of older A_UINT/A_INT.
Replace all such instances with the qdf u_int*_t/int*_t.

Change-Id: I7ce29b03f29a0d1a0cf87cfd3c846f4694da4c2a
CR's-Fixed: 2210869

wmi_tlv_helper.c

@@ -54,17 +54,17 @@
 	WMITLV_SET_ATTRB0(id), \
 	WMITLV_TABLE(id,SET_TLV_ATTRIB, NULL, 0)
 
-A_UINT32 cmd_attr_list[] = {
+uint32_t cmd_attr_list[] = {
 	WMITLV_ALL_CMD_LIST(WMITLV_GET_CMD_EVT_ATTRB_LIST)
 };
 
-A_UINT32 evt_attr_list[] = {
+uint32_t evt_attr_list[] = {
 	WMITLV_ALL_EVT_LIST(WMITLV_GET_CMD_EVT_ATTRB_LIST)
 };
 
 #ifdef NO_DYNAMIC_MEM_ALLOC
 static wmitlv_cmd_param_info *g_wmi_static_cmd_param_info_buf;
-A_UINT32 g_wmi_static_max_cmd_param_tlvs;
+uint32_t g_wmi_static_max_cmd_param_tlvs;
 #endif
 
 
@@ -88,7 +88,7 @@ A_UINT32 g_wmi_static_max_cmd_param_tlvs;
  */
 void
 wmitlv_set_static_param_tlv_buf(void *param_tlv_buf,
-				A_UINT32 max_tlvs_accomodated)
+				uint32_t max_tlvs_accomodated)
 {
 #ifdef NO_DYNAMIC_MEM_ALLOC
 	g_wmi_static_cmd_param_info_buf = param_tlv_buf;
@@ -110,12 +110,12 @@ wmitlv_set_static_param_tlv_buf(void *param_tlv_buf,
  * Return: 0 if success. Return >=1 if failure.
  */
 static
-A_UINT32 wmitlv_get_attributes(A_UINT32 is_cmd_id, A_UINT32 cmd_event_id,
-			       A_UINT32 curr_tlv_order,
+uint32_t wmitlv_get_attributes(uint32_t is_cmd_id, uint32_t cmd_event_id,
+			       uint32_t curr_tlv_order,
 			       wmitlv_attributes_struc *tlv_attr_ptr)
 {
-	A_UINT32 i, base_index, num_tlvs, num_entries;
-	A_UINT32 *pAttrArrayList;
+	uint32_t i, base_index, num_tlvs, num_entries;
+	uint32_t *pAttrArrayList;
 
 	if (is_cmd_id) {
 		pAttrArrayList = &cmd_attr_list[0];
@@ -198,15 +198,15 @@ A_UINT32 wmitlv_get_attributes(A_UINT32 is_cmd_id, A_UINT32 cmd_event_id,
  */
 static int
 wmitlv_check_tlv_params(void *os_handle, void *param_struc_ptr,
-			A_UINT32 param_buf_len, A_UINT32 is_cmd_id,
-			A_UINT32 wmi_cmd_event_id)
+			uint32_t param_buf_len, uint32_t is_cmd_id,
+			uint32_t wmi_cmd_event_id)
 {
 	wmitlv_attributes_struc attr_struct_ptr;
-	A_UINT32 buf_idx = 0;
-	A_UINT32 tlv_index = 0;
-	A_UINT8 *buf_ptr = (unsigned char *)param_struc_ptr;
-	A_UINT32 expected_num_tlvs, expected_tlv_len;
-	A_INT32 error = -1;
+	uint32_t buf_idx = 0;
+	uint32_t tlv_index = 0;
+	uint8_t *buf_ptr = (unsigned char *)param_struc_ptr;
+	uint32_t expected_num_tlvs, expected_tlv_len;
+	int32_t error = -1;
 
 	/* Get the number of TLVs for this command/event */
 	if (wmitlv_get_attributes
@@ -223,9 +223,9 @@ wmitlv_check_tlv_params(void *os_handle, void *param_struc_ptr,
 	expected_num_tlvs = attr_struct_ptr.cmd_num_tlv;
 
 	while ((buf_idx + WMI_TLV_HDR_SIZE) <= param_buf_len) {
-		A_UINT32 curr_tlv_tag =
+		uint32_t curr_tlv_tag =
 			WMITLV_GET_TLVTAG(WMITLV_GET_HDR(buf_ptr));
-		A_UINT32 curr_tlv_len =
+		uint32_t curr_tlv_len =
 			WMITLV_GET_TLVLEN(WMITLV_GET_HDR(buf_ptr));
 
 		if ((buf_idx + WMI_TLV_HDR_SIZE + curr_tlv_len) > param_buf_len) {
@@ -287,7 +287,7 @@ wmitlv_check_tlv_params(void *os_handle, void *param_struc_ptr,
 				    attr_struct_ptr.tag_id) {
 					expected_tlv_len =
 						roundup(expected_tlv_len,
-							sizeof(A_UINT32));
+							sizeof(uint32_t));
 				}
 
 				if (curr_tlv_len != expected_tlv_len) {
@@ -328,10 +328,10 @@ wmitlv_check_tlv_params(void *os_handle, void *param_struc_ptr,
 
 					if (curr_tlv_tag ==
 					    WMITLV_TAG_ARRAY_STRUC) {
-						A_UINT8 *tlv_buf_ptr = NULL;
-						A_UINT32 in_tlv_len;
-						A_UINT32 idx;
-						A_UINT32 num_of_elems;
+						uint8_t *tlv_buf_ptr = NULL;
+						uint32_t in_tlv_len;
+						uint32_t idx;
+						uint32_t num_of_elems;
 
 						/* Verify length of inner TLVs */
 
@@ -404,11 +404,11 @@ wmitlv_check_tlv_params(void *os_handle, void *param_struc_ptr,
 		}
 
 		/* Check TLV length is aligned to 4 bytes or not */
-		if ((curr_tlv_len % sizeof(A_UINT32)) != 0) {
+		if ((curr_tlv_len % sizeof(uint32_t)) != 0) {
 			wmi_tlv_print_error
 				("%s: ERROR: TLV length %d for Cmd=0x%x is not aligned to %zu bytes\n",
 				__func__, curr_tlv_len, wmi_cmd_event_id,
-				sizeof(A_UINT32));
+				sizeof(uint32_t));
 			goto Error_wmitlv_check_tlv_params;
 		}
 
@@ -443,9 +443,9 @@ Error_wmitlv_check_tlv_params:
  */
 int
 wmitlv_check_event_tlv_params(void *os_handle, void *param_struc_ptr,
-			      A_UINT32 param_buf_len, A_UINT32 wmi_cmd_event_id)
+			      uint32_t param_buf_len, uint32_t wmi_cmd_event_id)
 {
-	A_UINT32 is_cmd_id = 0;
+	uint32_t is_cmd_id = 0;
 
 	return wmitlv_check_tlv_params
 			(os_handle, param_struc_ptr, param_buf_len, is_cmd_id,
@@ -467,10 +467,10 @@ wmitlv_check_event_tlv_params(void *os_handle, void *param_struc_ptr,
  */
 int
 wmitlv_check_command_tlv_params(void *os_handle, void *param_struc_ptr,
-				A_UINT32 param_buf_len,
-				A_UINT32 wmi_cmd_event_id)
+				uint32_t param_buf_len,
+				uint32_t wmi_cmd_event_id)
 {
-	A_UINT32 is_cmd_id = 1;
+	uint32_t is_cmd_id = 1;
 
 	return wmitlv_check_tlv_params
 			(os_handle, param_struc_ptr, param_buf_len, is_cmd_id,
@@ -495,20 +495,20 @@ qdf_export_symbol(wmitlv_check_command_tlv_params);
  */
 static int
 wmitlv_check_and_pad_tlvs(void *os_handle, void *param_struc_ptr,
-			  A_UINT32 param_buf_len, A_UINT32 is_cmd_id,
-			  A_UINT32 wmi_cmd_event_id, void **wmi_cmd_struct_ptr)
+			  uint32_t param_buf_len, uint32_t is_cmd_id,
+			  uint32_t wmi_cmd_event_id, void **wmi_cmd_struct_ptr)
 {
 	wmitlv_attributes_struc attr_struct_ptr;
-	A_UINT32 buf_idx = 0;
-	A_UINT32 tlv_index = 0;
-	A_UINT32 num_of_elems = 0;
+	uint32_t buf_idx = 0;
+	uint32_t tlv_index = 0;
+	uint32_t num_of_elems = 0;
 	int tlv_size_diff = 0;
-	A_UINT8 *buf_ptr = (unsigned char *)param_struc_ptr;
+	uint8_t *buf_ptr = (unsigned char *)param_struc_ptr;
 	wmitlv_cmd_param_info *cmd_param_tlvs_ptr = NULL;
-	A_UINT32 remaining_expected_tlvs = 0xFFFFFFFF;
-	A_UINT32 len_wmi_cmd_struct_buf;
-	A_UINT32 free_buf_len;
-	A_INT32 error = -1;
+	uint32_t remaining_expected_tlvs = 0xFFFFFFFF;
+	uint32_t len_wmi_cmd_struct_buf;
+	uint32_t free_buf_len;
+	int32_t error = -1;
 
 	/* Get the number of TLVs for this command/event */
 	if (wmitlv_get_attributes
@@ -564,9 +564,9 @@ wmitlv_check_and_pad_tlvs(void *os_handle, void *param_struc_ptr,
 
 	while (((buf_idx + WMI_TLV_HDR_SIZE) <= param_buf_len)
 	       && (remaining_expected_tlvs)) {
-		A_UINT32 curr_tlv_tag =
+		uint32_t curr_tlv_tag =
 			WMITLV_GET_TLVTAG(WMITLV_GET_HDR(buf_ptr));
-		A_UINT32 curr_tlv_len =
+		uint32_t curr_tlv_len =
 			WMITLV_GET_TLVLEN(WMITLV_GET_HDR(buf_ptr));
 		int num_padding_bytes = 0;
 
@@ -633,7 +633,7 @@ wmitlv_check_and_pad_tlvs(void *os_handle, void *param_struc_ptr,
 		} else {
 			/* This TLV has a variable number of elements */
 			if (WMITLV_TAG_ARRAY_STRUC == attr_struct_ptr.tag_id) {
-				A_UINT32 in_tlv_len = 0;
+				uint32_t in_tlv_len = 0;
 
 				if (curr_tlv_len != 0) {
 					in_tlv_len =
@@ -683,9 +683,9 @@ wmitlv_check_and_pad_tlvs(void *os_handle, void *param_struc_ptr,
 		if ((WMITLV_TAG_ARRAY_STRUC == attr_struct_ptr.tag_id) &&
 		    (tlv_size_diff != 0)) {
 			void *new_tlv_buf = NULL;
-			A_UINT8 *tlv_buf_ptr = NULL;
-			A_UINT32 in_tlv_len;
-			A_UINT32 i;
+			uint8_t *tlv_buf_ptr = NULL;
+			uint32_t in_tlv_len;
+			uint32_t i;
 
 			if (attr_struct_ptr.tag_varied_size == WMITLV_SIZE_FIX) {
 				/* This is not allowed. The tag WMITLV_TAG_ARRAY_STRUC can
@@ -727,7 +727,7 @@ wmitlv_check_and_pad_tlvs(void *os_handle, void *param_struc_ptr,
 			wmi_tlv_OS_MEMZERO(new_tlv_buf,
 					   (num_of_elems *
 					    attr_struct_ptr.tag_struct_size));
-			tlv_buf_ptr = (A_UINT8 *) new_tlv_buf;
+			tlv_buf_ptr = (uint8_t *) new_tlv_buf;
 			for (i = 0; i < num_of_elems; i++) {
 				if (tlv_size_diff > 0) {
 					/* Incoming structure size is greater than expected
@@ -753,9 +753,9 @@ wmitlv_check_and_pad_tlvs(void *os_handle, void *param_struc_ptr,
 			}
 #else
 			{
-				A_UINT8 *src_addr;
-				A_UINT8 *dst_addr;
-				A_UINT32 buf_mov_len;
+				uint8_t *src_addr;
+				uint8_t *dst_addr;
+				uint32_t buf_mov_len;
 
 				if (tlv_size_diff < 0) {
 					/* Incoming structure size is smaller than expected size
@@ -939,9 +939,9 @@ wmitlv_check_and_pad_tlvs(void *os_handle, void *param_struc_ptr,
 			{
 				/* Note: tlv_size_diff is a value less than zero */
 				/* Move the Subsequent TLVs by amount of bytes needs to be padded */
-				A_UINT8 *src_addr;
-				A_UINT8 *dst_addr;
-				A_UINT32 src_len;
+				uint8_t *src_addr;
+				uint8_t *dst_addr;
+				uint32_t src_len;
 
 				num_padding_bytes = (tlv_size_diff * -1);
 
@@ -999,11 +999,11 @@ Error_wmitlv_check_and_pad_tlvs:
  */
 int
 wmitlv_check_and_pad_event_tlvs(void *os_handle, void *param_struc_ptr,
-				A_UINT32 param_buf_len,
-				A_UINT32 wmi_cmd_event_id,
+				uint32_t param_buf_len,
+				uint32_t wmi_cmd_event_id,
 				void **wmi_cmd_struct_ptr)
 {
-	A_UINT32 is_cmd_id = 0;
+	uint32_t is_cmd_id = 0;
 	return wmitlv_check_and_pad_tlvs
 			(os_handle, param_struc_ptr, param_buf_len, is_cmd_id,
 			wmi_cmd_event_id, wmi_cmd_struct_ptr);
@@ -1025,11 +1025,11 @@ qdf_export_symbol(wmitlv_check_and_pad_event_tlvs);
  */
 int
 wmitlv_check_and_pad_command_tlvs(void *os_handle, void *param_struc_ptr,
-				  A_UINT32 param_buf_len,
-				  A_UINT32 wmi_cmd_event_id,
+				  uint32_t param_buf_len,
+				  uint32_t wmi_cmd_event_id,
 				  void **wmi_cmd_struct_ptr)
 {
-	A_UINT32 is_cmd_id = 1;
+	uint32_t is_cmd_id = 1;
 	return wmitlv_check_and_pad_tlvs
 			(os_handle, param_struc_ptr, param_buf_len, is_cmd_id,
 			wmi_cmd_event_id, wmi_cmd_struct_ptr);
@@ -1046,8 +1046,8 @@ wmitlv_check_and_pad_command_tlvs(void *os_handle, void *param_struc_ptr,
  *
  * Return: none
  */
-static void wmitlv_free_allocated_tlvs(A_UINT32 is_cmd_id,
-				       A_UINT32 cmd_event_id,
+static void wmitlv_free_allocated_tlvs(uint32_t is_cmd_id,
+				       uint32_t cmd_event_id,
 				       void **wmi_cmd_struct_ptr)
 {
 	void *ptr = *wmi_cmd_struct_ptr;
@@ -1109,7 +1109,7 @@ break;
  *
  * Return: none
  */
-void wmitlv_free_allocated_command_tlvs(A_UINT32 cmd_event_id,
+void wmitlv_free_allocated_command_tlvs(uint32_t cmd_event_id,
 					void **wmi_cmd_struct_ptr)
 {
 	wmitlv_free_allocated_tlvs(1, cmd_event_id, wmi_cmd_struct_ptr);
@@ -1125,7 +1125,7 @@ void wmitlv_free_allocated_command_tlvs(A_UINT32 cmd_event_id,
  *
  * Return: none
  */
-void wmitlv_free_allocated_event_tlvs(A_UINT32 cmd_event_id,
+void wmitlv_free_allocated_event_tlvs(uint32_t cmd_event_id,
 				      void **wmi_cmd_struct_ptr)
 {
 	wmitlv_free_allocated_tlvs(0, cmd_event_id, wmi_cmd_struct_ptr);
@@ -1180,12 +1180,12 @@ wmi_versions_can_downgrade(int num_whitelist,
 			   wmi_abi_version *opp_vers,
 			   wmi_abi_version *out_vers)
 {
-	A_UINT8 can_try_to_downgrade;
-	A_UINT32 my_major_vers = WMI_VER_GET_MAJOR(my_vers->abi_version_0);
-	A_UINT32 my_minor_vers = WMI_VER_GET_MINOR(my_vers->abi_version_0);
-	A_UINT32 opp_major_vers = WMI_VER_GET_MAJOR(opp_vers->abi_version_0);
-	A_UINT32 opp_minor_vers = WMI_VER_GET_MINOR(opp_vers->abi_version_0);
-	A_UINT32 downgraded_minor_vers;
+	uint8_t can_try_to_downgrade;
+	uint32_t my_major_vers = WMI_VER_GET_MAJOR(my_vers->abi_version_0);
+	uint32_t my_minor_vers = WMI_VER_GET_MINOR(my_vers->abi_version_0);
+	uint32_t opp_major_vers = WMI_VER_GET_MAJOR(opp_vers->abi_version_0);
+	uint32_t opp_minor_vers = WMI_VER_GET_MINOR(opp_vers->abi_version_0);
+	uint32_t downgraded_minor_vers;
 
 	if ((my_vers->abi_version_ns_0 != opp_vers->abi_version_ns_0) ||
 	    (my_vers->abi_version_ns_1 != opp_vers->abi_version_ns_1) ||
@@ -1222,7 +1222,7 @@ wmi_versions_can_downgrade(int num_whitelist,
 	/* Try to see we can downgrade the supported version */
 	downgraded_minor_vers = my_minor_vers;
 	while (downgraded_minor_vers > opp_minor_vers) {
-		A_UINT8 downgraded = false;
+		uint8_t downgraded = false;
 		int i;
 
 		for (i = 0; i < num_whitelist; i++) {

wmi_unified.c

@@ -54,11 +54,11 @@ WMI_CMD_HDR to be defined here. */
 #define WO(_f)      ((_f##_OFFSET) >> 2)
 
 #undef GET_FIELD
-#define GET_FIELD(_addr, _f) MS(*((A_UINT32 *)(_addr) + WO(_f)), _f)
+#define GET_FIELD(_addr, _f) MS(*((uint32_t *)(_addr) + WO(_f)), _f)
 #undef SET_FIELD
 #define SET_FIELD(_addr, _f, _val)  \
-	    (*((A_UINT32 *)(_addr) + WO(_f)) = \
-		(*((A_UINT32 *)(_addr) + WO(_f)) & ~_f##_MASK) | SM(_val, _f))
+	    (*((uint32_t *)(_addr) + WO(_f)) = \
+		(*((uint32_t *)(_addr) + WO(_f)) & ~_f##_MASK) | SM(_val, _f))
 
 #define WMI_GET_FIELD(_msg_buf, _msg_type, _f) \
 	    GET_FIELD(_msg_buf, _msg_type ## _ ## _f)
@@ -74,7 +74,7 @@ WMI_CMD_HDR to be defined here. */
  *  * Control Path
  *   */
 typedef PREPACK struct {
-	A_UINT32	commandId:24,
+	uint32_t	commandId:24,
 			reserved:2, /* used for WMI endpoint ID */
 			plt_priv:6; /* platform private */
 } POSTPACK WMI_CMD_HDR;        /* used for commands and events */
@@ -1359,7 +1359,7 @@ QDF_STATUS wmi_unified_cmd_send(wmi_unified_t wmi_handle, wmi_buf_t buf,
 
 	if (wmi_get_runtime_pm_inprogress(wmi_handle)) {
 		htc_tag =
-			(A_UINT16)wmi_handle->ops->wmi_set_htc_tx_tag(
+			(uint16_t)wmi_handle->ops->wmi_set_htc_tx_tag(
 						wmi_handle, buf, cmd_id);
 	} else if (qdf_atomic_read(&wmi_handle->is_target_suspended) &&
 		(!wmi_is_pm_resume_cmd(cmd_id))) {

wmi_unified_api.c

@@ -1525,7 +1525,7 @@ QDF_STATUS wmi_unified_setup_install_key_cmd(void *wmi_hdl,
  * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
  */
 QDF_STATUS wmi_unified_p2p_go_set_beacon_ie_cmd(void *wmi_hdl,
-				    A_UINT32 vdev_id, uint8_t *p2p_ie)
+				    uint32_t vdev_id, uint8_t *p2p_ie)
 {
 	wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
 

wmi_unified_non_tlv.c

@@ -1639,7 +1639,7 @@ static QDF_STATUS send_beacon_send_cmd_non_tlv(wmi_unified_t wmi_handle,
 		wmi_buf_t wmi_buf;
 		int bcn_len = qdf_nbuf_len(param->wbuf);
 		int len = sizeof(wmi_bcn_send_from_host_cmd_t);
-		A_UINT32   dtim_flag = 0;
+		uint32_t   dtim_flag = 0;
 
 		/* get the DTIM count */
 
@@ -1828,7 +1828,7 @@ static QDF_STATUS send_peer_assoc_cmd_non_tlv(wmi_unified_t wmi_handle,
 	/* Update peer rate information */
 	cmd->peer_rate_caps = param->peer_rate_caps;
 	cmd->peer_legacy_rates.num_rates = param->peer_legacy_rates.num_rates;
-	/* NOTE: cmd->peer_legacy_rates.rates is of type A_UINT32 */
+	/* NOTE: cmd->peer_legacy_rates.rates is of type uint32_t */
 	/* ni->ni_rates.rs_rates is of type u_int8_t */
 	/**
 	 * for cmd->peer_legacy_rates.rates:
@@ -1841,7 +1841,7 @@ static QDF_STATUS send_peer_assoc_cmd_non_tlv(wmi_unified_t wmi_handle,
 			param->peer_legacy_rates.num_rates);
 #ifdef BIG_ENDIAN_HOST
 	for (i = 0;
-		i < param->peer_legacy_rates.num_rates/sizeof(A_UINT32) + 1;
+		i < param->peer_legacy_rates.num_rates/sizeof(uint32_t) + 1;
 		i++)
 		cmd->peer_legacy_rates.rates[i] =
 		    qdf_le32_to_cpu(cmd->peer_legacy_rates.rates[i]);
@@ -1852,7 +1852,7 @@ static QDF_STATUS send_peer_assoc_cmd_non_tlv(wmi_unified_t wmi_handle,
 			param->peer_ht_rates.num_rates);
 
 #ifdef BIG_ENDIAN_HOST
-	for (i = 0; i < param->peer_ht_rates.num_rates/sizeof(A_UINT32) + 1;
+	for (i = 0; i < param->peer_ht_rates.num_rates/sizeof(uint32_t) + 1;
 		i++)
 		cmd->peer_ht_rates.rates[i] =
 		    qdf_le32_to_cpu(cmd->peer_ht_rates.rates[i]);
@@ -1914,15 +1914,15 @@ static QDF_STATUS send_scan_start_cmd_non_tlv(wmi_unified_t wmi_handle,
 	wmi_bssid_list *bssid_list;
 	wmi_ssid_list *ssid_list;
 	wmi_ie_data *ie_data;
-	A_UINT32 *tmp_ptr;
+	uint32_t *tmp_ptr;
 	int i, len = sizeof(wmi_start_scan_cmd);
 
 #ifdef TEST_CODE
-	len += sizeof(wmi_chan_list) + 3 * sizeof(A_UINT32);
+	len += sizeof(wmi_chan_list) + 3 * sizeof(uint32_t);
 #else
 	if (param->chan_list.num_chan) {
 		len += sizeof(wmi_chan_list) + (param->chan_list.num_chan - 1)
-		    * sizeof(A_UINT32);
+		    * sizeof(uint32_t);
 	}
 #endif
 	if (param->num_ssids) {
@@ -1934,10 +1934,10 @@ static QDF_STATUS send_scan_start_cmd_non_tlv(wmi_unified_t wmi_handle,
 		    * sizeof(wmi_mac_addr);
 	}
 	if (param->extraie.len) {
-		i = param->extraie.len % sizeof(A_UINT32);
+		i = param->extraie.len % sizeof(uint32_t);
 		if (i)
-			len += sizeof(A_UINT32) - i;
-		len += 2 * sizeof(A_UINT32) + param->extraie.len;
+			len += sizeof(uint32_t) - i;
+		len += 2 * sizeof(uint32_t) + param->extraie.len;
 	}
 	buf = wmi_buf_alloc(wmi_handle, len);
 	if (!buf) {
@@ -2027,7 +2027,7 @@ static QDF_STATUS send_scan_start_cmd_non_tlv(wmi_unified_t wmi_handle,
 #else
 	cmd->max_scan_time = param->max_scan_time;
 #endif
-	tmp_ptr = (A_UINT32 *)  (cmd + 1);
+	tmp_ptr = (uint32_t *)  (cmd + 1);
 #ifdef TEST_CODE
 #define DEFAULT_TIME 150
 	 cmd->min_rest_time = DEFAULT_TIME;
@@ -2065,7 +2065,7 @@ static QDF_STATUS send_scan_start_cmd_non_tlv(wmi_unified_t wmi_handle,
 					param->ssid[i].length);
 		}
 		tmp_ptr +=  (2 + (sizeof(wmi_ssid) *
-			    param->num_ssids)/sizeof(A_UINT32));
+			    param->num_ssids)/sizeof(uint32_t));
 	}
 	if (param->num_bssid) {
 		bssid_list  = (wmi_bssid_list *) tmp_ptr;
@@ -2077,7 +2077,7 @@ static QDF_STATUS send_scan_start_cmd_non_tlv(wmi_unified_t wmi_handle,
 				&bssid_list->bssid_list[i]);
 		}
 		tmp_ptr +=  (2 + (sizeof(wmi_mac_addr) *
-			    param->num_bssid)/sizeof(A_UINT32));
+			    param->num_bssid)/sizeof(uint32_t));
 	}
 	if (param->extraie.len) {
 		ie_data  = (wmi_ie_data *) tmp_ptr;
@@ -3598,7 +3598,7 @@ void wmi_host_swap_bytes(void *pv, size_t n)
 {
 	int noWords;
 	int i;
-	A_UINT32 *wordPtr;
+	uint32_t *wordPtr;
 
 	noWords =   n/sizeof(u_int32_t);
 	wordPtr = (u_int32_t *)pv;
@@ -3790,7 +3790,7 @@ send_set_ratepwr_table_cmd_non_tlv(wmi_unified_t wmi_handle,
 		return QDF_STATUS_E_FAILURE;
 
 	len = sizeof(wmi_pdev_ratepwr_table_cmd);
-	len += roundup(param->ratepwr_len, sizeof(A_UINT32)) - sizeof(A_UINT32);
+	len += roundup(param->ratepwr_len, sizeof(uint32_t)) - sizeof(uint32_t);
 	/* already 4 bytes in cmd structure */
 	qdf_print("wmi buf len = %d\n", len);
 	buf = wmi_buf_alloc(wmi_handle, len);
@@ -3925,7 +3925,7 @@ send_set_ctl_table_cmd_non_tlv(wmi_unified_t wmi_handle,
 	}
 
 	len = sizeof(wmi_pdev_set_ctl_table_cmd);
-	len += roundup(param->ctl_cmd_len, sizeof(A_UINT32)) - sizeof(A_UINT32);
+	len += roundup(param->ctl_cmd_len, sizeof(uint32_t)) - sizeof(uint32_t);
 	qdf_print("wmi buf len = %d\n", len);
 	buf = wmi_buf_alloc(wmi_handle, len);
 	if (!buf) {
@@ -3976,7 +3976,7 @@ send_set_mimogain_table_cmd_non_tlv(wmi_unified_t wmi_handle,
 	}
 
 	len = sizeof(wmi_pdev_set_mimogain_table_cmd);
-	len += roundup(param->tbl_len, sizeof(A_UINT32)) - sizeof(A_UINT32);
+	len += roundup(param->tbl_len, sizeof(uint32_t)) - sizeof(uint32_t);
 	buf = wmi_buf_alloc(wmi_handle, len);
 	if (!buf) {
 		qdf_print("%s:wmi_buf_alloc failed\n", __func__);
@@ -4021,7 +4021,7 @@ send_set_ratepwr_chainmsk_cmd_non_tlv(wmi_unified_t wmi_handle,
 		return QDF_STATUS_E_FAILURE;
 
 	len = sizeof(wmi_pdev_ratepwr_chainmsk_tbl_cmd);
-	len += roundup(param->num_rate*sizeof(uint32_t), sizeof(A_UINT32));
+	len += roundup(param->num_rate*sizeof(uint32_t), sizeof(uint32_t));
 	buf = wmi_buf_alloc(wmi_handle, len);
 	if (!buf) {
 		qdf_print("%s:wmi_buf_alloc failed\n", __func__);
@@ -4195,7 +4195,7 @@ send_set_vap_dscp_tid_map_cmd_non_tlv(wmi_unified_t wmi_handle,
 
 	cmd_vdev = (wmi_vdev_set_dscp_tid_map_cmd *)wmi_buf_data(buf);
 	qdf_mem_copy(cmd_vdev->dscp_to_tid_map, param->dscp_to_tid_map,
-		sizeof(A_UINT32) * WMI_DSCP_MAP_MAX);
+		sizeof(uint32_t) * WMI_DSCP_MAP_MAX);
 
 	cmd_vdev->vdev_id = param->vdev_id;
 

wmi_unified_tlv.c

@@ -1617,13 +1617,13 @@ send_dbglog_cmd_tlv(wmi_unified_t wmi_handle,
 	configmsg->value = dbglog_param->val;
 	/* Filling in the data part of second tlv -- should
 	 * follow first tlv _ WMI_TLV_HDR_SIZE */
-	module_id_bitmap_array = (A_UINT32 *) (buf_ptr +
+	module_id_bitmap_array = (uint32_t *) (buf_ptr +
 				       sizeof
 				       (wmi_debug_log_config_cmd_fixed_param)
 				       + WMI_TLV_HDR_SIZE);
 	WMITLV_SET_HDR(buf_ptr + sizeof(wmi_debug_log_config_cmd_fixed_param),
 		       WMITLV_TAG_ARRAY_UINT32,
-		       sizeof(A_UINT32) * MAX_MODULE_ID_BITMAP_WORDS);
+		       sizeof(uint32_t) * MAX_MODULE_ID_BITMAP_WORDS);
 	if (dbglog_param->module_id_bitmap) {
 		for (i = 0; i < dbglog_param->bitmap_len; ++i) {
 			module_id_bitmap_array[i] =
@@ -3587,10 +3587,10 @@ static QDF_STATUS send_p2p_lo_start_cmd_tlv(wmi_unified_t wmi_handle,
 
 	device_types_len_aligned =
 		qdf_roundup(param->dev_types_len,
-			sizeof(A_UINT32));
+			sizeof(uint32_t));
 	probe_resp_len_aligned =
 		qdf_roundup(param->probe_resp_len,
-			sizeof(A_UINT32));
+			sizeof(uint32_t));
 
 	len += 2 * WMI_TLV_HDR_SIZE + device_types_len_aligned +
 			probe_resp_len_aligned;
@@ -5289,7 +5289,7 @@ static QDF_STATUS send_probe_rsp_tmpl_send_cmd_tlv(wmi_unified_t wmi_handle,
 	WMI_LOGD(FL("Send probe response template for vdev %d"), vdev_id);
 
 	tmpl_len = probe_rsp_info->prb_rsp_template_len;
-	tmpl_len_aligned = roundup(tmpl_len, sizeof(A_UINT32));
+	tmpl_len_aligned = roundup(tmpl_len, sizeof(uint32_t));
 
 	wmi_buf_len = sizeof(wmi_prb_tmpl_cmd_fixed_param) +
 			sizeof(wmi_bcn_prb_info) + WMI_TLV_HDR_SIZE +
@@ -5427,7 +5427,7 @@ static QDF_STATUS send_setup_install_key_cmd_tlv(wmi_unified_t wmi_handle,
 	buf_ptr += sizeof(wmi_vdev_install_key_cmd_fixed_param);
 	WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE,
 		       roundup(key_params->key_len, sizeof(uint32_t)));
-	key_data = (A_UINT8 *) (buf_ptr + WMI_TLV_HDR_SIZE);
+	key_data = (uint8_t *) (buf_ptr + WMI_TLV_HDR_SIZE);
 	qdf_mem_copy((void *)key_data,
 		     (const void *)key_params->key_data, key_params->key_len);
 	if (key_params->key_rsc_counter)
@@ -5635,7 +5635,7 @@ QDF_STATUS send_encrypt_decrypt_send_cmd_tlv(wmi_unified_t wmi_handle,
 	WMI_LOGD(FL("Send encrypt decrypt cmd"));
 
 	len = sizeof(*cmd) +
-		roundup(encrypt_decrypt_params->data_len, sizeof(A_UINT32)) +
+		roundup(encrypt_decrypt_params->data_len, sizeof(uint32_t)) +
 		WMI_TLV_HDR_SIZE;
 	wmi_buf = wmi_buf_alloc(wmi_handle, len);
 	if (!wmi_buf) {
@@ -5672,7 +5672,7 @@ QDF_STATUS send_encrypt_decrypt_send_cmd_tlv(wmi_unified_t wmi_handle,
 		buf_ptr += sizeof(*cmd);
 		WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE,
 				roundup(encrypt_decrypt_params->data_len,
-					sizeof(A_UINT32)));
+					sizeof(uint32_t)));
 		buf_ptr += WMI_TLV_HDR_SIZE;
 		qdf_mem_copy(buf_ptr, encrypt_decrypt_params->data,
 					encrypt_decrypt_params->data_len);
@@ -5749,7 +5749,7 @@ QDF_STATUS extract_encrypt_decrypt_resp_event_tlv(wmi_unified_t wmi_handle,
  * Return: QDF_STATUS_SUCCESS for success or error code
  */
 static QDF_STATUS send_p2p_go_set_beacon_ie_cmd_tlv(wmi_unified_t wmi_handle,
-				    A_UINT32 vdev_id, uint8_t *p2p_ie)
+				    uint32_t vdev_id, uint8_t *p2p_ie)
 {
 	QDF_STATUS ret;
 	wmi_p2p_go_set_beacon_ie_fixed_param *cmd;
@@ -5772,7 +5772,7 @@ static QDF_STATUS send_p2p_go_set_beacon_ie_cmd_tlv(wmi_unified_t wmi_handle,
 		return QDF_STATUS_E_INVAL;
 	}
 
-	ie_len_aligned = roundup(ie_len, sizeof(A_UINT32));
+	ie_len_aligned = roundup(ie_len, sizeof(uint32_t));
 
 	wmi_buf_len =
 		sizeof(wmi_p2p_go_set_beacon_ie_fixed_param) + ie_len_aligned +
@@ -6915,7 +6915,7 @@ static QDF_STATUS send_roam_scan_filter_cmd_tlv(wmi_unified_t wmi_handle,
 	len += 2 * WMI_TLV_HDR_SIZE;
 	if (roam_req->num_bssid_preferred_list) {
 		len += roam_req->num_bssid_preferred_list * sizeof(wmi_mac_addr);
-		len += roam_req->num_bssid_preferred_list * sizeof(A_UINT32);
+		len += roam_req->num_bssid_preferred_list * sizeof(uint32_t);
 	}
 	len += WMI_TLV_HDR_SIZE;
 	if (roam_req->lca_disallow_config_present) {
@@ -7037,7 +7037,7 @@ static QDF_STATUS send_roam_scan_filter_cmd_tlv(wmi_unified_t wmi_handle,
 		rssi_rej->remaining_disallow_duration =
 			roam_req->rssi_rejection_ap[i].remaining_duration;
 		rssi_rej->requested_rssi =
-			(A_INT32)roam_req->rssi_rejection_ap[i].expected_rssi;
+			(int32_t)roam_req->rssi_rejection_ap[i].expected_rssi;
 		buf_ptr +=
 			(sizeof(wmi_roam_rssi_rejection_oce_config_param));
 	}
@@ -8752,7 +8752,7 @@ static QDF_STATUS send_process_ll_stats_get_cmd_tlv(wmi_unified_t wmi_handle,
  * Return: CDF status
  */
 static QDF_STATUS send_congestion_cmd_tlv(wmi_unified_t wmi_handle,
-			A_UINT8 vdev_id)
+			uint8_t vdev_id)
 {
 	wmi_buf_t buf;
 	wmi_request_stats_cmd_fixed_param *cmd;
@@ -9635,8 +9635,8 @@ static QDF_STATUS send_wow_timer_pattern_cmd_tlv(wmi_unified_t wmi_handle,
 		WMI_TLV_HDR_SIZE + 0 * sizeof(WOW_IPV4_SYNC_PATTERN_T) +
 		WMI_TLV_HDR_SIZE + 0 * sizeof(WOW_IPV6_SYNC_PATTERN_T) +
 		WMI_TLV_HDR_SIZE + 0 * sizeof(WOW_MAGIC_PATTERN_CMD) +
-		WMI_TLV_HDR_SIZE + 1 * sizeof(A_UINT32) +
-		WMI_TLV_HDR_SIZE + 1 * sizeof(A_UINT32);
+		WMI_TLV_HDR_SIZE + 1 * sizeof(uint32_t) +
+		WMI_TLV_HDR_SIZE + 1 * sizeof(uint32_t);
 
 	buf = wmi_buf_alloc(wmi_handle, len);
 	if (!buf) {
@@ -9673,15 +9673,15 @@ static QDF_STATUS send_wow_timer_pattern_cmd_tlv(wmi_unified_t wmi_handle,
 	buf_ptr += WMI_TLV_HDR_SIZE;
 
 	/* Fill TLV for pattern_info_timeout, and time value */
-	WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32, sizeof(A_UINT32));
+	WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32, sizeof(uint32_t));
 	buf_ptr += WMI_TLV_HDR_SIZE;
-	*((A_UINT32 *) buf_ptr) = time;
-	buf_ptr += sizeof(A_UINT32);
+	*((uint32_t *) buf_ptr) = time;
+	buf_ptr += sizeof(uint32_t);
 
 	/* Fill TLV for ra_ratelimit_interval. with dummy 0 value */
-	WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32, sizeof(A_UINT32));
+	WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32, sizeof(uint32_t));
 	buf_ptr += WMI_TLV_HDR_SIZE;
-	*((A_UINT32 *) buf_ptr) = 0;
+	*((uint32_t *) buf_ptr) = 0;
 
 	WMI_LOGD("%s: send wake timer pattern with time[%d] to fw vdev = %d",
 		__func__, time, vdev_id);
@@ -11258,7 +11258,7 @@ send_set_ctl_table_cmd_tlv(wmi_unified_t wmi_handle,
 		return QDF_STATUS_E_FAILURE;
 
 	ctl_tlv_len = WMI_TLV_HDR_SIZE +
-		roundup(param->ctl_cmd_len, sizeof(A_UINT32));
+		roundup(param->ctl_cmd_len, sizeof(uint32_t));
 	len = sizeof(*cmd) + ctl_tlv_len;
 
 	buf = wmi_buf_alloc(wmi_handle, len);
@@ -11750,7 +11750,7 @@ send_set_vap_dscp_tid_map_cmd_tlv(wmi_unified_t wmi_handle,
 
 	cmd = (wmi_vdev_set_dscp_tid_map_cmd_fixed_param *)wmi_buf_data(buf);
 	qdf_mem_copy(cmd->dscp_to_tid_map, param->dscp_to_tid_map,
-		     sizeof(A_UINT32) * WMI_DSCP_MAP_MAX);
+		     sizeof(uint32_t) * WMI_DSCP_MAP_MAX);
 
 	cmd->vdev_id = param->vdev_id;
 	cmd->enable_override = 0;
@@ -12040,9 +12040,9 @@ static QDF_STATUS send_smart_ant_set_node_config_cmd_tlv(
 	int32_t len = 0, args_tlv_len;
 	int ret;
 	int i = 0;
-	A_UINT32 *node_config_args;
+	uint32_t *node_config_args;
 
-	args_tlv_len = WMI_TLV_HDR_SIZE + param->args_count * sizeof(A_UINT32);
+	args_tlv_len = WMI_TLV_HDR_SIZE + param->args_count * sizeof(uint32_t);
 	len = sizeof(*cmd) + args_tlv_len;
 
 	if ((param->args_count == 0)) {
@@ -12071,9 +12071,9 @@ static QDF_STATUS send_smart_ant_set_node_config_cmd_tlv(
 	buf_ptr += sizeof(
 		wmi_peer_smart_ant_set_node_config_ops_cmd_fixed_param);
 	WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32,
-			(cmd->args_count * sizeof(A_UINT32)));
+			(cmd->args_count * sizeof(uint32_t)));
 	buf_ptr += WMI_TLV_HDR_SIZE;
-	node_config_args = (A_UINT32 *)buf_ptr;
+	node_config_args = (uint32_t *)buf_ptr;
 
 	for (i = 0; i < param->args_count; i++) {
 		node_config_args[i] = param->args_arr[i];
@@ -14298,7 +14298,7 @@ static QDF_STATUS send_wow_patterns_to_fw_cmd_tlv(wmi_unified_t wmi_handle,
 		WMI_TLV_HDR_SIZE +
 		0 * sizeof(WOW_MAGIC_PATTERN_CMD) +
 		WMI_TLV_HDR_SIZE +
-		0 * sizeof(A_UINT32) + WMI_TLV_HDR_SIZE + 1 * sizeof(A_UINT32);
+		0 * sizeof(uint32_t) + WMI_TLV_HDR_SIZE + 1 * sizeof(uint32_t);
 
 	buf = wmi_buf_alloc(wmi_handle, len);
 	if (!buf) {
@@ -14373,9 +14373,9 @@ static QDF_STATUS send_wow_patterns_to_fw_cmd_tlv(wmi_unified_t wmi_handle,
 	buf_ptr += WMI_TLV_HDR_SIZE;
 
 	/* Fill TLV for ratelimit_interval with dummy data as this fix elem */
-	WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32, 1 * sizeof(A_UINT32));
+	WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32, 1 * sizeof(uint32_t));
 	buf_ptr += WMI_TLV_HDR_SIZE;
-	*(A_UINT32 *) buf_ptr = 0;
+	*(uint32_t *) buf_ptr = 0;
 
 	ret = wmi_unified_cmd_send(wmi_handle, buf, len,
 				   WMI_WOW_ADD_WAKE_PATTERN_CMDID);
@@ -14595,7 +14595,7 @@ static QDF_STATUS send_enable_arp_ns_offload_cmd_tlv(wmi_unified_t wmi_handle,
 {
 	int32_t res;
 	WMI_SET_ARP_NS_OFFLOAD_CMD_fixed_param *cmd;
-	A_UINT8 *buf_ptr;
+	uint8_t *buf_ptr;
 	wmi_buf_t buf;
 	int32_t len;
 	uint32_t count = 0, num_ns_ext_tuples = 0;
@@ -14633,7 +14633,7 @@ static QDF_STATUS send_enable_arp_ns_offload_cmd_tlv(wmi_unified_t wmi_handle,
 		return QDF_STATUS_E_NOMEM;
 	}
 
-	buf_ptr = (A_UINT8 *) wmi_buf_data(buf);
+	buf_ptr = (uint8_t *) wmi_buf_data(buf);
 	cmd = (WMI_SET_ARP_NS_OFFLOAD_CMD_fixed_param *) buf_ptr;
 	WMITLV_SET_HDR(&cmd->tlv_header,
 		       WMITLV_TAG_STRUC_WMI_SET_ARP_NS_OFFLOAD_CMD_fixed_param,
@@ -14781,7 +14781,7 @@ static QDF_STATUS send_wow_sta_ra_filter_cmd_tlv(wmi_unified_t wmi_handle,
 	      WMI_TLV_HDR_SIZE +
 	      0 * sizeof(WOW_MAGIC_PATTERN_CMD) +
 	      WMI_TLV_HDR_SIZE +
-	      0 * sizeof(A_UINT32) + WMI_TLV_HDR_SIZE + 1 * sizeof(A_UINT32);
+	      0 * sizeof(uint32_t) + WMI_TLV_HDR_SIZE + 1 * sizeof(uint32_t);
 
 	buf = wmi_buf_alloc(wmi_handle, len);
 	if (!buf) {
@@ -14822,10 +14822,10 @@ static QDF_STATUS send_wow_sta_ra_filter_cmd_tlv(wmi_unified_t wmi_handle,
 	buf_ptr += WMI_TLV_HDR_SIZE;
 
 	/* Fill TLV for ra_ratelimit_interval. */
-	WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32, sizeof(A_UINT32));
+	WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32, sizeof(uint32_t));
 	buf_ptr += WMI_TLV_HDR_SIZE;
 
-	*((A_UINT32 *) buf_ptr) = rate_limit_interval;
+	*((uint32_t *) buf_ptr) = rate_limit_interval;
 
 	WMI_LOGD("%s: send RA rate limit [%d] to fw vdev = %d", __func__,
 		 rate_limit_interval, vdev_id);
@@ -14925,7 +14925,7 @@ static QDF_STATUS send_multiple_add_clear_mcbc_filter_cmd_tlv(
 		return QDF_STATUS_E_NOMEM;
 	}
 
-	buf_ptr = (A_UINT8 *) wmi_buf_data(buf);
+	buf_ptr = (uint8_t *) wmi_buf_data(buf);
 	cmd = (WMI_SET_MULTIPLE_MCAST_FILTER_CMD_fixed_param *)
 		wmi_buf_data(buf);
 	qdf_mem_zero(cmd, sizeof(*cmd));
@@ -15124,7 +15124,7 @@ static QDF_STATUS send_action_frame_patterns_cmd_tlv(wmi_unified_t wmi_handle,
 	uint32_t len = 0, *cmd_args;
 	uint8_t *buf_ptr;
 
-	len = (PMO_SUPPORTED_ACTION_CATE * sizeof(A_UINT32))
+	len = (PMO_SUPPORTED_ACTION_CATE * sizeof(uint32_t))
 				+ WMI_TLV_HDR_SIZE + sizeof(*cmd);
 	buf = wmi_buf_alloc(wmi_handle, len);
 	if (!buf) {
@@ -15147,7 +15147,7 @@ static QDF_STATUS send_action_frame_patterns_cmd_tlv(wmi_unified_t wmi_handle,
 
 	buf_ptr += sizeof(WMI_WOW_SET_ACTION_WAKE_UP_CMD_fixed_param);
 	WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32,
-			(PMO_SUPPORTED_ACTION_CATE * sizeof(A_UINT32)));
+			(PMO_SUPPORTED_ACTION_CATE * sizeof(uint32_t)));
 	buf_ptr += WMI_TLV_HDR_SIZE;
 	cmd_args = (uint32_t *) buf_ptr;
 	for (i = 0; i < PMO_SUPPORTED_ACTION_CATE; i++)
@@ -15782,10 +15782,10 @@ static QDF_STATUS send_unit_test_cmd_tlv(wmi_unified_t wmi_handle,
 	uint8_t *buf_ptr;
 	int i;
 	uint16_t len, args_tlv_len;
-	A_UINT32 *unit_test_cmd_args;
+	uint32_t *unit_test_cmd_args;
 
 	args_tlv_len =
-		WMI_TLV_HDR_SIZE + wmi_utest->num_args * sizeof(A_UINT32);
+		WMI_TLV_HDR_SIZE + wmi_utest->num_args * sizeof(uint32_t);
 	len = sizeof(wmi_unit_test_cmd_fixed_param) + args_tlv_len;
 
 	wmi_buf = wmi_buf_alloc(wmi_handle, len);
@@ -15806,7 +15806,7 @@ static QDF_STATUS send_unit_test_cmd_tlv(wmi_unified_t wmi_handle,
 	buf_ptr += sizeof(wmi_unit_test_cmd_fixed_param);
 	WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32,
 		       (wmi_utest->num_args * sizeof(uint32_t)));
-	unit_test_cmd_args = (A_UINT32 *) (buf_ptr + WMI_TLV_HDR_SIZE);
+	unit_test_cmd_args = (uint32_t *) (buf_ptr + WMI_TLV_HDR_SIZE);
 	WMI_LOGI("%s: VDEV ID: %d\n", __func__, cmd->vdev_id);
 	WMI_LOGI("%s: MODULE ID: %d\n", __func__, cmd->module_id);
 	WMI_LOGI("%s: TOKEN: %d\n", __func__, cmd->diag_token);
@@ -15842,12 +15842,12 @@ static QDF_STATUS send_roam_invoke_cmd_tlv(wmi_unified_t wmi_handle,
 	wmi_buf_t wmi_buf;
 	u_int8_t *buf_ptr;
 	u_int16_t len, args_tlv_len;
-	A_UINT32 *channel_list;
+	uint32_t *channel_list;
 	wmi_mac_addr *bssid_list;
 	wmi_tlv_buf_len_param *buf_len_tlv;
 
 	/* Host sends only one channel and one bssid */
-	args_tlv_len = (4 * WMI_TLV_HDR_SIZE) + sizeof(A_UINT32) +
+	args_tlv_len = (4 * WMI_TLV_HDR_SIZE) + sizeof(uint32_t) +
 			sizeof(wmi_mac_addr) + sizeof(wmi_tlv_buf_len_param) +
 			roundup(roaminvoke->frame_len, sizeof(uint32_t));
 	len = sizeof(wmi_roam_invoke_cmd_fixed_param) + args_tlv_len;
@@ -15885,9 +15885,9 @@ static QDF_STATUS send_roam_invoke_cmd_tlv(wmi_unified_t wmi_handle,
 	buf_ptr += sizeof(wmi_roam_invoke_cmd_fixed_param);
 	WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32,
 				(sizeof(u_int32_t)));
-	channel_list = (A_UINT32 *)(buf_ptr + WMI_TLV_HDR_SIZE);
+	channel_list = (uint32_t *)(buf_ptr + WMI_TLV_HDR_SIZE);
 	*channel_list = ch_hz;
-	buf_ptr += sizeof(A_UINT32) + WMI_TLV_HDR_SIZE;
+	buf_ptr += sizeof(uint32_t) + WMI_TLV_HDR_SIZE;
 	WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_FIXED_STRUC,
 				(sizeof(wmi_mac_addr)));
 	bssid_list = (wmi_mac_addr *)(buf_ptr + WMI_TLV_HDR_SIZE);
@@ -16251,7 +16251,7 @@ static QDF_STATUS send_roam_scan_offload_chan_list_cmd_tlv(wmi_unified_t wmi_han
 	int i;
 	uint8_t *buf_ptr;
 	wmi_roam_chan_list_fixed_param *chan_list_fp;
-	A_UINT32 *roam_chan_list_array;
+	uint32_t *roam_chan_list_array;
 
 	if (chan_count == 0) {
 		WMI_LOGD("%s : invalid number of channels %d", __func__,
@@ -16259,7 +16259,7 @@ static QDF_STATUS send_roam_scan_offload_chan_list_cmd_tlv(wmi_unified_t wmi_han
 		return QDF_STATUS_E_EMPTY;
 	}
 	/* Channel list is a table of 2 TLV's */
-	list_tlv_len = WMI_TLV_HDR_SIZE + chan_count * sizeof(A_UINT32);
+	list_tlv_len = WMI_TLV_HDR_SIZE + chan_count * sizeof(uint32_t);
 	len = sizeof(wmi_roam_chan_list_fixed_param) + list_tlv_len;
 	buf = wmi_buf_alloc(wmi_handle, len);
 	if (!buf) {
@@ -16288,7 +16288,7 @@ static QDF_STATUS send_roam_scan_offload_chan_list_cmd_tlv(wmi_unified_t wmi_han
 	buf_ptr += sizeof(wmi_roam_chan_list_fixed_param);
 	WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32,
 		       (chan_list_fp->num_chan * sizeof(uint32_t)));
-	roam_chan_list_array = (A_UINT32 *) (buf_ptr + WMI_TLV_HDR_SIZE);
+	roam_chan_list_array = (uint32_t *) (buf_ptr + WMI_TLV_HDR_SIZE);
 	WMI_LOGD("%s: %d channels = ", __func__, chan_list_fp->num_chan);
 	for (i = 0; ((i < chan_list_fp->num_chan) &&
 		     (i < WMI_ROAM_MAX_CHANNELS)); i++) {
@@ -16769,13 +16769,13 @@ static QDF_STATUS send_multiple_vdev_restart_req_cmd_tlv(
 
 	WMITLV_SET_HDR(buf_ptr,
 		       WMITLV_TAG_ARRAY_UINT32,
-		       sizeof(A_UINT32) * param->num_vdevs);
+		       sizeof(uint32_t) * param->num_vdevs);
 	vdev_ids = (uint32_t *)(buf_ptr + WMI_TLV_HDR_SIZE);
 	for (i = 0; i < param->num_vdevs; i++) {
 		vdev_ids[i] = param->vdev_ids[i];
 	}
 
-	buf_ptr += (sizeof(A_UINT32) * param->num_vdevs) + WMI_TLV_HDR_SIZE;
+	buf_ptr += (sizeof(uint32_t) * param->num_vdevs) + WMI_TLV_HDR_SIZE;
 
 	WMITLV_SET_HDR(buf_ptr,
 		       WMITLV_TAG_STRUC_wmi_channel,