main.c revision edcdf8b21ac920e06b4180246123fe43b022e020
1/* 2 * Copyright 2002-2005, Instant802 Networks, Inc. 3 * Copyright 2005-2006, Devicescape Software, Inc. 4 * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz> 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License version 2 as 8 * published by the Free Software Foundation. 9 */ 10 11#include <net/mac80211.h> 12#include <net/ieee80211_radiotap.h> 13#include <linux/module.h> 14#include <linux/init.h> 15#include <linux/netdevice.h> 16#include <linux/types.h> 17#include <linux/slab.h> 18#include <linux/skbuff.h> 19#include <linux/etherdevice.h> 20#include <linux/if_arp.h> 21#include <linux/wireless.h> 22#include <linux/rtnetlink.h> 23#include <linux/bitmap.h> 24#include <net/net_namespace.h> 25#include <net/cfg80211.h> 26 27#include "ieee80211_i.h" 28#include "rate.h" 29#include "mesh.h" 30#include "wep.h" 31#include "wme.h" 32#include "aes_ccm.h" 33#include "led.h" 34#include "cfg.h" 35#include "debugfs.h" 36#include "debugfs_netdev.h" 37 38/* 39 * For seeing transmitted packets on monitor interfaces 40 * we have a radiotap header too. 41 */ 42struct ieee80211_tx_status_rtap_hdr { 43 struct ieee80211_radiotap_header hdr; 44 __le16 tx_flags; 45 u8 data_retries; 46} __attribute__ ((packed)); 47 48/* common interface routines */ 49 50static int header_parse_80211(const struct sk_buff *skb, unsigned char *haddr) 51{ 52 memcpy(haddr, skb_mac_header(skb) + 10, ETH_ALEN); /* addr2 */ 53 return ETH_ALEN; 54} 55 56/* must be called under mdev tx lock */ 57static void ieee80211_configure_filter(struct ieee80211_local *local) 58{ 59 unsigned int changed_flags; 60 unsigned int new_flags = 0; 61 62 if (atomic_read(&local->iff_promiscs)) 63 new_flags |= FIF_PROMISC_IN_BSS; 64 65 if (atomic_read(&local->iff_allmultis)) 66 new_flags |= FIF_ALLMULTI; 67 68 if (local->monitors) 69 new_flags |= FIF_BCN_PRBRESP_PROMISC; 70 71 if (local->fif_fcsfail) 72 new_flags |= FIF_FCSFAIL; 73 74 if (local->fif_plcpfail) 75 new_flags |= FIF_PLCPFAIL; 76 77 if (local->fif_control) 78 new_flags |= FIF_CONTROL; 79 80 if (local->fif_other_bss) 81 new_flags |= FIF_OTHER_BSS; 82 83 changed_flags = local->filter_flags ^ new_flags; 84 85 /* be a bit nasty */ 86 new_flags |= (1<<31); 87 88 local->ops->configure_filter(local_to_hw(local), 89 changed_flags, &new_flags, 90 local->mdev->mc_count, 91 local->mdev->mc_list); 92 93 WARN_ON(new_flags & (1<<31)); 94 95 local->filter_flags = new_flags & ~(1<<31); 96} 97 98/* master interface */ 99 100static int ieee80211_master_open(struct net_device *dev) 101{ 102 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 103 struct ieee80211_sub_if_data *sdata; 104 int res = -EOPNOTSUPP; 105 106 /* we hold the RTNL here so can safely walk the list */ 107 list_for_each_entry(sdata, &local->interfaces, list) { 108 if (sdata->dev != dev && netif_running(sdata->dev)) { 109 res = 0; 110 break; 111 } 112 } 113 return res; 114} 115 116static int ieee80211_master_stop(struct net_device *dev) 117{ 118 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 119 struct ieee80211_sub_if_data *sdata; 120 121 /* we hold the RTNL here so can safely walk the list */ 122 list_for_each_entry(sdata, &local->interfaces, list) 123 if (sdata->dev != dev && netif_running(sdata->dev)) 124 dev_close(sdata->dev); 125 126 return 0; 127} 128 129static void ieee80211_master_set_multicast_list(struct net_device *dev) 130{ 131 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 132 133 ieee80211_configure_filter(local); 134} 135 136/* regular interfaces */ 137 138static int ieee80211_change_mtu(struct net_device *dev, int new_mtu) 139{ 140 int meshhdrlen; 141 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 142 143 meshhdrlen = (sdata->vif.type == IEEE80211_IF_TYPE_MESH_POINT) ? 5 : 0; 144 145 /* FIX: what would be proper limits for MTU? 146 * This interface uses 802.3 frames. */ 147 if (new_mtu < 256 || 148 new_mtu > IEEE80211_MAX_DATA_LEN - 24 - 6 - meshhdrlen) { 149 printk(KERN_WARNING "%s: invalid MTU %d\n", 150 dev->name, new_mtu); 151 return -EINVAL; 152 } 153 154#ifdef CONFIG_MAC80211_VERBOSE_DEBUG 155 printk(KERN_DEBUG "%s: setting MTU %d\n", dev->name, new_mtu); 156#endif /* CONFIG_MAC80211_VERBOSE_DEBUG */ 157 dev->mtu = new_mtu; 158 return 0; 159} 160 161static inline int identical_mac_addr_allowed(int type1, int type2) 162{ 163 return (type1 == IEEE80211_IF_TYPE_MNTR || 164 type2 == IEEE80211_IF_TYPE_MNTR || 165 (type1 == IEEE80211_IF_TYPE_AP && 166 type2 == IEEE80211_IF_TYPE_WDS) || 167 (type1 == IEEE80211_IF_TYPE_WDS && 168 (type2 == IEEE80211_IF_TYPE_WDS || 169 type2 == IEEE80211_IF_TYPE_AP)) || 170 (type1 == IEEE80211_IF_TYPE_AP && 171 type2 == IEEE80211_IF_TYPE_VLAN) || 172 (type1 == IEEE80211_IF_TYPE_VLAN && 173 (type2 == IEEE80211_IF_TYPE_AP || 174 type2 == IEEE80211_IF_TYPE_VLAN))); 175} 176 177static int ieee80211_open(struct net_device *dev) 178{ 179 struct ieee80211_sub_if_data *sdata, *nsdata; 180 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 181 struct ieee80211_if_init_conf conf; 182 int res; 183 bool need_hw_reconfig = 0; 184 struct sta_info *sta; 185 186 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 187 188 /* we hold the RTNL here so can safely walk the list */ 189 list_for_each_entry(nsdata, &local->interfaces, list) { 190 struct net_device *ndev = nsdata->dev; 191 192 if (ndev != dev && ndev != local->mdev && netif_running(ndev)) { 193 /* 194 * Allow only a single IBSS interface to be up at any 195 * time. This is restricted because beacon distribution 196 * cannot work properly if both are in the same IBSS. 197 * 198 * To remove this restriction we'd have to disallow them 199 * from setting the same SSID on different IBSS interfaces 200 * belonging to the same hardware. Then, however, we're 201 * faced with having to adopt two different TSF timers... 202 */ 203 if (sdata->vif.type == IEEE80211_IF_TYPE_IBSS && 204 nsdata->vif.type == IEEE80211_IF_TYPE_IBSS) 205 return -EBUSY; 206 207 /* 208 * Disallow multiple IBSS/STA mode interfaces. 209 * 210 * This is a technical restriction, it is possible although 211 * most likely not IEEE 802.11 compliant to have multiple 212 * STAs with just a single hardware (the TSF timer will not 213 * be adjusted properly.) 214 * 215 * However, because mac80211 uses the master device's BSS 216 * information for each STA/IBSS interface, doing this will 217 * currently corrupt that BSS information completely, unless, 218 * a not very useful case, both STAs are associated to the 219 * same BSS. 220 * 221 * To remove this restriction, the BSS information needs to 222 * be embedded in the STA/IBSS mode sdata instead of using 223 * the master device's BSS structure. 224 */ 225 if ((sdata->vif.type == IEEE80211_IF_TYPE_STA || 226 sdata->vif.type == IEEE80211_IF_TYPE_IBSS) && 227 (nsdata->vif.type == IEEE80211_IF_TYPE_STA || 228 nsdata->vif.type == IEEE80211_IF_TYPE_IBSS)) 229 return -EBUSY; 230 231 /* 232 * The remaining checks are only performed for interfaces 233 * with the same MAC address. 234 */ 235 if (compare_ether_addr(dev->dev_addr, ndev->dev_addr)) 236 continue; 237 238 /* 239 * check whether it may have the same address 240 */ 241 if (!identical_mac_addr_allowed(sdata->vif.type, 242 nsdata->vif.type)) 243 return -ENOTUNIQ; 244 245 /* 246 * can only add VLANs to enabled APs 247 */ 248 if (sdata->vif.type == IEEE80211_IF_TYPE_VLAN && 249 nsdata->vif.type == IEEE80211_IF_TYPE_AP) 250 sdata->u.vlan.ap = nsdata; 251 } 252 } 253 254 switch (sdata->vif.type) { 255 case IEEE80211_IF_TYPE_WDS: 256 if (!is_valid_ether_addr(sdata->u.wds.remote_addr)) 257 return -ENOLINK; 258 break; 259 case IEEE80211_IF_TYPE_VLAN: 260 if (!sdata->u.vlan.ap) 261 return -ENOLINK; 262 break; 263 case IEEE80211_IF_TYPE_AP: 264 case IEEE80211_IF_TYPE_STA: 265 case IEEE80211_IF_TYPE_MNTR: 266 case IEEE80211_IF_TYPE_IBSS: 267 case IEEE80211_IF_TYPE_MESH_POINT: 268 /* no special treatment */ 269 break; 270 case IEEE80211_IF_TYPE_INVALID: 271 /* cannot happen */ 272 WARN_ON(1); 273 break; 274 } 275 276 if (local->open_count == 0) { 277 res = 0; 278 if (local->ops->start) 279 res = local->ops->start(local_to_hw(local)); 280 if (res) 281 return res; 282 need_hw_reconfig = 1; 283 ieee80211_led_radio(local, local->hw.conf.radio_enabled); 284 } 285 286 switch (sdata->vif.type) { 287 case IEEE80211_IF_TYPE_VLAN: 288 list_add(&sdata->u.vlan.list, &sdata->u.vlan.ap->u.ap.vlans); 289 /* no need to tell driver */ 290 break; 291 case IEEE80211_IF_TYPE_MNTR: 292 if (sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES) { 293 local->cooked_mntrs++; 294 break; 295 } 296 297 /* must be before the call to ieee80211_configure_filter */ 298 local->monitors++; 299 if (local->monitors == 1) 300 local->hw.conf.flags |= IEEE80211_CONF_RADIOTAP; 301 302 if (sdata->u.mntr_flags & MONITOR_FLAG_FCSFAIL) 303 local->fif_fcsfail++; 304 if (sdata->u.mntr_flags & MONITOR_FLAG_PLCPFAIL) 305 local->fif_plcpfail++; 306 if (sdata->u.mntr_flags & MONITOR_FLAG_CONTROL) 307 local->fif_control++; 308 if (sdata->u.mntr_flags & MONITOR_FLAG_OTHER_BSS) 309 local->fif_other_bss++; 310 311 netif_tx_lock_bh(local->mdev); 312 ieee80211_configure_filter(local); 313 netif_tx_unlock_bh(local->mdev); 314 break; 315 case IEEE80211_IF_TYPE_STA: 316 case IEEE80211_IF_TYPE_IBSS: 317 sdata->u.sta.flags &= ~IEEE80211_STA_PREV_BSSID_SET; 318 /* fall through */ 319 default: 320 conf.vif = &sdata->vif; 321 conf.type = sdata->vif.type; 322 conf.mac_addr = dev->dev_addr; 323 res = local->ops->add_interface(local_to_hw(local), &conf); 324 if (res) 325 goto err_stop; 326 327 ieee80211_if_config(dev); 328 ieee80211_reset_erp_info(dev); 329 ieee80211_enable_keys(sdata); 330 331 if (sdata->vif.type == IEEE80211_IF_TYPE_STA && 332 !(sdata->flags & IEEE80211_SDATA_USERSPACE_MLME)) 333 netif_carrier_off(dev); 334 else 335 netif_carrier_on(dev); 336 } 337 338 if (sdata->vif.type == IEEE80211_IF_TYPE_WDS) { 339 /* Create STA entry for the WDS peer */ 340 sta = sta_info_alloc(sdata, sdata->u.wds.remote_addr, 341 GFP_KERNEL); 342 if (!sta) { 343 res = -ENOMEM; 344 goto err_del_interface; 345 } 346 347 /* no locking required since STA is not live yet */ 348 sta->flags |= WLAN_STA_AUTHORIZED; 349 350 res = sta_info_insert(sta); 351 if (res) { 352 /* STA has been freed */ 353 goto err_del_interface; 354 } 355 } 356 357 if (local->open_count == 0) { 358 res = dev_open(local->mdev); 359 WARN_ON(res); 360 if (res) 361 goto err_del_interface; 362 tasklet_enable(&local->tx_pending_tasklet); 363 tasklet_enable(&local->tasklet); 364 } 365 366 /* 367 * set_multicast_list will be invoked by the networking core 368 * which will check whether any increments here were done in 369 * error and sync them down to the hardware as filter flags. 370 */ 371 if (sdata->flags & IEEE80211_SDATA_ALLMULTI) 372 atomic_inc(&local->iff_allmultis); 373 374 if (sdata->flags & IEEE80211_SDATA_PROMISC) 375 atomic_inc(&local->iff_promiscs); 376 377 local->open_count++; 378 if (need_hw_reconfig) 379 ieee80211_hw_config(local); 380 381 /* 382 * ieee80211_sta_work is disabled while network interface 383 * is down. Therefore, some configuration changes may not 384 * yet be effective. Trigger execution of ieee80211_sta_work 385 * to fix this. 386 */ 387 if (sdata->vif.type == IEEE80211_IF_TYPE_STA || 388 sdata->vif.type == IEEE80211_IF_TYPE_IBSS) { 389 struct ieee80211_if_sta *ifsta = &sdata->u.sta; 390 queue_work(local->hw.workqueue, &ifsta->work); 391 } 392 393 netif_start_queue(dev); 394 395 return 0; 396 err_del_interface: 397 local->ops->remove_interface(local_to_hw(local), &conf); 398 err_stop: 399 if (!local->open_count && local->ops->stop) 400 local->ops->stop(local_to_hw(local)); 401 return res; 402} 403 404static int ieee80211_stop(struct net_device *dev) 405{ 406 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 407 struct ieee80211_local *local = sdata->local; 408 struct ieee80211_if_init_conf conf; 409 struct sta_info *sta; 410 411 /* 412 * Stop TX on this interface first. 413 */ 414 netif_stop_queue(dev); 415 416 /* 417 * Now delete all active aggregation sessions. 418 */ 419 rcu_read_lock(); 420 421 list_for_each_entry_rcu(sta, &local->sta_list, list) { 422 if (sta->sdata == sdata) 423 ieee80211_sta_tear_down_BA_sessions(dev, sta->addr); 424 } 425 426 rcu_read_unlock(); 427 428 /* 429 * Remove all stations associated with this interface. 430 * 431 * This must be done before calling ops->remove_interface() 432 * because otherwise we can later invoke ops->sta_notify() 433 * whenever the STAs are removed, and that invalidates driver 434 * assumptions about always getting a vif pointer that is valid 435 * (because if we remove a STA after ops->remove_interface() 436 * the driver will have removed the vif info already!) 437 * 438 * We could relax this and only unlink the stations from the 439 * hash table and list but keep them on a per-sdata list that 440 * will be inserted back again when the interface is brought 441 * up again, but I don't currently see a use case for that, 442 * except with WDS which gets a STA entry created when it is 443 * brought up. 444 */ 445 sta_info_flush(local, sdata); 446 447 /* 448 * Don't count this interface for promisc/allmulti while it 449 * is down. dev_mc_unsync() will invoke set_multicast_list 450 * on the master interface which will sync these down to the 451 * hardware as filter flags. 452 */ 453 if (sdata->flags & IEEE80211_SDATA_ALLMULTI) 454 atomic_dec(&local->iff_allmultis); 455 456 if (sdata->flags & IEEE80211_SDATA_PROMISC) 457 atomic_dec(&local->iff_promiscs); 458 459 dev_mc_unsync(local->mdev, dev); 460 461 /* APs need special treatment */ 462 if (sdata->vif.type == IEEE80211_IF_TYPE_AP) { 463 struct ieee80211_sub_if_data *vlan, *tmp; 464 struct beacon_data *old_beacon = sdata->u.ap.beacon; 465 466 /* remove beacon */ 467 rcu_assign_pointer(sdata->u.ap.beacon, NULL); 468 synchronize_rcu(); 469 kfree(old_beacon); 470 471 /* down all dependent devices, that is VLANs */ 472 list_for_each_entry_safe(vlan, tmp, &sdata->u.ap.vlans, 473 u.vlan.list) 474 dev_close(vlan->dev); 475 WARN_ON(!list_empty(&sdata->u.ap.vlans)); 476 } 477 478 local->open_count--; 479 480 switch (sdata->vif.type) { 481 case IEEE80211_IF_TYPE_VLAN: 482 list_del(&sdata->u.vlan.list); 483 sdata->u.vlan.ap = NULL; 484 /* no need to tell driver */ 485 break; 486 case IEEE80211_IF_TYPE_MNTR: 487 if (sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES) { 488 local->cooked_mntrs--; 489 break; 490 } 491 492 local->monitors--; 493 if (local->monitors == 0) 494 local->hw.conf.flags &= ~IEEE80211_CONF_RADIOTAP; 495 496 if (sdata->u.mntr_flags & MONITOR_FLAG_FCSFAIL) 497 local->fif_fcsfail--; 498 if (sdata->u.mntr_flags & MONITOR_FLAG_PLCPFAIL) 499 local->fif_plcpfail--; 500 if (sdata->u.mntr_flags & MONITOR_FLAG_CONTROL) 501 local->fif_control--; 502 if (sdata->u.mntr_flags & MONITOR_FLAG_OTHER_BSS) 503 local->fif_other_bss--; 504 505 netif_tx_lock_bh(local->mdev); 506 ieee80211_configure_filter(local); 507 netif_tx_unlock_bh(local->mdev); 508 break; 509 case IEEE80211_IF_TYPE_MESH_POINT: 510 case IEEE80211_IF_TYPE_STA: 511 case IEEE80211_IF_TYPE_IBSS: 512 sdata->u.sta.state = IEEE80211_DISABLED; 513 del_timer_sync(&sdata->u.sta.timer); 514 /* 515 * When we get here, the interface is marked down. 516 * Call synchronize_rcu() to wait for the RX path 517 * should it be using the interface and enqueuing 518 * frames at this very time on another CPU. 519 */ 520 synchronize_rcu(); 521 skb_queue_purge(&sdata->u.sta.skb_queue); 522 523 if (local->scan_dev == sdata->dev) { 524 if (!local->ops->hw_scan) { 525 local->sta_sw_scanning = 0; 526 cancel_delayed_work(&local->scan_work); 527 } else 528 local->sta_hw_scanning = 0; 529 } 530 531 flush_workqueue(local->hw.workqueue); 532 533 sdata->u.sta.flags &= ~IEEE80211_STA_PRIVACY_INVOKED; 534 kfree(sdata->u.sta.extra_ie); 535 sdata->u.sta.extra_ie = NULL; 536 sdata->u.sta.extra_ie_len = 0; 537 /* fall through */ 538 default: 539 conf.vif = &sdata->vif; 540 conf.type = sdata->vif.type; 541 conf.mac_addr = dev->dev_addr; 542 /* disable all keys for as long as this netdev is down */ 543 ieee80211_disable_keys(sdata); 544 local->ops->remove_interface(local_to_hw(local), &conf); 545 } 546 547 if (local->open_count == 0) { 548 if (netif_running(local->mdev)) 549 dev_close(local->mdev); 550 551 if (local->ops->stop) 552 local->ops->stop(local_to_hw(local)); 553 554 ieee80211_led_radio(local, 0); 555 556 tasklet_disable(&local->tx_pending_tasklet); 557 tasklet_disable(&local->tasklet); 558 } 559 560 return 0; 561} 562 563int ieee80211_start_tx_ba_session(struct ieee80211_hw *hw, u8 *ra, u16 tid) 564{ 565 struct ieee80211_local *local = hw_to_local(hw); 566 struct sta_info *sta; 567 struct ieee80211_sub_if_data *sdata; 568 u16 start_seq_num = 0; 569 u8 *state; 570 int ret; 571 DECLARE_MAC_BUF(mac); 572 573 if (tid >= STA_TID_NUM) 574 return -EINVAL; 575 576#ifdef CONFIG_MAC80211_HT_DEBUG 577 printk(KERN_DEBUG "Open BA session requested for %s tid %u\n", 578 print_mac(mac, ra), tid); 579#endif /* CONFIG_MAC80211_HT_DEBUG */ 580 581 rcu_read_lock(); 582 583 sta = sta_info_get(local, ra); 584 if (!sta) { 585 printk(KERN_DEBUG "Could not find the station\n"); 586 rcu_read_unlock(); 587 return -ENOENT; 588 } 589 590 spin_lock_bh(&sta->lock); 591 592 /* we have tried too many times, receiver does not want A-MPDU */ 593 if (sta->ampdu_mlme.addba_req_num[tid] > HT_AGG_MAX_RETRIES) { 594 ret = -EBUSY; 595 goto start_ba_exit; 596 } 597 598 state = &sta->ampdu_mlme.tid_state_tx[tid]; 599 /* check if the TID is not in aggregation flow already */ 600 if (*state != HT_AGG_STATE_IDLE) { 601#ifdef CONFIG_MAC80211_HT_DEBUG 602 printk(KERN_DEBUG "BA request denied - session is not " 603 "idle on tid %u\n", tid); 604#endif /* CONFIG_MAC80211_HT_DEBUG */ 605 ret = -EAGAIN; 606 goto start_ba_exit; 607 } 608 609 /* prepare A-MPDU MLME for Tx aggregation */ 610 sta->ampdu_mlme.tid_tx[tid] = 611 kmalloc(sizeof(struct tid_ampdu_tx), GFP_ATOMIC); 612 if (!sta->ampdu_mlme.tid_tx[tid]) { 613 if (net_ratelimit()) 614 printk(KERN_ERR "allocate tx mlme to tid %d failed\n", 615 tid); 616 ret = -ENOMEM; 617 goto start_ba_exit; 618 } 619 /* Tx timer */ 620 sta->ampdu_mlme.tid_tx[tid]->addba_resp_timer.function = 621 sta_addba_resp_timer_expired; 622 sta->ampdu_mlme.tid_tx[tid]->addba_resp_timer.data = 623 (unsigned long)&sta->timer_to_tid[tid]; 624 init_timer(&sta->ampdu_mlme.tid_tx[tid]->addba_resp_timer); 625 626 /* ensure that TX flow won't interrupt us 627 * until the end of the call to requeue function */ 628 spin_lock_bh(&local->mdev->queue_lock); 629 630 /* create a new queue for this aggregation */ 631 ret = ieee80211_ht_agg_queue_add(local, sta, tid); 632 633 /* case no queue is available to aggregation 634 * don't switch to aggregation */ 635 if (ret) { 636#ifdef CONFIG_MAC80211_HT_DEBUG 637 printk(KERN_DEBUG "BA request denied - queue unavailable for" 638 " tid %d\n", tid); 639#endif /* CONFIG_MAC80211_HT_DEBUG */ 640 goto start_ba_err; 641 } 642 sdata = sta->sdata; 643 644 /* Ok, the Addba frame hasn't been sent yet, but if the driver calls the 645 * call back right away, it must see that the flow has begun */ 646 *state |= HT_ADDBA_REQUESTED_MSK; 647 648 if (local->ops->ampdu_action) 649 ret = local->ops->ampdu_action(hw, IEEE80211_AMPDU_TX_START, 650 ra, tid, &start_seq_num); 651 652 if (ret) { 653 /* No need to requeue the packets in the agg queue, since we 654 * held the tx lock: no packet could be enqueued to the newly 655 * allocated queue */ 656 ieee80211_ht_agg_queue_remove(local, sta, tid, 0); 657#ifdef CONFIG_MAC80211_HT_DEBUG 658 printk(KERN_DEBUG "BA request denied - HW unavailable for" 659 " tid %d\n", tid); 660#endif /* CONFIG_MAC80211_HT_DEBUG */ 661 *state = HT_AGG_STATE_IDLE; 662 goto start_ba_err; 663 } 664 665 /* Will put all the packets in the new SW queue */ 666 ieee80211_requeue(local, ieee802_1d_to_ac[tid]); 667 spin_unlock_bh(&local->mdev->queue_lock); 668 669 /* send an addBA request */ 670 sta->ampdu_mlme.dialog_token_allocator++; 671 sta->ampdu_mlme.tid_tx[tid]->dialog_token = 672 sta->ampdu_mlme.dialog_token_allocator; 673 sta->ampdu_mlme.tid_tx[tid]->ssn = start_seq_num; 674 675 ieee80211_send_addba_request(sta->sdata->dev, ra, tid, 676 sta->ampdu_mlme.tid_tx[tid]->dialog_token, 677 sta->ampdu_mlme.tid_tx[tid]->ssn, 678 0x40, 5000); 679 680 /* activate the timer for the recipient's addBA response */ 681 sta->ampdu_mlme.tid_tx[tid]->addba_resp_timer.expires = 682 jiffies + ADDBA_RESP_INTERVAL; 683 add_timer(&sta->ampdu_mlme.tid_tx[tid]->addba_resp_timer); 684 printk(KERN_DEBUG "activated addBA response timer on tid %d\n", tid); 685 goto start_ba_exit; 686 687start_ba_err: 688 kfree(sta->ampdu_mlme.tid_tx[tid]); 689 sta->ampdu_mlme.tid_tx[tid] = NULL; 690 spin_unlock_bh(&local->mdev->queue_lock); 691 ret = -EBUSY; 692start_ba_exit: 693 spin_unlock_bh(&sta->lock); 694 rcu_read_unlock(); 695 return ret; 696} 697EXPORT_SYMBOL(ieee80211_start_tx_ba_session); 698 699int ieee80211_stop_tx_ba_session(struct ieee80211_hw *hw, 700 u8 *ra, u16 tid, 701 enum ieee80211_back_parties initiator) 702{ 703 struct ieee80211_local *local = hw_to_local(hw); 704 struct sta_info *sta; 705 u8 *state; 706 int ret = 0; 707 DECLARE_MAC_BUF(mac); 708 709 if (tid >= STA_TID_NUM) 710 return -EINVAL; 711 712 rcu_read_lock(); 713 sta = sta_info_get(local, ra); 714 if (!sta) { 715 rcu_read_unlock(); 716 return -ENOENT; 717 } 718 719 /* check if the TID is in aggregation */ 720 state = &sta->ampdu_mlme.tid_state_tx[tid]; 721 spin_lock_bh(&sta->lock); 722 723 if (*state != HT_AGG_STATE_OPERATIONAL) { 724 ret = -ENOENT; 725 goto stop_BA_exit; 726 } 727 728#ifdef CONFIG_MAC80211_HT_DEBUG 729 printk(KERN_DEBUG "Tx BA session stop requested for %s tid %u\n", 730 print_mac(mac, ra), tid); 731#endif /* CONFIG_MAC80211_HT_DEBUG */ 732 733 ieee80211_stop_queue(hw, sta->tid_to_tx_q[tid]); 734 735 *state = HT_AGG_STATE_REQ_STOP_BA_MSK | 736 (initiator << HT_AGG_STATE_INITIATOR_SHIFT); 737 738 if (local->ops->ampdu_action) 739 ret = local->ops->ampdu_action(hw, IEEE80211_AMPDU_TX_STOP, 740 ra, tid, NULL); 741 742 /* case HW denied going back to legacy */ 743 if (ret) { 744 WARN_ON(ret != -EBUSY); 745 *state = HT_AGG_STATE_OPERATIONAL; 746 ieee80211_wake_queue(hw, sta->tid_to_tx_q[tid]); 747 goto stop_BA_exit; 748 } 749 750stop_BA_exit: 751 spin_unlock_bh(&sta->lock); 752 rcu_read_unlock(); 753 return ret; 754} 755EXPORT_SYMBOL(ieee80211_stop_tx_ba_session); 756 757void ieee80211_start_tx_ba_cb(struct ieee80211_hw *hw, u8 *ra, u16 tid) 758{ 759 struct ieee80211_local *local = hw_to_local(hw); 760 struct sta_info *sta; 761 u8 *state; 762 DECLARE_MAC_BUF(mac); 763 764 if (tid >= STA_TID_NUM) { 765 printk(KERN_DEBUG "Bad TID value: tid = %d (>= %d)\n", 766 tid, STA_TID_NUM); 767 return; 768 } 769 770 rcu_read_lock(); 771 sta = sta_info_get(local, ra); 772 if (!sta) { 773 rcu_read_unlock(); 774 printk(KERN_DEBUG "Could not find station: %s\n", 775 print_mac(mac, ra)); 776 return; 777 } 778 779 state = &sta->ampdu_mlme.tid_state_tx[tid]; 780 spin_lock_bh(&sta->lock); 781 782 if (!(*state & HT_ADDBA_REQUESTED_MSK)) { 783 printk(KERN_DEBUG "addBA was not requested yet, state is %d\n", 784 *state); 785 spin_unlock_bh(&sta->lock); 786 rcu_read_unlock(); 787 return; 788 } 789 790 WARN_ON_ONCE(*state & HT_ADDBA_DRV_READY_MSK); 791 792 *state |= HT_ADDBA_DRV_READY_MSK; 793 794 if (*state == HT_AGG_STATE_OPERATIONAL) { 795 printk(KERN_DEBUG "Aggregation is on for tid %d \n", tid); 796 ieee80211_wake_queue(hw, sta->tid_to_tx_q[tid]); 797 } 798 spin_unlock_bh(&sta->lock); 799 rcu_read_unlock(); 800} 801EXPORT_SYMBOL(ieee80211_start_tx_ba_cb); 802 803void ieee80211_stop_tx_ba_cb(struct ieee80211_hw *hw, u8 *ra, u8 tid) 804{ 805 struct ieee80211_local *local = hw_to_local(hw); 806 struct sta_info *sta; 807 u8 *state; 808 int agg_queue; 809 DECLARE_MAC_BUF(mac); 810 811 if (tid >= STA_TID_NUM) { 812 printk(KERN_DEBUG "Bad TID value: tid = %d (>= %d)\n", 813 tid, STA_TID_NUM); 814 return; 815 } 816 817#ifdef CONFIG_MAC80211_HT_DEBUG 818 printk(KERN_DEBUG "Stopping Tx BA session for %s tid %d\n", 819 print_mac(mac, ra), tid); 820#endif /* CONFIG_MAC80211_HT_DEBUG */ 821 822 rcu_read_lock(); 823 sta = sta_info_get(local, ra); 824 if (!sta) { 825 printk(KERN_DEBUG "Could not find station: %s\n", 826 print_mac(mac, ra)); 827 rcu_read_unlock(); 828 return; 829 } 830 state = &sta->ampdu_mlme.tid_state_tx[tid]; 831 832 spin_lock_bh(&sta->lock); 833 if ((*state & HT_AGG_STATE_REQ_STOP_BA_MSK) == 0) { 834 printk(KERN_DEBUG "unexpected callback to A-MPDU stop\n"); 835 spin_unlock_bh(&sta->lock); 836 rcu_read_unlock(); 837 return; 838 } 839 840 if (*state & HT_AGG_STATE_INITIATOR_MSK) 841 ieee80211_send_delba(sta->sdata->dev, ra, tid, 842 WLAN_BACK_INITIATOR, WLAN_REASON_QSTA_NOT_USE); 843 844 agg_queue = sta->tid_to_tx_q[tid]; 845 846 /* avoid ordering issues: we are the only one that can modify 847 * the content of the qdiscs */ 848 spin_lock_bh(&local->mdev->queue_lock); 849 /* remove the queue for this aggregation */ 850 ieee80211_ht_agg_queue_remove(local, sta, tid, 1); 851 spin_unlock_bh(&local->mdev->queue_lock); 852 853 /* we just requeued the all the frames that were in the removed 854 * queue, and since we might miss a softirq we do netif_schedule. 855 * ieee80211_wake_queue is not used here as this queue is not 856 * necessarily stopped */ 857 netif_schedule(local->mdev); 858 *state = HT_AGG_STATE_IDLE; 859 sta->ampdu_mlme.addba_req_num[tid] = 0; 860 kfree(sta->ampdu_mlme.tid_tx[tid]); 861 sta->ampdu_mlme.tid_tx[tid] = NULL; 862 spin_unlock_bh(&sta->lock); 863 864 rcu_read_unlock(); 865} 866EXPORT_SYMBOL(ieee80211_stop_tx_ba_cb); 867 868void ieee80211_start_tx_ba_cb_irqsafe(struct ieee80211_hw *hw, 869 const u8 *ra, u16 tid) 870{ 871 struct ieee80211_local *local = hw_to_local(hw); 872 struct ieee80211_ra_tid *ra_tid; 873 struct sk_buff *skb = dev_alloc_skb(0); 874 875 if (unlikely(!skb)) { 876 if (net_ratelimit()) 877 printk(KERN_WARNING "%s: Not enough memory, " 878 "dropping start BA session", skb->dev->name); 879 return; 880 } 881 ra_tid = (struct ieee80211_ra_tid *) &skb->cb; 882 memcpy(&ra_tid->ra, ra, ETH_ALEN); 883 ra_tid->tid = tid; 884 885 skb->pkt_type = IEEE80211_ADDBA_MSG; 886 skb_queue_tail(&local->skb_queue, skb); 887 tasklet_schedule(&local->tasklet); 888} 889EXPORT_SYMBOL(ieee80211_start_tx_ba_cb_irqsafe); 890 891void ieee80211_stop_tx_ba_cb_irqsafe(struct ieee80211_hw *hw, 892 const u8 *ra, u16 tid) 893{ 894 struct ieee80211_local *local = hw_to_local(hw); 895 struct ieee80211_ra_tid *ra_tid; 896 struct sk_buff *skb = dev_alloc_skb(0); 897 898 if (unlikely(!skb)) { 899 if (net_ratelimit()) 900 printk(KERN_WARNING "%s: Not enough memory, " 901 "dropping stop BA session", skb->dev->name); 902 return; 903 } 904 ra_tid = (struct ieee80211_ra_tid *) &skb->cb; 905 memcpy(&ra_tid->ra, ra, ETH_ALEN); 906 ra_tid->tid = tid; 907 908 skb->pkt_type = IEEE80211_DELBA_MSG; 909 skb_queue_tail(&local->skb_queue, skb); 910 tasklet_schedule(&local->tasklet); 911} 912EXPORT_SYMBOL(ieee80211_stop_tx_ba_cb_irqsafe); 913 914static void ieee80211_set_multicast_list(struct net_device *dev) 915{ 916 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 917 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 918 int allmulti, promisc, sdata_allmulti, sdata_promisc; 919 920 allmulti = !!(dev->flags & IFF_ALLMULTI); 921 promisc = !!(dev->flags & IFF_PROMISC); 922 sdata_allmulti = !!(sdata->flags & IEEE80211_SDATA_ALLMULTI); 923 sdata_promisc = !!(sdata->flags & IEEE80211_SDATA_PROMISC); 924 925 if (allmulti != sdata_allmulti) { 926 if (dev->flags & IFF_ALLMULTI) 927 atomic_inc(&local->iff_allmultis); 928 else 929 atomic_dec(&local->iff_allmultis); 930 sdata->flags ^= IEEE80211_SDATA_ALLMULTI; 931 } 932 933 if (promisc != sdata_promisc) { 934 if (dev->flags & IFF_PROMISC) 935 atomic_inc(&local->iff_promiscs); 936 else 937 atomic_dec(&local->iff_promiscs); 938 sdata->flags ^= IEEE80211_SDATA_PROMISC; 939 } 940 941 dev_mc_sync(local->mdev, dev); 942} 943 944static const struct header_ops ieee80211_header_ops = { 945 .create = eth_header, 946 .parse = header_parse_80211, 947 .rebuild = eth_rebuild_header, 948 .cache = eth_header_cache, 949 .cache_update = eth_header_cache_update, 950}; 951 952/* Must not be called for mdev */ 953void ieee80211_if_setup(struct net_device *dev) 954{ 955 ether_setup(dev); 956 dev->hard_start_xmit = ieee80211_subif_start_xmit; 957 dev->wireless_handlers = &ieee80211_iw_handler_def; 958 dev->set_multicast_list = ieee80211_set_multicast_list; 959 dev->change_mtu = ieee80211_change_mtu; 960 dev->open = ieee80211_open; 961 dev->stop = ieee80211_stop; 962 dev->destructor = ieee80211_if_free; 963} 964 965/* everything else */ 966 967static int __ieee80211_if_config(struct net_device *dev, 968 struct sk_buff *beacon, 969 struct ieee80211_tx_control *control) 970{ 971 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 972 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 973 struct ieee80211_if_conf conf; 974 975 if (!local->ops->config_interface || !netif_running(dev)) 976 return 0; 977 978 memset(&conf, 0, sizeof(conf)); 979 conf.type = sdata->vif.type; 980 if (sdata->vif.type == IEEE80211_IF_TYPE_STA || 981 sdata->vif.type == IEEE80211_IF_TYPE_IBSS) { 982 conf.bssid = sdata->u.sta.bssid; 983 conf.ssid = sdata->u.sta.ssid; 984 conf.ssid_len = sdata->u.sta.ssid_len; 985 } else if (ieee80211_vif_is_mesh(&sdata->vif)) { 986 conf.beacon = beacon; 987 conf.beacon_control = control; 988 ieee80211_start_mesh(dev); 989 } else if (sdata->vif.type == IEEE80211_IF_TYPE_AP) { 990 conf.ssid = sdata->u.ap.ssid; 991 conf.ssid_len = sdata->u.ap.ssid_len; 992 conf.beacon = beacon; 993 conf.beacon_control = control; 994 } 995 return local->ops->config_interface(local_to_hw(local), 996 &sdata->vif, &conf); 997} 998 999int ieee80211_if_config(struct net_device *dev) 1000{ 1001 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1002 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 1003 if (sdata->vif.type == IEEE80211_IF_TYPE_MESH_POINT && 1004 (local->hw.flags & IEEE80211_HW_HOST_GEN_BEACON_TEMPLATE)) 1005 return ieee80211_if_config_beacon(dev); 1006 return __ieee80211_if_config(dev, NULL, NULL); 1007} 1008 1009int ieee80211_if_config_beacon(struct net_device *dev) 1010{ 1011 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 1012 struct ieee80211_tx_control control; 1013 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1014 struct sk_buff *skb; 1015 1016 if (!(local->hw.flags & IEEE80211_HW_HOST_GEN_BEACON_TEMPLATE)) 1017 return 0; 1018 skb = ieee80211_beacon_get(local_to_hw(local), &sdata->vif, 1019 &control); 1020 if (!skb) 1021 return -ENOMEM; 1022 return __ieee80211_if_config(dev, skb, &control); 1023} 1024 1025int ieee80211_hw_config(struct ieee80211_local *local) 1026{ 1027 struct ieee80211_channel *chan; 1028 int ret = 0; 1029 1030 if (local->sta_sw_scanning) 1031 chan = local->scan_channel; 1032 else 1033 chan = local->oper_channel; 1034 1035 local->hw.conf.channel = chan; 1036 1037 if (!local->hw.conf.power_level) 1038 local->hw.conf.power_level = chan->max_power; 1039 else 1040 local->hw.conf.power_level = min(chan->max_power, 1041 local->hw.conf.power_level); 1042 1043 local->hw.conf.max_antenna_gain = chan->max_antenna_gain; 1044 1045#ifdef CONFIG_MAC80211_VERBOSE_DEBUG 1046 printk(KERN_DEBUG "%s: HW CONFIG: freq=%d\n", 1047 wiphy_name(local->hw.wiphy), chan->center_freq); 1048#endif 1049 1050 if (local->open_count) 1051 ret = local->ops->config(local_to_hw(local), &local->hw.conf); 1052 1053 return ret; 1054} 1055 1056/** 1057 * ieee80211_handle_ht should be used only after legacy configuration 1058 * has been determined namely band, as ht configuration depends upon 1059 * the hardware's HT abilities for a _specific_ band. 1060 */ 1061u32 ieee80211_handle_ht(struct ieee80211_local *local, int enable_ht, 1062 struct ieee80211_ht_info *req_ht_cap, 1063 struct ieee80211_ht_bss_info *req_bss_cap) 1064{ 1065 struct ieee80211_conf *conf = &local->hw.conf; 1066 struct ieee80211_supported_band *sband; 1067 struct ieee80211_ht_info ht_conf; 1068 struct ieee80211_ht_bss_info ht_bss_conf; 1069 u32 changed = 0; 1070 int i; 1071 u8 max_tx_streams = IEEE80211_HT_CAP_MAX_STREAMS; 1072 u8 tx_mcs_set_cap; 1073 1074 sband = local->hw.wiphy->bands[conf->channel->band]; 1075 1076 memset(&ht_conf, 0, sizeof(struct ieee80211_ht_info)); 1077 memset(&ht_bss_conf, 0, sizeof(struct ieee80211_ht_bss_info)); 1078 1079 /* HT is not supported */ 1080 if (!sband->ht_info.ht_supported) { 1081 conf->flags &= ~IEEE80211_CONF_SUPPORT_HT_MODE; 1082 goto out; 1083 } 1084 1085 /* disable HT */ 1086 if (!enable_ht) { 1087 if (conf->flags & IEEE80211_CONF_SUPPORT_HT_MODE) 1088 changed |= BSS_CHANGED_HT; 1089 conf->flags &= ~IEEE80211_CONF_SUPPORT_HT_MODE; 1090 conf->ht_conf.ht_supported = 0; 1091 goto out; 1092 } 1093 1094 1095 if (!(conf->flags & IEEE80211_CONF_SUPPORT_HT_MODE)) 1096 changed |= BSS_CHANGED_HT; 1097 1098 conf->flags |= IEEE80211_CONF_SUPPORT_HT_MODE; 1099 ht_conf.ht_supported = 1; 1100 1101 ht_conf.cap = req_ht_cap->cap & sband->ht_info.cap; 1102 ht_conf.cap &= ~(IEEE80211_HT_CAP_MIMO_PS); 1103 ht_conf.cap |= sband->ht_info.cap & IEEE80211_HT_CAP_MIMO_PS; 1104 ht_bss_conf.primary_channel = req_bss_cap->primary_channel; 1105 ht_bss_conf.bss_cap = req_bss_cap->bss_cap; 1106 ht_bss_conf.bss_op_mode = req_bss_cap->bss_op_mode; 1107 1108 ht_conf.ampdu_factor = req_ht_cap->ampdu_factor; 1109 ht_conf.ampdu_density = req_ht_cap->ampdu_density; 1110 1111 /* Bits 96-100 */ 1112 tx_mcs_set_cap = sband->ht_info.supp_mcs_set[12]; 1113 1114 /* configure suppoerted Tx MCS according to requested MCS 1115 * (based in most cases on Rx capabilities of peer) and self 1116 * Tx MCS capabilities (as defined by low level driver HW 1117 * Tx capabilities) */ 1118 if (!(tx_mcs_set_cap & IEEE80211_HT_CAP_MCS_TX_DEFINED)) 1119 goto check_changed; 1120 1121 /* Counting from 0 therfore + 1 */ 1122 if (tx_mcs_set_cap & IEEE80211_HT_CAP_MCS_TX_RX_DIFF) 1123 max_tx_streams = ((tx_mcs_set_cap & 1124 IEEE80211_HT_CAP_MCS_TX_STREAMS) >> 2) + 1; 1125 1126 for (i = 0; i < max_tx_streams; i++) 1127 ht_conf.supp_mcs_set[i] = 1128 sband->ht_info.supp_mcs_set[i] & 1129 req_ht_cap->supp_mcs_set[i]; 1130 1131 if (tx_mcs_set_cap & IEEE80211_HT_CAP_MCS_TX_UEQM) 1132 for (i = IEEE80211_SUPP_MCS_SET_UEQM; 1133 i < IEEE80211_SUPP_MCS_SET_LEN; i++) 1134 ht_conf.supp_mcs_set[i] = 1135 sband->ht_info.supp_mcs_set[i] & 1136 req_ht_cap->supp_mcs_set[i]; 1137 1138check_changed: 1139 /* if bss configuration changed store the new one */ 1140 if (memcmp(&conf->ht_conf, &ht_conf, sizeof(ht_conf)) || 1141 memcmp(&conf->ht_bss_conf, &ht_bss_conf, sizeof(ht_bss_conf))) { 1142 changed |= BSS_CHANGED_HT; 1143 memcpy(&conf->ht_conf, &ht_conf, sizeof(ht_conf)); 1144 memcpy(&conf->ht_bss_conf, &ht_bss_conf, sizeof(ht_bss_conf)); 1145 } 1146out: 1147 return changed; 1148} 1149 1150void ieee80211_bss_info_change_notify(struct ieee80211_sub_if_data *sdata, 1151 u32 changed) 1152{ 1153 struct ieee80211_local *local = sdata->local; 1154 1155 if (!changed) 1156 return; 1157 1158 if (local->ops->bss_info_changed) 1159 local->ops->bss_info_changed(local_to_hw(local), 1160 &sdata->vif, 1161 &sdata->bss_conf, 1162 changed); 1163} 1164 1165void ieee80211_reset_erp_info(struct net_device *dev) 1166{ 1167 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1168 1169 sdata->bss_conf.use_cts_prot = 0; 1170 sdata->bss_conf.use_short_preamble = 0; 1171 ieee80211_bss_info_change_notify(sdata, 1172 BSS_CHANGED_ERP_CTS_PROT | 1173 BSS_CHANGED_ERP_PREAMBLE); 1174} 1175 1176void ieee80211_tx_status_irqsafe(struct ieee80211_hw *hw, 1177 struct sk_buff *skb, 1178 struct ieee80211_tx_status *status) 1179{ 1180 struct ieee80211_local *local = hw_to_local(hw); 1181 struct ieee80211_tx_status *saved; 1182 int tmp; 1183 1184 skb->dev = local->mdev; 1185 saved = kmalloc(sizeof(struct ieee80211_tx_status), GFP_ATOMIC); 1186 if (unlikely(!saved)) { 1187 if (net_ratelimit()) 1188 printk(KERN_WARNING "%s: Not enough memory, " 1189 "dropping tx status", skb->dev->name); 1190 /* should be dev_kfree_skb_irq, but due to this function being 1191 * named _irqsafe instead of just _irq we can't be sure that 1192 * people won't call it from non-irq contexts */ 1193 dev_kfree_skb_any(skb); 1194 return; 1195 } 1196 memcpy(saved, status, sizeof(struct ieee80211_tx_status)); 1197 /* copy pointer to saved status into skb->cb for use by tasklet */ 1198 memcpy(skb->cb, &saved, sizeof(saved)); 1199 1200 skb->pkt_type = IEEE80211_TX_STATUS_MSG; 1201 skb_queue_tail(status->control.flags & IEEE80211_TXCTL_REQ_TX_STATUS ? 1202 &local->skb_queue : &local->skb_queue_unreliable, skb); 1203 tmp = skb_queue_len(&local->skb_queue) + 1204 skb_queue_len(&local->skb_queue_unreliable); 1205 while (tmp > IEEE80211_IRQSAFE_QUEUE_LIMIT && 1206 (skb = skb_dequeue(&local->skb_queue_unreliable))) { 1207 memcpy(&saved, skb->cb, sizeof(saved)); 1208 kfree(saved); 1209 dev_kfree_skb_irq(skb); 1210 tmp--; 1211 I802_DEBUG_INC(local->tx_status_drop); 1212 } 1213 tasklet_schedule(&local->tasklet); 1214} 1215EXPORT_SYMBOL(ieee80211_tx_status_irqsafe); 1216 1217static void ieee80211_tasklet_handler(unsigned long data) 1218{ 1219 struct ieee80211_local *local = (struct ieee80211_local *) data; 1220 struct sk_buff *skb; 1221 struct ieee80211_rx_status rx_status; 1222 struct ieee80211_tx_status *tx_status; 1223 struct ieee80211_ra_tid *ra_tid; 1224 1225 while ((skb = skb_dequeue(&local->skb_queue)) || 1226 (skb = skb_dequeue(&local->skb_queue_unreliable))) { 1227 switch (skb->pkt_type) { 1228 case IEEE80211_RX_MSG: 1229 /* status is in skb->cb */ 1230 memcpy(&rx_status, skb->cb, sizeof(rx_status)); 1231 /* Clear skb->pkt_type in order to not confuse kernel 1232 * netstack. */ 1233 skb->pkt_type = 0; 1234 __ieee80211_rx(local_to_hw(local), skb, &rx_status); 1235 break; 1236 case IEEE80211_TX_STATUS_MSG: 1237 /* get pointer to saved status out of skb->cb */ 1238 memcpy(&tx_status, skb->cb, sizeof(tx_status)); 1239 skb->pkt_type = 0; 1240 ieee80211_tx_status(local_to_hw(local), 1241 skb, tx_status); 1242 kfree(tx_status); 1243 break; 1244 case IEEE80211_DELBA_MSG: 1245 ra_tid = (struct ieee80211_ra_tid *) &skb->cb; 1246 ieee80211_stop_tx_ba_cb(local_to_hw(local), 1247 ra_tid->ra, ra_tid->tid); 1248 dev_kfree_skb(skb); 1249 break; 1250 case IEEE80211_ADDBA_MSG: 1251 ra_tid = (struct ieee80211_ra_tid *) &skb->cb; 1252 ieee80211_start_tx_ba_cb(local_to_hw(local), 1253 ra_tid->ra, ra_tid->tid); 1254 dev_kfree_skb(skb); 1255 break ; 1256 default: /* should never get here! */ 1257 printk(KERN_ERR "%s: Unknown message type (%d)\n", 1258 wiphy_name(local->hw.wiphy), skb->pkt_type); 1259 dev_kfree_skb(skb); 1260 break; 1261 } 1262 } 1263} 1264 1265/* Remove added headers (e.g., QoS control), encryption header/MIC, etc. to 1266 * make a prepared TX frame (one that has been given to hw) to look like brand 1267 * new IEEE 802.11 frame that is ready to go through TX processing again. 1268 * Also, tx_packet_data in cb is restored from tx_control. */ 1269static void ieee80211_remove_tx_extra(struct ieee80211_local *local, 1270 struct ieee80211_key *key, 1271 struct sk_buff *skb, 1272 struct ieee80211_tx_control *control) 1273{ 1274 int hdrlen, iv_len, mic_len; 1275 struct ieee80211_tx_packet_data *pkt_data; 1276 1277 pkt_data = (struct ieee80211_tx_packet_data *)skb->cb; 1278 pkt_data->ifindex = vif_to_sdata(control->vif)->dev->ifindex; 1279 pkt_data->flags = 0; 1280 if (control->flags & IEEE80211_TXCTL_REQ_TX_STATUS) 1281 pkt_data->flags |= IEEE80211_TXPD_REQ_TX_STATUS; 1282 if (control->flags & IEEE80211_TXCTL_DO_NOT_ENCRYPT) 1283 pkt_data->flags |= IEEE80211_TXPD_DO_NOT_ENCRYPT; 1284 if (control->flags & IEEE80211_TXCTL_REQUEUE) 1285 pkt_data->flags |= IEEE80211_TXPD_REQUEUE; 1286 if (control->flags & IEEE80211_TXCTL_EAPOL_FRAME) 1287 pkt_data->flags |= IEEE80211_TXPD_EAPOL_FRAME; 1288 pkt_data->queue = control->queue; 1289 1290 hdrlen = ieee80211_get_hdrlen_from_skb(skb); 1291 1292 if (!key) 1293 goto no_key; 1294 1295 switch (key->conf.alg) { 1296 case ALG_WEP: 1297 iv_len = WEP_IV_LEN; 1298 mic_len = WEP_ICV_LEN; 1299 break; 1300 case ALG_TKIP: 1301 iv_len = TKIP_IV_LEN; 1302 mic_len = TKIP_ICV_LEN; 1303 break; 1304 case ALG_CCMP: 1305 iv_len = CCMP_HDR_LEN; 1306 mic_len = CCMP_MIC_LEN; 1307 break; 1308 default: 1309 goto no_key; 1310 } 1311 1312 if (skb->len >= mic_len && 1313 !(key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE)) 1314 skb_trim(skb, skb->len - mic_len); 1315 if (skb->len >= iv_len && skb->len > hdrlen) { 1316 memmove(skb->data + iv_len, skb->data, hdrlen); 1317 skb_pull(skb, iv_len); 1318 } 1319 1320no_key: 1321 { 1322 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data; 1323 u16 fc = le16_to_cpu(hdr->frame_control); 1324 if ((fc & 0x8C) == 0x88) /* QoS Control Field */ { 1325 fc &= ~IEEE80211_STYPE_QOS_DATA; 1326 hdr->frame_control = cpu_to_le16(fc); 1327 memmove(skb->data + 2, skb->data, hdrlen - 2); 1328 skb_pull(skb, 2); 1329 } 1330 } 1331} 1332 1333static void ieee80211_handle_filtered_frame(struct ieee80211_local *local, 1334 struct sta_info *sta, 1335 struct sk_buff *skb, 1336 struct ieee80211_tx_status *status) 1337{ 1338 sta->tx_filtered_count++; 1339 1340 /* 1341 * Clear the TX filter mask for this STA when sending the next 1342 * packet. If the STA went to power save mode, this will happen 1343 * happen when it wakes up for the next time. 1344 */ 1345 set_sta_flags(sta, WLAN_STA_CLEAR_PS_FILT); 1346 1347 /* 1348 * This code races in the following way: 1349 * 1350 * (1) STA sends frame indicating it will go to sleep and does so 1351 * (2) hardware/firmware adds STA to filter list, passes frame up 1352 * (3) hardware/firmware processes TX fifo and suppresses a frame 1353 * (4) we get TX status before having processed the frame and 1354 * knowing that the STA has gone to sleep. 1355 * 1356 * This is actually quite unlikely even when both those events are 1357 * processed from interrupts coming in quickly after one another or 1358 * even at the same time because we queue both TX status events and 1359 * RX frames to be processed by a tasklet and process them in the 1360 * same order that they were received or TX status last. Hence, there 1361 * is no race as long as the frame RX is processed before the next TX 1362 * status, which drivers can ensure, see below. 1363 * 1364 * Note that this can only happen if the hardware or firmware can 1365 * actually add STAs to the filter list, if this is done by the 1366 * driver in response to set_tim() (which will only reduce the race 1367 * this whole filtering tries to solve, not completely solve it) 1368 * this situation cannot happen. 1369 * 1370 * To completely solve this race drivers need to make sure that they 1371 * (a) don't mix the irq-safe/not irq-safe TX status/RX processing 1372 * functions and 1373 * (b) always process RX events before TX status events if ordering 1374 * can be unknown, for example with different interrupt status 1375 * bits. 1376 */ 1377 if (test_sta_flags(sta, WLAN_STA_PS) && 1378 skb_queue_len(&sta->tx_filtered) < STA_MAX_TX_BUFFER) { 1379 ieee80211_remove_tx_extra(local, sta->key, skb, 1380 &status->control); 1381 skb_queue_tail(&sta->tx_filtered, skb); 1382 return; 1383 } 1384 1385 if (!test_sta_flags(sta, WLAN_STA_PS) && 1386 !(status->control.flags & IEEE80211_TXCTL_REQUEUE)) { 1387 /* Software retry the packet once */ 1388 status->control.flags |= IEEE80211_TXCTL_REQUEUE; 1389 ieee80211_remove_tx_extra(local, sta->key, skb, 1390 &status->control); 1391 dev_queue_xmit(skb); 1392 return; 1393 } 1394 1395 if (net_ratelimit()) 1396 printk(KERN_DEBUG "%s: dropped TX filtered frame, " 1397 "queue_len=%d PS=%d @%lu\n", 1398 wiphy_name(local->hw.wiphy), 1399 skb_queue_len(&sta->tx_filtered), 1400 !!test_sta_flags(sta, WLAN_STA_PS), jiffies); 1401 dev_kfree_skb(skb); 1402} 1403 1404void ieee80211_tx_status(struct ieee80211_hw *hw, struct sk_buff *skb, 1405 struct ieee80211_tx_status *status) 1406{ 1407 struct sk_buff *skb2; 1408 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data; 1409 struct ieee80211_local *local = hw_to_local(hw); 1410 u16 frag, type; 1411 struct ieee80211_tx_status_rtap_hdr *rthdr; 1412 struct ieee80211_sub_if_data *sdata; 1413 struct net_device *prev_dev = NULL; 1414 1415 if (!status) { 1416 printk(KERN_ERR 1417 "%s: ieee80211_tx_status called with NULL status\n", 1418 wiphy_name(local->hw.wiphy)); 1419 dev_kfree_skb(skb); 1420 return; 1421 } 1422 1423 rcu_read_lock(); 1424 1425 if (status->excessive_retries) { 1426 struct sta_info *sta; 1427 sta = sta_info_get(local, hdr->addr1); 1428 if (sta) { 1429 if (test_sta_flags(sta, WLAN_STA_PS)) { 1430 /* 1431 * The STA is in power save mode, so assume 1432 * that this TX packet failed because of that. 1433 */ 1434 status->excessive_retries = 0; 1435 status->flags |= IEEE80211_TX_STATUS_TX_FILTERED; 1436 ieee80211_handle_filtered_frame(local, sta, 1437 skb, status); 1438 rcu_read_unlock(); 1439 return; 1440 } 1441 } 1442 } 1443 1444 if (status->flags & IEEE80211_TX_STATUS_TX_FILTERED) { 1445 struct sta_info *sta; 1446 sta = sta_info_get(local, hdr->addr1); 1447 if (sta) { 1448 ieee80211_handle_filtered_frame(local, sta, skb, 1449 status); 1450 rcu_read_unlock(); 1451 return; 1452 } 1453 } else 1454 rate_control_tx_status(local->mdev, skb, status); 1455 1456 rcu_read_unlock(); 1457 1458 ieee80211_led_tx(local, 0); 1459 1460 /* SNMP counters 1461 * Fragments are passed to low-level drivers as separate skbs, so these 1462 * are actually fragments, not frames. Update frame counters only for 1463 * the first fragment of the frame. */ 1464 1465 frag = le16_to_cpu(hdr->seq_ctrl) & IEEE80211_SCTL_FRAG; 1466 type = le16_to_cpu(hdr->frame_control) & IEEE80211_FCTL_FTYPE; 1467 1468 if (status->flags & IEEE80211_TX_STATUS_ACK) { 1469 if (frag == 0) { 1470 local->dot11TransmittedFrameCount++; 1471 if (is_multicast_ether_addr(hdr->addr1)) 1472 local->dot11MulticastTransmittedFrameCount++; 1473 if (status->retry_count > 0) 1474 local->dot11RetryCount++; 1475 if (status->retry_count > 1) 1476 local->dot11MultipleRetryCount++; 1477 } 1478 1479 /* This counter shall be incremented for an acknowledged MPDU 1480 * with an individual address in the address 1 field or an MPDU 1481 * with a multicast address in the address 1 field of type Data 1482 * or Management. */ 1483 if (!is_multicast_ether_addr(hdr->addr1) || 1484 type == IEEE80211_FTYPE_DATA || 1485 type == IEEE80211_FTYPE_MGMT) 1486 local->dot11TransmittedFragmentCount++; 1487 } else { 1488 if (frag == 0) 1489 local->dot11FailedCount++; 1490 } 1491 1492 /* this was a transmitted frame, but now we want to reuse it */ 1493 skb_orphan(skb); 1494 1495 /* 1496 * This is a bit racy but we can avoid a lot of work 1497 * with this test... 1498 */ 1499 if (!local->monitors && !local->cooked_mntrs) { 1500 dev_kfree_skb(skb); 1501 return; 1502 } 1503 1504 /* send frame to monitor interfaces now */ 1505 1506 if (skb_headroom(skb) < sizeof(*rthdr)) { 1507 printk(KERN_ERR "ieee80211_tx_status: headroom too small\n"); 1508 dev_kfree_skb(skb); 1509 return; 1510 } 1511 1512 rthdr = (struct ieee80211_tx_status_rtap_hdr *) 1513 skb_push(skb, sizeof(*rthdr)); 1514 1515 memset(rthdr, 0, sizeof(*rthdr)); 1516 rthdr->hdr.it_len = cpu_to_le16(sizeof(*rthdr)); 1517 rthdr->hdr.it_present = 1518 cpu_to_le32((1 << IEEE80211_RADIOTAP_TX_FLAGS) | 1519 (1 << IEEE80211_RADIOTAP_DATA_RETRIES)); 1520 1521 if (!(status->flags & IEEE80211_TX_STATUS_ACK) && 1522 !is_multicast_ether_addr(hdr->addr1)) 1523 rthdr->tx_flags |= cpu_to_le16(IEEE80211_RADIOTAP_F_TX_FAIL); 1524 1525 if ((status->control.flags & IEEE80211_TXCTL_USE_RTS_CTS) && 1526 (status->control.flags & IEEE80211_TXCTL_USE_CTS_PROTECT)) 1527 rthdr->tx_flags |= cpu_to_le16(IEEE80211_RADIOTAP_F_TX_CTS); 1528 else if (status->control.flags & IEEE80211_TXCTL_USE_RTS_CTS) 1529 rthdr->tx_flags |= cpu_to_le16(IEEE80211_RADIOTAP_F_TX_RTS); 1530 1531 rthdr->data_retries = status->retry_count; 1532 1533 /* XXX: is this sufficient for BPF? */ 1534 skb_set_mac_header(skb, 0); 1535 skb->ip_summed = CHECKSUM_UNNECESSARY; 1536 skb->pkt_type = PACKET_OTHERHOST; 1537 skb->protocol = htons(ETH_P_802_2); 1538 memset(skb->cb, 0, sizeof(skb->cb)); 1539 1540 rcu_read_lock(); 1541 list_for_each_entry_rcu(sdata, &local->interfaces, list) { 1542 if (sdata->vif.type == IEEE80211_IF_TYPE_MNTR) { 1543 if (!netif_running(sdata->dev)) 1544 continue; 1545 1546 if (prev_dev) { 1547 skb2 = skb_clone(skb, GFP_ATOMIC); 1548 if (skb2) { 1549 skb2->dev = prev_dev; 1550 netif_rx(skb2); 1551 } 1552 } 1553 1554 prev_dev = sdata->dev; 1555 } 1556 } 1557 if (prev_dev) { 1558 skb->dev = prev_dev; 1559 netif_rx(skb); 1560 skb = NULL; 1561 } 1562 rcu_read_unlock(); 1563 dev_kfree_skb(skb); 1564} 1565EXPORT_SYMBOL(ieee80211_tx_status); 1566 1567struct ieee80211_hw *ieee80211_alloc_hw(size_t priv_data_len, 1568 const struct ieee80211_ops *ops) 1569{ 1570 struct ieee80211_local *local; 1571 int priv_size; 1572 struct wiphy *wiphy; 1573 1574 /* Ensure 32-byte alignment of our private data and hw private data. 1575 * We use the wiphy priv data for both our ieee80211_local and for 1576 * the driver's private data 1577 * 1578 * In memory it'll be like this: 1579 * 1580 * +-------------------------+ 1581 * | struct wiphy | 1582 * +-------------------------+ 1583 * | struct ieee80211_local | 1584 * +-------------------------+ 1585 * | driver's private data | 1586 * +-------------------------+ 1587 * 1588 */ 1589 priv_size = ((sizeof(struct ieee80211_local) + 1590 NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST) + 1591 priv_data_len; 1592 1593 wiphy = wiphy_new(&mac80211_config_ops, priv_size); 1594 1595 if (!wiphy) 1596 return NULL; 1597 1598 wiphy->privid = mac80211_wiphy_privid; 1599 1600 local = wiphy_priv(wiphy); 1601 local->hw.wiphy = wiphy; 1602 1603 local->hw.priv = (char *)local + 1604 ((sizeof(struct ieee80211_local) + 1605 NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST); 1606 1607 BUG_ON(!ops->tx); 1608 BUG_ON(!ops->start); 1609 BUG_ON(!ops->stop); 1610 BUG_ON(!ops->config); 1611 BUG_ON(!ops->add_interface); 1612 BUG_ON(!ops->remove_interface); 1613 BUG_ON(!ops->configure_filter); 1614 local->ops = ops; 1615 1616 local->hw.queues = 1; /* default */ 1617 1618 local->bridge_packets = 1; 1619 1620 local->rts_threshold = IEEE80211_MAX_RTS_THRESHOLD; 1621 local->fragmentation_threshold = IEEE80211_MAX_FRAG_THRESHOLD; 1622 local->short_retry_limit = 7; 1623 local->long_retry_limit = 4; 1624 local->hw.conf.radio_enabled = 1; 1625 1626 INIT_LIST_HEAD(&local->interfaces); 1627 1628 spin_lock_init(&local->key_lock); 1629 1630 INIT_DELAYED_WORK(&local->scan_work, ieee80211_sta_scan_work); 1631 1632 sta_info_init(local); 1633 1634 tasklet_init(&local->tx_pending_tasklet, ieee80211_tx_pending, 1635 (unsigned long)local); 1636 tasklet_disable(&local->tx_pending_tasklet); 1637 1638 tasklet_init(&local->tasklet, 1639 ieee80211_tasklet_handler, 1640 (unsigned long) local); 1641 tasklet_disable(&local->tasklet); 1642 1643 skb_queue_head_init(&local->skb_queue); 1644 skb_queue_head_init(&local->skb_queue_unreliable); 1645 1646 return local_to_hw(local); 1647} 1648EXPORT_SYMBOL(ieee80211_alloc_hw); 1649 1650int ieee80211_register_hw(struct ieee80211_hw *hw) 1651{ 1652 struct ieee80211_local *local = hw_to_local(hw); 1653 const char *name; 1654 int result; 1655 enum ieee80211_band band; 1656 struct net_device *mdev; 1657 struct ieee80211_sub_if_data *sdata; 1658 1659 /* 1660 * generic code guarantees at least one band, 1661 * set this very early because much code assumes 1662 * that hw.conf.channel is assigned 1663 */ 1664 for (band = 0; band < IEEE80211_NUM_BANDS; band++) { 1665 struct ieee80211_supported_band *sband; 1666 1667 sband = local->hw.wiphy->bands[band]; 1668 if (sband) { 1669 /* init channel we're on */ 1670 local->hw.conf.channel = 1671 local->oper_channel = 1672 local->scan_channel = &sband->channels[0]; 1673 break; 1674 } 1675 } 1676 1677 result = wiphy_register(local->hw.wiphy); 1678 if (result < 0) 1679 return result; 1680 1681 /* for now, mdev needs sub_if_data :/ */ 1682 mdev = alloc_netdev(sizeof(struct ieee80211_sub_if_data), 1683 "wmaster%d", ether_setup); 1684 if (!mdev) 1685 goto fail_mdev_alloc; 1686 1687 sdata = IEEE80211_DEV_TO_SUB_IF(mdev); 1688 mdev->ieee80211_ptr = &sdata->wdev; 1689 sdata->wdev.wiphy = local->hw.wiphy; 1690 1691 local->mdev = mdev; 1692 1693 ieee80211_rx_bss_list_init(mdev); 1694 1695 mdev->hard_start_xmit = ieee80211_master_start_xmit; 1696 mdev->open = ieee80211_master_open; 1697 mdev->stop = ieee80211_master_stop; 1698 mdev->type = ARPHRD_IEEE80211; 1699 mdev->header_ops = &ieee80211_header_ops; 1700 mdev->set_multicast_list = ieee80211_master_set_multicast_list; 1701 1702 sdata->vif.type = IEEE80211_IF_TYPE_AP; 1703 sdata->dev = mdev; 1704 sdata->local = local; 1705 sdata->u.ap.force_unicast_rateidx = -1; 1706 sdata->u.ap.max_ratectrl_rateidx = -1; 1707 ieee80211_if_sdata_init(sdata); 1708 1709 /* no RCU needed since we're still during init phase */ 1710 list_add_tail(&sdata->list, &local->interfaces); 1711 1712 name = wiphy_dev(local->hw.wiphy)->driver->name; 1713 local->hw.workqueue = create_singlethread_workqueue(name); 1714 if (!local->hw.workqueue) { 1715 result = -ENOMEM; 1716 goto fail_workqueue; 1717 } 1718 1719 /* 1720 * The hardware needs headroom for sending the frame, 1721 * and we need some headroom for passing the frame to monitor 1722 * interfaces, but never both at the same time. 1723 */ 1724 local->tx_headroom = max_t(unsigned int , local->hw.extra_tx_headroom, 1725 sizeof(struct ieee80211_tx_status_rtap_hdr)); 1726 1727 debugfs_hw_add(local); 1728 1729 local->hw.conf.beacon_int = 1000; 1730 1731 local->wstats_flags |= local->hw.flags & (IEEE80211_HW_SIGNAL_UNSPEC | 1732 IEEE80211_HW_SIGNAL_DB | 1733 IEEE80211_HW_SIGNAL_DBM) ? 1734 IW_QUAL_QUAL_UPDATED : IW_QUAL_QUAL_INVALID; 1735 local->wstats_flags |= local->hw.flags & IEEE80211_HW_NOISE_DBM ? 1736 IW_QUAL_NOISE_UPDATED : IW_QUAL_NOISE_INVALID; 1737 if (local->hw.flags & IEEE80211_HW_SIGNAL_DBM) 1738 local->wstats_flags |= IW_QUAL_DBM; 1739 1740 result = sta_info_start(local); 1741 if (result < 0) 1742 goto fail_sta_info; 1743 1744 rtnl_lock(); 1745 result = dev_alloc_name(local->mdev, local->mdev->name); 1746 if (result < 0) 1747 goto fail_dev; 1748 1749 memcpy(local->mdev->dev_addr, local->hw.wiphy->perm_addr, ETH_ALEN); 1750 SET_NETDEV_DEV(local->mdev, wiphy_dev(local->hw.wiphy)); 1751 1752 result = register_netdevice(local->mdev); 1753 if (result < 0) 1754 goto fail_dev; 1755 1756 ieee80211_debugfs_add_netdev(IEEE80211_DEV_TO_SUB_IF(local->mdev)); 1757 ieee80211_if_set_type(local->mdev, IEEE80211_IF_TYPE_AP); 1758 1759 result = ieee80211_init_rate_ctrl_alg(local, 1760 hw->rate_control_algorithm); 1761 if (result < 0) { 1762 printk(KERN_DEBUG "%s: Failed to initialize rate control " 1763 "algorithm\n", wiphy_name(local->hw.wiphy)); 1764 goto fail_rate; 1765 } 1766 1767 result = ieee80211_wep_init(local); 1768 1769 if (result < 0) { 1770 printk(KERN_DEBUG "%s: Failed to initialize wep\n", 1771 wiphy_name(local->hw.wiphy)); 1772 goto fail_wep; 1773 } 1774 1775 if (hw->queues > IEEE80211_MAX_QUEUES) 1776 hw->queues = IEEE80211_MAX_QUEUES; 1777 if (hw->ampdu_queues > IEEE80211_MAX_AMPDU_QUEUES) 1778 hw->ampdu_queues = IEEE80211_MAX_AMPDU_QUEUES; 1779 1780 ieee80211_install_qdisc(local->mdev); 1781 1782 /* add one default STA interface */ 1783 result = ieee80211_if_add(local->mdev, "wlan%d", NULL, 1784 IEEE80211_IF_TYPE_STA, NULL); 1785 if (result) 1786 printk(KERN_WARNING "%s: Failed to add default virtual iface\n", 1787 wiphy_name(local->hw.wiphy)); 1788 1789 local->reg_state = IEEE80211_DEV_REGISTERED; 1790 rtnl_unlock(); 1791 1792 ieee80211_led_init(local); 1793 1794 return 0; 1795 1796fail_wep: 1797 rate_control_deinitialize(local); 1798fail_rate: 1799 ieee80211_debugfs_remove_netdev(IEEE80211_DEV_TO_SUB_IF(local->mdev)); 1800 unregister_netdevice(local->mdev); 1801 local->mdev = NULL; 1802fail_dev: 1803 rtnl_unlock(); 1804 sta_info_stop(local); 1805fail_sta_info: 1806 debugfs_hw_del(local); 1807 destroy_workqueue(local->hw.workqueue); 1808fail_workqueue: 1809 if (local->mdev != NULL) { 1810 ieee80211_if_free(local->mdev); 1811 local->mdev = NULL; 1812 } 1813fail_mdev_alloc: 1814 wiphy_unregister(local->hw.wiphy); 1815 return result; 1816} 1817EXPORT_SYMBOL(ieee80211_register_hw); 1818 1819void ieee80211_unregister_hw(struct ieee80211_hw *hw) 1820{ 1821 struct ieee80211_local *local = hw_to_local(hw); 1822 struct ieee80211_sub_if_data *sdata, *tmp; 1823 1824 tasklet_kill(&local->tx_pending_tasklet); 1825 tasklet_kill(&local->tasklet); 1826 1827 rtnl_lock(); 1828 1829 BUG_ON(local->reg_state != IEEE80211_DEV_REGISTERED); 1830 1831 local->reg_state = IEEE80211_DEV_UNREGISTERED; 1832 1833 /* 1834 * At this point, interface list manipulations are fine 1835 * because the driver cannot be handing us frames any 1836 * more and the tasklet is killed. 1837 */ 1838 1839 /* 1840 * First, we remove all non-master interfaces. Do this because they 1841 * may have bss pointer dependency on the master, and when we free 1842 * the master these would be freed as well, breaking our list 1843 * iteration completely. 1844 */ 1845 list_for_each_entry_safe(sdata, tmp, &local->interfaces, list) { 1846 if (sdata->dev == local->mdev) 1847 continue; 1848 list_del(&sdata->list); 1849 __ieee80211_if_del(local, sdata); 1850 } 1851 1852 /* then, finally, remove the master interface */ 1853 __ieee80211_if_del(local, IEEE80211_DEV_TO_SUB_IF(local->mdev)); 1854 1855 rtnl_unlock(); 1856 1857 ieee80211_rx_bss_list_deinit(local->mdev); 1858 ieee80211_clear_tx_pending(local); 1859 sta_info_stop(local); 1860 rate_control_deinitialize(local); 1861 debugfs_hw_del(local); 1862 1863 if (skb_queue_len(&local->skb_queue) 1864 || skb_queue_len(&local->skb_queue_unreliable)) 1865 printk(KERN_WARNING "%s: skb_queue not empty\n", 1866 wiphy_name(local->hw.wiphy)); 1867 skb_queue_purge(&local->skb_queue); 1868 skb_queue_purge(&local->skb_queue_unreliable); 1869 1870 destroy_workqueue(local->hw.workqueue); 1871 wiphy_unregister(local->hw.wiphy); 1872 ieee80211_wep_free(local); 1873 ieee80211_led_exit(local); 1874 ieee80211_if_free(local->mdev); 1875 local->mdev = NULL; 1876} 1877EXPORT_SYMBOL(ieee80211_unregister_hw); 1878 1879void ieee80211_free_hw(struct ieee80211_hw *hw) 1880{ 1881 struct ieee80211_local *local = hw_to_local(hw); 1882 1883 wiphy_free(local->hw.wiphy); 1884} 1885EXPORT_SYMBOL(ieee80211_free_hw); 1886 1887static int __init ieee80211_init(void) 1888{ 1889 struct sk_buff *skb; 1890 int ret; 1891 1892 BUILD_BUG_ON(sizeof(struct ieee80211_tx_packet_data) > sizeof(skb->cb)); 1893 1894 ret = rc80211_pid_init(); 1895 if (ret) 1896 goto out; 1897 1898 ret = ieee80211_wme_register(); 1899 if (ret) { 1900 printk(KERN_DEBUG "ieee80211_init: failed to " 1901 "initialize WME (err=%d)\n", ret); 1902 goto out_cleanup_pid; 1903 } 1904 1905 ieee80211_debugfs_netdev_init(); 1906 1907 return 0; 1908 1909 out_cleanup_pid: 1910 rc80211_pid_exit(); 1911 out: 1912 return ret; 1913} 1914 1915static void __exit ieee80211_exit(void) 1916{ 1917 rc80211_pid_exit(); 1918 1919 /* 1920 * For key todo, it'll be empty by now but the work 1921 * might still be scheduled. 1922 */ 1923 flush_scheduled_work(); 1924 1925 if (mesh_allocated) 1926 ieee80211s_stop(); 1927 1928 ieee80211_wme_unregister(); 1929 ieee80211_debugfs_netdev_exit(); 1930} 1931 1932 1933subsys_initcall(ieee80211_init); 1934module_exit(ieee80211_exit); 1935 1936MODULE_DESCRIPTION("IEEE 802.11 subsystem"); 1937MODULE_LICENSE("GPL"); 1938