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