← Back to branch summary

~ubuntu-branches/ubuntu/saucy/linux-ti-omap4/saucy-proposed

« back to all changes in this revision

Viewing changes to drivers/net/wireless/rndis_wlan.c

  • Committer: Package Import Robot
  • Author(s): Paolo Pisati, Paolo Pisati, Stefan Bader, Upstream Kernel Changes
  • Date: 2012-08-15 17:17:43 UTC
  • Revision ID: package-import@ubuntu.com-20120815171743-h5wnuf51xe7pvdid
Tags: 3.5.0-207.13
[ Paolo Pisati ]

* Start new release

[ Stefan Bader ]

* (config) Enable getabis to use local package copies

[ Upstream Kernel Changes ]

* fixup: gargabe collect iva_seq[0|1] init
* [Config] enable all SND_OMAP_SOC_*s
* fixup: cm2xxx_3xxx.o is needed for omap2_cm_read|write_reg
* fixup: add some snd_soc_dai* helper functions
* fixup: s/snd_soc_dpcm_params/snd_soc_dpcm/g
* fixup: typo, no_host_mode and useless SDP4430 init
* fixup: enable again aess hwmod

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/net/wireless/rndis_wlan.c
88
88
MODULE_PARM_DESC(workaround_interval,
89
89
        "set stall workaround interval in msecs (0=disabled) (default: 0)");
90
90
 
91
 
 
92
 
/* various RNDIS OID defs */
93
 
#define OID_GEN_LINK_SPEED                      cpu_to_le32(0x00010107)
94
 
#define OID_GEN_RNDIS_CONFIG_PARAMETER          cpu_to_le32(0x0001021b)
95
 
 
96
 
#define OID_GEN_XMIT_OK                         cpu_to_le32(0x00020101)
97
 
#define OID_GEN_RCV_OK                          cpu_to_le32(0x00020102)
98
 
#define OID_GEN_XMIT_ERROR                      cpu_to_le32(0x00020103)
99
 
#define OID_GEN_RCV_ERROR                       cpu_to_le32(0x00020104)
100
 
#define OID_GEN_RCV_NO_BUFFER                   cpu_to_le32(0x00020105)
101
 
 
102
 
#define OID_802_3_CURRENT_ADDRESS               cpu_to_le32(0x01010102)
103
 
#define OID_802_3_MULTICAST_LIST                cpu_to_le32(0x01010103)
104
 
#define OID_802_3_MAXIMUM_LIST_SIZE             cpu_to_le32(0x01010104)
105
 
 
106
 
#define OID_802_11_BSSID                        cpu_to_le32(0x0d010101)
107
 
#define OID_802_11_SSID                         cpu_to_le32(0x0d010102)
108
 
#define OID_802_11_INFRASTRUCTURE_MODE          cpu_to_le32(0x0d010108)
109
 
#define OID_802_11_ADD_WEP                      cpu_to_le32(0x0d010113)
110
 
#define OID_802_11_REMOVE_WEP                   cpu_to_le32(0x0d010114)
111
 
#define OID_802_11_DISASSOCIATE                 cpu_to_le32(0x0d010115)
112
 
#define OID_802_11_AUTHENTICATION_MODE          cpu_to_le32(0x0d010118)
113
 
#define OID_802_11_PRIVACY_FILTER               cpu_to_le32(0x0d010119)
114
 
#define OID_802_11_BSSID_LIST_SCAN              cpu_to_le32(0x0d01011a)
115
 
#define OID_802_11_ENCRYPTION_STATUS            cpu_to_le32(0x0d01011b)
116
 
#define OID_802_11_ADD_KEY                      cpu_to_le32(0x0d01011d)
117
 
#define OID_802_11_REMOVE_KEY                   cpu_to_le32(0x0d01011e)
118
 
#define OID_802_11_ASSOCIATION_INFORMATION      cpu_to_le32(0x0d01011f)
119
 
#define OID_802_11_CAPABILITY                   cpu_to_le32(0x0d010122)
120
 
#define OID_802_11_PMKID                        cpu_to_le32(0x0d010123)
121
 
#define OID_802_11_NETWORK_TYPES_SUPPORTED      cpu_to_le32(0x0d010203)
122
 
#define OID_802_11_NETWORK_TYPE_IN_USE          cpu_to_le32(0x0d010204)
123
 
#define OID_802_11_TX_POWER_LEVEL               cpu_to_le32(0x0d010205)
124
 
#define OID_802_11_RSSI                         cpu_to_le32(0x0d010206)
125
 
#define OID_802_11_RSSI_TRIGGER                 cpu_to_le32(0x0d010207)
126
 
#define OID_802_11_FRAGMENTATION_THRESHOLD      cpu_to_le32(0x0d010209)
127
 
#define OID_802_11_RTS_THRESHOLD                cpu_to_le32(0x0d01020a)
128
 
#define OID_802_11_SUPPORTED_RATES              cpu_to_le32(0x0d01020e)
129
 
#define OID_802_11_CONFIGURATION                cpu_to_le32(0x0d010211)
130
 
#define OID_802_11_POWER_MODE                   cpu_to_le32(0x0d010216)
131
 
#define OID_802_11_BSSID_LIST                   cpu_to_le32(0x0d010217)
132
 
 
133
 
 
134
91
/* Typical noise/maximum signal level values taken from ndiswrapper iw_ndis.h */
135
92
#define WL_NOISE        -96     /* typical noise level in dBm */
136
93
#define WL_SIGMAX       -32     /* typical maximum signal level in dBm */
149
106
#define BCM4320_DEFAULT_TXPOWER_DBM_50  10
150
107
#define BCM4320_DEFAULT_TXPOWER_DBM_25  7
151
108
 
152
 
 
153
 
/* codes for "status" field of completion messages */
154
 
#define RNDIS_STATUS_ADAPTER_NOT_READY          cpu_to_le32(0xc0010011)
155
 
#define RNDIS_STATUS_ADAPTER_NOT_OPEN           cpu_to_le32(0xc0010012)
156
 
 
157
 
 
158
109
/* Known device types */
159
110
#define RNDIS_UNKNOWN   0
160
111
#define RNDIS_BCM4320A  1
515
466
        int infra_mode;
516
467
        bool connected;
517
468
        u8 bssid[ETH_ALEN];
518
 
        __le32 current_command_oid;
 
469
        u32 current_command_oid;
519
470
 
520
471
        /* encryption stuff */
521
472
        u8 encr_tx_key_index;
554
505
 
555
506
static int rndis_leave_ibss(struct wiphy *wiphy, struct net_device *dev);
556
507
 
557
 
static int rndis_set_channel(struct wiphy *wiphy, struct net_device *dev,
558
 
        struct ieee80211_channel *chan, enum nl80211_channel_type channel_type);
559
 
 
560
508
static int rndis_add_key(struct wiphy *wiphy, struct net_device *netdev,
561
509
                         u8 key_index, bool pairwise, const u8 *mac_addr,
562
510
                         struct key_params *params);
598
546
        .disconnect = rndis_disconnect,
599
547
        .join_ibss = rndis_join_ibss,
600
548
        .leave_ibss = rndis_leave_ibss,
601
 
        .set_channel = rndis_set_channel,
602
549
        .add_key = rndis_add_key,
603
550
        .del_key = rndis_del_key,
604
551
        .set_default_key = rndis_set_default_key,
670
617
}
671
618
 
672
619
#ifdef DEBUG
673
 
static const char *oid_to_string(__le32 oid)
 
620
static const char *oid_to_string(u32 oid)
674
621
{
675
622
        switch (oid) {
676
623
#define OID_STR(oid) case oid: return(#oid)
677
624
                /* from rndis_host.h */
678
 
                OID_STR(OID_802_3_PERMANENT_ADDRESS);
679
 
                OID_STR(OID_GEN_MAXIMUM_FRAME_SIZE);
680
 
                OID_STR(OID_GEN_CURRENT_PACKET_FILTER);
681
 
                OID_STR(OID_GEN_PHYSICAL_MEDIUM);
 
625
                OID_STR(RNDIS_OID_802_3_PERMANENT_ADDRESS);
 
626
                OID_STR(RNDIS_OID_GEN_MAXIMUM_FRAME_SIZE);
 
627
                OID_STR(RNDIS_OID_GEN_CURRENT_PACKET_FILTER);
 
628
                OID_STR(RNDIS_OID_GEN_PHYSICAL_MEDIUM);
682
629
 
683
630
                /* from rndis_wlan.c */
684
 
                OID_STR(OID_GEN_LINK_SPEED);
685
 
                OID_STR(OID_GEN_RNDIS_CONFIG_PARAMETER);
686
 
 
687
 
                OID_STR(OID_GEN_XMIT_OK);
688
 
                OID_STR(OID_GEN_RCV_OK);
689
 
                OID_STR(OID_GEN_XMIT_ERROR);
690
 
                OID_STR(OID_GEN_RCV_ERROR);
691
 
                OID_STR(OID_GEN_RCV_NO_BUFFER);
692
 
 
693
 
                OID_STR(OID_802_3_CURRENT_ADDRESS);
694
 
                OID_STR(OID_802_3_MULTICAST_LIST);
695
 
                OID_STR(OID_802_3_MAXIMUM_LIST_SIZE);
696
 
 
697
 
                OID_STR(OID_802_11_BSSID);
698
 
                OID_STR(OID_802_11_SSID);
699
 
                OID_STR(OID_802_11_INFRASTRUCTURE_MODE);
700
 
                OID_STR(OID_802_11_ADD_WEP);
701
 
                OID_STR(OID_802_11_REMOVE_WEP);
702
 
                OID_STR(OID_802_11_DISASSOCIATE);
703
 
                OID_STR(OID_802_11_AUTHENTICATION_MODE);
704
 
                OID_STR(OID_802_11_PRIVACY_FILTER);
705
 
                OID_STR(OID_802_11_BSSID_LIST_SCAN);
706
 
                OID_STR(OID_802_11_ENCRYPTION_STATUS);
707
 
                OID_STR(OID_802_11_ADD_KEY);
708
 
                OID_STR(OID_802_11_REMOVE_KEY);
709
 
                OID_STR(OID_802_11_ASSOCIATION_INFORMATION);
710
 
                OID_STR(OID_802_11_CAPABILITY);
711
 
                OID_STR(OID_802_11_PMKID);
712
 
                OID_STR(OID_802_11_NETWORK_TYPES_SUPPORTED);
713
 
                OID_STR(OID_802_11_NETWORK_TYPE_IN_USE);
714
 
                OID_STR(OID_802_11_TX_POWER_LEVEL);
715
 
                OID_STR(OID_802_11_RSSI);
716
 
                OID_STR(OID_802_11_RSSI_TRIGGER);
717
 
                OID_STR(OID_802_11_FRAGMENTATION_THRESHOLD);
718
 
                OID_STR(OID_802_11_RTS_THRESHOLD);
719
 
                OID_STR(OID_802_11_SUPPORTED_RATES);
720
 
                OID_STR(OID_802_11_CONFIGURATION);
721
 
                OID_STR(OID_802_11_POWER_MODE);
722
 
                OID_STR(OID_802_11_BSSID_LIST);
 
631
                OID_STR(RNDIS_OID_GEN_LINK_SPEED);
 
632
                OID_STR(RNDIS_OID_GEN_RNDIS_CONFIG_PARAMETER);
 
633
 
 
634
                OID_STR(RNDIS_OID_GEN_XMIT_OK);
 
635
                OID_STR(RNDIS_OID_GEN_RCV_OK);
 
636
                OID_STR(RNDIS_OID_GEN_XMIT_ERROR);
 
637
                OID_STR(RNDIS_OID_GEN_RCV_ERROR);
 
638
                OID_STR(RNDIS_OID_GEN_RCV_NO_BUFFER);
 
639
 
 
640
                OID_STR(RNDIS_OID_802_3_CURRENT_ADDRESS);
 
641
                OID_STR(RNDIS_OID_802_3_MULTICAST_LIST);
 
642
                OID_STR(RNDIS_OID_802_3_MAXIMUM_LIST_SIZE);
 
643
 
 
644
                OID_STR(RNDIS_OID_802_11_BSSID);
 
645
                OID_STR(RNDIS_OID_802_11_SSID);
 
646
                OID_STR(RNDIS_OID_802_11_INFRASTRUCTURE_MODE);
 
647
                OID_STR(RNDIS_OID_802_11_ADD_WEP);
 
648
                OID_STR(RNDIS_OID_802_11_REMOVE_WEP);
 
649
                OID_STR(RNDIS_OID_802_11_DISASSOCIATE);
 
650
                OID_STR(RNDIS_OID_802_11_AUTHENTICATION_MODE);
 
651
                OID_STR(RNDIS_OID_802_11_PRIVACY_FILTER);
 
652
                OID_STR(RNDIS_OID_802_11_BSSID_LIST_SCAN);
 
653
                OID_STR(RNDIS_OID_802_11_ENCRYPTION_STATUS);
 
654
                OID_STR(RNDIS_OID_802_11_ADD_KEY);
 
655
                OID_STR(RNDIS_OID_802_11_REMOVE_KEY);
 
656
                OID_STR(RNDIS_OID_802_11_ASSOCIATION_INFORMATION);
 
657
                OID_STR(RNDIS_OID_802_11_CAPABILITY);
 
658
                OID_STR(RNDIS_OID_802_11_PMKID);
 
659
                OID_STR(RNDIS_OID_802_11_NETWORK_TYPES_SUPPORTED);
 
660
                OID_STR(RNDIS_OID_802_11_NETWORK_TYPE_IN_USE);
 
661
                OID_STR(RNDIS_OID_802_11_TX_POWER_LEVEL);
 
662
                OID_STR(RNDIS_OID_802_11_RSSI);
 
663
                OID_STR(RNDIS_OID_802_11_RSSI_TRIGGER);
 
664
                OID_STR(RNDIS_OID_802_11_FRAGMENTATION_THRESHOLD);
 
665
                OID_STR(RNDIS_OID_802_11_RTS_THRESHOLD);
 
666
                OID_STR(RNDIS_OID_802_11_SUPPORTED_RATES);
 
667
                OID_STR(RNDIS_OID_802_11_CONFIGURATION);
 
668
                OID_STR(RNDIS_OID_802_11_POWER_MODE);
 
669
                OID_STR(RNDIS_OID_802_11_BSSID_LIST);
723
670
#undef OID_STR
724
671
        }
725
672
 
726
673
        return "?";
727
674
}
728
675
#else
729
 
static const char *oid_to_string(__le32 oid)
 
676
static const char *oid_to_string(u32 oid)
730
677
{
731
678
        return "?";
732
679
}
736
683
static int rndis_error_status(__le32 rndis_status)
737
684
{
738
685
        int ret = -EINVAL;
739
 
        switch (rndis_status) {
 
686
        switch (le32_to_cpu(rndis_status)) {
740
687
        case RNDIS_STATUS_SUCCESS:
741
688
                ret = 0;
742
689
                break;
755
702
        return ret;
756
703
}
757
704
 
758
 
static int rndis_query_oid(struct usbnet *dev, __le32 oid, void *data, int *len)
 
705
static int rndis_query_oid(struct usbnet *dev, u32 oid, void *data, int *len)
759
706
{
760
707
        struct rndis_wlan_private *priv = get_rndis_wlan_priv(dev);
761
708
        union {
782
729
        mutex_lock(&priv->command_lock);
783
730
 
784
731
        memset(u.get, 0, sizeof *u.get);
785
 
        u.get->msg_type = RNDIS_MSG_QUERY;
 
732
        u.get->msg_type = cpu_to_le32(RNDIS_MSG_QUERY);
786
733
        u.get->msg_len = cpu_to_le32(sizeof *u.get);
787
 
        u.get->oid = oid;
 
734
        u.get->oid = cpu_to_le32(oid);
788
735
 
789
736
        priv->current_command_oid = oid;
790
737
        ret = rndis_command(dev, u.header, buflen);
839
786
        return ret;
840
787
}
841
788
 
842
 
static int rndis_set_oid(struct usbnet *dev, __le32 oid, const void *data,
 
789
static int rndis_set_oid(struct usbnet *dev, u32 oid, const void *data,
843
790
                         int len)
844
791
{
845
792
        struct rndis_wlan_private *priv = get_rndis_wlan_priv(dev);
866
813
        mutex_lock(&priv->command_lock);
867
814
 
868
815
        memset(u.set, 0, sizeof *u.set);
869
 
        u.set->msg_type = RNDIS_MSG_SET;
 
816
        u.set->msg_type = cpu_to_le32(RNDIS_MSG_SET);
870
817
        u.set->msg_len = cpu_to_le32(sizeof(*u.set) + len);
871
 
        u.set->oid = oid;
 
818
        u.set->oid = cpu_to_le32(oid);
872
819
        u.set->len = cpu_to_le32(len);
873
820
        u.set->offset = cpu_to_le32(sizeof(*u.set) - 8);
874
821
        u.set->handle = cpu_to_le32(0);
908
855
 
909
856
        reset = (void *)priv->command_buffer;
910
857
        memset(reset, 0, sizeof(*reset));
911
 
        reset->msg_type = RNDIS_MSG_RESET;
 
858
        reset->msg_type = cpu_to_le32(RNDIS_MSG_RESET);
912
859
        reset->msg_len = cpu_to_le32(sizeof(*reset));
913
860
        priv->current_command_oid = 0;
914
861
        ret = rndis_command(usbdev, (void *)reset, CONTROL_BUFFER_SIZE);
994
941
        }
995
942
#endif
996
943
 
997
 
        ret = rndis_set_oid(dev, OID_GEN_RNDIS_CONFIG_PARAMETER,
 
944
        ret = rndis_set_oid(dev, RNDIS_OID_GEN_RNDIS_CONFIG_PARAMETER,
998
945
                                                        infobuf, info_len);
999
946
        if (ret != 0)
1000
947
                netdev_dbg(dev->net, "setting rndis config parameter failed, %d\n",
1031
978
{
1032
979
        __le32 tmp;
1033
980
 
1034
 
        /* Note: OID_802_11_BSSID_LIST_SCAN clears internal BSS list. */
 
981
        /* Note: RNDIS_OID_802_11_BSSID_LIST_SCAN clears internal BSS list. */
1035
982
        tmp = cpu_to_le32(1);
1036
 
        return rndis_set_oid(usbdev, OID_802_11_BSSID_LIST_SCAN, &tmp,
 
983
        return rndis_set_oid(usbdev, RNDIS_OID_802_11_BSSID_LIST_SCAN, &tmp,
1037
984
                                                        sizeof(tmp));
1038
985
}
1039
986
 
1042
989
        struct rndis_wlan_private *priv = get_rndis_wlan_priv(usbdev);
1043
990
        int ret;
1044
991
 
1045
 
        ret = rndis_set_oid(usbdev, OID_802_11_SSID, ssid, sizeof(*ssid));
 
992
        ret = rndis_set_oid(usbdev, RNDIS_OID_802_11_SSID,
 
993
                            ssid, sizeof(*ssid));
1046
994
        if (ret < 0) {
1047
995
                netdev_warn(usbdev->net, "setting SSID failed (%08X)\n", ret);
1048
996
                return ret;
1059
1007
{
1060
1008
        int ret;
1061
1009
 
1062
 
        ret = rndis_set_oid(usbdev, OID_802_11_BSSID, bssid, ETH_ALEN);
 
1010
        ret = rndis_set_oid(usbdev, RNDIS_OID_802_11_BSSID,
 
1011
                            bssid, ETH_ALEN);
1063
1012
        if (ret < 0) {
1064
1013
                netdev_warn(usbdev->net, "setting BSSID[%pM] failed (%08X)\n",
1065
1014
                            bssid, ret);
1083
1032
        int ret, len;
1084
1033
 
1085
1034
        len = ETH_ALEN;
1086
 
        ret = rndis_query_oid(usbdev, OID_802_11_BSSID, bssid, &len);
 
1035
        ret = rndis_query_oid(usbdev, RNDIS_OID_802_11_BSSID,
 
1036
                              bssid, &len);
1087
1037
 
1088
1038
        if (ret != 0)
1089
1039
                memset(bssid, 0, ETH_ALEN);
1094
1044
static int get_association_info(struct usbnet *usbdev,
1095
1045
                        struct ndis_80211_assoc_info *info, int len)
1096
1046
{
1097
 
        return rndis_query_oid(usbdev, OID_802_11_ASSOCIATION_INFORMATION,
1098
 
                                info, &len);
 
1047
        return rndis_query_oid(usbdev,
 
1048
                        RNDIS_OID_802_11_ASSOCIATION_INFORMATION,
 
1049
                        info, &len);
1099
1050
}
1100
1051
 
1101
1052
static bool is_associated(struct usbnet *usbdev)
1119
1070
        int i, ret = 0;
1120
1071
 
1121
1072
        if (priv->radio_on) {
1122
 
                ret = rndis_set_oid(usbdev, OID_802_11_DISASSOCIATE, NULL, 0);
 
1073
                ret = rndis_set_oid(usbdev,
 
1074
                                RNDIS_OID_802_11_DISASSOCIATE,
 
1075
                                NULL, 0);
1123
1076
                if (ret == 0) {
1124
1077
                        priv->radio_on = false;
1125
1078
                        netdev_dbg(usbdev->net, "%s(): radio_on = false\n",
1181
1134
                return -ENOTSUPP;
1182
1135
 
1183
1136
        tmp = cpu_to_le32(auth_mode);
1184
 
        ret = rndis_set_oid(usbdev, OID_802_11_AUTHENTICATION_MODE, &tmp,
1185
 
                                                                sizeof(tmp));
 
1137
        ret = rndis_set_oid(usbdev,
 
1138
                            RNDIS_OID_802_11_AUTHENTICATION_MODE,
 
1139
                            &tmp, sizeof(tmp));
1186
1140
        if (ret != 0) {
1187
1141
                netdev_warn(usbdev->net, "setting auth mode failed (%08X)\n",
1188
1142
                            ret);
1208
1162
        else
1209
1163
                tmp = cpu_to_le32(NDIS_80211_PRIV_ACCEPT_ALL);
1210
1164
 
1211
 
        return rndis_set_oid(usbdev, OID_802_11_PRIVACY_FILTER, &tmp,
1212
 
                                                                sizeof(tmp));
 
1165
        return rndis_set_oid(usbdev,
 
1166
                             RNDIS_OID_802_11_PRIVACY_FILTER, &tmp,
 
1167
                             sizeof(tmp));
1213
1168
}
1214
1169
 
1215
1170
static int set_encr_mode(struct usbnet *usbdev, int pairwise, int groupwise)
1234
1189
                encr_mode = NDIS_80211_ENCR_DISABLED;
1235
1190
 
1236
1191
        tmp = cpu_to_le32(encr_mode);
1237
 
        ret = rndis_set_oid(usbdev, OID_802_11_ENCRYPTION_STATUS, &tmp,
1238
 
                                                                sizeof(tmp));
 
1192
        ret = rndis_set_oid(usbdev,
 
1193
                        RNDIS_OID_802_11_ENCRYPTION_STATUS, &tmp,
 
1194
                        sizeof(tmp));
1239
1195
        if (ret != 0) {
1240
1196
                netdev_warn(usbdev->net, "setting encr mode failed (%08X)\n",
1241
1197
                            ret);
1255
1211
                   __func__, priv->infra_mode);
1256
1212
 
1257
1213
        tmp = cpu_to_le32(mode);
1258
 
        ret = rndis_set_oid(usbdev, OID_802_11_INFRASTRUCTURE_MODE, &tmp,
1259
 
                                                                sizeof(tmp));
 
1214
        ret = rndis_set_oid(usbdev,
 
1215
                            RNDIS_OID_802_11_INFRASTRUCTURE_MODE,
 
1216
                            &tmp, sizeof(tmp));
1260
1217
        if (ret != 0) {
1261
1218
                netdev_warn(usbdev->net, "setting infra mode failed (%08X)\n",
1262
1219
                            ret);
1282
1239
                rts_threshold = 2347;
1283
1240
 
1284
1241
        tmp = cpu_to_le32(rts_threshold);
1285
 
        return rndis_set_oid(usbdev, OID_802_11_RTS_THRESHOLD, &tmp,
1286
 
                                                                sizeof(tmp));
 
1242
        return rndis_set_oid(usbdev,
 
1243
                             RNDIS_OID_802_11_RTS_THRESHOLD,
 
1244
                             &tmp, sizeof(tmp));
1287
1245
}
1288
1246
 
1289
1247
static int set_frag_threshold(struct usbnet *usbdev, u32 frag_threshold)
1296
1254
                frag_threshold = 2346;
1297
1255
 
1298
1256
        tmp = cpu_to_le32(frag_threshold);
1299
 
        return rndis_set_oid(usbdev, OID_802_11_FRAGMENTATION_THRESHOLD, &tmp,
1300
 
                                                                sizeof(tmp));
 
1257
        return rndis_set_oid(usbdev,
 
1258
                        RNDIS_OID_802_11_FRAGMENTATION_THRESHOLD,
 
1259
                        &tmp, sizeof(tmp));
1301
1260
}
1302
1261
 
1303
1262
static void set_default_iw_params(struct usbnet *usbdev)
1333
1292
        dsconfig = ieee80211_dsss_chan_to_freq(channel) * 1000;
1334
1293
 
1335
1294
        len = sizeof(config);
1336
 
        ret = rndis_query_oid(usbdev, OID_802_11_CONFIGURATION, &config, &len);
 
1295
        ret = rndis_query_oid(usbdev,
 
1296
                        RNDIS_OID_802_11_CONFIGURATION,
 
1297
                        &config, &len);
1337
1298
        if (ret < 0) {
1338
1299
                netdev_dbg(usbdev->net, "%s(): querying configuration failed\n",
1339
1300
                           __func__);
1341
1302
        }
1342
1303
 
1343
1304
        config.ds_config = cpu_to_le32(dsconfig);
1344
 
        ret = rndis_set_oid(usbdev, OID_802_11_CONFIGURATION, &config,
1345
 
                                                                sizeof(config));
 
1305
        ret = rndis_set_oid(usbdev,
 
1306
                        RNDIS_OID_802_11_CONFIGURATION,
 
1307
                        &config, sizeof(config));
1346
1308
 
1347
1309
        netdev_dbg(usbdev->net, "%s(): %d -> %d\n", __func__, channel, ret);
1348
1310
 
1359
1321
 
1360
1322
        /* Get channel and beacon interval */
1361
1323
        len = sizeof(config);
1362
 
        ret = rndis_query_oid(usbdev, OID_802_11_CONFIGURATION, &config, &len);
1363
 
        netdev_dbg(usbdev->net, "%s(): OID_802_11_CONFIGURATION -> %d\n",
 
1324
        ret = rndis_query_oid(usbdev,
 
1325
                        RNDIS_OID_802_11_CONFIGURATION,
 
1326
                        &config, &len);
 
1327
        netdev_dbg(usbdev->net, "%s(): RNDIS_OID_802_11_CONFIGURATION -> %d\n",
1364
1328
                                __func__, ret);
1365
1329
        if (ret < 0)
1366
1330
                return NULL;
1413
1377
                                    ret);
1414
1378
        }
1415
1379
 
1416
 
        ret = rndis_set_oid(usbdev, OID_802_11_ADD_WEP, &ndis_key,
1417
 
                                                        sizeof(ndis_key));
 
1380
        ret = rndis_set_oid(usbdev,
 
1381
                        RNDIS_OID_802_11_ADD_WEP, &ndis_key,
 
1382
                        sizeof(ndis_key));
1418
1383
        if (ret != 0) {
1419
1384
                netdev_warn(usbdev->net, "adding encryption key %d failed (%08X)\n",
1420
1385
                            index + 1, ret);
1504
1469
                        get_bssid(usbdev, ndis_key.bssid);
1505
1470
        }
1506
1471
 
1507
 
        ret = rndis_set_oid(usbdev, OID_802_11_ADD_KEY, &ndis_key,
1508
 
                                        le32_to_cpu(ndis_key.size));
1509
 
        netdev_dbg(usbdev->net, "%s(): OID_802_11_ADD_KEY -> %08X\n",
 
1472
        ret = rndis_set_oid(usbdev,
 
1473
                        RNDIS_OID_802_11_ADD_KEY, &ndis_key,
 
1474
                        le32_to_cpu(ndis_key.size));
 
1475
        netdev_dbg(usbdev->net, "%s(): RNDIS_OID_802_11_ADD_KEY -> %08X\n",
1510
1476
                   __func__, ret);
1511
1477
        if (ret != 0)
1512
1478
                return ret;
1594
1560
                        memset(remove_key.bssid, 0xff,
1595
1561
                                                sizeof(remove_key.bssid));
1596
1562
 
1597
 
                ret = rndis_set_oid(usbdev, OID_802_11_REMOVE_KEY, &remove_key,
1598
 
                                                        sizeof(remove_key));
 
1563
                ret = rndis_set_oid(usbdev,
 
1564
                                RNDIS_OID_802_11_REMOVE_KEY,
 
1565
                                &remove_key, sizeof(remove_key));
1599
1566
                if (ret != 0)
1600
1567
                        return ret;
1601
1568
        } else {
1602
1569
                keyindex = cpu_to_le32(index);
1603
 
                ret = rndis_set_oid(usbdev, OID_802_11_REMOVE_WEP, &keyindex,
1604
 
                                                        sizeof(keyindex));
 
1570
                ret = rndis_set_oid(usbdev,
 
1571
                                RNDIS_OID_802_11_REMOVE_WEP,
 
1572
                                &keyindex, sizeof(keyindex));
1605
1573
                if (ret != 0) {
1606
1574
                        netdev_warn(usbdev->net,
1607
1575
                                    "removing encryption key %d failed (%08X)\n",
1626
1594
        char *mc_addrs = NULL;
1627
1595
        int mc_count;
1628
1596
 
1629
 
        basefilter = filter = RNDIS_PACKET_TYPE_DIRECTED |
1630
 
                              RNDIS_PACKET_TYPE_BROADCAST;
 
1597
        basefilter = filter = cpu_to_le32(RNDIS_PACKET_TYPE_DIRECTED |
 
1598
                                          RNDIS_PACKET_TYPE_BROADCAST);
1631
1599
 
1632
1600
        if (usbdev->net->flags & IFF_PROMISC) {
1633
 
                filter |= RNDIS_PACKET_TYPE_PROMISCUOUS |
1634
 
                        RNDIS_PACKET_TYPE_ALL_LOCAL;
 
1601
                filter |= cpu_to_le32(RNDIS_PACKET_TYPE_PROMISCUOUS |
 
1602
                                      RNDIS_PACKET_TYPE_ALL_LOCAL);
1635
1603
        } else if (usbdev->net->flags & IFF_ALLMULTI) {
1636
 
                filter |= RNDIS_PACKET_TYPE_ALL_MULTICAST;
 
1604
                filter |= cpu_to_le32(RNDIS_PACKET_TYPE_ALL_MULTICAST);
1637
1605
        }
1638
1606
 
1639
1607
        if (filter != basefilter)
1646
1614
        netif_addr_lock_bh(usbdev->net);
1647
1615
        mc_count = netdev_mc_count(usbdev->net);
1648
1616
        if (mc_count > priv->multicast_size) {
1649
 
                filter |= RNDIS_PACKET_TYPE_ALL_MULTICAST;
 
1617
                filter |= cpu_to_le32(RNDIS_PACKET_TYPE_ALL_MULTICAST);
1650
1618
        } else if (mc_count) {
1651
1619
                int i = 0;
1652
1620
 
1669
1637
                goto set_filter;
1670
1638
 
1671
1639
        if (mc_count) {
1672
 
                ret = rndis_set_oid(usbdev, OID_802_3_MULTICAST_LIST, mc_addrs,
1673
 
                                    mc_count * ETH_ALEN);
 
1640
                ret = rndis_set_oid(usbdev,
 
1641
                                RNDIS_OID_802_3_MULTICAST_LIST,
 
1642
                                mc_addrs, mc_count * ETH_ALEN);
1674
1643
                kfree(mc_addrs);
1675
1644
                if (ret == 0)
1676
 
                        filter |= RNDIS_PACKET_TYPE_MULTICAST;
 
1645
                        filter |= cpu_to_le32(RNDIS_PACKET_TYPE_MULTICAST);
1677
1646
                else
1678
 
                        filter |= RNDIS_PACKET_TYPE_ALL_MULTICAST;
 
1647
                        filter |= cpu_to_le32(RNDIS_PACKET_TYPE_ALL_MULTICAST);
1679
1648
 
1680
 
                netdev_dbg(usbdev->net, "OID_802_3_MULTICAST_LIST(%d, max: %d) -> %d\n",
 
1649
                netdev_dbg(usbdev->net, "RNDIS_OID_802_3_MULTICAST_LIST(%d, max: %d) -> %d\n",
1681
1650
                           mc_count, priv->multicast_size, ret);
1682
1651
        }
1683
1652
 
1684
1653
set_filter:
1685
 
        ret = rndis_set_oid(usbdev, OID_GEN_CURRENT_PACKET_FILTER, &filter,
 
1654
        ret = rndis_set_oid(usbdev, RNDIS_OID_GEN_CURRENT_PACKET_FILTER, &filter,
1686
1655
                                                        sizeof(filter));
1687
1656
        if (ret < 0) {
1688
1657
                netdev_warn(usbdev->net, "couldn't set packet filter: %08x\n",
1689
1658
                            le32_to_cpu(filter));
1690
1659
        }
1691
1660
 
1692
 
        netdev_dbg(usbdev->net, "OID_GEN_CURRENT_PACKET_FILTER(%08x) -> %d\n",
 
1661
        netdev_dbg(usbdev->net, "RNDIS_OID_GEN_CURRENT_PACKET_FILTER(%08x) -> %d\n",
1693
1662
                   le32_to_cpu(filter), ret);
1694
1663
}
1695
1664
 
1748
1717
        pmkids->length = cpu_to_le32(len);
1749
1718
        pmkids->bssid_info_count = cpu_to_le32(max_pmkids);
1750
1719
 
1751
 
        ret = rndis_query_oid(usbdev, OID_802_11_PMKID, pmkids, &len);
 
1720
        ret = rndis_query_oid(usbdev, RNDIS_OID_802_11_PMKID,
 
1721
                        pmkids, &len);
1752
1722
        if (ret < 0) {
1753
 
                netdev_dbg(usbdev->net, "%s(): OID_802_11_PMKID(%d, %d)"
 
1723
                netdev_dbg(usbdev->net, "%s(): RNDIS_OID_802_11_PMKID(%d, %d)"
1754
1724
                                " -> %d\n", __func__, len, max_pmkids, ret);
1755
1725
 
1756
1726
                kfree(pmkids);
1776
1746
 
1777
1747
        debug_print_pmkids(usbdev, pmkids, __func__);
1778
1748
 
1779
 
        ret = rndis_set_oid(usbdev, OID_802_11_PMKID, pmkids,
1780
 
                                                le32_to_cpu(pmkids->length));
 
1749
        ret = rndis_set_oid(usbdev, RNDIS_OID_802_11_PMKID, pmkids,
 
1750
                            le32_to_cpu(pmkids->length));
1781
1751
        if (ret < 0) {
1782
 
                netdev_dbg(usbdev->net, "%s(): OID_802_11_PMKID(%d, %d) -> %d"
 
1752
                netdev_dbg(usbdev->net, "%s(): RNDIS_OID_802_11_PMKID(%d, %d) -> %d"
1783
1753
                                "\n", __func__, len, num_pmkids, ret);
1784
1754
        }
1785
1755
 
1801
1771
                count = max_pmkids;
1802
1772
 
1803
1773
        for (i = 0; i < count; i++)
1804
 
                if (!compare_ether_addr(pmkids->bssid_info[i].bssid,
1805
 
                                                        pmksa->bssid))
 
1774
                if (ether_addr_equal(pmkids->bssid_info[i].bssid,
 
1775
                                     pmksa->bssid))
1806
1776
                        break;
1807
1777
 
1808
1778
        /* pmkid not found */
1843
1813
 
1844
1814
        /* update with new pmkid */
1845
1815
        for (i = 0; i < count; i++) {
1846
 
                if (compare_ether_addr(pmkids->bssid_info[i].bssid,
1847
 
                                                        pmksa->bssid))
 
1816
                if (!ether_addr_equal(pmkids->bssid_info[i].bssid,
 
1817
                                      pmksa->bssid))
1848
1818
                        continue;
1849
1819
 
1850
1820
                memcpy(pmkids->bssid_info[i].pmkid, pmksa->pmkid,
2113
2083
         * resizing until it won't get any bigger.
2114
2084
         */
2115
2085
        new_len = len;
2116
 
        ret = rndis_query_oid(usbdev, OID_802_11_BSSID_LIST, buf, &new_len);
 
2086
        ret = rndis_query_oid(usbdev, RNDIS_OID_802_11_BSSID_LIST,
 
2087
                              buf, &new_len);
2117
2088
        if (ret != 0 || new_len < sizeof(struct ndis_80211_bssid_list_ex))
2118
2089
                goto out;
2119
2090
 
2139
2110
        while (check_bssid_list_item(bssid, bssid_len, buf, len)) {
2140
2111
                if (rndis_bss_info_update(usbdev, bssid) && match_bssid &&
2141
2112
                    matched) {
2142
 
                        if (compare_ether_addr(bssid->mac, match_bssid))
 
2113
                        if (ether_addr_equal(bssid->mac, match_bssid))
2143
2114
                                *matched = true;
2144
2115
                }
2145
2116
 
2423
2394
        return deauthenticate(usbdev);
2424
2395
}
2425
2396
 
2426
 
static int rndis_set_channel(struct wiphy *wiphy, struct net_device *netdev,
2427
 
        struct ieee80211_channel *chan, enum nl80211_channel_type channel_type)
2428
 
{
2429
 
        struct rndis_wlan_private *priv = wiphy_priv(wiphy);
2430
 
        struct usbnet *usbdev = priv->usbdev;
2431
 
 
2432
 
        return set_channel(usbdev,
2433
 
                        ieee80211_frequency_to_channel(chan->center_freq));
2434
 
}
2435
 
 
2436
2397
static int rndis_add_key(struct wiphy *wiphy, struct net_device *netdev,
2437
2398
                         u8 key_index, bool pairwise, const u8 *mac_addr,
2438
2399
                         struct key_params *params)
2511
2472
        memset(sinfo, 0, sizeof(*sinfo));
2512
2473
 
2513
2474
        len = sizeof(linkspeed);
2514
 
        ret = rndis_query_oid(usbdev, OID_GEN_LINK_SPEED, &linkspeed, &len);
 
2475
        ret = rndis_query_oid(usbdev, RNDIS_OID_GEN_LINK_SPEED, &linkspeed, &len);
2515
2476
        if (ret == 0) {
2516
2477
                sinfo->txrate.legacy = le32_to_cpu(linkspeed) / 1000;
2517
2478
                sinfo->filled |= STATION_INFO_TX_BITRATE;
2518
2479
        }
2519
2480
 
2520
2481
        len = sizeof(rssi);
2521
 
        ret = rndis_query_oid(usbdev, OID_802_11_RSSI, &rssi, &len);
 
2482
        ret = rndis_query_oid(usbdev, RNDIS_OID_802_11_RSSI,
 
2483
                              &rssi, &len);
2522
2484
        if (ret == 0) {
2523
2485
                sinfo->signal = level_to_qual(le32_to_cpu(rssi));
2524
2486
                sinfo->filled |= STATION_INFO_SIGNAL;
2531
2493
        struct rndis_wlan_private *priv = wiphy_priv(wiphy);
2532
2494
        struct usbnet *usbdev = priv->usbdev;
2533
2495
 
2534
 
        if (compare_ether_addr(priv->bssid, mac))
 
2496
        if (!ether_addr_equal(priv->bssid, mac))
2535
2497
                return -ENOENT;
2536
2498
 
2537
2499
        rndis_fill_station_info(usbdev, sinfo);
2624
2586
        pmkid.length = cpu_to_le32(sizeof(pmkid));
2625
2587
        pmkid.bssid_info_count = cpu_to_le32(0);
2626
2588
 
2627
 
        return rndis_set_oid(usbdev, OID_802_11_PMKID, &pmkid, sizeof(pmkid));
 
2589
        return rndis_set_oid(usbdev, RNDIS_OID_802_11_PMKID,
 
2590
                             &pmkid, sizeof(pmkid));
2628
2591
}
2629
2592
 
2630
2593
static int rndis_set_power_mgmt(struct wiphy *wiphy, struct net_device *dev,
2654
2617
        priv->power_mode = power_mode;
2655
2618
 
2656
2619
        mode = cpu_to_le32(power_mode);
2657
 
        ret = rndis_set_oid(usbdev, OID_802_11_POWER_MODE, &mode, sizeof(mode));
 
2620
        ret = rndis_set_oid(usbdev, RNDIS_OID_802_11_POWER_MODE,
 
2621
                            &mode, sizeof(mode));
2658
2622
 
2659
 
        netdev_dbg(usbdev->net, "%s(): OID_802_11_POWER_MODE -> %d\n",
 
2623
        netdev_dbg(usbdev->net, "%s(): RNDIS_OID_802_11_POWER_MODE -> %d\n",
2660
2624
                                __func__, ret);
2661
2625
 
2662
2626
        return ret;
2693
2657
        /* Get signal quality, in case of error use rssi=0 and ignore error. */
2694
2658
        len = sizeof(rssi);
2695
2659
        rssi = 0;
2696
 
        ret = rndis_query_oid(usbdev, OID_802_11_RSSI, &rssi, &len);
 
2660
        ret = rndis_query_oid(usbdev, RNDIS_OID_802_11_RSSI,
 
2661
                              &rssi, &len);
2697
2662
        signal = level_to_qual(le32_to_cpu(rssi));
2698
2663
 
2699
 
        netdev_dbg(usbdev->net, "%s(): OID_802_11_RSSI -> %d, "
 
2664
        netdev_dbg(usbdev->net, "%s(): RNDIS_OID_802_11_RSSI -> %d, "
2700
2665
                   "rssi:%d, qual: %d\n", __func__, ret, le32_to_cpu(rssi),
2701
2666
                   level_to_qual(le32_to_cpu(rssi)));
2702
2667
 
2720
2685
        /* Get SSID, in case of error, use zero length SSID and ignore error. */
2721
2686
        len = sizeof(ssid);
2722
2687
        memset(&ssid, 0, sizeof(ssid));
2723
 
        ret = rndis_query_oid(usbdev, OID_802_11_SSID, &ssid, &len);
2724
 
        netdev_dbg(usbdev->net, "%s(): OID_802_11_SSID -> %d, len: %d, ssid: "
 
2688
        ret = rndis_query_oid(usbdev, RNDIS_OID_802_11_SSID,
 
2689
                              &ssid, &len);
 
2690
        netdev_dbg(usbdev->net, "%s(): RNDIS_OID_802_11_SSID -> %d, len: %d, ssid: "
2725
2691
                                "'%.32s'\n", __func__, ret,
2726
2692
                                le32_to_cpu(ssid.length), ssid.essid);
2727
2693
 
2843
2809
         * NDIS spec says: "If the device is associated, but the associated
2844
2810
         *  BSSID is not in its BSSID scan list, then the driver must add an
2845
2811
         *  entry for the BSSID at the end of the data that it returns in
2846
 
         *  response to query of OID_802_11_BSSID_LIST."
 
2812
         *  response to query of RNDIS_OID_802_11_BSSID_LIST."
2847
2813
         *
2848
2814
         * NOTE: Seems to be true for BCM4320b variant, but not BCM4320a.
2849
2815
         */
3095
3061
        struct rndis_wlan_private *priv = get_rndis_wlan_priv(usbdev);
3096
3062
        struct rndis_indicate *msg = ind;
3097
3063
 
3098
 
        switch (msg->status) {
 
3064
        switch (le32_to_cpu(msg->status)) {
3099
3065
        case RNDIS_STATUS_MEDIA_CONNECT:
3100
 
                if (priv->current_command_oid == OID_802_11_ADD_KEY) {
3101
 
                        /* OID_802_11_ADD_KEY causes sometimes extra
 
3066
                if (priv->current_command_oid == RNDIS_OID_802_11_ADD_KEY) {
 
3067
                        /* RNDIS_OID_802_11_ADD_KEY causes sometimes extra
3102
3068
                         * "media connect" indications which confuses driver
3103
3069
                         * and userspace to think that device is
3104
3070
                         * roaming/reassociating when it isn't.
3105
3071
                         */
3106
 
                        netdev_dbg(usbdev->net, "ignored OID_802_11_ADD_KEY triggered 'media connect'\n");
 
3072
                        netdev_dbg(usbdev->net, "ignored RNDIS_OID_802_11_ADD_KEY triggered 'media connect'\n");
3107
3073
                        return;
3108
3074
                }
3109
3075
 
3148
3114
 
3149
3115
        /* determine supported modes */
3150
3116
        len = sizeof(networks_supported);
3151
 
        retval = rndis_query_oid(usbdev, OID_802_11_NETWORK_TYPES_SUPPORTED,
3152
 
                                                &networks_supported, &len);
 
3117
        retval = rndis_query_oid(usbdev,
 
3118
                                 RNDIS_OID_802_11_NETWORK_TYPES_SUPPORTED,
 
3119
                                 &networks_supported, &len);
3153
3120
        if (retval >= 0) {
3154
3121
                n = le32_to_cpu(networks_supported.num_items);
3155
3122
                if (n > 8)
3173
3140
        /* get device 802.11 capabilities, number of PMKIDs */
3174
3141
        caps = (struct ndis_80211_capability *)caps_buf;
3175
3142
        len = sizeof(caps_buf);
3176
 
        retval = rndis_query_oid(usbdev, OID_802_11_CAPABILITY, caps, &len);
 
3143
        retval = rndis_query_oid(usbdev,
 
3144
                                 RNDIS_OID_802_11_CAPABILITY,
 
3145
                                 caps, &len);
3177
3146
        if (retval >= 0) {
3178
 
                netdev_dbg(usbdev->net, "OID_802_11_CAPABILITY -> len %d, "
 
3147
                netdev_dbg(usbdev->net, "RNDIS_OID_802_11_CAPABILITY -> len %d, "
3179
3148
                                "ver %d, pmkids %d, auth-encr-pairs %d\n",
3180
3149
                                le32_to_cpu(caps->length),
3181
3150
                                le32_to_cpu(caps->version),
3247
3216
        }
3248
3217
 
3249
3218
        len = sizeof(rssi);
3250
 
        ret = rndis_query_oid(usbdev, OID_802_11_RSSI, &rssi, &len);
 
3219
        ret = rndis_query_oid(usbdev, RNDIS_OID_802_11_RSSI,
 
3220
                              &rssi, &len);
3251
3221
        if (ret == 0) {
3252
3222
                priv->last_qual = level_to_qual(le32_to_cpu(rssi));
3253
3223
                rndis_do_cqm(usbdev, le32_to_cpu(rssi));
3254
3224
        }
3255
3225
 
3256
 
        netdev_dbg(usbdev->net, "dev-poller: OID_802_11_RSSI -> %d, rssi:%d, qual: %d\n",
 
3226
        netdev_dbg(usbdev->net, "dev-poller: RNDIS_OID_802_11_RSSI -> %d, rssi:%d, qual: %d\n",
3257
3227
                   ret, le32_to_cpu(rssi), level_to_qual(le32_to_cpu(rssi)));
3258
3228
 
3259
3229
        /* Workaround transfer stalls on poor quality links.
3275
3245
                 * working.
3276
3246
                 */
3277
3247
                tmp = cpu_to_le32(1);
3278
 
                rndis_set_oid(usbdev, OID_802_11_BSSID_LIST_SCAN, &tmp,
3279
 
                                                                sizeof(tmp));
 
3248
                rndis_set_oid(usbdev,
 
3249
                              RNDIS_OID_802_11_BSSID_LIST_SCAN,
 
3250
                              &tmp, sizeof(tmp));
3280
3251
 
3281
3252
                len = CONTROL_BUFFER_SIZE;
3282
3253
                buf = kmalloc(len, GFP_KERNEL);
3283
3254
                if (!buf)
3284
3255
                        goto end;
3285
3256
 
3286
 
                rndis_query_oid(usbdev, OID_802_11_BSSID_LIST, buf, &len);
 
3257
                rndis_query_oid(usbdev,
 
3258
                                RNDIS_OID_802_11_BSSID_LIST,
 
3259
                                buf, &len);
3287
3260
                kfree(buf);
3288
3261
        }
3289
3262
 
3465
3438
         */
3466
3439
        usbdev->net->netdev_ops = &rndis_wlan_netdev_ops;
3467
3440
 
3468
 
        tmp = RNDIS_PACKET_TYPE_DIRECTED | RNDIS_PACKET_TYPE_BROADCAST;
3469
 
        retval = rndis_set_oid(usbdev, OID_GEN_CURRENT_PACKET_FILTER, &tmp,
3470
 
                                                                sizeof(tmp));
 
3441
        tmp = cpu_to_le32(RNDIS_PACKET_TYPE_DIRECTED | RNDIS_PACKET_TYPE_BROADCAST);
 
3442
        retval = rndis_set_oid(usbdev,
 
3443
                               RNDIS_OID_GEN_CURRENT_PACKET_FILTER,
 
3444
                               &tmp, sizeof(tmp));
3471
3445
 
3472
3446
        len = sizeof(tmp);
3473
 
        retval = rndis_query_oid(usbdev, OID_802_3_MAXIMUM_LIST_SIZE, &tmp,
3474
 
                                                                &len);
 
3447
        retval = rndis_query_oid(usbdev,
 
3448
                                 RNDIS_OID_802_3_MAXIMUM_LIST_SIZE,
 
3449
                                 &tmp, &len);
3475
3450
        priv->multicast_size = le32_to_cpu(tmp);
3476
3451
        if (retval < 0 || priv->multicast_size < 0)
3477
3452
                priv->multicast_size = 0;
3601
3576
        /* Set current packet filter zero to block receiving data packets from
3602
3577
           device. */
3603
3578
        filter = 0;
3604
 
        rndis_set_oid(usbdev, OID_GEN_CURRENT_PACKET_FILTER, &filter,
 
3579
        rndis_set_oid(usbdev, RNDIS_OID_GEN_CURRENT_PACKET_FILTER, &filter,
3605
3580
                                                                sizeof(filter));
3606
3581
 
3607
3582
        return retval;
3776
3751
        .disconnect =   usbnet_disconnect,
3777
3752
        .suspend =      usbnet_suspend,
3778
3753
        .resume =       usbnet_resume,
 
3754
        .disable_hub_initiated_lpm = 1,
3779
3755
};
3780
3756
 
3781
3757
module_usb_driver(rndis_wlan_driver);