1 /* 2 * mac80211 configuration hooks for cfg80211 3 * 4 * Copyright 2006-2010 Johannes Berg <johannes@sipsolutions.net> 5 * 6 * This file is GPLv2 as found in COPYING. 7 */ 8 9 #include <linux/ieee80211.h> 10 #include <linux/nl80211.h> 11 #include <linux/rtnetlink.h> 12 #include <linux/slab.h> 13 #include <net/net_namespace.h> 14 #include <linux/rcupdate.h> 15 #include <linux/if_ether.h> 16 #include <net/cfg80211.h> 17 #include "ieee80211_i.h" 18 #include "driver-ops.h" 19 #include "cfg.h" 20 #include "rate.h" 21 #include "mesh.h" 22 23 static struct net_device *ieee80211_add_iface(struct wiphy *wiphy, char *name, 24 enum nl80211_iftype type, 25 u32 *flags, 26 struct vif_params *params) 27 { 28 struct ieee80211_local *local = wiphy_priv(wiphy); 29 struct net_device *dev; 30 struct ieee80211_sub_if_data *sdata; 31 int err; 32 33 err = ieee80211_if_add(local, name, &dev, type, params); 34 if (err) 35 return ERR_PTR(err); 36 37 if (type == NL80211_IFTYPE_MONITOR && flags) { 38 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 39 sdata->u.mntr_flags = *flags; 40 } 41 42 return dev; 43 } 44 45 static int ieee80211_del_iface(struct wiphy *wiphy, struct net_device *dev) 46 { 47 ieee80211_if_remove(IEEE80211_DEV_TO_SUB_IF(dev)); 48 49 return 0; 50 } 51 52 static int ieee80211_change_iface(struct wiphy *wiphy, 53 struct net_device *dev, 54 enum nl80211_iftype type, u32 *flags, 55 struct vif_params *params) 56 { 57 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 58 int ret; 59 60 ret = ieee80211_if_change_type(sdata, type); 61 if (ret) 62 return ret; 63 64 if (type == NL80211_IFTYPE_AP_VLAN && 65 params && params->use_4addr == 0) 66 RCU_INIT_POINTER(sdata->u.vlan.sta, NULL); 67 else if (type == NL80211_IFTYPE_STATION && 68 params && params->use_4addr >= 0) 69 sdata->u.mgd.use_4addr = params->use_4addr; 70 71 if (sdata->vif.type == NL80211_IFTYPE_MONITOR && flags) { 72 struct ieee80211_local *local = sdata->local; 73 74 if (ieee80211_sdata_running(sdata)) { 75 /* 76 * Prohibit MONITOR_FLAG_COOK_FRAMES to be 77 * changed while the interface is up. 78 * Else we would need to add a lot of cruft 79 * to update everything: 80 * cooked_mntrs, monitor and all fif_* counters 81 * reconfigure hardware 82 */ 83 if ((*flags & MONITOR_FLAG_COOK_FRAMES) != 84 (sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES)) 85 return -EBUSY; 86 87 ieee80211_adjust_monitor_flags(sdata, -1); 88 sdata->u.mntr_flags = *flags; 89 ieee80211_adjust_monitor_flags(sdata, 1); 90 91 ieee80211_configure_filter(local); 92 } else { 93 /* 94 * Because the interface is down, ieee80211_do_stop 95 * and ieee80211_do_open take care of "everything" 96 * mentioned in the comment above. 97 */ 98 sdata->u.mntr_flags = *flags; 99 } 100 } 101 102 return 0; 103 } 104 105 static int ieee80211_set_noack_map(struct wiphy *wiphy, 106 struct net_device *dev, 107 u16 noack_map) 108 { 109 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 110 111 sdata->noack_map = noack_map; 112 return 0; 113 } 114 115 static int ieee80211_add_key(struct wiphy *wiphy, struct net_device *dev, 116 u8 key_idx, bool pairwise, const u8 *mac_addr, 117 struct key_params *params) 118 { 119 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 120 struct sta_info *sta = NULL; 121 struct ieee80211_key *key; 122 int err; 123 124 if (!ieee80211_sdata_running(sdata)) 125 return -ENETDOWN; 126 127 /* reject WEP and TKIP keys if WEP failed to initialize */ 128 switch (params->cipher) { 129 case WLAN_CIPHER_SUITE_WEP40: 130 case WLAN_CIPHER_SUITE_TKIP: 131 case WLAN_CIPHER_SUITE_WEP104: 132 if (IS_ERR(sdata->local->wep_tx_tfm)) 133 return -EINVAL; 134 break; 135 default: 136 break; 137 } 138 139 key = ieee80211_key_alloc(params->cipher, key_idx, params->key_len, 140 params->key, params->seq_len, params->seq); 141 if (IS_ERR(key)) 142 return PTR_ERR(key); 143 144 if (pairwise) 145 key->conf.flags |= IEEE80211_KEY_FLAG_PAIRWISE; 146 147 mutex_lock(&sdata->local->sta_mtx); 148 149 if (mac_addr) { 150 if (ieee80211_vif_is_mesh(&sdata->vif)) 151 sta = sta_info_get(sdata, mac_addr); 152 else 153 sta = sta_info_get_bss(sdata, mac_addr); 154 if (!sta) { 155 ieee80211_key_free(sdata->local, key); 156 err = -ENOENT; 157 goto out_unlock; 158 } 159 } 160 161 err = ieee80211_key_link(key, sdata, sta); 162 if (err) 163 ieee80211_key_free(sdata->local, key); 164 165 out_unlock: 166 mutex_unlock(&sdata->local->sta_mtx); 167 168 return err; 169 } 170 171 static int ieee80211_del_key(struct wiphy *wiphy, struct net_device *dev, 172 u8 key_idx, bool pairwise, const u8 *mac_addr) 173 { 174 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 175 struct ieee80211_local *local = sdata->local; 176 struct sta_info *sta; 177 struct ieee80211_key *key = NULL; 178 int ret; 179 180 mutex_lock(&local->sta_mtx); 181 mutex_lock(&local->key_mtx); 182 183 if (mac_addr) { 184 ret = -ENOENT; 185 186 sta = sta_info_get_bss(sdata, mac_addr); 187 if (!sta) 188 goto out_unlock; 189 190 if (pairwise) 191 key = key_mtx_dereference(local, sta->ptk); 192 else 193 key = key_mtx_dereference(local, sta->gtk[key_idx]); 194 } else 195 key = key_mtx_dereference(local, sdata->keys[key_idx]); 196 197 if (!key) { 198 ret = -ENOENT; 199 goto out_unlock; 200 } 201 202 __ieee80211_key_free(key); 203 204 ret = 0; 205 out_unlock: 206 mutex_unlock(&local->key_mtx); 207 mutex_unlock(&local->sta_mtx); 208 209 return ret; 210 } 211 212 static int ieee80211_get_key(struct wiphy *wiphy, struct net_device *dev, 213 u8 key_idx, bool pairwise, const u8 *mac_addr, 214 void *cookie, 215 void (*callback)(void *cookie, 216 struct key_params *params)) 217 { 218 struct ieee80211_sub_if_data *sdata; 219 struct sta_info *sta = NULL; 220 u8 seq[6] = {0}; 221 struct key_params params; 222 struct ieee80211_key *key = NULL; 223 u64 pn64; 224 u32 iv32; 225 u16 iv16; 226 int err = -ENOENT; 227 228 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 229 230 rcu_read_lock(); 231 232 if (mac_addr) { 233 sta = sta_info_get_bss(sdata, mac_addr); 234 if (!sta) 235 goto out; 236 237 if (pairwise) 238 key = rcu_dereference(sta->ptk); 239 else if (key_idx < NUM_DEFAULT_KEYS) 240 key = rcu_dereference(sta->gtk[key_idx]); 241 } else 242 key = rcu_dereference(sdata->keys[key_idx]); 243 244 if (!key) 245 goto out; 246 247 memset(¶ms, 0, sizeof(params)); 248 249 params.cipher = key->conf.cipher; 250 251 switch (key->conf.cipher) { 252 case WLAN_CIPHER_SUITE_TKIP: 253 iv32 = key->u.tkip.tx.iv32; 254 iv16 = key->u.tkip.tx.iv16; 255 256 if (key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE) 257 drv_get_tkip_seq(sdata->local, 258 key->conf.hw_key_idx, 259 &iv32, &iv16); 260 261 seq[0] = iv16 & 0xff; 262 seq[1] = (iv16 >> 8) & 0xff; 263 seq[2] = iv32 & 0xff; 264 seq[3] = (iv32 >> 8) & 0xff; 265 seq[4] = (iv32 >> 16) & 0xff; 266 seq[5] = (iv32 >> 24) & 0xff; 267 params.seq = seq; 268 params.seq_len = 6; 269 break; 270 case WLAN_CIPHER_SUITE_CCMP: 271 pn64 = atomic64_read(&key->u.ccmp.tx_pn); 272 seq[0] = pn64; 273 seq[1] = pn64 >> 8; 274 seq[2] = pn64 >> 16; 275 seq[3] = pn64 >> 24; 276 seq[4] = pn64 >> 32; 277 seq[5] = pn64 >> 40; 278 params.seq = seq; 279 params.seq_len = 6; 280 break; 281 case WLAN_CIPHER_SUITE_AES_CMAC: 282 pn64 = atomic64_read(&key->u.aes_cmac.tx_pn); 283 seq[0] = pn64; 284 seq[1] = pn64 >> 8; 285 seq[2] = pn64 >> 16; 286 seq[3] = pn64 >> 24; 287 seq[4] = pn64 >> 32; 288 seq[5] = pn64 >> 40; 289 params.seq = seq; 290 params.seq_len = 6; 291 break; 292 } 293 294 params.key = key->conf.key; 295 params.key_len = key->conf.keylen; 296 297 callback(cookie, ¶ms); 298 err = 0; 299 300 out: 301 rcu_read_unlock(); 302 return err; 303 } 304 305 static int ieee80211_config_default_key(struct wiphy *wiphy, 306 struct net_device *dev, 307 u8 key_idx, bool uni, 308 bool multi) 309 { 310 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 311 312 ieee80211_set_default_key(sdata, key_idx, uni, multi); 313 314 return 0; 315 } 316 317 static int ieee80211_config_default_mgmt_key(struct wiphy *wiphy, 318 struct net_device *dev, 319 u8 key_idx) 320 { 321 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 322 323 ieee80211_set_default_mgmt_key(sdata, key_idx); 324 325 return 0; 326 } 327 328 static void rate_idx_to_bitrate(struct rate_info *rate, struct sta_info *sta, int idx) 329 { 330 if (!(rate->flags & RATE_INFO_FLAGS_MCS)) { 331 struct ieee80211_supported_band *sband; 332 sband = sta->local->hw.wiphy->bands[ 333 sta->local->hw.conf.channel->band]; 334 rate->legacy = sband->bitrates[idx].bitrate; 335 } else 336 rate->mcs = idx; 337 } 338 339 void sta_set_rate_info_tx(struct sta_info *sta, 340 const struct ieee80211_tx_rate *rate, 341 struct rate_info *rinfo) 342 { 343 rinfo->flags = 0; 344 if (rate->flags & IEEE80211_TX_RC_MCS) 345 rinfo->flags |= RATE_INFO_FLAGS_MCS; 346 if (rate->flags & IEEE80211_TX_RC_40_MHZ_WIDTH) 347 rinfo->flags |= RATE_INFO_FLAGS_40_MHZ_WIDTH; 348 if (rate->flags & IEEE80211_TX_RC_SHORT_GI) 349 rinfo->flags |= RATE_INFO_FLAGS_SHORT_GI; 350 rate_idx_to_bitrate(rinfo, sta, rate->idx); 351 } 352 353 static void sta_set_sinfo(struct sta_info *sta, struct station_info *sinfo) 354 { 355 struct ieee80211_sub_if_data *sdata = sta->sdata; 356 struct timespec uptime; 357 358 sinfo->generation = sdata->local->sta_generation; 359 360 sinfo->filled = STATION_INFO_INACTIVE_TIME | 361 STATION_INFO_RX_BYTES | 362 STATION_INFO_TX_BYTES | 363 STATION_INFO_RX_PACKETS | 364 STATION_INFO_TX_PACKETS | 365 STATION_INFO_TX_RETRIES | 366 STATION_INFO_TX_FAILED | 367 STATION_INFO_TX_BITRATE | 368 STATION_INFO_RX_BITRATE | 369 STATION_INFO_RX_DROP_MISC | 370 STATION_INFO_BSS_PARAM | 371 STATION_INFO_CONNECTED_TIME | 372 STATION_INFO_STA_FLAGS | 373 STATION_INFO_BEACON_LOSS_COUNT; 374 375 do_posix_clock_monotonic_gettime(&uptime); 376 sinfo->connected_time = uptime.tv_sec - sta->last_connected; 377 378 sinfo->inactive_time = jiffies_to_msecs(jiffies - sta->last_rx); 379 sinfo->rx_bytes = sta->rx_bytes; 380 sinfo->tx_bytes = sta->tx_bytes; 381 sinfo->rx_packets = sta->rx_packets; 382 sinfo->tx_packets = sta->tx_packets; 383 sinfo->tx_retries = sta->tx_retry_count; 384 sinfo->tx_failed = sta->tx_retry_failed; 385 sinfo->rx_dropped_misc = sta->rx_dropped; 386 sinfo->beacon_loss_count = sta->beacon_loss_count; 387 388 if ((sta->local->hw.flags & IEEE80211_HW_SIGNAL_DBM) || 389 (sta->local->hw.flags & IEEE80211_HW_SIGNAL_UNSPEC)) { 390 sinfo->filled |= STATION_INFO_SIGNAL | STATION_INFO_SIGNAL_AVG; 391 sinfo->signal = (s8)sta->last_signal; 392 sinfo->signal_avg = (s8) -ewma_read(&sta->avg_signal); 393 } 394 395 sta_set_rate_info_tx(sta, &sta->last_tx_rate, &sinfo->txrate); 396 397 sinfo->rxrate.flags = 0; 398 if (sta->last_rx_rate_flag & RX_FLAG_HT) 399 sinfo->rxrate.flags |= RATE_INFO_FLAGS_MCS; 400 if (sta->last_rx_rate_flag & RX_FLAG_40MHZ) 401 sinfo->rxrate.flags |= RATE_INFO_FLAGS_40_MHZ_WIDTH; 402 if (sta->last_rx_rate_flag & RX_FLAG_SHORT_GI) 403 sinfo->rxrate.flags |= RATE_INFO_FLAGS_SHORT_GI; 404 rate_idx_to_bitrate(&sinfo->rxrate, sta, sta->last_rx_rate_idx); 405 406 if (ieee80211_vif_is_mesh(&sdata->vif)) { 407 #ifdef CONFIG_MAC80211_MESH 408 sinfo->filled |= STATION_INFO_LLID | 409 STATION_INFO_PLID | 410 STATION_INFO_PLINK_STATE; 411 412 sinfo->llid = le16_to_cpu(sta->llid); 413 sinfo->plid = le16_to_cpu(sta->plid); 414 sinfo->plink_state = sta->plink_state; 415 if (test_sta_flag(sta, WLAN_STA_TOFFSET_KNOWN)) { 416 sinfo->filled |= STATION_INFO_T_OFFSET; 417 sinfo->t_offset = sta->t_offset; 418 } 419 #endif 420 } 421 422 sinfo->bss_param.flags = 0; 423 if (sdata->vif.bss_conf.use_cts_prot) 424 sinfo->bss_param.flags |= BSS_PARAM_FLAGS_CTS_PROT; 425 if (sdata->vif.bss_conf.use_short_preamble) 426 sinfo->bss_param.flags |= BSS_PARAM_FLAGS_SHORT_PREAMBLE; 427 if (sdata->vif.bss_conf.use_short_slot) 428 sinfo->bss_param.flags |= BSS_PARAM_FLAGS_SHORT_SLOT_TIME; 429 sinfo->bss_param.dtim_period = sdata->local->hw.conf.ps_dtim_period; 430 sinfo->bss_param.beacon_interval = sdata->vif.bss_conf.beacon_int; 431 432 sinfo->sta_flags.set = 0; 433 sinfo->sta_flags.mask = BIT(NL80211_STA_FLAG_AUTHORIZED) | 434 BIT(NL80211_STA_FLAG_SHORT_PREAMBLE) | 435 BIT(NL80211_STA_FLAG_WME) | 436 BIT(NL80211_STA_FLAG_MFP) | 437 BIT(NL80211_STA_FLAG_AUTHENTICATED) | 438 BIT(NL80211_STA_FLAG_TDLS_PEER); 439 if (test_sta_flag(sta, WLAN_STA_AUTHORIZED)) 440 sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_AUTHORIZED); 441 if (test_sta_flag(sta, WLAN_STA_SHORT_PREAMBLE)) 442 sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_SHORT_PREAMBLE); 443 if (test_sta_flag(sta, WLAN_STA_WME)) 444 sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_WME); 445 if (test_sta_flag(sta, WLAN_STA_MFP)) 446 sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_MFP); 447 if (test_sta_flag(sta, WLAN_STA_AUTH)) 448 sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_AUTHENTICATED); 449 if (test_sta_flag(sta, WLAN_STA_TDLS_PEER)) 450 sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_TDLS_PEER); 451 } 452 453 static const char ieee80211_gstrings_sta_stats[][ETH_GSTRING_LEN] = { 454 "rx_packets", "rx_bytes", "wep_weak_iv_count", 455 "rx_duplicates", "rx_fragments", "rx_dropped", 456 "tx_packets", "tx_bytes", "tx_fragments", 457 "tx_filtered", "tx_retry_failed", "tx_retries", 458 "beacon_loss", "sta_state", "txrate", "rxrate", "signal", 459 "channel", "noise", "ch_time", "ch_time_busy", 460 "ch_time_ext_busy", "ch_time_rx", "ch_time_tx" 461 }; 462 #define STA_STATS_LEN ARRAY_SIZE(ieee80211_gstrings_sta_stats) 463 464 static int ieee80211_get_et_sset_count(struct wiphy *wiphy, 465 struct net_device *dev, 466 int sset) 467 { 468 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 469 int rv = 0; 470 471 if (sset == ETH_SS_STATS) 472 rv += STA_STATS_LEN; 473 474 rv += drv_get_et_sset_count(sdata, sset); 475 476 if (rv == 0) 477 return -EOPNOTSUPP; 478 return rv; 479 } 480 481 static void ieee80211_get_et_stats(struct wiphy *wiphy, 482 struct net_device *dev, 483 struct ethtool_stats *stats, 484 u64 *data) 485 { 486 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 487 struct sta_info *sta; 488 struct ieee80211_local *local = sdata->local; 489 struct station_info sinfo; 490 struct survey_info survey; 491 int i, q; 492 #define STA_STATS_SURVEY_LEN 7 493 494 memset(data, 0, sizeof(u64) * STA_STATS_LEN); 495 496 #define ADD_STA_STATS(sta) \ 497 do { \ 498 data[i++] += sta->rx_packets; \ 499 data[i++] += sta->rx_bytes; \ 500 data[i++] += sta->wep_weak_iv_count; \ 501 data[i++] += sta->num_duplicates; \ 502 data[i++] += sta->rx_fragments; \ 503 data[i++] += sta->rx_dropped; \ 504 \ 505 data[i++] += sta->tx_packets; \ 506 data[i++] += sta->tx_bytes; \ 507 data[i++] += sta->tx_fragments; \ 508 data[i++] += sta->tx_filtered_count; \ 509 data[i++] += sta->tx_retry_failed; \ 510 data[i++] += sta->tx_retry_count; \ 511 data[i++] += sta->beacon_loss_count; \ 512 } while (0) 513 514 /* For Managed stations, find the single station based on BSSID 515 * and use that. For interface types, iterate through all available 516 * stations and add stats for any station that is assigned to this 517 * network device. 518 */ 519 520 rcu_read_lock(); 521 522 if (sdata->vif.type == NL80211_IFTYPE_STATION) { 523 sta = sta_info_get_bss(sdata, sdata->u.mgd.bssid); 524 525 if (!(sta && !WARN_ON(sta->sdata->dev != dev))) 526 goto do_survey; 527 528 i = 0; 529 ADD_STA_STATS(sta); 530 531 data[i++] = sta->sta_state; 532 533 sinfo.filled = 0; 534 sta_set_sinfo(sta, &sinfo); 535 536 if (sinfo.filled & STATION_INFO_TX_BITRATE) 537 data[i] = 100000 * 538 cfg80211_calculate_bitrate(&sinfo.txrate); 539 i++; 540 if (sinfo.filled & STATION_INFO_RX_BITRATE) 541 data[i] = 100000 * 542 cfg80211_calculate_bitrate(&sinfo.rxrate); 543 i++; 544 545 if (sinfo.filled & STATION_INFO_SIGNAL_AVG) 546 data[i] = (u8)sinfo.signal_avg; 547 i++; 548 } else { 549 list_for_each_entry_rcu(sta, &local->sta_list, list) { 550 /* Make sure this station belongs to the proper dev */ 551 if (sta->sdata->dev != dev) 552 continue; 553 554 i = 0; 555 ADD_STA_STATS(sta); 556 } 557 } 558 559 do_survey: 560 i = STA_STATS_LEN - STA_STATS_SURVEY_LEN; 561 /* Get survey stats for current channel */ 562 q = 0; 563 while (true) { 564 survey.filled = 0; 565 if (drv_get_survey(local, q, &survey) != 0) { 566 survey.filled = 0; 567 break; 568 } 569 570 if (survey.channel && 571 (local->oper_channel->center_freq == 572 survey.channel->center_freq)) 573 break; 574 q++; 575 } 576 577 if (survey.filled) 578 data[i++] = survey.channel->center_freq; 579 else 580 data[i++] = 0; 581 if (survey.filled & SURVEY_INFO_NOISE_DBM) 582 data[i++] = (u8)survey.noise; 583 else 584 data[i++] = -1LL; 585 if (survey.filled & SURVEY_INFO_CHANNEL_TIME) 586 data[i++] = survey.channel_time; 587 else 588 data[i++] = -1LL; 589 if (survey.filled & SURVEY_INFO_CHANNEL_TIME_BUSY) 590 data[i++] = survey.channel_time_busy; 591 else 592 data[i++] = -1LL; 593 if (survey.filled & SURVEY_INFO_CHANNEL_TIME_EXT_BUSY) 594 data[i++] = survey.channel_time_ext_busy; 595 else 596 data[i++] = -1LL; 597 if (survey.filled & SURVEY_INFO_CHANNEL_TIME_RX) 598 data[i++] = survey.channel_time_rx; 599 else 600 data[i++] = -1LL; 601 if (survey.filled & SURVEY_INFO_CHANNEL_TIME_TX) 602 data[i++] = survey.channel_time_tx; 603 else 604 data[i++] = -1LL; 605 606 rcu_read_unlock(); 607 608 if (WARN_ON(i != STA_STATS_LEN)) 609 return; 610 611 drv_get_et_stats(sdata, stats, &(data[STA_STATS_LEN])); 612 } 613 614 static void ieee80211_get_et_strings(struct wiphy *wiphy, 615 struct net_device *dev, 616 u32 sset, u8 *data) 617 { 618 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 619 int sz_sta_stats = 0; 620 621 if (sset == ETH_SS_STATS) { 622 sz_sta_stats = sizeof(ieee80211_gstrings_sta_stats); 623 memcpy(data, *ieee80211_gstrings_sta_stats, sz_sta_stats); 624 } 625 drv_get_et_strings(sdata, sset, &(data[sz_sta_stats])); 626 } 627 628 static int ieee80211_dump_station(struct wiphy *wiphy, struct net_device *dev, 629 int idx, u8 *mac, struct station_info *sinfo) 630 { 631 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 632 struct sta_info *sta; 633 int ret = -ENOENT; 634 635 rcu_read_lock(); 636 637 sta = sta_info_get_by_idx(sdata, idx); 638 if (sta) { 639 ret = 0; 640 memcpy(mac, sta->sta.addr, ETH_ALEN); 641 sta_set_sinfo(sta, sinfo); 642 } 643 644 rcu_read_unlock(); 645 646 return ret; 647 } 648 649 static int ieee80211_dump_survey(struct wiphy *wiphy, struct net_device *dev, 650 int idx, struct survey_info *survey) 651 { 652 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 653 654 return drv_get_survey(local, idx, survey); 655 } 656 657 static int ieee80211_get_station(struct wiphy *wiphy, struct net_device *dev, 658 u8 *mac, struct station_info *sinfo) 659 { 660 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 661 struct sta_info *sta; 662 int ret = -ENOENT; 663 664 rcu_read_lock(); 665 666 sta = sta_info_get_bss(sdata, mac); 667 if (sta) { 668 ret = 0; 669 sta_set_sinfo(sta, sinfo); 670 } 671 672 rcu_read_unlock(); 673 674 return ret; 675 } 676 677 static int ieee80211_set_probe_resp(struct ieee80211_sub_if_data *sdata, 678 const u8 *resp, size_t resp_len) 679 { 680 struct sk_buff *new, *old; 681 682 if (!resp || !resp_len) 683 return 1; 684 685 old = rtnl_dereference(sdata->u.ap.probe_resp); 686 687 new = dev_alloc_skb(resp_len); 688 if (!new) 689 return -ENOMEM; 690 691 memcpy(skb_put(new, resp_len), resp, resp_len); 692 693 rcu_assign_pointer(sdata->u.ap.probe_resp, new); 694 if (old) { 695 /* TODO: use call_rcu() */ 696 synchronize_rcu(); 697 dev_kfree_skb(old); 698 } 699 700 return 0; 701 } 702 703 static int ieee80211_assign_beacon(struct ieee80211_sub_if_data *sdata, 704 struct cfg80211_beacon_data *params) 705 { 706 struct beacon_data *new, *old; 707 int new_head_len, new_tail_len; 708 int size, err; 709 u32 changed = BSS_CHANGED_BEACON; 710 711 old = rtnl_dereference(sdata->u.ap.beacon); 712 713 /* Need to have a beacon head if we don't have one yet */ 714 if (!params->head && !old) 715 return -EINVAL; 716 717 /* new or old head? */ 718 if (params->head) 719 new_head_len = params->head_len; 720 else 721 new_head_len = old->head_len; 722 723 /* new or old tail? */ 724 if (params->tail || !old) 725 /* params->tail_len will be zero for !params->tail */ 726 new_tail_len = params->tail_len; 727 else 728 new_tail_len = old->tail_len; 729 730 size = sizeof(*new) + new_head_len + new_tail_len; 731 732 new = kzalloc(size, GFP_KERNEL); 733 if (!new) 734 return -ENOMEM; 735 736 /* start filling the new info now */ 737 738 /* 739 * pointers go into the block we allocated, 740 * memory is | beacon_data | head | tail | 741 */ 742 new->head = ((u8 *) new) + sizeof(*new); 743 new->tail = new->head + new_head_len; 744 new->head_len = new_head_len; 745 new->tail_len = new_tail_len; 746 747 /* copy in head */ 748 if (params->head) 749 memcpy(new->head, params->head, new_head_len); 750 else 751 memcpy(new->head, old->head, new_head_len); 752 753 /* copy in optional tail */ 754 if (params->tail) 755 memcpy(new->tail, params->tail, new_tail_len); 756 else 757 if (old) 758 memcpy(new->tail, old->tail, new_tail_len); 759 760 err = ieee80211_set_probe_resp(sdata, params->probe_resp, 761 params->probe_resp_len); 762 if (err < 0) 763 return err; 764 if (err == 0) 765 changed |= BSS_CHANGED_AP_PROBE_RESP; 766 767 rcu_assign_pointer(sdata->u.ap.beacon, new); 768 769 if (old) 770 kfree_rcu(old, rcu_head); 771 772 return changed; 773 } 774 775 static int ieee80211_start_ap(struct wiphy *wiphy, struct net_device *dev, 776 struct cfg80211_ap_settings *params) 777 { 778 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 779 struct beacon_data *old; 780 struct ieee80211_sub_if_data *vlan; 781 u32 changed = BSS_CHANGED_BEACON_INT | 782 BSS_CHANGED_BEACON_ENABLED | 783 BSS_CHANGED_BEACON | 784 BSS_CHANGED_SSID; 785 int err; 786 787 old = rtnl_dereference(sdata->u.ap.beacon); 788 if (old) 789 return -EALREADY; 790 791 /* 792 * Apply control port protocol, this allows us to 793 * not encrypt dynamic WEP control frames. 794 */ 795 sdata->control_port_protocol = params->crypto.control_port_ethertype; 796 sdata->control_port_no_encrypt = params->crypto.control_port_no_encrypt; 797 list_for_each_entry(vlan, &sdata->u.ap.vlans, u.vlan.list) { 798 vlan->control_port_protocol = 799 params->crypto.control_port_ethertype; 800 vlan->control_port_no_encrypt = 801 params->crypto.control_port_no_encrypt; 802 } 803 804 sdata->vif.bss_conf.beacon_int = params->beacon_interval; 805 sdata->vif.bss_conf.dtim_period = params->dtim_period; 806 807 sdata->vif.bss_conf.ssid_len = params->ssid_len; 808 if (params->ssid_len) 809 memcpy(sdata->vif.bss_conf.ssid, params->ssid, 810 params->ssid_len); 811 sdata->vif.bss_conf.hidden_ssid = 812 (params->hidden_ssid != NL80211_HIDDEN_SSID_NOT_IN_USE); 813 814 err = ieee80211_assign_beacon(sdata, ¶ms->beacon); 815 if (err < 0) 816 return err; 817 changed |= err; 818 819 ieee80211_bss_info_change_notify(sdata, changed); 820 821 netif_carrier_on(dev); 822 list_for_each_entry(vlan, &sdata->u.ap.vlans, u.vlan.list) 823 netif_carrier_on(vlan->dev); 824 825 return 0; 826 } 827 828 static int ieee80211_change_beacon(struct wiphy *wiphy, struct net_device *dev, 829 struct cfg80211_beacon_data *params) 830 { 831 struct ieee80211_sub_if_data *sdata; 832 struct beacon_data *old; 833 int err; 834 835 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 836 837 old = rtnl_dereference(sdata->u.ap.beacon); 838 if (!old) 839 return -ENOENT; 840 841 err = ieee80211_assign_beacon(sdata, params); 842 if (err < 0) 843 return err; 844 ieee80211_bss_info_change_notify(sdata, err); 845 return 0; 846 } 847 848 static int ieee80211_stop_ap(struct wiphy *wiphy, struct net_device *dev) 849 { 850 struct ieee80211_sub_if_data *sdata, *vlan; 851 struct beacon_data *old; 852 853 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 854 855 old = rtnl_dereference(sdata->u.ap.beacon); 856 if (!old) 857 return -ENOENT; 858 859 list_for_each_entry(vlan, &sdata->u.ap.vlans, u.vlan.list) 860 netif_carrier_off(vlan->dev); 861 netif_carrier_off(dev); 862 863 RCU_INIT_POINTER(sdata->u.ap.beacon, NULL); 864 865 kfree_rcu(old, rcu_head); 866 867 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON_ENABLED); 868 869 return 0; 870 } 871 872 /* Layer 2 Update frame (802.2 Type 1 LLC XID Update response) */ 873 struct iapp_layer2_update { 874 u8 da[ETH_ALEN]; /* broadcast */ 875 u8 sa[ETH_ALEN]; /* STA addr */ 876 __be16 len; /* 6 */ 877 u8 dsap; /* 0 */ 878 u8 ssap; /* 0 */ 879 u8 control; 880 u8 xid_info[3]; 881 } __packed; 882 883 static void ieee80211_send_layer2_update(struct sta_info *sta) 884 { 885 struct iapp_layer2_update *msg; 886 struct sk_buff *skb; 887 888 /* Send Level 2 Update Frame to update forwarding tables in layer 2 889 * bridge devices */ 890 891 skb = dev_alloc_skb(sizeof(*msg)); 892 if (!skb) 893 return; 894 msg = (struct iapp_layer2_update *)skb_put(skb, sizeof(*msg)); 895 896 /* 802.2 Type 1 Logical Link Control (LLC) Exchange Identifier (XID) 897 * Update response frame; IEEE Std 802.2-1998, 5.4.1.2.1 */ 898 899 memset(msg->da, 0xff, ETH_ALEN); 900 memcpy(msg->sa, sta->sta.addr, ETH_ALEN); 901 msg->len = htons(6); 902 msg->dsap = 0; 903 msg->ssap = 0x01; /* NULL LSAP, CR Bit: Response */ 904 msg->control = 0xaf; /* XID response lsb.1111F101. 905 * F=0 (no poll command; unsolicited frame) */ 906 msg->xid_info[0] = 0x81; /* XID format identifier */ 907 msg->xid_info[1] = 1; /* LLC types/classes: Type 1 LLC */ 908 msg->xid_info[2] = 0; /* XID sender's receive window size (RW) */ 909 910 skb->dev = sta->sdata->dev; 911 skb->protocol = eth_type_trans(skb, sta->sdata->dev); 912 memset(skb->cb, 0, sizeof(skb->cb)); 913 netif_rx_ni(skb); 914 } 915 916 static int sta_apply_parameters(struct ieee80211_local *local, 917 struct sta_info *sta, 918 struct station_parameters *params) 919 { 920 int ret = 0; 921 u32 rates; 922 int i, j; 923 struct ieee80211_supported_band *sband; 924 struct ieee80211_sub_if_data *sdata = sta->sdata; 925 u32 mask, set; 926 927 sband = local->hw.wiphy->bands[local->oper_channel->band]; 928 929 mask = params->sta_flags_mask; 930 set = params->sta_flags_set; 931 932 /* 933 * In mesh mode, we can clear AUTHENTICATED flag but must 934 * also make ASSOCIATED follow appropriately for the driver 935 * API. See also below, after AUTHORIZED changes. 936 */ 937 if (mask & BIT(NL80211_STA_FLAG_AUTHENTICATED)) { 938 /* cfg80211 should not allow this in non-mesh modes */ 939 if (WARN_ON(!ieee80211_vif_is_mesh(&sdata->vif))) 940 return -EINVAL; 941 942 if (set & BIT(NL80211_STA_FLAG_AUTHENTICATED) && 943 !test_sta_flag(sta, WLAN_STA_AUTH)) { 944 ret = sta_info_move_state(sta, IEEE80211_STA_AUTH); 945 if (ret) 946 return ret; 947 ret = sta_info_move_state(sta, IEEE80211_STA_ASSOC); 948 if (ret) 949 return ret; 950 } 951 } 952 953 if (mask & BIT(NL80211_STA_FLAG_AUTHORIZED)) { 954 if (set & BIT(NL80211_STA_FLAG_AUTHORIZED)) 955 ret = sta_info_move_state(sta, IEEE80211_STA_AUTHORIZED); 956 else if (test_sta_flag(sta, WLAN_STA_AUTHORIZED)) 957 ret = sta_info_move_state(sta, IEEE80211_STA_ASSOC); 958 if (ret) 959 return ret; 960 } 961 962 if (mask & BIT(NL80211_STA_FLAG_AUTHENTICATED)) { 963 /* cfg80211 should not allow this in non-mesh modes */ 964 if (WARN_ON(!ieee80211_vif_is_mesh(&sdata->vif))) 965 return -EINVAL; 966 967 if (!(set & BIT(NL80211_STA_FLAG_AUTHENTICATED)) && 968 test_sta_flag(sta, WLAN_STA_AUTH)) { 969 ret = sta_info_move_state(sta, IEEE80211_STA_AUTH); 970 if (ret) 971 return ret; 972 ret = sta_info_move_state(sta, IEEE80211_STA_NONE); 973 if (ret) 974 return ret; 975 } 976 } 977 978 979 if (mask & BIT(NL80211_STA_FLAG_SHORT_PREAMBLE)) { 980 if (set & BIT(NL80211_STA_FLAG_SHORT_PREAMBLE)) 981 set_sta_flag(sta, WLAN_STA_SHORT_PREAMBLE); 982 else 983 clear_sta_flag(sta, WLAN_STA_SHORT_PREAMBLE); 984 } 985 986 if (mask & BIT(NL80211_STA_FLAG_WME)) { 987 if (set & BIT(NL80211_STA_FLAG_WME)) { 988 set_sta_flag(sta, WLAN_STA_WME); 989 sta->sta.wme = true; 990 } else { 991 clear_sta_flag(sta, WLAN_STA_WME); 992 sta->sta.wme = false; 993 } 994 } 995 996 if (mask & BIT(NL80211_STA_FLAG_MFP)) { 997 if (set & BIT(NL80211_STA_FLAG_MFP)) 998 set_sta_flag(sta, WLAN_STA_MFP); 999 else 1000 clear_sta_flag(sta, WLAN_STA_MFP); 1001 } 1002 1003 if (mask & BIT(NL80211_STA_FLAG_TDLS_PEER)) { 1004 if (set & BIT(NL80211_STA_FLAG_TDLS_PEER)) 1005 set_sta_flag(sta, WLAN_STA_TDLS_PEER); 1006 else 1007 clear_sta_flag(sta, WLAN_STA_TDLS_PEER); 1008 } 1009 1010 if (params->sta_modify_mask & STATION_PARAM_APPLY_UAPSD) { 1011 sta->sta.uapsd_queues = params->uapsd_queues; 1012 sta->sta.max_sp = params->max_sp; 1013 } 1014 1015 /* 1016 * cfg80211 validates this (1-2007) and allows setting the AID 1017 * only when creating a new station entry 1018 */ 1019 if (params->aid) 1020 sta->sta.aid = params->aid; 1021 1022 /* 1023 * FIXME: updating the following information is racy when this 1024 * function is called from ieee80211_change_station(). 1025 * However, all this information should be static so 1026 * maybe we should just reject attemps to change it. 1027 */ 1028 1029 if (params->listen_interval >= 0) 1030 sta->listen_interval = params->listen_interval; 1031 1032 if (params->supported_rates) { 1033 rates = 0; 1034 1035 for (i = 0; i < params->supported_rates_len; i++) { 1036 int rate = (params->supported_rates[i] & 0x7f) * 5; 1037 for (j = 0; j < sband->n_bitrates; j++) { 1038 if (sband->bitrates[j].bitrate == rate) 1039 rates |= BIT(j); 1040 } 1041 } 1042 sta->sta.supp_rates[local->oper_channel->band] = rates; 1043 } 1044 1045 if (params->ht_capa) 1046 ieee80211_ht_cap_ie_to_sta_ht_cap(sdata, sband, 1047 params->ht_capa, 1048 &sta->sta.ht_cap); 1049 1050 if (ieee80211_vif_is_mesh(&sdata->vif)) { 1051 #ifdef CONFIG_MAC80211_MESH 1052 if (sdata->u.mesh.security & IEEE80211_MESH_SEC_SECURED) 1053 switch (params->plink_state) { 1054 case NL80211_PLINK_LISTEN: 1055 case NL80211_PLINK_ESTAB: 1056 case NL80211_PLINK_BLOCKED: 1057 sta->plink_state = params->plink_state; 1058 break; 1059 default: 1060 /* nothing */ 1061 break; 1062 } 1063 else 1064 switch (params->plink_action) { 1065 case PLINK_ACTION_OPEN: 1066 mesh_plink_open(sta); 1067 break; 1068 case PLINK_ACTION_BLOCK: 1069 mesh_plink_block(sta); 1070 break; 1071 } 1072 #endif 1073 } 1074 1075 return 0; 1076 } 1077 1078 static int ieee80211_add_station(struct wiphy *wiphy, struct net_device *dev, 1079 u8 *mac, struct station_parameters *params) 1080 { 1081 struct ieee80211_local *local = wiphy_priv(wiphy); 1082 struct sta_info *sta; 1083 struct ieee80211_sub_if_data *sdata; 1084 int err; 1085 int layer2_update; 1086 1087 if (params->vlan) { 1088 sdata = IEEE80211_DEV_TO_SUB_IF(params->vlan); 1089 1090 if (sdata->vif.type != NL80211_IFTYPE_AP_VLAN && 1091 sdata->vif.type != NL80211_IFTYPE_AP) 1092 return -EINVAL; 1093 } else 1094 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1095 1096 if (ether_addr_equal(mac, sdata->vif.addr)) 1097 return -EINVAL; 1098 1099 if (is_multicast_ether_addr(mac)) 1100 return -EINVAL; 1101 1102 sta = sta_info_alloc(sdata, mac, GFP_KERNEL); 1103 if (!sta) 1104 return -ENOMEM; 1105 1106 sta_info_pre_move_state(sta, IEEE80211_STA_AUTH); 1107 sta_info_pre_move_state(sta, IEEE80211_STA_ASSOC); 1108 1109 err = sta_apply_parameters(local, sta, params); 1110 if (err) { 1111 sta_info_free(local, sta); 1112 return err; 1113 } 1114 1115 /* 1116 * for TDLS, rate control should be initialized only when supported 1117 * rates are known. 1118 */ 1119 if (!test_sta_flag(sta, WLAN_STA_TDLS_PEER)) 1120 rate_control_rate_init(sta); 1121 1122 layer2_update = sdata->vif.type == NL80211_IFTYPE_AP_VLAN || 1123 sdata->vif.type == NL80211_IFTYPE_AP; 1124 1125 err = sta_info_insert_rcu(sta); 1126 if (err) { 1127 rcu_read_unlock(); 1128 return err; 1129 } 1130 1131 if (layer2_update) 1132 ieee80211_send_layer2_update(sta); 1133 1134 rcu_read_unlock(); 1135 1136 return 0; 1137 } 1138 1139 static int ieee80211_del_station(struct wiphy *wiphy, struct net_device *dev, 1140 u8 *mac) 1141 { 1142 struct ieee80211_local *local = wiphy_priv(wiphy); 1143 struct ieee80211_sub_if_data *sdata; 1144 1145 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1146 1147 if (mac) 1148 return sta_info_destroy_addr_bss(sdata, mac); 1149 1150 sta_info_flush(local, sdata); 1151 return 0; 1152 } 1153 1154 static int ieee80211_change_station(struct wiphy *wiphy, 1155 struct net_device *dev, 1156 u8 *mac, 1157 struct station_parameters *params) 1158 { 1159 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1160 struct ieee80211_local *local = wiphy_priv(wiphy); 1161 struct sta_info *sta; 1162 struct ieee80211_sub_if_data *vlansdata; 1163 int err; 1164 1165 mutex_lock(&local->sta_mtx); 1166 1167 sta = sta_info_get_bss(sdata, mac); 1168 if (!sta) { 1169 mutex_unlock(&local->sta_mtx); 1170 return -ENOENT; 1171 } 1172 1173 /* in station mode, supported rates are only valid with TDLS */ 1174 if (sdata->vif.type == NL80211_IFTYPE_STATION && 1175 params->supported_rates && 1176 !test_sta_flag(sta, WLAN_STA_TDLS_PEER)) { 1177 mutex_unlock(&local->sta_mtx); 1178 return -EINVAL; 1179 } 1180 1181 if (params->vlan && params->vlan != sta->sdata->dev) { 1182 bool prev_4addr = false; 1183 bool new_4addr = false; 1184 1185 vlansdata = IEEE80211_DEV_TO_SUB_IF(params->vlan); 1186 1187 if (vlansdata->vif.type != NL80211_IFTYPE_AP_VLAN && 1188 vlansdata->vif.type != NL80211_IFTYPE_AP) { 1189 mutex_unlock(&local->sta_mtx); 1190 return -EINVAL; 1191 } 1192 1193 if (params->vlan->ieee80211_ptr->use_4addr) { 1194 if (vlansdata->u.vlan.sta) { 1195 mutex_unlock(&local->sta_mtx); 1196 return -EBUSY; 1197 } 1198 1199 rcu_assign_pointer(vlansdata->u.vlan.sta, sta); 1200 new_4addr = true; 1201 } 1202 1203 if (sta->sdata->vif.type == NL80211_IFTYPE_AP_VLAN && 1204 sta->sdata->u.vlan.sta) { 1205 rcu_assign_pointer(sta->sdata->u.vlan.sta, NULL); 1206 prev_4addr = true; 1207 } 1208 1209 sta->sdata = vlansdata; 1210 1211 if (sta->sta_state == IEEE80211_STA_AUTHORIZED && 1212 prev_4addr != new_4addr) { 1213 if (new_4addr) 1214 atomic_dec(&sta->sdata->bss->num_mcast_sta); 1215 else 1216 atomic_inc(&sta->sdata->bss->num_mcast_sta); 1217 } 1218 1219 ieee80211_send_layer2_update(sta); 1220 } 1221 1222 err = sta_apply_parameters(local, sta, params); 1223 if (err) { 1224 mutex_unlock(&local->sta_mtx); 1225 return err; 1226 } 1227 1228 if (test_sta_flag(sta, WLAN_STA_TDLS_PEER) && params->supported_rates) 1229 rate_control_rate_init(sta); 1230 1231 mutex_unlock(&local->sta_mtx); 1232 1233 if (sdata->vif.type == NL80211_IFTYPE_STATION && 1234 params->sta_flags_mask & BIT(NL80211_STA_FLAG_AUTHORIZED)) 1235 ieee80211_recalc_ps(local, -1); 1236 1237 return 0; 1238 } 1239 1240 #ifdef CONFIG_MAC80211_MESH 1241 static int ieee80211_add_mpath(struct wiphy *wiphy, struct net_device *dev, 1242 u8 *dst, u8 *next_hop) 1243 { 1244 struct ieee80211_sub_if_data *sdata; 1245 struct mesh_path *mpath; 1246 struct sta_info *sta; 1247 int err; 1248 1249 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1250 1251 rcu_read_lock(); 1252 sta = sta_info_get(sdata, next_hop); 1253 if (!sta) { 1254 rcu_read_unlock(); 1255 return -ENOENT; 1256 } 1257 1258 err = mesh_path_add(dst, sdata); 1259 if (err) { 1260 rcu_read_unlock(); 1261 return err; 1262 } 1263 1264 mpath = mesh_path_lookup(dst, sdata); 1265 if (!mpath) { 1266 rcu_read_unlock(); 1267 return -ENXIO; 1268 } 1269 mesh_path_fix_nexthop(mpath, sta); 1270 1271 rcu_read_unlock(); 1272 return 0; 1273 } 1274 1275 static int ieee80211_del_mpath(struct wiphy *wiphy, struct net_device *dev, 1276 u8 *dst) 1277 { 1278 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1279 1280 if (dst) 1281 return mesh_path_del(dst, sdata); 1282 1283 mesh_path_flush_by_iface(sdata); 1284 return 0; 1285 } 1286 1287 static int ieee80211_change_mpath(struct wiphy *wiphy, 1288 struct net_device *dev, 1289 u8 *dst, u8 *next_hop) 1290 { 1291 struct ieee80211_sub_if_data *sdata; 1292 struct mesh_path *mpath; 1293 struct sta_info *sta; 1294 1295 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1296 1297 rcu_read_lock(); 1298 1299 sta = sta_info_get(sdata, next_hop); 1300 if (!sta) { 1301 rcu_read_unlock(); 1302 return -ENOENT; 1303 } 1304 1305 mpath = mesh_path_lookup(dst, sdata); 1306 if (!mpath) { 1307 rcu_read_unlock(); 1308 return -ENOENT; 1309 } 1310 1311 mesh_path_fix_nexthop(mpath, sta); 1312 1313 rcu_read_unlock(); 1314 return 0; 1315 } 1316 1317 static void mpath_set_pinfo(struct mesh_path *mpath, u8 *next_hop, 1318 struct mpath_info *pinfo) 1319 { 1320 struct sta_info *next_hop_sta = rcu_dereference(mpath->next_hop); 1321 1322 if (next_hop_sta) 1323 memcpy(next_hop, next_hop_sta->sta.addr, ETH_ALEN); 1324 else 1325 memset(next_hop, 0, ETH_ALEN); 1326 1327 pinfo->generation = mesh_paths_generation; 1328 1329 pinfo->filled = MPATH_INFO_FRAME_QLEN | 1330 MPATH_INFO_SN | 1331 MPATH_INFO_METRIC | 1332 MPATH_INFO_EXPTIME | 1333 MPATH_INFO_DISCOVERY_TIMEOUT | 1334 MPATH_INFO_DISCOVERY_RETRIES | 1335 MPATH_INFO_FLAGS; 1336 1337 pinfo->frame_qlen = mpath->frame_queue.qlen; 1338 pinfo->sn = mpath->sn; 1339 pinfo->metric = mpath->metric; 1340 if (time_before(jiffies, mpath->exp_time)) 1341 pinfo->exptime = jiffies_to_msecs(mpath->exp_time - jiffies); 1342 pinfo->discovery_timeout = 1343 jiffies_to_msecs(mpath->discovery_timeout); 1344 pinfo->discovery_retries = mpath->discovery_retries; 1345 pinfo->flags = 0; 1346 if (mpath->flags & MESH_PATH_ACTIVE) 1347 pinfo->flags |= NL80211_MPATH_FLAG_ACTIVE; 1348 if (mpath->flags & MESH_PATH_RESOLVING) 1349 pinfo->flags |= NL80211_MPATH_FLAG_RESOLVING; 1350 if (mpath->flags & MESH_PATH_SN_VALID) 1351 pinfo->flags |= NL80211_MPATH_FLAG_SN_VALID; 1352 if (mpath->flags & MESH_PATH_FIXED) 1353 pinfo->flags |= NL80211_MPATH_FLAG_FIXED; 1354 if (mpath->flags & MESH_PATH_RESOLVING) 1355 pinfo->flags |= NL80211_MPATH_FLAG_RESOLVING; 1356 1357 pinfo->flags = mpath->flags; 1358 } 1359 1360 static int ieee80211_get_mpath(struct wiphy *wiphy, struct net_device *dev, 1361 u8 *dst, u8 *next_hop, struct mpath_info *pinfo) 1362 1363 { 1364 struct ieee80211_sub_if_data *sdata; 1365 struct mesh_path *mpath; 1366 1367 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1368 1369 rcu_read_lock(); 1370 mpath = mesh_path_lookup(dst, sdata); 1371 if (!mpath) { 1372 rcu_read_unlock(); 1373 return -ENOENT; 1374 } 1375 memcpy(dst, mpath->dst, ETH_ALEN); 1376 mpath_set_pinfo(mpath, next_hop, pinfo); 1377 rcu_read_unlock(); 1378 return 0; 1379 } 1380 1381 static int ieee80211_dump_mpath(struct wiphy *wiphy, struct net_device *dev, 1382 int idx, u8 *dst, u8 *next_hop, 1383 struct mpath_info *pinfo) 1384 { 1385 struct ieee80211_sub_if_data *sdata; 1386 struct mesh_path *mpath; 1387 1388 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1389 1390 rcu_read_lock(); 1391 mpath = mesh_path_lookup_by_idx(idx, sdata); 1392 if (!mpath) { 1393 rcu_read_unlock(); 1394 return -ENOENT; 1395 } 1396 memcpy(dst, mpath->dst, ETH_ALEN); 1397 mpath_set_pinfo(mpath, next_hop, pinfo); 1398 rcu_read_unlock(); 1399 return 0; 1400 } 1401 1402 static int ieee80211_get_mesh_config(struct wiphy *wiphy, 1403 struct net_device *dev, 1404 struct mesh_config *conf) 1405 { 1406 struct ieee80211_sub_if_data *sdata; 1407 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1408 1409 memcpy(conf, &(sdata->u.mesh.mshcfg), sizeof(struct mesh_config)); 1410 return 0; 1411 } 1412 1413 static inline bool _chg_mesh_attr(enum nl80211_meshconf_params parm, u32 mask) 1414 { 1415 return (mask >> (parm-1)) & 0x1; 1416 } 1417 1418 static int copy_mesh_setup(struct ieee80211_if_mesh *ifmsh, 1419 const struct mesh_setup *setup) 1420 { 1421 u8 *new_ie; 1422 const u8 *old_ie; 1423 struct ieee80211_sub_if_data *sdata = container_of(ifmsh, 1424 struct ieee80211_sub_if_data, u.mesh); 1425 1426 /* allocate information elements */ 1427 new_ie = NULL; 1428 old_ie = ifmsh->ie; 1429 1430 if (setup->ie_len) { 1431 new_ie = kmemdup(setup->ie, setup->ie_len, 1432 GFP_KERNEL); 1433 if (!new_ie) 1434 return -ENOMEM; 1435 } 1436 ifmsh->ie_len = setup->ie_len; 1437 ifmsh->ie = new_ie; 1438 kfree(old_ie); 1439 1440 /* now copy the rest of the setup parameters */ 1441 ifmsh->mesh_id_len = setup->mesh_id_len; 1442 memcpy(ifmsh->mesh_id, setup->mesh_id, ifmsh->mesh_id_len); 1443 ifmsh->mesh_sp_id = setup->sync_method; 1444 ifmsh->mesh_pp_id = setup->path_sel_proto; 1445 ifmsh->mesh_pm_id = setup->path_metric; 1446 ifmsh->security = IEEE80211_MESH_SEC_NONE; 1447 if (setup->is_authenticated) 1448 ifmsh->security |= IEEE80211_MESH_SEC_AUTHED; 1449 if (setup->is_secure) 1450 ifmsh->security |= IEEE80211_MESH_SEC_SECURED; 1451 1452 /* mcast rate setting in Mesh Node */ 1453 memcpy(sdata->vif.bss_conf.mcast_rate, setup->mcast_rate, 1454 sizeof(setup->mcast_rate)); 1455 1456 return 0; 1457 } 1458 1459 static int ieee80211_update_mesh_config(struct wiphy *wiphy, 1460 struct net_device *dev, u32 mask, 1461 const struct mesh_config *nconf) 1462 { 1463 struct mesh_config *conf; 1464 struct ieee80211_sub_if_data *sdata; 1465 struct ieee80211_if_mesh *ifmsh; 1466 1467 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1468 ifmsh = &sdata->u.mesh; 1469 1470 /* Set the config options which we are interested in setting */ 1471 conf = &(sdata->u.mesh.mshcfg); 1472 if (_chg_mesh_attr(NL80211_MESHCONF_RETRY_TIMEOUT, mask)) 1473 conf->dot11MeshRetryTimeout = nconf->dot11MeshRetryTimeout; 1474 if (_chg_mesh_attr(NL80211_MESHCONF_CONFIRM_TIMEOUT, mask)) 1475 conf->dot11MeshConfirmTimeout = nconf->dot11MeshConfirmTimeout; 1476 if (_chg_mesh_attr(NL80211_MESHCONF_HOLDING_TIMEOUT, mask)) 1477 conf->dot11MeshHoldingTimeout = nconf->dot11MeshHoldingTimeout; 1478 if (_chg_mesh_attr(NL80211_MESHCONF_MAX_PEER_LINKS, mask)) 1479 conf->dot11MeshMaxPeerLinks = nconf->dot11MeshMaxPeerLinks; 1480 if (_chg_mesh_attr(NL80211_MESHCONF_MAX_RETRIES, mask)) 1481 conf->dot11MeshMaxRetries = nconf->dot11MeshMaxRetries; 1482 if (_chg_mesh_attr(NL80211_MESHCONF_TTL, mask)) 1483 conf->dot11MeshTTL = nconf->dot11MeshTTL; 1484 if (_chg_mesh_attr(NL80211_MESHCONF_ELEMENT_TTL, mask)) 1485 conf->dot11MeshTTL = nconf->element_ttl; 1486 if (_chg_mesh_attr(NL80211_MESHCONF_AUTO_OPEN_PLINKS, mask)) 1487 conf->auto_open_plinks = nconf->auto_open_plinks; 1488 if (_chg_mesh_attr(NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR, mask)) 1489 conf->dot11MeshNbrOffsetMaxNeighbor = 1490 nconf->dot11MeshNbrOffsetMaxNeighbor; 1491 if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES, mask)) 1492 conf->dot11MeshHWMPmaxPREQretries = 1493 nconf->dot11MeshHWMPmaxPREQretries; 1494 if (_chg_mesh_attr(NL80211_MESHCONF_PATH_REFRESH_TIME, mask)) 1495 conf->path_refresh_time = nconf->path_refresh_time; 1496 if (_chg_mesh_attr(NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT, mask)) 1497 conf->min_discovery_timeout = nconf->min_discovery_timeout; 1498 if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT, mask)) 1499 conf->dot11MeshHWMPactivePathTimeout = 1500 nconf->dot11MeshHWMPactivePathTimeout; 1501 if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL, mask)) 1502 conf->dot11MeshHWMPpreqMinInterval = 1503 nconf->dot11MeshHWMPpreqMinInterval; 1504 if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL, mask)) 1505 conf->dot11MeshHWMPperrMinInterval = 1506 nconf->dot11MeshHWMPperrMinInterval; 1507 if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME, 1508 mask)) 1509 conf->dot11MeshHWMPnetDiameterTraversalTime = 1510 nconf->dot11MeshHWMPnetDiameterTraversalTime; 1511 if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_ROOTMODE, mask)) { 1512 conf->dot11MeshHWMPRootMode = nconf->dot11MeshHWMPRootMode; 1513 ieee80211_mesh_root_setup(ifmsh); 1514 } 1515 if (_chg_mesh_attr(NL80211_MESHCONF_GATE_ANNOUNCEMENTS, mask)) { 1516 /* our current gate announcement implementation rides on root 1517 * announcements, so require this ifmsh to also be a root node 1518 * */ 1519 if (nconf->dot11MeshGateAnnouncementProtocol && 1520 !conf->dot11MeshHWMPRootMode) { 1521 conf->dot11MeshHWMPRootMode = 1; 1522 ieee80211_mesh_root_setup(ifmsh); 1523 } 1524 conf->dot11MeshGateAnnouncementProtocol = 1525 nconf->dot11MeshGateAnnouncementProtocol; 1526 } 1527 if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_RANN_INTERVAL, mask)) { 1528 conf->dot11MeshHWMPRannInterval = 1529 nconf->dot11MeshHWMPRannInterval; 1530 } 1531 if (_chg_mesh_attr(NL80211_MESHCONF_FORWARDING, mask)) 1532 conf->dot11MeshForwarding = nconf->dot11MeshForwarding; 1533 if (_chg_mesh_attr(NL80211_MESHCONF_RSSI_THRESHOLD, mask)) { 1534 /* our RSSI threshold implementation is supported only for 1535 * devices that report signal in dBm. 1536 */ 1537 if (!(sdata->local->hw.flags & IEEE80211_HW_SIGNAL_DBM)) 1538 return -ENOTSUPP; 1539 conf->rssi_threshold = nconf->rssi_threshold; 1540 } 1541 if (_chg_mesh_attr(NL80211_MESHCONF_HT_OPMODE, mask)) { 1542 conf->ht_opmode = nconf->ht_opmode; 1543 sdata->vif.bss_conf.ht_operation_mode = nconf->ht_opmode; 1544 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_HT); 1545 } 1546 return 0; 1547 } 1548 1549 static int ieee80211_join_mesh(struct wiphy *wiphy, struct net_device *dev, 1550 const struct mesh_config *conf, 1551 const struct mesh_setup *setup) 1552 { 1553 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1554 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; 1555 int err; 1556 1557 memcpy(&ifmsh->mshcfg, conf, sizeof(struct mesh_config)); 1558 err = copy_mesh_setup(ifmsh, setup); 1559 if (err) 1560 return err; 1561 ieee80211_start_mesh(sdata); 1562 1563 return 0; 1564 } 1565 1566 static int ieee80211_leave_mesh(struct wiphy *wiphy, struct net_device *dev) 1567 { 1568 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1569 1570 ieee80211_stop_mesh(sdata); 1571 1572 return 0; 1573 } 1574 #endif 1575 1576 static int ieee80211_change_bss(struct wiphy *wiphy, 1577 struct net_device *dev, 1578 struct bss_parameters *params) 1579 { 1580 struct ieee80211_sub_if_data *sdata; 1581 u32 changed = 0; 1582 1583 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1584 1585 if (params->use_cts_prot >= 0) { 1586 sdata->vif.bss_conf.use_cts_prot = params->use_cts_prot; 1587 changed |= BSS_CHANGED_ERP_CTS_PROT; 1588 } 1589 if (params->use_short_preamble >= 0) { 1590 sdata->vif.bss_conf.use_short_preamble = 1591 params->use_short_preamble; 1592 changed |= BSS_CHANGED_ERP_PREAMBLE; 1593 } 1594 1595 if (!sdata->vif.bss_conf.use_short_slot && 1596 sdata->local->hw.conf.channel->band == IEEE80211_BAND_5GHZ) { 1597 sdata->vif.bss_conf.use_short_slot = true; 1598 changed |= BSS_CHANGED_ERP_SLOT; 1599 } 1600 1601 if (params->use_short_slot_time >= 0) { 1602 sdata->vif.bss_conf.use_short_slot = 1603 params->use_short_slot_time; 1604 changed |= BSS_CHANGED_ERP_SLOT; 1605 } 1606 1607 if (params->basic_rates) { 1608 int i, j; 1609 u32 rates = 0; 1610 struct ieee80211_local *local = wiphy_priv(wiphy); 1611 struct ieee80211_supported_band *sband = 1612 wiphy->bands[local->oper_channel->band]; 1613 1614 for (i = 0; i < params->basic_rates_len; i++) { 1615 int rate = (params->basic_rates[i] & 0x7f) * 5; 1616 for (j = 0; j < sband->n_bitrates; j++) { 1617 if (sband->bitrates[j].bitrate == rate) 1618 rates |= BIT(j); 1619 } 1620 } 1621 sdata->vif.bss_conf.basic_rates = rates; 1622 changed |= BSS_CHANGED_BASIC_RATES; 1623 } 1624 1625 if (params->ap_isolate >= 0) { 1626 if (params->ap_isolate) 1627 sdata->flags |= IEEE80211_SDATA_DONT_BRIDGE_PACKETS; 1628 else 1629 sdata->flags &= ~IEEE80211_SDATA_DONT_BRIDGE_PACKETS; 1630 } 1631 1632 if (params->ht_opmode >= 0) { 1633 sdata->vif.bss_conf.ht_operation_mode = 1634 (u16) params->ht_opmode; 1635 changed |= BSS_CHANGED_HT; 1636 } 1637 1638 ieee80211_bss_info_change_notify(sdata, changed); 1639 1640 return 0; 1641 } 1642 1643 static int ieee80211_set_txq_params(struct wiphy *wiphy, 1644 struct net_device *dev, 1645 struct ieee80211_txq_params *params) 1646 { 1647 struct ieee80211_local *local = wiphy_priv(wiphy); 1648 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1649 struct ieee80211_tx_queue_params p; 1650 1651 if (!local->ops->conf_tx) 1652 return -EOPNOTSUPP; 1653 1654 if (local->hw.queues < IEEE80211_NUM_ACS) 1655 return -EOPNOTSUPP; 1656 1657 memset(&p, 0, sizeof(p)); 1658 p.aifs = params->aifs; 1659 p.cw_max = params->cwmax; 1660 p.cw_min = params->cwmin; 1661 p.txop = params->txop; 1662 1663 /* 1664 * Setting tx queue params disables u-apsd because it's only 1665 * called in master mode. 1666 */ 1667 p.uapsd = false; 1668 1669 sdata->tx_conf[params->ac] = p; 1670 if (drv_conf_tx(local, sdata, params->ac, &p)) { 1671 wiphy_debug(local->hw.wiphy, 1672 "failed to set TX queue parameters for AC %d\n", 1673 params->ac); 1674 return -EINVAL; 1675 } 1676 1677 return 0; 1678 } 1679 1680 static int ieee80211_set_channel(struct wiphy *wiphy, 1681 struct net_device *netdev, 1682 struct ieee80211_channel *chan, 1683 enum nl80211_channel_type channel_type) 1684 { 1685 struct ieee80211_local *local = wiphy_priv(wiphy); 1686 struct ieee80211_sub_if_data *sdata = NULL; 1687 struct ieee80211_channel *old_oper; 1688 enum nl80211_channel_type old_oper_type; 1689 enum nl80211_channel_type old_vif_oper_type= NL80211_CHAN_NO_HT; 1690 1691 if (netdev) 1692 sdata = IEEE80211_DEV_TO_SUB_IF(netdev); 1693 1694 switch (ieee80211_get_channel_mode(local, NULL)) { 1695 case CHAN_MODE_HOPPING: 1696 return -EBUSY; 1697 case CHAN_MODE_FIXED: 1698 if (local->oper_channel != chan) 1699 return -EBUSY; 1700 if (!sdata && local->_oper_channel_type == channel_type) 1701 return 0; 1702 break; 1703 case CHAN_MODE_UNDEFINED: 1704 break; 1705 } 1706 1707 if (sdata) 1708 old_vif_oper_type = sdata->vif.bss_conf.channel_type; 1709 old_oper_type = local->_oper_channel_type; 1710 1711 if (!ieee80211_set_channel_type(local, sdata, channel_type)) 1712 return -EBUSY; 1713 1714 old_oper = local->oper_channel; 1715 local->oper_channel = chan; 1716 1717 /* Update driver if changes were actually made. */ 1718 if ((old_oper != local->oper_channel) || 1719 (old_oper_type != local->_oper_channel_type)) 1720 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_CHANNEL); 1721 1722 if (sdata && sdata->vif.type != NL80211_IFTYPE_MONITOR && 1723 old_vif_oper_type != sdata->vif.bss_conf.channel_type) 1724 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_HT); 1725 1726 return 0; 1727 } 1728 1729 #ifdef CONFIG_PM 1730 static int ieee80211_suspend(struct wiphy *wiphy, 1731 struct cfg80211_wowlan *wowlan) 1732 { 1733 return __ieee80211_suspend(wiphy_priv(wiphy), wowlan); 1734 } 1735 1736 static int ieee80211_resume(struct wiphy *wiphy) 1737 { 1738 return __ieee80211_resume(wiphy_priv(wiphy)); 1739 } 1740 #else 1741 #define ieee80211_suspend NULL 1742 #define ieee80211_resume NULL 1743 #endif 1744 1745 static int ieee80211_scan(struct wiphy *wiphy, 1746 struct net_device *dev, 1747 struct cfg80211_scan_request *req) 1748 { 1749 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1750 1751 switch (ieee80211_vif_type_p2p(&sdata->vif)) { 1752 case NL80211_IFTYPE_STATION: 1753 case NL80211_IFTYPE_ADHOC: 1754 case NL80211_IFTYPE_MESH_POINT: 1755 case NL80211_IFTYPE_P2P_CLIENT: 1756 break; 1757 case NL80211_IFTYPE_P2P_GO: 1758 if (sdata->local->ops->hw_scan) 1759 break; 1760 /* 1761 * FIXME: implement NoA while scanning in software, 1762 * for now fall through to allow scanning only when 1763 * beaconing hasn't been configured yet 1764 */ 1765 case NL80211_IFTYPE_AP: 1766 if (sdata->u.ap.beacon) 1767 return -EOPNOTSUPP; 1768 break; 1769 default: 1770 return -EOPNOTSUPP; 1771 } 1772 1773 return ieee80211_request_scan(sdata, req); 1774 } 1775 1776 static int 1777 ieee80211_sched_scan_start(struct wiphy *wiphy, 1778 struct net_device *dev, 1779 struct cfg80211_sched_scan_request *req) 1780 { 1781 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1782 1783 if (!sdata->local->ops->sched_scan_start) 1784 return -EOPNOTSUPP; 1785 1786 return ieee80211_request_sched_scan_start(sdata, req); 1787 } 1788 1789 static int 1790 ieee80211_sched_scan_stop(struct wiphy *wiphy, struct net_device *dev) 1791 { 1792 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1793 1794 if (!sdata->local->ops->sched_scan_stop) 1795 return -EOPNOTSUPP; 1796 1797 return ieee80211_request_sched_scan_stop(sdata); 1798 } 1799 1800 static int ieee80211_auth(struct wiphy *wiphy, struct net_device *dev, 1801 struct cfg80211_auth_request *req) 1802 { 1803 return ieee80211_mgd_auth(IEEE80211_DEV_TO_SUB_IF(dev), req); 1804 } 1805 1806 static int ieee80211_assoc(struct wiphy *wiphy, struct net_device *dev, 1807 struct cfg80211_assoc_request *req) 1808 { 1809 struct ieee80211_local *local = wiphy_priv(wiphy); 1810 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1811 1812 switch (ieee80211_get_channel_mode(local, sdata)) { 1813 case CHAN_MODE_HOPPING: 1814 return -EBUSY; 1815 case CHAN_MODE_FIXED: 1816 if (local->oper_channel == req->bss->channel) 1817 break; 1818 return -EBUSY; 1819 case CHAN_MODE_UNDEFINED: 1820 break; 1821 } 1822 1823 return ieee80211_mgd_assoc(IEEE80211_DEV_TO_SUB_IF(dev), req); 1824 } 1825 1826 static int ieee80211_deauth(struct wiphy *wiphy, struct net_device *dev, 1827 struct cfg80211_deauth_request *req) 1828 { 1829 return ieee80211_mgd_deauth(IEEE80211_DEV_TO_SUB_IF(dev), req); 1830 } 1831 1832 static int ieee80211_disassoc(struct wiphy *wiphy, struct net_device *dev, 1833 struct cfg80211_disassoc_request *req) 1834 { 1835 return ieee80211_mgd_disassoc(IEEE80211_DEV_TO_SUB_IF(dev), req); 1836 } 1837 1838 static int ieee80211_join_ibss(struct wiphy *wiphy, struct net_device *dev, 1839 struct cfg80211_ibss_params *params) 1840 { 1841 struct ieee80211_local *local = wiphy_priv(wiphy); 1842 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1843 1844 switch (ieee80211_get_channel_mode(local, sdata)) { 1845 case CHAN_MODE_HOPPING: 1846 return -EBUSY; 1847 case CHAN_MODE_FIXED: 1848 if (!params->channel_fixed) 1849 return -EBUSY; 1850 if (local->oper_channel == params->channel) 1851 break; 1852 return -EBUSY; 1853 case CHAN_MODE_UNDEFINED: 1854 break; 1855 } 1856 1857 return ieee80211_ibss_join(sdata, params); 1858 } 1859 1860 static int ieee80211_leave_ibss(struct wiphy *wiphy, struct net_device *dev) 1861 { 1862 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1863 1864 return ieee80211_ibss_leave(sdata); 1865 } 1866 1867 static int ieee80211_set_wiphy_params(struct wiphy *wiphy, u32 changed) 1868 { 1869 struct ieee80211_local *local = wiphy_priv(wiphy); 1870 int err; 1871 1872 if (changed & WIPHY_PARAM_FRAG_THRESHOLD) { 1873 err = drv_set_frag_threshold(local, wiphy->frag_threshold); 1874 1875 if (err) 1876 return err; 1877 } 1878 1879 if (changed & WIPHY_PARAM_COVERAGE_CLASS) { 1880 err = drv_set_coverage_class(local, wiphy->coverage_class); 1881 1882 if (err) 1883 return err; 1884 } 1885 1886 if (changed & WIPHY_PARAM_RTS_THRESHOLD) { 1887 err = drv_set_rts_threshold(local, wiphy->rts_threshold); 1888 1889 if (err) 1890 return err; 1891 } 1892 1893 if (changed & WIPHY_PARAM_RETRY_SHORT) 1894 local->hw.conf.short_frame_max_tx_count = wiphy->retry_short; 1895 if (changed & WIPHY_PARAM_RETRY_LONG) 1896 local->hw.conf.long_frame_max_tx_count = wiphy->retry_long; 1897 if (changed & 1898 (WIPHY_PARAM_RETRY_SHORT | WIPHY_PARAM_RETRY_LONG)) 1899 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_RETRY_LIMITS); 1900 1901 return 0; 1902 } 1903 1904 static int ieee80211_set_tx_power(struct wiphy *wiphy, 1905 enum nl80211_tx_power_setting type, int mbm) 1906 { 1907 struct ieee80211_local *local = wiphy_priv(wiphy); 1908 struct ieee80211_channel *chan = local->hw.conf.channel; 1909 u32 changes = 0; 1910 1911 switch (type) { 1912 case NL80211_TX_POWER_AUTOMATIC: 1913 local->user_power_level = -1; 1914 break; 1915 case NL80211_TX_POWER_LIMITED: 1916 if (mbm < 0 || (mbm % 100)) 1917 return -EOPNOTSUPP; 1918 local->user_power_level = MBM_TO_DBM(mbm); 1919 break; 1920 case NL80211_TX_POWER_FIXED: 1921 if (mbm < 0 || (mbm % 100)) 1922 return -EOPNOTSUPP; 1923 /* TODO: move to cfg80211 when it knows the channel */ 1924 if (MBM_TO_DBM(mbm) > chan->max_power) 1925 return -EINVAL; 1926 local->user_power_level = MBM_TO_DBM(mbm); 1927 break; 1928 } 1929 1930 ieee80211_hw_config(local, changes); 1931 1932 return 0; 1933 } 1934 1935 static int ieee80211_get_tx_power(struct wiphy *wiphy, int *dbm) 1936 { 1937 struct ieee80211_local *local = wiphy_priv(wiphy); 1938 1939 *dbm = local->hw.conf.power_level; 1940 1941 return 0; 1942 } 1943 1944 static int ieee80211_set_wds_peer(struct wiphy *wiphy, struct net_device *dev, 1945 const u8 *addr) 1946 { 1947 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1948 1949 memcpy(&sdata->u.wds.remote_addr, addr, ETH_ALEN); 1950 1951 return 0; 1952 } 1953 1954 static void ieee80211_rfkill_poll(struct wiphy *wiphy) 1955 { 1956 struct ieee80211_local *local = wiphy_priv(wiphy); 1957 1958 drv_rfkill_poll(local); 1959 } 1960 1961 #ifdef CONFIG_NL80211_TESTMODE 1962 static int ieee80211_testmode_cmd(struct wiphy *wiphy, void *data, int len) 1963 { 1964 struct ieee80211_local *local = wiphy_priv(wiphy); 1965 1966 if (!local->ops->testmode_cmd) 1967 return -EOPNOTSUPP; 1968 1969 return local->ops->testmode_cmd(&local->hw, data, len); 1970 } 1971 1972 static int ieee80211_testmode_dump(struct wiphy *wiphy, 1973 struct sk_buff *skb, 1974 struct netlink_callback *cb, 1975 void *data, int len) 1976 { 1977 struct ieee80211_local *local = wiphy_priv(wiphy); 1978 1979 if (!local->ops->testmode_dump) 1980 return -EOPNOTSUPP; 1981 1982 return local->ops->testmode_dump(&local->hw, skb, cb, data, len); 1983 } 1984 #endif 1985 1986 int __ieee80211_request_smps(struct ieee80211_sub_if_data *sdata, 1987 enum ieee80211_smps_mode smps_mode) 1988 { 1989 const u8 *ap; 1990 enum ieee80211_smps_mode old_req; 1991 int err; 1992 1993 lockdep_assert_held(&sdata->u.mgd.mtx); 1994 1995 old_req = sdata->u.mgd.req_smps; 1996 sdata->u.mgd.req_smps = smps_mode; 1997 1998 if (old_req == smps_mode && 1999 smps_mode != IEEE80211_SMPS_AUTOMATIC) 2000 return 0; 2001 2002 /* 2003 * If not associated, or current association is not an HT 2004 * association, there's no need to send an action frame. 2005 */ 2006 if (!sdata->u.mgd.associated || 2007 sdata->vif.bss_conf.channel_type == NL80211_CHAN_NO_HT) { 2008 mutex_lock(&sdata->local->iflist_mtx); 2009 ieee80211_recalc_smps(sdata->local); 2010 mutex_unlock(&sdata->local->iflist_mtx); 2011 return 0; 2012 } 2013 2014 ap = sdata->u.mgd.associated->bssid; 2015 2016 if (smps_mode == IEEE80211_SMPS_AUTOMATIC) { 2017 if (sdata->u.mgd.powersave) 2018 smps_mode = IEEE80211_SMPS_DYNAMIC; 2019 else 2020 smps_mode = IEEE80211_SMPS_OFF; 2021 } 2022 2023 /* send SM PS frame to AP */ 2024 err = ieee80211_send_smps_action(sdata, smps_mode, 2025 ap, ap); 2026 if (err) 2027 sdata->u.mgd.req_smps = old_req; 2028 2029 return err; 2030 } 2031 2032 static int ieee80211_set_power_mgmt(struct wiphy *wiphy, struct net_device *dev, 2033 bool enabled, int timeout) 2034 { 2035 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 2036 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 2037 2038 if (sdata->vif.type != NL80211_IFTYPE_STATION) 2039 return -EOPNOTSUPP; 2040 2041 if (!(local->hw.flags & IEEE80211_HW_SUPPORTS_PS)) 2042 return -EOPNOTSUPP; 2043 2044 if (enabled == sdata->u.mgd.powersave && 2045 timeout == local->dynamic_ps_forced_timeout) 2046 return 0; 2047 2048 sdata->u.mgd.powersave = enabled; 2049 local->dynamic_ps_forced_timeout = timeout; 2050 2051 /* no change, but if automatic follow powersave */ 2052 mutex_lock(&sdata->u.mgd.mtx); 2053 __ieee80211_request_smps(sdata, sdata->u.mgd.req_smps); 2054 mutex_unlock(&sdata->u.mgd.mtx); 2055 2056 if (local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_PS) 2057 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS); 2058 2059 ieee80211_recalc_ps(local, -1); 2060 2061 return 0; 2062 } 2063 2064 static int ieee80211_set_cqm_rssi_config(struct wiphy *wiphy, 2065 struct net_device *dev, 2066 s32 rssi_thold, u32 rssi_hyst) 2067 { 2068 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 2069 struct ieee80211_vif *vif = &sdata->vif; 2070 struct ieee80211_bss_conf *bss_conf = &vif->bss_conf; 2071 2072 if (rssi_thold == bss_conf->cqm_rssi_thold && 2073 rssi_hyst == bss_conf->cqm_rssi_hyst) 2074 return 0; 2075 2076 bss_conf->cqm_rssi_thold = rssi_thold; 2077 bss_conf->cqm_rssi_hyst = rssi_hyst; 2078 2079 /* tell the driver upon association, unless already associated */ 2080 if (sdata->u.mgd.associated && 2081 sdata->vif.driver_flags & IEEE80211_VIF_SUPPORTS_CQM_RSSI) 2082 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_CQM); 2083 2084 return 0; 2085 } 2086 2087 static int ieee80211_set_bitrate_mask(struct wiphy *wiphy, 2088 struct net_device *dev, 2089 const u8 *addr, 2090 const struct cfg80211_bitrate_mask *mask) 2091 { 2092 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 2093 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 2094 int i, ret; 2095 2096 if (!ieee80211_sdata_running(sdata)) 2097 return -ENETDOWN; 2098 2099 if (local->hw.flags & IEEE80211_HW_HAS_RATE_CONTROL) { 2100 ret = drv_set_bitrate_mask(local, sdata, mask); 2101 if (ret) 2102 return ret; 2103 } 2104 2105 for (i = 0; i < IEEE80211_NUM_BANDS; i++) { 2106 sdata->rc_rateidx_mask[i] = mask->control[i].legacy; 2107 memcpy(sdata->rc_rateidx_mcs_mask[i], mask->control[i].mcs, 2108 sizeof(mask->control[i].mcs)); 2109 } 2110 2111 return 0; 2112 } 2113 2114 static int ieee80211_remain_on_channel_hw(struct ieee80211_local *local, 2115 struct net_device *dev, 2116 struct ieee80211_channel *chan, 2117 enum nl80211_channel_type chantype, 2118 unsigned int duration, u64 *cookie) 2119 { 2120 int ret; 2121 u32 random_cookie; 2122 2123 lockdep_assert_held(&local->mtx); 2124 2125 if (local->hw_roc_cookie) 2126 return -EBUSY; 2127 /* must be nonzero */ 2128 random_cookie = random32() | 1; 2129 2130 *cookie = random_cookie; 2131 local->hw_roc_dev = dev; 2132 local->hw_roc_cookie = random_cookie; 2133 local->hw_roc_channel = chan; 2134 local->hw_roc_channel_type = chantype; 2135 local->hw_roc_duration = duration; 2136 ret = drv_remain_on_channel(local, chan, chantype, duration); 2137 if (ret) { 2138 local->hw_roc_channel = NULL; 2139 local->hw_roc_cookie = 0; 2140 } 2141 2142 return ret; 2143 } 2144 2145 static int ieee80211_remain_on_channel(struct wiphy *wiphy, 2146 struct net_device *dev, 2147 struct ieee80211_channel *chan, 2148 enum nl80211_channel_type channel_type, 2149 unsigned int duration, 2150 u64 *cookie) 2151 { 2152 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 2153 struct ieee80211_local *local = sdata->local; 2154 2155 if (local->ops->remain_on_channel) { 2156 int ret; 2157 2158 mutex_lock(&local->mtx); 2159 ret = ieee80211_remain_on_channel_hw(local, dev, 2160 chan, channel_type, 2161 duration, cookie); 2162 local->hw_roc_for_tx = false; 2163 mutex_unlock(&local->mtx); 2164 2165 return ret; 2166 } 2167 2168 return ieee80211_wk_remain_on_channel(sdata, chan, channel_type, 2169 duration, cookie); 2170 } 2171 2172 static int ieee80211_cancel_remain_on_channel_hw(struct ieee80211_local *local, 2173 u64 cookie) 2174 { 2175 int ret; 2176 2177 lockdep_assert_held(&local->mtx); 2178 2179 if (local->hw_roc_cookie != cookie) 2180 return -ENOENT; 2181 2182 ret = drv_cancel_remain_on_channel(local); 2183 if (ret) 2184 return ret; 2185 2186 local->hw_roc_cookie = 0; 2187 local->hw_roc_channel = NULL; 2188 2189 ieee80211_recalc_idle(local); 2190 2191 return 0; 2192 } 2193 2194 static int ieee80211_cancel_remain_on_channel(struct wiphy *wiphy, 2195 struct net_device *dev, 2196 u64 cookie) 2197 { 2198 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 2199 struct ieee80211_local *local = sdata->local; 2200 2201 if (local->ops->cancel_remain_on_channel) { 2202 int ret; 2203 2204 mutex_lock(&local->mtx); 2205 ret = ieee80211_cancel_remain_on_channel_hw(local, cookie); 2206 mutex_unlock(&local->mtx); 2207 2208 return ret; 2209 } 2210 2211 return ieee80211_wk_cancel_remain_on_channel(sdata, cookie); 2212 } 2213 2214 static enum work_done_result 2215 ieee80211_offchan_tx_done(struct ieee80211_work *wk, struct sk_buff *skb) 2216 { 2217 /* 2218 * Use the data embedded in the work struct for reporting 2219 * here so if the driver mangled the SKB before dropping 2220 * it (which is the only way we really should get here) 2221 * then we don't report mangled data. 2222 * 2223 * If there was no wait time, then by the time we get here 2224 * the driver will likely not have reported the status yet, 2225 * so in that case userspace will have to deal with it. 2226 */ 2227 2228 if (wk->offchan_tx.wait && !wk->offchan_tx.status) 2229 cfg80211_mgmt_tx_status(wk->sdata->dev, 2230 (unsigned long) wk->offchan_tx.frame, 2231 wk->data, wk->data_len, false, GFP_KERNEL); 2232 2233 return WORK_DONE_DESTROY; 2234 } 2235 2236 static int ieee80211_mgmt_tx(struct wiphy *wiphy, struct net_device *dev, 2237 struct ieee80211_channel *chan, bool offchan, 2238 enum nl80211_channel_type channel_type, 2239 bool channel_type_valid, unsigned int wait, 2240 const u8 *buf, size_t len, bool no_cck, 2241 bool dont_wait_for_ack, u64 *cookie) 2242 { 2243 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 2244 struct ieee80211_local *local = sdata->local; 2245 struct sk_buff *skb; 2246 struct sta_info *sta; 2247 struct ieee80211_work *wk; 2248 const struct ieee80211_mgmt *mgmt = (void *)buf; 2249 u32 flags; 2250 bool is_offchan = false; 2251 2252 if (dont_wait_for_ack) 2253 flags = IEEE80211_TX_CTL_NO_ACK; 2254 else 2255 flags = IEEE80211_TX_INTFL_NL80211_FRAME_TX | 2256 IEEE80211_TX_CTL_REQ_TX_STATUS; 2257 2258 /* Check that we are on the requested channel for transmission */ 2259 if (chan != local->tmp_channel && 2260 chan != local->oper_channel) 2261 is_offchan = true; 2262 if (channel_type_valid && 2263 (channel_type != local->tmp_channel_type && 2264 channel_type != local->_oper_channel_type)) 2265 is_offchan = true; 2266 2267 if (chan == local->hw_roc_channel) { 2268 /* TODO: check channel type? */ 2269 is_offchan = false; 2270 flags |= IEEE80211_TX_CTL_TX_OFFCHAN; 2271 } 2272 2273 if (no_cck) 2274 flags |= IEEE80211_TX_CTL_NO_CCK_RATE; 2275 2276 if (is_offchan && !offchan) 2277 return -EBUSY; 2278 2279 switch (sdata->vif.type) { 2280 case NL80211_IFTYPE_ADHOC: 2281 case NL80211_IFTYPE_AP: 2282 case NL80211_IFTYPE_AP_VLAN: 2283 case NL80211_IFTYPE_P2P_GO: 2284 case NL80211_IFTYPE_MESH_POINT: 2285 if (!ieee80211_is_action(mgmt->frame_control) || 2286 mgmt->u.action.category == WLAN_CATEGORY_PUBLIC) 2287 break; 2288 rcu_read_lock(); 2289 sta = sta_info_get(sdata, mgmt->da); 2290 rcu_read_unlock(); 2291 if (!sta) 2292 return -ENOLINK; 2293 break; 2294 case NL80211_IFTYPE_STATION: 2295 case NL80211_IFTYPE_P2P_CLIENT: 2296 break; 2297 default: 2298 return -EOPNOTSUPP; 2299 } 2300 2301 skb = dev_alloc_skb(local->hw.extra_tx_headroom + len); 2302 if (!skb) 2303 return -ENOMEM; 2304 skb_reserve(skb, local->hw.extra_tx_headroom); 2305 2306 memcpy(skb_put(skb, len), buf, len); 2307 2308 IEEE80211_SKB_CB(skb)->flags = flags; 2309 2310 if (flags & IEEE80211_TX_CTL_TX_OFFCHAN) 2311 IEEE80211_SKB_CB(skb)->hw_queue = 2312 local->hw.offchannel_tx_hw_queue; 2313 2314 skb->dev = sdata->dev; 2315 2316 *cookie = (unsigned long) skb; 2317 2318 if (is_offchan && local->ops->remain_on_channel) { 2319 unsigned int duration; 2320 int ret; 2321 2322 mutex_lock(&local->mtx); 2323 /* 2324 * If the duration is zero, then the driver 2325 * wouldn't actually do anything. Set it to 2326 * 100 for now. 2327 * 2328 * TODO: cancel the off-channel operation 2329 * when we get the SKB's TX status and 2330 * the wait time was zero before. 2331 */ 2332 duration = 100; 2333 if (wait) 2334 duration = wait; 2335 ret = ieee80211_remain_on_channel_hw(local, dev, chan, 2336 channel_type, 2337 duration, cookie); 2338 if (ret) { 2339 kfree_skb(skb); 2340 mutex_unlock(&local->mtx); 2341 return ret; 2342 } 2343 2344 local->hw_roc_for_tx = true; 2345 local->hw_roc_duration = wait; 2346 2347 /* 2348 * queue up frame for transmission after 2349 * ieee80211_ready_on_channel call 2350 */ 2351 2352 /* modify cookie to prevent API mismatches */ 2353 *cookie ^= 2; 2354 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_CTL_TX_OFFCHAN; 2355 IEEE80211_SKB_CB(skb)->hw_queue = 2356 local->hw.offchannel_tx_hw_queue; 2357 local->hw_roc_skb = skb; 2358 local->hw_roc_skb_for_status = skb; 2359 mutex_unlock(&local->mtx); 2360 2361 return 0; 2362 } 2363 2364 /* 2365 * Can transmit right away if the channel was the 2366 * right one and there's no wait involved... If a 2367 * wait is involved, we might otherwise not be on 2368 * the right channel for long enough! 2369 */ 2370 if (!is_offchan && !wait && !sdata->vif.bss_conf.idle) { 2371 ieee80211_tx_skb(sdata, skb); 2372 return 0; 2373 } 2374 2375 wk = kzalloc(sizeof(*wk) + len, GFP_KERNEL); 2376 if (!wk) { 2377 kfree_skb(skb); 2378 return -ENOMEM; 2379 } 2380 2381 wk->type = IEEE80211_WORK_OFFCHANNEL_TX; 2382 wk->chan = chan; 2383 wk->chan_type = channel_type; 2384 wk->sdata = sdata; 2385 wk->done = ieee80211_offchan_tx_done; 2386 wk->offchan_tx.frame = skb; 2387 wk->offchan_tx.wait = wait; 2388 wk->data_len = len; 2389 memcpy(wk->data, buf, len); 2390 2391 ieee80211_add_work(wk); 2392 return 0; 2393 } 2394 2395 static int ieee80211_mgmt_tx_cancel_wait(struct wiphy *wiphy, 2396 struct net_device *dev, 2397 u64 cookie) 2398 { 2399 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 2400 struct ieee80211_local *local = sdata->local; 2401 struct ieee80211_work *wk; 2402 int ret = -ENOENT; 2403 2404 mutex_lock(&local->mtx); 2405 2406 if (local->ops->cancel_remain_on_channel) { 2407 cookie ^= 2; 2408 ret = ieee80211_cancel_remain_on_channel_hw(local, cookie); 2409 2410 if (ret == 0) { 2411 kfree_skb(local->hw_roc_skb); 2412 local->hw_roc_skb = NULL; 2413 local->hw_roc_skb_for_status = NULL; 2414 } 2415 2416 mutex_unlock(&local->mtx); 2417 2418 return ret; 2419 } 2420 2421 list_for_each_entry(wk, &local->work_list, list) { 2422 if (wk->sdata != sdata) 2423 continue; 2424 2425 if (wk->type != IEEE80211_WORK_OFFCHANNEL_TX) 2426 continue; 2427 2428 if (cookie != (unsigned long) wk->offchan_tx.frame) 2429 continue; 2430 2431 wk->timeout = jiffies; 2432 2433 ieee80211_queue_work(&local->hw, &local->work_work); 2434 ret = 0; 2435 break; 2436 } 2437 mutex_unlock(&local->mtx); 2438 2439 return ret; 2440 } 2441 2442 static void ieee80211_mgmt_frame_register(struct wiphy *wiphy, 2443 struct net_device *dev, 2444 u16 frame_type, bool reg) 2445 { 2446 struct ieee80211_local *local = wiphy_priv(wiphy); 2447 2448 if (frame_type != (IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_PROBE_REQ)) 2449 return; 2450 2451 if (reg) 2452 local->probe_req_reg++; 2453 else 2454 local->probe_req_reg--; 2455 2456 ieee80211_queue_work(&local->hw, &local->reconfig_filter); 2457 } 2458 2459 static int ieee80211_set_antenna(struct wiphy *wiphy, u32 tx_ant, u32 rx_ant) 2460 { 2461 struct ieee80211_local *local = wiphy_priv(wiphy); 2462 2463 if (local->started) 2464 return -EOPNOTSUPP; 2465 2466 return drv_set_antenna(local, tx_ant, rx_ant); 2467 } 2468 2469 static int ieee80211_get_antenna(struct wiphy *wiphy, u32 *tx_ant, u32 *rx_ant) 2470 { 2471 struct ieee80211_local *local = wiphy_priv(wiphy); 2472 2473 return drv_get_antenna(local, tx_ant, rx_ant); 2474 } 2475 2476 static int ieee80211_set_ringparam(struct wiphy *wiphy, u32 tx, u32 rx) 2477 { 2478 struct ieee80211_local *local = wiphy_priv(wiphy); 2479 2480 return drv_set_ringparam(local, tx, rx); 2481 } 2482 2483 static void ieee80211_get_ringparam(struct wiphy *wiphy, 2484 u32 *tx, u32 *tx_max, u32 *rx, u32 *rx_max) 2485 { 2486 struct ieee80211_local *local = wiphy_priv(wiphy); 2487 2488 drv_get_ringparam(local, tx, tx_max, rx, rx_max); 2489 } 2490 2491 static int ieee80211_set_rekey_data(struct wiphy *wiphy, 2492 struct net_device *dev, 2493 struct cfg80211_gtk_rekey_data *data) 2494 { 2495 struct ieee80211_local *local = wiphy_priv(wiphy); 2496 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 2497 2498 if (!local->ops->set_rekey_data) 2499 return -EOPNOTSUPP; 2500 2501 drv_set_rekey_data(local, sdata, data); 2502 2503 return 0; 2504 } 2505 2506 static void ieee80211_tdls_add_ext_capab(struct sk_buff *skb) 2507 { 2508 u8 *pos = (void *)skb_put(skb, 7); 2509 2510 *pos++ = WLAN_EID_EXT_CAPABILITY; 2511 *pos++ = 5; /* len */ 2512 *pos++ = 0x0; 2513 *pos++ = 0x0; 2514 *pos++ = 0x0; 2515 *pos++ = 0x0; 2516 *pos++ = WLAN_EXT_CAPA5_TDLS_ENABLED; 2517 } 2518 2519 static u16 ieee80211_get_tdls_sta_capab(struct ieee80211_sub_if_data *sdata) 2520 { 2521 struct ieee80211_local *local = sdata->local; 2522 u16 capab; 2523 2524 capab = 0; 2525 if (local->oper_channel->band != IEEE80211_BAND_2GHZ) 2526 return capab; 2527 2528 if (!(local->hw.flags & IEEE80211_HW_2GHZ_SHORT_SLOT_INCAPABLE)) 2529 capab |= WLAN_CAPABILITY_SHORT_SLOT_TIME; 2530 if (!(local->hw.flags & IEEE80211_HW_2GHZ_SHORT_PREAMBLE_INCAPABLE)) 2531 capab |= WLAN_CAPABILITY_SHORT_PREAMBLE; 2532 2533 return capab; 2534 } 2535 2536 static void ieee80211_tdls_add_link_ie(struct sk_buff *skb, u8 *src_addr, 2537 u8 *peer, u8 *bssid) 2538 { 2539 struct ieee80211_tdls_lnkie *lnkid; 2540 2541 lnkid = (void *)skb_put(skb, sizeof(struct ieee80211_tdls_lnkie)); 2542 2543 lnkid->ie_type = WLAN_EID_LINK_ID; 2544 lnkid->ie_len = sizeof(struct ieee80211_tdls_lnkie) - 2; 2545 2546 memcpy(lnkid->bssid, bssid, ETH_ALEN); 2547 memcpy(lnkid->init_sta, src_addr, ETH_ALEN); 2548 memcpy(lnkid->resp_sta, peer, ETH_ALEN); 2549 } 2550 2551 static int 2552 ieee80211_prep_tdls_encap_data(struct wiphy *wiphy, struct net_device *dev, 2553 u8 *peer, u8 action_code, u8 dialog_token, 2554 u16 status_code, struct sk_buff *skb) 2555 { 2556 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 2557 struct ieee80211_tdls_data *tf; 2558 2559 tf = (void *)skb_put(skb, offsetof(struct ieee80211_tdls_data, u)); 2560 2561 memcpy(tf->da, peer, ETH_ALEN); 2562 memcpy(tf->sa, sdata->vif.addr, ETH_ALEN); 2563 tf->ether_type = cpu_to_be16(ETH_P_TDLS); 2564 tf->payload_type = WLAN_TDLS_SNAP_RFTYPE; 2565 2566 switch (action_code) { 2567 case WLAN_TDLS_SETUP_REQUEST: 2568 tf->category = WLAN_CATEGORY_TDLS; 2569 tf->action_code = WLAN_TDLS_SETUP_REQUEST; 2570 2571 skb_put(skb, sizeof(tf->u.setup_req)); 2572 tf->u.setup_req.dialog_token = dialog_token; 2573 tf->u.setup_req.capability = 2574 cpu_to_le16(ieee80211_get_tdls_sta_capab(sdata)); 2575 2576 ieee80211_add_srates_ie(&sdata->vif, skb, false); 2577 ieee80211_add_ext_srates_ie(&sdata->vif, skb, false); 2578 ieee80211_tdls_add_ext_capab(skb); 2579 break; 2580 case WLAN_TDLS_SETUP_RESPONSE: 2581 tf->category = WLAN_CATEGORY_TDLS; 2582 tf->action_code = WLAN_TDLS_SETUP_RESPONSE; 2583 2584 skb_put(skb, sizeof(tf->u.setup_resp)); 2585 tf->u.setup_resp.status_code = cpu_to_le16(status_code); 2586 tf->u.setup_resp.dialog_token = dialog_token; 2587 tf->u.setup_resp.capability = 2588 cpu_to_le16(ieee80211_get_tdls_sta_capab(sdata)); 2589 2590 ieee80211_add_srates_ie(&sdata->vif, skb, false); 2591 ieee80211_add_ext_srates_ie(&sdata->vif, skb, false); 2592 ieee80211_tdls_add_ext_capab(skb); 2593 break; 2594 case WLAN_TDLS_SETUP_CONFIRM: 2595 tf->category = WLAN_CATEGORY_TDLS; 2596 tf->action_code = WLAN_TDLS_SETUP_CONFIRM; 2597 2598 skb_put(skb, sizeof(tf->u.setup_cfm)); 2599 tf->u.setup_cfm.status_code = cpu_to_le16(status_code); 2600 tf->u.setup_cfm.dialog_token = dialog_token; 2601 break; 2602 case WLAN_TDLS_TEARDOWN: 2603 tf->category = WLAN_CATEGORY_TDLS; 2604 tf->action_code = WLAN_TDLS_TEARDOWN; 2605 2606 skb_put(skb, sizeof(tf->u.teardown)); 2607 tf->u.teardown.reason_code = cpu_to_le16(status_code); 2608 break; 2609 case WLAN_TDLS_DISCOVERY_REQUEST: 2610 tf->category = WLAN_CATEGORY_TDLS; 2611 tf->action_code = WLAN_TDLS_DISCOVERY_REQUEST; 2612 2613 skb_put(skb, sizeof(tf->u.discover_req)); 2614 tf->u.discover_req.dialog_token = dialog_token; 2615 break; 2616 default: 2617 return -EINVAL; 2618 } 2619 2620 return 0; 2621 } 2622 2623 static int 2624 ieee80211_prep_tdls_direct(struct wiphy *wiphy, struct net_device *dev, 2625 u8 *peer, u8 action_code, u8 dialog_token, 2626 u16 status_code, struct sk_buff *skb) 2627 { 2628 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 2629 struct ieee80211_mgmt *mgmt; 2630 2631 mgmt = (void *)skb_put(skb, 24); 2632 memset(mgmt, 0, 24); 2633 memcpy(mgmt->da, peer, ETH_ALEN); 2634 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN); 2635 memcpy(mgmt->bssid, sdata->u.mgd.bssid, ETH_ALEN); 2636 2637 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | 2638 IEEE80211_STYPE_ACTION); 2639 2640 switch (action_code) { 2641 case WLAN_PUB_ACTION_TDLS_DISCOVER_RES: 2642 skb_put(skb, 1 + sizeof(mgmt->u.action.u.tdls_discover_resp)); 2643 mgmt->u.action.category = WLAN_CATEGORY_PUBLIC; 2644 mgmt->u.action.u.tdls_discover_resp.action_code = 2645 WLAN_PUB_ACTION_TDLS_DISCOVER_RES; 2646 mgmt->u.action.u.tdls_discover_resp.dialog_token = 2647 dialog_token; 2648 mgmt->u.action.u.tdls_discover_resp.capability = 2649 cpu_to_le16(ieee80211_get_tdls_sta_capab(sdata)); 2650 2651 ieee80211_add_srates_ie(&sdata->vif, skb, false); 2652 ieee80211_add_ext_srates_ie(&sdata->vif, skb, false); 2653 ieee80211_tdls_add_ext_capab(skb); 2654 break; 2655 default: 2656 return -EINVAL; 2657 } 2658 2659 return 0; 2660 } 2661 2662 static int ieee80211_tdls_mgmt(struct wiphy *wiphy, struct net_device *dev, 2663 u8 *peer, u8 action_code, u8 dialog_token, 2664 u16 status_code, const u8 *extra_ies, 2665 size_t extra_ies_len) 2666 { 2667 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 2668 struct ieee80211_local *local = sdata->local; 2669 struct ieee80211_tx_info *info; 2670 struct sk_buff *skb = NULL; 2671 bool send_direct; 2672 int ret; 2673 2674 if (!(wiphy->flags & WIPHY_FLAG_SUPPORTS_TDLS)) 2675 return -ENOTSUPP; 2676 2677 /* make sure we are in managed mode, and associated */ 2678 if (sdata->vif.type != NL80211_IFTYPE_STATION || 2679 !sdata->u.mgd.associated) 2680 return -EINVAL; 2681 2682 #ifdef CONFIG_MAC80211_VERBOSE_TDLS_DEBUG 2683 printk(KERN_DEBUG "TDLS mgmt action %d peer %pM\n", action_code, peer); 2684 #endif 2685 2686 skb = dev_alloc_skb(local->hw.extra_tx_headroom + 2687 max(sizeof(struct ieee80211_mgmt), 2688 sizeof(struct ieee80211_tdls_data)) + 2689 50 + /* supported rates */ 2690 7 + /* ext capab */ 2691 extra_ies_len + 2692 sizeof(struct ieee80211_tdls_lnkie)); 2693 if (!skb) 2694 return -ENOMEM; 2695 2696 info = IEEE80211_SKB_CB(skb); 2697 skb_reserve(skb, local->hw.extra_tx_headroom); 2698 2699 switch (action_code) { 2700 case WLAN_TDLS_SETUP_REQUEST: 2701 case WLAN_TDLS_SETUP_RESPONSE: 2702 case WLAN_TDLS_SETUP_CONFIRM: 2703 case WLAN_TDLS_TEARDOWN: 2704 case WLAN_TDLS_DISCOVERY_REQUEST: 2705 ret = ieee80211_prep_tdls_encap_data(wiphy, dev, peer, 2706 action_code, dialog_token, 2707 status_code, skb); 2708 send_direct = false; 2709 break; 2710 case WLAN_PUB_ACTION_TDLS_DISCOVER_RES: 2711 ret = ieee80211_prep_tdls_direct(wiphy, dev, peer, action_code, 2712 dialog_token, status_code, 2713 skb); 2714 send_direct = true; 2715 break; 2716 default: 2717 ret = -ENOTSUPP; 2718 break; 2719 } 2720 2721 if (ret < 0) 2722 goto fail; 2723 2724 if (extra_ies_len) 2725 memcpy(skb_put(skb, extra_ies_len), extra_ies, extra_ies_len); 2726 2727 /* the TDLS link IE is always added last */ 2728 switch (action_code) { 2729 case WLAN_TDLS_SETUP_REQUEST: 2730 case WLAN_TDLS_SETUP_CONFIRM: 2731 case WLAN_TDLS_TEARDOWN: 2732 case WLAN_TDLS_DISCOVERY_REQUEST: 2733 /* we are the initiator */ 2734 ieee80211_tdls_add_link_ie(skb, sdata->vif.addr, peer, 2735 sdata->u.mgd.bssid); 2736 break; 2737 case WLAN_TDLS_SETUP_RESPONSE: 2738 case WLAN_PUB_ACTION_TDLS_DISCOVER_RES: 2739 /* we are the responder */ 2740 ieee80211_tdls_add_link_ie(skb, peer, sdata->vif.addr, 2741 sdata->u.mgd.bssid); 2742 break; 2743 default: 2744 ret = -ENOTSUPP; 2745 goto fail; 2746 } 2747 2748 if (send_direct) { 2749 ieee80211_tx_skb(sdata, skb); 2750 return 0; 2751 } 2752 2753 /* 2754 * According to 802.11z: Setup req/resp are sent in AC_BK, otherwise 2755 * we should default to AC_VI. 2756 */ 2757 switch (action_code) { 2758 case WLAN_TDLS_SETUP_REQUEST: 2759 case WLAN_TDLS_SETUP_RESPONSE: 2760 skb_set_queue_mapping(skb, IEEE80211_AC_BK); 2761 skb->priority = 2; 2762 break; 2763 default: 2764 skb_set_queue_mapping(skb, IEEE80211_AC_VI); 2765 skb->priority = 5; 2766 break; 2767 } 2768 2769 /* disable bottom halves when entering the Tx path */ 2770 local_bh_disable(); 2771 ret = ieee80211_subif_start_xmit(skb, dev); 2772 local_bh_enable(); 2773 2774 return ret; 2775 2776 fail: 2777 dev_kfree_skb(skb); 2778 return ret; 2779 } 2780 2781 static int ieee80211_tdls_oper(struct wiphy *wiphy, struct net_device *dev, 2782 u8 *peer, enum nl80211_tdls_operation oper) 2783 { 2784 struct sta_info *sta; 2785 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 2786 2787 if (!(wiphy->flags & WIPHY_FLAG_SUPPORTS_TDLS)) 2788 return -ENOTSUPP; 2789 2790 if (sdata->vif.type != NL80211_IFTYPE_STATION) 2791 return -EINVAL; 2792 2793 #ifdef CONFIG_MAC80211_VERBOSE_TDLS_DEBUG 2794 printk(KERN_DEBUG "TDLS oper %d peer %pM\n", oper, peer); 2795 #endif 2796 2797 switch (oper) { 2798 case NL80211_TDLS_ENABLE_LINK: 2799 rcu_read_lock(); 2800 sta = sta_info_get(sdata, peer); 2801 if (!sta) { 2802 rcu_read_unlock(); 2803 return -ENOLINK; 2804 } 2805 2806 set_sta_flag(sta, WLAN_STA_TDLS_PEER_AUTH); 2807 rcu_read_unlock(); 2808 break; 2809 case NL80211_TDLS_DISABLE_LINK: 2810 return sta_info_destroy_addr(sdata, peer); 2811 case NL80211_TDLS_TEARDOWN: 2812 case NL80211_TDLS_SETUP: 2813 case NL80211_TDLS_DISCOVERY_REQ: 2814 /* We don't support in-driver setup/teardown/discovery */ 2815 return -ENOTSUPP; 2816 default: 2817 return -ENOTSUPP; 2818 } 2819 2820 return 0; 2821 } 2822 2823 static int ieee80211_probe_client(struct wiphy *wiphy, struct net_device *dev, 2824 const u8 *peer, u64 *cookie) 2825 { 2826 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 2827 struct ieee80211_local *local = sdata->local; 2828 struct ieee80211_qos_hdr *nullfunc; 2829 struct sk_buff *skb; 2830 int size = sizeof(*nullfunc); 2831 __le16 fc; 2832 bool qos; 2833 struct ieee80211_tx_info *info; 2834 struct sta_info *sta; 2835 2836 rcu_read_lock(); 2837 sta = sta_info_get(sdata, peer); 2838 if (sta) { 2839 qos = test_sta_flag(sta, WLAN_STA_WME); 2840 rcu_read_unlock(); 2841 } else { 2842 rcu_read_unlock(); 2843 return -ENOLINK; 2844 } 2845 2846 if (qos) { 2847 fc = cpu_to_le16(IEEE80211_FTYPE_DATA | 2848 IEEE80211_STYPE_QOS_NULLFUNC | 2849 IEEE80211_FCTL_FROMDS); 2850 } else { 2851 size -= 2; 2852 fc = cpu_to_le16(IEEE80211_FTYPE_DATA | 2853 IEEE80211_STYPE_NULLFUNC | 2854 IEEE80211_FCTL_FROMDS); 2855 } 2856 2857 skb = dev_alloc_skb(local->hw.extra_tx_headroom + size); 2858 if (!skb) 2859 return -ENOMEM; 2860 2861 skb->dev = dev; 2862 2863 skb_reserve(skb, local->hw.extra_tx_headroom); 2864 2865 nullfunc = (void *) skb_put(skb, size); 2866 nullfunc->frame_control = fc; 2867 nullfunc->duration_id = 0; 2868 memcpy(nullfunc->addr1, sta->sta.addr, ETH_ALEN); 2869 memcpy(nullfunc->addr2, sdata->vif.addr, ETH_ALEN); 2870 memcpy(nullfunc->addr3, sdata->vif.addr, ETH_ALEN); 2871 nullfunc->seq_ctrl = 0; 2872 2873 info = IEEE80211_SKB_CB(skb); 2874 2875 info->flags |= IEEE80211_TX_CTL_REQ_TX_STATUS | 2876 IEEE80211_TX_INTFL_NL80211_FRAME_TX; 2877 2878 skb_set_queue_mapping(skb, IEEE80211_AC_VO); 2879 skb->priority = 7; 2880 if (qos) 2881 nullfunc->qos_ctrl = cpu_to_le16(7); 2882 2883 local_bh_disable(); 2884 ieee80211_xmit(sdata, skb); 2885 local_bh_enable(); 2886 2887 *cookie = (unsigned long) skb; 2888 return 0; 2889 } 2890 2891 static struct ieee80211_channel * 2892 ieee80211_wiphy_get_channel(struct wiphy *wiphy, 2893 enum nl80211_channel_type *type) 2894 { 2895 struct ieee80211_local *local = wiphy_priv(wiphy); 2896 2897 *type = local->_oper_channel_type; 2898 return local->oper_channel; 2899 } 2900 2901 #ifdef CONFIG_PM 2902 static void ieee80211_set_wakeup(struct wiphy *wiphy, bool enabled) 2903 { 2904 drv_set_wakeup(wiphy_priv(wiphy), enabled); 2905 } 2906 #endif 2907 2908 struct cfg80211_ops mac80211_config_ops = { 2909 .add_virtual_intf = ieee80211_add_iface, 2910 .del_virtual_intf = ieee80211_del_iface, 2911 .change_virtual_intf = ieee80211_change_iface, 2912 .add_key = ieee80211_add_key, 2913 .del_key = ieee80211_del_key, 2914 .get_key = ieee80211_get_key, 2915 .set_default_key = ieee80211_config_default_key, 2916 .set_default_mgmt_key = ieee80211_config_default_mgmt_key, 2917 .start_ap = ieee80211_start_ap, 2918 .change_beacon = ieee80211_change_beacon, 2919 .stop_ap = ieee80211_stop_ap, 2920 .add_station = ieee80211_add_station, 2921 .del_station = ieee80211_del_station, 2922 .change_station = ieee80211_change_station, 2923 .get_station = ieee80211_get_station, 2924 .dump_station = ieee80211_dump_station, 2925 .dump_survey = ieee80211_dump_survey, 2926 #ifdef CONFIG_MAC80211_MESH 2927 .add_mpath = ieee80211_add_mpath, 2928 .del_mpath = ieee80211_del_mpath, 2929 .change_mpath = ieee80211_change_mpath, 2930 .get_mpath = ieee80211_get_mpath, 2931 .dump_mpath = ieee80211_dump_mpath, 2932 .update_mesh_config = ieee80211_update_mesh_config, 2933 .get_mesh_config = ieee80211_get_mesh_config, 2934 .join_mesh = ieee80211_join_mesh, 2935 .leave_mesh = ieee80211_leave_mesh, 2936 #endif 2937 .change_bss = ieee80211_change_bss, 2938 .set_txq_params = ieee80211_set_txq_params, 2939 .set_channel = ieee80211_set_channel, 2940 .suspend = ieee80211_suspend, 2941 .resume = ieee80211_resume, 2942 .scan = ieee80211_scan, 2943 .sched_scan_start = ieee80211_sched_scan_start, 2944 .sched_scan_stop = ieee80211_sched_scan_stop, 2945 .auth = ieee80211_auth, 2946 .assoc = ieee80211_assoc, 2947 .deauth = ieee80211_deauth, 2948 .disassoc = ieee80211_disassoc, 2949 .join_ibss = ieee80211_join_ibss, 2950 .leave_ibss = ieee80211_leave_ibss, 2951 .set_wiphy_params = ieee80211_set_wiphy_params, 2952 .set_tx_power = ieee80211_set_tx_power, 2953 .get_tx_power = ieee80211_get_tx_power, 2954 .set_wds_peer = ieee80211_set_wds_peer, 2955 .rfkill_poll = ieee80211_rfkill_poll, 2956 CFG80211_TESTMODE_CMD(ieee80211_testmode_cmd) 2957 CFG80211_TESTMODE_DUMP(ieee80211_testmode_dump) 2958 .set_power_mgmt = ieee80211_set_power_mgmt, 2959 .set_bitrate_mask = ieee80211_set_bitrate_mask, 2960 .remain_on_channel = ieee80211_remain_on_channel, 2961 .cancel_remain_on_channel = ieee80211_cancel_remain_on_channel, 2962 .mgmt_tx = ieee80211_mgmt_tx, 2963 .mgmt_tx_cancel_wait = ieee80211_mgmt_tx_cancel_wait, 2964 .set_cqm_rssi_config = ieee80211_set_cqm_rssi_config, 2965 .mgmt_frame_register = ieee80211_mgmt_frame_register, 2966 .set_antenna = ieee80211_set_antenna, 2967 .get_antenna = ieee80211_get_antenna, 2968 .set_ringparam = ieee80211_set_ringparam, 2969 .get_ringparam = ieee80211_get_ringparam, 2970 .set_rekey_data = ieee80211_set_rekey_data, 2971 .tdls_oper = ieee80211_tdls_oper, 2972 .tdls_mgmt = ieee80211_tdls_mgmt, 2973 .probe_client = ieee80211_probe_client, 2974 .get_channel = ieee80211_wiphy_get_channel, 2975 .set_noack_map = ieee80211_set_noack_map, 2976 #ifdef CONFIG_PM 2977 .set_wakeup = ieee80211_set_wakeup, 2978 #endif 2979 .get_et_sset_count = ieee80211_get_et_sset_count, 2980 .get_et_stats = ieee80211_get_et_stats, 2981 .get_et_strings = ieee80211_get_et_strings, 2982 }; 2983