cfg.c revision 4daf50f20256e0022c87c1609226e971a70c82fd
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 <net/cfg80211.h> 16#include "ieee80211_i.h" 17#include "driver-ops.h" 18#include "cfg.h" 19#include "rate.h" 20#include "mesh.h" 21 22static struct net_device *ieee80211_add_iface(struct wiphy *wiphy, char *name, 23 enum nl80211_iftype type, 24 u32 *flags, 25 struct vif_params *params) 26{ 27 struct ieee80211_local *local = wiphy_priv(wiphy); 28 struct net_device *dev; 29 struct ieee80211_sub_if_data *sdata; 30 int err; 31 32 err = ieee80211_if_add(local, name, &dev, type, params); 33 if (err) 34 return ERR_PTR(err); 35 36 if (type == NL80211_IFTYPE_MONITOR && flags) { 37 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 38 sdata->u.mntr_flags = *flags; 39 } 40 41 return dev; 42} 43 44static int ieee80211_del_iface(struct wiphy *wiphy, struct net_device *dev) 45{ 46 ieee80211_if_remove(IEEE80211_DEV_TO_SUB_IF(dev)); 47 48 return 0; 49} 50 51static int ieee80211_change_iface(struct wiphy *wiphy, 52 struct net_device *dev, 53 enum nl80211_iftype type, u32 *flags, 54 struct vif_params *params) 55{ 56 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 57 int ret; 58 59 ret = ieee80211_if_change_type(sdata, type); 60 if (ret) 61 return ret; 62 63 if (type == NL80211_IFTYPE_AP_VLAN && 64 params && params->use_4addr == 0) 65 rcu_assign_pointer(sdata->u.vlan.sta, NULL); 66 else if (type == NL80211_IFTYPE_STATION && 67 params && params->use_4addr >= 0) 68 sdata->u.mgd.use_4addr = params->use_4addr; 69 70 if (sdata->vif.type == NL80211_IFTYPE_MONITOR && flags) { 71 struct ieee80211_local *local = sdata->local; 72 73 if (ieee80211_sdata_running(sdata)) { 74 /* 75 * Prohibit MONITOR_FLAG_COOK_FRAMES to be 76 * changed while the interface is up. 77 * Else we would need to add a lot of cruft 78 * to update everything: 79 * cooked_mntrs, monitor and all fif_* counters 80 * reconfigure hardware 81 */ 82 if ((*flags & MONITOR_FLAG_COOK_FRAMES) != 83 (sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES)) 84 return -EBUSY; 85 86 ieee80211_adjust_monitor_flags(sdata, -1); 87 sdata->u.mntr_flags = *flags; 88 ieee80211_adjust_monitor_flags(sdata, 1); 89 90 ieee80211_configure_filter(local); 91 } else { 92 /* 93 * Because the interface is down, ieee80211_do_stop 94 * and ieee80211_do_open take care of "everything" 95 * mentioned in the comment above. 96 */ 97 sdata->u.mntr_flags = *flags; 98 } 99 } 100 101 return 0; 102} 103 104static int ieee80211_add_key(struct wiphy *wiphy, struct net_device *dev, 105 u8 key_idx, bool pairwise, const u8 *mac_addr, 106 struct key_params *params) 107{ 108 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 109 struct sta_info *sta = NULL; 110 struct ieee80211_key *key; 111 int err; 112 113 if (!ieee80211_sdata_running(sdata)) 114 return -ENETDOWN; 115 116 /* reject WEP and TKIP keys if WEP failed to initialize */ 117 switch (params->cipher) { 118 case WLAN_CIPHER_SUITE_WEP40: 119 case WLAN_CIPHER_SUITE_TKIP: 120 case WLAN_CIPHER_SUITE_WEP104: 121 if (IS_ERR(sdata->local->wep_tx_tfm)) 122 return -EINVAL; 123 break; 124 default: 125 break; 126 } 127 128 key = ieee80211_key_alloc(params->cipher, key_idx, params->key_len, 129 params->key, params->seq_len, params->seq); 130 if (IS_ERR(key)) 131 return PTR_ERR(key); 132 133 if (pairwise) 134 key->conf.flags |= IEEE80211_KEY_FLAG_PAIRWISE; 135 136 mutex_lock(&sdata->local->sta_mtx); 137 138 if (mac_addr) { 139 if (ieee80211_vif_is_mesh(&sdata->vif)) 140 sta = sta_info_get(sdata, mac_addr); 141 else 142 sta = sta_info_get_bss(sdata, mac_addr); 143 if (!sta) { 144 ieee80211_key_free(sdata->local, key); 145 err = -ENOENT; 146 goto out_unlock; 147 } 148 } 149 150 err = ieee80211_key_link(key, sdata, sta); 151 if (err) 152 ieee80211_key_free(sdata->local, key); 153 154 out_unlock: 155 mutex_unlock(&sdata->local->sta_mtx); 156 157 return err; 158} 159 160static int ieee80211_del_key(struct wiphy *wiphy, struct net_device *dev, 161 u8 key_idx, bool pairwise, const u8 *mac_addr) 162{ 163 struct ieee80211_sub_if_data *sdata; 164 struct sta_info *sta; 165 int ret; 166 167 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 168 169 mutex_lock(&sdata->local->sta_mtx); 170 171 if (mac_addr) { 172 ret = -ENOENT; 173 174 sta = sta_info_get_bss(sdata, mac_addr); 175 if (!sta) 176 goto out_unlock; 177 178 if (pairwise) { 179 if (sta->ptk) { 180 ieee80211_key_free(sdata->local, sta->ptk); 181 ret = 0; 182 } 183 } else { 184 if (sta->gtk[key_idx]) { 185 ieee80211_key_free(sdata->local, 186 sta->gtk[key_idx]); 187 ret = 0; 188 } 189 } 190 191 goto out_unlock; 192 } 193 194 if (!sdata->keys[key_idx]) { 195 ret = -ENOENT; 196 goto out_unlock; 197 } 198 199 ieee80211_key_free(sdata->local, sdata->keys[key_idx]); 200 WARN_ON(sdata->keys[key_idx]); 201 202 ret = 0; 203 out_unlock: 204 mutex_unlock(&sdata->local->sta_mtx); 205 206 return ret; 207} 208 209static int ieee80211_get_key(struct wiphy *wiphy, struct net_device *dev, 210 u8 key_idx, bool pairwise, const u8 *mac_addr, 211 void *cookie, 212 void (*callback)(void *cookie, 213 struct key_params *params)) 214{ 215 struct ieee80211_sub_if_data *sdata; 216 struct sta_info *sta = NULL; 217 u8 seq[6] = {0}; 218 struct key_params params; 219 struct ieee80211_key *key = NULL; 220 u32 iv32; 221 u16 iv16; 222 int err = -ENOENT; 223 224 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 225 226 rcu_read_lock(); 227 228 if (mac_addr) { 229 sta = sta_info_get_bss(sdata, mac_addr); 230 if (!sta) 231 goto out; 232 233 if (pairwise) 234 key = sta->ptk; 235 else if (key_idx < NUM_DEFAULT_KEYS) 236 key = sta->gtk[key_idx]; 237 } else 238 key = sdata->keys[key_idx]; 239 240 if (!key) 241 goto out; 242 243 memset(¶ms, 0, sizeof(params)); 244 245 params.cipher = key->conf.cipher; 246 247 switch (key->conf.cipher) { 248 case WLAN_CIPHER_SUITE_TKIP: 249 iv32 = key->u.tkip.tx.iv32; 250 iv16 = key->u.tkip.tx.iv16; 251 252 if (key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE) 253 drv_get_tkip_seq(sdata->local, 254 key->conf.hw_key_idx, 255 &iv32, &iv16); 256 257 seq[0] = iv16 & 0xff; 258 seq[1] = (iv16 >> 8) & 0xff; 259 seq[2] = iv32 & 0xff; 260 seq[3] = (iv32 >> 8) & 0xff; 261 seq[4] = (iv32 >> 16) & 0xff; 262 seq[5] = (iv32 >> 24) & 0xff; 263 params.seq = seq; 264 params.seq_len = 6; 265 break; 266 case WLAN_CIPHER_SUITE_CCMP: 267 seq[0] = key->u.ccmp.tx_pn[5]; 268 seq[1] = key->u.ccmp.tx_pn[4]; 269 seq[2] = key->u.ccmp.tx_pn[3]; 270 seq[3] = key->u.ccmp.tx_pn[2]; 271 seq[4] = key->u.ccmp.tx_pn[1]; 272 seq[5] = key->u.ccmp.tx_pn[0]; 273 params.seq = seq; 274 params.seq_len = 6; 275 break; 276 case WLAN_CIPHER_SUITE_AES_CMAC: 277 seq[0] = key->u.aes_cmac.tx_pn[5]; 278 seq[1] = key->u.aes_cmac.tx_pn[4]; 279 seq[2] = key->u.aes_cmac.tx_pn[3]; 280 seq[3] = key->u.aes_cmac.tx_pn[2]; 281 seq[4] = key->u.aes_cmac.tx_pn[1]; 282 seq[5] = key->u.aes_cmac.tx_pn[0]; 283 params.seq = seq; 284 params.seq_len = 6; 285 break; 286 } 287 288 params.key = key->conf.key; 289 params.key_len = key->conf.keylen; 290 291 callback(cookie, ¶ms); 292 err = 0; 293 294 out: 295 rcu_read_unlock(); 296 return err; 297} 298 299static int ieee80211_config_default_key(struct wiphy *wiphy, 300 struct net_device *dev, 301 u8 key_idx, bool uni, 302 bool multi) 303{ 304 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 305 306 ieee80211_set_default_key(sdata, key_idx, uni, multi); 307 308 return 0; 309} 310 311static int ieee80211_config_default_mgmt_key(struct wiphy *wiphy, 312 struct net_device *dev, 313 u8 key_idx) 314{ 315 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 316 317 ieee80211_set_default_mgmt_key(sdata, key_idx); 318 319 return 0; 320} 321 322static void rate_idx_to_bitrate(struct rate_info *rate, struct sta_info *sta, int idx) 323{ 324 if (!(rate->flags & RATE_INFO_FLAGS_MCS)) { 325 struct ieee80211_supported_band *sband; 326 sband = sta->local->hw.wiphy->bands[ 327 sta->local->hw.conf.channel->band]; 328 rate->legacy = sband->bitrates[idx].bitrate; 329 } else 330 rate->mcs = idx; 331} 332 333static void sta_set_sinfo(struct sta_info *sta, struct station_info *sinfo) 334{ 335 struct ieee80211_sub_if_data *sdata = sta->sdata; 336 struct timespec uptime; 337 338 sinfo->generation = sdata->local->sta_generation; 339 340 sinfo->filled = STATION_INFO_INACTIVE_TIME | 341 STATION_INFO_RX_BYTES | 342 STATION_INFO_TX_BYTES | 343 STATION_INFO_RX_PACKETS | 344 STATION_INFO_TX_PACKETS | 345 STATION_INFO_TX_RETRIES | 346 STATION_INFO_TX_FAILED | 347 STATION_INFO_TX_BITRATE | 348 STATION_INFO_RX_BITRATE | 349 STATION_INFO_RX_DROP_MISC | 350 STATION_INFO_BSS_PARAM | 351 STATION_INFO_CONNECTED_TIME; 352 353 do_posix_clock_monotonic_gettime(&uptime); 354 sinfo->connected_time = uptime.tv_sec - sta->last_connected; 355 356 sinfo->inactive_time = jiffies_to_msecs(jiffies - sta->last_rx); 357 sinfo->rx_bytes = sta->rx_bytes; 358 sinfo->tx_bytes = sta->tx_bytes; 359 sinfo->rx_packets = sta->rx_packets; 360 sinfo->tx_packets = sta->tx_packets; 361 sinfo->tx_retries = sta->tx_retry_count; 362 sinfo->tx_failed = sta->tx_retry_failed; 363 sinfo->rx_dropped_misc = sta->rx_dropped; 364 365 if ((sta->local->hw.flags & IEEE80211_HW_SIGNAL_DBM) || 366 (sta->local->hw.flags & IEEE80211_HW_SIGNAL_UNSPEC)) { 367 sinfo->filled |= STATION_INFO_SIGNAL | STATION_INFO_SIGNAL_AVG; 368 sinfo->signal = (s8)sta->last_signal; 369 sinfo->signal_avg = (s8) -ewma_read(&sta->avg_signal); 370 } 371 372 sinfo->txrate.flags = 0; 373 if (sta->last_tx_rate.flags & IEEE80211_TX_RC_MCS) 374 sinfo->txrate.flags |= RATE_INFO_FLAGS_MCS; 375 if (sta->last_tx_rate.flags & IEEE80211_TX_RC_40_MHZ_WIDTH) 376 sinfo->txrate.flags |= RATE_INFO_FLAGS_40_MHZ_WIDTH; 377 if (sta->last_tx_rate.flags & IEEE80211_TX_RC_SHORT_GI) 378 sinfo->txrate.flags |= RATE_INFO_FLAGS_SHORT_GI; 379 rate_idx_to_bitrate(&sinfo->txrate, sta, sta->last_tx_rate.idx); 380 381 sinfo->rxrate.flags = 0; 382 if (sta->last_rx_rate_flag & RX_FLAG_HT) 383 sinfo->rxrate.flags |= RATE_INFO_FLAGS_MCS; 384 if (sta->last_rx_rate_flag & RX_FLAG_40MHZ) 385 sinfo->rxrate.flags |= RATE_INFO_FLAGS_40_MHZ_WIDTH; 386 if (sta->last_rx_rate_flag & RX_FLAG_SHORT_GI) 387 sinfo->rxrate.flags |= RATE_INFO_FLAGS_SHORT_GI; 388 rate_idx_to_bitrate(&sinfo->rxrate, sta, sta->last_rx_rate_idx); 389 390 if (ieee80211_vif_is_mesh(&sdata->vif)) { 391#ifdef CONFIG_MAC80211_MESH 392 sinfo->filled |= STATION_INFO_LLID | 393 STATION_INFO_PLID | 394 STATION_INFO_PLINK_STATE; 395 396 sinfo->llid = le16_to_cpu(sta->llid); 397 sinfo->plid = le16_to_cpu(sta->plid); 398 sinfo->plink_state = sta->plink_state; 399#endif 400 } 401 402 sinfo->bss_param.flags = 0; 403 if (sdata->vif.bss_conf.use_cts_prot) 404 sinfo->bss_param.flags |= BSS_PARAM_FLAGS_CTS_PROT; 405 if (sdata->vif.bss_conf.use_short_preamble) 406 sinfo->bss_param.flags |= BSS_PARAM_FLAGS_SHORT_PREAMBLE; 407 if (sdata->vif.bss_conf.use_short_slot) 408 sinfo->bss_param.flags |= BSS_PARAM_FLAGS_SHORT_SLOT_TIME; 409 sinfo->bss_param.dtim_period = sdata->local->hw.conf.ps_dtim_period; 410 sinfo->bss_param.beacon_interval = sdata->vif.bss_conf.beacon_int; 411} 412 413 414static int ieee80211_dump_station(struct wiphy *wiphy, struct net_device *dev, 415 int idx, u8 *mac, struct station_info *sinfo) 416{ 417 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 418 struct sta_info *sta; 419 int ret = -ENOENT; 420 421 rcu_read_lock(); 422 423 sta = sta_info_get_by_idx(sdata, idx); 424 if (sta) { 425 ret = 0; 426 memcpy(mac, sta->sta.addr, ETH_ALEN); 427 sta_set_sinfo(sta, sinfo); 428 } 429 430 rcu_read_unlock(); 431 432 return ret; 433} 434 435static int ieee80211_dump_survey(struct wiphy *wiphy, struct net_device *dev, 436 int idx, struct survey_info *survey) 437{ 438 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 439 440 return drv_get_survey(local, idx, survey); 441} 442 443static int ieee80211_get_station(struct wiphy *wiphy, struct net_device *dev, 444 u8 *mac, struct station_info *sinfo) 445{ 446 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 447 struct sta_info *sta; 448 int ret = -ENOENT; 449 450 rcu_read_lock(); 451 452 sta = sta_info_get_bss(sdata, mac); 453 if (sta) { 454 ret = 0; 455 sta_set_sinfo(sta, sinfo); 456 } 457 458 rcu_read_unlock(); 459 460 return ret; 461} 462 463/* 464 * This handles both adding a beacon and setting new beacon info 465 */ 466static int ieee80211_config_beacon(struct ieee80211_sub_if_data *sdata, 467 struct beacon_parameters *params) 468{ 469 struct beacon_data *new, *old; 470 int new_head_len, new_tail_len; 471 int size; 472 int err = -EINVAL; 473 474 old = sdata->u.ap.beacon; 475 476 /* head must not be zero-length */ 477 if (params->head && !params->head_len) 478 return -EINVAL; 479 480 /* 481 * This is a kludge. beacon interval should really be part 482 * of the beacon information. 483 */ 484 if (params->interval && 485 (sdata->vif.bss_conf.beacon_int != params->interval)) { 486 sdata->vif.bss_conf.beacon_int = params->interval; 487 ieee80211_bss_info_change_notify(sdata, 488 BSS_CHANGED_BEACON_INT); 489 } 490 491 /* Need to have a beacon head if we don't have one yet */ 492 if (!params->head && !old) 493 return err; 494 495 /* sorry, no way to start beaconing without dtim period */ 496 if (!params->dtim_period && !old) 497 return err; 498 499 /* new or old head? */ 500 if (params->head) 501 new_head_len = params->head_len; 502 else 503 new_head_len = old->head_len; 504 505 /* new or old tail? */ 506 if (params->tail || !old) 507 /* params->tail_len will be zero for !params->tail */ 508 new_tail_len = params->tail_len; 509 else 510 new_tail_len = old->tail_len; 511 512 size = sizeof(*new) + new_head_len + new_tail_len; 513 514 new = kzalloc(size, GFP_KERNEL); 515 if (!new) 516 return -ENOMEM; 517 518 /* start filling the new info now */ 519 520 /* new or old dtim period? */ 521 if (params->dtim_period) 522 new->dtim_period = params->dtim_period; 523 else 524 new->dtim_period = old->dtim_period; 525 526 /* 527 * pointers go into the block we allocated, 528 * memory is | beacon_data | head | tail | 529 */ 530 new->head = ((u8 *) new) + sizeof(*new); 531 new->tail = new->head + new_head_len; 532 new->head_len = new_head_len; 533 new->tail_len = new_tail_len; 534 535 /* copy in head */ 536 if (params->head) 537 memcpy(new->head, params->head, new_head_len); 538 else 539 memcpy(new->head, old->head, new_head_len); 540 541 /* copy in optional tail */ 542 if (params->tail) 543 memcpy(new->tail, params->tail, new_tail_len); 544 else 545 if (old) 546 memcpy(new->tail, old->tail, new_tail_len); 547 548 sdata->vif.bss_conf.dtim_period = new->dtim_period; 549 550 rcu_assign_pointer(sdata->u.ap.beacon, new); 551 552 synchronize_rcu(); 553 554 kfree(old); 555 556 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON_ENABLED | 557 BSS_CHANGED_BEACON); 558 return 0; 559} 560 561static int ieee80211_add_beacon(struct wiphy *wiphy, struct net_device *dev, 562 struct beacon_parameters *params) 563{ 564 struct ieee80211_sub_if_data *sdata; 565 struct beacon_data *old; 566 567 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 568 569 old = sdata->u.ap.beacon; 570 571 if (old) 572 return -EALREADY; 573 574 return ieee80211_config_beacon(sdata, params); 575} 576 577static int ieee80211_set_beacon(struct wiphy *wiphy, struct net_device *dev, 578 struct beacon_parameters *params) 579{ 580 struct ieee80211_sub_if_data *sdata; 581 struct beacon_data *old; 582 583 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 584 585 old = sdata->u.ap.beacon; 586 587 if (!old) 588 return -ENOENT; 589 590 return ieee80211_config_beacon(sdata, params); 591} 592 593static int ieee80211_del_beacon(struct wiphy *wiphy, struct net_device *dev) 594{ 595 struct ieee80211_sub_if_data *sdata; 596 struct beacon_data *old; 597 598 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 599 600 old = sdata->u.ap.beacon; 601 602 if (!old) 603 return -ENOENT; 604 605 rcu_assign_pointer(sdata->u.ap.beacon, NULL); 606 synchronize_rcu(); 607 kfree(old); 608 609 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON_ENABLED); 610 return 0; 611} 612 613/* Layer 2 Update frame (802.2 Type 1 LLC XID Update response) */ 614struct iapp_layer2_update { 615 u8 da[ETH_ALEN]; /* broadcast */ 616 u8 sa[ETH_ALEN]; /* STA addr */ 617 __be16 len; /* 6 */ 618 u8 dsap; /* 0 */ 619 u8 ssap; /* 0 */ 620 u8 control; 621 u8 xid_info[3]; 622} __packed; 623 624static void ieee80211_send_layer2_update(struct sta_info *sta) 625{ 626 struct iapp_layer2_update *msg; 627 struct sk_buff *skb; 628 629 /* Send Level 2 Update Frame to update forwarding tables in layer 2 630 * bridge devices */ 631 632 skb = dev_alloc_skb(sizeof(*msg)); 633 if (!skb) 634 return; 635 msg = (struct iapp_layer2_update *)skb_put(skb, sizeof(*msg)); 636 637 /* 802.2 Type 1 Logical Link Control (LLC) Exchange Identifier (XID) 638 * Update response frame; IEEE Std 802.2-1998, 5.4.1.2.1 */ 639 640 memset(msg->da, 0xff, ETH_ALEN); 641 memcpy(msg->sa, sta->sta.addr, ETH_ALEN); 642 msg->len = htons(6); 643 msg->dsap = 0; 644 msg->ssap = 0x01; /* NULL LSAP, CR Bit: Response */ 645 msg->control = 0xaf; /* XID response lsb.1111F101. 646 * F=0 (no poll command; unsolicited frame) */ 647 msg->xid_info[0] = 0x81; /* XID format identifier */ 648 msg->xid_info[1] = 1; /* LLC types/classes: Type 1 LLC */ 649 msg->xid_info[2] = 0; /* XID sender's receive window size (RW) */ 650 651 skb->dev = sta->sdata->dev; 652 skb->protocol = eth_type_trans(skb, sta->sdata->dev); 653 memset(skb->cb, 0, sizeof(skb->cb)); 654 netif_rx_ni(skb); 655} 656 657static void sta_apply_parameters(struct ieee80211_local *local, 658 struct sta_info *sta, 659 struct station_parameters *params) 660{ 661 unsigned long flags; 662 u32 rates; 663 int i, j; 664 struct ieee80211_supported_band *sband; 665 struct ieee80211_sub_if_data *sdata = sta->sdata; 666 u32 mask, set; 667 668 sband = local->hw.wiphy->bands[local->oper_channel->band]; 669 670 spin_lock_irqsave(&sta->flaglock, flags); 671 mask = params->sta_flags_mask; 672 set = params->sta_flags_set; 673 674 if (mask & BIT(NL80211_STA_FLAG_AUTHORIZED)) { 675 sta->flags &= ~WLAN_STA_AUTHORIZED; 676 if (set & BIT(NL80211_STA_FLAG_AUTHORIZED)) 677 sta->flags |= WLAN_STA_AUTHORIZED; 678 } 679 680 if (mask & BIT(NL80211_STA_FLAG_SHORT_PREAMBLE)) { 681 sta->flags &= ~WLAN_STA_SHORT_PREAMBLE; 682 if (set & BIT(NL80211_STA_FLAG_SHORT_PREAMBLE)) 683 sta->flags |= WLAN_STA_SHORT_PREAMBLE; 684 } 685 686 if (mask & BIT(NL80211_STA_FLAG_WME)) { 687 sta->flags &= ~WLAN_STA_WME; 688 if (set & BIT(NL80211_STA_FLAG_WME)) 689 sta->flags |= WLAN_STA_WME; 690 } 691 692 if (mask & BIT(NL80211_STA_FLAG_MFP)) { 693 sta->flags &= ~WLAN_STA_MFP; 694 if (set & BIT(NL80211_STA_FLAG_MFP)) 695 sta->flags |= WLAN_STA_MFP; 696 } 697 698 if (mask & BIT(NL80211_STA_FLAG_AUTHENTICATED)) { 699 sta->flags &= ~WLAN_STA_AUTH; 700 if (set & BIT(NL80211_STA_FLAG_AUTHENTICATED)) 701 sta->flags |= WLAN_STA_AUTH; 702 } 703 spin_unlock_irqrestore(&sta->flaglock, flags); 704 705 /* 706 * cfg80211 validates this (1-2007) and allows setting the AID 707 * only when creating a new station entry 708 */ 709 if (params->aid) 710 sta->sta.aid = params->aid; 711 712 /* 713 * FIXME: updating the following information is racy when this 714 * function is called from ieee80211_change_station(). 715 * However, all this information should be static so 716 * maybe we should just reject attemps to change it. 717 */ 718 719 if (params->listen_interval >= 0) 720 sta->listen_interval = params->listen_interval; 721 722 if (params->supported_rates) { 723 rates = 0; 724 725 for (i = 0; i < params->supported_rates_len; i++) { 726 int rate = (params->supported_rates[i] & 0x7f) * 5; 727 for (j = 0; j < sband->n_bitrates; j++) { 728 if (sband->bitrates[j].bitrate == rate) 729 rates |= BIT(j); 730 } 731 } 732 sta->sta.supp_rates[local->oper_channel->band] = rates; 733 } 734 735 if (params->ht_capa) 736 ieee80211_ht_cap_ie_to_sta_ht_cap(sband, 737 params->ht_capa, 738 &sta->sta.ht_cap); 739 740 if (ieee80211_vif_is_mesh(&sdata->vif)) { 741#ifdef CONFIG_MAC80211_MESH 742 if (sdata->u.mesh.security & IEEE80211_MESH_SEC_SECURED) 743 switch (params->plink_state) { 744 case PLINK_LISTEN: 745 case PLINK_ESTAB: 746 case PLINK_BLOCKED: 747 sta->plink_state = params->plink_state; 748 break; 749 default: 750 /* nothing */ 751 break; 752 } 753 else 754 switch (params->plink_action) { 755 case PLINK_ACTION_OPEN: 756 mesh_plink_open(sta); 757 break; 758 case PLINK_ACTION_BLOCK: 759 mesh_plink_block(sta); 760 break; 761 } 762#endif 763 } 764} 765 766static int ieee80211_add_station(struct wiphy *wiphy, struct net_device *dev, 767 u8 *mac, struct station_parameters *params) 768{ 769 struct ieee80211_local *local = wiphy_priv(wiphy); 770 struct sta_info *sta; 771 struct ieee80211_sub_if_data *sdata; 772 int err; 773 int layer2_update; 774 775 if (params->vlan) { 776 sdata = IEEE80211_DEV_TO_SUB_IF(params->vlan); 777 778 if (sdata->vif.type != NL80211_IFTYPE_AP_VLAN && 779 sdata->vif.type != NL80211_IFTYPE_AP) 780 return -EINVAL; 781 } else 782 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 783 784 if (compare_ether_addr(mac, sdata->vif.addr) == 0) 785 return -EINVAL; 786 787 if (is_multicast_ether_addr(mac)) 788 return -EINVAL; 789 790 sta = sta_info_alloc(sdata, mac, GFP_KERNEL); 791 if (!sta) 792 return -ENOMEM; 793 794 sta->flags = WLAN_STA_AUTH | WLAN_STA_ASSOC; 795 796 sta_apply_parameters(local, sta, params); 797 798 rate_control_rate_init(sta); 799 800 layer2_update = sdata->vif.type == NL80211_IFTYPE_AP_VLAN || 801 sdata->vif.type == NL80211_IFTYPE_AP; 802 803 err = sta_info_insert_rcu(sta); 804 if (err) { 805 rcu_read_unlock(); 806 return err; 807 } 808 809 if (layer2_update) 810 ieee80211_send_layer2_update(sta); 811 812 rcu_read_unlock(); 813 814 return 0; 815} 816 817static int ieee80211_del_station(struct wiphy *wiphy, struct net_device *dev, 818 u8 *mac) 819{ 820 struct ieee80211_local *local = wiphy_priv(wiphy); 821 struct ieee80211_sub_if_data *sdata; 822 823 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 824 825 if (mac) 826 return sta_info_destroy_addr_bss(sdata, mac); 827 828 sta_info_flush(local, sdata); 829 return 0; 830} 831 832static int ieee80211_change_station(struct wiphy *wiphy, 833 struct net_device *dev, 834 u8 *mac, 835 struct station_parameters *params) 836{ 837 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 838 struct ieee80211_local *local = wiphy_priv(wiphy); 839 struct sta_info *sta; 840 struct ieee80211_sub_if_data *vlansdata; 841 842 rcu_read_lock(); 843 844 sta = sta_info_get_bss(sdata, mac); 845 if (!sta) { 846 rcu_read_unlock(); 847 return -ENOENT; 848 } 849 850 if (params->vlan && params->vlan != sta->sdata->dev) { 851 vlansdata = IEEE80211_DEV_TO_SUB_IF(params->vlan); 852 853 if (vlansdata->vif.type != NL80211_IFTYPE_AP_VLAN && 854 vlansdata->vif.type != NL80211_IFTYPE_AP) { 855 rcu_read_unlock(); 856 return -EINVAL; 857 } 858 859 if (params->vlan->ieee80211_ptr->use_4addr) { 860 if (vlansdata->u.vlan.sta) { 861 rcu_read_unlock(); 862 return -EBUSY; 863 } 864 865 rcu_assign_pointer(vlansdata->u.vlan.sta, sta); 866 } 867 868 sta->sdata = vlansdata; 869 ieee80211_send_layer2_update(sta); 870 } 871 872 sta_apply_parameters(local, sta, params); 873 874 rcu_read_unlock(); 875 876 if (sdata->vif.type == NL80211_IFTYPE_STATION && 877 params->sta_flags_mask & BIT(NL80211_STA_FLAG_AUTHORIZED)) 878 ieee80211_recalc_ps(local, -1); 879 880 return 0; 881} 882 883#ifdef CONFIG_MAC80211_MESH 884static int ieee80211_add_mpath(struct wiphy *wiphy, struct net_device *dev, 885 u8 *dst, u8 *next_hop) 886{ 887 struct ieee80211_sub_if_data *sdata; 888 struct mesh_path *mpath; 889 struct sta_info *sta; 890 int err; 891 892 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 893 894 rcu_read_lock(); 895 sta = sta_info_get(sdata, next_hop); 896 if (!sta) { 897 rcu_read_unlock(); 898 return -ENOENT; 899 } 900 901 err = mesh_path_add(dst, sdata); 902 if (err) { 903 rcu_read_unlock(); 904 return err; 905 } 906 907 mpath = mesh_path_lookup(dst, sdata); 908 if (!mpath) { 909 rcu_read_unlock(); 910 return -ENXIO; 911 } 912 mesh_path_fix_nexthop(mpath, sta); 913 914 rcu_read_unlock(); 915 return 0; 916} 917 918static int ieee80211_del_mpath(struct wiphy *wiphy, struct net_device *dev, 919 u8 *dst) 920{ 921 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 922 923 if (dst) 924 return mesh_path_del(dst, sdata); 925 926 mesh_path_flush(sdata); 927 return 0; 928} 929 930static int ieee80211_change_mpath(struct wiphy *wiphy, 931 struct net_device *dev, 932 u8 *dst, u8 *next_hop) 933{ 934 struct ieee80211_sub_if_data *sdata; 935 struct mesh_path *mpath; 936 struct sta_info *sta; 937 938 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 939 940 rcu_read_lock(); 941 942 sta = sta_info_get(sdata, next_hop); 943 if (!sta) { 944 rcu_read_unlock(); 945 return -ENOENT; 946 } 947 948 mpath = mesh_path_lookup(dst, sdata); 949 if (!mpath) { 950 rcu_read_unlock(); 951 return -ENOENT; 952 } 953 954 mesh_path_fix_nexthop(mpath, sta); 955 956 rcu_read_unlock(); 957 return 0; 958} 959 960static void mpath_set_pinfo(struct mesh_path *mpath, u8 *next_hop, 961 struct mpath_info *pinfo) 962{ 963 if (mpath->next_hop) 964 memcpy(next_hop, mpath->next_hop->sta.addr, ETH_ALEN); 965 else 966 memset(next_hop, 0, ETH_ALEN); 967 968 pinfo->generation = mesh_paths_generation; 969 970 pinfo->filled = MPATH_INFO_FRAME_QLEN | 971 MPATH_INFO_SN | 972 MPATH_INFO_METRIC | 973 MPATH_INFO_EXPTIME | 974 MPATH_INFO_DISCOVERY_TIMEOUT | 975 MPATH_INFO_DISCOVERY_RETRIES | 976 MPATH_INFO_FLAGS; 977 978 pinfo->frame_qlen = mpath->frame_queue.qlen; 979 pinfo->sn = mpath->sn; 980 pinfo->metric = mpath->metric; 981 if (time_before(jiffies, mpath->exp_time)) 982 pinfo->exptime = jiffies_to_msecs(mpath->exp_time - jiffies); 983 pinfo->discovery_timeout = 984 jiffies_to_msecs(mpath->discovery_timeout); 985 pinfo->discovery_retries = mpath->discovery_retries; 986 pinfo->flags = 0; 987 if (mpath->flags & MESH_PATH_ACTIVE) 988 pinfo->flags |= NL80211_MPATH_FLAG_ACTIVE; 989 if (mpath->flags & MESH_PATH_RESOLVING) 990 pinfo->flags |= NL80211_MPATH_FLAG_RESOLVING; 991 if (mpath->flags & MESH_PATH_SN_VALID) 992 pinfo->flags |= NL80211_MPATH_FLAG_SN_VALID; 993 if (mpath->flags & MESH_PATH_FIXED) 994 pinfo->flags |= NL80211_MPATH_FLAG_FIXED; 995 if (mpath->flags & MESH_PATH_RESOLVING) 996 pinfo->flags |= NL80211_MPATH_FLAG_RESOLVING; 997 998 pinfo->flags = mpath->flags; 999} 1000 1001static int ieee80211_get_mpath(struct wiphy *wiphy, struct net_device *dev, 1002 u8 *dst, u8 *next_hop, struct mpath_info *pinfo) 1003 1004{ 1005 struct ieee80211_sub_if_data *sdata; 1006 struct mesh_path *mpath; 1007 1008 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1009 1010 rcu_read_lock(); 1011 mpath = mesh_path_lookup(dst, sdata); 1012 if (!mpath) { 1013 rcu_read_unlock(); 1014 return -ENOENT; 1015 } 1016 memcpy(dst, mpath->dst, ETH_ALEN); 1017 mpath_set_pinfo(mpath, next_hop, pinfo); 1018 rcu_read_unlock(); 1019 return 0; 1020} 1021 1022static int ieee80211_dump_mpath(struct wiphy *wiphy, struct net_device *dev, 1023 int idx, u8 *dst, u8 *next_hop, 1024 struct mpath_info *pinfo) 1025{ 1026 struct ieee80211_sub_if_data *sdata; 1027 struct mesh_path *mpath; 1028 1029 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1030 1031 rcu_read_lock(); 1032 mpath = mesh_path_lookup_by_idx(idx, sdata); 1033 if (!mpath) { 1034 rcu_read_unlock(); 1035 return -ENOENT; 1036 } 1037 memcpy(dst, mpath->dst, ETH_ALEN); 1038 mpath_set_pinfo(mpath, next_hop, pinfo); 1039 rcu_read_unlock(); 1040 return 0; 1041} 1042 1043static int ieee80211_get_mesh_config(struct wiphy *wiphy, 1044 struct net_device *dev, 1045 struct mesh_config *conf) 1046{ 1047 struct ieee80211_sub_if_data *sdata; 1048 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1049 1050 memcpy(conf, &(sdata->u.mesh.mshcfg), sizeof(struct mesh_config)); 1051 return 0; 1052} 1053 1054static inline bool _chg_mesh_attr(enum nl80211_meshconf_params parm, u32 mask) 1055{ 1056 return (mask >> (parm-1)) & 0x1; 1057} 1058 1059static int copy_mesh_setup(struct ieee80211_if_mesh *ifmsh, 1060 const struct mesh_setup *setup) 1061{ 1062 u8 *new_ie; 1063 const u8 *old_ie; 1064 1065 /* allocate information elements */ 1066 new_ie = NULL; 1067 old_ie = ifmsh->ie; 1068 1069 if (setup->ie_len) { 1070 new_ie = kmemdup(setup->ie, setup->ie_len, 1071 GFP_KERNEL); 1072 if (!new_ie) 1073 return -ENOMEM; 1074 } 1075 ifmsh->ie_len = setup->ie_len; 1076 ifmsh->ie = new_ie; 1077 kfree(old_ie); 1078 1079 /* now copy the rest of the setup parameters */ 1080 ifmsh->mesh_id_len = setup->mesh_id_len; 1081 memcpy(ifmsh->mesh_id, setup->mesh_id, ifmsh->mesh_id_len); 1082 ifmsh->mesh_pp_id = setup->path_sel_proto; 1083 ifmsh->mesh_pm_id = setup->path_metric; 1084 ifmsh->security = IEEE80211_MESH_SEC_NONE; 1085 if (setup->is_authenticated) 1086 ifmsh->security |= IEEE80211_MESH_SEC_AUTHED; 1087 if (setup->is_secure) 1088 ifmsh->security |= IEEE80211_MESH_SEC_SECURED; 1089 1090 return 0; 1091} 1092 1093static int ieee80211_update_mesh_config(struct wiphy *wiphy, 1094 struct net_device *dev, u32 mask, 1095 const struct mesh_config *nconf) 1096{ 1097 struct mesh_config *conf; 1098 struct ieee80211_sub_if_data *sdata; 1099 struct ieee80211_if_mesh *ifmsh; 1100 1101 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1102 ifmsh = &sdata->u.mesh; 1103 1104 /* Set the config options which we are interested in setting */ 1105 conf = &(sdata->u.mesh.mshcfg); 1106 if (_chg_mesh_attr(NL80211_MESHCONF_RETRY_TIMEOUT, mask)) 1107 conf->dot11MeshRetryTimeout = nconf->dot11MeshRetryTimeout; 1108 if (_chg_mesh_attr(NL80211_MESHCONF_CONFIRM_TIMEOUT, mask)) 1109 conf->dot11MeshConfirmTimeout = nconf->dot11MeshConfirmTimeout; 1110 if (_chg_mesh_attr(NL80211_MESHCONF_HOLDING_TIMEOUT, mask)) 1111 conf->dot11MeshHoldingTimeout = nconf->dot11MeshHoldingTimeout; 1112 if (_chg_mesh_attr(NL80211_MESHCONF_MAX_PEER_LINKS, mask)) 1113 conf->dot11MeshMaxPeerLinks = nconf->dot11MeshMaxPeerLinks; 1114 if (_chg_mesh_attr(NL80211_MESHCONF_MAX_RETRIES, mask)) 1115 conf->dot11MeshMaxRetries = nconf->dot11MeshMaxRetries; 1116 if (_chg_mesh_attr(NL80211_MESHCONF_TTL, mask)) 1117 conf->dot11MeshTTL = nconf->dot11MeshTTL; 1118 if (_chg_mesh_attr(NL80211_MESHCONF_ELEMENT_TTL, mask)) 1119 conf->dot11MeshTTL = nconf->element_ttl; 1120 if (_chg_mesh_attr(NL80211_MESHCONF_AUTO_OPEN_PLINKS, mask)) 1121 conf->auto_open_plinks = nconf->auto_open_plinks; 1122 if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES, mask)) 1123 conf->dot11MeshHWMPmaxPREQretries = 1124 nconf->dot11MeshHWMPmaxPREQretries; 1125 if (_chg_mesh_attr(NL80211_MESHCONF_PATH_REFRESH_TIME, mask)) 1126 conf->path_refresh_time = nconf->path_refresh_time; 1127 if (_chg_mesh_attr(NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT, mask)) 1128 conf->min_discovery_timeout = nconf->min_discovery_timeout; 1129 if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT, mask)) 1130 conf->dot11MeshHWMPactivePathTimeout = 1131 nconf->dot11MeshHWMPactivePathTimeout; 1132 if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL, mask)) 1133 conf->dot11MeshHWMPpreqMinInterval = 1134 nconf->dot11MeshHWMPpreqMinInterval; 1135 if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME, 1136 mask)) 1137 conf->dot11MeshHWMPnetDiameterTraversalTime = 1138 nconf->dot11MeshHWMPnetDiameterTraversalTime; 1139 if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_ROOTMODE, mask)) { 1140 conf->dot11MeshHWMPRootMode = nconf->dot11MeshHWMPRootMode; 1141 ieee80211_mesh_root_setup(ifmsh); 1142 } 1143 return 0; 1144} 1145 1146static int ieee80211_join_mesh(struct wiphy *wiphy, struct net_device *dev, 1147 const struct mesh_config *conf, 1148 const struct mesh_setup *setup) 1149{ 1150 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1151 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; 1152 int err; 1153 1154 memcpy(&ifmsh->mshcfg, conf, sizeof(struct mesh_config)); 1155 err = copy_mesh_setup(ifmsh, setup); 1156 if (err) 1157 return err; 1158 ieee80211_start_mesh(sdata); 1159 1160 return 0; 1161} 1162 1163static int ieee80211_leave_mesh(struct wiphy *wiphy, struct net_device *dev) 1164{ 1165 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1166 1167 ieee80211_stop_mesh(sdata); 1168 1169 return 0; 1170} 1171#endif 1172 1173static int ieee80211_change_bss(struct wiphy *wiphy, 1174 struct net_device *dev, 1175 struct bss_parameters *params) 1176{ 1177 struct ieee80211_sub_if_data *sdata; 1178 u32 changed = 0; 1179 1180 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1181 1182 if (params->use_cts_prot >= 0) { 1183 sdata->vif.bss_conf.use_cts_prot = params->use_cts_prot; 1184 changed |= BSS_CHANGED_ERP_CTS_PROT; 1185 } 1186 if (params->use_short_preamble >= 0) { 1187 sdata->vif.bss_conf.use_short_preamble = 1188 params->use_short_preamble; 1189 changed |= BSS_CHANGED_ERP_PREAMBLE; 1190 } 1191 1192 if (!sdata->vif.bss_conf.use_short_slot && 1193 sdata->local->hw.conf.channel->band == IEEE80211_BAND_5GHZ) { 1194 sdata->vif.bss_conf.use_short_slot = true; 1195 changed |= BSS_CHANGED_ERP_SLOT; 1196 } 1197 1198 if (params->use_short_slot_time >= 0) { 1199 sdata->vif.bss_conf.use_short_slot = 1200 params->use_short_slot_time; 1201 changed |= BSS_CHANGED_ERP_SLOT; 1202 } 1203 1204 if (params->basic_rates) { 1205 int i, j; 1206 u32 rates = 0; 1207 struct ieee80211_local *local = wiphy_priv(wiphy); 1208 struct ieee80211_supported_band *sband = 1209 wiphy->bands[local->oper_channel->band]; 1210 1211 for (i = 0; i < params->basic_rates_len; i++) { 1212 int rate = (params->basic_rates[i] & 0x7f) * 5; 1213 for (j = 0; j < sband->n_bitrates; j++) { 1214 if (sband->bitrates[j].bitrate == rate) 1215 rates |= BIT(j); 1216 } 1217 } 1218 sdata->vif.bss_conf.basic_rates = rates; 1219 changed |= BSS_CHANGED_BASIC_RATES; 1220 } 1221 1222 if (params->ap_isolate >= 0) { 1223 if (params->ap_isolate) 1224 sdata->flags |= IEEE80211_SDATA_DONT_BRIDGE_PACKETS; 1225 else 1226 sdata->flags &= ~IEEE80211_SDATA_DONT_BRIDGE_PACKETS; 1227 } 1228 1229 if (params->ht_opmode >= 0) { 1230 sdata->vif.bss_conf.ht_operation_mode = 1231 (u16) params->ht_opmode; 1232 changed |= BSS_CHANGED_HT; 1233 } 1234 1235 ieee80211_bss_info_change_notify(sdata, changed); 1236 1237 return 0; 1238} 1239 1240static int ieee80211_set_txq_params(struct wiphy *wiphy, 1241 struct ieee80211_txq_params *params) 1242{ 1243 struct ieee80211_local *local = wiphy_priv(wiphy); 1244 struct ieee80211_tx_queue_params p; 1245 1246 if (!local->ops->conf_tx) 1247 return -EOPNOTSUPP; 1248 1249 memset(&p, 0, sizeof(p)); 1250 p.aifs = params->aifs; 1251 p.cw_max = params->cwmax; 1252 p.cw_min = params->cwmin; 1253 p.txop = params->txop; 1254 1255 /* 1256 * Setting tx queue params disables u-apsd because it's only 1257 * called in master mode. 1258 */ 1259 p.uapsd = false; 1260 1261 if (drv_conf_tx(local, params->queue, &p)) { 1262 wiphy_debug(local->hw.wiphy, 1263 "failed to set TX queue parameters for queue %d\n", 1264 params->queue); 1265 return -EINVAL; 1266 } 1267 1268 return 0; 1269} 1270 1271static int ieee80211_set_channel(struct wiphy *wiphy, 1272 struct net_device *netdev, 1273 struct ieee80211_channel *chan, 1274 enum nl80211_channel_type channel_type) 1275{ 1276 struct ieee80211_local *local = wiphy_priv(wiphy); 1277 struct ieee80211_sub_if_data *sdata = NULL; 1278 struct ieee80211_channel *old_oper; 1279 enum nl80211_channel_type old_oper_type; 1280 enum nl80211_channel_type old_vif_oper_type= NL80211_CHAN_NO_HT; 1281 1282 if (netdev) 1283 sdata = IEEE80211_DEV_TO_SUB_IF(netdev); 1284 1285 switch (ieee80211_get_channel_mode(local, NULL)) { 1286 case CHAN_MODE_HOPPING: 1287 return -EBUSY; 1288 case CHAN_MODE_FIXED: 1289 if (local->oper_channel != chan) 1290 return -EBUSY; 1291 if (!sdata && local->_oper_channel_type == channel_type) 1292 return 0; 1293 break; 1294 case CHAN_MODE_UNDEFINED: 1295 break; 1296 } 1297 1298 if (sdata) 1299 old_vif_oper_type = sdata->vif.bss_conf.channel_type; 1300 old_oper_type = local->_oper_channel_type; 1301 1302 if (!ieee80211_set_channel_type(local, sdata, channel_type)) 1303 return -EBUSY; 1304 1305 old_oper = local->oper_channel; 1306 local->oper_channel = chan; 1307 1308 /* Update driver if changes were actually made. */ 1309 if ((old_oper != local->oper_channel) || 1310 (old_oper_type != local->_oper_channel_type)) 1311 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_CHANNEL); 1312 1313 if ((sdata && sdata->vif.type != NL80211_IFTYPE_MONITOR) && 1314 old_vif_oper_type != sdata->vif.bss_conf.channel_type) 1315 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_HT); 1316 1317 return 0; 1318} 1319 1320#ifdef CONFIG_PM 1321static int ieee80211_suspend(struct wiphy *wiphy, 1322 struct cfg80211_wowlan *wowlan) 1323{ 1324 return __ieee80211_suspend(wiphy_priv(wiphy), wowlan); 1325} 1326 1327static int ieee80211_resume(struct wiphy *wiphy) 1328{ 1329 return __ieee80211_resume(wiphy_priv(wiphy)); 1330} 1331#else 1332#define ieee80211_suspend NULL 1333#define ieee80211_resume NULL 1334#endif 1335 1336static int ieee80211_scan(struct wiphy *wiphy, 1337 struct net_device *dev, 1338 struct cfg80211_scan_request *req) 1339{ 1340 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1341 1342 switch (ieee80211_vif_type_p2p(&sdata->vif)) { 1343 case NL80211_IFTYPE_STATION: 1344 case NL80211_IFTYPE_ADHOC: 1345 case NL80211_IFTYPE_MESH_POINT: 1346 case NL80211_IFTYPE_P2P_CLIENT: 1347 break; 1348 case NL80211_IFTYPE_P2P_GO: 1349 if (sdata->local->ops->hw_scan) 1350 break; 1351 /* 1352 * FIXME: implement NoA while scanning in software, 1353 * for now fall through to allow scanning only when 1354 * beaconing hasn't been configured yet 1355 */ 1356 case NL80211_IFTYPE_AP: 1357 if (sdata->u.ap.beacon) 1358 return -EOPNOTSUPP; 1359 break; 1360 default: 1361 return -EOPNOTSUPP; 1362 } 1363 1364 return ieee80211_request_scan(sdata, req); 1365} 1366 1367static int 1368ieee80211_sched_scan_start(struct wiphy *wiphy, 1369 struct net_device *dev, 1370 struct cfg80211_sched_scan_request *req) 1371{ 1372 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1373 1374 if (!sdata->local->ops->sched_scan_start) 1375 return -EOPNOTSUPP; 1376 1377 return ieee80211_request_sched_scan_start(sdata, req); 1378} 1379 1380static int 1381ieee80211_sched_scan_stop(struct wiphy *wiphy, struct net_device *dev, 1382 bool driver_initiated) 1383{ 1384 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1385 1386 if (!sdata->local->ops->sched_scan_stop) 1387 return -EOPNOTSUPP; 1388 1389 return ieee80211_request_sched_scan_stop(sdata, driver_initiated); 1390} 1391 1392static int ieee80211_auth(struct wiphy *wiphy, struct net_device *dev, 1393 struct cfg80211_auth_request *req) 1394{ 1395 return ieee80211_mgd_auth(IEEE80211_DEV_TO_SUB_IF(dev), req); 1396} 1397 1398static int ieee80211_assoc(struct wiphy *wiphy, struct net_device *dev, 1399 struct cfg80211_assoc_request *req) 1400{ 1401 struct ieee80211_local *local = wiphy_priv(wiphy); 1402 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1403 1404 switch (ieee80211_get_channel_mode(local, sdata)) { 1405 case CHAN_MODE_HOPPING: 1406 return -EBUSY; 1407 case CHAN_MODE_FIXED: 1408 if (local->oper_channel == req->bss->channel) 1409 break; 1410 return -EBUSY; 1411 case CHAN_MODE_UNDEFINED: 1412 break; 1413 } 1414 1415 return ieee80211_mgd_assoc(IEEE80211_DEV_TO_SUB_IF(dev), req); 1416} 1417 1418static int ieee80211_deauth(struct wiphy *wiphy, struct net_device *dev, 1419 struct cfg80211_deauth_request *req, 1420 void *cookie) 1421{ 1422 return ieee80211_mgd_deauth(IEEE80211_DEV_TO_SUB_IF(dev), 1423 req, cookie); 1424} 1425 1426static int ieee80211_disassoc(struct wiphy *wiphy, struct net_device *dev, 1427 struct cfg80211_disassoc_request *req, 1428 void *cookie) 1429{ 1430 return ieee80211_mgd_disassoc(IEEE80211_DEV_TO_SUB_IF(dev), 1431 req, cookie); 1432} 1433 1434static int ieee80211_join_ibss(struct wiphy *wiphy, struct net_device *dev, 1435 struct cfg80211_ibss_params *params) 1436{ 1437 struct ieee80211_local *local = wiphy_priv(wiphy); 1438 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1439 1440 switch (ieee80211_get_channel_mode(local, sdata)) { 1441 case CHAN_MODE_HOPPING: 1442 return -EBUSY; 1443 case CHAN_MODE_FIXED: 1444 if (!params->channel_fixed) 1445 return -EBUSY; 1446 if (local->oper_channel == params->channel) 1447 break; 1448 return -EBUSY; 1449 case CHAN_MODE_UNDEFINED: 1450 break; 1451 } 1452 1453 return ieee80211_ibss_join(sdata, params); 1454} 1455 1456static int ieee80211_leave_ibss(struct wiphy *wiphy, struct net_device *dev) 1457{ 1458 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1459 1460 return ieee80211_ibss_leave(sdata); 1461} 1462 1463static int ieee80211_set_wiphy_params(struct wiphy *wiphy, u32 changed) 1464{ 1465 struct ieee80211_local *local = wiphy_priv(wiphy); 1466 int err; 1467 1468 if (changed & WIPHY_PARAM_FRAG_THRESHOLD) { 1469 err = drv_set_frag_threshold(local, wiphy->frag_threshold); 1470 1471 if (err) 1472 return err; 1473 } 1474 1475 if (changed & WIPHY_PARAM_COVERAGE_CLASS) { 1476 err = drv_set_coverage_class(local, wiphy->coverage_class); 1477 1478 if (err) 1479 return err; 1480 } 1481 1482 if (changed & WIPHY_PARAM_RTS_THRESHOLD) { 1483 err = drv_set_rts_threshold(local, wiphy->rts_threshold); 1484 1485 if (err) 1486 return err; 1487 } 1488 1489 if (changed & WIPHY_PARAM_RETRY_SHORT) 1490 local->hw.conf.short_frame_max_tx_count = wiphy->retry_short; 1491 if (changed & WIPHY_PARAM_RETRY_LONG) 1492 local->hw.conf.long_frame_max_tx_count = wiphy->retry_long; 1493 if (changed & 1494 (WIPHY_PARAM_RETRY_SHORT | WIPHY_PARAM_RETRY_LONG)) 1495 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_RETRY_LIMITS); 1496 1497 return 0; 1498} 1499 1500static int ieee80211_set_tx_power(struct wiphy *wiphy, 1501 enum nl80211_tx_power_setting type, int mbm) 1502{ 1503 struct ieee80211_local *local = wiphy_priv(wiphy); 1504 struct ieee80211_channel *chan = local->hw.conf.channel; 1505 u32 changes = 0; 1506 1507 switch (type) { 1508 case NL80211_TX_POWER_AUTOMATIC: 1509 local->user_power_level = -1; 1510 break; 1511 case NL80211_TX_POWER_LIMITED: 1512 if (mbm < 0 || (mbm % 100)) 1513 return -EOPNOTSUPP; 1514 local->user_power_level = MBM_TO_DBM(mbm); 1515 break; 1516 case NL80211_TX_POWER_FIXED: 1517 if (mbm < 0 || (mbm % 100)) 1518 return -EOPNOTSUPP; 1519 /* TODO: move to cfg80211 when it knows the channel */ 1520 if (MBM_TO_DBM(mbm) > chan->max_power) 1521 return -EINVAL; 1522 local->user_power_level = MBM_TO_DBM(mbm); 1523 break; 1524 } 1525 1526 ieee80211_hw_config(local, changes); 1527 1528 return 0; 1529} 1530 1531static int ieee80211_get_tx_power(struct wiphy *wiphy, int *dbm) 1532{ 1533 struct ieee80211_local *local = wiphy_priv(wiphy); 1534 1535 *dbm = local->hw.conf.power_level; 1536 1537 return 0; 1538} 1539 1540static int ieee80211_set_wds_peer(struct wiphy *wiphy, struct net_device *dev, 1541 const u8 *addr) 1542{ 1543 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1544 1545 memcpy(&sdata->u.wds.remote_addr, addr, ETH_ALEN); 1546 1547 return 0; 1548} 1549 1550static void ieee80211_rfkill_poll(struct wiphy *wiphy) 1551{ 1552 struct ieee80211_local *local = wiphy_priv(wiphy); 1553 1554 drv_rfkill_poll(local); 1555} 1556 1557#ifdef CONFIG_NL80211_TESTMODE 1558static int ieee80211_testmode_cmd(struct wiphy *wiphy, void *data, int len) 1559{ 1560 struct ieee80211_local *local = wiphy_priv(wiphy); 1561 1562 if (!local->ops->testmode_cmd) 1563 return -EOPNOTSUPP; 1564 1565 return local->ops->testmode_cmd(&local->hw, data, len); 1566} 1567#endif 1568 1569int __ieee80211_request_smps(struct ieee80211_sub_if_data *sdata, 1570 enum ieee80211_smps_mode smps_mode) 1571{ 1572 const u8 *ap; 1573 enum ieee80211_smps_mode old_req; 1574 int err; 1575 1576 lockdep_assert_held(&sdata->u.mgd.mtx); 1577 1578 old_req = sdata->u.mgd.req_smps; 1579 sdata->u.mgd.req_smps = smps_mode; 1580 1581 if (old_req == smps_mode && 1582 smps_mode != IEEE80211_SMPS_AUTOMATIC) 1583 return 0; 1584 1585 /* 1586 * If not associated, or current association is not an HT 1587 * association, there's no need to send an action frame. 1588 */ 1589 if (!sdata->u.mgd.associated || 1590 sdata->vif.bss_conf.channel_type == NL80211_CHAN_NO_HT) { 1591 mutex_lock(&sdata->local->iflist_mtx); 1592 ieee80211_recalc_smps(sdata->local); 1593 mutex_unlock(&sdata->local->iflist_mtx); 1594 return 0; 1595 } 1596 1597 ap = sdata->u.mgd.associated->bssid; 1598 1599 if (smps_mode == IEEE80211_SMPS_AUTOMATIC) { 1600 if (sdata->u.mgd.powersave) 1601 smps_mode = IEEE80211_SMPS_DYNAMIC; 1602 else 1603 smps_mode = IEEE80211_SMPS_OFF; 1604 } 1605 1606 /* send SM PS frame to AP */ 1607 err = ieee80211_send_smps_action(sdata, smps_mode, 1608 ap, ap); 1609 if (err) 1610 sdata->u.mgd.req_smps = old_req; 1611 1612 return err; 1613} 1614 1615static int ieee80211_set_power_mgmt(struct wiphy *wiphy, struct net_device *dev, 1616 bool enabled, int timeout) 1617{ 1618 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1619 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 1620 1621 if (sdata->vif.type != NL80211_IFTYPE_STATION) 1622 return -EOPNOTSUPP; 1623 1624 if (!(local->hw.flags & IEEE80211_HW_SUPPORTS_PS)) 1625 return -EOPNOTSUPP; 1626 1627 if (enabled == sdata->u.mgd.powersave && 1628 timeout == local->dynamic_ps_forced_timeout) 1629 return 0; 1630 1631 sdata->u.mgd.powersave = enabled; 1632 local->dynamic_ps_forced_timeout = timeout; 1633 1634 /* no change, but if automatic follow powersave */ 1635 mutex_lock(&sdata->u.mgd.mtx); 1636 __ieee80211_request_smps(sdata, sdata->u.mgd.req_smps); 1637 mutex_unlock(&sdata->u.mgd.mtx); 1638 1639 if (local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_PS) 1640 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS); 1641 1642 ieee80211_recalc_ps(local, -1); 1643 1644 return 0; 1645} 1646 1647static int ieee80211_set_cqm_rssi_config(struct wiphy *wiphy, 1648 struct net_device *dev, 1649 s32 rssi_thold, u32 rssi_hyst) 1650{ 1651 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1652 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 1653 struct ieee80211_vif *vif = &sdata->vif; 1654 struct ieee80211_bss_conf *bss_conf = &vif->bss_conf; 1655 1656 if (rssi_thold == bss_conf->cqm_rssi_thold && 1657 rssi_hyst == bss_conf->cqm_rssi_hyst) 1658 return 0; 1659 1660 bss_conf->cqm_rssi_thold = rssi_thold; 1661 bss_conf->cqm_rssi_hyst = rssi_hyst; 1662 1663 if (!(local->hw.flags & IEEE80211_HW_SUPPORTS_CQM_RSSI)) { 1664 if (sdata->vif.type != NL80211_IFTYPE_STATION) 1665 return -EOPNOTSUPP; 1666 return 0; 1667 } 1668 1669 /* tell the driver upon association, unless already associated */ 1670 if (sdata->u.mgd.associated) 1671 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_CQM); 1672 1673 return 0; 1674} 1675 1676static int ieee80211_set_bitrate_mask(struct wiphy *wiphy, 1677 struct net_device *dev, 1678 const u8 *addr, 1679 const struct cfg80211_bitrate_mask *mask) 1680{ 1681 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1682 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 1683 int i, ret; 1684 1685 if (local->hw.flags & IEEE80211_HW_HAS_RATE_CONTROL) { 1686 ret = drv_set_bitrate_mask(local, sdata, mask); 1687 if (ret) 1688 return ret; 1689 } 1690 1691 for (i = 0; i < IEEE80211_NUM_BANDS; i++) 1692 sdata->rc_rateidx_mask[i] = mask->control[i].legacy; 1693 1694 return 0; 1695} 1696 1697static int ieee80211_remain_on_channel_hw(struct ieee80211_local *local, 1698 struct net_device *dev, 1699 struct ieee80211_channel *chan, 1700 enum nl80211_channel_type chantype, 1701 unsigned int duration, u64 *cookie) 1702{ 1703 int ret; 1704 u32 random_cookie; 1705 1706 lockdep_assert_held(&local->mtx); 1707 1708 if (local->hw_roc_cookie) 1709 return -EBUSY; 1710 /* must be nonzero */ 1711 random_cookie = random32() | 1; 1712 1713 *cookie = random_cookie; 1714 local->hw_roc_dev = dev; 1715 local->hw_roc_cookie = random_cookie; 1716 local->hw_roc_channel = chan; 1717 local->hw_roc_channel_type = chantype; 1718 local->hw_roc_duration = duration; 1719 ret = drv_remain_on_channel(local, chan, chantype, duration); 1720 if (ret) { 1721 local->hw_roc_channel = NULL; 1722 local->hw_roc_cookie = 0; 1723 } 1724 1725 return ret; 1726} 1727 1728static int ieee80211_remain_on_channel(struct wiphy *wiphy, 1729 struct net_device *dev, 1730 struct ieee80211_channel *chan, 1731 enum nl80211_channel_type channel_type, 1732 unsigned int duration, 1733 u64 *cookie) 1734{ 1735 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1736 struct ieee80211_local *local = sdata->local; 1737 1738 if (local->ops->remain_on_channel) { 1739 int ret; 1740 1741 mutex_lock(&local->mtx); 1742 ret = ieee80211_remain_on_channel_hw(local, dev, 1743 chan, channel_type, 1744 duration, cookie); 1745 local->hw_roc_for_tx = false; 1746 mutex_unlock(&local->mtx); 1747 1748 return ret; 1749 } 1750 1751 return ieee80211_wk_remain_on_channel(sdata, chan, channel_type, 1752 duration, cookie); 1753} 1754 1755static int ieee80211_cancel_remain_on_channel_hw(struct ieee80211_local *local, 1756 u64 cookie) 1757{ 1758 int ret; 1759 1760 lockdep_assert_held(&local->mtx); 1761 1762 if (local->hw_roc_cookie != cookie) 1763 return -ENOENT; 1764 1765 ret = drv_cancel_remain_on_channel(local); 1766 if (ret) 1767 return ret; 1768 1769 local->hw_roc_cookie = 0; 1770 local->hw_roc_channel = NULL; 1771 1772 ieee80211_recalc_idle(local); 1773 1774 return 0; 1775} 1776 1777static int ieee80211_cancel_remain_on_channel(struct wiphy *wiphy, 1778 struct net_device *dev, 1779 u64 cookie) 1780{ 1781 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1782 struct ieee80211_local *local = sdata->local; 1783 1784 if (local->ops->cancel_remain_on_channel) { 1785 int ret; 1786 1787 mutex_lock(&local->mtx); 1788 ret = ieee80211_cancel_remain_on_channel_hw(local, cookie); 1789 mutex_unlock(&local->mtx); 1790 1791 return ret; 1792 } 1793 1794 return ieee80211_wk_cancel_remain_on_channel(sdata, cookie); 1795} 1796 1797static enum work_done_result 1798ieee80211_offchan_tx_done(struct ieee80211_work *wk, struct sk_buff *skb) 1799{ 1800 /* 1801 * Use the data embedded in the work struct for reporting 1802 * here so if the driver mangled the SKB before dropping 1803 * it (which is the only way we really should get here) 1804 * then we don't report mangled data. 1805 * 1806 * If there was no wait time, then by the time we get here 1807 * the driver will likely not have reported the status yet, 1808 * so in that case userspace will have to deal with it. 1809 */ 1810 1811 if (wk->offchan_tx.wait && wk->offchan_tx.frame) 1812 cfg80211_mgmt_tx_status(wk->sdata->dev, 1813 (unsigned long) wk->offchan_tx.frame, 1814 wk->ie, wk->ie_len, false, GFP_KERNEL); 1815 1816 return WORK_DONE_DESTROY; 1817} 1818 1819static int ieee80211_mgmt_tx(struct wiphy *wiphy, struct net_device *dev, 1820 struct ieee80211_channel *chan, bool offchan, 1821 enum nl80211_channel_type channel_type, 1822 bool channel_type_valid, unsigned int wait, 1823 const u8 *buf, size_t len, u64 *cookie) 1824{ 1825 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1826 struct ieee80211_local *local = sdata->local; 1827 struct sk_buff *skb; 1828 struct sta_info *sta; 1829 struct ieee80211_work *wk; 1830 const struct ieee80211_mgmt *mgmt = (void *)buf; 1831 u32 flags = IEEE80211_TX_INTFL_NL80211_FRAME_TX | 1832 IEEE80211_TX_CTL_REQ_TX_STATUS; 1833 bool is_offchan = false; 1834 1835 /* Check that we are on the requested channel for transmission */ 1836 if (chan != local->tmp_channel && 1837 chan != local->oper_channel) 1838 is_offchan = true; 1839 if (channel_type_valid && 1840 (channel_type != local->tmp_channel_type && 1841 channel_type != local->_oper_channel_type)) 1842 is_offchan = true; 1843 1844 if (chan == local->hw_roc_channel) { 1845 /* TODO: check channel type? */ 1846 is_offchan = false; 1847 flags |= IEEE80211_TX_CTL_TX_OFFCHAN; 1848 } 1849 1850 if (is_offchan && !offchan) 1851 return -EBUSY; 1852 1853 switch (sdata->vif.type) { 1854 case NL80211_IFTYPE_ADHOC: 1855 case NL80211_IFTYPE_AP: 1856 case NL80211_IFTYPE_AP_VLAN: 1857 case NL80211_IFTYPE_P2P_GO: 1858 case NL80211_IFTYPE_MESH_POINT: 1859 if (!ieee80211_is_action(mgmt->frame_control) || 1860 mgmt->u.action.category == WLAN_CATEGORY_PUBLIC) 1861 break; 1862 rcu_read_lock(); 1863 sta = sta_info_get(sdata, mgmt->da); 1864 rcu_read_unlock(); 1865 if (!sta) 1866 return -ENOLINK; 1867 break; 1868 case NL80211_IFTYPE_STATION: 1869 case NL80211_IFTYPE_P2P_CLIENT: 1870 break; 1871 default: 1872 return -EOPNOTSUPP; 1873 } 1874 1875 skb = dev_alloc_skb(local->hw.extra_tx_headroom + len); 1876 if (!skb) 1877 return -ENOMEM; 1878 skb_reserve(skb, local->hw.extra_tx_headroom); 1879 1880 memcpy(skb_put(skb, len), buf, len); 1881 1882 IEEE80211_SKB_CB(skb)->flags = flags; 1883 1884 skb->dev = sdata->dev; 1885 1886 *cookie = (unsigned long) skb; 1887 1888 if (is_offchan && local->ops->offchannel_tx) { 1889 int ret; 1890 1891 IEEE80211_SKB_CB(skb)->band = chan->band; 1892 1893 mutex_lock(&local->mtx); 1894 1895 if (local->hw_offchan_tx_cookie) { 1896 mutex_unlock(&local->mtx); 1897 return -EBUSY; 1898 } 1899 1900 /* TODO: bitrate control, TX processing? */ 1901 ret = drv_offchannel_tx(local, skb, chan, channel_type, wait); 1902 1903 if (ret == 0) 1904 local->hw_offchan_tx_cookie = *cookie; 1905 mutex_unlock(&local->mtx); 1906 1907 /* 1908 * Allow driver to return 1 to indicate it wants to have the 1909 * frame transmitted with a remain_on_channel + regular TX. 1910 */ 1911 if (ret != 1) 1912 return ret; 1913 } 1914 1915 if (is_offchan && local->ops->remain_on_channel) { 1916 unsigned int duration; 1917 int ret; 1918 1919 mutex_lock(&local->mtx); 1920 /* 1921 * If the duration is zero, then the driver 1922 * wouldn't actually do anything. Set it to 1923 * 100 for now. 1924 * 1925 * TODO: cancel the off-channel operation 1926 * when we get the SKB's TX status and 1927 * the wait time was zero before. 1928 */ 1929 duration = 100; 1930 if (wait) 1931 duration = wait; 1932 ret = ieee80211_remain_on_channel_hw(local, dev, chan, 1933 channel_type, 1934 duration, cookie); 1935 if (ret) { 1936 kfree_skb(skb); 1937 mutex_unlock(&local->mtx); 1938 return ret; 1939 } 1940 1941 local->hw_roc_for_tx = true; 1942 local->hw_roc_duration = wait; 1943 1944 /* 1945 * queue up frame for transmission after 1946 * ieee80211_ready_on_channel call 1947 */ 1948 1949 /* modify cookie to prevent API mismatches */ 1950 *cookie ^= 2; 1951 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_CTL_TX_OFFCHAN; 1952 local->hw_roc_skb = skb; 1953 local->hw_roc_skb_for_status = skb; 1954 mutex_unlock(&local->mtx); 1955 1956 return 0; 1957 } 1958 1959 /* 1960 * Can transmit right away if the channel was the 1961 * right one and there's no wait involved... If a 1962 * wait is involved, we might otherwise not be on 1963 * the right channel for long enough! 1964 */ 1965 if (!is_offchan && !wait && !sdata->vif.bss_conf.idle) { 1966 ieee80211_tx_skb(sdata, skb); 1967 return 0; 1968 } 1969 1970 wk = kzalloc(sizeof(*wk) + len, GFP_KERNEL); 1971 if (!wk) { 1972 kfree_skb(skb); 1973 return -ENOMEM; 1974 } 1975 1976 wk->type = IEEE80211_WORK_OFFCHANNEL_TX; 1977 wk->chan = chan; 1978 wk->chan_type = channel_type; 1979 wk->sdata = sdata; 1980 wk->done = ieee80211_offchan_tx_done; 1981 wk->offchan_tx.frame = skb; 1982 wk->offchan_tx.wait = wait; 1983 wk->ie_len = len; 1984 memcpy(wk->ie, buf, len); 1985 1986 ieee80211_add_work(wk); 1987 return 0; 1988} 1989 1990static int ieee80211_mgmt_tx_cancel_wait(struct wiphy *wiphy, 1991 struct net_device *dev, 1992 u64 cookie) 1993{ 1994 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1995 struct ieee80211_local *local = sdata->local; 1996 struct ieee80211_work *wk; 1997 int ret = -ENOENT; 1998 1999 mutex_lock(&local->mtx); 2000 2001 if (local->ops->offchannel_tx_cancel_wait && 2002 local->hw_offchan_tx_cookie == cookie) { 2003 ret = drv_offchannel_tx_cancel_wait(local); 2004 2005 if (!ret) 2006 local->hw_offchan_tx_cookie = 0; 2007 2008 mutex_unlock(&local->mtx); 2009 2010 return ret; 2011 } 2012 2013 if (local->ops->cancel_remain_on_channel) { 2014 cookie ^= 2; 2015 ret = ieee80211_cancel_remain_on_channel_hw(local, cookie); 2016 2017 if (ret == 0) { 2018 kfree_skb(local->hw_roc_skb); 2019 local->hw_roc_skb = NULL; 2020 local->hw_roc_skb_for_status = NULL; 2021 } 2022 2023 mutex_unlock(&local->mtx); 2024 2025 return ret; 2026 } 2027 2028 list_for_each_entry(wk, &local->work_list, list) { 2029 if (wk->sdata != sdata) 2030 continue; 2031 2032 if (wk->type != IEEE80211_WORK_OFFCHANNEL_TX) 2033 continue; 2034 2035 if (cookie != (unsigned long) wk->offchan_tx.frame) 2036 continue; 2037 2038 wk->timeout = jiffies; 2039 2040 ieee80211_queue_work(&local->hw, &local->work_work); 2041 ret = 0; 2042 break; 2043 } 2044 mutex_unlock(&local->mtx); 2045 2046 return ret; 2047} 2048 2049static void ieee80211_mgmt_frame_register(struct wiphy *wiphy, 2050 struct net_device *dev, 2051 u16 frame_type, bool reg) 2052{ 2053 struct ieee80211_local *local = wiphy_priv(wiphy); 2054 2055 if (frame_type != (IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_PROBE_REQ)) 2056 return; 2057 2058 if (reg) 2059 local->probe_req_reg++; 2060 else 2061 local->probe_req_reg--; 2062 2063 ieee80211_queue_work(&local->hw, &local->reconfig_filter); 2064} 2065 2066static int ieee80211_set_antenna(struct wiphy *wiphy, u32 tx_ant, u32 rx_ant) 2067{ 2068 struct ieee80211_local *local = wiphy_priv(wiphy); 2069 2070 if (local->started) 2071 return -EOPNOTSUPP; 2072 2073 return drv_set_antenna(local, tx_ant, rx_ant); 2074} 2075 2076static int ieee80211_get_antenna(struct wiphy *wiphy, u32 *tx_ant, u32 *rx_ant) 2077{ 2078 struct ieee80211_local *local = wiphy_priv(wiphy); 2079 2080 return drv_get_antenna(local, tx_ant, rx_ant); 2081} 2082 2083static int ieee80211_set_ringparam(struct wiphy *wiphy, u32 tx, u32 rx) 2084{ 2085 struct ieee80211_local *local = wiphy_priv(wiphy); 2086 2087 return drv_set_ringparam(local, tx, rx); 2088} 2089 2090static void ieee80211_get_ringparam(struct wiphy *wiphy, 2091 u32 *tx, u32 *tx_max, u32 *rx, u32 *rx_max) 2092{ 2093 struct ieee80211_local *local = wiphy_priv(wiphy); 2094 2095 drv_get_ringparam(local, tx, tx_max, rx, rx_max); 2096} 2097 2098struct cfg80211_ops mac80211_config_ops = { 2099 .add_virtual_intf = ieee80211_add_iface, 2100 .del_virtual_intf = ieee80211_del_iface, 2101 .change_virtual_intf = ieee80211_change_iface, 2102 .add_key = ieee80211_add_key, 2103 .del_key = ieee80211_del_key, 2104 .get_key = ieee80211_get_key, 2105 .set_default_key = ieee80211_config_default_key, 2106 .set_default_mgmt_key = ieee80211_config_default_mgmt_key, 2107 .add_beacon = ieee80211_add_beacon, 2108 .set_beacon = ieee80211_set_beacon, 2109 .del_beacon = ieee80211_del_beacon, 2110 .add_station = ieee80211_add_station, 2111 .del_station = ieee80211_del_station, 2112 .change_station = ieee80211_change_station, 2113 .get_station = ieee80211_get_station, 2114 .dump_station = ieee80211_dump_station, 2115 .dump_survey = ieee80211_dump_survey, 2116#ifdef CONFIG_MAC80211_MESH 2117 .add_mpath = ieee80211_add_mpath, 2118 .del_mpath = ieee80211_del_mpath, 2119 .change_mpath = ieee80211_change_mpath, 2120 .get_mpath = ieee80211_get_mpath, 2121 .dump_mpath = ieee80211_dump_mpath, 2122 .update_mesh_config = ieee80211_update_mesh_config, 2123 .get_mesh_config = ieee80211_get_mesh_config, 2124 .join_mesh = ieee80211_join_mesh, 2125 .leave_mesh = ieee80211_leave_mesh, 2126#endif 2127 .change_bss = ieee80211_change_bss, 2128 .set_txq_params = ieee80211_set_txq_params, 2129 .set_channel = ieee80211_set_channel, 2130 .suspend = ieee80211_suspend, 2131 .resume = ieee80211_resume, 2132 .scan = ieee80211_scan, 2133 .sched_scan_start = ieee80211_sched_scan_start, 2134 .sched_scan_stop = ieee80211_sched_scan_stop, 2135 .auth = ieee80211_auth, 2136 .assoc = ieee80211_assoc, 2137 .deauth = ieee80211_deauth, 2138 .disassoc = ieee80211_disassoc, 2139 .join_ibss = ieee80211_join_ibss, 2140 .leave_ibss = ieee80211_leave_ibss, 2141 .set_wiphy_params = ieee80211_set_wiphy_params, 2142 .set_tx_power = ieee80211_set_tx_power, 2143 .get_tx_power = ieee80211_get_tx_power, 2144 .set_wds_peer = ieee80211_set_wds_peer, 2145 .rfkill_poll = ieee80211_rfkill_poll, 2146 CFG80211_TESTMODE_CMD(ieee80211_testmode_cmd) 2147 .set_power_mgmt = ieee80211_set_power_mgmt, 2148 .set_bitrate_mask = ieee80211_set_bitrate_mask, 2149 .remain_on_channel = ieee80211_remain_on_channel, 2150 .cancel_remain_on_channel = ieee80211_cancel_remain_on_channel, 2151 .mgmt_tx = ieee80211_mgmt_tx, 2152 .mgmt_tx_cancel_wait = ieee80211_mgmt_tx_cancel_wait, 2153 .set_cqm_rssi_config = ieee80211_set_cqm_rssi_config, 2154 .mgmt_frame_register = ieee80211_mgmt_frame_register, 2155 .set_antenna = ieee80211_set_antenna, 2156 .get_antenna = ieee80211_get_antenna, 2157 .set_ringparam = ieee80211_set_ringparam, 2158 .get_ringparam = ieee80211_get_ringparam, 2159}; 2160