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