drivers/net/wireless/rndis_wlan.c

   1 /*
   2  * Driver for RNDIS based wireless USB devices.
   3  *
   4  * Copyright (C) 2007 by Bjorge Dijkstra <bjd@jooz.net>
   5  * Copyright (C) 2008-2009 by Jussi Kivilinna <jussi.kivilinna@mbnet.fi>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  *
  21  *  Portions of this file are based on NDISwrapper project,
  22  *  Copyright (C) 2003-2005 Pontus Fuchs, Giridhar Pemmasani
  23  *  http://ndiswrapper.sourceforge.net/
  24  */
  25
  26 // #define      DEBUG                   // error path messages, extra info
  27 // #define      VERBOSE                 // more; success messages
  28
  29 #include <linux/module.h>
  30 #include <linux/init.h>
  31 #include <linux/netdevice.h>
  32 #include <linux/etherdevice.h>
  33 #include <linux/ethtool.h>
  34 #include <linux/workqueue.h>
  35 #include <linux/mutex.h>
  36 #include <linux/mii.h>
  37 #include <linux/usb.h>
  38 #include <linux/usb/cdc.h>
  39 #include <linux/wireless.h>
  40 #include <linux/ieee80211.h>
  41 #include <linux/if_arp.h>
  42 #include <linux/ctype.h>
  43 #include <linux/spinlock.h>
  44 #include <net/iw_handler.h>
  45 #include <net/cfg80211.h>
  46 #include <linux/usb/usbnet.h>
  47 #include <linux/usb/rndis_host.h>
  48
  49
  50 /* NOTE: All these are settings for Broadcom chipset */
  51 static char modparam_country[4] = "EU";
  52 module_param_string(country, modparam_country, 4, 0444);
  53 MODULE_PARM_DESC(country, "Country code (ISO 3166-1 alpha-2), default: EU");
  54
  55 static int modparam_frameburst = 1;
  56 module_param_named(frameburst, modparam_frameburst, int, 0444);
  57 MODULE_PARM_DESC(frameburst, "enable frame bursting (default: on)");
  58
  59 static int modparam_afterburner = 0;
  60 module_param_named(afterburner, modparam_afterburner, int, 0444);
  61 MODULE_PARM_DESC(afterburner,
  62         "enable afterburner aka '125 High Speed Mode' (default: off)");
  63
  64 static int modparam_power_save = 0;
  65 module_param_named(power_save, modparam_power_save, int, 0444);
  66 MODULE_PARM_DESC(power_save,
  67         "set power save mode: 0=off, 1=on, 2=fast (default: off)");
  68
  69 static int modparam_power_output = 3;
  70 module_param_named(power_output, modparam_power_output, int, 0444);
  71 MODULE_PARM_DESC(power_output,
  72         "set power output: 0=25%, 1=50%, 2=75%, 3=100% (default: 100%)");
  73
  74 static int modparam_roamtrigger = -70;
  75 module_param_named(roamtrigger, modparam_roamtrigger, int, 0444);
  76 MODULE_PARM_DESC(roamtrigger,
  77         "set roaming dBm trigger: -80=optimize for distance, "
  78                                 "-60=bandwidth (default: -70)");
  79
  80 static int modparam_roamdelta = 1;
  81 module_param_named(roamdelta, modparam_roamdelta, int, 0444);
  82 MODULE_PARM_DESC(roamdelta,
  83         "set roaming tendency: 0=aggressive, 1=moderate, "
  84                                 "2=conservative (default: moderate)");
  85
  86 static int modparam_workaround_interval;
  87 module_param_named(workaround_interval, modparam_workaround_interval,
  88                                                         int, 0444);
  89 MODULE_PARM_DESC(workaround_interval,
  90         "set stall workaround interval in msecs (0=disabled) (default: 0)");
  91
  92
  93 /* various RNDIS OID defs */
  94 #define OID_GEN_LINK_SPEED                      cpu_to_le32(0x00010107)
  95 #define OID_GEN_RNDIS_CONFIG_PARAMETER          cpu_to_le32(0x0001021b)
  96
  97 #define OID_GEN_XMIT_OK                         cpu_to_le32(0x00020101)
  98 #define OID_GEN_RCV_OK                          cpu_to_le32(0x00020102)
  99 #define OID_GEN_XMIT_ERROR                      cpu_to_le32(0x00020103)
 100 #define OID_GEN_RCV_ERROR                       cpu_to_le32(0x00020104)
 101 #define OID_GEN_RCV_NO_BUFFER                   cpu_to_le32(0x00020105)
 102
 103 #define OID_802_3_CURRENT_ADDRESS               cpu_to_le32(0x01010102)
 104 #define OID_802_3_MULTICAST_LIST                cpu_to_le32(0x01010103)
 105 #define OID_802_3_MAXIMUM_LIST_SIZE             cpu_to_le32(0x01010104)
 106
 107 #define OID_802_11_BSSID                        cpu_to_le32(0x0d010101)
 108 #define OID_802_11_SSID                         cpu_to_le32(0x0d010102)
 109 #define OID_802_11_INFRASTRUCTURE_MODE          cpu_to_le32(0x0d010108)
 110 #define OID_802_11_ADD_WEP                      cpu_to_le32(0x0d010113)
 111 #define OID_802_11_REMOVE_WEP                   cpu_to_le32(0x0d010114)
 112 #define OID_802_11_DISASSOCIATE                 cpu_to_le32(0x0d010115)
 113 #define OID_802_11_AUTHENTICATION_MODE          cpu_to_le32(0x0d010118)
 114 #define OID_802_11_PRIVACY_FILTER               cpu_to_le32(0x0d010119)
 115 #define OID_802_11_BSSID_LIST_SCAN              cpu_to_le32(0x0d01011a)
 116 #define OID_802_11_ENCRYPTION_STATUS            cpu_to_le32(0x0d01011b)
 117 #define OID_802_11_ADD_KEY                      cpu_to_le32(0x0d01011d)
 118 #define OID_802_11_REMOVE_KEY                   cpu_to_le32(0x0d01011e)
 119 #define OID_802_11_ASSOCIATION_INFORMATION      cpu_to_le32(0x0d01011f)
 120 #define OID_802_11_CAPABILITY                   cpu_to_le32(0x0d010122)
 121 #define OID_802_11_PMKID                        cpu_to_le32(0x0d010123)
 122 #define OID_802_11_NETWORK_TYPES_SUPPORTED      cpu_to_le32(0x0d010203)
 123 #define OID_802_11_NETWORK_TYPE_IN_USE          cpu_to_le32(0x0d010204)
 124 #define OID_802_11_TX_POWER_LEVEL               cpu_to_le32(0x0d010205)
 125 #define OID_802_11_RSSI                         cpu_to_le32(0x0d010206)
 126 #define OID_802_11_RSSI_TRIGGER                 cpu_to_le32(0x0d010207)
 127 #define OID_802_11_FRAGMENTATION_THRESHOLD      cpu_to_le32(0x0d010209)
 128 #define OID_802_11_RTS_THRESHOLD                cpu_to_le32(0x0d01020a)
 129 #define OID_802_11_SUPPORTED_RATES              cpu_to_le32(0x0d01020e)
 130 #define OID_802_11_CONFIGURATION                cpu_to_le32(0x0d010211)
 131 #define OID_802_11_BSSID_LIST                   cpu_to_le32(0x0d010217)
 132
 133
 134 /* Typical noise/maximum signal level values taken from ndiswrapper iw_ndis.h */
 135 #define WL_NOISE        -96     /* typical noise level in dBm */
 136 #define WL_SIGMAX       -32     /* typical maximum signal level in dBm */
 137
 138
 139 /* Assume that Broadcom 4320 (only chipset at time of writing known to be
 140  * based on wireless rndis) has default txpower of 13dBm.
 141  * This value is from Linksys WUSB54GSC User Guide, Appendix F: Specifications.
 142  *  100% : 20 mW ~ 13dBm
 143  *   75% : 15 mW ~ 12dBm
 144  *   50% : 10 mW ~ 10dBm
 145  *   25% :  5 mW ~  7dBm
 146  */
 147 #define BCM4320_DEFAULT_TXPOWER_DBM_100 13
 148 #define BCM4320_DEFAULT_TXPOWER_DBM_75  12
 149 #define BCM4320_DEFAULT_TXPOWER_DBM_50  10
 150 #define BCM4320_DEFAULT_TXPOWER_DBM_25  7
 151
 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 /* NDIS data structures. Taken from wpa_supplicant driver_ndis.c
 159  * slightly modified for datatype endianess, etc
 160  */
 161 #define NDIS_802_11_LENGTH_SSID 32
 162 #define NDIS_802_11_LENGTH_RATES 8
 163 #define NDIS_802_11_LENGTH_RATES_EX 16
 164
 165 enum ndis_80211_net_type {
 166         NDIS_80211_TYPE_FREQ_HOP,
 167         NDIS_80211_TYPE_DIRECT_SEQ,
 168         NDIS_80211_TYPE_OFDM_A,
 169         NDIS_80211_TYPE_OFDM_G
 170 };
 171
 172 enum ndis_80211_net_infra {
 173         NDIS_80211_INFRA_ADHOC,
 174         NDIS_80211_INFRA_INFRA,
 175         NDIS_80211_INFRA_AUTO_UNKNOWN
 176 };
 177
 178 enum ndis_80211_auth_mode {
 179         NDIS_80211_AUTH_OPEN,
 180         NDIS_80211_AUTH_SHARED,
 181         NDIS_80211_AUTH_AUTO_SWITCH,
 182         NDIS_80211_AUTH_WPA,
 183         NDIS_80211_AUTH_WPA_PSK,
 184         NDIS_80211_AUTH_WPA_NONE,
 185         NDIS_80211_AUTH_WPA2,
 186         NDIS_80211_AUTH_WPA2_PSK
 187 };
 188
 189 enum ndis_80211_encr_status {
 190         NDIS_80211_ENCR_WEP_ENABLED,
 191         NDIS_80211_ENCR_DISABLED,
 192         NDIS_80211_ENCR_WEP_KEY_ABSENT,
 193         NDIS_80211_ENCR_NOT_SUPPORTED,
 194         NDIS_80211_ENCR_TKIP_ENABLED,
 195         NDIS_80211_ENCR_TKIP_KEY_ABSENT,
 196         NDIS_80211_ENCR_CCMP_ENABLED,
 197         NDIS_80211_ENCR_CCMP_KEY_ABSENT
 198 };
 199
 200 enum ndis_80211_priv_filter {
 201         NDIS_80211_PRIV_ACCEPT_ALL,
 202         NDIS_80211_PRIV_8021X_WEP
 203 };
 204
 205 enum ndis_80211_status_type {
 206         NDIS_80211_STATUSTYPE_AUTHENTICATION,
 207         NDIS_80211_STATUSTYPE_MEDIASTREAMMODE,
 208         NDIS_80211_STATUSTYPE_PMKID_CANDIDATELIST,
 209         NDIS_80211_STATUSTYPE_RADIOSTATE,
 210 };
 211
 212 enum ndis_80211_media_stream_mode {
 213         NDIS_80211_MEDIA_STREAM_OFF,
 214         NDIS_80211_MEDIA_STREAM_ON
 215 };
 216
 217 enum ndis_80211_radio_status {
 218         NDIS_80211_RADIO_STATUS_ON,
 219         NDIS_80211_RADIO_STATUS_HARDWARE_OFF,
 220         NDIS_80211_RADIO_STATUS_SOFTWARE_OFF,
 221 };
 222
 223 enum ndis_80211_addkey_bits {
 224         NDIS_80211_ADDKEY_8021X_AUTH = cpu_to_le32(1 << 28),
 225         NDIS_80211_ADDKEY_SET_INIT_RECV_SEQ = cpu_to_le32(1 << 29),
 226         NDIS_80211_ADDKEY_PAIRWISE_KEY = cpu_to_le32(1 << 30),
 227         NDIS_80211_ADDKEY_TRANSMIT_KEY = cpu_to_le32(1 << 31)
 228 };
 229
 230 enum ndis_80211_addwep_bits {
 231         NDIS_80211_ADDWEP_PERCLIENT_KEY = cpu_to_le32(1 << 30),
 232         NDIS_80211_ADDWEP_TRANSMIT_KEY = cpu_to_le32(1 << 31)
 233 };
 234
 235 struct ndis_80211_auth_request {
 236         __le32 length;
 237         u8 bssid[6];
 238         u8 padding[2];
 239         __le32 flags;
 240 } __attribute__((packed));
 241
 242 struct ndis_80211_pmkid_candidate {
 243         u8 bssid[6];
 244         u8 padding[2];
 245         __le32 flags;
 246 } __attribute__((packed));
 247
 248 struct ndis_80211_pmkid_cand_list {
 249         __le32 version;
 250         __le32 num_candidates;
 251         struct ndis_80211_pmkid_candidate candidate_list[0];
 252 } __attribute__((packed));
 253
 254 struct ndis_80211_status_indication {
 255         __le32 status_type;
 256         union {
 257                 __le32                                  media_stream_mode;
 258                 __le32                                  radio_status;
 259                 struct ndis_80211_auth_request          auth_request[0];
 260                 struct ndis_80211_pmkid_cand_list       cand_list;
 261         } u;
 262 } __attribute__((packed));
 263
 264 struct ndis_80211_ssid {
 265         __le32 length;
 266         u8 essid[NDIS_802_11_LENGTH_SSID];
 267 } __attribute__((packed));
 268
 269 struct ndis_80211_conf_freq_hop {
 270         __le32 length;
 271         __le32 hop_pattern;
 272         __le32 hop_set;
 273         __le32 dwell_time;
 274 } __attribute__((packed));
 275
 276 struct ndis_80211_conf {
 277         __le32 length;
 278         __le32 beacon_period;
 279         __le32 atim_window;
 280         __le32 ds_config;
 281         struct ndis_80211_conf_freq_hop fh_config;
 282 } __attribute__((packed));
 283
 284 struct ndis_80211_bssid_ex {
 285         __le32 length;
 286         u8 mac[6];
 287         u8 padding[2];
 288         struct ndis_80211_ssid ssid;
 289         __le32 privacy;
 290         __le32 rssi;
 291         __le32 net_type;
 292         struct ndis_80211_conf config;
 293         __le32 net_infra;
 294         u8 rates[NDIS_802_11_LENGTH_RATES_EX];
 295         __le32 ie_length;
 296         u8 ies[0];
 297 } __attribute__((packed));
 298
 299 struct ndis_80211_bssid_list_ex {
 300         __le32 num_items;
 301         struct ndis_80211_bssid_ex bssid[0];
 302 } __attribute__((packed));
 303
 304 struct ndis_80211_fixed_ies {
 305         u8 timestamp[8];
 306         __le16 beacon_interval;
 307         __le16 capabilities;
 308 } __attribute__((packed));
 309
 310 struct ndis_80211_wep_key {
 311         __le32 size;
 312         __le32 index;
 313         __le32 length;
 314         u8 material[32];
 315 } __attribute__((packed));
 316
 317 struct ndis_80211_key {
 318         __le32 size;
 319         __le32 index;
 320         __le32 length;
 321         u8 bssid[6];
 322         u8 padding[6];
 323         u8 rsc[8];
 324         u8 material[32];
 325 } __attribute__((packed));
 326
 327 struct ndis_80211_remove_key {
 328         __le32 size;
 329         __le32 index;
 330         u8 bssid[6];
 331         u8 padding[2];
 332 } __attribute__((packed));
 333
 334 struct ndis_config_param {
 335         __le32 name_offs;
 336         __le32 name_length;
 337         __le32 type;
 338         __le32 value_offs;
 339         __le32 value_length;
 340 } __attribute__((packed));
 341
 342 struct ndis_80211_assoc_info {
 343         __le32 length;
 344         __le16 req_ies;
 345         struct req_ie {
 346                 __le16 capa;
 347                 __le16 listen_interval;
 348                 u8 cur_ap_address[6];
 349         } req_ie;
 350         __le32 req_ie_length;
 351         __le32 offset_req_ies;
 352         __le16 resp_ies;
 353         struct resp_ie {
 354                 __le16 capa;
 355                 __le16 status_code;
 356                 __le16 assoc_id;
 357         } resp_ie;
 358         __le32 resp_ie_length;
 359         __le32 offset_resp_ies;
 360 } __attribute__((packed));
 361
 362 struct ndis_80211_auth_encr_pair {
 363         __le32 auth_mode;
 364         __le32 encr_mode;
 365 } __attribute__((packed));
 366
 367 struct ndis_80211_capability {
 368         __le32 length;
 369         __le32 version;
 370         __le32 num_pmkids;
 371         __le32 num_auth_encr_pair;
 372         struct ndis_80211_auth_encr_pair auth_encr_pair[0];
 373 } __attribute__((packed));
 374
 375 struct ndis_80211_bssid_info {
 376         u8 bssid[6];
 377         u8 pmkid[16];
 378 };
 379
 380 struct ndis_80211_pmkid {
 381         __le32 length;
 382         __le32 bssid_info_count;
 383         struct ndis_80211_bssid_info bssid_info[0];
 384 };
 385
 386 /*
 387  *  private data
 388  */
 389 #define NET_TYPE_11FB   0
 390
 391 #define CAP_MODE_80211A         1
 392 #define CAP_MODE_80211B         2
 393 #define CAP_MODE_80211G         4
 394 #define CAP_MODE_MASK           7
 395
 396 #define WORK_LINK_UP            (1<<0)
 397 #define WORK_LINK_DOWN          (1<<1)
 398 #define WORK_SET_MULTICAST_LIST (1<<2)
 399
 400 #define RNDIS_WLAN_ALG_NONE     0
 401 #define RNDIS_WLAN_ALG_WEP      (1<<0)
 402 #define RNDIS_WLAN_ALG_TKIP     (1<<1)
 403 #define RNDIS_WLAN_ALG_CCMP     (1<<2)
 404
 405 #define RNDIS_WLAN_KEY_MGMT_NONE        0
 406 #define RNDIS_WLAN_KEY_MGMT_802_1X      (1<<0)
 407 #define RNDIS_WLAN_KEY_MGMT_PSK         (1<<1)
 408
 409 #define COMMAND_BUFFER_SIZE     (CONTROL_BUFFER_SIZE + sizeof(struct rndis_set))
 410
 411 static const struct ieee80211_channel rndis_channels[] = {
 412         { .center_freq = 2412 },
 413         { .center_freq = 2417 },
 414         { .center_freq = 2422 },
 415         { .center_freq = 2427 },
 416         { .center_freq = 2432 },
 417         { .center_freq = 2437 },
 418         { .center_freq = 2442 },
 419         { .center_freq = 2447 },
 420         { .center_freq = 2452 },
 421         { .center_freq = 2457 },
 422         { .center_freq = 2462 },
 423         { .center_freq = 2467 },
 424         { .center_freq = 2472 },
 425         { .center_freq = 2484 },
 426 };
 427
 428 static const struct ieee80211_rate rndis_rates[] = {
 429         { .bitrate = 10 },
 430         { .bitrate = 20, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
 431         { .bitrate = 55, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
 432         { .bitrate = 110, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
 433         { .bitrate = 60 },
 434         { .bitrate = 90 },
 435         { .bitrate = 120 },
 436         { .bitrate = 180 },
 437         { .bitrate = 240 },
 438         { .bitrate = 360 },
 439         { .bitrate = 480 },
 440         { .bitrate = 540 }
 441 };
 442
 443 static const u32 rndis_cipher_suites[] = {
 444         WLAN_CIPHER_SUITE_WEP40,
 445         WLAN_CIPHER_SUITE_WEP104,
 446         WLAN_CIPHER_SUITE_TKIP,
 447         WLAN_CIPHER_SUITE_CCMP,
 448 };
 449
 450 struct rndis_wlan_encr_key {
 451         int len;
 452         u32 cipher;
 453         u8 material[32];
 454         u8 bssid[ETH_ALEN];
 455         bool pairwise;
 456         bool tx_key;
 457 };
 458
 459 /* RNDIS device private data */
 460 struct rndis_wlan_private {
 461         struct usbnet *usbdev;
 462
 463         struct wireless_dev wdev;
 464
 465         struct cfg80211_scan_request *scan_request;
 466
 467         struct workqueue_struct *workqueue;
 468         struct delayed_work dev_poller_work;
 469         struct delayed_work scan_work;
 470         struct work_struct work;
 471         struct mutex command_lock;
 472         unsigned long work_pending;
 473         int last_qual;
 474
 475         struct ieee80211_supported_band band;
 476         struct ieee80211_channel channels[ARRAY_SIZE(rndis_channels)];
 477         struct ieee80211_rate rates[ARRAY_SIZE(rndis_rates)];
 478         u32 cipher_suites[ARRAY_SIZE(rndis_cipher_suites)];
 479
 480         int caps;
 481         int multicast_size;
 482
 483         /* module parameters */
 484         char param_country[4];
 485         int  param_frameburst;
 486         int  param_afterburner;
 487         int  param_power_save;
 488         int  param_power_output;
 489         int  param_roamtrigger;
 490         int  param_roamdelta;
 491         u32  param_workaround_interval;
 492
 493         /* hardware state */
 494         bool radio_on;
 495         int infra_mode;
 496         bool connected;
 497         u8 bssid[ETH_ALEN];
 498         struct ndis_80211_ssid essid;
 499         __le32 current_command_oid;
 500
 501         /* encryption stuff */
 502         int  encr_tx_key_index;
 503         struct rndis_wlan_encr_key encr_keys[4];
 504         int  wpa_version;
 505
 506         u8 command_buffer[COMMAND_BUFFER_SIZE];
 507 };
 508
 509 /*
 510  * cfg80211 ops
 511  */
 512 static int rndis_change_virtual_intf(struct wiphy *wiphy,
 513                                         struct net_device *dev,
 514                                         enum nl80211_iftype type, u32 *flags,
 515                                         struct vif_params *params);
 516
 517 static int rndis_scan(struct wiphy *wiphy, struct net_device *dev,
 518                         struct cfg80211_scan_request *request);
 519
 520 static int rndis_set_wiphy_params(struct wiphy *wiphy, u32 changed);
 521
 522 static int rndis_set_tx_power(struct wiphy *wiphy, enum tx_power_setting type,
 523                                 int dbm);
 524 static int rndis_get_tx_power(struct wiphy *wiphy, int *dbm);
 525
 526 static int rndis_connect(struct wiphy *wiphy, struct net_device *dev,
 527                                 struct cfg80211_connect_params *sme);
 528
 529 static int rndis_disconnect(struct wiphy *wiphy, struct net_device *dev,
 530                                 u16 reason_code);
 531
 532 static int rndis_join_ibss(struct wiphy *wiphy, struct net_device *dev,
 533                                         struct cfg80211_ibss_params *params);
 534
 535 static int rndis_leave_ibss(struct wiphy *wiphy, struct net_device *dev);
 536
 537 static int rndis_set_channel(struct wiphy *wiphy,
 538         struct ieee80211_channel *chan, enum nl80211_channel_type channel_type);
 539
 540 static int rndis_add_key(struct wiphy *wiphy, struct net_device *netdev,
 541                                         u8 key_index, const u8 *mac_addr,
 542                                         struct key_params *params);
 543
 544 static int rndis_del_key(struct wiphy *wiphy, struct net_device *netdev,
 545                                         u8 key_index, const u8 *mac_addr);
 546
 547 static int rndis_set_default_key(struct wiphy *wiphy, struct net_device *netdev,
 548                                                                 u8 key_index);
 549
 550 static int rndis_get_station(struct wiphy *wiphy, struct net_device *dev,
 551                                         u8 *mac, struct station_info *sinfo);
 552
 553 static int rndis_dump_station(struct wiphy *wiphy, struct net_device *dev,
 554                                int idx, u8 *mac, struct station_info *sinfo);
 555
 556 static int rndis_set_pmksa(struct wiphy *wiphy, struct net_device *netdev,
 557                                 struct cfg80211_pmksa *pmksa);
 558
 559 static int rndis_del_pmksa(struct wiphy *wiphy, struct net_device *netdev,
 560                                 struct cfg80211_pmksa *pmksa);
 561
 562 static int rndis_flush_pmksa(struct wiphy *wiphy, struct net_device *netdev);
 563
 564 static struct cfg80211_ops rndis_config_ops = {
 565         .change_virtual_intf = rndis_change_virtual_intf,
 566         .scan = rndis_scan,
 567         .set_wiphy_params = rndis_set_wiphy_params,
 568         .set_tx_power = rndis_set_tx_power,
 569         .get_tx_power = rndis_get_tx_power,
 570         .connect = rndis_connect,
 571         .disconnect = rndis_disconnect,
 572         .join_ibss = rndis_join_ibss,
 573         .leave_ibss = rndis_leave_ibss,
 574         .set_channel = rndis_set_channel,
 575         .add_key = rndis_add_key,
 576         .del_key = rndis_del_key,
 577         .set_default_key = rndis_set_default_key,
 578         .get_station = rndis_get_station,
 579         .dump_station = rndis_dump_station,
 580         .set_pmksa = rndis_set_pmksa,
 581         .del_pmksa = rndis_del_pmksa,
 582         .flush_pmksa = rndis_flush_pmksa,
 583 };
 584
 585 static void *rndis_wiphy_privid = &rndis_wiphy_privid;
 586
 587
 588 static struct rndis_wlan_private *get_rndis_wlan_priv(struct usbnet *dev)
 589 {
 590         return (struct rndis_wlan_private *)dev->driver_priv;
 591 }
 592
 593 static u32 get_bcm4320_power_dbm(struct rndis_wlan_private *priv)
 594 {
 595         switch (priv->param_power_output) {
 596         default:
 597         case 3:
 598                 return BCM4320_DEFAULT_TXPOWER_DBM_100;
 599         case 2:
 600                 return BCM4320_DEFAULT_TXPOWER_DBM_75;
 601         case 1:
 602                 return BCM4320_DEFAULT_TXPOWER_DBM_50;
 603         case 0:
 604                 return BCM4320_DEFAULT_TXPOWER_DBM_25;
 605         }
 606 }
 607
 608 static bool is_wpa_key(struct rndis_wlan_private *priv, int idx)
 609 {
 610         int cipher = priv->encr_keys[idx].cipher;
 611
 612         return (cipher == WLAN_CIPHER_SUITE_CCMP ||
 613                 cipher == WLAN_CIPHER_SUITE_TKIP);
 614 }
 615
 616 static int rndis_cipher_to_alg(u32 cipher)
 617 {
 618         switch (cipher) {
 619         default:
 620                 return RNDIS_WLAN_ALG_NONE;
 621         case WLAN_CIPHER_SUITE_WEP40:
 622         case WLAN_CIPHER_SUITE_WEP104:
 623                 return RNDIS_WLAN_ALG_WEP;
 624         case WLAN_CIPHER_SUITE_TKIP:
 625                 return RNDIS_WLAN_ALG_TKIP;
 626         case WLAN_CIPHER_SUITE_CCMP:
 627                 return RNDIS_WLAN_ALG_CCMP;
 628         }
 629 }
 630
 631 static int rndis_akm_suite_to_key_mgmt(u32 akm_suite)
 632 {
 633         switch (akm_suite) {
 634         default:
 635                 return RNDIS_WLAN_KEY_MGMT_NONE;
 636         case WLAN_AKM_SUITE_8021X:
 637                 return RNDIS_WLAN_KEY_MGMT_802_1X;
 638         case WLAN_AKM_SUITE_PSK:
 639                 return RNDIS_WLAN_KEY_MGMT_PSK;
 640         }
 641 }
 642
 643 #ifdef DEBUG
 644 static const char *oid_to_string(__le32 oid)
 645 {
 646         switch (oid) {
 647 #define OID_STR(oid) case oid: return(#oid)
 648                 /* from rndis_host.h */
 649                 OID_STR(OID_802_3_PERMANENT_ADDRESS);
 650                 OID_STR(OID_GEN_MAXIMUM_FRAME_SIZE);
 651                 OID_STR(OID_GEN_CURRENT_PACKET_FILTER);
 652                 OID_STR(OID_GEN_PHYSICAL_MEDIUM);
 653
 654                 /* from rndis_wlan.c */
 655                 OID_STR(OID_GEN_LINK_SPEED);
 656                 OID_STR(OID_GEN_RNDIS_CONFIG_PARAMETER);
 657
 658                 OID_STR(OID_GEN_XMIT_OK);
 659                 OID_STR(OID_GEN_RCV_OK);
 660                 OID_STR(OID_GEN_XMIT_ERROR);
 661                 OID_STR(OID_GEN_RCV_ERROR);
 662                 OID_STR(OID_GEN_RCV_NO_BUFFER);
 663
 664                 OID_STR(OID_802_3_CURRENT_ADDRESS);
 665                 OID_STR(OID_802_3_MULTICAST_LIST);
 666                 OID_STR(OID_802_3_MAXIMUM_LIST_SIZE);
 667
 668                 OID_STR(OID_802_11_BSSID);
 669                 OID_STR(OID_802_11_SSID);
 670                 OID_STR(OID_802_11_INFRASTRUCTURE_MODE);
 671                 OID_STR(OID_802_11_ADD_WEP);
 672                 OID_STR(OID_802_11_REMOVE_WEP);
 673                 OID_STR(OID_802_11_DISASSOCIATE);
 674                 OID_STR(OID_802_11_AUTHENTICATION_MODE);
 675                 OID_STR(OID_802_11_PRIVACY_FILTER);
 676                 OID_STR(OID_802_11_BSSID_LIST_SCAN);
 677                 OID_STR(OID_802_11_ENCRYPTION_STATUS);
 678                 OID_STR(OID_802_11_ADD_KEY);
 679                 OID_STR(OID_802_11_REMOVE_KEY);
 680                 OID_STR(OID_802_11_ASSOCIATION_INFORMATION);
 681                 OID_STR(OID_802_11_PMKID);
 682                 OID_STR(OID_802_11_NETWORK_TYPES_SUPPORTED);
 683                 OID_STR(OID_802_11_NETWORK_TYPE_IN_USE);
 684                 OID_STR(OID_802_11_TX_POWER_LEVEL);
 685                 OID_STR(OID_802_11_RSSI);
 686                 OID_STR(OID_802_11_RSSI_TRIGGER);
 687                 OID_STR(OID_802_11_FRAGMENTATION_THRESHOLD);
 688                 OID_STR(OID_802_11_RTS_THRESHOLD);
 689                 OID_STR(OID_802_11_SUPPORTED_RATES);
 690                 OID_STR(OID_802_11_CONFIGURATION);
 691                 OID_STR(OID_802_11_BSSID_LIST);
 692 #undef OID_STR
 693         }
 694
 695         return "?";
 696 }
 697 #else
 698 static const char *oid_to_string(__le32 oid)
 699 {
 700         return "?";
 701 }
 702 #endif
 703
 704 /* translate error code */
 705 static int rndis_error_status(__le32 rndis_status)
 706 {
 707         int ret = -EINVAL;
 708         switch (rndis_status) {
 709         case RNDIS_STATUS_SUCCESS:
 710                 ret = 0;
 711                 break;
 712         case RNDIS_STATUS_FAILURE:
 713         case RNDIS_STATUS_INVALID_DATA:
 714                 ret = -EINVAL;
 715                 break;
 716         case RNDIS_STATUS_NOT_SUPPORTED:
 717                 ret = -EOPNOTSUPP;
 718                 break;
 719         case RNDIS_STATUS_ADAPTER_NOT_READY:
 720         case RNDIS_STATUS_ADAPTER_NOT_OPEN:
 721                 ret = -EBUSY;
 722                 break;
 723         }
 724         return ret;
 725 }
 726
 727 static int rndis_query_oid(struct usbnet *dev, __le32 oid, void *data, int *len)
 728 {
 729         struct rndis_wlan_private *priv = get_rndis_wlan_priv(dev);
 730         union {
 731                 void                    *buf;
 732                 struct rndis_msg_hdr    *header;
 733                 struct rndis_query      *get;
 734                 struct rndis_query_c    *get_c;
 735         } u;
 736         int ret, buflen;
 737         int resplen, respoffs, copylen;
 738
 739         buflen = *len + sizeof(*u.get);
 740         if (buflen < CONTROL_BUFFER_SIZE)
 741                 buflen = CONTROL_BUFFER_SIZE;
 742
 743         if (buflen > COMMAND_BUFFER_SIZE) {
 744                 u.buf = kmalloc(buflen, GFP_KERNEL);
 745                 if (!u.buf)
 746                         return -ENOMEM;
 747         } else {
 748                 u.buf = priv->command_buffer;
 749         }
 750
 751         mutex_lock(&priv->command_lock);
 752
 753         memset(u.get, 0, sizeof *u.get);
 754         u.get->msg_type = RNDIS_MSG_QUERY;
 755         u.get->msg_len = cpu_to_le32(sizeof *u.get);
 756         u.get->oid = oid;
 757
 758         priv->current_command_oid = oid;
 759         ret = rndis_command(dev, u.header, buflen);
 760         priv->current_command_oid = 0;
 761         if (ret < 0)
 762                 netdev_dbg(dev->net, "%s(%s): rndis_command() failed, %d (%08x)\n",
 763                            __func__, oid_to_string(oid), ret,
 764                            le32_to_cpu(u.get_c->status));
 765
 766         if (ret == 0) {
 767                 resplen = le32_to_cpu(u.get_c->len);
 768                 respoffs = le32_to_cpu(u.get_c->offset) + 8;
 769
 770                 if (respoffs > buflen) {
 771                         /* Device returned data offset outside buffer, error. */
 772                         netdev_dbg(dev->net, "%s(%s): received invalid "
 773                                 "data offset: %d > %d\n", __func__,
 774                                 oid_to_string(oid), respoffs, buflen);
 775
 776                         ret = -EINVAL;
 777                         goto exit_unlock;
 778                 }
 779
 780                 if ((resplen + respoffs) > buflen) {
 781                         /* Device would have returned more data if buffer would
 782                          * have been big enough. Copy just the bits that we got.
 783                          */
 784                         copylen = buflen - respoffs;
 785                 } else {
 786                         copylen = resplen;
 787                 }
 788
 789                 if (copylen > *len)
 790                         copylen = *len;
 791
 792                 memcpy(data, u.buf + respoffs, copylen);
 793
 794                 *len = resplen;
 795
 796                 ret = rndis_error_status(u.get_c->status);
 797                 if (ret < 0)
 798                         netdev_dbg(dev->net, "%s(%s): device returned error,  0x%08x (%d)\n",
 799                                    __func__, oid_to_string(oid),
 800                                    le32_to_cpu(u.get_c->status), ret);
 801         }
 802
 803 exit_unlock:
 804         mutex_unlock(&priv->command_lock);
 805
 806         if (u.buf != priv->command_buffer)
 807                 kfree(u.buf);
 808         return ret;
 809 }
 810
 811 static int rndis_set_oid(struct usbnet *dev, __le32 oid, void *data, int len)
 812 {
 813         struct rndis_wlan_private *priv = get_rndis_wlan_priv(dev);
 814         union {
 815                 void                    *buf;
 816                 struct rndis_msg_hdr    *header;
 817                 struct rndis_set        *set;
 818                 struct rndis_set_c      *set_c;
 819         } u;
 820         int ret, buflen;
 821
 822         buflen = len + sizeof(*u.set);
 823         if (buflen < CONTROL_BUFFER_SIZE)
 824                 buflen = CONTROL_BUFFER_SIZE;
 825
 826         if (buflen > COMMAND_BUFFER_SIZE) {
 827                 u.buf = kmalloc(buflen, GFP_KERNEL);
 828                 if (!u.buf)
 829                         return -ENOMEM;
 830         } else {
 831                 u.buf = priv->command_buffer;
 832         }
 833
 834         mutex_lock(&priv->command_lock);
 835
 836         memset(u.set, 0, sizeof *u.set);
 837         u.set->msg_type = RNDIS_MSG_SET;
 838         u.set->msg_len = cpu_to_le32(sizeof(*u.set) + len);
 839         u.set->oid = oid;
 840         u.set->len = cpu_to_le32(len);
 841         u.set->offset = cpu_to_le32(sizeof(*u.set) - 8);
 842         u.set->handle = cpu_to_le32(0);
 843         memcpy(u.buf + sizeof(*u.set), data, len);
 844
 845         priv->current_command_oid = oid;
 846         ret = rndis_command(dev, u.header, buflen);
 847         priv->current_command_oid = 0;
 848         if (ret < 0)
 849                 netdev_dbg(dev->net, "%s(%s): rndis_command() failed, %d (%08x)\n",
 850                            __func__, oid_to_string(oid), ret,
 851                            le32_to_cpu(u.set_c->status));
 852
 853         if (ret == 0) {
 854                 ret = rndis_error_status(u.set_c->status);
 855
 856                 if (ret < 0)
 857                         netdev_dbg(dev->net, "%s(%s): device returned error, 0x%08x (%d)\n",
 858                                    __func__, oid_to_string(oid),
 859                                    le32_to_cpu(u.set_c->status), ret);
 860         }
 861
 862         mutex_unlock(&priv->command_lock);
 863
 864         if (u.buf != priv->command_buffer)
 865                 kfree(u.buf);
 866         return ret;
 867 }
 868
 869 static int rndis_reset(struct usbnet *usbdev)
 870 {
 871         struct rndis_wlan_private *priv = get_rndis_wlan_priv(usbdev);
 872         struct rndis_reset *reset;
 873         int ret;
 874
 875         mutex_lock(&priv->command_lock);
 876
 877         reset = (void *)priv->command_buffer;
 878         memset(reset, 0, sizeof(*reset));
 879         reset->msg_type = RNDIS_MSG_RESET;
 880         reset->msg_len = cpu_to_le32(sizeof(*reset));
 881         priv->current_command_oid = 0;
 882         ret = rndis_command(usbdev, (void *)reset, CONTROL_BUFFER_SIZE);
 883
 884         mutex_unlock(&priv->command_lock);
 885
 886         if (ret < 0)
 887                 return ret;
 888         return 0;
 889 }
 890
 891 /*
 892  * Specs say that we can only set config parameters only soon after device
 893  * initialization.
 894  *   value_type: 0 = u32, 2 = unicode string
 895  */
 896 static int rndis_set_config_parameter(struct usbnet *dev, char *param,
 897                                                 int value_type, void *value)
 898 {
 899         struct ndis_config_param *infobuf;
 900         int value_len, info_len, param_len, ret, i;
 901         __le16 *unibuf;
 902         __le32 *dst_value;
 903
 904         if (value_type == 0)
 905                 value_len = sizeof(__le32);
 906         else if (value_type == 2)
 907                 value_len = strlen(value) * sizeof(__le16);
 908         else
 909                 return -EINVAL;
 910
 911         param_len = strlen(param) * sizeof(__le16);
 912         info_len = sizeof(*infobuf) + param_len + value_len;
 913
 914 #ifdef DEBUG
 915         info_len += 12;
 916 #endif
 917         infobuf = kmalloc(info_len, GFP_KERNEL);
 918         if (!infobuf)
 919                 return -ENOMEM;
 920
 921 #ifdef DEBUG
 922         info_len -= 12;
 923         /* extra 12 bytes are for padding (debug output) */
 924         memset(infobuf, 0xCC, info_len + 12);
 925 #endif
 926
 927         if (value_type == 2)
 928                 netdev_dbg(dev->net, "setting config parameter: %s, value: %s\n",
 929                            param, (u8 *)value);
 930         else
 931                 netdev_dbg(dev->net, "setting config parameter: %s, value: %d\n",
 932                            param, *(u32 *)value);
 933
 934         infobuf->name_offs = cpu_to_le32(sizeof(*infobuf));
 935         infobuf->name_length = cpu_to_le32(param_len);
 936         infobuf->type = cpu_to_le32(value_type);
 937         infobuf->value_offs = cpu_to_le32(sizeof(*infobuf) + param_len);
 938         infobuf->value_length = cpu_to_le32(value_len);
 939
 940         /* simple string to unicode string conversion */
 941         unibuf = (void *)infobuf + sizeof(*infobuf);
 942         for (i = 0; i < param_len / sizeof(__le16); i++)
 943                 unibuf[i] = cpu_to_le16(param[i]);
 944
 945         if (value_type == 2) {
 946                 unibuf = (void *)infobuf + sizeof(*infobuf) + param_len;
 947                 for (i = 0; i < value_len / sizeof(__le16); i++)
 948                         unibuf[i] = cpu_to_le16(((u8 *)value)[i]);
 949         } else {
 950                 dst_value = (void *)infobuf + sizeof(*infobuf) + param_len;
 951                 *dst_value = cpu_to_le32(*(u32 *)value);
 952         }
 953
 954 #ifdef DEBUG
 955         netdev_dbg(dev->net, "info buffer (len: %d)\n", info_len);
 956         for (i = 0; i < info_len; i += 12) {
 957                 u32 *tmp = (u32 *)((u8 *)infobuf + i);
 958                 netdev_dbg(dev->net, "%08X:%08X:%08X\n",
 959                            cpu_to_be32(tmp[0]),
 960                            cpu_to_be32(tmp[1]),
 961                            cpu_to_be32(tmp[2]));
 962         }
 963 #endif
 964
 965         ret = rndis_set_oid(dev, OID_GEN_RNDIS_CONFIG_PARAMETER,
 966                                                         infobuf, info_len);
 967         if (ret != 0)
 968                 netdev_dbg(dev->net, "setting rndis config parameter failed, %d\n",
 969                            ret);
 970
 971         kfree(infobuf);
 972         return ret;
 973 }
 974
 975 static int rndis_set_config_parameter_str(struct usbnet *dev,
 976                                                 char *param, char *value)
 977 {
 978         return rndis_set_config_parameter(dev, param, 2, value);
 979 }
 980
 981 /*
 982  * data conversion functions
 983  */
 984 static int level_to_qual(int level)
 985 {
 986         int qual = 100 * (level - WL_NOISE) / (WL_SIGMAX - WL_NOISE);
 987         return qual >= 0 ? (qual <= 100 ? qual : 100) : 0;
 988 }
 989
 990 /*
 991  * common functions
 992  */
 993 static int set_infra_mode(struct usbnet *usbdev, int mode);
 994 static void restore_keys(struct usbnet *usbdev);
 995 static int rndis_check_bssid_list(struct usbnet *usbdev);
 996
 997 static int set_essid(struct usbnet *usbdev, struct ndis_80211_ssid *ssid)
 998 {
 999         struct rndis_wlan_private *priv = get_rndis_wlan_priv(usbdev);
1000         int ret;
1001
1002         ret = rndis_set_oid(usbdev, OID_802_11_SSID, ssid, sizeof(*ssid));
1003         if (ret < 0) {
1004                 netdev_warn(usbdev->net, "setting SSID failed (%08X)\n", ret);
1005                 return ret;
1006         }
1007         if (ret == 0) {
1008                 memcpy(&priv->essid, ssid, sizeof(priv->essid));
1009                 priv->radio_on = true;
1010                 netdev_dbg(usbdev->net, "%s(): radio_on = true\n", __func__);
1011         }
1012
1013         return ret;
1014 }
1015
1016 static int set_bssid(struct usbnet *usbdev, u8 bssid[ETH_ALEN])
1017 {
1018         int ret;
1019
1020         ret = rndis_set_oid(usbdev, OID_802_11_BSSID, bssid, ETH_ALEN);
1021         if (ret < 0) {
1022                 netdev_warn(usbdev->net, "setting BSSID[%pM] failed (%08X)\n",
1023                             bssid, ret);
1024                 return ret;
1025         }
1026
1027         return ret;
1028 }
1029
1030 static int clear_bssid(struct usbnet *usbdev)
1031 {
1032         u8 broadcast_mac[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
1033
1034         return set_bssid(usbdev, broadcast_mac);
1035 }
1036
1037 static int get_bssid(struct usbnet *usbdev, u8 bssid[ETH_ALEN])
1038 {
1039         int ret, len;
1040
1041         len = ETH_ALEN;
1042         ret = rndis_query_oid(usbdev, OID_802_11_BSSID, bssid, &len);
1043
1044         if (ret != 0)
1045                 memset(bssid, 0, ETH_ALEN);
1046
1047         return ret;
1048 }
1049
1050 static int get_association_info(struct usbnet *usbdev,
1051                         struct ndis_80211_assoc_info *info, int len)
1052 {
1053         return rndis_query_oid(usbdev, OID_802_11_ASSOCIATION_INFORMATION,
1054                                 info, &len);
1055 }
1056
1057 static bool is_associated(struct usbnet *usbdev)
1058 {
1059         struct rndis_wlan_private *priv = get_rndis_wlan_priv(usbdev);
1060         u8 bssid[ETH_ALEN];
1061         int ret;
1062
1063         if (!priv->radio_on)
1064                 return false;
1065
1066         ret = get_bssid(usbdev, bssid);
1067
1068         return (ret == 0 && !is_zero_ether_addr(bssid));
1069 }
1070
1071 static int disassociate(struct usbnet *usbdev, bool reset_ssid)
1072 {
1073         struct rndis_wlan_private *priv = get_rndis_wlan_priv(usbdev);
1074         struct ndis_80211_ssid ssid;
1075         int i, ret = 0;
1076
1077         if (priv->radio_on) {
1078                 ret = rndis_set_oid(usbdev, OID_802_11_DISASSOCIATE, NULL, 0);
1079                 if (ret == 0) {
1080                         priv->radio_on = false;
1081                         netdev_dbg(usbdev->net, "%s(): radio_on = false\n",
1082                                    __func__);
1083
1084                         if (reset_ssid)
1085                                 msleep(100);
1086                 }
1087         }
1088
1089         /* disassociate causes radio to be turned off; if reset_ssid
1090          * is given, set random ssid to enable radio */
1091         if (reset_ssid) {
1092                 /* Set device to infrastructure mode so we don't get ad-hoc
1093                  * 'media connect' indications with the random ssid.
1094                  */
1095                 set_infra_mode(usbdev, NDIS_80211_INFRA_INFRA);
1096
1097                 ssid.length = cpu_to_le32(sizeof(ssid.essid));
1098                 get_random_bytes(&ssid.essid[2], sizeof(ssid.essid)-2);
1099                 ssid.essid[0] = 0x1;
1100                 ssid.essid[1] = 0xff;
1101                 for (i = 2; i < sizeof(ssid.essid); i++)
1102                         ssid.essid[i] = 0x1 + (ssid.essid[i] * 0xfe / 0xff);
1103                 ret = set_essid(usbdev, &ssid);
1104         }
1105         return ret;
1106 }
1107
1108 static int set_auth_mode(struct usbnet *usbdev, u32 wpa_version,
1109                                 enum nl80211_auth_type auth_type, int keymgmt)
1110 {
1111         struct rndis_wlan_private *priv = get_rndis_wlan_priv(usbdev);
1112         __le32 tmp;
1113         int auth_mode, ret;
1114
1115         netdev_dbg(usbdev->net, "%s(): wpa_version=0x%x authalg=0x%x keymgmt=0x%x\n",
1116                    __func__, wpa_version, auth_type, keymgmt);
1117
1118         if (wpa_version & NL80211_WPA_VERSION_2) {
1119                 if (keymgmt & RNDIS_WLAN_KEY_MGMT_802_1X)
1120                         auth_mode = NDIS_80211_AUTH_WPA2;
1121                 else
1122                         auth_mode = NDIS_80211_AUTH_WPA2_PSK;
1123         } else if (wpa_version & NL80211_WPA_VERSION_1) {
1124                 if (keymgmt & RNDIS_WLAN_KEY_MGMT_802_1X)
1125                         auth_mode = NDIS_80211_AUTH_WPA;
1126                 else if (keymgmt & RNDIS_WLAN_KEY_MGMT_PSK)
1127                         auth_mode = NDIS_80211_AUTH_WPA_PSK;
1128                 else
1129                         auth_mode = NDIS_80211_AUTH_WPA_NONE;
1130         } else if (auth_type == NL80211_AUTHTYPE_SHARED_KEY)
1131                 auth_mode = NDIS_80211_AUTH_SHARED;
1132         else if (auth_type == NL80211_AUTHTYPE_OPEN_SYSTEM)
1133                 auth_mode = NDIS_80211_AUTH_OPEN;
1134         else if (auth_type == NL80211_AUTHTYPE_AUTOMATIC)
1135                 auth_mode = NDIS_80211_AUTH_AUTO_SWITCH;
1136         else
1137                 return -ENOTSUPP;
1138
1139         tmp = cpu_to_le32(auth_mode);
1140         ret = rndis_set_oid(usbdev, OID_802_11_AUTHENTICATION_MODE, &tmp,
1141                                                                 sizeof(tmp));
1142         if (ret != 0) {
1143                 netdev_warn(usbdev->net, "setting auth mode failed (%08X)\n",
1144                             ret);
1145                 return ret;
1146         }
1147
1148         priv->wpa_version = wpa_version;
1149
1150         return 0;
1151 }
1152
1153 static int set_priv_filter(struct usbnet *usbdev)
1154 {
1155         struct rndis_wlan_private *priv = get_rndis_wlan_priv(usbdev);
1156         __le32 tmp;
1157
1158         netdev_dbg(usbdev->net, "%s(): wpa_version=0x%x\n",
1159                    __func__, priv->wpa_version);
1160
1161         if (priv->wpa_version & NL80211_WPA_VERSION_2 ||
1162             priv->wpa_version & NL80211_WPA_VERSION_1)
1163                 tmp = cpu_to_le32(NDIS_80211_PRIV_8021X_WEP);
1164         else
1165                 tmp = cpu_to_le32(NDIS_80211_PRIV_ACCEPT_ALL);
1166
1167         return rndis_set_oid(usbdev, OID_802_11_PRIVACY_FILTER, &tmp,
1168                                                                 sizeof(tmp));
1169 }
1170
1171 static int set_encr_mode(struct usbnet *usbdev, int pairwise, int groupwise)
1172 {
1173         __le32 tmp;
1174         int encr_mode, ret;
1175
1176         netdev_dbg(usbdev->net, "%s(): cipher_pair=0x%x cipher_group=0x%x\n",
1177                    __func__, pairwise, groupwise);
1178
1179         if (pairwise & RNDIS_WLAN_ALG_CCMP)
1180                 encr_mode = NDIS_80211_ENCR_CCMP_ENABLED;
1181         else if (pairwise & RNDIS_WLAN_ALG_TKIP)
1182                 encr_mode = NDIS_80211_ENCR_TKIP_ENABLED;
1183         else if (pairwise & RNDIS_WLAN_ALG_WEP)
1184                 encr_mode = NDIS_80211_ENCR_WEP_ENABLED;
1185         else if (groupwise & RNDIS_WLAN_ALG_CCMP)
1186                 encr_mode = NDIS_80211_ENCR_CCMP_ENABLED;
1187         else if (groupwise & RNDIS_WLAN_ALG_TKIP)
1188                 encr_mode = NDIS_80211_ENCR_TKIP_ENABLED;
1189         else
1190                 encr_mode = NDIS_80211_ENCR_DISABLED;
1191
1192         tmp = cpu_to_le32(encr_mode);
1193         ret = rndis_set_oid(usbdev, OID_802_11_ENCRYPTION_STATUS, &tmp,
1194                                                                 sizeof(tmp));
1195         if (ret != 0) {
1196                 netdev_warn(usbdev->net, "setting encr mode failed (%08X)\n",
1197                             ret);
1198                 return ret;
1199         }
1200
1201         return 0;
1202 }
1203
1204 static int set_infra_mode(struct usbnet *usbdev, int mode)
1205 {
1206         struct rndis_wlan_private *priv = get_rndis_wlan_priv(usbdev);
1207         __le32 tmp;
1208         int ret;
1209
1210         netdev_dbg(usbdev->net, "%s(): infra_mode=0x%x\n",
1211                    __func__, priv->infra_mode);
1212
1213         tmp = cpu_to_le32(mode);
1214         ret = rndis_set_oid(usbdev, OID_802_11_INFRASTRUCTURE_MODE, &tmp,
1215                                                                 sizeof(tmp));
1216         if (ret != 0) {
1217                 netdev_warn(usbdev->net, "setting infra mode failed (%08X)\n",
1218                             ret);
1219                 return ret;
1220         }
1221
1222         /* NDIS drivers clear keys when infrastructure mode is
1223          * changed. But Linux tools assume otherwise. So set the
1224          * keys */
1225         restore_keys(usbdev);
1226
1227         priv->infra_mode = mode;
1228         return 0;
1229 }
1230
1231 static int set_rts_threshold(struct usbnet *usbdev, u32 rts_threshold)
1232 {
1233         __le32 tmp;
1234
1235         netdev_dbg(usbdev->net, "%s(): %i\n", __func__, rts_threshold);
1236
1237         if (rts_threshold < 0 || rts_threshold > 2347)
1238                 rts_threshold = 2347;
1239
1240         tmp = cpu_to_le32(rts_threshold);
1241         return rndis_set_oid(usbdev, OID_802_11_RTS_THRESHOLD, &tmp,
1242                                                                 sizeof(tmp));
1243 }
1244
1245 static int set_frag_threshold(struct usbnet *usbdev, u32 frag_threshold)
1246 {
1247         __le32 tmp;
1248
1249         netdev_dbg(usbdev->net, "%s(): %i\n", __func__, frag_threshold);
1250
1251         if (frag_threshold < 256 || frag_threshold > 2346)
1252                 frag_threshold = 2346;
1253
1254         tmp = cpu_to_le32(frag_threshold);
1255         return rndis_set_oid(usbdev, OID_802_11_FRAGMENTATION_THRESHOLD, &tmp,
1256                                                                 sizeof(tmp));
1257 }
1258
1259 static void set_default_iw_params(struct usbnet *usbdev)
1260 {
1261         set_infra_mode(usbdev, NDIS_80211_INFRA_INFRA);
1262         set_auth_mode(usbdev, 0, NL80211_AUTHTYPE_OPEN_SYSTEM,
1263                                                 RNDIS_WLAN_KEY_MGMT_NONE);
1264         set_priv_filter(usbdev);
1265         set_encr_mode(usbdev, RNDIS_WLAN_ALG_NONE, RNDIS_WLAN_ALG_NONE);
1266 }
1267
1268 static int deauthenticate(struct usbnet *usbdev)
1269 {
1270         int ret;
1271
1272         ret = disassociate(usbdev, true);
1273         set_default_iw_params(usbdev);
1274         return ret;
1275 }
1276
1277 static int set_channel(struct usbnet *usbdev, int channel)
1278 {
1279         struct ndis_80211_conf config;
1280         unsigned int dsconfig;
1281         int len, ret;
1282
1283         netdev_dbg(usbdev->net, "%s(%d)\n", __func__, channel);
1284
1285         /* this OID is valid only when not associated */
1286         if (is_associated(usbdev))
1287                 return 0;
1288
1289         dsconfig = ieee80211_dsss_chan_to_freq(channel) * 1000;
1290
1291         len = sizeof(config);
1292         ret = rndis_query_oid(usbdev, OID_802_11_CONFIGURATION, &config, &len);
1293         if (ret < 0) {
1294                 netdev_dbg(usbdev->net, "%s(): querying configuration failed\n",
1295                            __func__);
1296                 return ret;
1297         }
1298
1299         config.ds_config = cpu_to_le32(dsconfig);
1300         ret = rndis_set_oid(usbdev, OID_802_11_CONFIGURATION, &config,
1301                                                                 sizeof(config));
1302
1303         netdev_dbg(usbdev->net, "%s(): %d -> %d\n", __func__, channel, ret);
1304
1305         return ret;
1306 }
1307
1308 /* index must be 0 - N, as per NDIS  */
1309 static int add_wep_key(struct usbnet *usbdev, const u8 *key, int key_len,
1310                                                                 int index)
1311 {
1312         struct rndis_wlan_private *priv = get_rndis_wlan_priv(usbdev);
1313         struct ndis_80211_wep_key ndis_key;
1314         u32 cipher;
1315         int ret;
1316
1317         netdev_dbg(usbdev->net, "%s(idx: %d, len: %d)\n",
1318                    __func__, index, key_len);
1319
1320         if ((key_len != 5 && key_len != 13) || index < 0 || index > 3)
1321                 return -EINVAL;
1322
1323         if (key_len == 5)
1324                 cipher = WLAN_CIPHER_SUITE_WEP40;
1325         else
1326                 cipher = WLAN_CIPHER_SUITE_WEP104;
1327
1328         memset(&ndis_key, 0, sizeof(ndis_key));
1329
1330         ndis_key.size = cpu_to_le32(sizeof(ndis_key));
1331         ndis_key.length = cpu_to_le32(key_len);
1332         ndis_key.index = cpu_to_le32(index);
1333         memcpy(&ndis_key.material, key, key_len);
1334
1335         if (index == priv->encr_tx_key_index) {
1336                 ndis_key.index |= NDIS_80211_ADDWEP_TRANSMIT_KEY;
1337                 ret = set_encr_mode(usbdev, RNDIS_WLAN_ALG_WEP,
1338                                                         RNDIS_WLAN_ALG_NONE);
1339                 if (ret)
1340                         netdev_warn(usbdev->net, "encryption couldn't be enabled (%08X)\n",
1341                                     ret);
1342         }
1343
1344         ret = rndis_set_oid(usbdev, OID_802_11_ADD_WEP, &ndis_key,
1345                                                         sizeof(ndis_key));
1346         if (ret != 0) {
1347                 netdev_warn(usbdev->net, "adding encryption key %d failed (%08X)\n",
1348                             index + 1, ret);
1349                 return ret;
1350         }
1351
1352         priv->encr_keys[index].len = key_len;
1353         priv->encr_keys[index].cipher = cipher;
1354         memcpy(&priv->encr_keys[index].material, key, key_len);
1355         memset(&priv->encr_keys[index].bssid, 0xff, ETH_ALEN);
1356
1357         return 0;
1358 }
1359
1360 static int add_wpa_key(struct usbnet *usbdev, const u8 *key, int key_len,
1361                         int index, const u8 *addr, const u8 *rx_seq,
1362                         int seq_len, u32 cipher, __le32 flags)
1363 {
1364         struct rndis_wlan_private *priv = get_rndis_wlan_priv(usbdev);
1365         struct ndis_80211_key ndis_key;
1366         bool is_addr_ok;
1367         int ret;
1368
1369         if (index < 0 || index >= 4) {
1370                 netdev_dbg(usbdev->net, "%s(): index out of range (%i)\n",
1371                            __func__, index);
1372                 return -EINVAL;
1373         }
1374         if (key_len > sizeof(ndis_key.material) || key_len < 0) {
1375                 netdev_dbg(usbdev->net, "%s(): key length out of range (%i)\n",
1376                            __func__, key_len);
1377                 return -EINVAL;
1378         }
1379         if (flags & NDIS_80211_ADDKEY_SET_INIT_RECV_SEQ) {
1380                 if (!rx_seq || seq_len <= 0) {
1381                         netdev_dbg(usbdev->net, "%s(): recv seq flag without buffer\n",
1382                                    __func__);
1383                         return -EINVAL;
1384                 }
1385                 if (rx_seq && seq_len > sizeof(ndis_key.rsc)) {
1386                         netdev_dbg(usbdev->net, "%s(): too big recv seq buffer\n", __func__);
1387                         return -EINVAL;
1388                 }
1389         }
1390
1391         is_addr_ok = addr && !is_zero_ether_addr(addr) &&
1392                                         !is_broadcast_ether_addr(addr);
1393         if ((flags & NDIS_80211_ADDKEY_PAIRWISE_KEY) && !is_addr_ok) {
1394                 netdev_dbg(usbdev->net, "%s(): pairwise but bssid invalid (%pM)\n",
1395                            __func__, addr);
1396                 return -EINVAL;
1397         }
1398
1399         netdev_dbg(usbdev->net, "%s(%i): flags:%i%i%i\n",
1400                    __func__, index,
1401                    !!(flags & NDIS_80211_ADDKEY_TRANSMIT_KEY),
1402                    !!(flags & NDIS_80211_ADDKEY_PAIRWISE_KEY),
1403                    !!(flags & NDIS_80211_ADDKEY_SET_INIT_RECV_SEQ));
1404
1405         memset(&ndis_key, 0, sizeof(ndis_key));
1406
1407         ndis_key.size = cpu_to_le32(sizeof(ndis_key) -
1408                                 sizeof(ndis_key.material) + key_len);
1409         ndis_key.length = cpu_to_le32(key_len);
1410         ndis_key.index = cpu_to_le32(index) | flags;
1411
1412         if (cipher == WLAN_CIPHER_SUITE_TKIP && key_len == 32) {
1413                 /* wpa_supplicant gives us the Michael MIC RX/TX keys in
1414                  * different order than NDIS spec, so swap the order here. */
1415                 memcpy(ndis_key.material, key, 16);
1416                 memcpy(ndis_key.material + 16, key + 24, 8);
1417                 memcpy(ndis_key.material + 24, key + 16, 8);
1418         } else
1419                 memcpy(ndis_key.material, key, key_len);
1420
1421         if (flags & NDIS_80211_ADDKEY_SET_INIT_RECV_SEQ)
1422                 memcpy(ndis_key.rsc, rx_seq, seq_len);
1423
1424         if (flags & NDIS_80211_ADDKEY_PAIRWISE_KEY) {
1425                 /* pairwise key */
1426                 memcpy(ndis_key.bssid, addr, ETH_ALEN);
1427         } else {
1428                 /* group key */
1429                 if (priv->infra_mode == NDIS_80211_INFRA_ADHOC)
1430                         memset(ndis_key.bssid, 0xff, ETH_ALEN);
1431                 else
1432                         get_bssid(usbdev, ndis_key.bssid);
1433         }
1434
1435         ret = rndis_set_oid(usbdev, OID_802_11_ADD_KEY, &ndis_key,
1436                                         le32_to_cpu(ndis_key.size));
1437         netdev_dbg(usbdev->net, "%s(): OID_802_11_ADD_KEY -> %08X\n",
1438                    __func__, ret);
1439         if (ret != 0)
1440                 return ret;
1441
1442         memset(&priv->encr_keys[index], 0, sizeof(priv->encr_keys[index]));
1443         priv->encr_keys[index].len = key_len;
1444         priv->encr_keys[index].cipher = cipher;
1445         memcpy(&priv->encr_keys[index].material, key, key_len);
1446         if (flags & NDIS_80211_ADDKEY_PAIRWISE_KEY)
1447                 memcpy(&priv->encr_keys[index].bssid, ndis_key.bssid, ETH_ALEN);
1448         else
1449                 memset(&priv->encr_keys[index].bssid, 0xff, ETH_ALEN);
1450
1451         if (flags & NDIS_80211_ADDKEY_TRANSMIT_KEY)
1452                 priv->encr_tx_key_index = index;
1453
1454         return 0;
1455 }
1456
1457 static int restore_key(struct usbnet *usbdev, int key_idx)
1458 {
1459         struct rndis_wlan_private *priv = get_rndis_wlan_priv(usbdev);
1460         struct rndis_wlan_encr_key key;
1461
1462         if (is_wpa_key(priv, key_idx))
1463                 return 0;
1464
1465         key = priv->encr_keys[key_idx];
1466
1467         netdev_dbg(usbdev->net, "%s(): %i:%i\n", __func__, key_idx, key.len);
1468
1469         if (key.len == 0)
1470                 return 0;
1471
1472         return add_wep_key(usbdev, key.material, key.len, key_idx);
1473 }
1474
1475 static void restore_keys(struct usbnet *usbdev)
1476 {
1477         int i;
1478
1479         for (i = 0; i < 4; i++)
1480                 restore_key(usbdev, i);
1481 }
1482
1483 static void clear_key(struct rndis_wlan_private *priv, int idx)
1484 {
1485         memset(&priv->encr_keys[idx], 0, sizeof(priv->encr_keys[idx]));
1486 }
1487
1488 /* remove_key is for both wep and wpa */
1489 static int remove_key(struct usbnet *usbdev, int index, const u8 *bssid)
1490 {
1491         struct rndis_wlan_private *priv = get_rndis_wlan_priv(usbdev);
1492         struct ndis_80211_remove_key remove_key;
1493         __le32 keyindex;
1494         bool is_wpa;
1495         int ret;
1496
1497         if (priv->encr_keys[index].len == 0)
1498                 return 0;
1499
1500         is_wpa = is_wpa_key(priv, index);
1501
1502         netdev_dbg(usbdev->net, "%s(): %i:%s:%i\n",
1503                    __func__, index, is_wpa ? "wpa" : "wep",
1504                    priv->encr_keys[index].len);
1505
1506         clear_key(priv, index);
1507
1508         if (is_wpa) {
1509                 remove_key.size = cpu_to_le32(sizeof(remove_key));
1510                 remove_key.index = cpu_to_le32(index);
1511                 if (bssid) {
1512                         /* pairwise key */
1513                         if (!is_broadcast_ether_addr(bssid))
1514                                 remove_key.index |=
1515                                         NDIS_80211_ADDKEY_PAIRWISE_KEY;
1516                         memcpy(remove_key.bssid, bssid,
1517                                         sizeof(remove_key.bssid));
1518                 } else
1519                         memset(remove_key.bssid, 0xff,
1520                                                 sizeof(remove_key.bssid));
1521
1522                 ret = rndis_set_oid(usbdev, OID_802_11_REMOVE_KEY, &remove_key,
1523                                                         sizeof(remove_key));
1524                 if (ret != 0)
1525                         return ret;
1526         } else {
1527                 keyindex = cpu_to_le32(index);
1528                 ret = rndis_set_oid(usbdev, OID_802_11_REMOVE_WEP, &keyindex,
1529                                                         sizeof(keyindex));
1530                 if (ret != 0) {
1531                         netdev_warn(usbdev->net,
1532                                     "removing encryption key %d failed (%08X)\n",
1533                                     index, ret);
1534                         return ret;
1535                 }
1536         }
1537
1538         /* if it is transmit key, disable encryption */
1539         if (index == priv->encr_tx_key_index)
1540                 set_encr_mode(usbdev, RNDIS_WLAN_ALG_NONE, RNDIS_WLAN_ALG_NONE);
1541
1542         return 0;
1543 }
1544
1545 static void set_multicast_list(struct usbnet *usbdev)
1546 {
1547         struct rndis_wlan_private *priv = get_rndis_wlan_priv(usbdev);
1548         struct netdev_hw_addr *ha;
1549         __le32 filter, basefilter;
1550         int ret;
1551         char *mc_addrs = NULL;
1552         int mc_count;
1553
1554         basefilter = filter = RNDIS_PACKET_TYPE_DIRECTED |
1555                               RNDIS_PACKET_TYPE_BROADCAST;
1556
1557         if (usbdev->net->flags & IFF_PROMISC) {
1558                 filter |= RNDIS_PACKET_TYPE_PROMISCUOUS |
1559                         RNDIS_PACKET_TYPE_ALL_LOCAL;
1560         } else if (usbdev->net->flags & IFF_ALLMULTI) {
1561                 filter |= RNDIS_PACKET_TYPE_ALL_MULTICAST;
1562         }
1563
1564         if (filter != basefilter)
1565                 goto set_filter;
1566
1567         /*
1568          * mc_list should be accessed holding the lock, so copy addresses to
1569          * local buffer first.
1570          */
1571         netif_addr_lock_bh(usbdev->net);
1572         mc_count = netdev_mc_count(usbdev->net);
1573         if (mc_count > priv->multicast_size) {
1574                 filter |= RNDIS_PACKET_TYPE_ALL_MULTICAST;
1575         } else if (mc_count) {
1576                 int i = 0;
1577
1578                 mc_addrs = kmalloc(mc_count * ETH_ALEN, GFP_ATOMIC);
1579                 if (!mc_addrs) {
1580                         netdev_warn(usbdev->net,
1581                                     "couldn't alloc %d bytes of memory\n",
1582                                     mc_count * ETH_ALEN);
1583                         netif_addr_unlock_bh(usbdev->net);
1584                         return;
1585                 }
1586
1587                 netdev_for_each_mc_addr(ha, usbdev->net)
1588                         memcpy(mc_addrs + i++ * ETH_ALEN,
1589                                ha->addr, ETH_ALEN);
1590         }
1591         netif_addr_unlock_bh(usbdev->net);
1592
1593         if (filter != basefilter)
1594                 goto set_filter;
1595
1596         if (mc_count) {
1597                 ret = rndis_set_oid(usbdev, OID_802_3_MULTICAST_LIST, mc_addrs,
1598                                     mc_count * ETH_ALEN);
1599                 kfree(mc_addrs);
1600                 if (ret == 0)
1601                         filter |= RNDIS_PACKET_TYPE_MULTICAST;
1602                 else
1603                         filter |= RNDIS_PACKET_TYPE_ALL_MULTICAST;
1604
1605                 netdev_dbg(usbdev->net, "OID_802_3_MULTICAST_LIST(%d, max: %d) -> %d\n",
1606                            mc_count, priv->multicast_size, ret);
1607         }
1608
1609 set_filter:
1610         ret = rndis_set_oid(usbdev, OID_GEN_CURRENT_PACKET_FILTER, &filter,
1611                                                         sizeof(filter));
1612         if (ret < 0) {
1613                 netdev_warn(usbdev->net, "couldn't set packet filter: %08x\n",
1614                             le32_to_cpu(filter));
1615         }
1616
1617         netdev_dbg(usbdev->net, "OID_GEN_CURRENT_PACKET_FILTER(%08x) -> %d\n",
1618                    le32_to_cpu(filter), ret);
1619 }
1620
1621 #ifdef DEBUG
1622 static void debug_print_pmkids(struct usbnet *usbdev,
1623                                 struct ndis_80211_pmkid *pmkids,
1624                                 const char *func_str)
1625 {
1626         struct rndis_wlan_private *priv = get_rndis_wlan_priv(usbdev);
1627         int i, len, count, max_pmkids, entry_len;
1628
1629         max_pmkids = priv->wdev.wiphy->max_num_pmkids;
1630         len = le32_to_cpu(pmkids->length);
1631         count = le32_to_cpu(pmkids->bssid_info_count);
1632
1633         entry_len = (count > 0) ? (len - sizeof(*pmkids)) / count : -1;
1634
1635         netdev_dbg(usbdev->net, "%s(): %d PMKIDs (data len: %d, entry len: "
1636                                 "%d)\n", func_str, count, len, entry_len);
1637
1638         if (count > max_pmkids)
1639                 count = max_pmkids;
1640
1641         for (i = 0; i < count; i++) {
1642                 u32 *tmp = (u32 *)pmkids->bssid_info[i].pmkid;
1643
1644                 netdev_dbg(usbdev->net, "%s():  bssid: %pM, "
1645                                 "pmkid: %08X:%08X:%08X:%08X\n",
1646                                 func_str, pmkids->bssid_info[i].bssid,
1647                                 cpu_to_be32(tmp[0]), cpu_to_be32(tmp[1]),
1648                                 cpu_to_be32(tmp[2]), cpu_to_be32(tmp[3]));
1649         }
1650 }
1651 #else
1652 static void debug_print_pmkids(struct usbnet *usbdev,
1653                                 struct ndis_80211_pmkid *pmkids,
1654                                 const char *func_str)
1655 {
1656         return;
1657 }
1658 #endif
1659
1660 static struct ndis_80211_pmkid *get_device_pmkids(struct usbnet *usbdev)
1661 {
1662         struct rndis_wlan_private *priv = get_rndis_wlan_priv(usbdev);
1663         struct ndis_80211_pmkid *pmkids;
1664         int len, ret, max_pmkids;
1665
1666         max_pmkids = priv->wdev.wiphy->max_num_pmkids;
1667         len = sizeof(*pmkids) + max_pmkids * sizeof(pmkids->bssid_info[0]);
1668
1669         pmkids = kzalloc(len, GFP_KERNEL);
1670         if (!pmkids)
1671                 return ERR_PTR(-ENOMEM);
1672
1673         pmkids->length = cpu_to_le32(len);
1674         pmkids->bssid_info_count = cpu_to_le32(max_pmkids);
1675
1676         ret = rndis_query_oid(usbdev, OID_802_11_PMKID, pmkids, &len);
1677         if (ret < 0) {
1678                 netdev_dbg(usbdev->net, "%s(): OID_802_11_PMKID(%d, %d)"
1679                                 " -> %d\n", __func__, len, max_pmkids, ret);
1680
1681                 kfree(pmkids);
1682                 return ERR_PTR(ret);
1683         }
1684
1685         if (le32_to_cpu(pmkids->bssid_info_count) > max_pmkids)
1686                 pmkids->bssid_info_count = cpu_to_le32(max_pmkids);
1687
1688         debug_print_pmkids(usbdev, pmkids, __func__);
1689
1690         return pmkids;
1691 }
1692
1693 static int set_device_pmkids(struct usbnet *usbdev,
1694                                 struct ndis_80211_pmkid *pmkids)
1695 {
1696         int ret, len, num_pmkids;
1697
1698         num_pmkids = le32_to_cpu(pmkids->bssid_info_count);
1699         len = sizeof(*pmkids) + num_pmkids * sizeof(pmkids->bssid_info[0]);
1700         pmkids->length = cpu_to_le32(len);
1701
1702         debug_print_pmkids(usbdev, pmkids, __func__);
1703
1704         ret = rndis_set_oid(usbdev, OID_802_11_PMKID, pmkids,
1705                                                 le32_to_cpu(pmkids->length));
1706         if (ret < 0) {
1707                 netdev_dbg(usbdev->net, "%s(): OID_802_11_PMKID(%d, %d) -> %d"
1708                                 "\n", __func__, len, num_pmkids, ret);
1709         }
1710
1711         kfree(pmkids);
1712         return ret;
1713 }
1714
1715 static struct ndis_80211_pmkid *remove_pmkid(struct usbnet *usbdev,
1716                                                 struct ndis_80211_pmkid *pmkids,
1717                                                 struct cfg80211_pmksa *pmksa,
1718                                                 int max_pmkids)
1719 {
1720         int i, len, count, newlen, err;
1721
1722         len = le32_to_cpu(pmkids->length);
1723         count = le32_to_cpu(pmkids->bssid_info_count);
1724
1725         if (count > max_pmkids)
1726                 count = max_pmkids;
1727
1728         for (i = 0; i < count; i++)
1729                 if (!compare_ether_addr(pmkids->bssid_info[i].bssid,
1730                                                         pmksa->bssid))
1731                         break;
1732
1733         /* pmkid not found */
1734         if (i == count) {
1735                 netdev_dbg(usbdev->net, "%s(): bssid not found (%pM)\n",
1736                                         __func__, pmksa->bssid);
1737                 err = -ENOENT;
1738                 goto error;
1739         }
1740
1741         for (; i + 1 < count; i++)
1742                 pmkids->bssid_info[i] = pmkids->bssid_info[i + 1];
1743
1744         count--;
1745         newlen = sizeof(*pmkids) + count * sizeof(pmkids->bssid_info[0]);
1746
1747         pmkids->length = cpu_to_le32(newlen);
1748         pmkids->bssid_info_count = cpu_to_le32(count);
1749
1750         return pmkids;
1751 error:
1752         kfree(pmkids);
1753         return ERR_PTR(err);
1754 }
1755
1756 static struct ndis_80211_pmkid *update_pmkid(struct usbnet *usbdev,
1757                                                 struct ndis_80211_pmkid *pmkids,
1758                                                 struct cfg80211_pmksa *pmksa,
1759                                                 int max_pmkids)
1760 {
1761         int i, err, len, count, newlen;
1762
1763         len = le32_to_cpu(pmkids->length);
1764         count = le32_to_cpu(pmkids->bssid_info_count);
1765
1766         if (count > max_pmkids)
1767                 count = max_pmkids;
1768
1769         /* update with new pmkid */
1770         for (i = 0; i < count; i++) {
1771                 if (compare_ether_addr(pmkids->bssid_info[i].bssid,
1772                                                         pmksa->bssid))
1773                         continue;
1774
1775                 memcpy(pmkids->bssid_info[i].pmkid, pmksa->pmkid,
1776                                                                 WLAN_PMKID_LEN);
1777
1778                 return pmkids;
1779         }
1780
1781         /* out of space, return error */
1782         if (i == max_pmkids) {
1783                 netdev_dbg(usbdev->net, "%s(): out of space\n", __func__);
1784                 err = -ENOSPC;
1785                 goto error;
1786         }
1787
1788         /* add new pmkid */
1789         newlen = sizeof(*pmkids) + (count + 1) * sizeof(pmkids->bssid_info[0]);
1790
1791         pmkids = krealloc(pmkids, newlen, GFP_KERNEL);
1792         if (!pmkids) {
1793                 err = -ENOMEM;
1794                 goto error;
1795         }
1796
1797         pmkids->length = cpu_to_le32(newlen);
1798         pmkids->bssid_info_count = cpu_to_le32(count + 1);
1799
1800         memcpy(pmkids->bssid_info[count].bssid, pmksa->bssid, ETH_ALEN);
1801         memcpy(pmkids->bssid_info[count].pmkid, pmksa->pmkid, WLAN_PMKID_LEN);
1802
1803         return pmkids;
1804 error:
1805         kfree(pmkids);
1806         return ERR_PTR(err);
1807 }
1808
1809 /*
1810  * cfg80211 ops
1811  */
1812 static int rndis_change_virtual_intf(struct wiphy *wiphy,
1813                                         struct net_device *dev,
1814                                         enum nl80211_iftype type, u32 *flags,
1815                                         struct vif_params *params)
1816 {
1817         struct rndis_wlan_private *priv = wiphy_priv(wiphy);
1818         struct usbnet *usbdev = priv->usbdev;
1819         int mode;
1820
1821         switch (type) {
1822         case NL80211_IFTYPE_ADHOC:
1823                 mode = NDIS_80211_INFRA_ADHOC;
1824                 break;
1825         case NL80211_IFTYPE_STATION:
1826                 mode = NDIS_80211_INFRA_INFRA;
1827                 break;
1828         default:
1829                 return -EINVAL;
1830         }
1831
1832         priv->wdev.iftype = type;
1833
1834         return set_infra_mode(usbdev, mode);
1835 }
1836
1837 static int rndis_set_wiphy_params(struct wiphy *wiphy, u32 changed)
1838 {
1839         struct rndis_wlan_private *priv = wiphy_priv(wiphy);
1840         struct usbnet *usbdev = priv->usbdev;
1841         int err;
1842
1843         if (changed & WIPHY_PARAM_FRAG_THRESHOLD) {
1844                 err = set_frag_threshold(usbdev, wiphy->frag_threshold);
1845                 if (err < 0)
1846                         return err;
1847         }
1848
1849         if (changed & WIPHY_PARAM_RTS_THRESHOLD) {
1850                 err = set_rts_threshold(usbdev, wiphy->rts_threshold);
1851                 if (err < 0)
1852                         return err;
1853         }
1854
1855         return 0;
1856 }
1857
1858 static int rndis_set_tx_power(struct wiphy *wiphy, enum tx_power_setting type,
1859                                 int dbm)
1860 {
1861         struct rndis_wlan_private *priv = wiphy_priv(wiphy);
1862         struct usbnet *usbdev = priv->usbdev;
1863
1864         netdev_dbg(usbdev->net, "%s(): type:0x%x dbm:%i\n",
1865                    __func__, type, dbm);
1866
1867         /* Device doesn't support changing txpower after initialization, only
1868          * turn off/on radio. Support 'auto' mode and setting same dBm that is
1869          * currently used.
1870          */
1871         if (type == TX_POWER_AUTOMATIC || dbm == get_bcm4320_power_dbm(priv)) {
1872                 if (!priv->radio_on)
1873                         disassociate(usbdev, true); /* turn on radio */
1874
1875                 return 0;
1876         }
1877
1878         return -ENOTSUPP;
1879 }
1880
1881 static int rndis_get_tx_power(struct wiphy *wiphy, int *dbm)
1882 {
1883         struct rndis_wlan_private *priv = wiphy_priv(wiphy);
1884         struct usbnet *usbdev = priv->usbdev;
1885
1886         *dbm = get_bcm4320_power_dbm(priv);
1887
1888         netdev_dbg(usbdev->net, "%s(): dbm:%i\n", __func__, *dbm);
1889
1890         return 0;
1891 }
1892
1893 #define SCAN_DELAY_JIFFIES (6 * HZ)
1894 static int rndis_scan(struct wiphy *wiphy, struct net_device *dev,
1895                         struct cfg80211_scan_request *request)
1896 {
1897         struct usbnet *usbdev = netdev_priv(dev);
1898         struct rndis_wlan_private *priv = get_rndis_wlan_priv(usbdev);
1899         int ret;
1900         __le32 tmp;
1901
1902         netdev_dbg(usbdev->net, "cfg80211.scan\n");
1903
1904         /* Get current bssid list from device before new scan, as new scan
1905          * clears internal bssid list.
1906          */
1907         rndis_check_bssid_list(usbdev);
1908
1909         if (!request)
1910                 return -EINVAL;
1911
1912         if (priv->scan_request && priv->scan_request != request)
1913                 return -EBUSY;
1914
1915         priv->scan_request = request;
1916
1917         tmp = cpu_to_le32(1);
1918         ret = rndis_set_oid(usbdev, OID_802_11_BSSID_LIST_SCAN, &tmp,
1919                                                         sizeof(tmp));
1920         if (ret == 0) {
1921                 /* Wait before retrieving scan results from device */
1922                 queue_delayed_work(priv->workqueue, &priv->scan_work,
1923                         SCAN_DELAY_JIFFIES);
1924         }
1925
1926         return ret;
1927 }
1928
1929 static struct cfg80211_bss *rndis_bss_info_update(struct usbnet *usbdev,
1930                                         struct ndis_80211_bssid_ex *bssid)
1931 {
1932         struct rndis_wlan_private *priv = get_rndis_wlan_priv(usbdev);
1933         struct ieee80211_channel *channel;
1934         s32 signal;
1935         u64 timestamp;
1936         u16 capability;
1937         u16 beacon_interval;
1938         struct ndis_80211_fixed_ies *fixed;
1939         int ie_len, bssid_len;
1940         u8 *ie;
1941
1942         netdev_dbg(usbdev->net, " found bssid: '%.32s' [%pM]\n",
1943                    bssid->ssid.essid, bssid->mac);
1944
1945         /* parse bssid structure */
1946         bssid_len = le32_to_cpu(bssid->length);
1947
1948         if (bssid_len < sizeof(struct ndis_80211_bssid_ex) +
1949                         sizeof(struct ndis_80211_fixed_ies))
1950                 return NULL;
1951
1952         fixed = (struct ndis_80211_fixed_ies *)bssid->ies;
1953
1954         ie = (void *)(bssid->ies + sizeof(struct ndis_80211_fixed_ies));
1955         ie_len = min(bssid_len - (int)sizeof(*bssid),
1956                                         (int)le32_to_cpu(bssid->ie_length));
1957         ie_len -= sizeof(struct ndis_80211_fixed_ies);
1958         if (ie_len < 0)
1959                 return NULL;
1960
1961         /* extract data for cfg80211_inform_bss */
1962         channel = ieee80211_get_channel(priv->wdev.wiphy,
1963                         KHZ_TO_MHZ(le32_to_cpu(bssid->config.ds_config)));
1964         if (!channel)
1965                 return NULL;
1966
1967         signal = level_to_qual(le32_to_cpu(bssid->rssi));
1968         timestamp = le64_to_cpu(*(__le64 *)fixed->timestamp);
1969         capability = le16_to_cpu(fixed->capabilities);
1970         beacon_interval = le16_to_cpu(fixed->beacon_interval);
1971
1972         return cfg80211_inform_bss(priv->wdev.wiphy, channel, bssid->mac,
1973                 timestamp, capability, beacon_interval, ie, ie_len, signal,
1974                 GFP_KERNEL);
1975 }
1976
1977 static int rndis_check_bssid_list(struct usbnet *usbdev)
1978 {
1979         void *buf = NULL;
1980         struct ndis_80211_bssid_list_ex *bssid_list;
1981         struct ndis_80211_bssid_ex *bssid;
1982         int ret = -EINVAL, len, count, bssid_len;
1983         bool resized = false;
1984
1985         netdev_dbg(usbdev->net, "check_bssid_list\n");
1986
1987         len = CONTROL_BUFFER_SIZE;
1988 resize_buf:
1989         buf = kmalloc(len, GFP_KERNEL);
1990         if (!buf) {
1991                 ret = -ENOMEM;
1992                 goto out;
1993         }
1994
1995         ret = rndis_query_oid(usbdev, OID_802_11_BSSID_LIST, buf, &len);
1996         if (ret != 0)
1997                 goto out;
1998
1999         if (!resized && len > CONTROL_BUFFER_SIZE) {
2000                 resized = true;
2001                 kfree(buf);
2002                 goto resize_buf;
2003         }
2004
2005         bssid_list = buf;
2006         bssid = bssid_list->bssid;
2007         bssid_len = le32_to_cpu(bssid->length);
2008         count = le32_to_cpu(bssid_list->num_items);
2009         netdev_dbg(usbdev->net, "check_bssid_list: %d BSSIDs found (buflen: %d)\n",
2010                    count, len);
2011
2012         while (count && ((void *)bssid + bssid_len) <= (buf + len)) {
2013                 rndis_bss_info_update(usbdev, bssid);
2014
2015                 bssid = (void *)bssid + bssid_len;
2016                 bssid_len = le32_to_cpu(bssid->length);
2017                 count--;
2018         }
2019
2020 out:
2021         kfree(buf);
2022         return ret;
2023 }
2024
2025 static void rndis_get_scan_results(struct work_struct *work)
2026 {
2027         struct rndis_wlan_private *priv =
2028                 container_of(work, struct rndis_wlan_private, scan_work.work);
2029         struct usbnet *usbdev = priv->usbdev;
2030         int ret;
2031
2032         netdev_dbg(usbdev->net, "get_scan_results\n");
2033
2034         if (!priv->scan_request)
2035                 return;
2036
2037         ret = rndis_check_bssid_list(usbdev);
2038
2039         cfg80211_scan_done(priv->scan_request, ret < 0);
2040
2041         priv->scan_request = NULL;
2042 }
2043
2044 static int rndis_connect(struct wiphy *wiphy, struct net_device *dev,
2045                                         struct cfg80211_connect_params *sme)
2046 {
2047         struct rndis_wlan_private *priv = wiphy_priv(wiphy);
2048         struct usbnet *usbdev = priv->usbdev;
2049         struct ieee80211_channel *channel = sme->channel;
2050         struct ndis_80211_ssid ssid;
2051         int pairwise = RNDIS_WLAN_ALG_NONE;
2052         int groupwise = RNDIS_WLAN_ALG_NONE;
2053         int keymgmt = RNDIS_WLAN_KEY_MGMT_NONE;
2054         int length, i, ret, chan = -1;
2055
2056         if (channel)
2057                 chan = ieee80211_frequency_to_channel(channel->center_freq);
2058
2059         groupwise = rndis_cipher_to_alg(sme->crypto.cipher_group);
2060         for (i = 0; i < sme->crypto.n_ciphers_pairwise; i++)
2061                 pairwise |=
2062                         rndis_cipher_to_alg(sme->crypto.ciphers_pairwise[i]);
2063
2064         if (sme->crypto.n_ciphers_pairwise > 0 &&
2065                         pairwise == RNDIS_WLAN_ALG_NONE) {
2066                 netdev_err(usbdev->net, "Unsupported pairwise cipher\n");
2067                 return -ENOTSUPP;
2068         }
2069
2070         for (i = 0; i < sme->crypto.n_akm_suites; i++)
2071                 keymgmt |=
2072                         rndis_akm_suite_to_key_mgmt(sme->crypto.akm_suites[i]);
2073
2074         if (sme->crypto.n_akm_suites > 0 &&
2075                         keymgmt == RNDIS_WLAN_KEY_MGMT_NONE) {
2076                 netdev_err(usbdev->net, "Invalid keymgmt\n");
2077                 return -ENOTSUPP;
2078         }
2079
2080         netdev_dbg(usbdev->net, "cfg80211.connect('%.32s':[%pM]:%d:[%d,0x%x:0x%x]:[0x%x:0x%x]:0x%x)\n",
2081                    sme->ssid, sme->bssid, chan,
2082                    sme->privacy, sme->crypto.wpa_versions, sme->auth_type,
2083                    groupwise, pairwise, keymgmt);
2084
2085         if (is_associated(usbdev))
2086                 disassociate(usbdev, false);
2087
2088         ret = set_infra_mode(usbdev, NDIS_80211_INFRA_INFRA);
2089         if (ret < 0) {
2090                 netdev_dbg(usbdev->net, "connect: set_infra_mode failed, %d\n",
2091                            ret);
2092                 goto err_turn_radio_on;
2093         }
2094
2095         ret = set_auth_mode(usbdev, sme->crypto.wpa_versions, sme->auth_type,
2096                                                                 keymgmt);
2097         if (ret < 0) {
2098                 netdev_dbg(usbdev->net, "connect: set_auth_mode failed, %d\n",
2099                            ret);
2100                 goto err_turn_radio_on;
2101         }
2102
2103         set_priv_filter(usbdev);
2104
2105         ret = set_encr_mode(usbdev, pairwise, groupwise);
2106         if (ret < 0) {
2107                 netdev_dbg(usbdev->net, "connect: set_encr_mode failed, %d\n",
2108                            ret);
2109                 goto err_turn_radio_on;
2110         }
2111
2112         if (channel) {
2113                 ret = set_channel(usbdev, chan);
2114                 if (ret < 0) {
2115                         netdev_dbg(usbdev->net, "connect: set_channel failed, %d\n",
2116                                    ret);
2117                         goto err_turn_radio_on;
2118                 }
2119         }
2120
2121         if (sme->key && ((groupwise | pairwise) & RNDIS_WLAN_ALG_WEP)) {
2122                 priv->encr_tx_key_index = sme->key_idx;
2123                 ret = add_wep_key(usbdev, sme->key, sme->key_len, sme->key_idx);
2124                 if (ret < 0) {
2125                         netdev_dbg(usbdev->net, "connect: add_wep_key failed, %d (%d, %d)\n",
2126                                    ret, sme->key_len, sme->key_idx);
2127                         goto err_turn_radio_on;
2128                 }
2129         }
2130
2131         if (sme->bssid && !is_zero_ether_addr(sme->bssid) &&
2132                                 !is_broadcast_ether_addr(sme->bssid)) {
2133                 ret = set_bssid(usbdev, sme->bssid);
2134                 if (ret < 0) {
2135                         netdev_dbg(usbdev->net, "connect: set_bssid failed, %d\n",
2136                                    ret);
2137                         goto err_turn_radio_on;
2138                 }
2139         } else
2140                 clear_bssid(usbdev);
2141
2142         length = sme->ssid_len;
2143         if (length > NDIS_802_11_LENGTH_SSID)
2144                 length = NDIS_802_11_LENGTH_SSID;
2145
2146         memset(&ssid, 0, sizeof(ssid));
2147         ssid.length = cpu_to_le32(length);
2148         memcpy(ssid.essid, sme->ssid, length);
2149
2150         /* Pause and purge rx queue, so we don't pass packets before
2151          * 'media connect'-indication.
2152          */
2153         usbnet_pause_rx(usbdev);
2154         usbnet_purge_paused_rxq(usbdev);
2155
2156         ret = set_essid(usbdev, &ssid);
2157         if (ret < 0)
2158                 netdev_dbg(usbdev->net, "connect: set_essid failed, %d\n", ret);
2159         return ret;
2160
2161 err_turn_radio_on:
2162         disassociate(usbdev, true);
2163
2164         return ret;
2165 }
2166
2167 static int rndis_disconnect(struct wiphy *wiphy, struct net_device *dev,
2168                                                                 u16 reason_code)
2169 {
2170         struct rndis_wlan_private *priv = wiphy_priv(wiphy);
2171         struct usbnet *usbdev = priv->usbdev;
2172
2173         netdev_dbg(usbdev->net, "cfg80211.disconnect(%d)\n", reason_code);
2174
2175         priv->connected = false;
2176         memset(priv->bssid, 0, ETH_ALEN);
2177
2178         return deauthenticate(usbdev);
2179 }
2180
2181 static int rndis_join_ibss(struct wiphy *wiphy, struct net_device *dev,
2182                                         struct cfg80211_ibss_params *params)
2183 {
2184         struct rndis_wlan_private *priv = wiphy_priv(wiphy);
2185         struct usbnet *usbdev = priv->usbdev;
2186         struct ieee80211_channel *channel = params->channel;
2187         struct ndis_80211_ssid ssid;
2188         enum nl80211_auth_type auth_type;
2189         int ret, alg, length, chan = -1;
2190
2191         if (channel)
2192                 chan = ieee80211_frequency_to_channel(channel->center_freq);
2193
2194         /* TODO: How to handle ad-hoc encryption?
2195          * connect() has *key, join_ibss() doesn't. RNDIS requires key to be
2196          * pre-shared for encryption (open/shared/wpa), is key set before
2197          * join_ibss? Which auth_type to use (not in params)? What about WPA?
2198          */
2199         if (params->privacy) {
2200                 auth_type = NL80211_AUTHTYPE_SHARED_KEY;
2201                 alg = RNDIS_WLAN_ALG_WEP;
2202         } else {
2203                 auth_type = NL80211_AUTHTYPE_OPEN_SYSTEM;
2204                 alg = RNDIS_WLAN_ALG_NONE;
2205         }
2206
2207         netdev_dbg(usbdev->net, "cfg80211.join_ibss('%.32s':[%pM]:%d:%d)\n",
2208                    params->ssid, params->bssid, chan, params->privacy);
2209
2210         if (is_associated(usbdev))
2211                 disassociate(usbdev, false);
2212
2213         ret = set_infra_mode(usbdev, NDIS_80211_INFRA_ADHOC);
2214         if (ret < 0) {
2215                 netdev_dbg(usbdev->net, "join_ibss: set_infra_mode failed, %d\n",
2216                            ret);
2217                 goto err_turn_radio_on;
2218         }
2219
2220         ret = set_auth_mode(usbdev, 0, auth_type, RNDIS_WLAN_KEY_MGMT_NONE);
2221         if (ret < 0) {
2222                 netdev_dbg(usbdev->net, "join_ibss: set_auth_mode failed, %d\n",
2223                            ret);
2224                 goto err_turn_radio_on;
2225         }
2226
2227         set_priv_filter(usbdev);
2228
2229         ret = set_encr_mode(usbdev, alg, RNDIS_WLAN_ALG_NONE);
2230         if (ret < 0) {
2231                 netdev_dbg(usbdev->net, "join_ibss: set_encr_mode failed, %d\n",
2232                            ret);
2233                 goto err_turn_radio_on;
2234         }
2235
2236         if (channel) {
2237                 ret = set_channel(usbdev, chan);
2238                 if (ret < 0) {
2239                         netdev_dbg(usbdev->net, "join_ibss: set_channel failed, %d\n",
2240                                    ret);
2241                         goto err_turn_radio_on;
2242                 }
2243         }
2244
2245         if (params->bssid && !is_zero_ether_addr(params->bssid) &&
2246                                 !is_broadcast_ether_addr(params->bssid)) {
2247                 ret = set_bssid(usbdev, params->bssid);
2248                 if (ret < 0) {
2249                         netdev_dbg(usbdev->net, "join_ibss: set_bssid failed, %d\n",
2250                                    ret);
2251                         goto err_turn_radio_on;
2252                 }
2253         } else
2254                 clear_bssid(usbdev);
2255
2256         length = params->ssid_len;
2257         if (length > NDIS_802_11_LENGTH_SSID)
2258                 length = NDIS_802_11_LENGTH_SSID;
2259
2260         memset(&ssid, 0, sizeof(ssid));
2261         ssid.length = cpu_to_le32(length);
2262         memcpy(ssid.essid, params->ssid, length);
2263
2264         /* Don't need to pause rx queue for ad-hoc. */
2265         usbnet_purge_paused_rxq(usbdev);
2266         usbnet_resume_rx(usbdev);
2267
2268         ret = set_essid(usbdev, &ssid);
2269         if (ret < 0)
2270                 netdev_dbg(usbdev->net, "join_ibss: set_essid failed, %d\n",
2271                            ret);
2272         return ret;
2273
2274 err_turn_radio_on:
2275         disassociate(usbdev, true);
2276
2277         return ret;
2278 }
2279
2280 static int rndis_leave_ibss(struct wiphy *wiphy, struct net_device *dev)
2281 {
2282         struct rndis_wlan_private *priv = wiphy_priv(wiphy);
2283         struct usbnet *usbdev = priv->usbdev;
2284
2285         netdev_dbg(usbdev->net, "cfg80211.leave_ibss()\n");
2286
2287         priv->connected = false;
2288         memset(priv->bssid, 0, ETH_ALEN);
2289
2290         return deauthenticate(usbdev);
2291 }
2292
2293 static int rndis_set_channel(struct wiphy *wiphy,
2294         struct ieee80211_channel *chan, enum nl80211_channel_type channel_type)
2295 {
2296         struct rndis_wlan_private *priv = wiphy_priv(wiphy);
2297         struct usbnet *usbdev = priv->usbdev;
2298
2299         return set_channel(usbdev,
2300                         ieee80211_frequency_to_channel(chan->center_freq));
2301 }
2302
2303 static int rndis_add_key(struct wiphy *wiphy, struct net_device *netdev,
2304                                         u8 key_index, const u8 *mac_addr,
2305                                         struct key_params *params)
2306 {
2307         struct rndis_wlan_private *priv = wiphy_priv(wiphy);
2308         struct usbnet *usbdev = priv->usbdev;
2309         __le32 flags;
2310
2311         netdev_dbg(usbdev->net, "%s(%i, %pM, %08x)\n",
2312                    __func__, key_index, mac_addr, params->cipher);
2313
2314         switch (params->cipher) {
2315         case WLAN_CIPHER_SUITE_WEP40:
2316         case WLAN_CIPHER_SUITE_WEP104:
2317                 return add_wep_key(usbdev, params->key, params->key_len,
2318                                                                 key_index);
2319         case WLAN_CIPHER_SUITE_TKIP:
2320         case WLAN_CIPHER_SUITE_CCMP:
2321                 flags = 0;
2322
2323                 if (params->seq && params->seq_len > 0)
2324                         flags |= NDIS_80211_ADDKEY_SET_INIT_RECV_SEQ;
2325                 if (mac_addr)
2326                         flags |= NDIS_80211_ADDKEY_PAIRWISE_KEY |
2327                                         NDIS_80211_ADDKEY_TRANSMIT_KEY;
2328
2329                 return add_wpa_key(usbdev, params->key, params->key_len,
2330                                 key_index, mac_addr, params->seq,
2331                                 params->seq_len, params->cipher, flags);
2332         default:
2333                 netdev_dbg(usbdev->net, "%s(): unsupported cipher %08x\n",
2334                            __func__, params->cipher);
2335                 return -ENOTSUPP;
2336         }
2337 }
2338
2339 static int rndis_del_key(struct wiphy *wiphy, struct net_device *netdev,
2340                                         u8 key_index, const u8 *mac_addr)
2341 {
2342         struct rndis_wlan_private *priv = wiphy_priv(wiphy);
2343         struct usbnet *usbdev = priv->usbdev;
2344
2345         netdev_dbg(usbdev->net, "%s(%i, %pM)\n", __func__, key_index, mac_addr);
2346
2347         return remove_key(usbdev, key_index, mac_addr);
2348 }
2349
2350 static int rndis_set_default_key(struct wiphy *wiphy, struct net_device *netdev,
2351                                                                 u8 key_index)
2352 {
2353         struct rndis_wlan_private *priv = wiphy_priv(wiphy);
2354         struct usbnet *usbdev = priv->usbdev;
2355         struct rndis_wlan_encr_key key;
2356
2357         netdev_dbg(usbdev->net, "%s(%i)\n", __func__, key_index);
2358
2359         priv->encr_tx_key_index = key_index;
2360
2361         key = priv->encr_keys[key_index];
2362
2363         return add_wep_key(usbdev, key.material, key.len, key_index);
2364 }
2365
2366 static void rndis_fill_station_info(struct usbnet *usbdev,
2367                                                 struct station_info *sinfo)
2368 {
2369         __le32 linkspeed, rssi;
2370         int ret, len;
2371
2372         memset(sinfo, 0, sizeof(*sinfo));
2373
2374         len = sizeof(linkspeed);
2375         ret = rndis_query_oid(usbdev, OID_GEN_LINK_SPEED, &linkspeed, &len);
2376         if (ret == 0) {
2377                 sinfo->txrate.legacy = le32_to_cpu(linkspeed) / 1000;
2378                 sinfo->filled |= STATION_INFO_TX_BITRATE;
2379         }
2380
2381         len = sizeof(rssi);
2382         ret = rndis_query_oid(usbdev, OID_802_11_RSSI, &rssi, &len);
2383         if (ret == 0) {
2384                 sinfo->signal = level_to_qual(le32_to_cpu(rssi));
2385                 sinfo->filled |= STATION_INFO_SIGNAL;
2386         }
2387 }
2388
2389 static int rndis_get_station(struct wiphy *wiphy, struct net_device *dev,
2390                                         u8 *mac, struct station_info *sinfo)
2391 {
2392         struct rndis_wlan_private *priv = wiphy_priv(wiphy);
2393         struct usbnet *usbdev = priv->usbdev;
2394
2395         if (compare_ether_addr(priv->bssid, mac))
2396                 return -ENOENT;
2397
2398         rndis_fill_station_info(usbdev, sinfo);
2399
2400         return 0;
2401 }
2402
2403 static int rndis_dump_station(struct wiphy *wiphy, struct net_device *dev,
2404                                int idx, u8 *mac, struct station_info *sinfo)
2405 {
2406         struct rndis_wlan_private *priv = wiphy_priv(wiphy);
2407         struct usbnet *usbdev = priv->usbdev;
2408
2409         if (idx != 0)
2410                 return -ENOENT;
2411
2412         memcpy(mac, priv->bssid, ETH_ALEN);
2413
2414         rndis_fill_station_info(usbdev, sinfo);
2415
2416         return 0;
2417 }
2418
2419 static int rndis_set_pmksa(struct wiphy *wiphy, struct net_device *netdev,
2420                                 struct cfg80211_pmksa *pmksa)
2421 {
2422         struct rndis_wlan_private *priv = wiphy_priv(wiphy);
2423         struct usbnet *usbdev = priv->usbdev;
2424         struct ndis_80211_pmkid *pmkids;
2425         u32 *tmp = (u32 *)pmksa->pmkid;
2426
2427         netdev_dbg(usbdev->net, "%s(%pM, %08X:%08X:%08X:%08X)\n", __func__,
2428                         pmksa->bssid,
2429                         cpu_to_be32(tmp[0]), cpu_to_be32(tmp[1]),
2430                         cpu_to_be32(tmp[2]), cpu_to_be32(tmp[3]));
2431
2432         pmkids = get_device_pmkids(usbdev);
2433         if (IS_ERR(pmkids)) {
2434                 /* couldn't read PMKID cache from device */
2435                 return PTR_ERR(pmkids);
2436         }
2437
2438         pmkids = update_pmkid(usbdev, pmkids, pmksa, wiphy->max_num_pmkids);
2439         if (IS_ERR(pmkids)) {
2440                 /* not found, list full, etc */
2441                 return PTR_ERR(pmkids);
2442         }
2443
2444         return set_device_pmkids(usbdev, pmkids);
2445 }
2446
2447 static int rndis_del_pmksa(struct wiphy *wiphy, struct net_device *netdev,
2448                                 struct cfg80211_pmksa *pmksa)
2449 {
2450         struct rndis_wlan_private *priv = wiphy_priv(wiphy);
2451         struct usbnet *usbdev = priv->usbdev;
2452         struct ndis_80211_pmkid *pmkids;
2453         u32 *tmp = (u32 *)pmksa->pmkid;
2454
2455         netdev_dbg(usbdev->net, "%s(%pM, %08X:%08X:%08X:%08X)\n", __func__,
2456                         pmksa->bssid,
2457                         cpu_to_be32(tmp[0]), cpu_to_be32(tmp[1]),
2458                         cpu_to_be32(tmp[2]), cpu_to_be32(tmp[3]));
2459
2460         pmkids = get_device_pmkids(usbdev);
2461         if (IS_ERR(pmkids)) {
2462                 /* Couldn't read PMKID cache from device */
2463                 return PTR_ERR(pmkids);
2464         }
2465
2466         pmkids = remove_pmkid(usbdev, pmkids, pmksa, wiphy->max_num_pmkids);
2467         if (IS_ERR(pmkids)) {
2468                 /* not found, etc */
2469                 return PTR_ERR(pmkids);
2470         }
2471
2472         return set_device_pmkids(usbdev, pmkids);
2473 }
2474
2475 static int rndis_flush_pmksa(struct wiphy *wiphy, struct net_device *netdev)
2476 {
2477         struct rndis_wlan_private *priv = wiphy_priv(wiphy);
2478         struct usbnet *usbdev = priv->usbdev;
2479         struct ndis_80211_pmkid pmkid;
2480
2481         netdev_dbg(usbdev->net, "%s()\n", __func__);
2482
2483         memset(&pmkid, 0, sizeof(pmkid));
2484
2485         pmkid.length = cpu_to_le32(sizeof(pmkid));
2486         pmkid.bssid_info_count = cpu_to_le32(0);
2487
2488         return rndis_set_oid(usbdev, OID_802_11_PMKID, &pmkid, sizeof(pmkid));
2489 }
2490
2491 /*
2492  * workers, indication handlers, device poller
2493  */
2494 static void rndis_wlan_do_link_up_work(struct usbnet *usbdev)
2495 {
2496         struct rndis_wlan_private *priv = get_rndis_wlan_priv(usbdev);
2497         struct ndis_80211_assoc_info *info;
2498         u8 assoc_buf[sizeof(*info) + IW_CUSTOM_MAX + 32];
2499         u8 bssid[ETH_ALEN];
2500         int resp_ie_len, req_ie_len;
2501         u8 *req_ie, *resp_ie;
2502         int ret, offset;
2503         bool roamed = false;
2504
2505         if (priv->infra_mode == NDIS_80211_INFRA_INFRA && priv->connected) {
2506                 /* received media connect indication while connected, either
2507                  * device reassociated with same AP or roamed to new. */
2508                 roamed = true;
2509         }
2510
2511         req_ie_len = 0;
2512         resp_ie_len = 0;
2513         req_ie = NULL;
2514         resp_ie = NULL;
2515
2516         if (priv->infra_mode == NDIS_80211_INFRA_INFRA) {
2517                 memset(assoc_buf, 0, sizeof(assoc_buf));
2518                 info = (void *)assoc_buf;
2519
2520                 /* Get association info IEs from device and send them back to
2521                  * userspace. */
2522                 ret = get_association_info(usbdev, info, sizeof(assoc_buf));
2523                 if (!ret) {
2524                         req_ie_len = le32_to_cpu(info->req_ie_length);
2525                         if (req_ie_len > 0) {
2526                                 offset = le32_to_cpu(info->offset_req_ies);
2527                                 req_ie = (u8 *)info + offset;
2528                         }
2529
2530                         resp_ie_len = le32_to_cpu(info->resp_ie_length);
2531                         if (resp_ie_len > 0) {
2532                                 offset = le32_to_cpu(info->offset_resp_ies);
2533                                 resp_ie = (u8 *)info + offset;
2534                         }
2535                 }
2536         } else if (WARN_ON(priv->infra_mode != NDIS_80211_INFRA_ADHOC))
2537                 return;
2538
2539         ret = get_bssid(usbdev, bssid);
2540         if (ret < 0)
2541                 memset(bssid, 0, sizeof(bssid));
2542
2543         netdev_dbg(usbdev->net, "link up work: [%pM]%s\n",
2544                    bssid, roamed ? " roamed" : "");
2545
2546         /* Internal bss list in device always contains at least the currently
2547          * connected bss and we can get it to cfg80211 with
2548          * rndis_check_bssid_list().
2549          * NOTE: This is true for Broadcom chip, but not mentioned in RNDIS
2550          * spec.
2551          */
2552         rndis_check_bssid_list(usbdev);
2553
2554         if (priv->infra_mode == NDIS_80211_INFRA_INFRA) {
2555                 if (!roamed)
2556                         cfg80211_connect_result(usbdev->net, bssid, req_ie,
2557                                                 req_ie_len, resp_ie,
2558                                                 resp_ie_len, 0, GFP_KERNEL);
2559                 else
2560                         cfg80211_roamed(usbdev->net, bssid, req_ie, req_ie_len,
2561                                         resp_ie, resp_ie_len, GFP_KERNEL);
2562         } else if (priv->infra_mode == NDIS_80211_INFRA_ADHOC)
2563                 cfg80211_ibss_joined(usbdev->net, bssid, GFP_KERNEL);
2564
2565         priv->connected = true;
2566         memcpy(priv->bssid, bssid, ETH_ALEN);
2567
2568         usbnet_resume_rx(usbdev);
2569         netif_carrier_on(usbdev->net);
2570 }
2571
2572 static void rndis_wlan_do_link_down_work(struct usbnet *usbdev)
2573 {
2574         union iwreq_data evt;
2575
2576         netif_carrier_off(usbdev->net);
2577
2578         evt.data.flags = 0;
2579         evt.data.length = 0;
2580         memset(evt.ap_addr.sa_data, 0, ETH_ALEN);
2581         wireless_send_event(usbdev->net, SIOCGIWAP, &evt, NULL);
2582 }
2583
2584 static void rndis_wlan_worker(struct work_struct *work)
2585 {
2586         struct rndis_wlan_private *priv =
2587                 container_of(work, struct rndis_wlan_private, work);
2588         struct usbnet *usbdev = priv->usbdev;
2589
2590         if (test_and_clear_bit(WORK_LINK_UP, &priv->work_pending))
2591                 rndis_wlan_do_link_up_work(usbdev);
2592
2593         if (test_and_clear_bit(WORK_LINK_DOWN, &priv->work_pending))
2594                 rndis_wlan_do_link_down_work(usbdev);
2595
2596         if (test_and_clear_bit(WORK_SET_MULTICAST_LIST, &priv->work_pending))
2597                 set_multicast_list(usbdev);
2598 }
2599
2600 static void rndis_wlan_set_multicast_list(struct net_device *dev)
2601 {
2602         struct usbnet *usbdev = netdev_priv(dev);
2603         struct rndis_wlan_private *priv = get_rndis_wlan_priv(usbdev);
2604
2605         if (test_bit(WORK_SET_MULTICAST_LIST, &priv->work_pending))
2606                 return;
2607
2608         set_bit(WORK_SET_MULTICAST_LIST, &priv->work_pending);
2609         queue_work(priv->workqueue, &priv->work);
2610 }
2611
2612 static void rndis_wlan_auth_indication(struct usbnet *usbdev,
2613                                 struct ndis_80211_status_indication *indication,
2614                                 int len)
2615 {
2616         u8 *buf;
2617         const char *type;
2618         int flags, buflen, key_id;
2619         bool pairwise_error, group_error;
2620         struct ndis_80211_auth_request *auth_req;
2621         enum nl80211_key_type key_type;
2622
2623         /* must have at least one array entry */
2624         if (len < offsetof(struct ndis_80211_status_indication, u) +
2625                                 sizeof(struct ndis_80211_auth_request)) {
2626                 netdev_info(usbdev->net, "authentication indication: too short message (%i)\n",
2627                             len);
2628                 return;
2629         }
2630
2631         buf = (void *)&indication->u.auth_request[0];
2632         buflen = len - offsetof(struct ndis_80211_status_indication, u);
2633
2634         while (buflen >= sizeof(*auth_req)) {
2635                 auth_req = (void *)buf;
2636                 type = "unknown";
2637                 flags = le32_to_cpu(auth_req->flags);
2638                 pairwise_error = false;
2639                 group_error = false;
2640
2641                 if (flags & 0x1)
2642                         type = "reauth request";
2643                 if (flags & 0x2)
2644                         type = "key update request";
2645                 if (flags & 0x6) {
2646                         pairwise_error = true;
2647                         type = "pairwise_error";
2648                 }
2649                 if (flags & 0xe) {
2650                         group_error = true;
2651                         type = "group_error";
2652                 }
2653
2654                 netdev_info(usbdev->net, "authentication indication: %s (0x%08x)\n",
2655                             type, le32_to_cpu(auth_req->flags));
2656
2657                 if (pairwise_error) {
2658                         key_type = NL80211_KEYTYPE_PAIRWISE;
2659                         key_id = -1;
2660
2661                         cfg80211_michael_mic_failure(usbdev->net,
2662                                                         auth_req->bssid,
2663                                                         key_type, key_id, NULL,
2664                                                         GFP_KERNEL);
2665                 }
2666
2667                 if (group_error) {
2668                         key_type = NL80211_KEYTYPE_GROUP;
2669                         key_id = -1;
2670
2671                         cfg80211_michael_mic_failure(usbdev->net,
2672                                                         auth_req->bssid,
2673                                                         key_type, key_id, NULL,
2674                                                         GFP_KERNEL);
2675                 }
2676
2677                 buflen -= le32_to_cpu(auth_req->length);
2678                 buf += le32_to_cpu(auth_req->length);
2679         }
2680 }
2681
2682 static void rndis_wlan_pmkid_cand_list_indication(struct usbnet *usbdev,
2683                                 struct ndis_80211_status_indication *indication,
2684                                 int len)
2685 {
2686         struct ndis_80211_pmkid_cand_list *cand_list;
2687         int list_len, expected_len, i;
2688
2689         if (len < offsetof(struct ndis_80211_status_indication, u) +
2690                                 sizeof(struct ndis_80211_pmkid_cand_list)) {
2691                 netdev_info(usbdev->net, "pmkid candidate list indication: too short message (%i)\n",
2692                             len);
2693                 return;
2694         }
2695
2696         list_len = le32_to_cpu(indication->u.cand_list.num_candidates) *
2697                         sizeof(struct ndis_80211_pmkid_candidate);
2698         expected_len = sizeof(struct ndis_80211_pmkid_cand_list) + list_len +
2699                         offsetof(struct ndis_80211_status_indication, u);
2700
2701         if (len < expected_len) {
2702                 netdev_info(usbdev->net, "pmkid candidate list indication: list larger than buffer (%i < %i)\n",
2703                             len, expected_len);
2704                 return;
2705         }
2706
2707         cand_list = &indication->u.cand_list;
2708
2709         netdev_info(usbdev->net, "pmkid candidate list indication: version %i, candidates %i\n",
2710                     le32_to_cpu(cand_list->version),
2711                     le32_to_cpu(cand_list->num_candidates));
2712
2713         if (le32_to_cpu(cand_list->version) != 1)
2714                 return;
2715
2716         for (i = 0; i < le32_to_cpu(cand_list->num_candidates); i++) {
2717                 struct ndis_80211_pmkid_candidate *cand =
2718                                                 &cand_list->candidate_list[i];
2719
2720                 netdev_dbg(usbdev->net, "cand[%i]: flags: 0x%08x, bssid: %pM\n",
2721                            i, le32_to_cpu(cand->flags), cand->bssid);
2722
2723 #if 0
2724                 struct iw_pmkid_cand pcand;
2725                 union iwreq_data wrqu;
2726
2727                 memset(&pcand, 0, sizeof(pcand));
2728                 if (le32_to_cpu(cand->flags) & 0x01)
2729                         pcand.flags |= IW_PMKID_CAND_PREAUTH;
2730                 pcand.index = i;
2731                 memcpy(pcand.bssid.sa_data, cand->bssid, ETH_ALEN);
2732
2733                 memset(&wrqu, 0, sizeof(wrqu));
2734                 wrqu.data.length = sizeof(pcand);
2735                 wireless_send_event(usbdev->net, IWEVPMKIDCAND, &wrqu,
2736                                                                 (u8 *)&pcand);
2737 #endif
2738         }
2739 }
2740
2741 static void rndis_wlan_media_specific_indication(struct usbnet *usbdev,
2742                         struct rndis_indicate *msg, int buflen)
2743 {
2744         struct ndis_80211_status_indication *indication;
2745         int len, offset;
2746
2747         offset = offsetof(struct rndis_indicate, status) +
2748                         le32_to_cpu(msg->offset);
2749         len = le32_to_cpu(msg->length);
2750
2751         if (len < 8) {
2752                 netdev_info(usbdev->net, "media specific indication, ignore too short message (%i < 8)\n",
2753                             len);
2754                 return;
2755         }
2756
2757         if (offset + len > buflen) {
2758                 netdev_info(usbdev->net, "media specific indication, too large to fit to buffer (%i > %i)\n",
2759                             offset + len, buflen);
2760                 return;
2761         }
2762
2763         indication = (void *)((u8 *)msg + offset);
2764
2765         switch (le32_to_cpu(indication->status_type)) {
2766         case NDIS_80211_STATUSTYPE_RADIOSTATE:
2767                 netdev_info(usbdev->net, "radio state indication: %i\n",
2768                             le32_to_cpu(indication->u.radio_status));
2769                 return;
2770
2771         case NDIS_80211_STATUSTYPE_MEDIASTREAMMODE:
2772                 netdev_info(usbdev->net, "media stream mode indication: %i\n",
2773                             le32_to_cpu(indication->u.media_stream_mode));
2774                 return;
2775
2776         case NDIS_80211_STATUSTYPE_AUTHENTICATION:
2777                 rndis_wlan_auth_indication(usbdev, indication, len);
2778                 return;
2779
2780         case NDIS_80211_STATUSTYPE_PMKID_CANDIDATELIST:
2781                 rndis_wlan_pmkid_cand_list_indication(usbdev, indication, len);
2782                 return;
2783
2784         default:
2785                 netdev_info(usbdev->net, "media specific indication: unknown status type 0x%08x\n",
2786                             le32_to_cpu(indication->status_type));
2787         }
2788 }
2789
2790 static void rndis_wlan_indication(struct usbnet *usbdev, void *ind, int buflen)
2791 {
2792         struct rndis_wlan_private *priv = get_rndis_wlan_priv(usbdev);
2793         struct rndis_indicate *msg = ind;
2794
2795         switch (msg->status) {
2796         case RNDIS_STATUS_MEDIA_CONNECT:
2797                 if (priv->current_command_oid == OID_802_11_ADD_KEY) {
2798                         /* OID_802_11_ADD_KEY causes sometimes extra
2799                          * "media connect" indications which confuses driver
2800                          * and userspace to think that device is
2801                          * roaming/reassociating when it isn't.
2802                          */
2803                         netdev_dbg(usbdev->net, "ignored OID_802_11_ADD_KEY triggered 'media connect'\n");
2804                         return;
2805                 }
2806
2807                 usbnet_pause_rx(usbdev);
2808
2809                 netdev_info(usbdev->net, "media connect\n");
2810
2811                 /* queue work to avoid recursive calls into rndis_command */
2812                 set_bit(WORK_LINK_UP, &priv->work_pending);
2813                 queue_work(priv->workqueue, &priv->work);
2814                 break;
2815
2816         case RNDIS_STATUS_MEDIA_DISCONNECT:
2817                 netdev_info(usbdev->net, "media disconnect\n");
2818
2819                 /* queue work to avoid recursive calls into rndis_command */
2820                 set_bit(WORK_LINK_DOWN, &priv->work_pending);
2821                 queue_work(priv->workqueue, &priv->work);
2822                 break;
2823
2824         case RNDIS_STATUS_MEDIA_SPECIFIC_INDICATION:
2825                 rndis_wlan_media_specific_indication(usbdev, msg, buflen);
2826                 break;
2827
2828         default:
2829                 netdev_info(usbdev->net, "indication: 0x%08x\n",
2830                             le32_to_cpu(msg->status));
2831                 break;
2832         }
2833 }
2834
2835 static int rndis_wlan_get_caps(struct usbnet *usbdev, struct wiphy *wiphy)
2836 {
2837         struct {
2838                 __le32  num_items;
2839                 __le32  items[8];
2840         } networks_supported;
2841         struct ndis_80211_capability *caps;
2842         u8 caps_buf[sizeof(*caps) + sizeof(caps->auth_encr_pair) * 16];
2843         int len, retval, i, n;
2844         struct rndis_wlan_private *priv = get_rndis_wlan_priv(usbdev);
2845
2846         /* determine supported modes */
2847         len = sizeof(networks_supported);
2848         retval = rndis_query_oid(usbdev, OID_802_11_NETWORK_TYPES_SUPPORTED,
2849                                                 &networks_supported, &len);
2850         if (retval >= 0) {
2851                 n = le32_to_cpu(networks_supported.num_items);
2852                 if (n > 8)
2853                         n = 8;
2854                 for (i = 0; i < n; i++) {
2855                         switch (le32_to_cpu(networks_supported.items[i])) {
2856                         case NDIS_80211_TYPE_FREQ_HOP:
2857                         case NDIS_80211_TYPE_DIRECT_SEQ:
2858                                 priv->caps |= CAP_MODE_80211B;
2859                                 break;
2860                         case NDIS_80211_TYPE_OFDM_A:
2861                                 priv->caps |= CAP_MODE_80211A;
2862                                 break;
2863                         case NDIS_80211_TYPE_OFDM_G:
2864                                 priv->caps |= CAP_MODE_80211G;
2865                                 break;
2866                         }
2867                 }
2868         }
2869
2870         /* get device 802.11 capabilities, number of PMKIDs */
2871         caps = (struct ndis_80211_capability *)caps_buf;
2872         len = sizeof(caps_buf);
2873         retval = rndis_query_oid(usbdev, OID_802_11_CAPABILITY, caps, &len);
2874         if (retval >= 0) {
2875                 netdev_dbg(usbdev->net, "OID_802_11_CAPABILITY -> len %d, "
2876                                 "ver %d, pmkids %d, auth-encr-pairs %d\n",
2877                                 le32_to_cpu(caps->length),
2878                                 le32_to_cpu(caps->version),
2879                                 le32_to_cpu(caps->num_pmkids),
2880                                 le32_to_cpu(caps->num_auth_encr_pair));
2881                 wiphy->max_num_pmkids = le32_to_cpu(caps->num_pmkids);
2882         } else
2883                 wiphy->max_num_pmkids = 0;
2884
2885         return retval;
2886 }
2887
2888 #define DEVICE_POLLER_JIFFIES (HZ)
2889 static void rndis_device_poller(struct work_struct *work)
2890 {
2891         struct rndis_wlan_private *priv =
2892                 container_of(work, struct rndis_wlan_private,
2893                                                         dev_poller_work.work);
2894         struct usbnet *usbdev = priv->usbdev;
2895         __le32 rssi, tmp;
2896         int len, ret, j;
2897         int update_jiffies = DEVICE_POLLER_JIFFIES;
2898         void *buf;
2899
2900         /* Only check/do workaround when connected. Calling is_associated()
2901          * also polls device with rndis_command() and catches for media link
2902          * indications.
2903          */
2904         if (!is_associated(usbdev))
2905                 goto end;
2906
2907         len = sizeof(rssi);
2908         ret = rndis_query_oid(usbdev, OID_802_11_RSSI, &rssi, &len);
2909         if (ret == 0)
2910                 priv->last_qual = level_to_qual(le32_to_cpu(rssi));
2911
2912         netdev_dbg(usbdev->net, "dev-poller: OID_802_11_RSSI -> %d, rssi:%d, qual: %d\n",
2913                    ret, le32_to_cpu(rssi), level_to_qual(le32_to_cpu(rssi)));
2914
2915         /* Workaround transfer stalls on poor quality links.
2916          * TODO: find right way to fix these stalls (as stalls do not happen
2917          * with ndiswrapper/windows driver). */
2918         if (priv->param_workaround_interval > 0 && priv->last_qual <= 25) {
2919                 /* Decrease stats worker interval to catch stalls.
2920                  * faster. Faster than 400-500ms causes packet loss,
2921                  * Slower doesn't catch stalls fast enough.
2922                  */
2923                 j = msecs_to_jiffies(priv->param_workaround_interval);
2924                 if (j > DEVICE_POLLER_JIFFIES)
2925                         j = DEVICE_POLLER_JIFFIES;
2926                 else if (j <= 0)
2927                         j = 1;
2928                 update_jiffies = j;
2929
2930                 /* Send scan OID. Use of both OIDs is required to get device
2931                  * working.
2932                  */
2933                 tmp = cpu_to_le32(1);
2934                 rndis_set_oid(usbdev, OID_802_11_BSSID_LIST_SCAN, &tmp,
2935                                                                 sizeof(tmp));
2936
2937                 len = CONTROL_BUFFER_SIZE;
2938                 buf = kmalloc(len, GFP_KERNEL);
2939                 if (!buf)
2940                         goto end;
2941
2942                 rndis_query_oid(usbdev, OID_802_11_BSSID_LIST, buf, &len);
2943                 kfree(buf);
2944         }
2945
2946 end:
2947         if (update_jiffies >= HZ)
2948                 update_jiffies = round_jiffies_relative(update_jiffies);
2949         else {
2950                 j = round_jiffies_relative(update_jiffies);
2951                 if (abs(j - update_jiffies) <= 10)
2952                         update_jiffies = j;
2953         }
2954
2955         queue_delayed_work(priv->workqueue, &priv->dev_poller_work,
2956                                                                 update_jiffies);
2957 }
2958
2959 /*
2960  * driver/device initialization
2961  */
2962 static void rndis_copy_module_params(struct usbnet *usbdev)
2963 {
2964         struct rndis_wlan_private *priv = get_rndis_wlan_priv(usbdev);
2965
2966         priv->param_country[0] = modparam_country[0];
2967         priv->param_country[1] = modparam_country[1];
2968         priv->param_country[2] = 0;
2969         priv->param_frameburst   = modparam_frameburst;
2970         priv->param_afterburner  = modparam_afterburner;
2971         priv->param_power_save   = modparam_power_save;
2972         priv->param_power_output = modparam_power_output;
2973         priv->param_roamtrigger  = modparam_roamtrigger;
2974         priv->param_roamdelta    = modparam_roamdelta;
2975
2976         priv->param_country[0] = toupper(priv->param_country[0]);
2977         priv->param_country[1] = toupper(priv->param_country[1]);
2978         /* doesn't support EU as country code, use FI instead */
2979         if (!strcmp(priv->param_country, "EU"))
2980                 strcpy(priv->param_country, "FI");
2981
2982         if (priv->param_power_save < 0)
2983                 priv->param_power_save = 0;
2984         else if (priv->param_power_save > 2)
2985                 priv->param_power_save = 2;
2986
2987         if (priv->param_power_output < 0)
2988                 priv->param_power_output = 0;
2989         else if (priv->param_power_output > 3)
2990                 priv->param_power_output = 3;
2991
2992         if (priv->param_roamtrigger < -80)
2993                 priv->param_roamtrigger = -80;
2994         else if (priv->param_roamtrigger > -60)
2995                 priv->param_roamtrigger = -60;
2996
2997         if (priv->param_roamdelta < 0)
2998                 priv->param_roamdelta = 0;
2999         else if (priv->param_roamdelta > 2)
3000                 priv->param_roamdelta = 2;
3001
3002         if (modparam_workaround_interval < 0)
3003                 priv->param_workaround_interval = 500;
3004         else
3005                 priv->param_workaround_interval = modparam_workaround_interval;
3006 }
3007
3008 static int bcm4320a_early_init(struct usbnet *usbdev)
3009 {
3010         /* copy module parameters for bcm4320a so that iwconfig reports txpower
3011          * and workaround parameter is copied to private structure correctly.
3012          */
3013         rndis_copy_module_params(usbdev);
3014
3015         /* bcm4320a doesn't handle configuration parameters well. Try
3016          * set any and you get partially zeroed mac and broken device.
3017          */
3018
3019         return 0;
3020 }
3021
3022 static int bcm4320b_early_init(struct usbnet *usbdev)
3023 {
3024         struct rndis_wlan_private *priv = get_rndis_wlan_priv(usbdev);
3025         char buf[8];
3026
3027         rndis_copy_module_params(usbdev);
3028
3029         /* Early initialization settings, setting these won't have effect
3030          * if called after generic_rndis_bind().
3031          */
3032
3033         rndis_set_config_parameter_str(usbdev, "Country", priv->param_country);
3034         rndis_set_config_parameter_str(usbdev, "FrameBursting",
3035                                         priv->param_frameburst ? "1" : "0");
3036         rndis_set_config_parameter_str(usbdev, "Afterburner",
3037                                         priv->param_afterburner ? "1" : "0");
3038         sprintf(buf, "%d", priv->param_power_save);
3039         rndis_set_config_parameter_str(usbdev, "PowerSaveMode", buf);
3040         sprintf(buf, "%d", priv->param_power_output);
3041         rndis_set_config_parameter_str(usbdev, "PwrOut", buf);
3042         sprintf(buf, "%d", priv->param_roamtrigger);
3043         rndis_set_config_parameter_str(usbdev, "RoamTrigger", buf);
3044         sprintf(buf, "%d", priv->param_roamdelta);
3045         rndis_set_config_parameter_str(usbdev, "RoamDelta", buf);
3046
3047         return 0;
3048 }
3049
3050 /* same as rndis_netdev_ops but with local multicast handler */
3051 static const struct net_device_ops rndis_wlan_netdev_ops = {
3052         .ndo_open               = usbnet_open,
3053         .ndo_stop               = usbnet_stop,
3054         .ndo_start_xmit         = usbnet_start_xmit,
3055         .ndo_tx_timeout         = usbnet_tx_timeout,
3056         .ndo_set_mac_address    = eth_mac_addr,
3057         .ndo_validate_addr      = eth_validate_addr,
3058         .ndo_set_multicast_list = rndis_wlan_set_multicast_list,
3059 };
3060
3061 static int rndis_wlan_bind(struct usbnet *usbdev, struct usb_interface *intf)
3062 {
3063         struct wiphy *wiphy;
3064         struct rndis_wlan_private *priv;
3065         int retval, len;
3066         __le32 tmp;
3067
3068         /* allocate wiphy and rndis private data
3069          * NOTE: We only support a single virtual interface, so wiphy
3070          * and wireless_dev are somewhat synonymous for this device.
3071          */
3072         wiphy = wiphy_new(&rndis_config_ops, sizeof(struct rndis_wlan_private));
3073         if (!wiphy)
3074                 return -ENOMEM;
3075
3076         priv = wiphy_priv(wiphy);
3077         usbdev->net->ieee80211_ptr = &priv->wdev;
3078         priv->wdev.wiphy = wiphy;
3079         priv->wdev.iftype = NL80211_IFTYPE_STATION;
3080
3081         /* These have to be initialized before calling generic_rndis_bind().
3082          * Otherwise we'll be in big trouble in rndis_wlan_early_init().
3083          */
3084         usbdev->driver_priv = priv;
3085         priv->usbdev = usbdev;
3086
3087         mutex_init(&priv->command_lock);
3088
3089         /* because rndis_command() sleeps we need to use workqueue */
3090         priv->workqueue = create_singlethread_workqueue("rndis_wlan");
3091         INIT_WORK(&priv->work, rndis_wlan_worker);
3092         INIT_DELAYED_WORK(&priv->dev_poller_work, rndis_device_poller);
3093         INIT_DELAYED_WORK(&priv->scan_work, rndis_get_scan_results);
3094
3095         /* try bind rndis_host */
3096         retval = generic_rndis_bind(usbdev, intf, FLAG_RNDIS_PHYM_WIRELESS);
3097         if (retval < 0)
3098                 goto fail;
3099
3100         /* generic_rndis_bind set packet filter to multicast_all+
3101          * promisc mode which doesn't work well for our devices (device
3102          * picks up rssi to closest station instead of to access point).
3103          *
3104          * rndis_host wants to avoid all OID as much as possible
3105          * so do promisc/multicast handling in rndis_wlan.
3106          */
3107         usbdev->net->netdev_ops = &rndis_wlan_netdev_ops;
3108
3109         tmp = RNDIS_PACKET_TYPE_DIRECTED | RNDIS_PACKET_TYPE_BROADCAST;
3110         retval = rndis_set_oid(usbdev, OID_GEN_CURRENT_PACKET_FILTER, &tmp,
3111                                                                 sizeof(tmp));
3112
3113         len = sizeof(tmp);
3114         retval = rndis_query_oid(usbdev, OID_802_3_MAXIMUM_LIST_SIZE, &tmp,
3115                                                                 &len);
3116         priv->multicast_size = le32_to_cpu(tmp);
3117         if (retval < 0 || priv->multicast_size < 0)
3118                 priv->multicast_size = 0;
3119         if (priv->multicast_size > 0)
3120                 usbdev->net->flags |= IFF_MULTICAST;
3121         else
3122                 usbdev->net->flags &= ~IFF_MULTICAST;
3123
3124         /* fill-out wiphy structure and register w/ cfg80211 */
3125         memcpy(wiphy->perm_addr, usbdev->net->dev_addr, ETH_ALEN);
3126         wiphy->privid = rndis_wiphy_privid;
3127         wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION)
3128                                         | BIT(NL80211_IFTYPE_ADHOC);
3129         wiphy->max_scan_ssids = 1;
3130
3131         /* TODO: fill-out band/encr information based on priv->caps */
3132         rndis_wlan_get_caps(usbdev, wiphy);
3133
3134         memcpy(priv->channels, rndis_channels, sizeof(rndis_channels));
3135         memcpy(priv->rates, rndis_rates, sizeof(rndis_rates));
3136         priv->band.channels = priv->channels;
3137         priv->band.n_channels = ARRAY_SIZE(rndis_channels);
3138         priv->band.bitrates = priv->rates;
3139         priv->band.n_bitrates = ARRAY_SIZE(rndis_rates);
3140         wiphy->bands[IEEE80211_BAND_2GHZ] = &priv->band;
3141         wiphy->signal_type = CFG80211_SIGNAL_TYPE_UNSPEC;
3142
3143         memcpy(priv->cipher_suites, rndis_cipher_suites,
3144                                                 sizeof(rndis_cipher_suites));
3145         wiphy->cipher_suites = priv->cipher_suites;
3146         wiphy->n_cipher_suites = ARRAY_SIZE(rndis_cipher_suites);
3147
3148         set_wiphy_dev(wiphy, &usbdev->udev->dev);
3149
3150         if (wiphy_register(wiphy)) {
3151                 retval = -ENODEV;
3152                 goto fail;
3153         }
3154
3155         set_default_iw_params(usbdev);
3156
3157         /* set default rts/frag */
3158         rndis_set_wiphy_params(wiphy,
3159                         WIPHY_PARAM_FRAG_THRESHOLD | WIPHY_PARAM_RTS_THRESHOLD);
3160
3161         /* turn radio on */
3162         priv->radio_on = true;
3163         disassociate(usbdev, true);
3164         netif_carrier_off(usbdev->net);
3165
3166         return 0;
3167
3168 fail:
3169         cancel_delayed_work_sync(&priv->dev_poller_work);
3170         cancel_delayed_work_sync(&priv->scan_work);
3171         cancel_work_sync(&priv->work);
3172         flush_workqueue(priv->workqueue);
3173         destroy_workqueue(priv->workqueue);
3174
3175         wiphy_free(wiphy);
3176         return retval;
3177 }
3178
3179 static void rndis_wlan_unbind(struct usbnet *usbdev, struct usb_interface *intf)
3180 {
3181         struct rndis_wlan_private *priv = get_rndis_wlan_priv(usbdev);
3182
3183         /* turn radio off */
3184         disassociate(usbdev, false);
3185
3186         cancel_delayed_work_sync(&priv->dev_poller_work);
3187         cancel_delayed_work_sync(&priv->scan_work);
3188         cancel_work_sync(&priv->work);
3189         flush_workqueue(priv->workqueue);
3190         destroy_workqueue(priv->workqueue);
3191
3192         rndis_unbind(usbdev, intf);
3193
3194         wiphy_unregister(priv->wdev.wiphy);
3195         wiphy_free(priv->wdev.wiphy);
3196 }
3197
3198 static int rndis_wlan_reset(struct usbnet *usbdev)
3199 {
3200         struct rndis_wlan_private *priv = get_rndis_wlan_priv(usbdev);
3201         int retval;
3202
3203         netdev_dbg(usbdev->net, "%s()\n", __func__);
3204
3205         retval = rndis_reset(usbdev);
3206         if (retval)
3207                 netdev_warn(usbdev->net, "rndis_reset failed: %d\n", retval);
3208
3209         /* rndis_reset cleared multicast list, so restore here.
3210            (set_multicast_list() also turns on current packet filter) */
3211         set_multicast_list(usbdev);
3212
3213         queue_delayed_work(priv->workqueue, &priv->dev_poller_work,
3214                 round_jiffies_relative(DEVICE_POLLER_JIFFIES));
3215
3216         return deauthenticate(usbdev);
3217 }
3218
3219 static int rndis_wlan_stop(struct usbnet *usbdev)
3220 {
3221         struct rndis_wlan_private *priv = get_rndis_wlan_priv(usbdev);
3222         int retval;
3223         __le32 filter;
3224
3225         netdev_dbg(usbdev->net, "%s()\n", __func__);
3226
3227         retval = disassociate(usbdev, false);
3228
3229         priv->work_pending = 0;
3230         cancel_delayed_work_sync(&priv->dev_poller_work);
3231         cancel_delayed_work_sync(&priv->scan_work);
3232         cancel_work_sync(&priv->work);
3233         flush_workqueue(priv->workqueue);
3234
3235         if (priv->scan_request) {
3236                 cfg80211_scan_done(priv->scan_request, true);
3237                 priv->scan_request = NULL;
3238         }
3239
3240         /* Set current packet filter zero to block receiving data packets from
3241            device. */
3242         filter = 0;
3243         rndis_set_oid(usbdev, OID_GEN_CURRENT_PACKET_FILTER, &filter,
3244                                                                 sizeof(filter));
3245
3246         return retval;
3247 }
3248
3249 static const struct driver_info bcm4320b_info = {
3250         .description =  "Wireless RNDIS device, BCM4320b based",
3251         .flags =        FLAG_WLAN | FLAG_FRAMING_RN | FLAG_NO_SETINT |
3252                                 FLAG_AVOID_UNLINK_URBS,
3253         .bind =         rndis_wlan_bind,
3254         .unbind =       rndis_wlan_unbind,
3255         .status =       rndis_status,
3256         .rx_fixup =     rndis_rx_fixup,
3257         .tx_fixup =     rndis_tx_fixup,
3258         .reset =        rndis_wlan_reset,
3259         .stop =         rndis_wlan_stop,
3260         .early_init =   bcm4320b_early_init,
3261         .indication =   rndis_wlan_indication,
3262 };
3263
3264 static const struct driver_info bcm4320a_info = {
3265         .description =  "Wireless RNDIS device, BCM4320a based",
3266         .flags =        FLAG_WLAN | FLAG_FRAMING_RN | FLAG_NO_SETINT |
3267                                 FLAG_AVOID_UNLINK_URBS,
3268         .bind =         rndis_wlan_bind,
3269         .unbind =       rndis_wlan_unbind,
3270         .status =       rndis_status,
3271         .rx_fixup =     rndis_rx_fixup,
3272         .tx_fixup =     rndis_tx_fixup,
3273         .reset =        rndis_wlan_reset,
3274         .stop =         rndis_wlan_stop,
3275         .early_init =   bcm4320a_early_init,
3276         .indication =   rndis_wlan_indication,
3277 };
3278
3279 static const struct driver_info rndis_wlan_info = {
3280         .description =  "Wireless RNDIS device",
3281         .flags =        FLAG_WLAN | FLAG_FRAMING_RN | FLAG_NO_SETINT |
3282                                 FLAG_AVOID_UNLINK_URBS,
3283         .bind =         rndis_wlan_bind,
3284         .unbind =       rndis_wlan_unbind,
3285         .status =       rndis_status,
3286         .rx_fixup =     rndis_rx_fixup,
3287         .tx_fixup =     rndis_tx_fixup,
3288         .reset =        rndis_wlan_reset,
3289         .stop =         rndis_wlan_stop,
3290         .early_init =   bcm4320a_early_init,
3291         .indication =   rndis_wlan_indication,
3292 };
3293
3294 /*-------------------------------------------------------------------------*/
3295
3296 static const struct usb_device_id products [] = {
3297 #define RNDIS_MASTER_INTERFACE \
3298         .bInterfaceClass        = USB_CLASS_COMM, \
3299         .bInterfaceSubClass     = 2 /* ACM */, \
3300         .bInterfaceProtocol     = 0x0ff
3301
3302 /* INF driver for these devices have DriverVer >= 4.xx.xx.xx and many custom
3303  * parameters available. Chipset marked as 'BCM4320SKFBG' in NDISwrapper-wiki.
3304  */
3305 {
3306         .match_flags    =   USB_DEVICE_ID_MATCH_INT_INFO
3307                           | USB_DEVICE_ID_MATCH_DEVICE,
3308         .idVendor               = 0x0411,
3309         .idProduct              = 0x00bc,       /* Buffalo WLI-U2-KG125S */
3310         RNDIS_MASTER_INTERFACE,
3311         .driver_info            = (unsigned long) &bcm4320b_info,
3312 }, {
3313         .match_flags    =   USB_DEVICE_ID_MATCH_INT_INFO
3314                           | USB_DEVICE_ID_MATCH_DEVICE,
3315         .idVendor               = 0x0baf,
3316         .idProduct              = 0x011b,       /* U.S. Robotics USR5421 */
3317         RNDIS_MASTER_INTERFACE,
3318         .driver_info            = (unsigned long) &bcm4320b_info,
3319 }, {
3320         .match_flags    =   USB_DEVICE_ID_MATCH_INT_INFO
3321                           | USB_DEVICE_ID_MATCH_DEVICE,
3322         .idVendor               = 0x050d,
3323         .idProduct              = 0x011b,       /* Belkin F5D7051 */
3324         RNDIS_MASTER_INTERFACE,
3325         .driver_info            = (unsigned long) &bcm4320b_info,
3326 }, {
3327         .match_flags    =   USB_DEVICE_ID_MATCH_INT_INFO
3328                           | USB_DEVICE_ID_MATCH_DEVICE,
3329         .idVendor               = 0x1799,       /* Belkin has two vendor ids */
3330         .idProduct              = 0x011b,       /* Belkin F5D7051 */
3331         RNDIS_MASTER_INTERFACE,
3332         .driver_info            = (unsigned long) &bcm4320b_info,
3333 }, {
3334         .match_flags    =   USB_DEVICE_ID_MATCH_INT_INFO
3335                           | USB_DEVICE_ID_MATCH_DEVICE,
3336         .idVendor               = 0x13b1,
3337         .idProduct              = 0x0014,       /* Linksys WUSB54GSv2 */
3338         RNDIS_MASTER_INTERFACE,
3339         .driver_info            = (unsigned long) &bcm4320b_info,
3340 }, {
3341         .match_flags    =   USB_DEVICE_ID_MATCH_INT_INFO
3342                           | USB_DEVICE_ID_MATCH_DEVICE,
3343         .idVendor               = 0x13b1,
3344         .idProduct              = 0x0026,       /* Linksys WUSB54GSC */
3345         RNDIS_MASTER_INTERFACE,
3346         .driver_info            = (unsigned long) &bcm4320b_info,
3347 }, {
3348         .match_flags    =   USB_DEVICE_ID_MATCH_INT_INFO
3349                           | USB_DEVICE_ID_MATCH_DEVICE,
3350         .idVendor               = 0x0b05,
3351         .idProduct              = 0x1717,       /* Asus WL169gE */
3352         RNDIS_MASTER_INTERFACE,
3353         .driver_info            = (unsigned long) &bcm4320b_info,
3354 }, {
3355         .match_flags    =   USB_DEVICE_ID_MATCH_INT_INFO
3356                           | USB_DEVICE_ID_MATCH_DEVICE,
3357         .idVendor               = 0x0a5c,
3358         .idProduct              = 0xd11b,       /* Eminent EM4045 */
3359         RNDIS_MASTER_INTERFACE,
3360         .driver_info            = (unsigned long) &bcm4320b_info,
3361 }, {
3362         .match_flags    =   USB_DEVICE_ID_MATCH_INT_INFO
3363                           | USB_DEVICE_ID_MATCH_DEVICE,
3364         .idVendor               = 0x1690,
3365         .idProduct              = 0x0715,       /* BT Voyager 1055 */
3366         RNDIS_MASTER_INTERFACE,
3367         .driver_info            = (unsigned long) &bcm4320b_info,
3368 },
3369 /* These devices have DriverVer < 4.xx.xx.xx and do not have any custom
3370  * parameters available, hardware probably contain older firmware version with
3371  * no way of updating. Chipset marked as 'BCM4320????' in NDISwrapper-wiki.
3372  */
3373 {
3374         .match_flags    =   USB_DEVICE_ID_MATCH_INT_INFO
3375                           | USB_DEVICE_ID_MATCH_DEVICE,
3376         .idVendor               = 0x13b1,
3377         .idProduct              = 0x000e,       /* Linksys WUSB54GSv1 */
3378         RNDIS_MASTER_INTERFACE,
3379         .driver_info            = (unsigned long) &bcm4320a_info,
3380 }, {
3381         .match_flags    =   USB_DEVICE_ID_MATCH_INT_INFO
3382                           | USB_DEVICE_ID_MATCH_DEVICE,
3383         .idVendor               = 0x0baf,
3384         .idProduct              = 0x0111,       /* U.S. Robotics USR5420 */
3385         RNDIS_MASTER_INTERFACE,
3386         .driver_info            = (unsigned long) &bcm4320a_info,
3387 }, {
3388         .match_flags    =   USB_DEVICE_ID_MATCH_INT_INFO
3389                           | USB_DEVICE_ID_MATCH_DEVICE,
3390         .idVendor               = 0x0411,
3391         .idProduct              = 0x004b,       /* BUFFALO WLI-USB-G54 */
3392         RNDIS_MASTER_INTERFACE,
3393         .driver_info            = (unsigned long) &bcm4320a_info,
3394 },
3395 /* Generic Wireless RNDIS devices that we don't have exact
3396  * idVendor/idProduct/chip yet.
3397  */
3398 {
3399         /* RNDIS is MSFT's un-official variant of CDC ACM */
3400         USB_INTERFACE_INFO(USB_CLASS_COMM, 2 /* ACM */, 0x0ff),
3401         .driver_info = (unsigned long) &rndis_wlan_info,
3402 }, {
3403         /* "ActiveSync" is an undocumented variant of RNDIS, used in WM5 */
3404         USB_INTERFACE_INFO(USB_CLASS_MISC, 1, 1),
3405         .driver_info = (unsigned long) &rndis_wlan_info,
3406 },
3407         { },            // END
3408 };
3409 MODULE_DEVICE_TABLE(usb, products);
3410
3411 static struct usb_driver rndis_wlan_driver = {
3412         .name =         "rndis_wlan",
3413         .id_table =     products,
3414         .probe =        usbnet_probe,
3415         .disconnect =   usbnet_disconnect,
3416         .suspend =      usbnet_suspend,
3417         .resume =       usbnet_resume,
3418 };
3419
3420 static int __init rndis_wlan_init(void)
3421 {
3422         return usb_register(&rndis_wlan_driver);
3423 }
3424 module_init(rndis_wlan_init);
3425
3426 static void __exit rndis_wlan_exit(void)
3427 {
3428         usb_deregister(&rndis_wlan_driver);
3429 }
3430 module_exit(rndis_wlan_exit);
3431
3432 MODULE_AUTHOR("Bjorge Dijkstra");
3433 MODULE_AUTHOR("Jussi Kivilinna");
3434 MODULE_DESCRIPTION("Driver for RNDIS based USB Wireless adapters");
3435 MODULE_LICENSE("GPL");
3436