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