1 files changed, 219 insertions, 232 deletions

diff --git a/drivers/net/wireless/rndis_wlan.c b/drivers/net/wireless/rndis_wlan.c
index 10b776c1adc5..977751f372ff 100644
--- a/drivers/net/wireless/rndis_wlan.c
+++ b/drivers/net/wireless/rndis_wlan.c
@@ -154,128 +154,121 @@ MODULE_PARM_DESC(workaround_interval,
 #define NDIS_802_11_LENGTH_RATES 8
 #define NDIS_802_11_LENGTH_RATES_EX 16
 
-struct NDIS_802_11_SSID {
-        __le32 SsidLength;
-        u8 Ssid[NDIS_802_11_LENGTH_SSID];
-} __attribute__((packed));
-
-enum NDIS_802_11_NETWORK_TYPE {
-        Ndis802_11FH,
-        Ndis802_11DS,
-        Ndis802_11OFDM5,
-        Ndis802_11OFDM24,
-        Ndis802_11NetworkTypeMax
+enum ndis_80211_net_type {
+        ndis_80211_type_freq_hop,
+        ndis_80211_type_direct_seq,
+        ndis_80211_type_ofdm_a,
+        ndis_80211_type_ofdm_g
 };
 
-struct NDIS_802_11_CONFIGURATION_FH {
-        __le32 Length;
-        __le32 HopPattern;
-        __le32 HopSet;
-        __le32 DwellTime;
-} __attribute__((packed));
-
-struct NDIS_802_11_CONFIGURATION {
-        __le32 Length;
-        __le32 BeaconPeriod;
-        __le32 ATIMWindow;
-        __le32 DSConfig;
-        struct NDIS_802_11_CONFIGURATION_FH FHConfig;
-} __attribute__((packed));
-
-enum NDIS_802_11_NETWORK_INFRASTRUCTURE {
-        Ndis802_11IBSS,
-        Ndis802_11Infrastructure,
-        Ndis802_11AutoUnknown,
-        Ndis802_11InfrastructureMax
+enum ndis_80211_net_infra {
+        ndis_80211_infra_adhoc,
+        ndis_80211_infra_infra,
+        ndis_80211_infra_auto_unknown
 };
 
-enum NDIS_802_11_AUTHENTICATION_MODE {
-        Ndis802_11AuthModeOpen,
-        Ndis802_11AuthModeShared,
-        Ndis802_11AuthModeAutoSwitch,
-        Ndis802_11AuthModeWPA,
-        Ndis802_11AuthModeWPAPSK,
-        Ndis802_11AuthModeWPANone,
-        Ndis802_11AuthModeWPA2,
-        Ndis802_11AuthModeWPA2PSK,
-        Ndis802_11AuthModeMax
+enum ndis_80211_auth_mode {
+        ndis_80211_auth_open,
+        ndis_80211_auth_shared,
+        ndis_80211_auth_auto_switch,
+        ndis_80211_auth_wpa,
+        ndis_80211_auth_wpa_psk,
+        ndis_80211_auth_wpa_none,
+        ndis_80211_auth_wpa2,
+        ndis_80211_auth_wpa2_psk
 };
 
-enum NDIS_802_11_ENCRYPTION_STATUS {
-        Ndis802_11WEPEnabled,
-        Ndis802_11Encryption1Enabled = Ndis802_11WEPEnabled,
-        Ndis802_11WEPDisabled,
-        Ndis802_11EncryptionDisabled = Ndis802_11WEPDisabled,
-        Ndis802_11WEPKeyAbsent,
-        Ndis802_11Encryption1KeyAbsent = Ndis802_11WEPKeyAbsent,
-        Ndis802_11WEPNotSupported,
-        Ndis802_11EncryptionNotSupported = Ndis802_11WEPNotSupported,
-        Ndis802_11Encryption2Enabled,
-        Ndis802_11Encryption2KeyAbsent,
-        Ndis802_11Encryption3Enabled,
-        Ndis802_11Encryption3KeyAbsent
+enum ndis_80211_encr_status {
+        ndis_80211_encr_wep_enabled,
+        ndis_80211_encr_disabled,
+        ndis_80211_encr_wep_key_absent,
+        ndis_80211_encr_not_supported,
+        ndis_80211_encr_tkip_enabled,
+        ndis_80211_encr_tkip_key_absent,
+        ndis_80211_encr_ccmp_enabled,
+        ndis_80211_encr_ccmp_key_absent
 };
 
-enum NDIS_802_11_PRIVACY_FILTER {
-        Ndis802_11PrivFilterAcceptAll,
-        Ndis802_11PrivFilter8021xWEP
+enum ndis_80211_priv_filter {
+        ndis_80211_priv_accept_all,
+        ndis_80211_priv_8021x_wep
 };
 
-struct NDIS_WLAN_BSSID_EX {
-        __le32 Length;
-        u8 MacAddress[6];
-        u8 Padding[2];
-        struct NDIS_802_11_SSID Ssid;
-        __le32 Privacy;
-        __le32 Rssi;
-        __le32 NetworkTypeInUse;
-        struct NDIS_802_11_CONFIGURATION Configuration;
-        __le32 InfrastructureMode;
-        u8 SupportedRates[NDIS_802_11_LENGTH_RATES_EX];
-        __le32 IELength;
-        u8 IEs[0];
+struct ndis_80211_ssid {
+        __le32 length;
+        u8 essid[NDIS_802_11_LENGTH_SSID];
+} __attribute__((packed));
+
+struct ndis_80211_conf_freq_hop {
+        __le32 length;
+        __le32 hop_pattern;
+        __le32 hop_set;
+        __le32 dwell_time;
+} __attribute__((packed));
+
+struct ndis_80211_conf {
+        __le32 length;
+        __le32 beacon_period;
+        __le32 atim_window;
+        __le32 ds_config;
+        struct ndis_80211_conf_freq_hop fh_config;
+} __attribute__((packed));
+
+struct ndis_80211_bssid_ex {
+        __le32 length;
+        u8 mac[6];
+        u8 padding[2];
+        struct ndis_80211_ssid ssid;
+        __le32 privacy;
+        __le32 rssi;
+        __le32 net_type;
+        struct ndis_80211_conf config;
+        __le32 net_infra;
+        u8 rates[NDIS_802_11_LENGTH_RATES_EX];
+        __le32 ie_length;
+        u8 ies[0];
 } __attribute__((packed));
 
-struct NDIS_802_11_BSSID_LIST_EX {
-        __le32 NumberOfItems;
-        struct NDIS_WLAN_BSSID_EX Bssid[0];
+struct ndis_80211_bssid_list_ex {
+        __le32 num_items;
+        struct ndis_80211_bssid_ex bssid[0];
 } __attribute__((packed));
 
-struct NDIS_802_11_FIXED_IEs {
-        u8 Timestamp[8];
-        __le16 BeaconInterval;
-        __le16 Capabilities;
+struct ndis_80211_fixed_ies {
+        u8 timestamp[8];
+        __le16 beacon_interval;
+        __le16 capabilities;
 } __attribute__((packed));
 
-struct NDIS_802_11_WEP {
-        __le32 Length;
-        __le32 KeyIndex;
-        __le32 KeyLength;
-        u8 KeyMaterial[32];
+struct ndis_80211_wep_key {
+        __le32 size;
+        __le32 index;
+        __le32 length;
+        u8 material[32];
 } __attribute__((packed));
 
-struct NDIS_802_11_KEY {
-        __le32 Length;
-        __le32 KeyIndex;
-        __le32 KeyLength;
-        u8 Bssid[6];
-        u8 Padding[6];
-        u8 KeyRSC[8];
-        u8 KeyMaterial[32];
+struct ndis_80211_key {
+        __le32 size;
+        __le32 index;
+        __le32 length;
+        u8 bssid[6];
+        u8 padding[6];
+        u8 rsc[8];
+        u8 material[32];
 } __attribute__((packed));
 
-struct NDIS_802_11_REMOVE_KEY {
-        __le32 Length;
-        __le32 KeyIndex;
-        u8 Bssid[6];
+struct ndis_80211_remove_key {
+        __le32 size;
+        __le32 index;
+        u8 bssid[6];
 } __attribute__((packed));
 
-struct RNDIS_CONFIG_PARAMETER_INFOBUFFER {
-        __le32 ParameterNameOffset;
-        __le32 ParameterNameLength;
-        __le32 ParameterType;
-        __le32 ParameterValueOffset;
-        __le32 ParameterValueLength;
+struct ndis_config_param {
+        __le32 name_offs;
+        __le32 name_length;
+        __le32 type;
+        __le32 value_offs;
+        __le32 value_length;
 } __attribute__((packed));
 
 /* these have to match what is in wpa_supplicant */
@@ -334,7 +327,7 @@ struct rndis_wext_private {
         /* hardware state */
         int radio_on;
         int infra_mode;
-        struct NDIS_802_11_SSID essid;
+        struct ndis_80211_ssid essid;
 
         /* encryption stuff */
         int  encr_tx_key_index;
@@ -484,7 +477,7 @@ static int rndis_set_oid(struct usbnet *dev, __le32 oid, void *data, int len)
 static int rndis_set_config_parameter(struct usbnet *dev, char *param,
                                                 int value_type, void *value)
 {
-        struct RNDIS_CONFIG_PARAMETER_INFOBUFFER *infobuf;
+        struct ndis_config_param *infobuf;
         int value_len, info_len, param_len, ret, i;
         __le16 *unibuf;
         __le32 *dst_value;
@@ -519,12 +512,11 @@ static int rndis_set_config_parameter(struct usbnet *dev, char *param,
                 devdbg(dev, "setting config parameter: %s, value: %d",
                                                 param, *(u32 *)value);
 
-        infobuf->ParameterNameOffset = cpu_to_le32(sizeof(*infobuf));
-        infobuf->ParameterNameLength = cpu_to_le32(param_len);
-        infobuf->ParameterType = cpu_to_le32(value_type);
-        infobuf->ParameterValueOffset = cpu_to_le32(sizeof(*infobuf) +
-                                                                param_len);
-        infobuf->ParameterValueLength = cpu_to_le32(value_len);
+        infobuf->name_offs = cpu_to_le32(sizeof(*infobuf));
+        infobuf->name_length = cpu_to_le32(param_len);
+        infobuf->type = cpu_to_le32(value_type);
+        infobuf->value_offs = cpu_to_le32(sizeof(*infobuf) + param_len);
+        infobuf->value_length = cpu_to_le32(value_len);
 
         /* simple string to unicode string conversion */
         unibuf = (void *)infobuf + sizeof(*infobuf);
@@ -630,7 +622,7 @@ static int freq_to_dsconfig(struct iw_freq *freq, unsigned int *dsconfig)
 static int
 add_wep_key(struct usbnet *usbdev, char *key, int key_len, int index);
 
-static int get_essid(struct usbnet *usbdev, struct NDIS_802_11_SSID *ssid)
+static int get_essid(struct usbnet *usbdev, struct ndis_80211_ssid *ssid)
 {
         int ret, len;
 
@@ -638,14 +630,14 @@ static int get_essid(struct usbnet *usbdev, struct NDIS_802_11_SSID *ssid)
         ret = rndis_query_oid(usbdev, OID_802_11_SSID, ssid, &len);
 
         if (ret != 0)
-                ssid->SsidLength = 0;
+                ssid->length = 0;
 
 #ifdef DEBUG
         {
                 unsigned char tmp[NDIS_802_11_LENGTH_SSID + 1];
 
-                memcpy(tmp, ssid->Ssid, le32_to_cpu(ssid->SsidLength));
-                tmp[le32_to_cpu(ssid->SsidLength)] = 0;
+                memcpy(tmp, ssid->essid, le32_to_cpu(ssid->length));
+                tmp[le32_to_cpu(ssid->length)] = 0;
                 devdbg(usbdev, "get_essid: '%s', ret: %d", tmp, ret);
         }
 #endif
@@ -653,7 +645,7 @@ static int get_essid(struct usbnet *usbdev, struct NDIS_802_11_SSID *ssid)
 }
 
 
-static int set_essid(struct usbnet *usbdev, struct NDIS_802_11_SSID *ssid)
+static int set_essid(struct usbnet *usbdev, struct ndis_80211_ssid *ssid)
 {
         struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
         int ret;
@@ -697,7 +689,7 @@ static int is_associated(struct usbnet *usbdev)
 static int disassociate(struct usbnet *usbdev, int reset_ssid)
 {
         struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
-        struct NDIS_802_11_SSID ssid;
+        struct ndis_80211_ssid ssid;
         int i, ret = 0;
 
         if (priv->radio_on) {
@@ -714,12 +706,12 @@ static int disassociate(struct usbnet *usbdev, int reset_ssid)
         /* disassociate causes radio to be turned off; if reset_ssid
          * is given, set random ssid to enable radio */
         if (reset_ssid) {
-                ssid.SsidLength = cpu_to_le32(sizeof(ssid.Ssid));
-                get_random_bytes(&ssid.Ssid[2], sizeof(ssid.Ssid)-2);
-                ssid.Ssid[0] = 0x1;
-                ssid.Ssid[1] = 0xff;
-                for (i = 2; i < sizeof(ssid.Ssid); i++)
-                        ssid.Ssid[i] = 0x1 + (ssid.Ssid[i] * 0xfe / 0xff);
+                ssid.length = cpu_to_le32(sizeof(ssid.essid));
+                get_random_bytes(&ssid.essid[2], sizeof(ssid.essid)-2);
+                ssid.essid[0] = 0x1;
+                ssid.essid[1] = 0xff;
+                for (i = 2; i < sizeof(ssid.essid); i++)
+                        ssid.essid[i] = 0x1 + (ssid.essid[i] * 0xfe / 0xff);
                 ret = set_essid(usbdev, &ssid);
         }
         return ret;
@@ -737,23 +729,23 @@ static int set_auth_mode(struct usbnet *usbdev, int wpa_version, int authalg)
 
         if (wpa_version & IW_AUTH_WPA_VERSION_WPA2) {
                 if (priv->wpa_keymgmt & IW_AUTH_KEY_MGMT_802_1X)
-                        auth_mode = Ndis802_11AuthModeWPA2;
+                        auth_mode = ndis_80211_auth_wpa2;
                 else
-                        auth_mode = Ndis802_11AuthModeWPA2PSK;
+                        auth_mode = ndis_80211_auth_wpa2_psk;
         } else if (wpa_version & IW_AUTH_WPA_VERSION_WPA) {
                 if (priv->wpa_keymgmt & IW_AUTH_KEY_MGMT_802_1X)
-                        auth_mode = Ndis802_11AuthModeWPA;
+                        auth_mode = ndis_80211_auth_wpa;
                 else if (priv->wpa_keymgmt & IW_AUTH_KEY_MGMT_PSK)
-                        auth_mode = Ndis802_11AuthModeWPAPSK;
+                        auth_mode = ndis_80211_auth_wpa_psk;
                 else
-                        auth_mode = Ndis802_11AuthModeWPANone;
+                        auth_mode = ndis_80211_auth_wpa_none;
         } else if (authalg & IW_AUTH_ALG_SHARED_KEY) {
                 if (authalg & IW_AUTH_ALG_OPEN_SYSTEM)
-                        auth_mode = Ndis802_11AuthModeAutoSwitch;
+                        auth_mode = ndis_80211_auth_auto_switch;
                 else
-                        auth_mode = Ndis802_11AuthModeShared;
+                        auth_mode = ndis_80211_auth_shared;
         } else
-                auth_mode = Ndis802_11AuthModeOpen;
+                auth_mode = ndis_80211_auth_open;
 
         tmp = cpu_to_le32(auth_mode);
         ret = rndis_set_oid(usbdev, OID_802_11_AUTHENTICATION_MODE, &tmp,
@@ -778,9 +770,9 @@ static int set_priv_filter(struct usbnet *usbdev)
 
         if (priv->wpa_version & IW_AUTH_WPA_VERSION_WPA2 ||
             priv->wpa_version & IW_AUTH_WPA_VERSION_WPA)
-                tmp = cpu_to_le32(Ndis802_11PrivFilter8021xWEP);
+                tmp = cpu_to_le32(ndis_80211_priv_8021x_wep);
         else
-                tmp = cpu_to_le32(Ndis802_11PrivFilterAcceptAll);
+                tmp = cpu_to_le32(ndis_80211_priv_accept_all);
 
         return rndis_set_oid(usbdev, OID_802_11_PRIVACY_FILTER, &tmp,
                                                                 sizeof(tmp));
@@ -798,18 +790,18 @@ static int set_encr_mode(struct usbnet *usbdev, int pairwise, int groupwise)
                 groupwise);
 
         if (pairwise & IW_AUTH_CIPHER_CCMP)
-                encr_mode = Ndis802_11Encryption3Enabled;
+                encr_mode = ndis_80211_encr_ccmp_enabled;
         else if (pairwise & IW_AUTH_CIPHER_TKIP)
-                encr_mode = Ndis802_11Encryption2Enabled;
+                encr_mode = ndis_80211_encr_tkip_enabled;
         else if (pairwise &
                  (IW_AUTH_CIPHER_WEP40 | IW_AUTH_CIPHER_WEP104))
-                encr_mode = Ndis802_11Encryption1Enabled;
+                encr_mode = ndis_80211_encr_wep_enabled;
         else if (groupwise & IW_AUTH_CIPHER_CCMP)
-                encr_mode = Ndis802_11Encryption3Enabled;
+                encr_mode = ndis_80211_encr_ccmp_enabled;
         else if (groupwise & IW_AUTH_CIPHER_TKIP)
-                encr_mode = Ndis802_11Encryption2Enabled;
+                encr_mode = ndis_80211_encr_tkip_enabled;
         else
-                encr_mode = Ndis802_11EncryptionDisabled;
+                encr_mode = ndis_80211_encr_disabled;
 
         tmp = cpu_to_le32(encr_mode);
         ret = rndis_set_oid(usbdev, OID_802_11_ENCRYPTION_STATUS, &tmp,
@@ -877,7 +869,7 @@ static void set_default_iw_params(struct usbnet *usbdev)
         priv->wpa_keymgmt = 0;
         priv->wpa_version = 0;
 
-        set_infra_mode(usbdev, Ndis802_11Infrastructure);
+        set_infra_mode(usbdev, ndis_80211_infra_infra);
         set_auth_mode(usbdev, IW_AUTH_WPA_VERSION_DISABLED,
                                 IW_AUTH_ALG_OPEN_SYSTEM);
         set_priv_filter(usbdev);
@@ -899,7 +891,7 @@ static int deauthenticate(struct usbnet *usbdev)
 static int add_wep_key(struct usbnet *usbdev, char *key, int key_len, int index)
 {
         struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
-        struct NDIS_802_11_WEP ndis_key;
+        struct ndis_80211_wep_key ndis_key;
         int ret;
 
         if (key_len <= 0 || key_len > 32 || index < 0 || index >= 4)
@@ -907,13 +899,13 @@ static int add_wep_key(struct usbnet *usbdev, char *key, int key_len, int index)
 
         memset(&ndis_key, 0, sizeof(ndis_key));
 
-        ndis_key.Length = cpu_to_le32(sizeof(ndis_key));
-        ndis_key.KeyLength = cpu_to_le32(key_len);
-        ndis_key.KeyIndex = cpu_to_le32(index);
-        memcpy(&ndis_key.KeyMaterial, key, key_len);
+        ndis_key.size = cpu_to_le32(sizeof(ndis_key));
+        ndis_key.length = cpu_to_le32(key_len);
+        ndis_key.index = cpu_to_le32(index);
+        memcpy(&ndis_key.material, key, key_len);
 
         if (index == priv->encr_tx_key_index) {
-                ndis_key.KeyIndex |= cpu_to_le32(1 << 31);
+                ndis_key.index |= cpu_to_le32(1 << 31);
                 ret = set_encr_mode(usbdev, IW_AUTH_CIPHER_WEP104,
                                                 IW_AUTH_CIPHER_NONE);
                 if (ret)
@@ -940,7 +932,7 @@ static int add_wep_key(struct usbnet *usbdev, char *key, int key_len, int index)
 static int remove_key(struct usbnet *usbdev, int index, u8 bssid[ETH_ALEN])
 {
         struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
-        struct NDIS_802_11_REMOVE_KEY remove_key;
+        struct ndis_80211_remove_key remove_key;
         __le32 keyindex;
         int ret;
 
@@ -954,17 +946,17 @@ static int remove_key(struct usbnet *usbdev, int index, u8 bssid[ETH_ALEN])
             priv->wpa_cipher_pair == IW_AUTH_CIPHER_CCMP ||
             priv->wpa_cipher_group == IW_AUTH_CIPHER_TKIP ||
             priv->wpa_cipher_group == IW_AUTH_CIPHER_CCMP) {
-                remove_key.Length = cpu_to_le32(sizeof(remove_key));
-                remove_key.KeyIndex = cpu_to_le32(index);
+                remove_key.size = cpu_to_le32(sizeof(remove_key));
+                remove_key.index = cpu_to_le32(index);
                 if (bssid) {
                         /* pairwise key */
                         if (memcmp(bssid, ffff_bssid, ETH_ALEN) != 0)
-                                remove_key.KeyIndex |= cpu_to_le32(1 << 30);
-                        memcpy(remove_key.Bssid, bssid,
-                                        sizeof(remove_key.Bssid));
+                                remove_key.index |= cpu_to_le32(1 << 30);
+                        memcpy(remove_key.bssid, bssid,
+                                        sizeof(remove_key.bssid));
                 } else
-                        memset(remove_key.Bssid, 0xff,
-                                                sizeof(remove_key.Bssid));
+                        memset(remove_key.bssid, 0xff,
+                                                sizeof(remove_key.bssid));
 
                 ret = rndis_set_oid(usbdev, OID_802_11_REMOVE_KEY, &remove_key,
                                                         sizeof(remove_key));
@@ -1184,7 +1176,7 @@ static int rndis_iw_get_name(struct net_device *dev,
 static int rndis_iw_set_essid(struct net_device *dev,
     struct iw_request_info *info, union iwreq_data *wrqu, char *essid)
 {
-        struct NDIS_802_11_SSID ssid;
+        struct ndis_80211_ssid ssid;
         int length = wrqu->essid.length;
         struct usbnet *usbdev = dev->priv;
 
@@ -1194,11 +1186,11 @@ static int rndis_iw_set_essid(struct net_device *dev,
         if (length > NDIS_802_11_LENGTH_SSID)
                 length = NDIS_802_11_LENGTH_SSID;
 
-        ssid.SsidLength = cpu_to_le32(length);
+        ssid.length = cpu_to_le32(length);
         if (length > 0)
-                memcpy(ssid.Ssid, essid, length);
+                memcpy(ssid.essid, essid, length);
         else
-                memset(ssid.Ssid, 0, NDIS_802_11_LENGTH_SSID);
+                memset(ssid.essid, 0, NDIS_802_11_LENGTH_SSID);
 
         set_assoc_params(usbdev);
 
@@ -1212,16 +1204,16 @@ static int rndis_iw_set_essid(struct net_device *dev,
 static int rndis_iw_get_essid(struct net_device *dev,
     struct iw_request_info *info, union iwreq_data *wrqu, char *essid)
 {
-        struct NDIS_802_11_SSID ssid;
+        struct ndis_80211_ssid ssid;
         struct usbnet *usbdev = dev->priv;
         int ret;
 
         ret = get_essid(usbdev, &ssid);
 
-        if (ret == 0 && le32_to_cpu(ssid.SsidLength) > 0) {
+        if (ret == 0 && le32_to_cpu(ssid.length) > 0) {
                 wrqu->essid.flags = 1;
-                wrqu->essid.length = le32_to_cpu(ssid.SsidLength);
-                memcpy(essid, ssid.Ssid, wrqu->essid.length);
+                wrqu->essid.length = le32_to_cpu(ssid.length);
+                memcpy(essid, ssid.essid, wrqu->essid.length);
                 essid[wrqu->essid.length] = 0;
         } else {
                 memset(essid, 0, sizeof(NDIS_802_11_LENGTH_SSID));
@@ -1398,13 +1390,13 @@ static int rndis_iw_get_mode(struct net_device *dev,
         struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
 
         switch (priv->infra_mode) {
-        case Ndis802_11IBSS:
+        case ndis_80211_infra_adhoc:
                 wrqu->mode = IW_MODE_ADHOC;
                 break;
-        case Ndis802_11Infrastructure:
+        case ndis_80211_infra_infra:
                 wrqu->mode = IW_MODE_INFRA;
                 break;
-        /*case Ndis802_11AutoUnknown:*/
+        /*case ndis_80211_infra_auto_unknown:*/
         default:
                 wrqu->mode = IW_MODE_AUTO;
                 break;
@@ -1424,14 +1416,14 @@ static int rndis_iw_set_mode(struct net_device *dev,
 
         switch (wrqu->mode) {
         case IW_MODE_ADHOC:
-                mode = Ndis802_11IBSS;
+                mode = ndis_80211_infra_adhoc;
                 break;
         case IW_MODE_INFRA:
-                mode = Ndis802_11Infrastructure;
+                mode = ndis_80211_infra_infra;
                 break;
         /*case IW_MODE_AUTO:*/
         default:
-                mode = Ndis802_11AutoUnknown;
+                mode = ndis_80211_infra_auto_unknown;
                 break;
         }
 
@@ -1507,7 +1499,7 @@ static int rndis_iw_set_encode_ext(struct net_device *dev,
         struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
         struct usbnet *usbdev = dev->priv;
         struct rndis_wext_private *priv = get_rndis_wext_priv(usbdev);
-        struct NDIS_802_11_KEY ndis_key;
+        struct ndis_80211_key ndis_key;
         int keyidx, ret;
         u8 *addr;
 
@@ -1532,54 +1524,54 @@ static int rndis_iw_set_encode_ext(struct net_device *dev,
             ext->alg == IW_ENCODE_ALG_NONE || ext->key_len == 0)
                 return remove_key(usbdev, keyidx, NULL);
 
-        if (ext->key_len > sizeof(ndis_key.KeyMaterial))
+        if (ext->key_len > sizeof(ndis_key.material))
                 return -1;
 
         memset(&ndis_key, 0, sizeof(ndis_key));
 
-        ndis_key.Length = cpu_to_le32(sizeof(ndis_key) -
-                                sizeof(ndis_key.KeyMaterial) + ext->key_len);
-        ndis_key.KeyLength = cpu_to_le32(ext->key_len);
-        ndis_key.KeyIndex = cpu_to_le32(keyidx);
+        ndis_key.size = cpu_to_le32(sizeof(ndis_key) -
+                                sizeof(ndis_key.material) + ext->key_len);
+        ndis_key.length = cpu_to_le32(ext->key_len);
+        ndis_key.index = cpu_to_le32(keyidx);
 
         if (ext->ext_flags & IW_ENCODE_EXT_RX_SEQ_VALID) {
-                memcpy(ndis_key.KeyRSC, ext->rx_seq, 6);
-                ndis_key.KeyIndex |= cpu_to_le32(1 << 29);
+                memcpy(ndis_key.rsc, ext->rx_seq, 6);
+                ndis_key.index |= cpu_to_le32(1 << 29);
         }
 
         addr = ext->addr.sa_data;
         if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY) {
                 /* group key */
-                if (priv->infra_mode == Ndis802_11IBSS)
-                        memset(ndis_key.Bssid, 0xff, ETH_ALEN);
+                if (priv->infra_mode == ndis_80211_infra_adhoc)
+                        memset(ndis_key.bssid, 0xff, ETH_ALEN);
                 else
-                        get_bssid(usbdev, ndis_key.Bssid);
+                        get_bssid(usbdev, ndis_key.bssid);
         } else {
                 /* pairwise key */
-                ndis_key.KeyIndex |= cpu_to_le32(1 << 30);
-                memcpy(ndis_key.Bssid, addr, ETH_ALEN);
+                ndis_key.index |= cpu_to_le32(1 << 30);
+                memcpy(ndis_key.bssid, addr, ETH_ALEN);
         }
 
         if (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY)
-                ndis_key.KeyIndex |= cpu_to_le32(1 << 31);
+                ndis_key.index |= cpu_to_le32(1 << 31);
 
         if (ext->alg == IW_ENCODE_ALG_TKIP && ext->key_len == 32) {
                 /* wpa_supplicant gives us the Michael MIC RX/TX keys in
                  * different order than NDIS spec, so swap the order here. */
-                memcpy(ndis_key.KeyMaterial, ext->key, 16);
-                memcpy(ndis_key.KeyMaterial + 16, ext->key + 24, 8);
-                memcpy(ndis_key.KeyMaterial + 24, ext->key + 16, 8);
+                memcpy(ndis_key.material, ext->key, 16);
+                memcpy(ndis_key.material + 16, ext->key + 24, 8);
+                memcpy(ndis_key.material + 24, ext->key + 16, 8);
         } else
-                memcpy(ndis_key.KeyMaterial, ext->key, ext->key_len);
+                memcpy(ndis_key.material, ext->key, ext->key_len);
 
         ret = rndis_set_oid(usbdev, OID_802_11_ADD_KEY, &ndis_key,
-                                        le32_to_cpu(ndis_key.Length));
+                                        le32_to_cpu(ndis_key.size));
         devdbg(usbdev, "SIOCSIWENCODEEXT: OID_802_11_ADD_KEY -> %08X", ret);
         if (ret != 0)
                 return ret;
 
         priv->encr_key_len[keyidx] = ext->key_len;
-        memcpy(&priv->encr_keys[keyidx], ndis_key.KeyMaterial, ext->key_len);
+        memcpy(&priv->encr_keys[keyidx], ndis_key.material, ext->key_len);
         if (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY)
                 priv->encr_tx_key_index = keyidx;
 
@@ -1611,7 +1603,7 @@ static int rndis_iw_set_scan(struct net_device *dev,
 
 
 static char *rndis_translate_scan(struct net_device *dev,
-    char *cev, char *end_buf, struct NDIS_WLAN_BSSID_EX *bssid)
+    char *cev, char *end_buf, struct ndis_80211_bssid_ex *bssid)
 {
 #ifdef DEBUG
         struct usbnet *usbdev = dev->priv;
@@ -1624,60 +1616,55 @@ static char *rndis_translate_scan(struct net_device *dev,
         unsigned char sbuf[32];
         DECLARE_MAC_BUF(mac);
 
-        bssid_len = le32_to_cpu(bssid->Length);
+        bssid_len = le32_to_cpu(bssid->length);
 
-        devdbg(usbdev, "BSSID %s", print_mac(mac, bssid->MacAddress));
+        devdbg(usbdev, "BSSID %s", print_mac(mac, bssid->mac));
         iwe.cmd = SIOCGIWAP;
         iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
-        memcpy(iwe.u.ap_addr.sa_data, bssid->MacAddress, ETH_ALEN);
+        memcpy(iwe.u.ap_addr.sa_data, bssid->mac, ETH_ALEN);
         cev = iwe_stream_add_event(cev, end_buf, &iwe, IW_EV_ADDR_LEN);
 
-        devdbg(usbdev, "SSID(%d) %s",
-                le32_to_cpu(bssid->Ssid.SsidLength),
-                bssid->Ssid.Ssid);
+        devdbg(usbdev, "SSID(%d) %s", le32_to_cpu(bssid->ssid.length),
+                                                bssid->ssid.essid);
         iwe.cmd = SIOCGIWESSID;
-        iwe.u.essid.length = le32_to_cpu(bssid->Ssid.SsidLength);
+        iwe.u.essid.length = le32_to_cpu(bssid->ssid.length);
         iwe.u.essid.flags = 1;
-        cev = iwe_stream_add_point(cev, end_buf, &iwe,
-                                                bssid->Ssid.Ssid);
+        cev = iwe_stream_add_point(cev, end_buf, &iwe, bssid->ssid.essid);
 
-        devdbg(usbdev, "MODE %d",
-                        le32_to_cpu(bssid->InfrastructureMode));
+        devdbg(usbdev, "MODE %d", le32_to_cpu(bssid->net_infra));
         iwe.cmd = SIOCGIWMODE;
-        switch (le32_to_cpu(bssid->InfrastructureMode)) {
-        case Ndis802_11IBSS:
+        switch (le32_to_cpu(bssid->net_infra)) {
+        case ndis_80211_infra_adhoc:
                 iwe.u.mode = IW_MODE_ADHOC;
                 break;
-        case Ndis802_11Infrastructure:
+        case ndis_80211_infra_infra:
                 iwe.u.mode = IW_MODE_INFRA;
                 break;
-        /*case Ndis802_11AutoUnknown:*/
+        /*case ndis_80211_infra_auto_unknown:*/
         default:
                 iwe.u.mode = IW_MODE_AUTO;
                 break;
         }
         cev = iwe_stream_add_event(cev, end_buf, &iwe, IW_EV_UINT_LEN);
 
-        devdbg(usbdev, "FREQ %d kHz",
-                le32_to_cpu(bssid->Configuration.DSConfig));
+        devdbg(usbdev, "FREQ %d kHz", le32_to_cpu(bssid->config.ds_config));
         iwe.cmd = SIOCGIWFREQ;
-        dsconfig_to_freq(le32_to_cpu(bssid->Configuration.DSConfig),
-                                                                &iwe.u.freq);
+        dsconfig_to_freq(le32_to_cpu(bssid->config.ds_config), &iwe.u.freq);
         cev = iwe_stream_add_event(cev, end_buf, &iwe, IW_EV_FREQ_LEN);
 
-        devdbg(usbdev, "QUAL %d", le32_to_cpu(bssid->Rssi));
+        devdbg(usbdev, "QUAL %d", le32_to_cpu(bssid->rssi));
         iwe.cmd = IWEVQUAL;
-        iwe.u.qual.qual  = level_to_qual(le32_to_cpu(bssid->Rssi));
-        iwe.u.qual.level = le32_to_cpu(bssid->Rssi);
+        iwe.u.qual.qual  = level_to_qual(le32_to_cpu(bssid->rssi));
+        iwe.u.qual.level = le32_to_cpu(bssid->rssi);
         iwe.u.qual.updated = IW_QUAL_QUAL_UPDATED
                         | IW_QUAL_LEVEL_UPDATED
                         | IW_QUAL_NOISE_INVALID;
         cev = iwe_stream_add_event(cev, end_buf, &iwe, IW_EV_QUAL_LEN);
 
-        devdbg(usbdev, "ENCODE %d", le32_to_cpu(bssid->Privacy));
+        devdbg(usbdev, "ENCODE %d", le32_to_cpu(bssid->privacy));
         iwe.cmd = SIOCGIWENCODE;
         iwe.u.data.length = 0;
-        if (le32_to_cpu(bssid->Privacy) == Ndis802_11PrivFilterAcceptAll)
+        if (le32_to_cpu(bssid->privacy) == ndis_80211_priv_accept_all)
                 iwe.u.data.flags = IW_ENCODE_DISABLED;
         else
                 iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
@@ -1687,10 +1674,10 @@ static char *rndis_translate_scan(struct net_device *dev,
         devdbg(usbdev, "RATES:");
         current_val = cev + IW_EV_LCP_LEN;
         iwe.cmd = SIOCGIWRATE;
-        for (i = 0; i < sizeof(bssid->SupportedRates); i++) {
-                if (bssid->SupportedRates[i] & 0x7f) {
+        for (i = 0; i < sizeof(bssid->rates); i++) {
+                if (bssid->rates[i] & 0x7f) {
                         iwe.u.bitrate.value =
-                                ((bssid->SupportedRates[i] & 0x7f) *
+                                ((bssid->rates[i] & 0x7f) *
                                 500000);
                         devdbg(usbdev, " %d", iwe.u.bitrate.value);
                         current_val = iwe_stream_add_value(cev,
@@ -1702,24 +1689,24 @@ static char *rndis_translate_scan(struct net_device *dev,
         if ((current_val - cev) > IW_EV_LCP_LEN)
                 cev = current_val;
 
-        beacon = le32_to_cpu(bssid->Configuration.BeaconPeriod);
+        beacon = le32_to_cpu(bssid->config.beacon_period);
         devdbg(usbdev, "BCN_INT %d", beacon);
         iwe.cmd = IWEVCUSTOM;
         snprintf(sbuf, sizeof(sbuf), "bcn_int=%d", beacon);
         iwe.u.data.length = strlen(sbuf);
         cev = iwe_stream_add_point(cev, end_buf, &iwe, sbuf);
 
-        atim = le32_to_cpu(bssid->Configuration.ATIMWindow);
+        atim = le32_to_cpu(bssid->config.atim_window);
         devdbg(usbdev, "ATIM %d", atim);
         iwe.cmd = IWEVCUSTOM;
         snprintf(sbuf, sizeof(sbuf), "atim=%u", atim);
         iwe.u.data.length = strlen(sbuf);
         cev = iwe_stream_add_point(cev, end_buf, &iwe, sbuf);
 
-        ie = (void *)(bssid->IEs + sizeof(struct NDIS_802_11_FIXED_IEs));
+        ie = (void *)(bssid->ies + sizeof(struct ndis_80211_fixed_ies));
         ie_len = min(bssid_len - (int)sizeof(*bssid),
-                                        (int)le32_to_cpu(bssid->IELength));
-        ie_len -= sizeof(struct NDIS_802_11_FIXED_IEs);
+                                        (int)le32_to_cpu(bssid->ie_length));
+        ie_len -= sizeof(struct ndis_80211_fixed_ies);
         while (ie_len >= sizeof(*ie) && sizeof(*ie) + ie->len <= ie_len) {
                 if ((ie->id == MFIE_TYPE_GENERIC && ie->len >= 4 &&
                                 memcmp(ie->data, "\x00\x50\xf2\x01", 4) == 0) ||
@@ -1746,8 +1733,8 @@ static int rndis_iw_get_scan(struct net_device *dev,
         struct usbnet *usbdev = dev->priv;
         void *buf = NULL;
         char *cev = extra;
-        struct NDIS_802_11_BSSID_LIST_EX *bssid_list;
-        struct NDIS_WLAN_BSSID_EX *bssid;
+        struct ndis_80211_bssid_list_ex *bssid_list;
+        struct ndis_80211_bssid_ex *bssid;
         int ret = -EINVAL, len, count, bssid_len;
 
         devdbg(usbdev, "SIOCGIWSCAN");
@@ -1765,16 +1752,16 @@ static int rndis_iw_get_scan(struct net_device *dev,
                 goto out;
 
         bssid_list = buf;
-        bssid = bssid_list->Bssid;
-        bssid_len = le32_to_cpu(bssid->Length);
-        count = le32_to_cpu(bssid_list->NumberOfItems);
+        bssid = bssid_list->bssid;
+        bssid_len = le32_to_cpu(bssid->length);
+        count = le32_to_cpu(bssid_list->num_items);
         devdbg(usbdev, "SIOCGIWSCAN: %d BSSIDs found", count);
 
         while (count && ((void *)bssid + bssid_len) <= (buf + len)) {
                 cev = rndis_translate_scan(dev, cev, extra + IW_SCAN_MAX_DATA,
                                                                         bssid);
                 bssid = (void *)bssid + bssid_len;
-                bssid_len = le32_to_cpu(bssid->Length);
+                bssid_len = le32_to_cpu(bssid->length);
                 count--;
         }
 
@@ -1948,7 +1935,7 @@ static int rndis_iw_set_freq(struct net_device *dev,
     struct iw_request_info *info, union iwreq_data *wrqu, char *extra)
 {
         struct usbnet *usbdev = dev->priv;
-        struct NDIS_802_11_CONFIGURATION config;
+        struct ndis_80211_conf config;
         unsigned int dsconfig;
         int len, ret;
 
@@ -1967,7 +1954,7 @@ static int rndis_iw_set_freq(struct net_device *dev,
                 return 0;
         }
 
-        config.DSConfig = cpu_to_le32(dsconfig);
+        config.ds_config = cpu_to_le32(dsconfig);
 
         devdbg(usbdev, "SIOCSIWFREQ: %d * 10^%d", wrqu->freq.m, wrqu->freq.e);
         return rndis_set_oid(usbdev, OID_802_11_CONFIGURATION, &config,
@@ -1979,13 +1966,13 @@ static int rndis_iw_get_freq(struct net_device *dev,
     struct iw_request_info *info, union iwreq_data *wrqu, char *extra)
 {
         struct usbnet *usbdev = dev->priv;
-        struct NDIS_802_11_CONFIGURATION config;
+        struct ndis_80211_conf config;
         int len, ret;
 
         len = sizeof(config);
         ret = rndis_query_oid(usbdev, OID_802_11_CONFIGURATION, &config, &len);
         if (ret == 0)
-                dsconfig_to_freq(le32_to_cpu(config.DSConfig), &wrqu->freq);
+                dsconfig_to_freq(le32_to_cpu(config.ds_config), &wrqu->freq);
 
         devdbg(usbdev, "SIOCGIWFREQ: %d", wrqu->freq.m);
         return ret;
@@ -2266,14 +2253,14 @@ static int rndis_wext_get_caps(struct usbnet *dev)
                         n = 8;
                 for (i = 0; i < n; i++) {
                         switch (le32_to_cpu(networks_supported.items[i])) {
-                        case Ndis802_11FH:
-                        case Ndis802_11DS:
+                        case ndis_80211_type_freq_hop:
+                        case ndis_80211_type_direct_seq:
                                 priv->caps |= CAP_MODE_80211B;
                                 break;
-                        case Ndis802_11OFDM5:
+                        case ndis_80211_type_ofdm_a:
                                 priv->caps |= CAP_MODE_80211A;
                                 break;
-                        case Ndis802_11OFDM24:
+                        case ndis_80211_type_ofdm_g:
                                 priv->caps |= CAP_MODE_80211G;
                                 break;
                         }