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