main.c revision 05c914fe330fa8e1cc67870dc0d3809dfd96c107
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 (netif_running(sdata->dev)) { 109 res = 0; 110 break; 111 } 112 } 113 114 if (res) 115 return res; 116 117 netif_tx_start_all_queues(local->mdev); 118 119 return 0; 120} 121 122static int ieee80211_master_stop(struct net_device *dev) 123{ 124 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 125 struct ieee80211_sub_if_data *sdata; 126 127 /* we hold the RTNL here so can safely walk the list */ 128 list_for_each_entry(sdata, &local->interfaces, list) 129 if (netif_running(sdata->dev)) 130 dev_close(sdata->dev); 131 132 return 0; 133} 134 135static void ieee80211_master_set_multicast_list(struct net_device *dev) 136{ 137 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 138 139 ieee80211_configure_filter(local); 140} 141 142/* regular interfaces */ 143 144static int ieee80211_change_mtu(struct net_device *dev, int new_mtu) 145{ 146 int meshhdrlen; 147 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 148 149 meshhdrlen = (sdata->vif.type == NL80211_IFTYPE_MESH_POINT) ? 5 : 0; 150 151 /* FIX: what would be proper limits for MTU? 152 * This interface uses 802.3 frames. */ 153 if (new_mtu < 256 || 154 new_mtu > IEEE80211_MAX_DATA_LEN - 24 - 6 - meshhdrlen) { 155 return -EINVAL; 156 } 157 158#ifdef CONFIG_MAC80211_VERBOSE_DEBUG 159 printk(KERN_DEBUG "%s: setting MTU %d\n", dev->name, new_mtu); 160#endif /* CONFIG_MAC80211_VERBOSE_DEBUG */ 161 dev->mtu = new_mtu; 162 return 0; 163} 164 165static inline int identical_mac_addr_allowed(int type1, int type2) 166{ 167 return type1 == NL80211_IFTYPE_MONITOR || 168 type2 == NL80211_IFTYPE_MONITOR || 169 (type1 == NL80211_IFTYPE_AP && type2 == NL80211_IFTYPE_WDS) || 170 (type1 == NL80211_IFTYPE_WDS && 171 (type2 == NL80211_IFTYPE_WDS || 172 type2 == NL80211_IFTYPE_AP)) || 173 (type1 == NL80211_IFTYPE_AP && type2 == NL80211_IFTYPE_AP_VLAN) || 174 (type1 == NL80211_IFTYPE_AP_VLAN && 175 (type2 == NL80211_IFTYPE_AP || 176 type2 == NL80211_IFTYPE_AP_VLAN)); 177} 178 179static int ieee80211_open(struct net_device *dev) 180{ 181 struct ieee80211_sub_if_data *sdata, *nsdata; 182 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 183 struct sta_info *sta; 184 struct ieee80211_if_init_conf conf; 185 u32 changed = 0; 186 int res; 187 bool need_hw_reconfig = 0; 188 u8 null_addr[ETH_ALEN] = {0}; 189 190 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 191 192 /* fail early if user set an invalid address */ 193 if (compare_ether_addr(dev->dev_addr, null_addr) && 194 !is_valid_ether_addr(dev->dev_addr)) 195 return -EADDRNOTAVAIL; 196 197 /* we hold the RTNL here so can safely walk the list */ 198 list_for_each_entry(nsdata, &local->interfaces, list) { 199 struct net_device *ndev = nsdata->dev; 200 201 if (ndev != dev && netif_running(ndev)) { 202 /* 203 * Allow only a single IBSS interface to be up at any 204 * time. This is restricted because beacon distribution 205 * cannot work properly if both are in the same IBSS. 206 * 207 * To remove this restriction we'd have to disallow them 208 * from setting the same SSID on different IBSS interfaces 209 * belonging to the same hardware. Then, however, we're 210 * faced with having to adopt two different TSF timers... 211 */ 212 if (sdata->vif.type == NL80211_IFTYPE_ADHOC && 213 nsdata->vif.type == NL80211_IFTYPE_ADHOC) 214 return -EBUSY; 215 216 /* 217 * The remaining checks are only performed for interfaces 218 * with the same MAC address. 219 */ 220 if (compare_ether_addr(dev->dev_addr, ndev->dev_addr)) 221 continue; 222 223 /* 224 * check whether it may have the same address 225 */ 226 if (!identical_mac_addr_allowed(sdata->vif.type, 227 nsdata->vif.type)) 228 return -ENOTUNIQ; 229 230 /* 231 * can only add VLANs to enabled APs 232 */ 233 if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN && 234 nsdata->vif.type == NL80211_IFTYPE_AP) 235 sdata->bss = &nsdata->u.ap; 236 } 237 } 238 239 switch (sdata->vif.type) { 240 case NL80211_IFTYPE_WDS: 241 if (!is_valid_ether_addr(sdata->u.wds.remote_addr)) 242 return -ENOLINK; 243 break; 244 case NL80211_IFTYPE_AP_VLAN: 245 if (!sdata->bss) 246 return -ENOLINK; 247 list_add(&sdata->u.vlan.list, &sdata->bss->vlans); 248 break; 249 case NL80211_IFTYPE_AP: 250 sdata->bss = &sdata->u.ap; 251 break; 252 case NL80211_IFTYPE_MESH_POINT: 253 if (!ieee80211_vif_is_mesh(&sdata->vif)) 254 break; 255 /* mesh ifaces must set allmulti to forward mcast traffic */ 256 atomic_inc(&local->iff_allmultis); 257 break; 258 case NL80211_IFTYPE_STATION: 259 case NL80211_IFTYPE_MONITOR: 260 case NL80211_IFTYPE_ADHOC: 261 /* no special treatment */ 262 break; 263 case NL80211_IFTYPE_UNSPECIFIED: 264 case __NL80211_IFTYPE_AFTER_LAST: 265 /* cannot happen */ 266 WARN_ON(1); 267 break; 268 } 269 270 if (local->open_count == 0) { 271 res = 0; 272 if (local->ops->start) 273 res = local->ops->start(local_to_hw(local)); 274 if (res) 275 goto err_del_bss; 276 need_hw_reconfig = 1; 277 ieee80211_led_radio(local, local->hw.conf.radio_enabled); 278 } 279 280 /* 281 * Check all interfaces and copy the hopefully now-present 282 * MAC address to those that have the special null one. 283 */ 284 list_for_each_entry(nsdata, &local->interfaces, list) { 285 struct net_device *ndev = nsdata->dev; 286 287 /* 288 * No need to check netif_running since we do not allow 289 * it to start up with this invalid address. 290 */ 291 if (compare_ether_addr(null_addr, ndev->dev_addr) == 0) 292 memcpy(ndev->dev_addr, 293 local->hw.wiphy->perm_addr, 294 ETH_ALEN); 295 } 296 297 if (compare_ether_addr(null_addr, local->mdev->dev_addr) == 0) 298 memcpy(local->mdev->dev_addr, local->hw.wiphy->perm_addr, 299 ETH_ALEN); 300 301 /* 302 * Validate the MAC address for this device. 303 */ 304 if (!is_valid_ether_addr(dev->dev_addr)) { 305 if (!local->open_count && local->ops->stop) 306 local->ops->stop(local_to_hw(local)); 307 return -EADDRNOTAVAIL; 308 } 309 310 switch (sdata->vif.type) { 311 case NL80211_IFTYPE_AP_VLAN: 312 /* no need to tell driver */ 313 break; 314 case NL80211_IFTYPE_MONITOR: 315 if (sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES) { 316 local->cooked_mntrs++; 317 break; 318 } 319 320 /* must be before the call to ieee80211_configure_filter */ 321 local->monitors++; 322 if (local->monitors == 1) 323 local->hw.conf.flags |= IEEE80211_CONF_RADIOTAP; 324 325 if (sdata->u.mntr_flags & MONITOR_FLAG_FCSFAIL) 326 local->fif_fcsfail++; 327 if (sdata->u.mntr_flags & MONITOR_FLAG_PLCPFAIL) 328 local->fif_plcpfail++; 329 if (sdata->u.mntr_flags & MONITOR_FLAG_CONTROL) 330 local->fif_control++; 331 if (sdata->u.mntr_flags & MONITOR_FLAG_OTHER_BSS) 332 local->fif_other_bss++; 333 334 netif_addr_lock_bh(local->mdev); 335 ieee80211_configure_filter(local); 336 netif_addr_unlock_bh(local->mdev); 337 break; 338 case NL80211_IFTYPE_STATION: 339 case NL80211_IFTYPE_ADHOC: 340 sdata->u.sta.flags &= ~IEEE80211_STA_PREV_BSSID_SET; 341 /* fall through */ 342 default: 343 conf.vif = &sdata->vif; 344 conf.type = sdata->vif.type; 345 conf.mac_addr = dev->dev_addr; 346 res = local->ops->add_interface(local_to_hw(local), &conf); 347 if (res) 348 goto err_stop; 349 350 if (ieee80211_vif_is_mesh(&sdata->vif)) 351 ieee80211_start_mesh(sdata); 352 changed |= ieee80211_reset_erp_info(sdata); 353 ieee80211_bss_info_change_notify(sdata, changed); 354 ieee80211_enable_keys(sdata); 355 356 if (sdata->vif.type == NL80211_IFTYPE_STATION && 357 !(sdata->flags & IEEE80211_SDATA_USERSPACE_MLME)) 358 netif_carrier_off(dev); 359 else 360 netif_carrier_on(dev); 361 } 362 363 if (sdata->vif.type == NL80211_IFTYPE_WDS) { 364 /* Create STA entry for the WDS peer */ 365 sta = sta_info_alloc(sdata, sdata->u.wds.remote_addr, 366 GFP_KERNEL); 367 if (!sta) { 368 res = -ENOMEM; 369 goto err_del_interface; 370 } 371 372 /* no locking required since STA is not live yet */ 373 sta->flags |= WLAN_STA_AUTHORIZED; 374 375 res = sta_info_insert(sta); 376 if (res) { 377 /* STA has been freed */ 378 goto err_del_interface; 379 } 380 } 381 382 if (local->open_count == 0) { 383 res = dev_open(local->mdev); 384 WARN_ON(res); 385 if (res) 386 goto err_del_interface; 387 tasklet_enable(&local->tx_pending_tasklet); 388 tasklet_enable(&local->tasklet); 389 } 390 391 /* 392 * set_multicast_list will be invoked by the networking core 393 * which will check whether any increments here were done in 394 * error and sync them down to the hardware as filter flags. 395 */ 396 if (sdata->flags & IEEE80211_SDATA_ALLMULTI) 397 atomic_inc(&local->iff_allmultis); 398 399 if (sdata->flags & IEEE80211_SDATA_PROMISC) 400 atomic_inc(&local->iff_promiscs); 401 402 local->open_count++; 403 if (need_hw_reconfig) { 404 ieee80211_hw_config(local); 405 /* 406 * set default queue parameters so drivers don't 407 * need to initialise the hardware if the hardware 408 * doesn't start up with sane defaults 409 */ 410 ieee80211_set_wmm_default(sdata); 411 } 412 413 /* 414 * ieee80211_sta_work is disabled while network interface 415 * is down. Therefore, some configuration changes may not 416 * yet be effective. Trigger execution of ieee80211_sta_work 417 * to fix this. 418 */ 419 if (sdata->vif.type == NL80211_IFTYPE_STATION || 420 sdata->vif.type == NL80211_IFTYPE_ADHOC) { 421 struct ieee80211_if_sta *ifsta = &sdata->u.sta; 422 queue_work(local->hw.workqueue, &ifsta->work); 423 } 424 425 netif_tx_start_all_queues(dev); 426 427 return 0; 428 err_del_interface: 429 local->ops->remove_interface(local_to_hw(local), &conf); 430 err_stop: 431 if (!local->open_count && local->ops->stop) 432 local->ops->stop(local_to_hw(local)); 433 err_del_bss: 434 sdata->bss = NULL; 435 if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) 436 list_del(&sdata->u.vlan.list); 437 return res; 438} 439 440static int ieee80211_stop(struct net_device *dev) 441{ 442 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 443 struct ieee80211_local *local = sdata->local; 444 struct ieee80211_if_init_conf conf; 445 struct sta_info *sta; 446 447 /* 448 * Stop TX on this interface first. 449 */ 450 netif_tx_stop_all_queues(dev); 451 452 /* 453 * Now delete all active aggregation sessions. 454 */ 455 rcu_read_lock(); 456 457 list_for_each_entry_rcu(sta, &local->sta_list, list) { 458 if (sta->sdata == sdata) 459 ieee80211_sta_tear_down_BA_sessions(sdata, sta->addr); 460 } 461 462 rcu_read_unlock(); 463 464 /* 465 * Remove all stations associated with this interface. 466 * 467 * This must be done before calling ops->remove_interface() 468 * because otherwise we can later invoke ops->sta_notify() 469 * whenever the STAs are removed, and that invalidates driver 470 * assumptions about always getting a vif pointer that is valid 471 * (because if we remove a STA after ops->remove_interface() 472 * the driver will have removed the vif info already!) 473 * 474 * We could relax this and only unlink the stations from the 475 * hash table and list but keep them on a per-sdata list that 476 * will be inserted back again when the interface is brought 477 * up again, but I don't currently see a use case for that, 478 * except with WDS which gets a STA entry created when it is 479 * brought up. 480 */ 481 sta_info_flush(local, sdata); 482 483 /* 484 * Don't count this interface for promisc/allmulti while it 485 * is down. dev_mc_unsync() will invoke set_multicast_list 486 * on the master interface which will sync these down to the 487 * hardware as filter flags. 488 */ 489 if (sdata->flags & IEEE80211_SDATA_ALLMULTI) 490 atomic_dec(&local->iff_allmultis); 491 492 if (sdata->flags & IEEE80211_SDATA_PROMISC) 493 atomic_dec(&local->iff_promiscs); 494 495 dev_mc_unsync(local->mdev, dev); 496 497 /* APs need special treatment */ 498 if (sdata->vif.type == NL80211_IFTYPE_AP) { 499 struct ieee80211_sub_if_data *vlan, *tmp; 500 struct beacon_data *old_beacon = sdata->u.ap.beacon; 501 502 /* remove beacon */ 503 rcu_assign_pointer(sdata->u.ap.beacon, NULL); 504 synchronize_rcu(); 505 kfree(old_beacon); 506 507 /* down all dependent devices, that is VLANs */ 508 list_for_each_entry_safe(vlan, tmp, &sdata->u.ap.vlans, 509 u.vlan.list) 510 dev_close(vlan->dev); 511 WARN_ON(!list_empty(&sdata->u.ap.vlans)); 512 } 513 514 local->open_count--; 515 516 switch (sdata->vif.type) { 517 case NL80211_IFTYPE_AP_VLAN: 518 list_del(&sdata->u.vlan.list); 519 /* no need to tell driver */ 520 break; 521 case NL80211_IFTYPE_MONITOR: 522 if (sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES) { 523 local->cooked_mntrs--; 524 break; 525 } 526 527 local->monitors--; 528 if (local->monitors == 0) 529 local->hw.conf.flags &= ~IEEE80211_CONF_RADIOTAP; 530 531 if (sdata->u.mntr_flags & MONITOR_FLAG_FCSFAIL) 532 local->fif_fcsfail--; 533 if (sdata->u.mntr_flags & MONITOR_FLAG_PLCPFAIL) 534 local->fif_plcpfail--; 535 if (sdata->u.mntr_flags & MONITOR_FLAG_CONTROL) 536 local->fif_control--; 537 if (sdata->u.mntr_flags & MONITOR_FLAG_OTHER_BSS) 538 local->fif_other_bss--; 539 540 netif_addr_lock_bh(local->mdev); 541 ieee80211_configure_filter(local); 542 netif_addr_unlock_bh(local->mdev); 543 break; 544 case NL80211_IFTYPE_STATION: 545 case NL80211_IFTYPE_ADHOC: 546 sdata->u.sta.state = IEEE80211_STA_MLME_DISABLED; 547 memset(sdata->u.sta.bssid, 0, ETH_ALEN); 548 del_timer_sync(&sdata->u.sta.timer); 549 /* 550 * If the timer fired while we waited for it, it will have 551 * requeued the work. Now the work will be running again 552 * but will not rearm the timer again because it checks 553 * whether the interface is running, which, at this point, 554 * it no longer is. 555 */ 556 cancel_work_sync(&sdata->u.sta.work); 557 /* 558 * When we get here, the interface is marked down. 559 * Call synchronize_rcu() to wait for the RX path 560 * should it be using the interface and enqueuing 561 * frames at this very time on another CPU. 562 */ 563 synchronize_rcu(); 564 skb_queue_purge(&sdata->u.sta.skb_queue); 565 566 sdata->u.sta.flags &= ~IEEE80211_STA_PRIVACY_INVOKED; 567 kfree(sdata->u.sta.extra_ie); 568 sdata->u.sta.extra_ie = NULL; 569 sdata->u.sta.extra_ie_len = 0; 570 /* fall through */ 571 case NL80211_IFTYPE_MESH_POINT: 572 if (ieee80211_vif_is_mesh(&sdata->vif)) { 573 /* allmulti is always set on mesh ifaces */ 574 atomic_dec(&local->iff_allmultis); 575 ieee80211_stop_mesh(sdata); 576 } 577 /* fall through */ 578 default: 579 if (local->scan_sdata == sdata) { 580 if (!local->ops->hw_scan) 581 cancel_delayed_work_sync(&local->scan_work); 582 /* 583 * The software scan can no longer run now, so we can 584 * clear out the scan_sdata reference. However, the 585 * hardware scan may still be running. The complete 586 * function must be prepared to handle a NULL value. 587 */ 588 local->scan_sdata = NULL; 589 /* 590 * The memory barrier guarantees that another CPU 591 * that is hardware-scanning will now see the fact 592 * that this interface is gone. 593 */ 594 smp_mb(); 595 /* 596 * If software scanning, complete the scan but since 597 * the scan_sdata is NULL already don't send out a 598 * scan event to userspace -- the scan is incomplete. 599 */ 600 if (local->sw_scanning) 601 ieee80211_scan_completed(&local->hw); 602 } 603 604 conf.vif = &sdata->vif; 605 conf.type = sdata->vif.type; 606 conf.mac_addr = dev->dev_addr; 607 /* disable all keys for as long as this netdev is down */ 608 ieee80211_disable_keys(sdata); 609 local->ops->remove_interface(local_to_hw(local), &conf); 610 } 611 612 sdata->bss = NULL; 613 614 if (local->open_count == 0) { 615 if (netif_running(local->mdev)) 616 dev_close(local->mdev); 617 618 if (local->ops->stop) 619 local->ops->stop(local_to_hw(local)); 620 621 ieee80211_led_radio(local, 0); 622 623 flush_workqueue(local->hw.workqueue); 624 625 tasklet_disable(&local->tx_pending_tasklet); 626 tasklet_disable(&local->tasklet); 627 } 628 629 return 0; 630} 631 632static void ieee80211_set_multicast_list(struct net_device *dev) 633{ 634 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 635 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 636 int allmulti, promisc, sdata_allmulti, sdata_promisc; 637 638 allmulti = !!(dev->flags & IFF_ALLMULTI); 639 promisc = !!(dev->flags & IFF_PROMISC); 640 sdata_allmulti = !!(sdata->flags & IEEE80211_SDATA_ALLMULTI); 641 sdata_promisc = !!(sdata->flags & IEEE80211_SDATA_PROMISC); 642 643 if (allmulti != sdata_allmulti) { 644 if (dev->flags & IFF_ALLMULTI) 645 atomic_inc(&local->iff_allmultis); 646 else 647 atomic_dec(&local->iff_allmultis); 648 sdata->flags ^= IEEE80211_SDATA_ALLMULTI; 649 } 650 651 if (promisc != sdata_promisc) { 652 if (dev->flags & IFF_PROMISC) 653 atomic_inc(&local->iff_promiscs); 654 else 655 atomic_dec(&local->iff_promiscs); 656 sdata->flags ^= IEEE80211_SDATA_PROMISC; 657 } 658 659 dev_mc_sync(local->mdev, dev); 660} 661 662static const struct header_ops ieee80211_header_ops = { 663 .create = eth_header, 664 .parse = header_parse_80211, 665 .rebuild = eth_rebuild_header, 666 .cache = eth_header_cache, 667 .cache_update = eth_header_cache_update, 668}; 669 670void ieee80211_if_setup(struct net_device *dev) 671{ 672 ether_setup(dev); 673 dev->hard_start_xmit = ieee80211_subif_start_xmit; 674 dev->wireless_handlers = &ieee80211_iw_handler_def; 675 dev->set_multicast_list = ieee80211_set_multicast_list; 676 dev->change_mtu = ieee80211_change_mtu; 677 dev->open = ieee80211_open; 678 dev->stop = ieee80211_stop; 679 dev->destructor = free_netdev; 680 /* we will validate the address ourselves in ->open */ 681 dev->validate_addr = NULL; 682} 683 684/* everything else */ 685 686int ieee80211_if_config(struct ieee80211_sub_if_data *sdata, u32 changed) 687{ 688 struct ieee80211_local *local = sdata->local; 689 struct ieee80211_if_conf conf; 690 691 if (WARN_ON(!netif_running(sdata->dev))) 692 return 0; 693 694 if (!local->ops->config_interface) 695 return 0; 696 697 memset(&conf, 0, sizeof(conf)); 698 conf.changed = changed; 699 700 if (sdata->vif.type == NL80211_IFTYPE_STATION || 701 sdata->vif.type == NL80211_IFTYPE_ADHOC) { 702 conf.bssid = sdata->u.sta.bssid; 703 conf.ssid = sdata->u.sta.ssid; 704 conf.ssid_len = sdata->u.sta.ssid_len; 705 } else if (sdata->vif.type == NL80211_IFTYPE_AP) { 706 conf.bssid = sdata->dev->dev_addr; 707 conf.ssid = sdata->u.ap.ssid; 708 conf.ssid_len = sdata->u.ap.ssid_len; 709 } else if (ieee80211_vif_is_mesh(&sdata->vif)) { 710 u8 zero[ETH_ALEN] = { 0 }; 711 conf.bssid = zero; 712 conf.ssid = zero; 713 conf.ssid_len = 0; 714 } else { 715 WARN_ON(1); 716 return -EINVAL; 717 } 718 719 if (WARN_ON(!conf.bssid && (changed & IEEE80211_IFCC_BSSID))) 720 return -EINVAL; 721 722 if (WARN_ON(!conf.ssid && (changed & IEEE80211_IFCC_SSID))) 723 return -EINVAL; 724 725 return local->ops->config_interface(local_to_hw(local), 726 &sdata->vif, &conf); 727} 728 729int ieee80211_hw_config(struct ieee80211_local *local) 730{ 731 struct ieee80211_channel *chan; 732 int ret = 0; 733 734 if (local->sw_scanning) 735 chan = local->scan_channel; 736 else 737 chan = local->oper_channel; 738 739 local->hw.conf.channel = chan; 740 741 if (!local->hw.conf.power_level) 742 local->hw.conf.power_level = chan->max_power; 743 else 744 local->hw.conf.power_level = min(chan->max_power, 745 local->hw.conf.power_level); 746 747 local->hw.conf.max_antenna_gain = chan->max_antenna_gain; 748 749#ifdef CONFIG_MAC80211_VERBOSE_DEBUG 750 printk(KERN_DEBUG "%s: HW CONFIG: freq=%d\n", 751 wiphy_name(local->hw.wiphy), chan->center_freq); 752#endif 753 754 if (local->open_count) 755 ret = local->ops->config(local_to_hw(local), &local->hw.conf); 756 757 return ret; 758} 759 760/** 761 * ieee80211_handle_ht should be used only after legacy configuration 762 * has been determined namely band, as ht configuration depends upon 763 * the hardware's HT abilities for a _specific_ band. 764 */ 765u32 ieee80211_handle_ht(struct ieee80211_local *local, int enable_ht, 766 struct ieee80211_ht_info *req_ht_cap, 767 struct ieee80211_ht_bss_info *req_bss_cap) 768{ 769 struct ieee80211_conf *conf = &local->hw.conf; 770 struct ieee80211_supported_band *sband; 771 struct ieee80211_ht_info ht_conf; 772 struct ieee80211_ht_bss_info ht_bss_conf; 773 u32 changed = 0; 774 int i; 775 u8 max_tx_streams = IEEE80211_HT_CAP_MAX_STREAMS; 776 u8 tx_mcs_set_cap; 777 778 sband = local->hw.wiphy->bands[conf->channel->band]; 779 780 memset(&ht_conf, 0, sizeof(struct ieee80211_ht_info)); 781 memset(&ht_bss_conf, 0, sizeof(struct ieee80211_ht_bss_info)); 782 783 /* HT is not supported */ 784 if (!sband->ht_info.ht_supported) { 785 conf->flags &= ~IEEE80211_CONF_SUPPORT_HT_MODE; 786 goto out; 787 } 788 789 /* disable HT */ 790 if (!enable_ht) { 791 if (conf->flags & IEEE80211_CONF_SUPPORT_HT_MODE) 792 changed |= BSS_CHANGED_HT; 793 conf->flags &= ~IEEE80211_CONF_SUPPORT_HT_MODE; 794 conf->ht_conf.ht_supported = 0; 795 goto out; 796 } 797 798 799 if (!(conf->flags & IEEE80211_CONF_SUPPORT_HT_MODE)) 800 changed |= BSS_CHANGED_HT; 801 802 conf->flags |= IEEE80211_CONF_SUPPORT_HT_MODE; 803 ht_conf.ht_supported = 1; 804 805 ht_conf.cap = req_ht_cap->cap & sband->ht_info.cap; 806 ht_conf.cap &= ~(IEEE80211_HT_CAP_SM_PS); 807 ht_conf.cap |= sband->ht_info.cap & IEEE80211_HT_CAP_SM_PS; 808 ht_bss_conf.primary_channel = req_bss_cap->primary_channel; 809 ht_bss_conf.bss_cap = req_bss_cap->bss_cap; 810 ht_bss_conf.bss_op_mode = req_bss_cap->bss_op_mode; 811 812 ht_conf.ampdu_factor = req_ht_cap->ampdu_factor; 813 ht_conf.ampdu_density = req_ht_cap->ampdu_density; 814 815 /* Bits 96-100 */ 816 tx_mcs_set_cap = sband->ht_info.supp_mcs_set[12]; 817 818 /* configure suppoerted Tx MCS according to requested MCS 819 * (based in most cases on Rx capabilities of peer) and self 820 * Tx MCS capabilities (as defined by low level driver HW 821 * Tx capabilities) */ 822 if (!(tx_mcs_set_cap & IEEE80211_HT_CAP_MCS_TX_DEFINED)) 823 goto check_changed; 824 825 /* Counting from 0 therfore + 1 */ 826 if (tx_mcs_set_cap & IEEE80211_HT_CAP_MCS_TX_RX_DIFF) 827 max_tx_streams = ((tx_mcs_set_cap & 828 IEEE80211_HT_CAP_MCS_TX_STREAMS) >> 2) + 1; 829 830 for (i = 0; i < max_tx_streams; i++) 831 ht_conf.supp_mcs_set[i] = 832 sband->ht_info.supp_mcs_set[i] & 833 req_ht_cap->supp_mcs_set[i]; 834 835 if (tx_mcs_set_cap & IEEE80211_HT_CAP_MCS_TX_UEQM) 836 for (i = IEEE80211_SUPP_MCS_SET_UEQM; 837 i < IEEE80211_SUPP_MCS_SET_LEN; i++) 838 ht_conf.supp_mcs_set[i] = 839 sband->ht_info.supp_mcs_set[i] & 840 req_ht_cap->supp_mcs_set[i]; 841 842check_changed: 843 /* if bss configuration changed store the new one */ 844 if (memcmp(&conf->ht_conf, &ht_conf, sizeof(ht_conf)) || 845 memcmp(&conf->ht_bss_conf, &ht_bss_conf, sizeof(ht_bss_conf))) { 846 changed |= BSS_CHANGED_HT; 847 memcpy(&conf->ht_conf, &ht_conf, sizeof(ht_conf)); 848 memcpy(&conf->ht_bss_conf, &ht_bss_conf, sizeof(ht_bss_conf)); 849 } 850out: 851 return changed; 852} 853 854void ieee80211_bss_info_change_notify(struct ieee80211_sub_if_data *sdata, 855 u32 changed) 856{ 857 struct ieee80211_local *local = sdata->local; 858 859 if (!changed) 860 return; 861 862 if (local->ops->bss_info_changed) 863 local->ops->bss_info_changed(local_to_hw(local), 864 &sdata->vif, 865 &sdata->bss_conf, 866 changed); 867} 868 869u32 ieee80211_reset_erp_info(struct ieee80211_sub_if_data *sdata) 870{ 871 sdata->bss_conf.use_cts_prot = 0; 872 sdata->bss_conf.use_short_preamble = 0; 873 return BSS_CHANGED_ERP_CTS_PROT | BSS_CHANGED_ERP_PREAMBLE; 874} 875 876void ieee80211_tx_status_irqsafe(struct ieee80211_hw *hw, 877 struct sk_buff *skb) 878{ 879 struct ieee80211_local *local = hw_to_local(hw); 880 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 881 int tmp; 882 883 skb->dev = local->mdev; 884 skb->pkt_type = IEEE80211_TX_STATUS_MSG; 885 skb_queue_tail(info->flags & IEEE80211_TX_CTL_REQ_TX_STATUS ? 886 &local->skb_queue : &local->skb_queue_unreliable, skb); 887 tmp = skb_queue_len(&local->skb_queue) + 888 skb_queue_len(&local->skb_queue_unreliable); 889 while (tmp > IEEE80211_IRQSAFE_QUEUE_LIMIT && 890 (skb = skb_dequeue(&local->skb_queue_unreliable))) { 891 dev_kfree_skb_irq(skb); 892 tmp--; 893 I802_DEBUG_INC(local->tx_status_drop); 894 } 895 tasklet_schedule(&local->tasklet); 896} 897EXPORT_SYMBOL(ieee80211_tx_status_irqsafe); 898 899static void ieee80211_tasklet_handler(unsigned long data) 900{ 901 struct ieee80211_local *local = (struct ieee80211_local *) data; 902 struct sk_buff *skb; 903 struct ieee80211_rx_status rx_status; 904 struct ieee80211_ra_tid *ra_tid; 905 906 while ((skb = skb_dequeue(&local->skb_queue)) || 907 (skb = skb_dequeue(&local->skb_queue_unreliable))) { 908 switch (skb->pkt_type) { 909 case IEEE80211_RX_MSG: 910 /* status is in skb->cb */ 911 memcpy(&rx_status, skb->cb, sizeof(rx_status)); 912 /* Clear skb->pkt_type in order to not confuse kernel 913 * netstack. */ 914 skb->pkt_type = 0; 915 __ieee80211_rx(local_to_hw(local), skb, &rx_status); 916 break; 917 case IEEE80211_TX_STATUS_MSG: 918 skb->pkt_type = 0; 919 ieee80211_tx_status(local_to_hw(local), skb); 920 break; 921 case IEEE80211_DELBA_MSG: 922 ra_tid = (struct ieee80211_ra_tid *) &skb->cb; 923 ieee80211_stop_tx_ba_cb(local_to_hw(local), 924 ra_tid->ra, ra_tid->tid); 925 dev_kfree_skb(skb); 926 break; 927 case IEEE80211_ADDBA_MSG: 928 ra_tid = (struct ieee80211_ra_tid *) &skb->cb; 929 ieee80211_start_tx_ba_cb(local_to_hw(local), 930 ra_tid->ra, ra_tid->tid); 931 dev_kfree_skb(skb); 932 break ; 933 default: 934 WARN_ON(1); 935 dev_kfree_skb(skb); 936 break; 937 } 938 } 939} 940 941/* Remove added headers (e.g., QoS control), encryption header/MIC, etc. to 942 * make a prepared TX frame (one that has been given to hw) to look like brand 943 * new IEEE 802.11 frame that is ready to go through TX processing again. 944 */ 945static void ieee80211_remove_tx_extra(struct ieee80211_local *local, 946 struct ieee80211_key *key, 947 struct sk_buff *skb) 948{ 949 unsigned int hdrlen, iv_len, mic_len; 950 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 951 952 hdrlen = ieee80211_hdrlen(hdr->frame_control); 953 954 if (!key) 955 goto no_key; 956 957 switch (key->conf.alg) { 958 case ALG_WEP: 959 iv_len = WEP_IV_LEN; 960 mic_len = WEP_ICV_LEN; 961 break; 962 case ALG_TKIP: 963 iv_len = TKIP_IV_LEN; 964 mic_len = TKIP_ICV_LEN; 965 break; 966 case ALG_CCMP: 967 iv_len = CCMP_HDR_LEN; 968 mic_len = CCMP_MIC_LEN; 969 break; 970 default: 971 goto no_key; 972 } 973 974 if (skb->len >= hdrlen + mic_len && 975 !(key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE)) 976 skb_trim(skb, skb->len - mic_len); 977 if (skb->len >= hdrlen + iv_len) { 978 memmove(skb->data + iv_len, skb->data, hdrlen); 979 hdr = (struct ieee80211_hdr *)skb_pull(skb, iv_len); 980 } 981 982no_key: 983 if (ieee80211_is_data_qos(hdr->frame_control)) { 984 hdr->frame_control &= ~cpu_to_le16(IEEE80211_STYPE_QOS_DATA); 985 memmove(skb->data + IEEE80211_QOS_CTL_LEN, skb->data, 986 hdrlen - IEEE80211_QOS_CTL_LEN); 987 skb_pull(skb, IEEE80211_QOS_CTL_LEN); 988 } 989} 990 991static void ieee80211_handle_filtered_frame(struct ieee80211_local *local, 992 struct sta_info *sta, 993 struct sk_buff *skb) 994{ 995 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 996 997 sta->tx_filtered_count++; 998 999 /* 1000 * Clear the TX filter mask for this STA when sending the next 1001 * packet. If the STA went to power save mode, this will happen 1002 * when it wakes up for the next time. 1003 */ 1004 set_sta_flags(sta, WLAN_STA_CLEAR_PS_FILT); 1005 1006 /* 1007 * This code races in the following way: 1008 * 1009 * (1) STA sends frame indicating it will go to sleep and does so 1010 * (2) hardware/firmware adds STA to filter list, passes frame up 1011 * (3) hardware/firmware processes TX fifo and suppresses a frame 1012 * (4) we get TX status before having processed the frame and 1013 * knowing that the STA has gone to sleep. 1014 * 1015 * This is actually quite unlikely even when both those events are 1016 * processed from interrupts coming in quickly after one another or 1017 * even at the same time because we queue both TX status events and 1018 * RX frames to be processed by a tasklet and process them in the 1019 * same order that they were received or TX status last. Hence, there 1020 * is no race as long as the frame RX is processed before the next TX 1021 * status, which drivers can ensure, see below. 1022 * 1023 * Note that this can only happen if the hardware or firmware can 1024 * actually add STAs to the filter list, if this is done by the 1025 * driver in response to set_tim() (which will only reduce the race 1026 * this whole filtering tries to solve, not completely solve it) 1027 * this situation cannot happen. 1028 * 1029 * To completely solve this race drivers need to make sure that they 1030 * (a) don't mix the irq-safe/not irq-safe TX status/RX processing 1031 * functions and 1032 * (b) always process RX events before TX status events if ordering 1033 * can be unknown, for example with different interrupt status 1034 * bits. 1035 */ 1036 if (test_sta_flags(sta, WLAN_STA_PS) && 1037 skb_queue_len(&sta->tx_filtered) < STA_MAX_TX_BUFFER) { 1038 ieee80211_remove_tx_extra(local, sta->key, skb); 1039 skb_queue_tail(&sta->tx_filtered, skb); 1040 return; 1041 } 1042 1043 if (!test_sta_flags(sta, WLAN_STA_PS) && 1044 !(info->flags & IEEE80211_TX_CTL_REQUEUE)) { 1045 /* Software retry the packet once */ 1046 info->flags |= IEEE80211_TX_CTL_REQUEUE; 1047 ieee80211_remove_tx_extra(local, sta->key, skb); 1048 dev_queue_xmit(skb); 1049 return; 1050 } 1051 1052#ifdef CONFIG_MAC80211_VERBOSE_DEBUG 1053 if (net_ratelimit()) 1054 printk(KERN_DEBUG "%s: dropped TX filtered frame, " 1055 "queue_len=%d PS=%d @%lu\n", 1056 wiphy_name(local->hw.wiphy), 1057 skb_queue_len(&sta->tx_filtered), 1058 !!test_sta_flags(sta, WLAN_STA_PS), jiffies); 1059#endif 1060 dev_kfree_skb(skb); 1061} 1062 1063void ieee80211_tx_status(struct ieee80211_hw *hw, struct sk_buff *skb) 1064{ 1065 struct sk_buff *skb2; 1066 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data; 1067 struct ieee80211_local *local = hw_to_local(hw); 1068 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 1069 u16 frag, type; 1070 __le16 fc; 1071 struct ieee80211_tx_status_rtap_hdr *rthdr; 1072 struct ieee80211_sub_if_data *sdata; 1073 struct net_device *prev_dev = NULL; 1074 struct sta_info *sta; 1075 1076 rcu_read_lock(); 1077 1078 if (info->status.excessive_retries) { 1079 sta = sta_info_get(local, hdr->addr1); 1080 if (sta) { 1081 if (test_sta_flags(sta, WLAN_STA_PS)) { 1082 /* 1083 * The STA is in power save mode, so assume 1084 * that this TX packet failed because of that. 1085 */ 1086 ieee80211_handle_filtered_frame(local, sta, skb); 1087 rcu_read_unlock(); 1088 return; 1089 } 1090 } 1091 } 1092 1093 fc = hdr->frame_control; 1094 1095 if ((info->flags & IEEE80211_TX_STAT_AMPDU_NO_BACK) && 1096 (ieee80211_is_data_qos(fc))) { 1097 u16 tid, ssn; 1098 u8 *qc; 1099 sta = sta_info_get(local, hdr->addr1); 1100 if (sta) { 1101 qc = ieee80211_get_qos_ctl(hdr); 1102 tid = qc[0] & 0xf; 1103 ssn = ((le16_to_cpu(hdr->seq_ctrl) + 0x10) 1104 & IEEE80211_SCTL_SEQ); 1105 ieee80211_send_bar(sta->sdata, hdr->addr1, 1106 tid, ssn); 1107 } 1108 } 1109 1110 if (info->flags & IEEE80211_TX_STAT_TX_FILTERED) { 1111 sta = sta_info_get(local, hdr->addr1); 1112 if (sta) { 1113 ieee80211_handle_filtered_frame(local, sta, skb); 1114 rcu_read_unlock(); 1115 return; 1116 } 1117 } else 1118 rate_control_tx_status(local->mdev, skb); 1119 1120 rcu_read_unlock(); 1121 1122 ieee80211_led_tx(local, 0); 1123 1124 /* SNMP counters 1125 * Fragments are passed to low-level drivers as separate skbs, so these 1126 * are actually fragments, not frames. Update frame counters only for 1127 * the first fragment of the frame. */ 1128 1129 frag = le16_to_cpu(hdr->seq_ctrl) & IEEE80211_SCTL_FRAG; 1130 type = le16_to_cpu(hdr->frame_control) & IEEE80211_FCTL_FTYPE; 1131 1132 if (info->flags & IEEE80211_TX_STAT_ACK) { 1133 if (frag == 0) { 1134 local->dot11TransmittedFrameCount++; 1135 if (is_multicast_ether_addr(hdr->addr1)) 1136 local->dot11MulticastTransmittedFrameCount++; 1137 if (info->status.retry_count > 0) 1138 local->dot11RetryCount++; 1139 if (info->status.retry_count > 1) 1140 local->dot11MultipleRetryCount++; 1141 } 1142 1143 /* This counter shall be incremented for an acknowledged MPDU 1144 * with an individual address in the address 1 field or an MPDU 1145 * with a multicast address in the address 1 field of type Data 1146 * or Management. */ 1147 if (!is_multicast_ether_addr(hdr->addr1) || 1148 type == IEEE80211_FTYPE_DATA || 1149 type == IEEE80211_FTYPE_MGMT) 1150 local->dot11TransmittedFragmentCount++; 1151 } else { 1152 if (frag == 0) 1153 local->dot11FailedCount++; 1154 } 1155 1156 /* this was a transmitted frame, but now we want to reuse it */ 1157 skb_orphan(skb); 1158 1159 /* 1160 * This is a bit racy but we can avoid a lot of work 1161 * with this test... 1162 */ 1163 if (!local->monitors && !local->cooked_mntrs) { 1164 dev_kfree_skb(skb); 1165 return; 1166 } 1167 1168 /* send frame to monitor interfaces now */ 1169 1170 if (skb_headroom(skb) < sizeof(*rthdr)) { 1171 printk(KERN_ERR "ieee80211_tx_status: headroom too small\n"); 1172 dev_kfree_skb(skb); 1173 return; 1174 } 1175 1176 rthdr = (struct ieee80211_tx_status_rtap_hdr *) 1177 skb_push(skb, sizeof(*rthdr)); 1178 1179 memset(rthdr, 0, sizeof(*rthdr)); 1180 rthdr->hdr.it_len = cpu_to_le16(sizeof(*rthdr)); 1181 rthdr->hdr.it_present = 1182 cpu_to_le32((1 << IEEE80211_RADIOTAP_TX_FLAGS) | 1183 (1 << IEEE80211_RADIOTAP_DATA_RETRIES)); 1184 1185 if (!(info->flags & IEEE80211_TX_STAT_ACK) && 1186 !is_multicast_ether_addr(hdr->addr1)) 1187 rthdr->tx_flags |= cpu_to_le16(IEEE80211_RADIOTAP_F_TX_FAIL); 1188 1189 if ((info->flags & IEEE80211_TX_CTL_USE_RTS_CTS) && 1190 (info->flags & IEEE80211_TX_CTL_USE_CTS_PROTECT)) 1191 rthdr->tx_flags |= cpu_to_le16(IEEE80211_RADIOTAP_F_TX_CTS); 1192 else if (info->flags & IEEE80211_TX_CTL_USE_RTS_CTS) 1193 rthdr->tx_flags |= cpu_to_le16(IEEE80211_RADIOTAP_F_TX_RTS); 1194 1195 rthdr->data_retries = info->status.retry_count; 1196 1197 /* XXX: is this sufficient for BPF? */ 1198 skb_set_mac_header(skb, 0); 1199 skb->ip_summed = CHECKSUM_UNNECESSARY; 1200 skb->pkt_type = PACKET_OTHERHOST; 1201 skb->protocol = htons(ETH_P_802_2); 1202 memset(skb->cb, 0, sizeof(skb->cb)); 1203 1204 rcu_read_lock(); 1205 list_for_each_entry_rcu(sdata, &local->interfaces, list) { 1206 if (sdata->vif.type == NL80211_IFTYPE_MONITOR) { 1207 if (!netif_running(sdata->dev)) 1208 continue; 1209 1210 if (prev_dev) { 1211 skb2 = skb_clone(skb, GFP_ATOMIC); 1212 if (skb2) { 1213 skb2->dev = prev_dev; 1214 netif_rx(skb2); 1215 } 1216 } 1217 1218 prev_dev = sdata->dev; 1219 } 1220 } 1221 if (prev_dev) { 1222 skb->dev = prev_dev; 1223 netif_rx(skb); 1224 skb = NULL; 1225 } 1226 rcu_read_unlock(); 1227 dev_kfree_skb(skb); 1228} 1229EXPORT_SYMBOL(ieee80211_tx_status); 1230 1231struct ieee80211_hw *ieee80211_alloc_hw(size_t priv_data_len, 1232 const struct ieee80211_ops *ops) 1233{ 1234 struct ieee80211_local *local; 1235 int priv_size; 1236 struct wiphy *wiphy; 1237 1238 /* Ensure 32-byte alignment of our private data and hw private data. 1239 * We use the wiphy priv data for both our ieee80211_local and for 1240 * the driver's private data 1241 * 1242 * In memory it'll be like this: 1243 * 1244 * +-------------------------+ 1245 * | struct wiphy | 1246 * +-------------------------+ 1247 * | struct ieee80211_local | 1248 * +-------------------------+ 1249 * | driver's private data | 1250 * +-------------------------+ 1251 * 1252 */ 1253 priv_size = ((sizeof(struct ieee80211_local) + 1254 NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST) + 1255 priv_data_len; 1256 1257 wiphy = wiphy_new(&mac80211_config_ops, priv_size); 1258 1259 if (!wiphy) 1260 return NULL; 1261 1262 wiphy->privid = mac80211_wiphy_privid; 1263 1264 local = wiphy_priv(wiphy); 1265 local->hw.wiphy = wiphy; 1266 1267 local->hw.priv = (char *)local + 1268 ((sizeof(struct ieee80211_local) + 1269 NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST); 1270 1271 BUG_ON(!ops->tx); 1272 BUG_ON(!ops->start); 1273 BUG_ON(!ops->stop); 1274 BUG_ON(!ops->config); 1275 BUG_ON(!ops->add_interface); 1276 BUG_ON(!ops->remove_interface); 1277 BUG_ON(!ops->configure_filter); 1278 local->ops = ops; 1279 1280 local->hw.queues = 1; /* default */ 1281 1282 local->rts_threshold = IEEE80211_MAX_RTS_THRESHOLD; 1283 local->fragmentation_threshold = IEEE80211_MAX_FRAG_THRESHOLD; 1284 local->short_retry_limit = 7; 1285 local->long_retry_limit = 4; 1286 local->hw.conf.radio_enabled = 1; 1287 1288 INIT_LIST_HEAD(&local->interfaces); 1289 1290 spin_lock_init(&local->key_lock); 1291 1292 INIT_DELAYED_WORK(&local->scan_work, ieee80211_scan_work); 1293 1294 sta_info_init(local); 1295 1296 tasklet_init(&local->tx_pending_tasklet, ieee80211_tx_pending, 1297 (unsigned long)local); 1298 tasklet_disable(&local->tx_pending_tasklet); 1299 1300 tasklet_init(&local->tasklet, 1301 ieee80211_tasklet_handler, 1302 (unsigned long) local); 1303 tasklet_disable(&local->tasklet); 1304 1305 skb_queue_head_init(&local->skb_queue); 1306 skb_queue_head_init(&local->skb_queue_unreliable); 1307 1308 return local_to_hw(local); 1309} 1310EXPORT_SYMBOL(ieee80211_alloc_hw); 1311 1312int ieee80211_register_hw(struct ieee80211_hw *hw) 1313{ 1314 struct ieee80211_local *local = hw_to_local(hw); 1315 const char *name; 1316 int result; 1317 enum ieee80211_band band; 1318 struct net_device *mdev; 1319 struct wireless_dev *mwdev; 1320 1321 /* 1322 * generic code guarantees at least one band, 1323 * set this very early because much code assumes 1324 * that hw.conf.channel is assigned 1325 */ 1326 for (band = 0; band < IEEE80211_NUM_BANDS; band++) { 1327 struct ieee80211_supported_band *sband; 1328 1329 sband = local->hw.wiphy->bands[band]; 1330 if (sband) { 1331 /* init channel we're on */ 1332 local->hw.conf.channel = 1333 local->oper_channel = 1334 local->scan_channel = &sband->channels[0]; 1335 break; 1336 } 1337 } 1338 1339 /* if low-level driver supports AP, we also support VLAN */ 1340 if (local->hw.wiphy->interface_modes & BIT(NL80211_IFTYPE_AP)) 1341 local->hw.wiphy->interface_modes |= BIT(NL80211_IFTYPE_AP_VLAN); 1342 1343 /* mac80211 always supports monitor */ 1344 local->hw.wiphy->interface_modes |= BIT(NL80211_IFTYPE_MONITOR); 1345 1346 result = wiphy_register(local->hw.wiphy); 1347 if (result < 0) 1348 return result; 1349 1350 /* 1351 * We use the number of queues for feature tests (QoS, HT) internally 1352 * so restrict them appropriately. 1353 */ 1354 if (hw->queues > IEEE80211_MAX_QUEUES) 1355 hw->queues = IEEE80211_MAX_QUEUES; 1356 if (hw->ampdu_queues > IEEE80211_MAX_AMPDU_QUEUES) 1357 hw->ampdu_queues = IEEE80211_MAX_AMPDU_QUEUES; 1358 if (hw->queues < 4) 1359 hw->ampdu_queues = 0; 1360 1361 mdev = alloc_netdev_mq(sizeof(struct wireless_dev), 1362 "wmaster%d", ether_setup, 1363 ieee80211_num_queues(hw)); 1364 if (!mdev) 1365 goto fail_mdev_alloc; 1366 1367 mwdev = netdev_priv(mdev); 1368 mdev->ieee80211_ptr = mwdev; 1369 mwdev->wiphy = local->hw.wiphy; 1370 1371 local->mdev = mdev; 1372 1373 ieee80211_rx_bss_list_init(local); 1374 1375 mdev->hard_start_xmit = ieee80211_master_start_xmit; 1376 mdev->open = ieee80211_master_open; 1377 mdev->stop = ieee80211_master_stop; 1378 mdev->type = ARPHRD_IEEE80211; 1379 mdev->header_ops = &ieee80211_header_ops; 1380 mdev->set_multicast_list = ieee80211_master_set_multicast_list; 1381 1382 name = wiphy_dev(local->hw.wiphy)->driver->name; 1383 local->hw.workqueue = create_freezeable_workqueue(name); 1384 if (!local->hw.workqueue) { 1385 result = -ENOMEM; 1386 goto fail_workqueue; 1387 } 1388 1389 /* 1390 * The hardware needs headroom for sending the frame, 1391 * and we need some headroom for passing the frame to monitor 1392 * interfaces, but never both at the same time. 1393 */ 1394 local->tx_headroom = max_t(unsigned int , local->hw.extra_tx_headroom, 1395 sizeof(struct ieee80211_tx_status_rtap_hdr)); 1396 1397 debugfs_hw_add(local); 1398 1399 if (local->hw.conf.beacon_int < 10) 1400 local->hw.conf.beacon_int = 100; 1401 1402 if (local->hw.max_listen_interval == 0) 1403 local->hw.max_listen_interval = 1; 1404 1405 local->hw.conf.listen_interval = local->hw.max_listen_interval; 1406 1407 local->wstats_flags |= local->hw.flags & (IEEE80211_HW_SIGNAL_UNSPEC | 1408 IEEE80211_HW_SIGNAL_DB | 1409 IEEE80211_HW_SIGNAL_DBM) ? 1410 IW_QUAL_QUAL_UPDATED : IW_QUAL_QUAL_INVALID; 1411 local->wstats_flags |= local->hw.flags & IEEE80211_HW_NOISE_DBM ? 1412 IW_QUAL_NOISE_UPDATED : IW_QUAL_NOISE_INVALID; 1413 if (local->hw.flags & IEEE80211_HW_SIGNAL_DBM) 1414 local->wstats_flags |= IW_QUAL_DBM; 1415 1416 result = sta_info_start(local); 1417 if (result < 0) 1418 goto fail_sta_info; 1419 1420 rtnl_lock(); 1421 result = dev_alloc_name(local->mdev, local->mdev->name); 1422 if (result < 0) 1423 goto fail_dev; 1424 1425 memcpy(local->mdev->dev_addr, local->hw.wiphy->perm_addr, ETH_ALEN); 1426 SET_NETDEV_DEV(local->mdev, wiphy_dev(local->hw.wiphy)); 1427 1428 result = register_netdevice(local->mdev); 1429 if (result < 0) 1430 goto fail_dev; 1431 1432 result = ieee80211_init_rate_ctrl_alg(local, 1433 hw->rate_control_algorithm); 1434 if (result < 0) { 1435 printk(KERN_DEBUG "%s: Failed to initialize rate control " 1436 "algorithm\n", wiphy_name(local->hw.wiphy)); 1437 goto fail_rate; 1438 } 1439 1440 result = ieee80211_wep_init(local); 1441 1442 if (result < 0) { 1443 printk(KERN_DEBUG "%s: Failed to initialize wep: %d\n", 1444 wiphy_name(local->hw.wiphy), result); 1445 goto fail_wep; 1446 } 1447 1448 local->mdev->select_queue = ieee80211_select_queue; 1449 1450 /* add one default STA interface */ 1451 result = ieee80211_if_add(local, "wlan%d", NULL, 1452 NL80211_IFTYPE_STATION, NULL); 1453 if (result) 1454 printk(KERN_WARNING "%s: Failed to add default virtual iface\n", 1455 wiphy_name(local->hw.wiphy)); 1456 1457 rtnl_unlock(); 1458 1459 ieee80211_led_init(local); 1460 1461 return 0; 1462 1463fail_wep: 1464 rate_control_deinitialize(local); 1465fail_rate: 1466 unregister_netdevice(local->mdev); 1467 local->mdev = NULL; 1468fail_dev: 1469 rtnl_unlock(); 1470 sta_info_stop(local); 1471fail_sta_info: 1472 debugfs_hw_del(local); 1473 destroy_workqueue(local->hw.workqueue); 1474fail_workqueue: 1475 if (local->mdev) 1476 free_netdev(local->mdev); 1477fail_mdev_alloc: 1478 wiphy_unregister(local->hw.wiphy); 1479 return result; 1480} 1481EXPORT_SYMBOL(ieee80211_register_hw); 1482 1483void ieee80211_unregister_hw(struct ieee80211_hw *hw) 1484{ 1485 struct ieee80211_local *local = hw_to_local(hw); 1486 1487 tasklet_kill(&local->tx_pending_tasklet); 1488 tasklet_kill(&local->tasklet); 1489 1490 rtnl_lock(); 1491 1492 /* 1493 * At this point, interface list manipulations are fine 1494 * because the driver cannot be handing us frames any 1495 * more and the tasklet is killed. 1496 */ 1497 1498 /* First, we remove all virtual interfaces. */ 1499 ieee80211_remove_interfaces(local); 1500 1501 /* then, finally, remove the master interface */ 1502 unregister_netdevice(local->mdev); 1503 1504 rtnl_unlock(); 1505 1506 ieee80211_rx_bss_list_deinit(local); 1507 ieee80211_clear_tx_pending(local); 1508 sta_info_stop(local); 1509 rate_control_deinitialize(local); 1510 debugfs_hw_del(local); 1511 1512 if (skb_queue_len(&local->skb_queue) 1513 || skb_queue_len(&local->skb_queue_unreliable)) 1514 printk(KERN_WARNING "%s: skb_queue not empty\n", 1515 wiphy_name(local->hw.wiphy)); 1516 skb_queue_purge(&local->skb_queue); 1517 skb_queue_purge(&local->skb_queue_unreliable); 1518 1519 destroy_workqueue(local->hw.workqueue); 1520 wiphy_unregister(local->hw.wiphy); 1521 ieee80211_wep_free(local); 1522 ieee80211_led_exit(local); 1523 free_netdev(local->mdev); 1524} 1525EXPORT_SYMBOL(ieee80211_unregister_hw); 1526 1527void ieee80211_free_hw(struct ieee80211_hw *hw) 1528{ 1529 struct ieee80211_local *local = hw_to_local(hw); 1530 1531 wiphy_free(local->hw.wiphy); 1532} 1533EXPORT_SYMBOL(ieee80211_free_hw); 1534 1535static int __init ieee80211_init(void) 1536{ 1537 struct sk_buff *skb; 1538 int ret; 1539 1540 BUILD_BUG_ON(sizeof(struct ieee80211_tx_info) > sizeof(skb->cb)); 1541 BUILD_BUG_ON(offsetof(struct ieee80211_tx_info, driver_data) + 1542 IEEE80211_TX_INFO_DRIVER_DATA_SIZE > sizeof(skb->cb)); 1543 1544 ret = rc80211_pid_init(); 1545 if (ret) 1546 return ret; 1547 1548 ieee80211_debugfs_netdev_init(); 1549 1550 return 0; 1551} 1552 1553static void __exit ieee80211_exit(void) 1554{ 1555 rc80211_pid_exit(); 1556 1557 /* 1558 * For key todo, it'll be empty by now but the work 1559 * might still be scheduled. 1560 */ 1561 flush_scheduled_work(); 1562 1563 if (mesh_allocated) 1564 ieee80211s_stop(); 1565 1566 ieee80211_debugfs_netdev_exit(); 1567} 1568 1569 1570subsys_initcall(ieee80211_init); 1571module_exit(ieee80211_exit); 1572 1573MODULE_DESCRIPTION("IEEE 802.11 subsystem"); 1574MODULE_LICENSE("GPL"); 1575