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