Checkpatch emits CHECK prefer kernel type. Source and header file use
C standard types uintN_t.
Replace C standard types with kernel types. uintN_t -> uN
Signed-off-by: Tobin C. Harding <m...@tobin.cc>
---
drivers/staging/ks7010/ks_hostif.c | 250 +++++++++++++++---------------
drivers/staging/ks7010/ks_hostif.h | 304 ++++++++++++++++++-------------------
2 files changed, 277 insertions(+), 277 deletions(-)
diff --git a/drivers/staging/ks7010/ks_hostif.c
b/drivers/staging/ks7010/ks_hostif.c
index a6c5c53..a354e34e 100644
--- a/drivers/staging/ks7010/ks_hostif.c
+++ b/drivers/staging/ks7010/ks_hostif.c
@@ -379,8 +379,8 @@ void hostif_data_indication(struct ks_wlan_private *priv)
(priv->rxp) + ((priv->rx_size) - 8), 8);
priv->rx_size = priv->rx_size - 8;
if (auth_type > 0 && auth_type < 4) { /*
auth_type check */
- MichaelMICFunction(&michel_mic,
(uint8_t *)priv->wpa.key[auth_type - 1].rx_mic_key, (uint8_t *)priv->rxp,
(int)priv->rx_size, (uint8_t)0, /* priority */
- (uint8_t
*)michel_mic.Result);
+ MichaelMICFunction(&michel_mic, (u8
*)priv->wpa.key[auth_type - 1].rx_mic_key, (u8 *)priv->rxp, (int)priv->rx_size,
(u8)0, /* priority */
+ (u8
*)michel_mic.Result);
}
if (memcmp(michel_mic.Result, RecvMIC, 8)) {
now = jiffies;
@@ -399,7 +399,7 @@ void hostif_data_indication(struct ks_wlan_private *priv)
} else if (mic_failure->failure == 1) {
mic_failure->failure = 2;
mic_failure->counter =
- (uint16_t)((now -
+ (u16)((now -
mic_failure->
last_failure_time)
/ HZ);
@@ -507,10 +507,10 @@ static
void hostif_mib_get_confirm(struct ks_wlan_private *priv)
{
struct net_device *dev = priv->net_dev;
- uint32_t mib_status;
- uint32_t mib_attribute;
- uint16_t mib_val_size;
- uint16_t mib_val_type;
+ u32 mib_status;
+ u32 mib_attribute;
+ u16 mib_val_size;
+ u16 mib_val_type;
DPRINTK(3, "\n");
@@ -587,8 +587,8 @@ void hostif_mib_get_confirm(struct ks_wlan_private *priv)
static
void hostif_mib_set_confirm(struct ks_wlan_private *priv)
{
- uint32_t mib_status; /* +04 MIB Status */
- uint32_t mib_attribute; /* +08 MIB attribute */
+ u32 mib_status; /* +04 MIB Status */
+ u32 mib_attribute; /* +08 MIB attribute */
DPRINTK(3, "\n");
@@ -902,7 +902,7 @@ void hostif_ps_adhoc_set_confirm(struct ks_wlan_private
*priv)
static
void hostif_infrastructure_set_confirm(struct ks_wlan_private *priv)
{
- uint16_t result_code;
+ u16 result_code;
DPRINTK(3, "\n");
result_code = get_WORD(priv);
@@ -1216,37 +1216,37 @@ int hostif_data_request(struct ks_wlan_private *priv,
struct sk_buff *packet)
&& !(priv->wpa.key[1].key_len)
&& !(priv->wpa.key[2].key_len)
&& !(priv->wpa.key[3].key_len)) {
- pp->auth_type = cpu_to_le16((uint16_t)TYPE_AUTH);
/* no encryption */
+ pp->auth_type = cpu_to_le16((u16)TYPE_AUTH); /* no
encryption */
} else {
if (priv->wpa.pairwise_suite == IW_AUTH_CIPHER_TKIP) {
- MichaelMICFunction(&michel_mic, (uint8_t
*)priv->wpa.key[0].tx_mic_key, (uint8_t *)&pp->data[0], (int)packet_len,
(uint8_t)0, /* priority */
- (uint8_t *)michel_mic.
+ MichaelMICFunction(&michel_mic, (u8
*)priv->wpa.key[0].tx_mic_key, (u8 *)&pp->data[0], (int)packet_len, (u8)0, /*
priority */
+ (u8 *)michel_mic.
Result);
memcpy(p, michel_mic.Result, 8);
length += 8;
packet_len += 8;
p += 8;
pp->auth_type =
- cpu_to_le16((uint16_t)TYPE_DATA);
+ cpu_to_le16((u16)TYPE_DATA);
} else if (priv->wpa.pairwise_suite ==
IW_AUTH_CIPHER_CCMP) {
pp->auth_type =
- cpu_to_le16((uint16_t)TYPE_DATA);
+ cpu_to_le16((u16)TYPE_DATA);
}
}
} else {
if (eth_proto == ETHER_PROTOCOL_TYPE_EAP)
- pp->auth_type = cpu_to_le16((uint16_t)TYPE_AUTH);
+ pp->auth_type = cpu_to_le16((u16)TYPE_AUTH);
else
- pp->auth_type = cpu_to_le16((uint16_t)TYPE_DATA);
+ pp->auth_type = cpu_to_le16((u16)TYPE_DATA);
}
/* header value set */
pp->header.size =
- cpu_to_le16((uint16_t)
+ cpu_to_le16((u16)
(sizeof(*pp) - sizeof(pp->header.size) + packet_len));
- pp->header.event = cpu_to_le16((uint16_t)HIF_DATA_REQ);
+ pp->header.event = cpu_to_le16((u16)HIF_DATA_REQ);
/* tx request */
result =
@@ -1290,9 +1290,9 @@ void hostif_mib_get_request(struct ks_wlan_private *priv,
return;
}
pp->header.size =
- cpu_to_le16((uint16_t)(sizeof(*pp) - sizeof(pp->header.size)));
- pp->header.event = cpu_to_le16((uint16_t)HIF_MIB_GET_REQ);
- pp->mib_attribute = cpu_to_le32((uint32_t)mib_attribute);
+ cpu_to_le16((u16)(sizeof(*pp) - sizeof(pp->header.size)));
+ pp->header.event = cpu_to_le16((u16)HIF_MIB_GET_REQ);
+ pp->mib_attribute = cpu_to_le32((u32)mib_attribute);
/* send to device request */
ps_confirm_wait_inc(priv);
@@ -1321,12 +1321,12 @@ void hostif_mib_set_request(struct ks_wlan_private
*priv,
}
pp->header.size =
- cpu_to_le16((uint16_t)
+ cpu_to_le16((u16)
(sizeof(*pp) - sizeof(pp->header.size) + size));
- pp->header.event = cpu_to_le16((uint16_t)HIF_MIB_SET_REQ);
- pp->mib_attribute = cpu_to_le32((uint32_t)mib_attribute);
- pp->mib_value.size = cpu_to_le16((uint16_t)size);
- pp->mib_value.type = cpu_to_le16((uint16_t)type);
+ pp->header.event = cpu_to_le16((u16)HIF_MIB_SET_REQ);
+ pp->mib_attribute = cpu_to_le32((u32)mib_attribute);
+ pp->mib_value.size = cpu_to_le16((u16)size);
+ pp->mib_value.type = cpu_to_le16((u16)type);
memcpy(&pp->mib_value.body, vp, size);
/* send to device request */
@@ -1349,9 +1349,9 @@ void hostif_start_request(struct ks_wlan_private *priv,
unsigned char mode)
return;
}
pp->header.size =
- cpu_to_le16((uint16_t)(sizeof(*pp) - sizeof(pp->header.size)));
- pp->header.event = cpu_to_le16((uint16_t)HIF_START_REQ);
- pp->mode = cpu_to_le16((uint16_t)mode);
+ cpu_to_le16((u16)(sizeof(*pp) - sizeof(pp->header.size)));
+ pp->header.event = cpu_to_le16((u16)HIF_START_REQ);
+ pp->mode = cpu_to_le16((u16)mode);
/* send to device request */
ps_confirm_wait_inc(priv);
@@ -1365,7 +1365,7 @@ static
void hostif_ps_adhoc_set_request(struct ks_wlan_private *priv)
{
struct hostif_ps_adhoc_set_request_t *pp;
- uint16_t capability;
+ u16 capability;
DPRINTK(3, "\n");
@@ -1377,12 +1377,12 @@ void hostif_ps_adhoc_set_request(struct ks_wlan_private
*priv)
}
memset(pp, 0, sizeof(*pp));
pp->header.size =
- cpu_to_le16((uint16_t)(sizeof(*pp) - sizeof(pp->header.size)));
- pp->header.event = cpu_to_le16((uint16_t)HIF_PS_ADH_SET_REQ);
- pp->phy_type = cpu_to_le16((uint16_t)(priv->reg.phy_type));
- pp->cts_mode = cpu_to_le16((uint16_t)(priv->reg.cts_mode));
- pp->scan_type = cpu_to_le16((uint16_t)(priv->reg.scan_type));
- pp->channel = cpu_to_le16((uint16_t)(priv->reg.channel));
+ cpu_to_le16((u16)(sizeof(*pp) - sizeof(pp->header.size)));
+ pp->header.event = cpu_to_le16((u16)HIF_PS_ADH_SET_REQ);
+ pp->phy_type = cpu_to_le16((u16)(priv->reg.phy_type));
+ pp->cts_mode = cpu_to_le16((u16)(priv->reg.cts_mode));
+ pp->scan_type = cpu_to_le16((u16)(priv->reg.scan_type));
+ pp->channel = cpu_to_le16((u16)(priv->reg.channel));
pp->rate_set.size = priv->reg.rate_set.size;
memcpy(&pp->rate_set.body[0], &priv->reg.rate_set.body[0],
priv->reg.rate_set.size);
@@ -1397,7 +1397,7 @@ void hostif_ps_adhoc_set_request(struct ks_wlan_private
*priv)
capability |= BSS_CAP_SHORT_SLOT_TIME; /* ShortSlotTime
support */
capability &= ~(BSS_CAP_DSSS_OFDM); /* DSSS OFDM */
}
- pp->capability = cpu_to_le16((uint16_t)capability);
+ pp->capability = cpu_to_le16((u16)capability);
/* send to device request */
ps_confirm_wait_inc(priv);
@@ -1408,7 +1408,7 @@ static
void hostif_infrastructure_set_request(struct ks_wlan_private *priv)
{
struct hostif_infrastructure_set_request_t *pp;
- uint16_t capability;
+ u16 capability;
DPRINTK(3, "ssid.size=%d\n", priv->reg.ssid.size);
@@ -1419,11 +1419,11 @@ void hostif_infrastructure_set_request(struct
ks_wlan_private *priv)
return;
}
pp->header.size =
- cpu_to_le16((uint16_t)(sizeof(*pp) - sizeof(pp->header.size)));
- pp->header.event = cpu_to_le16((uint16_t)HIF_INFRA_SET_REQ);
- pp->phy_type = cpu_to_le16((uint16_t)(priv->reg.phy_type));
- pp->cts_mode = cpu_to_le16((uint16_t)(priv->reg.cts_mode));
- pp->scan_type = cpu_to_le16((uint16_t)(priv->reg.scan_type));
+ cpu_to_le16((u16)(sizeof(*pp) - sizeof(pp->header.size)));
+ pp->header.event = cpu_to_le16((u16)HIF_INFRA_SET_REQ);
+ pp->phy_type = cpu_to_le16((u16)(priv->reg.phy_type));
+ pp->cts_mode = cpu_to_le16((u16)(priv->reg.cts_mode));
+ pp->scan_type = cpu_to_le16((u16)(priv->reg.scan_type));
pp->rate_set.size = priv->reg.rate_set.size;
memcpy(&pp->rate_set.body[0], &priv->reg.rate_set.body[0],
@@ -1441,10 +1441,10 @@ void hostif_infrastructure_set_request(struct
ks_wlan_private *priv)
capability |= BSS_CAP_SHORT_SLOT_TIME; /* ShortSlotTime
support */
capability &= ~(BSS_CAP_DSSS_OFDM); /* DSSS OFDM not
support */
}
- pp->capability = cpu_to_le16((uint16_t)capability);
+ pp->capability = cpu_to_le16((u16)capability);
pp->beacon_lost_count =
- cpu_to_le16((uint16_t)(priv->reg.beacon_lost_count));
- pp->auth_type = cpu_to_le16((uint16_t)(priv->reg.authenticate_type));
+ cpu_to_le16((u16)(priv->reg.beacon_lost_count));
+ pp->auth_type = cpu_to_le16((u16)(priv->reg.authenticate_type));
pp->channel_list.body[0] = 1;
pp->channel_list.body[1] = 8;
@@ -1474,7 +1474,7 @@ void hostif_infrastructure_set_request(struct
ks_wlan_private *priv)
static void hostif_infrastructure_set2_request(struct ks_wlan_private *priv)
{
struct hostif_infrastructure_set2_request_t *pp;
- uint16_t capability;
+ u16 capability;
DPRINTK(2, "ssid.size=%d\n", priv->reg.ssid.size);
@@ -1485,11 +1485,11 @@ static void hostif_infrastructure_set2_request(struct
ks_wlan_private *priv)
return;
}
pp->header.size =
- cpu_to_le16((uint16_t)(sizeof(*pp) - sizeof(pp->header.size)));
- pp->header.event = cpu_to_le16((uint16_t)HIF_INFRA_SET2_REQ);
- pp->phy_type = cpu_to_le16((uint16_t)(priv->reg.phy_type));
- pp->cts_mode = cpu_to_le16((uint16_t)(priv->reg.cts_mode));
- pp->scan_type = cpu_to_le16((uint16_t)(priv->reg.scan_type));
+ cpu_to_le16((u16)(sizeof(*pp) - sizeof(pp->header.size)));
+ pp->header.event = cpu_to_le16((u16)HIF_INFRA_SET2_REQ);
+ pp->phy_type = cpu_to_le16((u16)(priv->reg.phy_type));
+ pp->cts_mode = cpu_to_le16((u16)(priv->reg.cts_mode));
+ pp->scan_type = cpu_to_le16((u16)(priv->reg.scan_type));
pp->rate_set.size = priv->reg.rate_set.size;
memcpy(&pp->rate_set.body[0], &priv->reg.rate_set.body[0],
@@ -1507,10 +1507,10 @@ static void hostif_infrastructure_set2_request(struct
ks_wlan_private *priv)
capability |= BSS_CAP_SHORT_SLOT_TIME; /* ShortSlotTime
support */
capability &= ~(BSS_CAP_DSSS_OFDM); /* DSSS OFDM not
support */
}
- pp->capability = cpu_to_le16((uint16_t)capability);
+ pp->capability = cpu_to_le16((u16)capability);
pp->beacon_lost_count =
- cpu_to_le16((uint16_t)(priv->reg.beacon_lost_count));
- pp->auth_type = cpu_to_le16((uint16_t)(priv->reg.authenticate_type));
+ cpu_to_le16((u16)(priv->reg.beacon_lost_count));
+ pp->auth_type = cpu_to_le16((u16)(priv->reg.authenticate_type));
pp->channel_list.body[0] = 1;
pp->channel_list.body[1] = 8;
@@ -1543,7 +1543,7 @@ static
void hostif_adhoc_set_request(struct ks_wlan_private *priv)
{
struct hostif_adhoc_set_request_t *pp;
- uint16_t capability;
+ u16 capability;
DPRINTK(3, "\n");
@@ -1555,12 +1555,12 @@ void hostif_adhoc_set_request(struct ks_wlan_private
*priv)
}
memset(pp, 0, sizeof(*pp));
pp->header.size =
- cpu_to_le16((uint16_t)(sizeof(*pp) - sizeof(pp->header.size)));
- pp->header.event = cpu_to_le16((uint16_t)HIF_ADH_SET_REQ);
- pp->phy_type = cpu_to_le16((uint16_t)(priv->reg.phy_type));
- pp->cts_mode = cpu_to_le16((uint16_t)(priv->reg.cts_mode));
- pp->scan_type = cpu_to_le16((uint16_t)(priv->reg.scan_type));
- pp->channel = cpu_to_le16((uint16_t)(priv->reg.channel));
+ cpu_to_le16((u16)(sizeof(*pp) - sizeof(pp->header.size)));
+ pp->header.event = cpu_to_le16((u16)HIF_ADH_SET_REQ);
+ pp->phy_type = cpu_to_le16((u16)(priv->reg.phy_type));
+ pp->cts_mode = cpu_to_le16((u16)(priv->reg.cts_mode));
+ pp->scan_type = cpu_to_le16((u16)(priv->reg.scan_type));
+ pp->channel = cpu_to_le16((u16)(priv->reg.channel));
pp->rate_set.size = priv->reg.rate_set.size;
memcpy(&pp->rate_set.body[0], &priv->reg.rate_set.body[0],
priv->reg.rate_set.size);
@@ -1577,7 +1577,7 @@ void hostif_adhoc_set_request(struct ks_wlan_private
*priv)
capability |= BSS_CAP_SHORT_SLOT_TIME; /* ShortSlotTime
support */
capability &= ~(BSS_CAP_DSSS_OFDM); /* DSSS OFDM not
support */
}
- pp->capability = cpu_to_le16((uint16_t)capability);
+ pp->capability = cpu_to_le16((u16)capability);
/* send to device request */
ps_confirm_wait_inc(priv);
@@ -1588,7 +1588,7 @@ static
void hostif_adhoc_set2_request(struct ks_wlan_private *priv)
{
struct hostif_adhoc_set2_request_t *pp;
- uint16_t capability;
+ u16 capability;
DPRINTK(3, "\n");
@@ -1600,11 +1600,11 @@ void hostif_adhoc_set2_request(struct ks_wlan_private
*priv)
}
memset(pp, 0, sizeof(*pp));
pp->header.size =
- cpu_to_le16((uint16_t)(sizeof(*pp) - sizeof(pp->header.size)));
- pp->header.event = cpu_to_le16((uint16_t)HIF_ADH_SET_REQ);
- pp->phy_type = cpu_to_le16((uint16_t)(priv->reg.phy_type));
- pp->cts_mode = cpu_to_le16((uint16_t)(priv->reg.cts_mode));
- pp->scan_type = cpu_to_le16((uint16_t)(priv->reg.scan_type));
+ cpu_to_le16((u16)(sizeof(*pp) - sizeof(pp->header.size)));
+ pp->header.event = cpu_to_le16((u16)HIF_ADH_SET_REQ);
+ pp->phy_type = cpu_to_le16((u16)(priv->reg.phy_type));
+ pp->cts_mode = cpu_to_le16((u16)(priv->reg.cts_mode));
+ pp->scan_type = cpu_to_le16((u16)(priv->reg.scan_type));
pp->rate_set.size = priv->reg.rate_set.size;
memcpy(&pp->rate_set.body[0], &priv->reg.rate_set.body[0],
priv->reg.rate_set.size);
@@ -1621,7 +1621,7 @@ void hostif_adhoc_set2_request(struct ks_wlan_private
*priv)
capability |= BSS_CAP_SHORT_SLOT_TIME; /* ShortSlotTime
support */
capability &= ~(BSS_CAP_DSSS_OFDM); /* DSSS OFDM not
support */
}
- pp->capability = cpu_to_le16((uint16_t)capability);
+ pp->capability = cpu_to_le16((u16)capability);
pp->channel_list.body[0] = priv->reg.channel;
pp->channel_list.size = 1;
@@ -1646,8 +1646,8 @@ void hostif_stop_request(struct ks_wlan_private *priv)
return;
}
pp->header.size =
- cpu_to_le16((uint16_t)(sizeof(*pp) - sizeof(pp->header.size)));
- pp->header.event = cpu_to_le16((uint16_t)HIF_STOP_REQ);
+ cpu_to_le16((u16)(sizeof(*pp) - sizeof(pp->header.size)));
+ pp->header.event = cpu_to_le16((u16)HIF_STOP_REQ);
/* send to device request */
ps_confirm_wait_inc(priv);
@@ -1668,14 +1668,14 @@ void hostif_phy_information_request(struct
ks_wlan_private *priv)
return;
}
pp->header.size =
- cpu_to_le16((uint16_t)(sizeof(*pp) - sizeof(pp->header.size)));
- pp->header.event = cpu_to_le16((uint16_t)HIF_PHY_INFO_REQ);
+ cpu_to_le16((u16)(sizeof(*pp) - sizeof(pp->header.size)));
+ pp->header.event = cpu_to_le16((u16)HIF_PHY_INFO_REQ);
if (priv->reg.phy_info_timer) {
- pp->type = cpu_to_le16((uint16_t)TIME_TYPE);
- pp->time = cpu_to_le16((uint16_t)(priv->reg.phy_info_timer));
+ pp->type = cpu_to_le16((u16)TIME_TYPE);
+ pp->time = cpu_to_le16((u16)(priv->reg.phy_info_timer));
} else {
- pp->type = cpu_to_le16((uint16_t)NORMAL_TYPE);
- pp->time = cpu_to_le16((uint16_t)0);
+ pp->type = cpu_to_le16((u16)NORMAL_TYPE);
+ pp->time = cpu_to_le16((u16)0);
}
/* send to device request */
@@ -1699,11 +1699,11 @@ void hostif_power_mngmt_request(struct ks_wlan_private
*priv,
return;
}
pp->header.size =
- cpu_to_le16((uint16_t)(sizeof(*pp) - sizeof(pp->header.size)));
- pp->header.event = cpu_to_le16((uint16_t)HIF_POWERMGT_REQ);
- pp->mode = cpu_to_le32((uint32_t)mode);
- pp->wake_up = cpu_to_le32((uint32_t)wake_up);
- pp->receiveDTIMs = cpu_to_le32((uint32_t)receiveDTIMs);
+ cpu_to_le16((u16)(sizeof(*pp) - sizeof(pp->header.size)));
+ pp->header.event = cpu_to_le16((u16)HIF_POWERMGT_REQ);
+ pp->mode = cpu_to_le32((u32)mode);
+ pp->wake_up = cpu_to_le32((u32)wake_up);
+ pp->receiveDTIMs = cpu_to_le32((u32)receiveDTIMs);
/* send to device request */
ps_confirm_wait_inc(priv);
@@ -1725,8 +1725,8 @@ void hostif_sleep_request(struct ks_wlan_private *priv,
unsigned long mode)
return;
}
pp->header.size =
- cpu_to_le16((uint16_t)(sizeof(*pp) -
sizeof(pp->header.size)));
- pp->header.event = cpu_to_le16((uint16_t)HIF_SLEEP_REQ);
+ cpu_to_le16((u16)(sizeof(*pp) - sizeof(pp->header.size)));
+ pp->header.event = cpu_to_le16((u16)HIF_SLEEP_REQ);
/* send to device request */
ps_confirm_wait_inc(priv);
@@ -1744,8 +1744,8 @@ void hostif_sleep_request(struct ks_wlan_private *priv,
unsigned long mode)
static
void hostif_bss_scan_request(struct ks_wlan_private *priv,
- unsigned long scan_type, uint8_t *scan_ssid,
- uint8_t scan_ssid_len)
+ unsigned long scan_type, u8 *scan_ssid,
+ u8 scan_ssid_len)
{
struct hostif_bss_scan_request_t *pp;
@@ -1757,12 +1757,12 @@ void hostif_bss_scan_request(struct ks_wlan_private
*priv,
return;
}
pp->header.size =
- cpu_to_le16((uint16_t)(sizeof(*pp) - sizeof(pp->header.size)));
- pp->header.event = cpu_to_le16((uint16_t)HIF_SCAN_REQ);
+ cpu_to_le16((u16)(sizeof(*pp) - sizeof(pp->header.size)));
+ pp->header.event = cpu_to_le16((u16)HIF_SCAN_REQ);
pp->scan_type = scan_type;
- pp->ch_time_min = cpu_to_le32((uint32_t)110); /* default value */
- pp->ch_time_max = cpu_to_le32((uint32_t)130); /* default value */
+ pp->ch_time_min = cpu_to_le32((u32)110); /* default value */
+ pp->ch_time_max = cpu_to_le32((u32)130); /* default value */
pp->channel_list.body[0] = 1;
pp->channel_list.body[1] = 8;
pp->channel_list.body[2] = 2;
@@ -1813,10 +1813,10 @@ void hostif_mic_failure_request(struct ks_wlan_private
*priv,
return;
}
pp->header.size =
- cpu_to_le16((uint16_t)(sizeof(*pp) - sizeof(pp->header.size)));
- pp->header.event = cpu_to_le16((uint16_t)HIF_MIC_FAILURE_REQ);
- pp->failure_count = cpu_to_le16((uint16_t)failure_count);
- pp->timer = cpu_to_le16((uint16_t)timer);
+ cpu_to_le16((u16)(sizeof(*pp) - sizeof(pp->header.size)));
+ pp->header.event = cpu_to_le16((u16)HIF_MIC_FAILURE_REQ);
+ pp->failure_count = cpu_to_le16((u16)failure_count);
+ pp->timer = cpu_to_le16((u16)timer);
/* send to device request */
ps_confirm_wait_inc(priv);
@@ -1865,11 +1865,11 @@ void hostif_receive(struct ks_wlan_private *priv,
unsigned char *p,
static
void hostif_sme_set_wep(struct ks_wlan_private *priv, int type)
{
- uint32_t val;
+ u32 val;
switch (type) {
case SME_WEP_INDEX_REQUEST:
- val = cpu_to_le32((uint32_t)(priv->reg.wep_index));
+ val = cpu_to_le32((u32)(priv->reg.wep_index));
hostif_mib_set_request(priv, DOT11_WEP_DEFAULT_KEY_ID,
sizeof(val), MIB_VALUE_TYPE_INT, &val);
break;
@@ -1906,7 +1906,7 @@ void hostif_sme_set_wep(struct ks_wlan_private *priv, int
type)
&priv->reg.wep_key[3].val[0]);
break;
case SME_WEP_FLAG_REQUEST:
- val = cpu_to_le32((uint32_t)(priv->reg.privacy_invoked));
+ val = cpu_to_le32((u32)(priv->reg.privacy_invoked));
hostif_mib_set_request(priv, DOT11_PRIVACY_INVOKED,
sizeof(val), MIB_VALUE_TYPE_BOOL, &val);
break;
@@ -1919,8 +1919,8 @@ struct wpa_suite_t {
} __packed;
struct rsn_mode_t {
- uint32_t rsn_mode;
- uint16_t rsn_capability;
+ u32 rsn_mode;
+ u16 rsn_capability;
} __packed;
static
@@ -1928,13 +1928,13 @@ void hostif_sme_set_rsn(struct ks_wlan_private *priv,
int type)
{
struct wpa_suite_t wpa_suite;
struct rsn_mode_t rsn_mode;
- uint32_t val;
+ u32 val;
memset(&wpa_suite, 0, sizeof(wpa_suite));
switch (type) {
case SME_RSN_UCAST_REQUEST:
- wpa_suite.size = cpu_to_le16((uint16_t)1);
+ wpa_suite.size = cpu_to_le16((u16)1);
switch (priv->wpa.pairwise_suite) {
case IW_AUTH_CIPHER_NONE:
if (priv->wpa.version == IW_AUTH_WPA_VERSION_WPA2)
@@ -2032,7 +2032,7 @@ void hostif_sme_set_rsn(struct ks_wlan_private *priv, int
type)
&wpa_suite.suite[0][0]);
break;
case SME_RSN_AUTH_REQUEST:
- wpa_suite.size = cpu_to_le16((uint16_t)1);
+ wpa_suite.size = cpu_to_le16((u16)1);
switch (priv->wpa.key_mgmt_suite) {
case IW_AUTH_KEY_MGMT_802_1X:
if (priv->wpa.version == IW_AUTH_WPA_VERSION_WPA2)
@@ -2076,23 +2076,23 @@ void hostif_sme_set_rsn(struct ks_wlan_private *priv,
int type)
MIB_VALUE_TYPE_OSTRING, &wpa_suite);
break;
case SME_RSN_ENABLED_REQUEST:
- val = cpu_to_le32((uint32_t)(priv->wpa.rsn_enabled));
+ val = cpu_to_le32((u32)(priv->wpa.rsn_enabled));
hostif_mib_set_request(priv, DOT11_RSN_ENABLED,
sizeof(val), MIB_VALUE_TYPE_BOOL, &val);
break;
case SME_RSN_MODE_REQUEST:
if (priv->wpa.version == IW_AUTH_WPA_VERSION_WPA2) {
rsn_mode.rsn_mode =
- cpu_to_le32((uint32_t)RSN_MODE_WPA2);
- rsn_mode.rsn_capability = cpu_to_le16((uint16_t)0);
+ cpu_to_le32((u32)RSN_MODE_WPA2);
+ rsn_mode.rsn_capability = cpu_to_le16((u16)0);
} else if (priv->wpa.version == IW_AUTH_WPA_VERSION_WPA) {
rsn_mode.rsn_mode =
- cpu_to_le32((uint32_t)RSN_MODE_WPA);
- rsn_mode.rsn_capability = cpu_to_le16((uint16_t)0);
+ cpu_to_le32((u32)RSN_MODE_WPA);
+ rsn_mode.rsn_capability = cpu_to_le16((u16)0);
} else {
rsn_mode.rsn_mode =
- cpu_to_le32((uint32_t)RSN_MODE_NONE);
- rsn_mode.rsn_capability = cpu_to_le16((uint16_t)0);
+ cpu_to_le32((u32)RSN_MODE_NONE);
+ rsn_mode.rsn_capability = cpu_to_le16((u16)0);
}
hostif_mib_set_request(priv, LOCAL_RSN_MODE, sizeof(rsn_mode),
MIB_VALUE_TYPE_OSTRING, &rsn_mode);
@@ -2225,13 +2225,13 @@ void hostif_sme_multicast_set(struct ks_wlan_private
*priv)
memset(set_address, 0, NIC_MAX_MCAST_LIST * ETH_ALEN);
if (dev->flags & IFF_PROMISC) {
- filter_type = cpu_to_le32((uint32_t)MCAST_FILTER_PROMISC);
+ filter_type = cpu_to_le32((u32)MCAST_FILTER_PROMISC);
hostif_mib_set_request(priv, LOCAL_MULTICAST_FILTER,
sizeof(filter_type), MIB_VALUE_TYPE_BOOL,
&filter_type);
} else if ((netdev_mc_count(dev) > NIC_MAX_MCAST_LIST)
|| (dev->flags & IFF_ALLMULTI)) {
- filter_type = cpu_to_le32((uint32_t)MCAST_FILTER_MCASTALL);
+ filter_type = cpu_to_le32((u32)MCAST_FILTER_MCASTALL);
hostif_mib_set_request(priv, LOCAL_MULTICAST_FILTER,
sizeof(filter_type), MIB_VALUE_TYPE_BOOL,
&filter_type);
@@ -2250,7 +2250,7 @@ void hostif_sme_multicast_set(struct ks_wlan_private
*priv)
&set_address[0]);
} else {
filter_type =
- cpu_to_le32((uint32_t)MCAST_FILTER_MCAST);
+ cpu_to_le32((u32)MCAST_FILTER_MCAST);
priv->sme_i.sme_flag |= SME_MULTICAST;
hostif_mib_set_request(priv, LOCAL_MULTICAST_FILTER,
sizeof(filter_type),
@@ -2324,16 +2324,16 @@ void hostif_sme_sleep_set(struct ks_wlan_private *priv)
static
void hostif_sme_set_key(struct ks_wlan_private *priv, int type)
{
- uint32_t val;
+ u32 val;
switch (type) {
case SME_SET_FLAG:
- val = cpu_to_le32((uint32_t)(priv->reg.privacy_invoked));
+ val = cpu_to_le32((u32)(priv->reg.privacy_invoked));
hostif_mib_set_request(priv, DOT11_PRIVACY_INVOKED,
sizeof(val), MIB_VALUE_TYPE_BOOL, &val);
break;
case SME_SET_TXKEY:
- val = cpu_to_le32((uint32_t)(priv->wpa.txkey));
+ val = cpu_to_le32((u32)(priv->wpa.txkey));
hostif_mib_set_request(priv, DOT11_WEP_DEFAULT_KEY_ID,
sizeof(val), MIB_VALUE_TYPE_INT, &val);
break;
@@ -2383,10 +2383,10 @@ static
void hostif_sme_set_pmksa(struct ks_wlan_private *priv)
{
struct pmk_cache_t {
- uint16_t size;
+ u16 size;
struct {
- uint8_t bssid[ETH_ALEN];
- uint8_t pmkid[IW_PMKID_LEN];
+ u8 bssid[ETH_ALEN];
+ u8 pmkid[IW_PMKID_LEN];
} __packed list[PMK_LIST_MAX];
} __packed pmkcache;
struct pmk_t *pmk;
@@ -2402,7 +2402,7 @@ void hostif_sme_set_pmksa(struct ks_wlan_private *priv)
i++;
}
}
- pmkcache.size = cpu_to_le16((uint16_t)(priv->pmklist.size));
+ pmkcache.size = cpu_to_le16((u16)(priv->pmklist.size));
hostif_mib_set_request(priv, LOCAL_PMK,
sizeof(priv->pmklist.size) + (ETH_ALEN +
IW_PMKID_LEN) *
@@ -2414,7 +2414,7 @@ void hostif_sme_set_pmksa(struct ks_wlan_private *priv)
static
void hostif_sme_execute(struct ks_wlan_private *priv, int event)
{
- uint32_t val;
+ u32 val;
DPRINTK(3, "event=%d\n", event);
switch (event) {
@@ -2476,12 +2476,12 @@ void hostif_sme_execute(struct ks_wlan_private *priv,
int event)
hostif_stop_request(priv);
break;
case SME_RTS_THRESHOLD_REQUEST:
- val = cpu_to_le32((uint32_t)(priv->reg.rts));
+ val = cpu_to_le32((u32)(priv->reg.rts));
hostif_mib_set_request(priv, DOT11_RTS_THRESHOLD,
sizeof(val), MIB_VALUE_TYPE_INT, &val);
break;
case SME_FRAGMENTATION_THRESHOLD_REQUEST:
- val = cpu_to_le32((uint32_t)(priv->reg.fragment));
+ val = cpu_to_le32((u32)(priv->reg.fragment));
hostif_mib_set_request(priv, DOT11_FRAGMENTATION_THRESHOLD,
sizeof(val), MIB_VALUE_TYPE_INT, &val);
break;
@@ -2558,7 +2558,7 @@ void hostif_sme_execute(struct ks_wlan_private *priv, int
event)
hostif_sme_sleep_set(priv);
break;
case SME_SET_REGION:
- val = cpu_to_le32((uint32_t)(priv->region));
+ val = cpu_to_le32((u32)(priv->region));
hostif_mib_set_request(priv, LOCAL_REGION,
sizeof(val), MIB_VALUE_TYPE_INT, &val);
break;
diff --git a/drivers/staging/ks7010/ks_hostif.h
b/drivers/staging/ks7010/ks_hostif.h
index 1d57bf0..2d596a8 100644
--- a/drivers/staging/ks7010/ks_hostif.h
+++ b/drivers/staging/ks7010/ks_hostif.h
@@ -62,35 +62,35 @@
*/
struct hostif_hdr {
- uint16_t size;
- uint16_t event;
+ u16 size;
+ u16 event;
} __packed;
struct hostif_data_request_t {
struct hostif_hdr header;
- uint16_t auth_type;
+ u16 auth_type;
#define TYPE_DATA 0x0000
#define TYPE_AUTH 0x0001
- uint16_t reserved;
- uint8_t data[0];
+ u16 reserved;
+ u8 data[0];
} __packed;
struct hostif_data_indication_t {
struct hostif_hdr header;
- uint16_t auth_type;
+ u16 auth_type;
/* #define TYPE_DATA 0x0000 */
#define TYPE_PMK1 0x0001
#define TYPE_GMK1 0x0002
#define TYPE_GMK2 0x0003
- uint16_t reserved;
- uint8_t data[0];
+ u16 reserved;
+ u8 data[0];
} __packed;
#define CHANNEL_LIST_MAX_SIZE 14
struct channel_list_t {
- uint8_t size;
- uint8_t body[CHANNEL_LIST_MAX_SIZE];
- uint8_t pad;
+ u8 size;
+ u8 body[CHANNEL_LIST_MAX_SIZE];
+ u8 pad;
} __packed;
/* MIB Attribute */
@@ -143,52 +143,52 @@ struct channel_list_t {
struct hostif_mib_get_request_t {
struct hostif_hdr header;
- uint32_t mib_attribute;
+ u32 mib_attribute;
} __packed;
struct hostif_mib_value_t {
- uint16_t size;
- uint16_t type;
+ u16 size;
+ u16 type;
#define MIB_VALUE_TYPE_NULL 0
#define MIB_VALUE_TYPE_INT 1
#define MIB_VALUE_TYPE_BOOL 2
#define MIB_VALUE_TYPE_COUNT32 3
#define MIB_VALUE_TYPE_OSTRING 4
- uint8_t body[0];
+ u8 body[0];
} __packed;
struct hostif_mib_get_confirm_t {
struct hostif_hdr header;
- uint32_t mib_status;
+ u32 mib_status;
#define MIB_SUCCESS 0
#define MIB_INVALID 1
#define MIB_READ_ONLY 2
#define MIB_WRITE_ONLY 3
- uint32_t mib_attribute;
+ u32 mib_attribute;
struct hostif_mib_value_t mib_value;
} __packed;
struct hostif_mib_set_request_t {
struct hostif_hdr header;
- uint32_t mib_attribute;
+ u32 mib_attribute;
struct hostif_mib_value_t mib_value;
} __packed;
struct hostif_mib_set_confirm_t {
struct hostif_hdr header;
- uint32_t mib_status;
- uint32_t mib_attribute;
+ u32 mib_status;
+ u32 mib_attribute;
} __packed;
struct hostif_power_mngmt_request_t {
struct hostif_hdr header;
- uint32_t mode;
+ u32 mode;
#define POWER_ACTIVE 1
#define POWER_SAVE 2
- uint32_t wake_up;
+ u32 wake_up;
#define SLEEP_FALSE 0
#define SLEEP_TRUE 1 /* not used */
- uint32_t receiveDTIMs;
+ u32 receiveDTIMs;
#define DTIM_FALSE 0
#define DTIM_TRUE 1
} __packed;
@@ -208,12 +208,12 @@ enum {
struct hostif_power_mngmt_confirm_t {
struct hostif_hdr header;
- uint16_t result_code;
+ u16 result_code;
} __packed;
struct hostif_start_request_t {
struct hostif_hdr header;
- uint16_t mode;
+ u16 mode;
#define MODE_PSEUDO_ADHOC 0
#define MODE_INFRASTRUCTURE 1
#define MODE_AP 2 /* not used */
@@ -222,69 +222,69 @@ struct hostif_start_request_t {
struct hostif_start_confirm_t {
struct hostif_hdr header;
- uint16_t result_code;
+ u16 result_code;
} __packed;
#define SSID_MAX_SIZE 32
struct ssid_t {
- uint8_t size;
- uint8_t body[SSID_MAX_SIZE];
- uint8_t ssid_pad;
+ u8 size;
+ u8 body[SSID_MAX_SIZE];
+ u8 ssid_pad;
} __packed;
#define RATE_SET_MAX_SIZE 16
struct rate_set8_t {
- uint8_t size;
- uint8_t body[8];
- uint8_t rate_pad;
+ u8 size;
+ u8 body[8];
+ u8 rate_pad;
} __packed;
struct FhParms_t {
- uint16_t dwellTime;
- uint8_t hopSet;
- uint8_t hopPattern;
- uint8_t hopIndex;
+ u16 dwellTime;
+ u8 hopSet;
+ u8 hopPattern;
+ u8 hopIndex;
} __packed;
struct DsParms_t {
- uint8_t channel;
+ u8 channel;
} __packed;
struct CfParms_t {
- uint8_t count;
- uint8_t period;
- uint16_t maxDuration;
- uint16_t durRemaining;
+ u8 count;
+ u8 period;
+ u16 maxDuration;
+ u16 durRemaining;
} __packed;
struct IbssParms_t {
- uint16_t atimWindow;
+ u16 atimWindow;
} __packed;
struct rsn_t {
- uint8_t size;
+ u8 size;
#define RSN_BODY_SIZE 64
- uint8_t body[RSN_BODY_SIZE];
+ u8 body[RSN_BODY_SIZE];
} __packed;
struct ErpParams_t {
- uint8_t erp_info;
+ u8 erp_info;
} __packed;
struct rate_set16_t {
- uint8_t size;
- uint8_t body[16];
- uint8_t rate_pad;
+ u8 size;
+ u8 body[16];
+ u8 rate_pad;
} __packed;
struct ap_info_t {
- uint8_t bssid[6]; /* +00 */
- uint8_t rssi; /* +06 */
- uint8_t sq; /* +07 */
- uint8_t noise; /* +08 */
- uint8_t pad0; /* +09 */
- uint16_t beacon_period; /* +10 */
- uint16_t capability; /* +12 */
+ u8 bssid[6]; /* +00 */
+ u8 rssi; /* +06 */
+ u8 sq; /* +07 */
+ u8 noise; /* +08 */
+ u8 pad0; /* +09 */
+ u16 beacon_period; /* +10 */
+ u16 capability; /* +12 */
#define BSS_CAP_ESS BIT(0)
#define BSS_CAP_IBSS BIT(1)
#define BSS_CAP_CF_POLABLE BIT(2)
@@ -295,45 +295,45 @@ struct ap_info_t {
#define BSS_CAP_CHANNEL_AGILITY BIT(7)
#define BSS_CAP_SHORT_SLOT_TIME BIT(10)
#define BSS_CAP_DSSS_OFDM BIT(13)
- uint8_t frame_type; /* +14 */
- uint8_t ch_info; /* +15 */
+ u8 frame_type; /* +14 */
+ u8 ch_info; /* +15 */
#define FRAME_TYPE_BEACON 0x80
#define FRAME_TYPE_PROBE_RESP 0x50
- uint16_t body_size; /* +16 */
- uint8_t body[1024]; /* +18 */
+ u16 body_size; /* +16 */
+ u8 body[1024]; /* +18 */
/* +1032 */
} __packed;
struct link_ap_info_t {
- uint8_t bssid[6]; /* +00 */
- uint8_t rssi; /* +06 */
- uint8_t sq; /* +07 */
- uint8_t noise; /* +08 */
- uint8_t pad0; /* +09 */
- uint16_t beacon_period; /* +10 */
- uint16_t capability; /* +12 */
+ u8 bssid[6]; /* +00 */
+ u8 rssi; /* +06 */
+ u8 sq; /* +07 */
+ u8 noise; /* +08 */
+ u8 pad0; /* +09 */
+ u16 beacon_period; /* +10 */
+ u16 capability; /* +12 */
struct rate_set8_t rate_set; /* +14 */
struct FhParms_t fh_parameter; /* +24 */
struct DsParms_t ds_parameter; /* +29 */
struct CfParms_t cf_parameter; /* +30 */
struct IbssParms_t ibss_parameter; /* +36 */
struct ErpParams_t erp_parameter; /* +38 */
- uint8_t pad1; /* +39 */
+ u8 pad1; /* +39 */
struct rate_set8_t ext_rate_set; /* +40 */
- uint8_t DTIM_period; /* +50 */
- uint8_t rsn_mode; /* +51 */
+ u8 DTIM_period; /* +50 */
+ u8 rsn_mode; /* +51 */
#define RSN_MODE_NONE 0
#define RSN_MODE_WPA 1
#define RSN_MODE_WPA2 2
struct {
- uint8_t size; /* +52 */
- uint8_t body[128]; /* +53 */
+ u8 size; /* +52 */
+ u8 body[128]; /* +53 */
} __packed rsn;
} __packed;
struct hostif_connect_indication_t {
struct hostif_hdr header;
- uint16_t connect_code;
+ u16 connect_code;
#define RESULT_CONNECT 0
#define RESULT_DISCONNECT 1
struct link_ap_info_t link_ap_info;
@@ -345,125 +345,125 @@ struct hostif_stop_request_t {
struct hostif_stop_confirm_t {
struct hostif_hdr header;
- uint16_t result_code;
+ u16 result_code;
} __packed;
struct hostif_ps_adhoc_set_request_t {
struct hostif_hdr header;
- uint16_t phy_type;
+ u16 phy_type;
#define D_11B_ONLY_MODE 0
#define D_11G_ONLY_MODE 1
#define D_11BG_COMPATIBLE_MODE 2
#define D_11A_ONLY_MODE 3
- uint16_t cts_mode;
+ u16 cts_mode;
#define CTS_MODE_FALSE 0
#define CTS_MODE_TRUE 1
- uint16_t channel;
+ u16 channel;
struct rate_set16_t rate_set;
- uint16_t capability; /* bit5:preamble bit6:pbcc pbcc not supported
always 0
+ u16 capability; /* bit5:preamble bit6:pbcc pbcc not supported always 0
* bit10:ShortSlotTime bit13:DSSS-OFDM
DSSS-OFDM not supported always 0 */
- uint16_t scan_type;
+ u16 scan_type;
} __packed;
struct hostif_ps_adhoc_set_confirm_t {
struct hostif_hdr header;
- uint16_t result_code;
+ u16 result_code;
} __packed;
struct hostif_infrastructure_set_request_t {
struct hostif_hdr header;
- uint16_t phy_type;
- uint16_t cts_mode;
+ u16 phy_type;
+ u16 cts_mode;
struct rate_set16_t rate_set;
struct ssid_t ssid;
- uint16_t capability; /* bit5:preamble bit6:pbcc pbcc not supported
always 0
+ u16 capability; /* bit5:preamble bit6:pbcc pbcc not supported always 0
* bit10:ShortSlotTime bit13:DSSS-OFDM
DSSS-OFDM not supported always 0 */
- uint16_t beacon_lost_count;
- uint16_t auth_type;
+ u16 beacon_lost_count;
+ u16 auth_type;
#define AUTH_TYPE_OPEN_SYSTEM 0
#define AUTH_TYPE_SHARED_KEY 1
struct channel_list_t channel_list;
- uint16_t scan_type;
+ u16 scan_type;
} __packed;
struct hostif_infrastructure_set2_request_t {
struct hostif_hdr header;
- uint16_t phy_type;
- uint16_t cts_mode;
+ u16 phy_type;
+ u16 cts_mode;
struct rate_set16_t rate_set;
struct ssid_t ssid;
- uint16_t capability; /* bit5:preamble bit6:pbcc pbcc not supported
always 0
+ u16 capability; /* bit5:preamble bit6:pbcc pbcc not supported always 0
* bit10:ShortSlotTime bit13:DSSS-OFDM
DSSS-OFDM not supported always 0 */
- uint16_t beacon_lost_count;
- uint16_t auth_type;
+ u16 beacon_lost_count;
+ u16 auth_type;
#define AUTH_TYPE_OPEN_SYSTEM 0
#define AUTH_TYPE_SHARED_KEY 1
struct channel_list_t channel_list;
- uint16_t scan_type;
- uint8_t bssid[ETH_ALEN];
+ u16 scan_type;
+ u8 bssid[ETH_ALEN];
} __packed;
struct hostif_infrastructure_set_confirm_t {
struct hostif_hdr header;
- uint16_t result_code;
+ u16 result_code;
} __packed;
struct hostif_adhoc_set_request_t {
struct hostif_hdr header;
- uint16_t phy_type;
- uint16_t cts_mode;
- uint16_t channel;
+ u16 phy_type;
+ u16 cts_mode;
+ u16 channel;
struct rate_set16_t rate_set;
struct ssid_t ssid;
- uint16_t capability; /* bit5:preamble bit6:pbcc pbcc not supported
always 0
+ u16 capability; /* bit5:preamble bit6:pbcc pbcc not supported always 0
* bit10:ShortSlotTime bit13:DSSS-OFDM
DSSS-OFDM not supported always 0 */
- uint16_t scan_type;
+ u16 scan_type;
} __packed;
struct hostif_adhoc_set2_request_t {
struct hostif_hdr header;
- uint16_t phy_type;
- uint16_t cts_mode;
- uint16_t reserved;
+ u16 phy_type;
+ u16 cts_mode;
+ u16 reserved;
struct rate_set16_t rate_set;
struct ssid_t ssid;
- uint16_t capability; /* bit5:preamble bit6:pbcc pbcc not supported
always 0
+ u16 capability; /* bit5:preamble bit6:pbcc pbcc not supported always 0
* bit10:ShortSlotTime bit13:DSSS-OFDM
DSSS-OFDM not supported always 0 */
- uint16_t scan_type;
+ u16 scan_type;
struct channel_list_t channel_list;
- uint8_t bssid[ETH_ALEN];
+ u8 bssid[ETH_ALEN];
} __packed;
struct hostif_adhoc_set_confirm_t {
struct hostif_hdr header;
- uint16_t result_code;
+ u16 result_code;
} __packed;
struct last_associate_t {
- uint8_t type;
- uint8_t status;
+ u8 type;
+ u8 status;
} __packed;
struct association_request_t {
- uint8_t type;
+ u8 type;
#define FRAME_TYPE_ASSOC_REQ 0x00
#define FRAME_TYPE_REASSOC_REQ 0x20
- uint8_t pad;
- uint16_t capability;
- uint16_t listen_interval;
- uint8_t ap_address[6];
- uint16_t reqIEs_size;
+ u8 pad;
+ u16 capability;
+ u16 listen_interval;
+ u8 ap_address[6];
+ u16 reqIEs_size;
} __packed;
struct association_response_t {
- uint8_t type;
+ u8 type;
#define FRAME_TYPE_ASSOC_RESP 0x10
#define FRAME_TYPE_REASSOC_RESP 0x30
- uint8_t pad;
- uint16_t capability;
- uint16_t status;
- uint16_t association_id;
- uint16_t respIEs_size;
+ u8 pad;
+ u16 capability;
+ u16 status;
+ u16 association_id;
+ u16 respIEs_size;
} __packed;
struct hostif_associate_indication_t {
@@ -476,40 +476,40 @@ struct hostif_associate_indication_t {
struct hostif_bss_scan_request_t {
struct hostif_hdr header;
- uint8_t scan_type;
+ u8 scan_type;
#define ACTIVE_SCAN 0
#define PASSIVE_SCAN 1
- uint8_t pad[3];
- uint32_t ch_time_min;
- uint32_t ch_time_max;
+ u8 pad[3];
+ u32 ch_time_min;
+ u32 ch_time_max;
struct channel_list_t channel_list;
struct ssid_t ssid;
} __packed;
struct hostif_bss_scan_confirm_t {
struct hostif_hdr header;
- uint16_t result_code;
- uint16_t reserved;
+ u16 result_code;
+ u16 reserved;
} __packed;
struct hostif_phy_information_request_t {
struct hostif_hdr header;
- uint16_t type;
+ u16 type;
#define NORMAL_TYPE 0
#define TIME_TYPE 1
- uint16_t time; /* unit 100ms */
+ u16 time; /* unit 100ms */
} __packed;
struct hostif_phy_information_confirm_t {
struct hostif_hdr header;
- uint8_t rssi;
- uint8_t sq;
- uint8_t noise;
- uint8_t link_speed;
- uint32_t tx_frame;
- uint32_t rx_frame;
- uint32_t tx_error;
- uint32_t rx_error;
+ u8 rssi;
+ u8 sq;
+ u8 noise;
+ u8 link_speed;
+ u32 tx_frame;
+ u32 rx_frame;
+ u32 tx_error;
+ u32 rx_error;
} __packed;
/* sleep mode */
@@ -521,18 +521,18 @@ struct hostif_sleep_request_t {
struct hostif_sleep_confirm_t {
struct hostif_hdr header;
- uint16_t result_code;
+ u16 result_code;
} __packed;
struct hostif_mic_failure_request_t {
struct hostif_hdr header;
- uint16_t failure_count;
- uint16_t timer;
+ u16 failure_count;
+ u16 timer;
} __packed;
struct hostif_mic_failure_confirm_t {
struct hostif_hdr header;
- uint16_t result_code;
+ u16 result_code;
} __packed;
#define BASIC_RATE 0x80
@@ -553,20 +553,20 @@ struct hostif_mic_failure_confirm_t {
#define TX_RATE_FIXED 5
/* 11b rate */
-#define TX_RATE_1M (uint8_t)(10 / 5) /* 11b 11g basic rate */
-#define TX_RATE_2M (uint8_t)(20 / 5) /* 11b 11g basic rate */
-#define TX_RATE_5M (uint8_t)(55 / 5) /* 11g basic rate */
-#define TX_RATE_11M (uint8_t)(110 / 5) /* 11g basic rate */
+#define TX_RATE_1M (u8)(10 / 5) /* 11b 11g basic rate */
+#define TX_RATE_2M (u8)(20 / 5) /* 11b 11g basic rate */
+#define TX_RATE_5M (u8)(55 / 5) /* 11g basic rate */
+#define TX_RATE_11M (u8)(110 / 5) /* 11g basic rate */
/* 11g rate */
-#define TX_RATE_6M (uint8_t)(60 / 5) /* 11g basic rate */
-#define TX_RATE_12M (uint8_t)(120 / 5) /* 11g basic rate */
-#define TX_RATE_24M (uint8_t)(240 / 5) /* 11g basic rate */
-#define TX_RATE_9M (uint8_t)(90 / 5)
-#define TX_RATE_18M (uint8_t)(180 / 5)
-#define TX_RATE_36M (uint8_t)(360 / 5)
-#define TX_RATE_48M (uint8_t)(480 / 5)
-#define TX_RATE_54M (uint8_t)(540 / 5)
+#define TX_RATE_6M (u8)(60 / 5) /* 11g basic rate */
+#define TX_RATE_12M (u8)(120 / 5) /* 11g basic rate */
+#define TX_RATE_24M (u8)(240 / 5) /* 11g basic rate */
+#define TX_RATE_9M (u8)(90 / 5)
+#define TX_RATE_18M (u8)(180 / 5)
+#define TX_RATE_36M (u8)(360 / 5)
+#define TX_RATE_48M (u8)(480 / 5)
+#define TX_RATE_54M (u8)(540 / 5)
#define IS_11B_RATE(A) (((A & RATE_MASK) == TX_RATE_1M) || ((A & RATE_MASK) ==
TX_RATE_2M) || \
((A & RATE_MASK) == TX_RATE_5M) || ((A & RATE_MASK) ==
TX_RATE_11M))
@@ -623,7 +623,7 @@ int hostif_data_request(struct ks_wlan_private *priv,
struct sk_buff *packet);
void hostif_receive(struct ks_wlan_private *priv, unsigned char *p,
unsigned int size);
-void hostif_sme_enqueue(struct ks_wlan_private *priv, uint16_t event);
+void hostif_sme_enqueue(struct ks_wlan_private *priv, u16 event);
int hostif_init(struct ks_wlan_private *priv);
void hostif_exit(struct ks_wlan_private *priv);
int ks_wlan_hw_tx(struct ks_wlan_private *priv, void *p,
--
2.7.4
_______________________________________________
devel mailing list
de...@linuxdriverproject.org
http://driverdev.linuxdriverproject.org/mailman/listinfo/driverdev-devel
