1 /* 2 * mac80211 configuration hooks for cfg80211 3 * 4 * Copyright 2006, 2007 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 <net/net_namespace.h> 13 #include <linux/rcupdate.h> 14 #include <net/cfg80211.h> 15 #include "ieee80211_i.h" 16 #include "driver-ops.h" 17 #include "cfg.h" 18 #include "rate.h" 19 #include "mesh.h" 20 21 static bool nl80211_type_check(enum nl80211_iftype type) 22 { 23 switch (type) { 24 case NL80211_IFTYPE_ADHOC: 25 case NL80211_IFTYPE_STATION: 26 case NL80211_IFTYPE_MONITOR: 27 #ifdef CONFIG_MAC80211_MESH 28 case NL80211_IFTYPE_MESH_POINT: 29 #endif 30 case NL80211_IFTYPE_AP: 31 case NL80211_IFTYPE_AP_VLAN: 32 case NL80211_IFTYPE_WDS: 33 return true; 34 default: 35 return false; 36 } 37 } 38 39 static bool nl80211_params_check(enum nl80211_iftype type, 40 struct vif_params *params) 41 { 42 if (!nl80211_type_check(type)) 43 return false; 44 45 return true; 46 } 47 48 static int ieee80211_add_iface(struct wiphy *wiphy, char *name, 49 enum nl80211_iftype type, u32 *flags, 50 struct vif_params *params) 51 { 52 struct ieee80211_local *local = wiphy_priv(wiphy); 53 struct net_device *dev; 54 struct ieee80211_sub_if_data *sdata; 55 int err; 56 57 if (!nl80211_params_check(type, params)) 58 return -EINVAL; 59 60 err = ieee80211_if_add(local, name, &dev, type, params); 61 if (err || type != NL80211_IFTYPE_MONITOR || !flags) 62 return err; 63 64 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 65 sdata->u.mntr_flags = *flags; 66 return 0; 67 } 68 69 static int ieee80211_del_iface(struct wiphy *wiphy, struct net_device *dev) 70 { 71 ieee80211_if_remove(IEEE80211_DEV_TO_SUB_IF(dev)); 72 73 return 0; 74 } 75 76 static int ieee80211_change_iface(struct wiphy *wiphy, 77 struct net_device *dev, 78 enum nl80211_iftype type, u32 *flags, 79 struct vif_params *params) 80 { 81 struct ieee80211_sub_if_data *sdata; 82 int ret; 83 84 if (netif_running(dev)) 85 return -EBUSY; 86 87 if (!nl80211_params_check(type, params)) 88 return -EINVAL; 89 90 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 91 92 ret = ieee80211_if_change_type(sdata, type); 93 if (ret) 94 return ret; 95 96 if (ieee80211_vif_is_mesh(&sdata->vif) && params->mesh_id_len) 97 ieee80211_sdata_set_mesh_id(sdata, 98 params->mesh_id_len, 99 params->mesh_id); 100 101 if (sdata->vif.type != NL80211_IFTYPE_MONITOR || !flags) 102 return 0; 103 104 if (type == NL80211_IFTYPE_AP_VLAN && 105 params && params->use_4addr == 0) 106 rcu_assign_pointer(sdata->u.vlan.sta, NULL); 107 else if (type == NL80211_IFTYPE_STATION && 108 params && params->use_4addr >= 0) 109 sdata->u.mgd.use_4addr = params->use_4addr; 110 111 sdata->u.mntr_flags = *flags; 112 return 0; 113 } 114 115 static int ieee80211_add_key(struct wiphy *wiphy, struct net_device *dev, 116 u8 key_idx, const u8 *mac_addr, 117 struct key_params *params) 118 { 119 struct ieee80211_sub_if_data *sdata; 120 struct sta_info *sta = NULL; 121 enum ieee80211_key_alg alg; 122 struct ieee80211_key *key; 123 int err; 124 125 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 126 127 switch (params->cipher) { 128 case WLAN_CIPHER_SUITE_WEP40: 129 case WLAN_CIPHER_SUITE_WEP104: 130 alg = ALG_WEP; 131 break; 132 case WLAN_CIPHER_SUITE_TKIP: 133 alg = ALG_TKIP; 134 break; 135 case WLAN_CIPHER_SUITE_CCMP: 136 alg = ALG_CCMP; 137 break; 138 case WLAN_CIPHER_SUITE_AES_CMAC: 139 alg = ALG_AES_CMAC; 140 break; 141 default: 142 return -EINVAL; 143 } 144 145 key = ieee80211_key_alloc(alg, key_idx, params->key_len, params->key, 146 params->seq_len, params->seq); 147 if (!key) 148 return -ENOMEM; 149 150 rcu_read_lock(); 151 152 if (mac_addr) { 153 sta = sta_info_get(sdata->local, mac_addr); 154 if (!sta) { 155 ieee80211_key_free(key); 156 err = -ENOENT; 157 goto out_unlock; 158 } 159 } 160 161 ieee80211_key_link(key, sdata, sta); 162 163 err = 0; 164 out_unlock: 165 rcu_read_unlock(); 166 167 return err; 168 } 169 170 static int ieee80211_del_key(struct wiphy *wiphy, struct net_device *dev, 171 u8 key_idx, const u8 *mac_addr) 172 { 173 struct ieee80211_sub_if_data *sdata; 174 struct sta_info *sta; 175 int ret; 176 177 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 178 179 rcu_read_lock(); 180 181 if (mac_addr) { 182 ret = -ENOENT; 183 184 sta = sta_info_get(sdata->local, mac_addr); 185 if (!sta) 186 goto out_unlock; 187 188 if (sta->key) { 189 ieee80211_key_free(sta->key); 190 WARN_ON(sta->key); 191 ret = 0; 192 } 193 194 goto out_unlock; 195 } 196 197 if (!sdata->keys[key_idx]) { 198 ret = -ENOENT; 199 goto out_unlock; 200 } 201 202 ieee80211_key_free(sdata->keys[key_idx]); 203 WARN_ON(sdata->keys[key_idx]); 204 205 ret = 0; 206 out_unlock: 207 rcu_read_unlock(); 208 209 return ret; 210 } 211 212 static int ieee80211_get_key(struct wiphy *wiphy, struct net_device *dev, 213 u8 key_idx, const u8 *mac_addr, void *cookie, 214 void (*callback)(void *cookie, 215 struct key_params *params)) 216 { 217 struct ieee80211_sub_if_data *sdata; 218 struct sta_info *sta = NULL; 219 u8 seq[6] = {0}; 220 struct key_params params; 221 struct ieee80211_key *key; 222 u32 iv32; 223 u16 iv16; 224 int err = -ENOENT; 225 226 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 227 228 rcu_read_lock(); 229 230 if (mac_addr) { 231 sta = sta_info_get(sdata->local, mac_addr); 232 if (!sta) 233 goto out; 234 235 key = sta->key; 236 } else 237 key = sdata->keys[key_idx]; 238 239 if (!key) 240 goto out; 241 242 memset(¶ms, 0, sizeof(params)); 243 244 switch (key->conf.alg) { 245 case ALG_TKIP: 246 params.cipher = WLAN_CIPHER_SUITE_TKIP; 247 248 iv32 = key->u.tkip.tx.iv32; 249 iv16 = key->u.tkip.tx.iv16; 250 251 if (key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE) 252 drv_get_tkip_seq(sdata->local, 253 key->conf.hw_key_idx, 254 &iv32, &iv16); 255 256 seq[0] = iv16 & 0xff; 257 seq[1] = (iv16 >> 8) & 0xff; 258 seq[2] = iv32 & 0xff; 259 seq[3] = (iv32 >> 8) & 0xff; 260 seq[4] = (iv32 >> 16) & 0xff; 261 seq[5] = (iv32 >> 24) & 0xff; 262 params.seq = seq; 263 params.seq_len = 6; 264 break; 265 case ALG_CCMP: 266 params.cipher = 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 ALG_WEP: 277 if (key->conf.keylen == 5) 278 params.cipher = WLAN_CIPHER_SUITE_WEP40; 279 else 280 params.cipher = WLAN_CIPHER_SUITE_WEP104; 281 break; 282 case ALG_AES_CMAC: 283 params.cipher = WLAN_CIPHER_SUITE_AES_CMAC; 284 seq[0] = key->u.aes_cmac.tx_pn[5]; 285 seq[1] = key->u.aes_cmac.tx_pn[4]; 286 seq[2] = key->u.aes_cmac.tx_pn[3]; 287 seq[3] = key->u.aes_cmac.tx_pn[2]; 288 seq[4] = key->u.aes_cmac.tx_pn[1]; 289 seq[5] = key->u.aes_cmac.tx_pn[0]; 290 params.seq = seq; 291 params.seq_len = 6; 292 break; 293 } 294 295 params.key = key->conf.key; 296 params.key_len = key->conf.keylen; 297 298 callback(cookie, ¶ms); 299 err = 0; 300 301 out: 302 rcu_read_unlock(); 303 return err; 304 } 305 306 static int ieee80211_config_default_key(struct wiphy *wiphy, 307 struct net_device *dev, 308 u8 key_idx) 309 { 310 struct ieee80211_sub_if_data *sdata; 311 312 rcu_read_lock(); 313 314 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 315 ieee80211_set_default_key(sdata, key_idx); 316 317 rcu_read_unlock(); 318 319 return 0; 320 } 321 322 static int ieee80211_config_default_mgmt_key(struct wiphy *wiphy, 323 struct net_device *dev, 324 u8 key_idx) 325 { 326 struct ieee80211_sub_if_data *sdata; 327 328 rcu_read_lock(); 329 330 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 331 ieee80211_set_default_mgmt_key(sdata, key_idx); 332 333 rcu_read_unlock(); 334 335 return 0; 336 } 337 338 static void sta_set_sinfo(struct sta_info *sta, struct station_info *sinfo) 339 { 340 struct ieee80211_sub_if_data *sdata = sta->sdata; 341 342 sinfo->generation = sdata->local->sta_generation; 343 344 sinfo->filled = STATION_INFO_INACTIVE_TIME | 345 STATION_INFO_RX_BYTES | 346 STATION_INFO_TX_BYTES | 347 STATION_INFO_RX_PACKETS | 348 STATION_INFO_TX_PACKETS | 349 STATION_INFO_TX_BITRATE; 350 351 sinfo->inactive_time = jiffies_to_msecs(jiffies - sta->last_rx); 352 sinfo->rx_bytes = sta->rx_bytes; 353 sinfo->tx_bytes = sta->tx_bytes; 354 sinfo->rx_packets = sta->rx_packets; 355 sinfo->tx_packets = sta->tx_packets; 356 357 if ((sta->local->hw.flags & IEEE80211_HW_SIGNAL_DBM) || 358 (sta->local->hw.flags & IEEE80211_HW_SIGNAL_UNSPEC)) { 359 sinfo->filled |= STATION_INFO_SIGNAL; 360 sinfo->signal = (s8)sta->last_signal; 361 } 362 363 sinfo->txrate.flags = 0; 364 if (sta->last_tx_rate.flags & IEEE80211_TX_RC_MCS) 365 sinfo->txrate.flags |= RATE_INFO_FLAGS_MCS; 366 if (sta->last_tx_rate.flags & IEEE80211_TX_RC_40_MHZ_WIDTH) 367 sinfo->txrate.flags |= RATE_INFO_FLAGS_40_MHZ_WIDTH; 368 if (sta->last_tx_rate.flags & IEEE80211_TX_RC_SHORT_GI) 369 sinfo->txrate.flags |= RATE_INFO_FLAGS_SHORT_GI; 370 371 if (!(sta->last_tx_rate.flags & IEEE80211_TX_RC_MCS)) { 372 struct ieee80211_supported_band *sband; 373 sband = sta->local->hw.wiphy->bands[ 374 sta->local->hw.conf.channel->band]; 375 sinfo->txrate.legacy = 376 sband->bitrates[sta->last_tx_rate.idx].bitrate; 377 } else 378 sinfo->txrate.mcs = sta->last_tx_rate.idx; 379 380 if (ieee80211_vif_is_mesh(&sdata->vif)) { 381 #ifdef CONFIG_MAC80211_MESH 382 sinfo->filled |= STATION_INFO_LLID | 383 STATION_INFO_PLID | 384 STATION_INFO_PLINK_STATE; 385 386 sinfo->llid = le16_to_cpu(sta->llid); 387 sinfo->plid = le16_to_cpu(sta->plid); 388 sinfo->plink_state = sta->plink_state; 389 #endif 390 } 391 } 392 393 394 static int ieee80211_dump_station(struct wiphy *wiphy, struct net_device *dev, 395 int idx, u8 *mac, struct station_info *sinfo) 396 { 397 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 398 struct sta_info *sta; 399 int ret = -ENOENT; 400 401 rcu_read_lock(); 402 403 sta = sta_info_get_by_idx(sdata, idx); 404 if (sta) { 405 ret = 0; 406 memcpy(mac, sta->sta.addr, ETH_ALEN); 407 sta_set_sinfo(sta, sinfo); 408 } 409 410 rcu_read_unlock(); 411 412 return ret; 413 } 414 415 static int ieee80211_get_station(struct wiphy *wiphy, struct net_device *dev, 416 u8 *mac, struct station_info *sinfo) 417 { 418 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 419 struct sta_info *sta; 420 int ret = -ENOENT; 421 422 rcu_read_lock(); 423 424 /* XXX: verify sta->dev == dev */ 425 426 sta = sta_info_get(local, mac); 427 if (sta) { 428 ret = 0; 429 sta_set_sinfo(sta, sinfo); 430 } 431 432 rcu_read_unlock(); 433 434 return ret; 435 } 436 437 /* 438 * This handles both adding a beacon and setting new beacon info 439 */ 440 static int ieee80211_config_beacon(struct ieee80211_sub_if_data *sdata, 441 struct beacon_parameters *params) 442 { 443 struct beacon_data *new, *old; 444 int new_head_len, new_tail_len; 445 int size; 446 int err = -EINVAL; 447 448 old = sdata->u.ap.beacon; 449 450 /* head must not be zero-length */ 451 if (params->head && !params->head_len) 452 return -EINVAL; 453 454 /* 455 * This is a kludge. beacon interval should really be part 456 * of the beacon information. 457 */ 458 if (params->interval && 459 (sdata->vif.bss_conf.beacon_int != params->interval)) { 460 sdata->vif.bss_conf.beacon_int = params->interval; 461 ieee80211_bss_info_change_notify(sdata, 462 BSS_CHANGED_BEACON_INT); 463 } 464 465 /* Need to have a beacon head if we don't have one yet */ 466 if (!params->head && !old) 467 return err; 468 469 /* sorry, no way to start beaconing without dtim period */ 470 if (!params->dtim_period && !old) 471 return err; 472 473 /* new or old head? */ 474 if (params->head) 475 new_head_len = params->head_len; 476 else 477 new_head_len = old->head_len; 478 479 /* new or old tail? */ 480 if (params->tail || !old) 481 /* params->tail_len will be zero for !params->tail */ 482 new_tail_len = params->tail_len; 483 else 484 new_tail_len = old->tail_len; 485 486 size = sizeof(*new) + new_head_len + new_tail_len; 487 488 new = kzalloc(size, GFP_KERNEL); 489 if (!new) 490 return -ENOMEM; 491 492 /* start filling the new info now */ 493 494 /* new or old dtim period? */ 495 if (params->dtim_period) 496 new->dtim_period = params->dtim_period; 497 else 498 new->dtim_period = old->dtim_period; 499 500 /* 501 * pointers go into the block we allocated, 502 * memory is | beacon_data | head | tail | 503 */ 504 new->head = ((u8 *) new) + sizeof(*new); 505 new->tail = new->head + new_head_len; 506 new->head_len = new_head_len; 507 new->tail_len = new_tail_len; 508 509 /* copy in head */ 510 if (params->head) 511 memcpy(new->head, params->head, new_head_len); 512 else 513 memcpy(new->head, old->head, new_head_len); 514 515 /* copy in optional tail */ 516 if (params->tail) 517 memcpy(new->tail, params->tail, new_tail_len); 518 else 519 if (old) 520 memcpy(new->tail, old->tail, new_tail_len); 521 522 rcu_assign_pointer(sdata->u.ap.beacon, new); 523 524 synchronize_rcu(); 525 526 kfree(old); 527 528 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON_ENABLED | 529 BSS_CHANGED_BEACON); 530 return 0; 531 } 532 533 static int ieee80211_add_beacon(struct wiphy *wiphy, struct net_device *dev, 534 struct beacon_parameters *params) 535 { 536 struct ieee80211_sub_if_data *sdata; 537 struct beacon_data *old; 538 539 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 540 541 old = sdata->u.ap.beacon; 542 543 if (old) 544 return -EALREADY; 545 546 return ieee80211_config_beacon(sdata, params); 547 } 548 549 static int ieee80211_set_beacon(struct wiphy *wiphy, struct net_device *dev, 550 struct beacon_parameters *params) 551 { 552 struct ieee80211_sub_if_data *sdata; 553 struct beacon_data *old; 554 555 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 556 557 old = sdata->u.ap.beacon; 558 559 if (!old) 560 return -ENOENT; 561 562 return ieee80211_config_beacon(sdata, params); 563 } 564 565 static int ieee80211_del_beacon(struct wiphy *wiphy, struct net_device *dev) 566 { 567 struct ieee80211_sub_if_data *sdata; 568 struct beacon_data *old; 569 570 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 571 572 old = sdata->u.ap.beacon; 573 574 if (!old) 575 return -ENOENT; 576 577 rcu_assign_pointer(sdata->u.ap.beacon, NULL); 578 synchronize_rcu(); 579 kfree(old); 580 581 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON_ENABLED); 582 return 0; 583 } 584 585 /* Layer 2 Update frame (802.2 Type 1 LLC XID Update response) */ 586 struct iapp_layer2_update { 587 u8 da[ETH_ALEN]; /* broadcast */ 588 u8 sa[ETH_ALEN]; /* STA addr */ 589 __be16 len; /* 6 */ 590 u8 dsap; /* 0 */ 591 u8 ssap; /* 0 */ 592 u8 control; 593 u8 xid_info[3]; 594 } __attribute__ ((packed)); 595 596 static void ieee80211_send_layer2_update(struct sta_info *sta) 597 { 598 struct iapp_layer2_update *msg; 599 struct sk_buff *skb; 600 601 /* Send Level 2 Update Frame to update forwarding tables in layer 2 602 * bridge devices */ 603 604 skb = dev_alloc_skb(sizeof(*msg)); 605 if (!skb) 606 return; 607 msg = (struct iapp_layer2_update *)skb_put(skb, sizeof(*msg)); 608 609 /* 802.2 Type 1 Logical Link Control (LLC) Exchange Identifier (XID) 610 * Update response frame; IEEE Std 802.2-1998, 5.4.1.2.1 */ 611 612 memset(msg->da, 0xff, ETH_ALEN); 613 memcpy(msg->sa, sta->sta.addr, ETH_ALEN); 614 msg->len = htons(6); 615 msg->dsap = 0; 616 msg->ssap = 0x01; /* NULL LSAP, CR Bit: Response */ 617 msg->control = 0xaf; /* XID response lsb.1111F101. 618 * F=0 (no poll command; unsolicited frame) */ 619 msg->xid_info[0] = 0x81; /* XID format identifier */ 620 msg->xid_info[1] = 1; /* LLC types/classes: Type 1 LLC */ 621 msg->xid_info[2] = 0; /* XID sender's receive window size (RW) */ 622 623 skb->dev = sta->sdata->dev; 624 skb->protocol = eth_type_trans(skb, sta->sdata->dev); 625 memset(skb->cb, 0, sizeof(skb->cb)); 626 netif_rx(skb); 627 } 628 629 static void sta_apply_parameters(struct ieee80211_local *local, 630 struct sta_info *sta, 631 struct station_parameters *params) 632 { 633 u32 rates; 634 int i, j; 635 struct ieee80211_supported_band *sband; 636 struct ieee80211_sub_if_data *sdata = sta->sdata; 637 u32 mask, set; 638 639 sband = local->hw.wiphy->bands[local->oper_channel->band]; 640 641 spin_lock_bh(&sta->lock); 642 mask = params->sta_flags_mask; 643 set = params->sta_flags_set; 644 645 if (mask & BIT(NL80211_STA_FLAG_AUTHORIZED)) { 646 sta->flags &= ~WLAN_STA_AUTHORIZED; 647 if (set & BIT(NL80211_STA_FLAG_AUTHORIZED)) 648 sta->flags |= WLAN_STA_AUTHORIZED; 649 } 650 651 if (mask & BIT(NL80211_STA_FLAG_SHORT_PREAMBLE)) { 652 sta->flags &= ~WLAN_STA_SHORT_PREAMBLE; 653 if (set & BIT(NL80211_STA_FLAG_SHORT_PREAMBLE)) 654 sta->flags |= WLAN_STA_SHORT_PREAMBLE; 655 } 656 657 if (mask & BIT(NL80211_STA_FLAG_WME)) { 658 sta->flags &= ~WLAN_STA_WME; 659 if (set & BIT(NL80211_STA_FLAG_WME)) 660 sta->flags |= WLAN_STA_WME; 661 } 662 663 if (mask & BIT(NL80211_STA_FLAG_MFP)) { 664 sta->flags &= ~WLAN_STA_MFP; 665 if (set & BIT(NL80211_STA_FLAG_MFP)) 666 sta->flags |= WLAN_STA_MFP; 667 } 668 spin_unlock_bh(&sta->lock); 669 670 /* 671 * cfg80211 validates this (1-2007) and allows setting the AID 672 * only when creating a new station entry 673 */ 674 if (params->aid) 675 sta->sta.aid = params->aid; 676 677 /* 678 * FIXME: updating the following information is racy when this 679 * function is called from ieee80211_change_station(). 680 * However, all this information should be static so 681 * maybe we should just reject attemps to change it. 682 */ 683 684 if (params->listen_interval >= 0) 685 sta->listen_interval = params->listen_interval; 686 687 if (params->supported_rates) { 688 rates = 0; 689 690 for (i = 0; i < params->supported_rates_len; i++) { 691 int rate = (params->supported_rates[i] & 0x7f) * 5; 692 for (j = 0; j < sband->n_bitrates; j++) { 693 if (sband->bitrates[j].bitrate == rate) 694 rates |= BIT(j); 695 } 696 } 697 sta->sta.supp_rates[local->oper_channel->band] = rates; 698 } 699 700 if (params->ht_capa) 701 ieee80211_ht_cap_ie_to_sta_ht_cap(sband, 702 params->ht_capa, 703 &sta->sta.ht_cap); 704 705 if (ieee80211_vif_is_mesh(&sdata->vif) && params->plink_action) { 706 switch (params->plink_action) { 707 case PLINK_ACTION_OPEN: 708 mesh_plink_open(sta); 709 break; 710 case PLINK_ACTION_BLOCK: 711 mesh_plink_block(sta); 712 break; 713 } 714 } 715 } 716 717 static int ieee80211_add_station(struct wiphy *wiphy, struct net_device *dev, 718 u8 *mac, struct station_parameters *params) 719 { 720 struct ieee80211_local *local = wiphy_priv(wiphy); 721 struct sta_info *sta; 722 struct ieee80211_sub_if_data *sdata; 723 int err; 724 int layer2_update; 725 726 if (params->vlan) { 727 sdata = IEEE80211_DEV_TO_SUB_IF(params->vlan); 728 729 if (sdata->vif.type != NL80211_IFTYPE_AP_VLAN && 730 sdata->vif.type != NL80211_IFTYPE_AP) 731 return -EINVAL; 732 } else 733 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 734 735 if (compare_ether_addr(mac, dev->dev_addr) == 0) 736 return -EINVAL; 737 738 if (is_multicast_ether_addr(mac)) 739 return -EINVAL; 740 741 sta = sta_info_alloc(sdata, mac, GFP_KERNEL); 742 if (!sta) 743 return -ENOMEM; 744 745 sta->flags = WLAN_STA_AUTH | WLAN_STA_ASSOC; 746 747 sta_apply_parameters(local, sta, params); 748 749 rate_control_rate_init(sta); 750 751 layer2_update = sdata->vif.type == NL80211_IFTYPE_AP_VLAN || 752 sdata->vif.type == NL80211_IFTYPE_AP; 753 754 rcu_read_lock(); 755 756 err = sta_info_insert(sta); 757 if (err) { 758 rcu_read_unlock(); 759 return err; 760 } 761 762 if (layer2_update) 763 ieee80211_send_layer2_update(sta); 764 765 rcu_read_unlock(); 766 767 return 0; 768 } 769 770 static int ieee80211_del_station(struct wiphy *wiphy, struct net_device *dev, 771 u8 *mac) 772 { 773 struct ieee80211_local *local = wiphy_priv(wiphy); 774 struct ieee80211_sub_if_data *sdata; 775 struct sta_info *sta; 776 777 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 778 779 if (mac) { 780 rcu_read_lock(); 781 782 /* XXX: get sta belonging to dev */ 783 sta = sta_info_get(local, mac); 784 if (!sta) { 785 rcu_read_unlock(); 786 return -ENOENT; 787 } 788 789 sta_info_unlink(&sta); 790 rcu_read_unlock(); 791 792 sta_info_destroy(sta); 793 } else 794 sta_info_flush(local, sdata); 795 796 return 0; 797 } 798 799 static int ieee80211_change_station(struct wiphy *wiphy, 800 struct net_device *dev, 801 u8 *mac, 802 struct station_parameters *params) 803 { 804 struct ieee80211_local *local = wiphy_priv(wiphy); 805 struct sta_info *sta; 806 struct ieee80211_sub_if_data *vlansdata; 807 808 rcu_read_lock(); 809 810 /* XXX: get sta belonging to dev */ 811 sta = sta_info_get(local, mac); 812 if (!sta) { 813 rcu_read_unlock(); 814 return -ENOENT; 815 } 816 817 if (params->vlan && params->vlan != sta->sdata->dev) { 818 vlansdata = IEEE80211_DEV_TO_SUB_IF(params->vlan); 819 820 if (vlansdata->vif.type != NL80211_IFTYPE_AP_VLAN && 821 vlansdata->vif.type != NL80211_IFTYPE_AP) { 822 rcu_read_unlock(); 823 return -EINVAL; 824 } 825 826 if (params->vlan->ieee80211_ptr->use_4addr) { 827 if (vlansdata->u.vlan.sta) { 828 rcu_read_unlock(); 829 return -EBUSY; 830 } 831 832 rcu_assign_pointer(vlansdata->u.vlan.sta, sta); 833 } 834 835 sta->sdata = vlansdata; 836 ieee80211_send_layer2_update(sta); 837 } 838 839 sta_apply_parameters(local, sta, params); 840 841 rcu_read_unlock(); 842 843 return 0; 844 } 845 846 #ifdef CONFIG_MAC80211_MESH 847 static int ieee80211_add_mpath(struct wiphy *wiphy, struct net_device *dev, 848 u8 *dst, u8 *next_hop) 849 { 850 struct ieee80211_local *local = wiphy_priv(wiphy); 851 struct ieee80211_sub_if_data *sdata; 852 struct mesh_path *mpath; 853 struct sta_info *sta; 854 int err; 855 856 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 857 858 rcu_read_lock(); 859 sta = sta_info_get(local, next_hop); 860 if (!sta) { 861 rcu_read_unlock(); 862 return -ENOENT; 863 } 864 865 err = mesh_path_add(dst, sdata); 866 if (err) { 867 rcu_read_unlock(); 868 return err; 869 } 870 871 mpath = mesh_path_lookup(dst, sdata); 872 if (!mpath) { 873 rcu_read_unlock(); 874 return -ENXIO; 875 } 876 mesh_path_fix_nexthop(mpath, sta); 877 878 rcu_read_unlock(); 879 return 0; 880 } 881 882 static int ieee80211_del_mpath(struct wiphy *wiphy, struct net_device *dev, 883 u8 *dst) 884 { 885 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 886 887 if (dst) 888 return mesh_path_del(dst, sdata); 889 890 mesh_path_flush(sdata); 891 return 0; 892 } 893 894 static int ieee80211_change_mpath(struct wiphy *wiphy, 895 struct net_device *dev, 896 u8 *dst, u8 *next_hop) 897 { 898 struct ieee80211_local *local = wiphy_priv(wiphy); 899 struct ieee80211_sub_if_data *sdata; 900 struct mesh_path *mpath; 901 struct sta_info *sta; 902 903 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 904 905 rcu_read_lock(); 906 907 sta = sta_info_get(local, next_hop); 908 if (!sta) { 909 rcu_read_unlock(); 910 return -ENOENT; 911 } 912 913 mpath = mesh_path_lookup(dst, sdata); 914 if (!mpath) { 915 rcu_read_unlock(); 916 return -ENOENT; 917 } 918 919 mesh_path_fix_nexthop(mpath, sta); 920 921 rcu_read_unlock(); 922 return 0; 923 } 924 925 static void mpath_set_pinfo(struct mesh_path *mpath, u8 *next_hop, 926 struct mpath_info *pinfo) 927 { 928 if (mpath->next_hop) 929 memcpy(next_hop, mpath->next_hop->sta.addr, ETH_ALEN); 930 else 931 memset(next_hop, 0, ETH_ALEN); 932 933 pinfo->generation = mesh_paths_generation; 934 935 pinfo->filled = MPATH_INFO_FRAME_QLEN | 936 MPATH_INFO_SN | 937 MPATH_INFO_METRIC | 938 MPATH_INFO_EXPTIME | 939 MPATH_INFO_DISCOVERY_TIMEOUT | 940 MPATH_INFO_DISCOVERY_RETRIES | 941 MPATH_INFO_FLAGS; 942 943 pinfo->frame_qlen = mpath->frame_queue.qlen; 944 pinfo->sn = mpath->sn; 945 pinfo->metric = mpath->metric; 946 if (time_before(jiffies, mpath->exp_time)) 947 pinfo->exptime = jiffies_to_msecs(mpath->exp_time - jiffies); 948 pinfo->discovery_timeout = 949 jiffies_to_msecs(mpath->discovery_timeout); 950 pinfo->discovery_retries = mpath->discovery_retries; 951 pinfo->flags = 0; 952 if (mpath->flags & MESH_PATH_ACTIVE) 953 pinfo->flags |= NL80211_MPATH_FLAG_ACTIVE; 954 if (mpath->flags & MESH_PATH_RESOLVING) 955 pinfo->flags |= NL80211_MPATH_FLAG_RESOLVING; 956 if (mpath->flags & MESH_PATH_SN_VALID) 957 pinfo->flags |= NL80211_MPATH_FLAG_SN_VALID; 958 if (mpath->flags & MESH_PATH_FIXED) 959 pinfo->flags |= NL80211_MPATH_FLAG_FIXED; 960 if (mpath->flags & MESH_PATH_RESOLVING) 961 pinfo->flags |= NL80211_MPATH_FLAG_RESOLVING; 962 963 pinfo->flags = mpath->flags; 964 } 965 966 static int ieee80211_get_mpath(struct wiphy *wiphy, struct net_device *dev, 967 u8 *dst, u8 *next_hop, struct mpath_info *pinfo) 968 969 { 970 struct ieee80211_sub_if_data *sdata; 971 struct mesh_path *mpath; 972 973 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 974 975 rcu_read_lock(); 976 mpath = mesh_path_lookup(dst, sdata); 977 if (!mpath) { 978 rcu_read_unlock(); 979 return -ENOENT; 980 } 981 memcpy(dst, mpath->dst, ETH_ALEN); 982 mpath_set_pinfo(mpath, next_hop, pinfo); 983 rcu_read_unlock(); 984 return 0; 985 } 986 987 static int ieee80211_dump_mpath(struct wiphy *wiphy, struct net_device *dev, 988 int idx, u8 *dst, u8 *next_hop, 989 struct mpath_info *pinfo) 990 { 991 struct ieee80211_sub_if_data *sdata; 992 struct mesh_path *mpath; 993 994 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 995 996 rcu_read_lock(); 997 mpath = mesh_path_lookup_by_idx(idx, sdata); 998 if (!mpath) { 999 rcu_read_unlock(); 1000 return -ENOENT; 1001 } 1002 memcpy(dst, mpath->dst, ETH_ALEN); 1003 mpath_set_pinfo(mpath, next_hop, pinfo); 1004 rcu_read_unlock(); 1005 return 0; 1006 } 1007 1008 static int ieee80211_get_mesh_params(struct wiphy *wiphy, 1009 struct net_device *dev, 1010 struct mesh_config *conf) 1011 { 1012 struct ieee80211_sub_if_data *sdata; 1013 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1014 1015 memcpy(conf, &(sdata->u.mesh.mshcfg), sizeof(struct mesh_config)); 1016 return 0; 1017 } 1018 1019 static inline bool _chg_mesh_attr(enum nl80211_meshconf_params parm, u32 mask) 1020 { 1021 return (mask >> (parm-1)) & 0x1; 1022 } 1023 1024 static int ieee80211_set_mesh_params(struct wiphy *wiphy, 1025 struct net_device *dev, 1026 const struct mesh_config *nconf, u32 mask) 1027 { 1028 struct mesh_config *conf; 1029 struct ieee80211_sub_if_data *sdata; 1030 struct ieee80211_if_mesh *ifmsh; 1031 1032 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1033 ifmsh = &sdata->u.mesh; 1034 1035 /* Set the config options which we are interested in setting */ 1036 conf = &(sdata->u.mesh.mshcfg); 1037 if (_chg_mesh_attr(NL80211_MESHCONF_RETRY_TIMEOUT, mask)) 1038 conf->dot11MeshRetryTimeout = nconf->dot11MeshRetryTimeout; 1039 if (_chg_mesh_attr(NL80211_MESHCONF_CONFIRM_TIMEOUT, mask)) 1040 conf->dot11MeshConfirmTimeout = nconf->dot11MeshConfirmTimeout; 1041 if (_chg_mesh_attr(NL80211_MESHCONF_HOLDING_TIMEOUT, mask)) 1042 conf->dot11MeshHoldingTimeout = nconf->dot11MeshHoldingTimeout; 1043 if (_chg_mesh_attr(NL80211_MESHCONF_MAX_PEER_LINKS, mask)) 1044 conf->dot11MeshMaxPeerLinks = nconf->dot11MeshMaxPeerLinks; 1045 if (_chg_mesh_attr(NL80211_MESHCONF_MAX_RETRIES, mask)) 1046 conf->dot11MeshMaxRetries = nconf->dot11MeshMaxRetries; 1047 if (_chg_mesh_attr(NL80211_MESHCONF_TTL, mask)) 1048 conf->dot11MeshTTL = nconf->dot11MeshTTL; 1049 if (_chg_mesh_attr(NL80211_MESHCONF_AUTO_OPEN_PLINKS, mask)) 1050 conf->auto_open_plinks = nconf->auto_open_plinks; 1051 if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES, mask)) 1052 conf->dot11MeshHWMPmaxPREQretries = 1053 nconf->dot11MeshHWMPmaxPREQretries; 1054 if (_chg_mesh_attr(NL80211_MESHCONF_PATH_REFRESH_TIME, mask)) 1055 conf->path_refresh_time = nconf->path_refresh_time; 1056 if (_chg_mesh_attr(NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT, mask)) 1057 conf->min_discovery_timeout = nconf->min_discovery_timeout; 1058 if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT, mask)) 1059 conf->dot11MeshHWMPactivePathTimeout = 1060 nconf->dot11MeshHWMPactivePathTimeout; 1061 if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL, mask)) 1062 conf->dot11MeshHWMPpreqMinInterval = 1063 nconf->dot11MeshHWMPpreqMinInterval; 1064 if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME, 1065 mask)) 1066 conf->dot11MeshHWMPnetDiameterTraversalTime = 1067 nconf->dot11MeshHWMPnetDiameterTraversalTime; 1068 if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_ROOTMODE, mask)) { 1069 conf->dot11MeshHWMPRootMode = nconf->dot11MeshHWMPRootMode; 1070 ieee80211_mesh_root_setup(ifmsh); 1071 } 1072 return 0; 1073 } 1074 1075 #endif 1076 1077 static int ieee80211_change_bss(struct wiphy *wiphy, 1078 struct net_device *dev, 1079 struct bss_parameters *params) 1080 { 1081 struct ieee80211_sub_if_data *sdata; 1082 u32 changed = 0; 1083 1084 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1085 1086 if (params->use_cts_prot >= 0) { 1087 sdata->vif.bss_conf.use_cts_prot = params->use_cts_prot; 1088 changed |= BSS_CHANGED_ERP_CTS_PROT; 1089 } 1090 if (params->use_short_preamble >= 0) { 1091 sdata->vif.bss_conf.use_short_preamble = 1092 params->use_short_preamble; 1093 changed |= BSS_CHANGED_ERP_PREAMBLE; 1094 } 1095 if (params->use_short_slot_time >= 0) { 1096 sdata->vif.bss_conf.use_short_slot = 1097 params->use_short_slot_time; 1098 changed |= BSS_CHANGED_ERP_SLOT; 1099 } 1100 1101 if (params->basic_rates) { 1102 int i, j; 1103 u32 rates = 0; 1104 struct ieee80211_local *local = wiphy_priv(wiphy); 1105 struct ieee80211_supported_band *sband = 1106 wiphy->bands[local->oper_channel->band]; 1107 1108 for (i = 0; i < params->basic_rates_len; i++) { 1109 int rate = (params->basic_rates[i] & 0x7f) * 5; 1110 for (j = 0; j < sband->n_bitrates; j++) { 1111 if (sband->bitrates[j].bitrate == rate) 1112 rates |= BIT(j); 1113 } 1114 } 1115 sdata->vif.bss_conf.basic_rates = rates; 1116 changed |= BSS_CHANGED_BASIC_RATES; 1117 } 1118 1119 ieee80211_bss_info_change_notify(sdata, changed); 1120 1121 return 0; 1122 } 1123 1124 static int ieee80211_set_txq_params(struct wiphy *wiphy, 1125 struct ieee80211_txq_params *params) 1126 { 1127 struct ieee80211_local *local = wiphy_priv(wiphy); 1128 struct ieee80211_tx_queue_params p; 1129 1130 if (!local->ops->conf_tx) 1131 return -EOPNOTSUPP; 1132 1133 memset(&p, 0, sizeof(p)); 1134 p.aifs = params->aifs; 1135 p.cw_max = params->cwmax; 1136 p.cw_min = params->cwmin; 1137 p.txop = params->txop; 1138 if (drv_conf_tx(local, params->queue, &p)) { 1139 printk(KERN_DEBUG "%s: failed to set TX queue " 1140 "parameters for queue %d\n", 1141 wiphy_name(local->hw.wiphy), params->queue); 1142 return -EINVAL; 1143 } 1144 1145 return 0; 1146 } 1147 1148 static int ieee80211_set_channel(struct wiphy *wiphy, 1149 struct ieee80211_channel *chan, 1150 enum nl80211_channel_type channel_type) 1151 { 1152 struct ieee80211_local *local = wiphy_priv(wiphy); 1153 1154 local->oper_channel = chan; 1155 local->oper_channel_type = channel_type; 1156 1157 return ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_CHANNEL); 1158 } 1159 1160 #ifdef CONFIG_PM 1161 static int ieee80211_suspend(struct wiphy *wiphy) 1162 { 1163 return __ieee80211_suspend(wiphy_priv(wiphy)); 1164 } 1165 1166 static int ieee80211_resume(struct wiphy *wiphy) 1167 { 1168 return __ieee80211_resume(wiphy_priv(wiphy)); 1169 } 1170 #else 1171 #define ieee80211_suspend NULL 1172 #define ieee80211_resume NULL 1173 #endif 1174 1175 static int ieee80211_scan(struct wiphy *wiphy, 1176 struct net_device *dev, 1177 struct cfg80211_scan_request *req) 1178 { 1179 struct ieee80211_sub_if_data *sdata; 1180 1181 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1182 1183 if (sdata->vif.type != NL80211_IFTYPE_STATION && 1184 sdata->vif.type != NL80211_IFTYPE_ADHOC && 1185 sdata->vif.type != NL80211_IFTYPE_MESH_POINT && 1186 (sdata->vif.type != NL80211_IFTYPE_AP || sdata->u.ap.beacon)) 1187 return -EOPNOTSUPP; 1188 1189 return ieee80211_request_scan(sdata, req); 1190 } 1191 1192 static int ieee80211_auth(struct wiphy *wiphy, struct net_device *dev, 1193 struct cfg80211_auth_request *req) 1194 { 1195 return ieee80211_mgd_auth(IEEE80211_DEV_TO_SUB_IF(dev), req); 1196 } 1197 1198 static int ieee80211_assoc(struct wiphy *wiphy, struct net_device *dev, 1199 struct cfg80211_assoc_request *req) 1200 { 1201 return ieee80211_mgd_assoc(IEEE80211_DEV_TO_SUB_IF(dev), req); 1202 } 1203 1204 static int ieee80211_deauth(struct wiphy *wiphy, struct net_device *dev, 1205 struct cfg80211_deauth_request *req, 1206 void *cookie) 1207 { 1208 return ieee80211_mgd_deauth(IEEE80211_DEV_TO_SUB_IF(dev), 1209 req, cookie); 1210 } 1211 1212 static int ieee80211_disassoc(struct wiphy *wiphy, struct net_device *dev, 1213 struct cfg80211_disassoc_request *req, 1214 void *cookie) 1215 { 1216 return ieee80211_mgd_disassoc(IEEE80211_DEV_TO_SUB_IF(dev), 1217 req, cookie); 1218 } 1219 1220 static int ieee80211_join_ibss(struct wiphy *wiphy, struct net_device *dev, 1221 struct cfg80211_ibss_params *params) 1222 { 1223 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1224 1225 return ieee80211_ibss_join(sdata, params); 1226 } 1227 1228 static int ieee80211_leave_ibss(struct wiphy *wiphy, struct net_device *dev) 1229 { 1230 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1231 1232 return ieee80211_ibss_leave(sdata); 1233 } 1234 1235 static int ieee80211_set_wiphy_params(struct wiphy *wiphy, u32 changed) 1236 { 1237 struct ieee80211_local *local = wiphy_priv(wiphy); 1238 int err; 1239 1240 if (changed & WIPHY_PARAM_RTS_THRESHOLD) { 1241 err = drv_set_rts_threshold(local, wiphy->rts_threshold); 1242 1243 if (err) 1244 return err; 1245 } 1246 1247 if (changed & WIPHY_PARAM_RETRY_SHORT) 1248 local->hw.conf.short_frame_max_tx_count = wiphy->retry_short; 1249 if (changed & WIPHY_PARAM_RETRY_LONG) 1250 local->hw.conf.long_frame_max_tx_count = wiphy->retry_long; 1251 if (changed & 1252 (WIPHY_PARAM_RETRY_SHORT | WIPHY_PARAM_RETRY_LONG)) 1253 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_RETRY_LIMITS); 1254 1255 return 0; 1256 } 1257 1258 static int ieee80211_set_tx_power(struct wiphy *wiphy, 1259 enum tx_power_setting type, int dbm) 1260 { 1261 struct ieee80211_local *local = wiphy_priv(wiphy); 1262 struct ieee80211_channel *chan = local->hw.conf.channel; 1263 u32 changes = 0; 1264 1265 switch (type) { 1266 case TX_POWER_AUTOMATIC: 1267 local->user_power_level = -1; 1268 break; 1269 case TX_POWER_LIMITED: 1270 if (dbm < 0) 1271 return -EINVAL; 1272 local->user_power_level = dbm; 1273 break; 1274 case TX_POWER_FIXED: 1275 if (dbm < 0) 1276 return -EINVAL; 1277 /* TODO: move to cfg80211 when it knows the channel */ 1278 if (dbm > chan->max_power) 1279 return -EINVAL; 1280 local->user_power_level = dbm; 1281 break; 1282 } 1283 1284 ieee80211_hw_config(local, changes); 1285 1286 return 0; 1287 } 1288 1289 static int ieee80211_get_tx_power(struct wiphy *wiphy, int *dbm) 1290 { 1291 struct ieee80211_local *local = wiphy_priv(wiphy); 1292 1293 *dbm = local->hw.conf.power_level; 1294 1295 return 0; 1296 } 1297 1298 static int ieee80211_set_wds_peer(struct wiphy *wiphy, struct net_device *dev, 1299 u8 *addr) 1300 { 1301 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1302 1303 memcpy(&sdata->u.wds.remote_addr, addr, ETH_ALEN); 1304 1305 return 0; 1306 } 1307 1308 static void ieee80211_rfkill_poll(struct wiphy *wiphy) 1309 { 1310 struct ieee80211_local *local = wiphy_priv(wiphy); 1311 1312 drv_rfkill_poll(local); 1313 } 1314 1315 #ifdef CONFIG_NL80211_TESTMODE 1316 static int ieee80211_testmode_cmd(struct wiphy *wiphy, void *data, int len) 1317 { 1318 struct ieee80211_local *local = wiphy_priv(wiphy); 1319 1320 if (!local->ops->testmode_cmd) 1321 return -EOPNOTSUPP; 1322 1323 return local->ops->testmode_cmd(&local->hw, data, len); 1324 } 1325 #endif 1326 1327 static int ieee80211_set_power_mgmt(struct wiphy *wiphy, struct net_device *dev, 1328 bool enabled, int timeout) 1329 { 1330 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1331 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 1332 struct ieee80211_conf *conf = &local->hw.conf; 1333 1334 if (sdata->vif.type != NL80211_IFTYPE_STATION) 1335 return -EOPNOTSUPP; 1336 1337 if (!(local->hw.flags & IEEE80211_HW_SUPPORTS_PS)) 1338 return -EOPNOTSUPP; 1339 1340 if (enabled == sdata->u.mgd.powersave && 1341 timeout == conf->dynamic_ps_timeout) 1342 return 0; 1343 1344 sdata->u.mgd.powersave = enabled; 1345 conf->dynamic_ps_timeout = timeout; 1346 1347 if (local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_PS) 1348 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS); 1349 1350 ieee80211_recalc_ps(local, -1); 1351 1352 return 0; 1353 } 1354 1355 static int ieee80211_set_bitrate_mask(struct wiphy *wiphy, 1356 struct net_device *dev, 1357 const u8 *addr, 1358 const struct cfg80211_bitrate_mask *mask) 1359 { 1360 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1361 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 1362 int i, err = -EINVAL; 1363 u32 target_rate; 1364 struct ieee80211_supported_band *sband; 1365 1366 sband = local->hw.wiphy->bands[local->hw.conf.channel->band]; 1367 1368 /* target_rate = -1, rate->fixed = 0 means auto only, so use all rates 1369 * target_rate = X, rate->fixed = 1 means only rate X 1370 * target_rate = X, rate->fixed = 0 means all rates <= X */ 1371 sdata->max_ratectrl_rateidx = -1; 1372 sdata->force_unicast_rateidx = -1; 1373 1374 if (mask->fixed) 1375 target_rate = mask->fixed / 100; 1376 else if (mask->maxrate) 1377 target_rate = mask->maxrate / 100; 1378 else 1379 return 0; 1380 1381 for (i=0; i< sband->n_bitrates; i++) { 1382 struct ieee80211_rate *brate = &sband->bitrates[i]; 1383 int this_rate = brate->bitrate; 1384 1385 if (target_rate == this_rate) { 1386 sdata->max_ratectrl_rateidx = i; 1387 if (mask->fixed) 1388 sdata->force_unicast_rateidx = i; 1389 err = 0; 1390 break; 1391 } 1392 } 1393 1394 return err; 1395 } 1396 1397 struct cfg80211_ops mac80211_config_ops = { 1398 .add_virtual_intf = ieee80211_add_iface, 1399 .del_virtual_intf = ieee80211_del_iface, 1400 .change_virtual_intf = ieee80211_change_iface, 1401 .add_key = ieee80211_add_key, 1402 .del_key = ieee80211_del_key, 1403 .get_key = ieee80211_get_key, 1404 .set_default_key = ieee80211_config_default_key, 1405 .set_default_mgmt_key = ieee80211_config_default_mgmt_key, 1406 .add_beacon = ieee80211_add_beacon, 1407 .set_beacon = ieee80211_set_beacon, 1408 .del_beacon = ieee80211_del_beacon, 1409 .add_station = ieee80211_add_station, 1410 .del_station = ieee80211_del_station, 1411 .change_station = ieee80211_change_station, 1412 .get_station = ieee80211_get_station, 1413 .dump_station = ieee80211_dump_station, 1414 #ifdef CONFIG_MAC80211_MESH 1415 .add_mpath = ieee80211_add_mpath, 1416 .del_mpath = ieee80211_del_mpath, 1417 .change_mpath = ieee80211_change_mpath, 1418 .get_mpath = ieee80211_get_mpath, 1419 .dump_mpath = ieee80211_dump_mpath, 1420 .set_mesh_params = ieee80211_set_mesh_params, 1421 .get_mesh_params = ieee80211_get_mesh_params, 1422 #endif 1423 .change_bss = ieee80211_change_bss, 1424 .set_txq_params = ieee80211_set_txq_params, 1425 .set_channel = ieee80211_set_channel, 1426 .suspend = ieee80211_suspend, 1427 .resume = ieee80211_resume, 1428 .scan = ieee80211_scan, 1429 .auth = ieee80211_auth, 1430 .assoc = ieee80211_assoc, 1431 .deauth = ieee80211_deauth, 1432 .disassoc = ieee80211_disassoc, 1433 .join_ibss = ieee80211_join_ibss, 1434 .leave_ibss = ieee80211_leave_ibss, 1435 .set_wiphy_params = ieee80211_set_wiphy_params, 1436 .set_tx_power = ieee80211_set_tx_power, 1437 .get_tx_power = ieee80211_get_tx_power, 1438 .set_wds_peer = ieee80211_set_wds_peer, 1439 .rfkill_poll = ieee80211_rfkill_poll, 1440 CFG80211_TESTMODE_CMD(ieee80211_testmode_cmd) 1441 .set_power_mgmt = ieee80211_set_power_mgmt, 1442 .set_bitrate_mask = ieee80211_set_bitrate_mask, 1443 }; 1444