net/mac80211/ieee80211.c

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