staging: wfx: replace uintXX_t to uXX and intXX_t to sXX

Replace uint8_t to u8, uint16_t to u16, uint32_t to u32
int8_t to s8,int16_t to s16 and int32_t to s32
As per recommendation of checkpatch tool.

Signed-off-by: Jules Irenge <jbi.octave@gmail.com>
Link: https://lore.kernel.org/r/20191111133055.214410-1-jbi.octave@gmail.com
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

14 files changed, 649 insertions, 643 deletions

diff --git a/drivers/staging/wfx/bh.c b/drivers/staging/wfx/bh.c
index 955ed3a1dd73..2432ba95c2f5 100644
--- a/drivers/staging/wfx/bh.c
+++ b/drivers/staging/wfx/bh.c
@@ -239,7 +239,7 @@ static int bh_work_tx(struct wfx_dev *wdev, int max_msg)
  */
 static void ack_sdio_data(struct wfx_dev *wdev)
 {
-	uint32_t cfg_reg;
+	u32 cfg_reg;
 
 	config_reg_read(wdev, &cfg_reg);
 	if (cfg_reg & 0xFF) {
diff --git a/drivers/staging/wfx/data_tx.c b/drivers/staging/wfx/data_tx.c
index ea4205ac2149..b722e9773232 100644
--- a/drivers/staging/wfx/data_tx.c
+++ b/drivers/staging/wfx/data_tx.c
@@ -107,7 +107,7 @@ static void wfx_tx_policy_build(struct wfx_vif *wvif, struct tx_policy *policy,
 
 	for (i = 0; i < IEEE80211_TX_MAX_RATES; ++i) {
 		int rateid;
-		uint8_t count;
+		u8 count;
 
 		if (rates[i].idx < 0)
 			break;
@@ -477,7 +477,7 @@ static void wfx_tx_manage_pm(struct wfx_vif *wvif, struct ieee80211_hdr *hdr,
 		ieee80211_sta_set_buffered(sta, tx_priv->tid, true);
 }
 
-static uint8_t wfx_tx_get_raw_link_id(struct wfx_vif *wvif,
+static u8 wfx_tx_get_raw_link_id(struct wfx_vif *wvif,
 				      struct ieee80211_sta *sta,
 				      struct ieee80211_hdr *hdr)
 {
@@ -542,11 +542,11 @@ static void wfx_tx_fixup_rates(struct ieee80211_tx_rate *rates)
 		rates[i].flags &= ~IEEE80211_TX_RC_SHORT_GI;
 }
 
-static uint8_t wfx_tx_get_rate_id(struct wfx_vif *wvif,
+static u8 wfx_tx_get_rate_id(struct wfx_vif *wvif,
 				  struct ieee80211_tx_info *tx_info)
 {
 	bool tx_policy_renew = false;
-	uint8_t rate_id;
+	u8 rate_id;
 
 	rate_id = wfx_tx_policy_get(wvif,
 				    tx_info->driver_rates, &tx_policy_renew);
@@ -584,7 +584,7 @@ static struct hif_ht_tx_parameters wfx_tx_get_tx_parms(struct wfx_dev *wdev, str
 	return ret;
 }
 
-static uint8_t wfx_tx_get_tid(struct ieee80211_hdr *hdr)
+static u8 wfx_tx_get_tid(struct ieee80211_hdr *hdr)
 {
 	// FIXME: ieee80211_get_tid(hdr) should be sufficient for all cases.
 	if (!ieee80211_is_data(hdr->frame_control))
diff --git a/drivers/staging/wfx/data_tx.h b/drivers/staging/wfx/data_tx.h
index f74d1988925d..29faa5640516 100644
--- a/drivers/staging/wfx/data_tx.h
+++ b/drivers/staging/wfx/data_tx.h
@@ -31,17 +31,17 @@ enum wfx_link_status {
 struct wfx_link_entry {
 	unsigned long		timestamp;
 	enum wfx_link_status	status;
-	uint8_t			mac[ETH_ALEN];
-	uint8_t			old_mac[ETH_ALEN];
-	uint8_t			buffered[WFX_MAX_TID];
+	u8			mac[ETH_ALEN];
+	u8			old_mac[ETH_ALEN];
+	u8			buffered[WFX_MAX_TID];
 	struct sk_buff_head	rx_queue;
 };
 
 struct tx_policy {
 	struct list_head link;
-	uint8_t rates[12];
-	uint8_t usage_count;
-	uint8_t uploaded;
+	u8 rates[12];
+	u8 usage_count;
+	u8 uploaded;
 };
 
 struct tx_policy_cache {
@@ -55,9 +55,9 @@ struct tx_policy_cache {
 struct wfx_tx_priv {
 	ktime_t xmit_timestamp;
 	struct ieee80211_key_conf *hw_key;
-	uint8_t link_id;
-	uint8_t raw_link_id;
-	uint8_t tid;
+	u8 link_id;
+	u8 raw_link_id;
+	u8 tid;
 } __packed;
 
 void wfx_tx_policy_init(struct wfx_vif *wvif);
diff --git a/drivers/staging/wfx/hif_api_cmd.h b/drivers/staging/wfx/hif_api_cmd.h
index 7c5d1ea6098d..c15831de4ff4 100644
--- a/drivers/staging/wfx/hif_api_cmd.h
+++ b/drivers/staging/wfx/hif_api_cmd.h
@@ -85,10 +85,10 @@ enum hif_status {
 };
 
 struct hif_reset_flags {
-	uint8_t    reset_stat:1;
-	uint8_t    reset_all_int:1;
-	uint8_t    reserved1:6;
-	uint8_t    reserved2[3];
+	u8    reset_stat:1;
+	u8    reset_all_int:1;
+	u8    reserved1:6;
+	u8    reserved2[3];
 } __packed;
 
 struct hif_req_reset {
@@ -96,121 +96,121 @@ struct hif_req_reset {
 } __packed;
 
 struct hif_cnf_reset {
-	uint32_t   status;
+	u32   status;
 } __packed;
 
 struct hif_req_read_mib {
-	uint16_t   mib_id;
-	uint16_t   reserved;
+	u16   mib_id;
+	u16   reserved;
 } __packed;
 
 struct hif_cnf_read_mib {
-	uint32_t   status;
-	uint16_t   mib_id;
-	uint16_t   length;
-	uint8_t    mib_data[];
+	u32   status;
+	u16   mib_id;
+	u16   length;
+	u8    mib_data[];
 } __packed;
 
 struct hif_req_write_mib {
-	uint16_t   mib_id;
-	uint16_t   length;
-	uint8_t    mib_data[];
+	u16   mib_id;
+	u16   length;
+	u8    mib_data[];
 } __packed;
 
 struct hif_cnf_write_mib {
-	uint32_t   status;
+	u32   status;
 } __packed;
 
 struct hif_ie_flags {
-	uint8_t    beacon:1;
-	uint8_t    probe_resp:1;
-	uint8_t    probe_req:1;
-	uint8_t    reserved1:5;
-	uint8_t    reserved2;
+	u8    beacon:1;
+	u8    probe_resp:1;
+	u8    probe_req:1;
+	u8    reserved1:5;
+	u8    reserved2;
 } __packed;
 
 struct hif_ie_tlv {
-	uint8_t    type;
-	uint8_t    length;
-	uint8_t    data[];
+	u8    type;
+	u8    length;
+	u8    data[];
 } __packed;
 
 struct hif_req_update_ie {
 	struct hif_ie_flags ie_flags;
-	uint16_t   num_i_es;
+	u16   num_i_es;
 	struct hif_ie_tlv ie[];
 } __packed;
 
 struct hif_cnf_update_ie {
-	uint32_t   status;
+	u32   status;
 } __packed;
 
 struct hif_scan_type {
-	uint8_t    type:1;
-	uint8_t    mode:1;
-	uint8_t    reserved:6;
+	u8    type:1;
+	u8    mode:1;
+	u8    reserved:6;
 } __packed;
 
 struct hif_scan_flags {
-	uint8_t    fbg:1;
-	uint8_t    reserved1:1;
-	uint8_t    pre:1;
-	uint8_t    reserved2:5;
+	u8    fbg:1;
+	u8    reserved1:1;
+	u8    pre:1;
+	u8    reserved2:5;
 } __packed;
 
 struct hif_auto_scan_param {
-	uint16_t   interval;
-	uint8_t    reserved;
-	int8_t     rssi_thr;
+	u16   interval;
+	u8    reserved;
+	s8     rssi_thr;
 } __packed;
 
 struct hif_ssid_def {
-	uint32_t   ssid_length;
-	uint8_t    ssid[HIF_API_SSID_SIZE];
+	u32   ssid_length;
+	u8    ssid[HIF_API_SSID_SIZE];
 } __packed;
 
 #define HIF_API_MAX_NB_SSIDS                           2
 #define HIF_API_MAX_NB_CHANNELS                       14
 
 struct hif_req_start_scan {
-	uint8_t    band;
+	u8    band;
 	struct hif_scan_type scan_type;
 	struct hif_scan_flags scan_flags;
-	uint8_t    max_transmit_rate;
+	u8    max_transmit_rate;
 	struct hif_auto_scan_param auto_scan_param;
-	uint8_t    num_of_probe_requests;
-	uint8_t    probe_delay;
-	uint8_t    num_of_ssi_ds;
-	uint8_t    num_of_channels;
-	uint32_t   min_channel_time;
-	uint32_t   max_channel_time;
-	int32_t    tx_power_level;
-	uint8_t    ssid_and_channel_lists[];
+	u8    num_of_probe_requests;
+	u8    probe_delay;
+	u8    num_of_ssi_ds;
+	u8    num_of_channels;
+	u32   min_channel_time;
+	u32   max_channel_time;
+	s32    tx_power_level;
+	u8    ssid_and_channel_lists[];
 } __packed;
 
 struct hif_start_scan_req_cstnbssid_body {
-	uint8_t    band;
+	u8    band;
 	struct hif_scan_type scan_type;
 	struct hif_scan_flags scan_flags;
-	uint8_t    max_transmit_rate;
+	u8    max_transmit_rate;
 	struct hif_auto_scan_param auto_scan_param;
-	uint8_t    num_of_probe_requests;
-	uint8_t    probe_delay;
-	uint8_t    num_of_ssi_ds;
-	uint8_t    num_of_channels;
-	uint32_t   min_channel_time;
-	uint32_t   max_channel_time;
-	int32_t    tx_power_level;
+	u8    num_of_probe_requests;
+	u8    probe_delay;
+	u8    num_of_ssi_ds;
+	u8    num_of_channels;
+	u32   min_channel_time;
+	u32   max_channel_time;
+	s32    tx_power_level;
 	struct hif_ssid_def ssid_def[HIF_API_MAX_NB_SSIDS];
-	uint8_t    channel_list[];
+	u8    channel_list[];
 } __packed;
 
 struct hif_cnf_start_scan {
-	uint32_t   status;
+	u32   status;
 } __packed;
 
 struct hif_cnf_stop_scan {
-	uint32_t   status;
+	u32   status;
 } __packed;
 
 enum hif_pm_mode_status {
@@ -220,10 +220,10 @@ enum hif_pm_mode_status {
 };
 
 struct hif_ind_scan_cmpl {
-	uint32_t   status;
-	uint8_t    pm_mode;
-	uint8_t    num_channels_completed;
-	uint16_t   reserved;
+	u32   status;
+	u8    pm_mode;
+	u8    num_channels_completed;
+	u16   reserved;
 } __packed;
 
 enum hif_queue_id {
@@ -245,45 +245,45 @@ enum hif_stbc {
 };
 
 struct hif_queue {
-	uint8_t    queue_id:2;
-	uint8_t    peer_sta_id:4;
-	uint8_t    reserved:2;
+	u8    queue_id:2;
+	u8    peer_sta_id:4;
+	u8    reserved:2;
 } __packed;
 
 struct hif_data_flags {
-	uint8_t    more:1;
-	uint8_t    fc_offset:3;
-	uint8_t    reserved:4;
+	u8    more:1;
+	u8    fc_offset:3;
+	u8    reserved:4;
 } __packed;
 
 struct hif_tx_flags {
-	uint8_t    start_exp:1;
-	uint8_t    reserved:3;
-	uint8_t    retry_policy_index:4;
+	u8    start_exp:1;
+	u8    reserved:3;
+	u8    retry_policy_index:4;
 } __packed;
 
 struct hif_ht_tx_parameters {
-	uint8_t    frame_format:4;
-	uint8_t    fec_coding:1;
-	uint8_t    short_gi:1;
-	uint8_t    reserved1:1;
-	uint8_t    stbc:1;
-	uint8_t    reserved2;
-	uint8_t    aggregation:1;
-	uint8_t    reserved3:7;
-	uint8_t    reserved4;
+	u8    frame_format:4;
+	u8    fec_coding:1;
+	u8    short_gi:1;
+	u8    reserved1:1;
+	u8    stbc:1;
+	u8    reserved2;
+	u8    aggregation:1;
+	u8    reserved3:7;
+	u8    reserved4;
 } __packed;
 
 struct hif_req_tx {
-	uint32_t   packet_id;
-	uint8_t    max_tx_rate;
+	u32   packet_id;
+	u8    max_tx_rate;
 	struct hif_queue queue_id;
 	struct hif_data_flags data_flags;
 	struct hif_tx_flags tx_flags;
-	uint32_t   reserved;
-	uint32_t   expire_time;
+	u32   reserved;
+	u32   expire_time;
 	struct hif_ht_tx_parameters ht_tx_parameters;
-	uint8_t    frame[];
+	u8    frame[];
 } __packed;
 
 enum hif_qos_ackplcy {
@@ -294,26 +294,26 @@ enum hif_qos_ackplcy {
 };
 
 struct hif_tx_result_flags {
-	uint8_t    aggr:1;
-	uint8_t    requeue:1;
-	uint8_t    ack_policy:2;
-	uint8_t    txop_limit:1;
-	uint8_t    reserved1:3;
-	uint8_t    reserved2;
+	u8    aggr:1;
+	u8    requeue:1;
+	u8    ack_policy:2;
+	u8    txop_limit:1;
+	u8    reserved1:3;
+	u8    reserved2;
 } __packed;
 
 struct hif_cnf_tx {
-	uint32_t   status;
-	uint32_t   packet_id;
-	uint8_t    txed_rate;
-	uint8_t    ack_failures;
+	u32   status;
+	u32   packet_id;
+	u8    txed_rate;
+	u8    ack_failures;
 	struct hif_tx_result_flags tx_result_flags;
-	uint32_t   media_delay;
-	uint32_t   tx_queue_delay;
+	u32   media_delay;
+	u32   tx_queue_delay;
 } __packed;
 
 struct hif_cnf_multi_transmit {
-	uint32_t   num_tx_confs;
+	u32   num_tx_confs;
 	struct hif_cnf_tx   tx_conf_payload[];
 } __packed;
 
@@ -326,55 +326,55 @@ enum hif_ri_flags_encrypt {
 };
 
 struct hif_rx_flags {
-	uint8_t    encryp:3;
-	uint8_t    in_aggr:1;
-	uint8_t    first_aggr:1;
-	uint8_t    last_aggr:1;
-	uint8_t    defrag:1;
-	uint8_t    beacon:1;
-	uint8_t    tim:1;
-	uint8_t    bitmap:1;
-	uint8_t    match_ssid:1;
-	uint8_t    match_bssid:1;
-	uint8_t    more:1;
-	uint8_t    reserved1:1;
-	uint8_t    ht:1;
-	uint8_t    stbc:1;
-	uint8_t    match_uc_addr:1;
-	uint8_t    match_mc_addr:1;
-	uint8_t    match_bc_addr:1;
-	uint8_t    key_type:1;
-	uint8_t    key_index:4;
-	uint8_t    reserved2:1;
-	uint8_t    peer_sta_id:4;
-	uint8_t    reserved3:2;
-	uint8_t    reserved4:1;
+	u8    encryp:3;
+	u8    in_aggr:1;
+	u8    first_aggr:1;
+	u8    last_aggr:1;
+	u8    defrag:1;
+	u8    beacon:1;
+	u8    tim:1;
+	u8    bitmap:1;
+	u8    match_ssid:1;
+	u8    match_bssid:1;
+	u8    more:1;
+	u8    reserved1:1;
+	u8    ht:1;
+	u8    stbc:1;
+	u8    match_uc_addr:1;
+	u8    match_mc_addr:1;
+	u8    match_bc_addr:1;
+	u8    key_type:1;
+	u8    key_index:4;
+	u8    reserved2:1;
+	u8    peer_sta_id:4;
+	u8    reserved3:2;
+	u8    reserved4:1;
 } __packed;
 
 struct hif_ind_rx {
-	uint32_t   status;
-	uint16_t   channel_number;
-	uint8_t    rxed_rate;
-	uint8_t    rcpi_rssi;
+	u32   status;
+	u16   channel_number;
+	u8    rxed_rate;
+	u8    rcpi_rssi;
 	struct hif_rx_flags rx_flags;
-	uint8_t    frame[];
+	u8    frame[];
 } __packed;
 
 
 struct hif_req_edca_queue_params {
-	uint8_t    queue_id;
-	uint8_t    reserved1;
-	uint8_t    aifsn;
-	uint8_t    reserved2;
-	uint16_t   cw_min;
-	uint16_t   cw_max;
-	uint16_t   tx_op_limit;
-	uint16_t   allowed_medium_time;
-	uint32_t   reserved3;
+	u8    queue_id;
+	u8    reserved1;
+	u8    aifsn;
+	u8    reserved2;
+	u16   cw_min;
+	u16   cw_max;
+	u16   tx_op_limit;
+	u16   allowed_medium_time;
+	u32   reserved3;
 } __packed;
 
 struct hif_cnf_edca_queue_params {
-	uint32_t   status;
+	u32   status;
 } __packed;
 
 enum hif_ap_mode {
@@ -389,92 +389,92 @@ enum hif_preamble {
 };
 
 struct hif_join_flags {
-	uint8_t    reserved1:2;
-	uint8_t    force_no_beacon:1;
-	uint8_t    force_with_ind:1;
-	uint8_t    reserved2:4;
+	u8    reserved1:2;
+	u8    force_no_beacon:1;
+	u8    force_with_ind:1;
+	u8    reserved2:4;
 } __packed;
 
 struct hif_req_join {
-	uint8_t    mode;
-	uint8_t    band;
-	uint16_t   channel_number;
-	uint8_t    bssid[ETH_ALEN];
-	uint16_t   atim_window;
-	uint8_t    preamble_type;
-	uint8_t    probe_for_join;
-	uint8_t    reserved;
+	u8    mode;
+	u8    band;
+	u16   channel_number;
+	u8    bssid[ETH_ALEN];
+	u16   atim_window;
+	u8    preamble_type;
+	u8    probe_for_join;
+	u8    reserved;
 	struct hif_join_flags join_flags;
-	uint32_t   ssid_length;
-	uint8_t    ssid[HIF_API_SSID_SIZE];
-	uint32_t   beacon_interval;
-	uint32_t   basic_rate_set;
+	u32   ssid_length;
+	u8    ssid[HIF_API_SSID_SIZE];
+	u32   beacon_interval;
+	u32   basic_rate_set;
 } __packed;
 
 struct hif_cnf_join {
-	uint32_t   status;
+	u32   status;
 } __packed;
 
 struct hif_ind_join_complete {
-	uint32_t   status;
+	u32   status;
 } __packed;
 
 struct hif_bss_flags {
-	uint8_t    lost_count_only:1;
-	uint8_t    reserved:7;
+	u8    lost_count_only:1;
+	u8    reserved:7;
 } __packed;
 
 struct hif_req_set_bss_params {
 	struct hif_bss_flags bss_flags;
-	uint8_t    beacon_lost_count;
-	uint16_t   aid;
-	uint32_t   operational_rate_set;
+	u8    beacon_lost_count;
+	u16   aid;
+	u32   operational_rate_set;
 } __packed;
 
 struct hif_cnf_set_bss_params {
-	uint32_t   status;
+	u32   status;
 } __packed;
 
 struct hif_pm_mode {
-	uint8_t    enter_psm:1;
-	uint8_t    reserved:6;
-	uint8_t    fast_psm:1;
+	u8    enter_psm:1;
+	u8    reserved:6;
+	u8    fast_psm:1;
 } __packed;
 
 struct hif_req_set_pm_mode {
 	struct hif_pm_mode pm_mode;
-	uint8_t    fast_psm_idle_period;
-	uint8_t    ap_psm_change_period;
-	uint8_t    min_auto_ps_poll_period;
+	u8    fast_psm_idle_period;
+	u8    ap_psm_change_period;
+	u8    min_auto_ps_poll_period;
 } __packed;
 
 struct hif_cnf_set_pm_mode {
-	uint32_t   status;
+	u32   status;
 } __packed;
 
 struct hif_ind_set_pm_mode_cmpl {
-	uint32_t   status;
-	uint8_t    pm_mode;
-	uint8_t    reserved[3];
+	u32   status;
+	u8    pm_mode;
+	u8    reserved[3];
 } __packed;
 
 
 struct hif_req_start {
-	uint8_t    mode;
-	uint8_t    band;
-	uint16_t   channel_number;
-	uint32_t   reserved1;
-	uint32_t   beacon_interval;
-	uint8_t    dtim_period;
-	uint8_t    preamble_type;
-	uint8_t    reserved2;
-	uint8_t    ssid_length;
-	uint8_t    ssid[HIF_API_SSID_SIZE];
-	uint32_t   basic_rate_set;
+	u8    mode;
+	u8    band;
+	u16   channel_number;
+	u32   reserved1;
+	u32   beacon_interval;
+	u8    dtim_period;
+	u8    preamble_type;
+	u8    reserved2;
+	u8    ssid_length;
+	u8    ssid[HIF_API_SSID_SIZE];
+	u32   basic_rate_set;
 } __packed;
 
 struct hif_cnf_start {
-	uint32_t   status;
+	u32   status;
 } __packed;
 
 enum hif_beacon {
@@ -483,12 +483,12 @@ enum hif_beacon {
 };
 
 struct hif_req_beacon_transmit {
-	uint8_t    enable_beaconing;
-	uint8_t    reserved[3];
+	u8    enable_beaconing;
+	u8    reserved[3];
 } __packed;
 
 struct hif_cnf_beacon_transmit {
-	uint32_t   status;
+	u32   status;
 } __packed;
 
 enum hif_sta_map_direction {
@@ -497,32 +497,32 @@ enum hif_sta_map_direction {
 };
 
 struct hif_map_link_flags {
-	uint8_t    map_direction:1;
-	uint8_t    mfpc:1;
-	uint8_t    reserved:6;
+	u8    map_direction:1;
+	u8    mfpc:1;
+	u8    reserved:6;
 } __packed;
 
 struct hif_req_map_link {
-	uint8_t    mac_addr[ETH_ALEN];
+	u8    mac_addr[ETH_ALEN];
 	struct hif_map_link_flags map_link_flags;
-	uint8_t    peer_sta_id;
+	u8    peer_sta_id;
 } __packed;
 
 struct hif_cnf_map_link {
-	uint32_t   status;
+	u32   status;
 } __packed;
 
 struct hif_suspend_resume_flags {
-	uint8_t    resume:1;
-	uint8_t    reserved1:2;
-	uint8_t    bc_mc_only:1;
-	uint8_t    reserved2:4;
-	uint8_t    reserved3;
+	u8    resume:1;
+	u8    reserved1:2;
+	u8    bc_mc_only:1;
+	u8    reserved2:4;
+	u8    reserved3;
 } __packed;
 
 struct hif_ind_suspend_resume_tx {
 	struct hif_suspend_resume_flags suspend_resume_flags;
-	uint16_t   peer_sta_set;
+	u16   peer_sta_set;
 } __packed;
 
 
@@ -552,68 +552,68 @@ enum hif_key_type {
 };
 
 struct hif_wep_pairwise_key {
-	uint8_t    peer_address[ETH_ALEN];
-	uint8_t    reserved;
-	uint8_t    key_length;
-	uint8_t    key_data[HIF_API_WEP_KEY_DATA_SIZE];
+	u8    peer_address[ETH_ALEN];
+	u8    reserved;
+	u8    key_length;
+	u8    key_data[HIF_API_WEP_KEY_DATA_SIZE];
 } __packed;
 
 struct hif_wep_group_key {
-	uint8_t    key_id;
-	uint8_t    key_length;
-	uint8_t    reserved[2];
-	uint8_t    key_data[HIF_API_WEP_KEY_DATA_SIZE];
+	u8    key_id;
+	u8    key_length;
+	u8    reserved[2];
+	u8    key_data[HIF_API_WEP_KEY_DATA_SIZE];
 } __packed;
 
 struct hif_tkip_pairwise_key {
-	uint8_t    peer_address[ETH_ALEN];
-	uint8_t    reserved[2];
-	uint8_t    tkip_key_data[HIF_API_TKIP_KEY_DATA_SIZE];
-	uint8_t    rx_mic_key[HIF_API_RX_MIC_KEY_SIZE];
-	uint8_t    tx_mic_key[HIF_API_TX_MIC_KEY_SIZE];
+	u8    peer_address[ETH_ALEN];
+	u8    reserved[2];
+	u8    tkip_key_data[HIF_API_TKIP_KEY_DATA_SIZE];
+	u8    rx_mic_key[HIF_API_RX_MIC_KEY_SIZE];
+	u8    tx_mic_key[HIF_API_TX_MIC_KEY_SIZE];
 } __packed;
 
 struct hif_tkip_group_key {
-	uint8_t    tkip_key_data[HIF_API_TKIP_KEY_DATA_SIZE];
-	uint8_t    rx_mic_key[HIF_API_RX_MIC_KEY_SIZE];
-	uint8_t    key_id;
-	uint8_t    reserved[3];
-	uint8_t    rx_sequence_counter[HIF_API_RX_SEQUENCE_COUNTER_SIZE];
+	u8    tkip_key_data[HIF_API_TKIP_KEY_DATA_SIZE];
+	u8    rx_mic_key[HIF_API_RX_MIC_KEY_SIZE];
+	u8    key_id;
+	u8    reserved[3];
+	u8    rx_sequence_counter[HIF_API_RX_SEQUENCE_COUNTER_SIZE];
 } __packed;
 
 struct hif_aes_pairwise_key {
-	uint8_t    peer_address[ETH_ALEN];
-	uint8_t    reserved[2];
-	uint8_t    aes_key_data[HIF_API_AES_KEY_DATA_SIZE];
+	u8    peer_address[ETH_ALEN];
+	u8    reserved[2];
+	u8    aes_key_data[HIF_API_AES_KEY_DATA_SIZE];
 } __packed;
 
 struct hif_aes_group_key {
-	uint8_t    aes_key_data[HIF_API_AES_KEY_DATA_SIZE];
-	uint8_t    key_id;
-	uint8_t    reserved[3];
-	uint8_t    rx_sequence_counter[HIF_API_RX_SEQUENCE_COUNTER_SIZE];
+	u8    aes_key_data[HIF_API_AES_KEY_DATA_SIZE];
+	u8    key_id;
+	u8    reserved[3];
+	u8    rx_sequence_counter[HIF_API_RX_SEQUENCE_COUNTER_SIZE];
 } __packed;
 
 struct hif_wapi_pairwise_key {
-	uint8_t    peer_address[ETH_ALEN];
-	uint8_t    key_id;
-	uint8_t    reserved;
-	uint8_t    wapi_key_data[HIF_API_WAPI_KEY_DATA_SIZE];
-	uint8_t    mic_key_data[HIF_API_MIC_KEY_DATA_SIZE];
+	u8    peer_address[ETH_ALEN];
+	u8    key_id;
+	u8    reserved;
+	u8    wapi_key_data[HIF_API_WAPI_KEY_DATA_SIZE];
+	u8    mic_key_data[HIF_API_MIC_KEY_DATA_SIZE];
 } __packed;
 
 struct hif_wapi_group_key {
-	uint8_t    wapi_key_data[HIF_API_WAPI_KEY_DATA_SIZE];
-	uint8_t    mic_key_data[HIF_API_MIC_KEY_DATA_SIZE];
-	uint8_t    key_id;
-	uint8_t    reserved[3];
+	u8    wapi_key_data[HIF_API_WAPI_KEY_DATA_SIZE];
+	u8    mic_key_data[HIF_API_MIC_KEY_DATA_SIZE];
+	u8    key_id;
+	u8    reserved[3];
 } __packed;
 
 struct hif_igtk_group_key {
-	uint8_t    igtk_key_data[HIF_API_IGTK_KEY_DATA_SIZE];
-	uint8_t    key_id;
-	uint8_t    reserved[3];
-	uint8_t    ipn[HIF_API_IPN_SIZE];
+	u8    igtk_key_data[HIF_API_IGTK_KEY_DATA_SIZE];
+	u8    key_id;
+	u8    reserved[3];
+	u8    ipn[HIF_API_IPN_SIZE];
 } __packed;
 
 union hif_privacy_key_data {
@@ -629,25 +629,25 @@ union hif_privacy_key_data {
 };
 
 struct hif_req_add_key {
-	uint8_t    type;
-	uint8_t    entry_index;
-	uint8_t    int_id:2;
-	uint8_t    reserved1:6;
-	uint8_t    reserved2;
+	u8    type;
+	u8    entry_index;
+	u8    int_id:2;
+	u8    reserved1:6;
+	u8    reserved2;
 	union hif_privacy_key_data key;
 } __packed;
 
 struct hif_cnf_add_key {
-	uint32_t   status;
+	u32   status;
 } __packed;
 
 struct hif_req_remove_key {
-	uint8_t    entry_index;
-	uint8_t    reserved[3];
+	u8    entry_index;
+	u8    reserved[3];
 } __packed;
 
 struct hif_cnf_remove_key {
-	uint32_t   status;
+	u32   status;
 } __packed;
 
 enum hif_event_ind {
@@ -667,13 +667,13 @@ enum hif_ps_mode_error {
 };
 
 union hif_event_data {
-	uint8_t    rcpi_rssi;
-	uint32_t   ps_mode_error;
-	uint32_t   peer_sta_set;
+	u8    rcpi_rssi;
+	u32   ps_mode_error;
+	u32   peer_sta_set;
 };
 
 struct hif_ind_event {
-	uint32_t   event_id;
+	u32   event_id;
 	union hif_event_data event_data;
 } __packed;
 
diff --git a/drivers/staging/wfx/hif_api_general.h b/drivers/staging/wfx/hif_api_general.h
index d885b55d2882..a069c3a21b4d 100644
--- a/drivers/staging/wfx/hif_api_general.h
+++ b/drivers/staging/wfx/hif_api_general.h
@@ -23,13 +23,13 @@
 #define HIF_COUNTER_MAX                    7
 
 struct hif_msg {
-	uint16_t    len;
-	uint8_t     id;
-	uint8_t     reserved:1;
-	uint8_t     interface:2;
-	uint8_t     seqnum:3;
-	uint8_t     encrypted:2;
-	uint8_t     body[];
+	u16    len;
+	u8     id;
+	u8     reserved:1;
+	u8     interface:2;
+	u8     seqnum:3;
+	u8     encrypted:2;
+	u8     body[];
 } __packed;
 
 enum hif_general_requests_ids {
@@ -117,22 +117,22 @@ enum hif_fw_type {
 };
 
 struct hif_capabilities {
-	uint8_t    link_mode:2;
-	uint8_t    reserved1:6;
-	uint8_t    reserved2;
-	uint8_t    reserved3;
-	uint8_t    reserved4;
+	u8    link_mode:2;
+	u8    reserved1:6;
+	u8    reserved2;
+	u8    reserved3;
+	u8    reserved4;
 } __packed;
 
 struct hif_otp_regul_sel_mode_info {
-	uint8_t    region_sel_mode:4;
-	uint8_t    reserved:4;
+	u8    region_sel_mode:4;
+	u8    reserved:4;
 } __packed;
 
 struct hif_otp_phy_info {
-	uint8_t    phy1_region:3;
-	uint8_t    phy0_region:3;
-	uint8_t    otp_phy_ver:2;
+	u8    phy1_region:3;
+	u8    phy0_region:3;
+	u8    otp_phy_ver:2;
 } __packed;
 
 #define API_OPN_SIZE                                    14
@@ -141,39 +141,39 @@ struct hif_otp_phy_info {
 #define API_FIRMWARE_LABEL_SIZE                         128
 
 struct hif_ind_startup {
-	uint32_t   status;
-	uint16_t   hardware_id;
-	uint8_t    opn[API_OPN_SIZE];
-	uint8_t    uid[API_UID_SIZE];
-	uint16_t   num_inp_ch_bufs;
-	uint16_t   size_inp_ch_buf;
-	uint8_t    num_links_ap;
-	uint8_t    num_interfaces;
-	uint8_t    mac_addr[2][ETH_ALEN];
-	uint8_t    api_version_minor;
-	uint8_t    api_version_major;
+	u32   status;
+	u16   hardware_id;
+	u8    opn[API_OPN_SIZE];
+	u8    uid[API_UID_SIZE];
+	u16   num_inp_ch_bufs;
+	u16   size_inp_ch_buf;
+	u8    num_links_ap;
+	u8    num_interfaces;
+	u8    mac_addr[2][ETH_ALEN];
+	u8    api_version_minor;
+	u8    api_version_major;
 	struct hif_capabilities capabilities;
-	uint8_t    firmware_build;
-	uint8_t    firmware_minor;
-	uint8_t    firmware_major;
-	uint8_t    firmware_type;
-	uint8_t    disabled_channel_list[API_DISABLED_CHANNEL_LIST_SIZE];
+	u8    firmware_build;
+	u8    firmware_minor;
+	u8    firmware_major;
+	u8    firmware_type;
+	u8    disabled_channel_list[API_DISABLED_CHANNEL_LIST_SIZE];
 	struct hif_otp_regul_sel_mode_info regul_sel_mode_info;
 	struct hif_otp_phy_info otp_phy_info;
-	uint32_t   supported_rate_mask;
-	uint8_t    firmware_label[API_FIRMWARE_LABEL_SIZE];
+	u32   supported_rate_mask;
+	u8    firmware_label[API_FIRMWARE_LABEL_SIZE];
 } __packed;
 
 struct hif_ind_wakeup {
 } __packed;
 
 struct hif_req_configuration {
-	uint16_t   length;
-	uint8_t    pds_data[];
+	u16   length;
+	u8    pds_data[];
 } __packed;
 
 struct hif_cnf_configuration {
-	uint32_t   status;
+	u32   status;
 } __packed;
 
 enum hif_gpio_mode {
@@ -187,8 +187,8 @@ enum hif_gpio_mode {
 };
 
 struct hif_req_control_gpio {
-	uint8_t gpio_label;
-	uint8_t gpio_mode;
+	u8 gpio_label;
+	u8 gpio_mode;
 } __packed;
 
 enum hif_gpio_error {
@@ -198,8 +198,8 @@ enum hif_gpio_error {
 };
 
 struct hif_cnf_control_gpio {
-	uint32_t status;
-	uint32_t value;
+	u32 status;
+	u32 value;
 } __packed;
 
 enum hif_generic_indication_type {
@@ -209,28 +209,28 @@ enum hif_generic_indication_type {
 };
 
 struct hif_rx_stats {
-	uint32_t   nb_rx_frame;
-	uint32_t   nb_crc_frame;
-	uint32_t   per_total;
-	uint32_t   throughput;
-	uint32_t   nb_rx_by_rate[API_RATE_NUM_ENTRIES];
-	uint16_t   per[API_RATE_NUM_ENTRIES];
-	int16_t    snr[API_RATE_NUM_ENTRIES];
-	int16_t    rssi[API_RATE_NUM_ENTRIES];
-	int16_t    cfo[API_RATE_NUM_ENTRIES];
-	uint32_t   date;
-	uint32_t   pwr_clk_freq;
-	uint8_t    is_ext_pwr_clk;
-	int8_t     current_temp;
+	u32   nb_rx_frame;
+	u32   nb_crc_frame;
+	u32   per_total;
+	u32   throughput;
+	u32   nb_rx_by_rate[API_RATE_NUM_ENTRIES];
+	u16   per[API_RATE_NUM_ENTRIES];
+	s16    snr[API_RATE_NUM_ENTRIES];
+	s16    rssi[API_RATE_NUM_ENTRIES];
+	s16    cfo[API_RATE_NUM_ENTRIES];
+	u32   date;
+	u32   pwr_clk_freq;
+	u8    is_ext_pwr_clk;
+	s8     current_temp;
 } __packed;
 
 union hif_indication_data {
 	struct hif_rx_stats                                   rx_stats;
-	uint8_t                                       raw_data[1];
+	u8                                       raw_data[1];
 };
 
 struct hif_ind_generic {
-	uint32_t indication_type;
+	u32 indication_type;
 	union hif_indication_data indication_data;
 } __packed;
 
@@ -238,7 +238,7 @@ struct hif_ind_generic {
 #define HIF_EXCEPTION_DATA_SIZE            124
 
 struct hif_ind_exception {
-	uint8_t    data[HIF_EXCEPTION_DATA_SIZE];
+	u8    data[HIF_EXCEPTION_DATA_SIZE];
 } __packed;
 
 
@@ -257,8 +257,8 @@ enum hif_error {
 };
 
 struct hif_ind_error {
-	uint32_t   type;
-	uint8_t    data[];
+	u32   type;
+	u8    data[];
 } __packed;
 
 enum hif_secure_link_state {
@@ -276,20 +276,20 @@ enum hif_sl_encryption_type {
 };
 
 struct hif_sl_msg_hdr {
-	uint32_t    seqnum:30;
-	uint32_t    encrypted:2;
+	u32    seqnum:30;
+	u32    encrypted:2;
 } __packed;
 
 struct hif_sl_msg {
 	struct hif_sl_msg_hdr hdr;
-	uint16_t        len;
-	uint8_t         payload[];
+	u16        len;
+	u8         payload[];
 } __packed;
 
 #define AES_CCM_TAG_SIZE     16
 
 struct hif_sl_tag {
-	uint8_t tag[16];
+	u8 tag[16];
 } __packed;
 
 enum hif_sl_mac_key_dest {
@@ -300,12 +300,12 @@ enum hif_sl_mac_key_dest {
 #define API_KEY_VALUE_SIZE      32
 
 struct hif_req_set_sl_mac_key {
-	uint8_t    otp_or_ram;
-	uint8_t    key_value[API_KEY_VALUE_SIZE];
+	u8    otp_or_ram;
+	u8    key_value[API_KEY_VALUE_SIZE];
 } __packed;
 
 struct hif_cnf_set_sl_mac_key {
-	uint32_t   status;
+	u32   status;
 } __packed;
 
 #define API_HOST_PUB_KEY_SIZE                           32
@@ -317,45 +317,45 @@ enum hif_sl_session_key_alg {
 };
 
 struct hif_req_sl_exchange_pub_keys {
-	uint8_t    algorithm:2;
-	uint8_t    reserved1:6;
-	uint8_t    reserved2[3];
-	uint8_t    host_pub_key[API_HOST_PUB_KEY_SIZE];
-	uint8_t    host_pub_key_mac[API_HOST_PUB_KEY_MAC_SIZE];
+	u8    algorithm:2;
+	u8    reserved1:6;
+	u8    reserved2[3];
+	u8    host_pub_key[API_HOST_PUB_KEY_SIZE];
+	u8    host_pub_key_mac[API_HOST_PUB_KEY_MAC_SIZE];
 } __packed;
 
 struct hif_cnf_sl_exchange_pub_keys {
-	uint32_t   status;
+	u32   status;
 } __packed;
 
 #define API_NCP_PUB_KEY_SIZE                            32
 #define API_NCP_PUB_KEY_MAC_SIZE                        64
 
 struct hif_ind_sl_exchange_pub_keys {
-	uint32_t   status;
-	uint8_t    ncp_pub_key[API_NCP_PUB_KEY_SIZE];
-	uint8_t    ncp_pub_key_mac[API_NCP_PUB_KEY_MAC_SIZE];
+	u32   status;
+	u8    ncp_pub_key[API_NCP_PUB_KEY_SIZE];
+	u8    ncp_pub_key_mac[API_NCP_PUB_KEY_MAC_SIZE];
 } __packed;
 
 #define API_ENCR_BMP_SIZE        32
 
 struct hif_req_sl_configure {
-	uint8_t    encr_bmp[API_ENCR_BMP_SIZE];
-	uint8_t    disable_session_key_protection:1;
-	uint8_t    reserved1:7;
-	uint8_t    reserved2[3];
+	u8    encr_bmp[API_ENCR_BMP_SIZE];
+	u8    disable_session_key_protection:1;
+	u8    reserved1:7;
+	u8    reserved2[3];
 } __packed;
 
 struct hif_cnf_sl_configure {
-	uint32_t status;
+	u32 status;
 } __packed;
 
 struct hif_req_prevent_rollback {
-	uint32_t   magic_word;
+	u32   magic_word;
 } __packed;
 
 struct hif_cnf_prevent_rollback {
-	uint32_t    status;
+	u32    status;
 } __packed;
 
 enum hif_pta_mode {
@@ -382,27 +382,27 @@ enum hif_grant_state {
 };
 
 struct hif_req_pta_settings {
-	uint8_t pta_mode;
-	uint8_t request_signal_active_level;
-	uint8_t priority_signal_active_level;
-	uint8_t freq_signal_active_level;
-	uint8_t grant_signal_active_level;
-	uint8_t coex_type;
-	uint8_t default_grant_state;
-	uint8_t simultaneous_rx_accesses;
-	uint8_t priority_sampling_time;
-	uint8_t tx_rx_sampling_time;
-	uint8_t freq_sampling_time;
-	uint8_t grant_valid_time;
-	uint8_t fem_control_time;
-	uint8_t first_slot_time;
-	uint16_t periodic_tx_rx_sampling_time;
-	uint16_t coex_quota;
-	uint16_t wlan_quota;
+	u8 pta_mode;
+	u8 request_signal_active_level;
+	u8 priority_signal_active_level;
+	u8 freq_signal_active_level;
+	u8 grant_signal_active_level;
+	u8 coex_type;
+	u8 default_grant_state;
+	u8 simultaneous_rx_accesses;
+	u8 priority_sampling_time;
+	u8 tx_rx_sampling_time;
+	u8 freq_sampling_time;
+	u8 grant_valid_time;
+	u8 fem_control_time;
+	u8 first_slot_time;
+	u16 periodic_tx_rx_sampling_time;
+	u16 coex_quota;
+	u16 wlan_quota;
 } __packed;
 
 struct hif_cnf_pta_settings {
-	uint32_t status;
+	u32 status;
 } __packed;
 
 enum hif_pta_priority {
@@ -414,11 +414,11 @@ enum hif_pta_priority {
 };
 
 struct hif_req_pta_priority {
-	uint32_t priority;
+	u32 priority;
 } __packed;
 
 struct hif_cnf_pta_priority {
-	uint32_t status;
+	u32 status;
 } __packed;
 
 enum hif_pta_state {
@@ -427,11 +427,11 @@ enum hif_pta_state {
 };
 
 struct hif_req_pta_state {
-	uint32_t pta_state;
+	u32 pta_state;
 } __packed;
 
 struct hif_cnf_pta_state {
-	uint32_t status;
+	u32 status;
 } __packed;
 
 #endif
diff --git a/drivers/staging/wfx/hif_api_mib.h b/drivers/staging/wfx/hif_api_mib.h
index af657555f894..94b789ceb4ff 100644
--- a/drivers/staging/wfx/hif_api_mib.h
+++ b/drivers/staging/wfx/hif_api_mib.h
@@ -72,23 +72,23 @@ enum hif_op_power_mode {
 };
 
 struct hif_mib_gl_operational_power_mode {
-	uint8_t    power_mode:4;
-	uint8_t    reserved1:3;
-	uint8_t    wup_ind_activation:1;
-	uint8_t    reserved2[3];
+	u8    power_mode:4;
+	u8    reserved1:3;
+	u8    wup_ind_activation:1;
+	u8    reserved2[3];
 } __packed;
 
 struct hif_mib_gl_block_ack_info {
-	uint8_t    rx_buffer_size;
-	uint8_t    rx_max_num_agreements;
-	uint8_t    tx_buffer_size;
-	uint8_t    tx_max_num_agreements;
+	u8    rx_buffer_size;
+	u8    rx_max_num_agreements;
+	u8    tx_buffer_size;
+	u8    tx_max_num_agreements;
 } __packed;
 
 struct hif_mib_gl_set_multi_msg {
-	uint8_t    enable_multi_tx_conf:1;
-	uint8_t    reserved1:7;
-	uint8_t    reserved2[3];
+	u8    enable_multi_tx_conf:1;
+	u8    reserved1:7;
+	u8    reserved2[3];
 } __packed;
 
 enum hif_cca_thr_mode {
@@ -97,8 +97,8 @@ enum hif_cca_thr_mode {
 };
 
 struct hif_mib_gl_cca_config {
-	uint8_t  cca_thr_mode;
-	uint8_t  reserved[3];
+	u8  cca_thr_mode;
+	u8  reserved[3];
 } __packed;
 
 #define MAX_NUMBER_DATA_FILTERS             0xA
@@ -114,9 +114,9 @@ struct hif_mib_gl_cca_config {
 #define MAX_NUMBER_NS_CONDITIONS            0x2
 
 struct hif_mib_ethertype_data_frame_condition {
-	uint8_t    condition_idx;
-	uint8_t    reserved;
-	uint16_t   ether_type;
+	u8    condition_idx;
+	u8    reserved;
+	u16   ether_type;
 } __packed;
 
 enum hif_udp_tcp_protocol {
@@ -132,22 +132,22 @@ enum hif_which_port {
 };
 
 struct hif_mib_ports_data_frame_condition {
-	uint8_t    condition_idx;
-	uint8_t    protocol;
-	uint8_t    which_port;
-	uint8_t    reserved1;
-	uint16_t   port_number;
-	uint8_t    reserved2[2];
+	u8    condition_idx;
+	u8    protocol;
+	u8    which_port;
+	u8    reserved1;
+	u16   port_number;
+	u8    reserved2[2];
 } __packed;
 
 #define HIF_API_MAGIC_PATTERN_SIZE                 32
 
 struct hif_mib_magic_data_frame_condition {
-	uint8_t    condition_idx;
-	uint8_t    offset;
-	uint8_t    magic_pattern_length;
-	uint8_t    reserved;
-	uint8_t    magic_pattern[HIF_API_MAGIC_PATTERN_SIZE];
+	u8    condition_idx;
+	u8    offset;
+	u8    magic_pattern_length;
+	u8    reserved;
+	u8    magic_pattern[HIF_API_MAGIC_PATTERN_SIZE];
 } __packed;
 
 enum hif_mac_addr_type {
@@ -157,9 +157,9 @@ enum hif_mac_addr_type {
 };
 
 struct hif_mib_mac_addr_data_frame_condition {
-	uint8_t    condition_idx;
-	uint8_t    address_type;
-	uint8_t    mac_address[ETH_ALEN];
+	u8    condition_idx;
+	u8    address_type;
+	u8    mac_address[ETH_ALEN];
 } __packed;
 
 enum hif_ip_addr_mode {
@@ -168,53 +168,53 @@ enum hif_ip_addr_mode {
 };
 
 struct hif_mib_ipv4_addr_data_frame_condition {
-	uint8_t    condition_idx;
-	uint8_t    address_mode;
-	uint8_t    reserved[2];
-	uint8_t    i_pv4_address[HIF_API_IPV4_ADDRESS_SIZE];
+	u8    condition_idx;
+	u8    address_mode;
+	u8    reserved[2];
+	u8    i_pv4_address[HIF_API_IPV4_ADDRESS_SIZE];
 } __packed;
 
 struct hif_mib_ipv6_addr_data_frame_condition {
-	uint8_t    condition_idx;
-	uint8_t    address_mode;
-	uint8_t    reserved[2];
-	uint8_t    i_pv6_address[HIF_API_IPV6_ADDRESS_SIZE];
+	u8    condition_idx;
+	u8    address_mode;
+	u8    reserved[2];
+	u8    i_pv6_address[HIF_API_IPV6_ADDRESS_SIZE];
 } __packed;
 
 union hif_addr_type {
-	uint8_t value;
+	u8 value;
 	struct {
-		uint8_t    type_unicast:1;
-		uint8_t    type_multicast:1;
-		uint8_t    type_broadcast:1;
-		uint8_t    reserved:5;
+		u8    type_unicast:1;
+		u8    type_multicast:1;
+		u8    type_broadcast:1;
+		u8    reserved:5;
 	} bits;
 };
 
 struct hif_mib_uc_mc_bc_data_frame_condition {
-	uint8_t    condition_idx;
+	u8    condition_idx;
 	union hif_addr_type param;
-	uint8_t    reserved[2];
+	u8    reserved[2];
 } __packed;
 
 struct hif_mib_config_data_filter {
-	uint8_t    filter_idx;
-	uint8_t    enable;
-	uint8_t    reserved1[2];
-	uint8_t    eth_type_cond;
-	uint8_t    port_cond;
-	uint8_t    magic_cond;
-	uint8_t    mac_cond;
-	uint8_t    ipv4_cond;
-	uint8_t    ipv6_cond;
-	uint8_t    uc_mc_bc_cond;
-	uint8_t    reserved2;
+	u8    filter_idx;
+	u8    enable;
+	u8    reserved1[2];
+	u8    eth_type_cond;
+	u8    port_cond;
+	u8    magic_cond;
+	u8    mac_cond;
+	u8    ipv4_cond;
+	u8    ipv6_cond;
+	u8    uc_mc_bc_cond;
+	u8    reserved2;
 } __packed;
 
 struct hif_mib_set_data_filtering {
-	uint8_t    default_filter;
-	uint8_t    enable;
-	uint8_t    reserved[2];
+	u8    default_filter;
+	u8    enable;
+	u8    reserved[2];
 } __packed;
 
 enum hif_arp_ns_frame_treatment {
@@ -224,45 +224,45 @@ enum hif_arp_ns_frame_treatment {
 };
 
 struct hif_mib_arp_ip_addr_table {
-	uint8_t    condition_idx;
-	uint8_t    arp_enable;
-	uint8_t    reserved[2];
-	uint8_t    ipv4_address[HIF_API_IPV4_ADDRESS_SIZE];
+	u8    condition_idx;
+	u8    arp_enable;
+	u8    reserved[2];
+	u8    ipv4_address[HIF_API_IPV4_ADDRESS_SIZE];
 } __packed;
 
 struct hif_mib_ns_ip_addr_table {
-	uint8_t    condition_idx;
-	uint8_t    ns_enable;
-	uint8_t    reserved[2];
-	uint8_t    ipv6_address[HIF_API_IPV6_ADDRESS_SIZE];
+	u8    condition_idx;
+	u8    ns_enable;
+	u8    reserved[2];
+	u8    ipv6_address[HIF_API_IPV6_ADDRESS_SIZE];
 } __packed;
 
 struct hif_mib_rx_filter {
-	uint8_t    reserved1:1;
-	uint8_t    bssid_filter:1;
-	uint8_t    reserved2:1;
-	uint8_t    fwd_probe_req:1;
-	uint8_t    keep_alive_filter:1;
-	uint8_t    reserved3:3;
-	uint8_t    reserved4[3];
+	u8    reserved1:1;
+	u8    bssid_filter:1;
+	u8    reserved2:1;
+	u8    fwd_probe_req:1;
+	u8    keep_alive_filter:1;
+	u8    reserved3:3;
+	u8    reserved4[3];
 } __packed;
 
 #define HIF_API_OUI_SIZE                                3
 #define HIF_API_MATCH_DATA_SIZE                         3
 
 struct hif_ie_table_entry {
-	uint8_t    ie_id;
-	uint8_t    has_changed:1;
-	uint8_t    no_longer:1;
-	uint8_t    has_appeared:1;
-	uint8_t    reserved:1;
-	uint8_t    num_match_data:4;
-	uint8_t    oui[HIF_API_OUI_SIZE];
-	uint8_t    match_data[HIF_API_MATCH_DATA_SIZE];
+	u8    ie_id;
+	u8    has_changed:1;
+	u8    no_longer:1;
+	u8    has_appeared:1;
+	u8    reserved:1;
+	u8    num_match_data:4;
+	u8    oui[HIF_API_OUI_SIZE];
+	u8    match_data[HIF_API_MATCH_DATA_SIZE];
 } __packed;
 
 struct hif_mib_bcn_filter_table {
-	uint32_t   num_of_info_elmts;
+	u32   num_of_info_elmts;
 	struct hif_ie_table_entry ie_table[];
 } __packed;
 
@@ -273,126 +273,126 @@ enum hif_beacon_filter {
 };
 
 struct hif_mib_bcn_filter_enable {
-	uint32_t   enable;
-	uint32_t   bcn_count;
+	u32   enable;
+	u32   bcn_count;
 } __packed;
 
 struct hif_mib_group_seq_counter {
-	uint32_t   bits4716;
-	uint16_t   bits1500;
-	uint16_t   reserved;
+	u32   bits4716;
+	u16   bits1500;
+	u16   reserved;
 } __packed;
 
 struct hif_mib_tsf_counter {
-	uint32_t   tsf_counterlo;
-	uint32_t   tsf_counterhi;
+	u32   tsf_counterlo;
+	u32   tsf_counterhi;
 } __packed;
 
 struct hif_mib_stats_table {
-	int16_t    latest_snr;
-	uint8_t    latest_rcpi;
-	int8_t     latest_rssi;
+	s16    latest_snr;
+	u8    latest_rcpi;
+	s8     latest_rssi;
 } __packed;
 
 struct hif_mib_extended_count_table {
-	uint32_t   count_plcp_errors;
-	uint32_t   count_fcs_errors;
-	uint32_t   count_tx_packets;
-	uint32_t   count_rx_packets;
-	uint32_t   count_rx_packet_errors;
-	uint32_t   count_rx_decryption_failures;
-	uint32_t   count_rx_mic_failures;
-	uint32_t   count_rx_no_key_failures;
-	uint32_t   count_tx_multicast_frames;
-	uint32_t   count_tx_frames_success;
-	uint32_t   count_tx_frame_failures;
-	uint32_t   count_tx_frames_retried;
-	uint32_t   count_tx_frames_multi_retried;
-	uint32_t   count_rx_frame_duplicates;
-	uint32_t   count_rts_success;
-	uint32_t   count_rts_failures;
-	uint32_t   count_ack_failures;
-	uint32_t   count_rx_multicast_frames;
-	uint32_t   count_rx_frames_success;
-	uint32_t   count_rx_cmacicv_errors;
-	uint32_t   count_rx_cmac_replays;
-	uint32_t   count_rx_mgmt_ccmp_replays;
-	uint32_t   count_rx_bipmic_errors;
-	uint32_t   count_rx_beacon;
-	uint32_t   count_miss_beacon;
-	uint32_t   reserved[15];
+	u32   count_plcp_errors;
+	u32   count_fcs_errors;
+	u32   count_tx_packets;
+	u32   count_rx_packets;
+	u32   count_rx_packet_errors;
+	u32   count_rx_decryption_failures;
+	u32   count_rx_mic_failures;
+	u32   count_rx_no_key_failures;
+	u32   count_tx_multicast_frames;
+	u32   count_tx_frames_success;
+	u32   count_tx_frame_failures;
+	u32   count_tx_frames_retried;
+	u32   count_tx_frames_multi_retried;
+	u32   count_rx_frame_duplicates;
+	u32   count_rts_success;
+	u32   count_rts_failures;
+	u32   count_ack_failures;
+	u32   count_rx_multicast_frames;
+	u32   count_rx_frames_success;
+	u32   count_rx_cmacicv_errors;
+	u32   count_rx_cmac_replays;
+	u32   count_rx_mgmt_ccmp_replays;
+	u32   count_rx_bipmic_errors;
+	u32   count_rx_beacon;
+	u32   count_miss_beacon;
+	u32   reserved[15];
 } __packed;
 
 struct hif_mib_count_table {
-	uint32_t   count_plcp_errors;
-	uint32_t   count_fcs_errors;
-	uint32_t   count_tx_packets;
-	uint32_t   count_rx_packets;
-	uint32_t   count_rx_packet_errors;
-	uint32_t   count_rx_decryption_failures;
-	uint32_t   count_rx_mic_failures;
-	uint32_t   count_rx_no_key_failures;
-	uint32_t   count_tx_multicast_frames;
-	uint32_t   count_tx_frames_success;
-	uint32_t   count_tx_frame_failures;
-	uint32_t   count_tx_frames_retried;
-	uint32_t   count_tx_frames_multi_retried;
-	uint32_t   count_rx_frame_duplicates;
-	uint32_t   count_rts_success;
-	uint32_t   count_rts_failures;
-	uint32_t   count_ack_failures;
-	uint32_t   count_rx_multicast_frames;
-	uint32_t   count_rx_frames_success;
-	uint32_t   count_rx_cmacicv_errors;
-	uint32_t   count_rx_cmac_replays;
-	uint32_t   count_rx_mgmt_ccmp_replays;
-	uint32_t   count_rx_bipmic_errors;
+	u32   count_plcp_errors;
+	u32   count_fcs_errors;
+	u32   count_tx_packets;
+	u32   count_rx_packets;
+	u32   count_rx_packet_errors;
+	u32   count_rx_decryption_failures;
+	u32   count_rx_mic_failures;
+	u32   count_rx_no_key_failures;
+	u32   count_tx_multicast_frames;
+	u32   count_tx_frames_success;
+	u32   count_tx_frame_failures;
+	u32   count_tx_frames_retried;
+	u32   count_tx_frames_multi_retried;
+	u32   count_rx_frame_duplicates;
+	u32   count_rts_success;
+	u32   count_rts_failures;
+	u32   count_ack_failures;
+	u32   count_rx_multicast_frames;
+	u32   count_rx_frames_success;
+	u32   count_rx_cmacicv_errors;
+	u32   count_rx_cmac_replays;
+	u32   count_rx_mgmt_ccmp_replays;
+	u32   count_rx_bipmic_errors;
 } __packed;
 
 struct hif_mib_max_tx_power_level {
-	int32_t       max_tx_power_level_rf_port1;
-	int32_t       max_tx_power_level_rf_port2;
+	s32       max_tx_power_level_rf_port1;
+	s32       max_tx_power_level_rf_port2;
 } __packed;
 
 struct hif_mib_beacon_stats {
-	int32_t     latest_tbtt_diff;
-	uint32_t    reserved[4];
+	s32     latest_tbtt_diff;
+	u32    reserved[4];
 } __packed;
 
 struct hif_mib_mac_address {
-	uint8_t    mac_addr[ETH_ALEN];
-	uint16_t   reserved;
+	u8    mac_addr[ETH_ALEN];
+	u16   reserved;
 } __packed;
 
 struct hif_mib_dot11_max_transmit_msdu_lifetime {
-	uint32_t   max_life_time;
+	u32   max_life_time;
 } __packed;
 
 struct hif_mib_dot11_max_receive_lifetime {
-	uint32_t   max_life_time;
+	u32   max_life_time;
 } __packed;
 
 struct hif_mib_wep_default_key_id {
-	uint8_t    wep_default_key_id;
-	uint8_t    reserved[3];
+	u8    wep_default_key_id;
+	u8    reserved[3];
 } __packed;
 
 struct hif_mib_dot11_rts_threshold {
-	uint32_t   threshold;
+	u32   threshold;
 } __packed;
 
 struct hif_mib_slot_time {
-	uint32_t   slot_time;
+	u32   slot_time;
 } __packed;
 
 struct hif_mib_current_tx_power_level {
-	int32_t   power_level;
+	s32   power_level;
 } __packed;
 
 struct hif_mib_non_erp_protection {
-	uint8_t   use_cts_to_self:1;
-	uint8_t   reserved1:7;
-	uint8_t   reserved2[3];
+	u8   use_cts_to_self:1;
+	u8   reserved1:7;
+	u8   reserved2[3];
 } __packed;
 
 enum hif_tx_mode {
@@ -414,45 +414,45 @@ enum hif_tmplt {
 #define HIF_API_MAX_TEMPLATE_FRAME_SIZE                              700
 
 struct hif_mib_template_frame {
-	uint8_t    frame_type;
-	uint8_t    init_rate:7;
-	uint8_t    mode:1;
-	uint16_t   frame_length;
-	uint8_t    frame[HIF_API_MAX_TEMPLATE_FRAME_SIZE];
+	u8    frame_type;
+	u8    init_rate:7;
+	u8    mode:1;
+	u16   frame_length;
+	u8    frame[HIF_API_MAX_TEMPLATE_FRAME_SIZE];
 } __packed;
 
 struct hif_mib_beacon_wake_up_period {
-	uint8_t    wakeup_period_min;
-	uint8_t    receive_dtim:1;
-	uint8_t    reserved1:7;
-	uint8_t    wakeup_period_max;
-	uint8_t    reserved2;
+	u8    wakeup_period_min;
+	u8    receive_dtim:1;
+	u8    reserved1:7;
+	u8    wakeup_period_max;
+	u8    reserved2;
 } __packed;
 
 struct hif_mib_rcpi_rssi_threshold {
-	uint8_t    detection:1;
-	uint8_t    rcpi_rssi:1;
-	uint8_t    upperthresh:1;
-	uint8_t    lowerthresh:1;
-	uint8_t    reserved:4;
-	uint8_t    lower_threshold;
-	uint8_t    upper_threshold;
-	uint8_t    rolling_average_count;
+	u8    detection:1;
+	u8    rcpi_rssi:1;
+	u8    upperthresh:1;
+	u8    lowerthresh:1;
+	u8    reserved:4;
+	u8    lower_threshold;
+	u8    upper_threshold;
+	u8    rolling_average_count;
 } __packed;
 
 #define DEFAULT_BA_MAX_RX_BUFFER_SIZE 16
 
 struct hif_mib_block_ack_policy {
-	uint8_t    block_ack_tx_tid_policy;
-	uint8_t    reserved1;
-	uint8_t    block_ack_rx_tid_policy;
-	uint8_t    block_ack_rx_max_buffer_size;
+	u8    block_ack_tx_tid_policy;
+	u8    reserved1;
+	u8    block_ack_rx_tid_policy;
+	u8    block_ack_rx_max_buffer_size;
 } __packed;
 
 struct hif_mib_override_int_rate {
-	uint8_t    internal_tx_rate;
-	uint8_t    non_erp_internal_tx_rate;
-	uint8_t    reserved[2];
+	u8    internal_tx_rate;
+	u8    non_erp_internal_tx_rate;
+	u8    reserved[2];
 } __packed;
 
 enum hif_mpdu_start_spacing {
@@ -467,92 +467,91 @@ enum hif_mpdu_start_spacing {
 };
 
 struct hif_mib_set_association_mode {
-	uint8_t    preambtype_use:1;
-	uint8_t    mode:1;
-	uint8_t    rateset:1;
-	uint8_t    spacing:1;
-	uint8_t    reserved:4;
-	uint8_t    preamble_type;
-	uint8_t    mixed_or_greenfield_type;
-	uint8_t    mpdu_start_spacing;
-	uint32_t   basic_rate_set;
+	u8    preambtype_use:1;
+	u8    mode:1;
+	u8    rateset:1;
+	u8    spacing:1;
+	u8    reserved:4;
+	u8    preamble_type;
+	u8    mixed_or_greenfield_type;
+	u8    mpdu_start_spacing;
+	u32   basic_rate_set;
 } __packed;
 
 struct hif_mib_set_uapsd_information {
-	uint8_t    trig_bckgrnd:1;
-	uint8_t    trig_be:1;
-	uint8_t    trig_video:1;
-	uint8_t    trig_voice:1;
-	uint8_t    reserved1:4;
-	uint8_t    deliv_bckgrnd:1;
-	uint8_t    deliv_be:1;
-	uint8_t    deliv_video:1;
-	uint8_t    deliv_voice:1;
-	uint8_t    reserved2:4;
-	uint16_t   min_auto_trigger_interval;
-	uint16_t   max_auto_trigger_interval;
-	uint16_t   auto_trigger_step;
+	u8    trig_bckgrnd:1;
+	u8    trig_be:1;
+	u8    trig_video:1;
+	u8    trig_voice:1;
+	u8    reserved1:4;
+	u8    deliv_bckgrnd:1;
+	u8    deliv_be:1;
+	u8    deliv_video:1;
+	u8    deliv_voice:1;
+	u8    reserved2:4;
+	u16   min_auto_trigger_interval;
+	u16   max_auto_trigger_interval;
+	u16   auto_trigger_step;
 } __packed;
 
 struct hif_mib_tx_rate_retry_policy {
-	uint8_t    policy_index;
-	uint8_t    short_retry_count;
-	uint8_t    long_retry_count;
-	uint8_t    first_rate_sel:2;
-	uint8_t    terminate:1;
-	uint8_t    count_init:1;
-	uint8_t    reserved1:4;
-	uint8_t    rate_recovery_count;
-	uint8_t    reserved2[3];
-	uint8_t    rates[12];
+	u8    policy_index;
+	u8    short_retry_count;
+	u8    long_retry_count;
+	u8    first_rate_sel:2;
+	u8    terminate:1;
+	u8    count_init:1;
+	u8    reserved1:4;
+	u8    rate_recovery_count;
+	u8    reserved2[3];
+	u8    rates[12];
 } __packed;
 
 #define HIF_MIB_NUM_TX_RATE_RETRY_POLICIES    15
 
 struct hif_mib_set_tx_rate_retry_policy {
-	uint8_t    num_tx_rate_policies;
-	uint8_t    reserved[3];
+	u8    num_tx_rate_policies;
+	u8    reserved[3];
 	struct hif_mib_tx_rate_retry_policy tx_rate_retry_policy[];
 } __packed;
 
 struct hif_mib_protected_mgmt_policy {
-	uint8_t   pmf_enable:1;
-	uint8_t   unpmf_allowed:1;
-	uint8_t   host_enc_auth_frames:1;
-	uint8_t   reserved1:5;
-	uint8_t   reserved2[3];
+	u8   pmf_enable:1;
+	u8   unpmf_allowed:1;
+	u8   host_enc_auth_frames:1;
+	u8   reserved1:5;
+	u8   reserved2[3];
 } __packed;
 
 struct hif_mib_set_ht_protection {
-	uint8_t   dual_cts_prot:1;
-	uint8_t   reserved1:7;
-	uint8_t   reserved2[3];
+	u8   dual_cts_prot:1;
+	u8   reserved1:7;
+	u8   reserved2[3];
 } __packed;
 
 struct hif_mib_keep_alive_period {
-	uint16_t   keep_alive_period;
-	uint8_t    reserved[2];
+	u16   keep_alive_period;
+	u8    reserved[2];
 } __packed;
 
 struct hif_mib_arp_keep_alive_period {
-	uint16_t   arp_keep_alive_period;
-	uint8_t    encr_type;
-	uint8_t    reserved;
-	uint8_t    sender_ipv4_address[HIF_API_IPV4_ADDRESS_SIZE];
-	uint8_t    target_ipv4_address[HIF_API_IPV4_ADDRESS_SIZE];
+	u16   arp_keep_alive_period;
+	u8    encr_type;
+	u8    reserved;
+	u8    sender_ipv4_address[HIF_API_IPV4_ADDRESS_SIZE];
+	u8    target_ipv4_address[HIF_API_IPV4_ADDRESS_SIZE];
 } __packed;
 
 struct hif_mib_inactivity_timer {
-	uint8_t    min_active_time;
-	uint8_t    max_active_time;
-	uint16_t   reserved;
+	u8    min_active_time;
+	u8    max_active_time;
+	u16   reserved;
 } __packed;
 
 struct hif_mib_interface_protection {
-	uint8_t   use_cts_prot:1;
-	uint8_t   reserved1:7;
-	uint8_t   reserved2[3];
+	u8   use_cts_prot:1;
+	u8   reserved1:7;
+	u8   reserved2[3];
 } __packed;
 
-
 #endif
diff --git a/drivers/staging/wfx/hif_tx.c b/drivers/staging/wfx/hif_tx.c
index 2d40225a0fce..2f5dadff0660 100644
--- a/drivers/staging/wfx/hif_tx.c
+++ b/drivers/staging/wfx/hif_tx.c
@@ -452,7 +452,8 @@ int hif_sl_config(struct wfx_dev *wdev, const unsigned long *bitmap)
 	return ret;
 }
 
-int hif_sl_set_mac_key(struct wfx_dev *wdev, const uint8_t *slk_key, int destination)
+int hif_sl_set_mac_key(struct wfx_dev *wdev, const u8 *slk_key,
+		       int destination)
 {
 	int ret;
 	struct hif_msg *hif;
diff --git a/drivers/staging/wfx/hif_tx.h b/drivers/staging/wfx/hif_tx.h
index 6f2ea2f3a77d..f61ae7b0d41c 100644
--- a/drivers/staging/wfx/hif_tx.h
+++ b/drivers/staging/wfx/hif_tx.h
@@ -18,7 +18,7 @@ struct wfx_vif;
 struct wfx_scan_params {
 	struct hif_req_start_scan scan_req;
 	struct hif_ssid_def *ssids;
-	uint8_t *ch;
+	u8 *ch;
 };
 
 struct wfx_hif_cmd {
@@ -59,9 +59,10 @@ int hif_beacon_transmit(struct wfx_vif *wvif, bool enable);
 int hif_map_link(struct wfx_vif *wvif, u8 *mac_addr, int flags, int sta_id);
 int hif_update_ie(struct wfx_vif *wvif, const struct hif_ie_flags *target_frame,
 		  const u8 *ies, size_t ies_len);
-int hif_sl_set_mac_key(struct wfx_dev *wdev, const uint8_t *slk_key, int destination);
+int hif_sl_set_mac_key(struct wfx_dev *wdev, const u8 *slk_key,
+		       int destination);
 int hif_sl_config(struct wfx_dev *wdev, const unsigned long *bitmap);
 int hif_sl_send_pub_keys(struct wfx_dev *wdev,
-			 const uint8_t *pubkey, const uint8_t *pubkey_hmac);
+			 const u8 *pubkey, const u8 *pubkey_hmac);
 
 #endif
diff --git a/drivers/staging/wfx/hif_tx_mib.h b/drivers/staging/wfx/hif_tx_mib.h
index 3339ad95f732..d1cabd697205 100644
--- a/drivers/staging/wfx/hif_tx_mib.h
+++ b/drivers/staging/wfx/hif_tx_mib.h
@@ -145,7 +145,7 @@ static inline int hif_set_mfp(struct wfx_vif *wvif, bool capable, bool required)
 	}
 	if (!required)
 		val.unpmf_allowed = 1;
-	cpu_to_le32s((uint32_t *) &val);
+	cpu_to_le32s((u32 *) &val);
 	return hif_write_mib(wvif->wdev, wvif->id,
 			     HIF_MIB_ID_PROTECTED_MGMT_POLICY,
 			     &val, sizeof(val));
diff --git a/drivers/staging/wfx/key.c b/drivers/staging/wfx/key.c
index 6d03abec20e4..caea6d959b0e 100644
--- a/drivers/staging/wfx/key.c
+++ b/drivers/staging/wfx/key.c
@@ -31,7 +31,7 @@ static void wfx_free_key(struct wfx_dev *wdev, int idx)
 	wdev->key_map &= ~BIT(idx);
 }
 
-static uint8_t fill_wep_pair(struct hif_wep_pairwise_key *msg,
+static u8 fill_wep_pair(struct hif_wep_pairwise_key *msg,
 			     struct ieee80211_key_conf *key, u8 *peer_addr)
 {
 	WARN(key->keylen > sizeof(msg->key_data), "inconsistent data");
@@ -41,7 +41,7 @@ static uint8_t fill_wep_pair(struct hif_wep_pairwise_key *msg,
 	return HIF_KEY_TYPE_WEP_PAIRWISE;
 }
 
-static uint8_t fill_wep_group(struct hif_wep_group_key *msg,
+static u8 fill_wep_group(struct hif_wep_group_key *msg,
 			      struct ieee80211_key_conf *key)
 {
 	WARN(key->keylen > sizeof(msg->key_data), "inconsistent data");
@@ -51,10 +51,10 @@ static uint8_t fill_wep_group(struct hif_wep_group_key *msg,
 	return HIF_KEY_TYPE_WEP_DEFAULT;
 }
 
-static uint8_t fill_tkip_pair(struct hif_tkip_pairwise_key *msg,
+static u8 fill_tkip_pair(struct hif_tkip_pairwise_key *msg,
 			      struct ieee80211_key_conf *key, u8 *peer_addr)
 {
-	uint8_t *keybuf = key->key;
+	u8 *keybuf = key->key;
 
 	WARN(key->keylen != sizeof(msg->tkip_key_data)
 			    + sizeof(msg->tx_mic_key)
@@ -68,18 +68,20 @@ static uint8_t fill_tkip_pair(struct hif_tkip_pairwise_key *msg,
 	return HIF_KEY_TYPE_TKIP_PAIRWISE;
 }
 
-static uint8_t fill_tkip_group(struct hif_tkip_group_key *msg,
+static u8 fill_tkip_group(struct hif_tkip_group_key *msg,
 			       struct ieee80211_key_conf *key,
 			       struct ieee80211_key_seq *seq,
 			       enum nl80211_iftype iftype)
 {
-	uint8_t *keybuf = key->key;
+	u8 *keybuf = key->key;
 
 	WARN(key->keylen != sizeof(msg->tkip_key_data)
 			    + 2 * sizeof(msg->rx_mic_key), "inconsistent data");
 	msg->key_id = key->keyidx;
-	memcpy(msg->rx_sequence_counter, &seq->tkip.iv16, sizeof(seq->tkip.iv16));
-	memcpy(msg->rx_sequence_counter + sizeof(uint16_t), &seq->tkip.iv32, sizeof(seq->tkip.iv32));
+	memcpy(msg->rx_sequence_counter,
+	       &seq->tkip.iv16, sizeof(seq->tkip.iv16));
+	memcpy(msg->rx_sequence_counter + sizeof(u16),
+	       &seq->tkip.iv32, sizeof(seq->tkip.iv32));
 	memcpy(msg->tkip_key_data, keybuf, sizeof(msg->tkip_key_data));
 	keybuf += sizeof(msg->tkip_key_data);
 	if (iftype == NL80211_IFTYPE_AP)
@@ -91,7 +93,7 @@ static uint8_t fill_tkip_group(struct hif_tkip_group_key *msg,
 	return HIF_KEY_TYPE_TKIP_GROUP;
 }
 
-static uint8_t fill_ccmp_pair(struct hif_aes_pairwise_key *msg,
+static u8 fill_ccmp_pair(struct hif_aes_pairwise_key *msg,
 			      struct ieee80211_key_conf *key, u8 *peer_addr)
 {
 	WARN(key->keylen != sizeof(msg->aes_key_data), "inconsistent data");
@@ -100,7 +102,7 @@ static uint8_t fill_ccmp_pair(struct hif_aes_pairwise_key *msg,
 	return HIF_KEY_TYPE_AES_PAIRWISE;
 }
 
-static uint8_t fill_ccmp_group(struct hif_aes_group_key *msg,
+static u8 fill_ccmp_group(struct hif_aes_group_key *msg,
 			       struct ieee80211_key_conf *key,
 			       struct ieee80211_key_seq *seq)
 {
@@ -112,10 +114,10 @@ static uint8_t fill_ccmp_group(struct hif_aes_group_key *msg,
 	return HIF_KEY_TYPE_AES_GROUP;
 }
 
-static uint8_t fill_sms4_pair(struct hif_wapi_pairwise_key *msg,
+static u8 fill_sms4_pair(struct hif_wapi_pairwise_key *msg,
 			      struct ieee80211_key_conf *key, u8 *peer_addr)
 {
-	uint8_t *keybuf = key->key;
+	u8 *keybuf = key->key;
 
 	WARN(key->keylen != sizeof(msg->wapi_key_data)
 			    + sizeof(msg->mic_key_data), "inconsistent data");
@@ -127,10 +129,10 @@ static uint8_t fill_sms4_pair(struct hif_wapi_pairwise_key *msg,
 	return HIF_KEY_TYPE_WAPI_PAIRWISE;
 }
 
-static uint8_t fill_sms4_group(struct hif_wapi_group_key *msg,
+static u8 fill_sms4_group(struct hif_wapi_group_key *msg,
 			       struct ieee80211_key_conf *key)
 {
-	uint8_t *keybuf = key->key;
+	u8 *keybuf = key->key;
 
 	WARN(key->keylen != sizeof(msg->wapi_key_data)
 			    + sizeof(msg->mic_key_data), "inconsistent data");
@@ -141,7 +143,7 @@ static uint8_t fill_sms4_group(struct hif_wapi_group_key *msg,
 	return HIF_KEY_TYPE_WAPI_GROUP;
 }
 
-static uint8_t fill_aes_cmac_group(struct hif_igtk_group_key *msg,
+static u8 fill_aes_cmac_group(struct hif_igtk_group_key *msg,
 				   struct ieee80211_key_conf *key,
 				   struct ieee80211_key_seq *seq)
 {
diff --git a/drivers/staging/wfx/secure_link.h b/drivers/staging/wfx/secure_link.h
index 376d7bc4c0c4..666b26e5308d 100644
--- a/drivers/staging/wfx/secure_link.h
+++ b/drivers/staging/wfx/secure_link.h
@@ -25,12 +25,14 @@ static inline int wfx_sl_decode(struct wfx_dev *wdev, struct hif_sl_msg *m)
 	return -EIO;
 }
 
-static inline int wfx_sl_encode(struct wfx_dev *wdev, struct hif_msg *input, struct hif_sl_msg *output)
+static inline int wfx_sl_encode(struct wfx_dev *wdev, struct hif_msg *input,
+				struct hif_sl_msg *output)
 {
 	return -EIO;
 }
 
-static inline int wfx_sl_check_pubkey(struct wfx_dev *wdev, uint8_t *ncp_pubkey, uint8_t *ncp_pubmac)
+static inline int wfx_sl_check_pubkey(struct wfx_dev *wdev, u8 *ncp_pubkey,
+				      u8 *ncp_pubmac)
 {
 	return -EIO;
 }
diff --git a/drivers/staging/wfx/sta.c b/drivers/staging/wfx/sta.c
index 2ab5ba9742ad..1cdfa88ffee7 100644
--- a/drivers/staging/wfx/sta.c
+++ b/drivers/staging/wfx/sta.c
@@ -453,7 +453,7 @@ void wfx_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
 
 /* WSM callbacks */
 
-static void wfx_event_report_rssi(struct wfx_vif *wvif, uint8_t raw_rcpi_rssi)
+static void wfx_event_report_rssi(struct wfx_vif *wvif, u8 raw_rcpi_rssi)
 {
 	/* RSSI: signed Q8.0, RCPI: unsigned Q7.1
 	 * RSSI = RCPI / 2 - 110
@@ -590,10 +590,10 @@ done:
 
 static void wfx_set_mfp(struct wfx_vif *wvif, struct cfg80211_bss *bss)
 {
-	const int pairwise_cipher_suite_count_offset = 8 / sizeof(uint16_t);
-	const int pairwise_cipher_suite_size = 4 / sizeof(uint16_t);
-	const int akm_suite_size = 4 / sizeof(uint16_t);
-	const uint16_t *ptr = NULL;
+	const int pairwise_cipher_suite_count_offset = 8 / sizeof(u16);
+	const int pairwise_cipher_suite_size = 4 / sizeof(u16);
+	const int akm_suite_size = 4 / sizeof(u16);
+	const u16 *ptr = NULL;
 	bool mfpc = false;
 	bool mfpr = false;
 
@@ -603,7 +603,8 @@ static void wfx_set_mfp(struct wfx_vif *wvif, struct cfg80211_bss *bss)
 
 	rcu_read_lock();
 	if (bss)
-		ptr = (const uint16_t *) ieee80211_bss_get_ie(bss, WLAN_EID_RSN);
+		ptr = (const u16 *) ieee80211_bss_get_ie(bss,
+							      WLAN_EID_RSN);
 
 	if (ptr) {
 		ptr += pairwise_cipher_suite_count_offset;
diff --git a/drivers/staging/wfx/sta.h b/drivers/staging/wfx/sta.h
index 307ed0196110..57c46bd4e650 100644
--- a/drivers/staging/wfx/sta.h
+++ b/drivers/staging/wfx/sta.h
@@ -26,7 +26,7 @@ enum wfx_state {
 struct wfx_ht_info {
 	struct ieee80211_sta_ht_cap ht_cap;
 	enum nl80211_channel_type channel_type;
-	uint16_t operation_mode;
+	u16 operation_mode;
 };
 
 struct wfx_hif_event {
diff --git a/drivers/staging/wfx/wfx.h b/drivers/staging/wfx/wfx.h
index d678b5a08873..44e580a07c91 100644
--- a/drivers/staging/wfx/wfx.h
+++ b/drivers/staging/wfx/wfx.h
@@ -179,11 +179,11 @@ static inline int wvif_count(struct wfx_dev *wdev)
 	return ret;
 }
 
-static inline void memreverse(uint8_t *src, uint8_t length)
+static inline void memreverse(u8 *src, u8 length)
 {
-	uint8_t *lo = src;
-	uint8_t *hi = src + length - 1;
-	uint8_t swap;
+	u8 *lo = src;
+	u8 *hi = src + length - 1;
+	u8 swap;
 
 	while (lo < hi) {
 		swap = *lo;
@@ -194,7 +194,7 @@ static inline void memreverse(uint8_t *src, uint8_t length)
 
 static inline int memzcmp(void *src, unsigned int size)
 {
-	uint8_t *buf = src;
+	u8 *buf = src;
 
 	if (!size)
 		return 0;