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