Merge git://git.kernel.org/pub/scm/linux/kernel/git/linville/wireless-2.6
[linux-2.6.git] / net / mac80211 / iface.c
index a7ef028..264a6c9 100644 (file)
 #include <linux/netdevice.h>
 #include <linux/rtnetlink.h>
 #include <net/mac80211.h>
+#include <net/ieee80211_radiotap.h>
 #include "ieee80211_i.h"
 #include "sta_info.h"
 #include "debugfs_netdev.h"
 #include "mesh.h"
 #include "led.h"
+#include "driver-ops.h"
+#include "wme.h"
+
+/**
+ * DOC: Interface list locking
+ *
+ * The interface list in each struct ieee80211_local is protected
+ * three-fold:
+ *
+ * (1) modifications may only be done under the RTNL
+ * (2) modifications and readers are protected against each other by
+ *     the iflist_mtx.
+ * (3) modifications are done in an RCU manner so atomic readers
+ *     can traverse the list in RCU-safe blocks.
+ *
+ * As a consequence, reads (traversals) of the list can be protected
+ * by either the RTNL, the iflist_mtx or RCU.
+ */
+
 
 static int ieee80211_change_mtu(struct net_device *dev, int new_mtu)
 {
@@ -42,6 +62,23 @@ static int ieee80211_change_mtu(struct net_device *dev, int new_mtu)
        return 0;
 }
 
+static int ieee80211_change_mac(struct net_device *dev, void *addr)
+{
+       struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
+       struct sockaddr *sa = addr;
+       int ret;
+
+       if (ieee80211_sdata_running(sdata))
+               return -EBUSY;
+
+       ret = eth_mac_addr(dev, sa);
+
+       if (ret == 0)
+               memcpy(sdata->vif.addr, sa->sa_data, ETH_ALEN);
+
+       return ret;
+}
+
 static inline int identical_mac_addr_allowed(int type1, int type2)
 {
        return type1 == NL80211_IFTYPE_MONITOR ||
@@ -58,17 +95,15 @@ static inline int identical_mac_addr_allowed(int type1, int type2)
 
 static int ieee80211_open(struct net_device *dev)
 {
-       struct ieee80211_sub_if_data *sdata, *nsdata;
-       struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
+       struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
+       struct ieee80211_sub_if_data *nsdata;
+       struct ieee80211_local *local = sdata->local;
        struct sta_info *sta;
-       struct ieee80211_if_init_conf conf;
        u32 changed = 0;
        int res;
-       bool need_hw_reconfig = 0;
+       u32 hw_reconf_flags = 0;
        u8 null_addr[ETH_ALEN] = {0};
 
-       sdata = IEEE80211_DEV_TO_SUB_IF(dev);
-
        /* fail early if user set an invalid address */
        if (compare_ether_addr(dev->dev_addr, null_addr) &&
            !is_valid_ether_addr(dev->dev_addr))
@@ -78,7 +113,7 @@ static int ieee80211_open(struct net_device *dev)
        list_for_each_entry(nsdata, &local->interfaces, list) {
                struct net_device *ndev = nsdata->dev;
 
-               if (ndev != dev && netif_running(ndev)) {
+               if (ndev != dev && ieee80211_sdata_running(nsdata)) {
                        /*
                         * Allow only a single IBSS interface to be up at any
                         * time. This is restricted because beacon distribution
@@ -148,13 +183,12 @@ static int ieee80211_open(struct net_device *dev)
        }
 
        if (local->open_count == 0) {
-               res = 0;
-               if (local->ops->start)
-                       res = local->ops->start(local_to_hw(local));
+               res = drv_start(local);
                if (res)
                        goto err_del_bss;
-               need_hw_reconfig = 1;
-               ieee80211_led_radio(local, local->hw.conf.radio_enabled);
+               /* we're brought up, everything changes */
+               hw_reconf_flags = ~0;
+               ieee80211_led_radio(local, true);
        }
 
        /*
@@ -165,25 +199,23 @@ static int ieee80211_open(struct net_device *dev)
                struct net_device *ndev = nsdata->dev;
 
                /*
-                * No need to check netif_running since we do not allow
+                * No need to check running since we do not allow
                 * it to start up with this invalid address.
                 */
-               if (compare_ether_addr(null_addr, ndev->dev_addr) == 0)
+               if (compare_ether_addr(null_addr, ndev->dev_addr) == 0) {
                        memcpy(ndev->dev_addr,
                               local->hw.wiphy->perm_addr,
                               ETH_ALEN);
+                       memcpy(ndev->perm_addr, ndev->dev_addr, ETH_ALEN);
+               }
        }
 
-       if (compare_ether_addr(null_addr, local->mdev->dev_addr) == 0)
-               memcpy(local->mdev->dev_addr, local->hw.wiphy->perm_addr,
-                      ETH_ALEN);
-
        /*
         * Validate the MAC address for this device.
         */
        if (!is_valid_ether_addr(dev->dev_addr)) {
-               if (!local->open_count && local->ops->stop)
-                       local->ops->stop(local_to_hw(local));
+               if (!local->open_count)
+                       drv_stop(local);
                return -EADDRNOTAVAIL;
        }
 
@@ -199,42 +231,45 @@ static int ieee80211_open(struct net_device *dev)
 
                /* must be before the call to ieee80211_configure_filter */
                local->monitors++;
-               if (local->monitors == 1)
-                       local->hw.conf.flags |= IEEE80211_CONF_RADIOTAP;
+               if (local->monitors == 1) {
+                       local->hw.conf.flags |= IEEE80211_CONF_MONITOR;
+                       hw_reconf_flags |= IEEE80211_CONF_CHANGE_MONITOR;
+               }
 
                if (sdata->u.mntr_flags & MONITOR_FLAG_FCSFAIL)
                        local->fif_fcsfail++;
                if (sdata->u.mntr_flags & MONITOR_FLAG_PLCPFAIL)
                        local->fif_plcpfail++;
-               if (sdata->u.mntr_flags & MONITOR_FLAG_CONTROL)
+               if (sdata->u.mntr_flags & MONITOR_FLAG_CONTROL) {
                        local->fif_control++;
+                       local->fif_pspoll++;
+               }
                if (sdata->u.mntr_flags & MONITOR_FLAG_OTHER_BSS)
                        local->fif_other_bss++;
 
-               netif_addr_lock_bh(local->mdev);
                ieee80211_configure_filter(local);
-               netif_addr_unlock_bh(local->mdev);
                break;
-       case NL80211_IFTYPE_STATION:
-       case NL80211_IFTYPE_ADHOC:
-               sdata->u.sta.flags &= ~IEEE80211_STA_PREV_BSSID_SET;
-               /* fall through */
        default:
-               conf.vif = &sdata->vif;
-               conf.type = sdata->vif.type;
-               conf.mac_addr = dev->dev_addr;
-               res = local->ops->add_interface(local_to_hw(local), &conf);
+               res = drv_add_interface(local, &sdata->vif);
                if (res)
                        goto err_stop;
 
-               if (ieee80211_vif_is_mesh(&sdata->vif))
+               if (ieee80211_vif_is_mesh(&sdata->vif)) {
+                       local->fif_other_bss++;
+                       ieee80211_configure_filter(local);
+
                        ieee80211_start_mesh(sdata);
+               } else if (sdata->vif.type == NL80211_IFTYPE_AP) {
+                       local->fif_pspoll++;
+
+                       ieee80211_configure_filter(local);
+               }
+
                changed |= ieee80211_reset_erp_info(sdata);
                ieee80211_bss_info_change_notify(sdata, changed);
                ieee80211_enable_keys(sdata);
 
-               if (sdata->vif.type == NL80211_IFTYPE_STATION &&
-                   !(sdata->flags & IEEE80211_SDATA_USERSPACE_MLME))
+               if (sdata->vif.type == NL80211_IFTYPE_STATION)
                        netif_carrier_off(dev);
                else
                        netif_carrier_on(dev);
@@ -259,15 +294,6 @@ static int ieee80211_open(struct net_device *dev)
                }
        }
 
-       if (local->open_count == 0) {
-               res = dev_open(local->mdev);
-               WARN_ON(res);
-               if (res)
-                       goto err_del_interface;
-               tasklet_enable(&local->tx_pending_tasklet);
-               tasklet_enable(&local->tasklet);
-       }
-
        /*
         * set_multicast_list will be invoked by the networking core
         * which will check whether any increments here were done in
@@ -279,9 +305,11 @@ static int ieee80211_open(struct net_device *dev)
        if (sdata->flags & IEEE80211_SDATA_PROMISC)
                atomic_inc(&local->iff_promiscs);
 
+       hw_reconf_flags |= __ieee80211_recalc_idle(local);
+
        local->open_count++;
-       if (need_hw_reconfig) {
-               ieee80211_hw_config(local);
+       if (hw_reconf_flags) {
+               ieee80211_hw_config(local, hw_reconf_flags);
                /*
                 * set default queue parameters so drivers don't
                 * need to initialise the hardware if the hardware
@@ -290,26 +318,25 @@ static int ieee80211_open(struct net_device *dev)
                ieee80211_set_wmm_default(sdata);
        }
 
+       ieee80211_recalc_ps(local, -1);
+
        /*
         * ieee80211_sta_work is disabled while network interface
         * is down. Therefore, some configuration changes may not
         * yet be effective. Trigger execution of ieee80211_sta_work
         * to fix this.
         */
-       if (sdata->vif.type == NL80211_IFTYPE_STATION ||
-           sdata->vif.type == NL80211_IFTYPE_ADHOC) {
-               struct ieee80211_if_sta *ifsta = &sdata->u.sta;
-               queue_work(local->hw.workqueue, &ifsta->work);
-       }
+       if (sdata->vif.type == NL80211_IFTYPE_STATION)
+               ieee80211_queue_work(&local->hw, &sdata->u.mgd.work);
 
        netif_tx_start_all_queues(dev);
 
        return 0;
  err_del_interface:
-       local->ops->remove_interface(local_to_hw(local), &conf);
+       drv_remove_interface(local, &sdata->vif);
  err_stop:
-       if (!local->open_count && local->ops->stop)
-               local->ops->stop(local_to_hw(local));
+       if (!local->open_count)
+               drv_stop(local);
  err_del_bss:
        sdata->bss = NULL;
        if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
@@ -321,8 +348,11 @@ static int ieee80211_stop(struct net_device *dev)
 {
        struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
        struct ieee80211_local *local = sdata->local;
-       struct ieee80211_if_init_conf conf;
        struct sta_info *sta;
+       unsigned long flags;
+       struct sk_buff *skb, *tmp;
+       u32 hw_reconf_flags = 0;
+       int i;
 
        /*
         * Stop TX on this interface first.
@@ -330,14 +360,18 @@ static int ieee80211_stop(struct net_device *dev)
        netif_tx_stop_all_queues(dev);
 
        /*
+        * Purge work for this interface.
+        */
+       ieee80211_work_purge(sdata);
+
+       /*
         * Now delete all active aggregation sessions.
         */
        rcu_read_lock();
 
        list_for_each_entry_rcu(sta, &local->sta_list, list) {
                if (sta->sdata == sdata)
-                       ieee80211_sta_tear_down_BA_sessions(sdata,
-                                                           sta->sta.addr);
+                       ieee80211_sta_tear_down_BA_sessions(sta);
        }
 
        rcu_read_unlock();
@@ -373,11 +407,24 @@ static int ieee80211_stop(struct net_device *dev)
        if (sdata->flags & IEEE80211_SDATA_PROMISC)
                atomic_dec(&local->iff_promiscs);
 
-       dev_mc_unsync(local->mdev, dev);
+       if (sdata->vif.type == NL80211_IFTYPE_AP)
+               local->fif_pspoll--;
+
+       netif_addr_lock_bh(dev);
+       spin_lock_bh(&local->filter_lock);
+       __dev_addr_unsync(&local->mc_list, &local->mc_count,
+                         &dev->mc_list, &dev->mc_count);
+       spin_unlock_bh(&local->filter_lock);
+       netif_addr_unlock_bh(dev);
+
+       ieee80211_configure_filter(local);
+
+       del_timer_sync(&local->dynamic_ps_timer);
+       cancel_work_sync(&local->dynamic_ps_enable_work);
 
        /* APs need special treatment */
        if (sdata->vif.type == NL80211_IFTYPE_AP) {
-               struct ieee80211_sub_if_data *vlan, *tmp;
+               struct ieee80211_sub_if_data *vlan, *tmpsdata;
                struct beacon_data *old_beacon = sdata->u.ap.beacon;
 
                /* remove beacon */
@@ -386,7 +433,7 @@ static int ieee80211_stop(struct net_device *dev)
                kfree(old_beacon);
 
                /* down all dependent devices, that is VLANs */
-               list_for_each_entry_safe(vlan, tmp, &sdata->u.ap.vlans,
+               list_for_each_entry_safe(vlan, tmpsdata, &sdata->u.ap.vlans,
                                         u.vlan.list)
                        dev_close(vlan->dev);
                WARN_ON(!list_empty(&sdata->u.ap.vlans));
@@ -406,35 +453,41 @@ static int ieee80211_stop(struct net_device *dev)
                }
 
                local->monitors--;
-               if (local->monitors == 0)
-                       local->hw.conf.flags &= ~IEEE80211_CONF_RADIOTAP;
+               if (local->monitors == 0) {
+                       local->hw.conf.flags &= ~IEEE80211_CONF_MONITOR;
+                       hw_reconf_flags |= IEEE80211_CONF_CHANGE_MONITOR;
+               }
 
                if (sdata->u.mntr_flags & MONITOR_FLAG_FCSFAIL)
                        local->fif_fcsfail--;
                if (sdata->u.mntr_flags & MONITOR_FLAG_PLCPFAIL)
                        local->fif_plcpfail--;
-               if (sdata->u.mntr_flags & MONITOR_FLAG_CONTROL)
+               if (sdata->u.mntr_flags & MONITOR_FLAG_CONTROL) {
+                       local->fif_pspoll--;
                        local->fif_control--;
+               }
                if (sdata->u.mntr_flags & MONITOR_FLAG_OTHER_BSS)
                        local->fif_other_bss--;
 
-               netif_addr_lock_bh(local->mdev);
                ieee80211_configure_filter(local);
-               netif_addr_unlock_bh(local->mdev);
                break;
        case NL80211_IFTYPE_STATION:
-       case NL80211_IFTYPE_ADHOC:
-               sdata->u.sta.state = IEEE80211_STA_MLME_DISABLED;
-               memset(sdata->u.sta.bssid, 0, ETH_ALEN);
-               del_timer_sync(&sdata->u.sta.timer);
+               del_timer_sync(&sdata->u.mgd.chswitch_timer);
+               del_timer_sync(&sdata->u.mgd.timer);
+               del_timer_sync(&sdata->u.mgd.conn_mon_timer);
+               del_timer_sync(&sdata->u.mgd.bcn_mon_timer);
                /*
-                * If the timer fired while we waited for it, it will have
-                * requeued the work. Now the work will be running again
+                * If any of the timers fired while we waited for it, it will
+                * have queued its work. Now the work will be running again
                 * but will not rearm the timer again because it checks
                 * whether the interface is running, which, at this point,
                 * it no longer is.
                 */
-               cancel_work_sync(&sdata->u.sta.work);
+               cancel_work_sync(&sdata->u.mgd.work);
+               cancel_work_sync(&sdata->u.mgd.chswitch_work);
+               cancel_work_sync(&sdata->u.mgd.monitor_work);
+               cancel_work_sync(&sdata->u.mgd.beacon_loss_work);
+
                /*
                 * When we get here, the interface is marked down.
                 * Call synchronize_rcu() to wait for the RX path
@@ -442,78 +495,84 @@ static int ieee80211_stop(struct net_device *dev)
                 * frames at this very time on another CPU.
                 */
                synchronize_rcu();
-               skb_queue_purge(&sdata->u.sta.skb_queue);
-
-               sdata->u.sta.flags &= ~IEEE80211_STA_PRIVACY_INVOKED;
-               kfree(sdata->u.sta.extra_ie);
-               sdata->u.sta.extra_ie = NULL;
-               sdata->u.sta.extra_ie_len = 0;
+               skb_queue_purge(&sdata->u.mgd.skb_queue);
+               /* fall through */
+       case NL80211_IFTYPE_ADHOC:
+               if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
+                       del_timer_sync(&sdata->u.ibss.timer);
+                       cancel_work_sync(&sdata->u.ibss.work);
+                       synchronize_rcu();
+                       skb_queue_purge(&sdata->u.ibss.skb_queue);
+               }
                /* fall through */
        case NL80211_IFTYPE_MESH_POINT:
                if (ieee80211_vif_is_mesh(&sdata->vif)) {
-                       /* allmulti is always set on mesh ifaces */
+                       /* other_bss and allmulti are always set on mesh
+                        * ifaces */
+                       local->fif_other_bss--;
                        atomic_dec(&local->iff_allmultis);
+
+                       ieee80211_configure_filter(local);
+
                        ieee80211_stop_mesh(sdata);
                }
                /* fall through */
        default:
-               if (local->scan_sdata == sdata) {
-                       if (!local->ops->hw_scan)
-                               cancel_delayed_work_sync(&local->scan_work);
-                       /*
-                        * The software scan can no longer run now, so we can
-                        * clear out the scan_sdata reference. However, the
-                        * hardware scan may still be running. The complete
-                        * function must be prepared to handle a NULL value.
-                        */
-                       local->scan_sdata = NULL;
-                       /*
-                        * The memory barrier guarantees that another CPU
-                        * that is hardware-scanning will now see the fact
-                        * that this interface is gone.
-                        */
-                       smp_mb();
-                       /*
-                        * If software scanning, complete the scan but since
-                        * the scan_sdata is NULL already don't send out a
-                        * scan event to userspace -- the scan is incomplete.
-                        */
-                       if (local->sw_scanning)
-                               ieee80211_scan_completed(&local->hw);
+               if (local->scan_sdata == sdata)
+                       ieee80211_scan_cancel(local);
+
+               /*
+                * Disable beaconing for AP and mesh, IBSS can't
+                * still be joined to a network at this point.
+                */
+               if (sdata->vif.type == NL80211_IFTYPE_AP ||
+                   sdata->vif.type == NL80211_IFTYPE_MESH_POINT) {
+                       ieee80211_bss_info_change_notify(sdata,
+                               BSS_CHANGED_BEACON_ENABLED);
                }
 
-               conf.vif = &sdata->vif;
-               conf.type = sdata->vif.type;
-               conf.mac_addr = dev->dev_addr;
                /* disable all keys for as long as this netdev is down */
                ieee80211_disable_keys(sdata);
-               local->ops->remove_interface(local_to_hw(local), &conf);
+               drv_remove_interface(local, &sdata->vif);
        }
 
        sdata->bss = NULL;
 
-       if (local->open_count == 0) {
-               if (netif_running(local->mdev))
-                       dev_close(local->mdev);
+       hw_reconf_flags |= __ieee80211_recalc_idle(local);
 
-               if (local->ops->stop)
-                       local->ops->stop(local_to_hw(local));
+       ieee80211_recalc_ps(local, -1);
 
-               ieee80211_led_radio(local, 0);
+       if (local->open_count == 0) {
+               ieee80211_clear_tx_pending(local);
+               ieee80211_stop_device(local);
 
-               flush_workqueue(local->hw.workqueue);
+               /* no reconfiguring after stop! */
+               hw_reconf_flags = 0;
+       }
 
-               tasklet_disable(&local->tx_pending_tasklet);
-               tasklet_disable(&local->tasklet);
+       /* do after stop to avoid reconfiguring when we stop anyway */
+       if (hw_reconf_flags)
+               ieee80211_hw_config(local, hw_reconf_flags);
+
+       spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
+       for (i = 0; i < IEEE80211_MAX_QUEUES; i++) {
+               skb_queue_walk_safe(&local->pending[i], skb, tmp) {
+                       struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
+                       if (info->control.vif == &sdata->vif) {
+                               __skb_unlink(skb, &local->pending[i]);
+                               dev_kfree_skb_irq(skb);
+                       }
+               }
        }
+       spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
 
        return 0;
 }
 
 static void ieee80211_set_multicast_list(struct net_device *dev)
 {
-       struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
        struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
+       struct ieee80211_local *local = sdata->local;
        int allmulti, promisc, sdata_allmulti, sdata_promisc;
 
        allmulti = !!(dev->flags & IFF_ALLMULTI);
@@ -536,23 +595,13 @@ static void ieee80211_set_multicast_list(struct net_device *dev)
                        atomic_dec(&local->iff_promiscs);
                sdata->flags ^= IEEE80211_SDATA_PROMISC;
        }
-
-       dev_mc_sync(local->mdev, dev);
+       spin_lock_bh(&local->filter_lock);
+       __dev_addr_sync(&local->mc_list, &local->mc_count,
+                       &dev->mc_list, &dev->mc_count);
+       spin_unlock_bh(&local->filter_lock);
+       ieee80211_queue_work(&local->hw, &local->reconfig_filter);
 }
 
-static void ieee80211_if_setup(struct net_device *dev)
-{
-       ether_setup(dev);
-       dev->hard_start_xmit = ieee80211_subif_start_xmit;
-       dev->wireless_handlers = &ieee80211_iw_handler_def;
-       dev->set_multicast_list = ieee80211_set_multicast_list;
-       dev->change_mtu = ieee80211_change_mtu;
-       dev->open = ieee80211_open;
-       dev->stop = ieee80211_stop;
-       dev->destructor = free_netdev;
-       /* we will validate the address ourselves in ->open */
-       dev->validate_addr = NULL;
-}
 /*
  * Called when the netdev is removed or, by the code below, before
  * the interface type changes.
@@ -592,13 +641,11 @@ static void ieee80211_teardown_sdata(struct net_device *dev)
                if (ieee80211_vif_is_mesh(&sdata->vif))
                        mesh_rmc_free(sdata);
                break;
-       case NL80211_IFTYPE_STATION:
        case NL80211_IFTYPE_ADHOC:
-               kfree(sdata->u.sta.extra_ie);
-               kfree(sdata->u.sta.assocreq_ies);
-               kfree(sdata->u.sta.assocresp_ies);
-               kfree_skb(sdata->u.sta.probe_resp);
+               if (WARN_ON(sdata->u.ibss.presp))
+                       kfree_skb(sdata->u.ibss.presp);
                break;
+       case NL80211_IFTYPE_STATION:
        case NL80211_IFTYPE_WDS:
        case NL80211_IFTYPE_AP_VLAN:
        case NL80211_IFTYPE_MONITOR:
@@ -613,6 +660,66 @@ static void ieee80211_teardown_sdata(struct net_device *dev)
        WARN_ON(flushed);
 }
 
+static u16 ieee80211_netdev_select_queue(struct net_device *dev,
+                                        struct sk_buff *skb)
+{
+       return ieee80211_select_queue(IEEE80211_DEV_TO_SUB_IF(dev), skb);
+}
+
+static const struct net_device_ops ieee80211_dataif_ops = {
+       .ndo_open               = ieee80211_open,
+       .ndo_stop               = ieee80211_stop,
+       .ndo_uninit             = ieee80211_teardown_sdata,
+       .ndo_start_xmit         = ieee80211_subif_start_xmit,
+       .ndo_set_multicast_list = ieee80211_set_multicast_list,
+       .ndo_change_mtu         = ieee80211_change_mtu,
+       .ndo_set_mac_address    = ieee80211_change_mac,
+       .ndo_select_queue       = ieee80211_netdev_select_queue,
+};
+
+static u16 ieee80211_monitor_select_queue(struct net_device *dev,
+                                         struct sk_buff *skb)
+{
+       struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
+       struct ieee80211_local *local = sdata->local;
+       struct ieee80211_hdr *hdr;
+       struct ieee80211_radiotap_header *rtap = (void *)skb->data;
+
+       if (local->hw.queues < 4)
+               return 0;
+
+       if (skb->len < 4 ||
+           skb->len < rtap->it_len + 2 /* frame control */)
+               return 0; /* doesn't matter, frame will be dropped */
+
+       hdr = (void *)((u8 *)skb->data + rtap->it_len);
+
+       if (!ieee80211_is_data(hdr->frame_control)) {
+               skb->priority = 7;
+               return ieee802_1d_to_ac[skb->priority];
+       }
+
+       return ieee80211_downgrade_queue(local, skb);
+}
+
+static const struct net_device_ops ieee80211_monitorif_ops = {
+       .ndo_open               = ieee80211_open,
+       .ndo_stop               = ieee80211_stop,
+       .ndo_uninit             = ieee80211_teardown_sdata,
+       .ndo_start_xmit         = ieee80211_monitor_start_xmit,
+       .ndo_set_multicast_list = ieee80211_set_multicast_list,
+       .ndo_change_mtu         = ieee80211_change_mtu,
+       .ndo_set_mac_address    = eth_mac_addr,
+       .ndo_select_queue       = ieee80211_monitor_select_queue,
+};
+
+static void ieee80211_if_setup(struct net_device *dev)
+{
+       ether_setup(dev);
+       dev->netdev_ops = &ieee80211_dataif_ops;
+       dev->destructor = free_netdev;
+}
+
 /*
  * Helper function to initialise an interface to a specific type.
  */
@@ -624,6 +731,8 @@ static void ieee80211_setup_sdata(struct ieee80211_sub_if_data *sdata,
 
        /* and set some type-dependent values */
        sdata->vif.type = type;
+       sdata->dev->netdev_ops = &ieee80211_dataif_ops;
+       sdata->wdev.iftype = type;
 
        /* only monitor differs */
        sdata->dev->type = ARPHRD_ETHER;
@@ -634,16 +743,18 @@ static void ieee80211_setup_sdata(struct ieee80211_sub_if_data *sdata,
                INIT_LIST_HEAD(&sdata->u.ap.vlans);
                break;
        case NL80211_IFTYPE_STATION:
-       case NL80211_IFTYPE_ADHOC:
                ieee80211_sta_setup_sdata(sdata);
                break;
+       case NL80211_IFTYPE_ADHOC:
+               ieee80211_ibss_setup_sdata(sdata);
+               break;
        case NL80211_IFTYPE_MESH_POINT:
                if (ieee80211_vif_is_mesh(&sdata->vif))
                        ieee80211_mesh_init_sdata(sdata);
                break;
        case NL80211_IFTYPE_MONITOR:
                sdata->dev->type = ARPHRD_IEEE80211_RADIOTAP;
-               sdata->dev->hard_start_xmit = ieee80211_monitor_start_xmit;
+               sdata->dev->netdev_ops = &ieee80211_monitorif_ops;
                sdata->u.mntr_flags = MONITOR_FLAG_CONTROL |
                                      MONITOR_FLAG_OTHER_BSS;
                break;
@@ -667,13 +778,18 @@ int ieee80211_if_change_type(struct ieee80211_sub_if_data *sdata,
        if (type == sdata->vif.type)
                return 0;
 
+       /* Setting ad-hoc mode on non-IBSS channel is not supported. */
+       if (sdata->local->oper_channel->flags & IEEE80211_CHAN_NO_IBSS &&
+           type == NL80211_IFTYPE_ADHOC)
+               return -EOPNOTSUPP;
+
        /*
         * We could, here, on changes between IBSS/STA/MESH modes,
         * invoke an MLME function instead that disassociates etc.
         * and goes into the requested mode.
         */
 
-       if (netif_running(sdata->dev))
+       if (ieee80211_sdata_running(sdata))
                return -EBUSY;
 
        /* Purge and reset type-dependent state. */
@@ -681,10 +797,12 @@ int ieee80211_if_change_type(struct ieee80211_sub_if_data *sdata,
        ieee80211_setup_sdata(sdata, type);
 
        /* reset some values that shouldn't be kept across type changes */
-       sdata->bss_conf.basic_rates =
+       sdata->vif.bss_conf.basic_rates =
                ieee80211_mandatory_rates(sdata->local,
                        sdata->local->hw.conf.channel->band);
        sdata->drop_unencrypted = 0;
+       if (type == NL80211_IFTYPE_STATION)
+               sdata->u.mgd.use_4addr = false;
 
        return 0;
 }
@@ -699,10 +817,11 @@ int ieee80211_if_add(struct ieee80211_local *local, const char *name,
 
        ASSERT_RTNL();
 
-       ndev = alloc_netdev(sizeof(*sdata) + local->hw.vif_data_size,
-                           name, ieee80211_if_setup);
+       ndev = alloc_netdev_mq(sizeof(*sdata) + local->hw.vif_data_size,
+                              name, ieee80211_if_setup, local->hw.queues);
        if (!ndev)
                return -ENOMEM;
+       dev_net_set(ndev, wiphy_net(local->hw.wiphy));
 
        ndev->needed_headroom = local->tx_headroom +
                                4*6 /* four MAC addresses */
@@ -718,11 +837,14 @@ int ieee80211_if_add(struct ieee80211_local *local, const char *name,
                goto fail;
 
        memcpy(ndev->dev_addr, local->hw.wiphy->perm_addr, ETH_ALEN);
+       memcpy(ndev->perm_addr, ndev->dev_addr, ETH_ALEN);
        SET_NETDEV_DEV(ndev, wiphy_dev(local->hw.wiphy));
 
        /* don't use IEEE80211_DEV_TO_SUB_IF because it checks too much */
        sdata = netdev_priv(ndev);
        ndev->ieee80211_ptr = &sdata->wdev;
+       memcpy(sdata->vif.addr, ndev->dev_addr, ETH_ALEN);
+       memcpy(sdata->name, ndev->name, IFNAMSIZ);
 
        /* initialise type-independent data */
        sdata->wdev.wiphy = local->hw.wiphy;
@@ -740,19 +862,25 @@ int ieee80211_if_add(struct ieee80211_local *local, const char *name,
        /* setup type-dependent data */
        ieee80211_setup_sdata(sdata, type);
 
+       if (params) {
+               ndev->ieee80211_ptr->use_4addr = params->use_4addr;
+               if (type == NL80211_IFTYPE_STATION)
+                       sdata->u.mgd.use_4addr = params->use_4addr;
+       }
+
        ret = register_netdevice(ndev);
        if (ret)
                goto fail;
 
-       ndev->uninit = ieee80211_teardown_sdata;
-
        if (ieee80211_vif_is_mesh(&sdata->vif) &&
            params && params->mesh_id_len)
                ieee80211_sdata_set_mesh_id(sdata,
                                            params->mesh_id_len,
                                            params->mesh_id);
 
+       mutex_lock(&local->iflist_mtx);
        list_add_tail_rcu(&sdata->list, &local->interfaces);
+       mutex_unlock(&local->iflist_mtx);
 
        if (new_dev)
                *new_dev = ndev;
@@ -768,7 +896,10 @@ void ieee80211_if_remove(struct ieee80211_sub_if_data *sdata)
 {
        ASSERT_RTNL();
 
+       mutex_lock(&sdata->local->iflist_mtx);
        list_del_rcu(&sdata->list);
+       mutex_unlock(&sdata->local->iflist_mtx);
+
        synchronize_rcu();
        unregister_netdevice(sdata->dev);
 }
@@ -780,11 +911,130 @@ void ieee80211_if_remove(struct ieee80211_sub_if_data *sdata)
 void ieee80211_remove_interfaces(struct ieee80211_local *local)
 {
        struct ieee80211_sub_if_data *sdata, *tmp;
+       LIST_HEAD(unreg_list);
 
        ASSERT_RTNL();
 
+       mutex_lock(&local->iflist_mtx);
        list_for_each_entry_safe(sdata, tmp, &local->interfaces, list) {
                list_del(&sdata->list);
-               unregister_netdevice(sdata->dev);
+
+               unregister_netdevice_queue(sdata->dev, &unreg_list);
+       }
+       mutex_unlock(&local->iflist_mtx);
+       unregister_netdevice_many(&unreg_list);
+}
+
+static u32 ieee80211_idle_off(struct ieee80211_local *local,
+                             const char *reason)
+{
+       if (!(local->hw.conf.flags & IEEE80211_CONF_IDLE))
+               return 0;
+
+#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
+       printk(KERN_DEBUG "%s: device no longer idle - %s\n",
+              wiphy_name(local->hw.wiphy), reason);
+#endif
+
+       local->hw.conf.flags &= ~IEEE80211_CONF_IDLE;
+       return IEEE80211_CONF_CHANGE_IDLE;
+}
+
+static u32 ieee80211_idle_on(struct ieee80211_local *local)
+{
+       if (local->hw.conf.flags & IEEE80211_CONF_IDLE)
+               return 0;
+
+#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
+       printk(KERN_DEBUG "%s: device now idle\n",
+              wiphy_name(local->hw.wiphy));
+#endif
+
+       drv_flush(local, false);
+
+       local->hw.conf.flags |= IEEE80211_CONF_IDLE;
+       return IEEE80211_CONF_CHANGE_IDLE;
+}
+
+u32 __ieee80211_recalc_idle(struct ieee80211_local *local)
+{
+       struct ieee80211_sub_if_data *sdata;
+       int count = 0;
+
+       if (!list_empty(&local->work_list))
+               return ieee80211_idle_off(local, "working");
+
+       if (local->scanning)
+               return ieee80211_idle_off(local, "scanning");
+
+       list_for_each_entry(sdata, &local->interfaces, list) {
+               if (!ieee80211_sdata_running(sdata))
+                       continue;
+               /* do not count disabled managed interfaces */
+               if (sdata->vif.type == NL80211_IFTYPE_STATION &&
+                   !sdata->u.mgd.associated)
+                       continue;
+               /* do not count unused IBSS interfaces */
+               if (sdata->vif.type == NL80211_IFTYPE_ADHOC &&
+                   !sdata->u.ibss.ssid_len)
+                       continue;
+               /* count everything else */
+               count++;
        }
+
+       if (!count)
+               return ieee80211_idle_on(local);
+       else
+               return ieee80211_idle_off(local, "in use");
+
+       return 0;
+}
+
+void ieee80211_recalc_idle(struct ieee80211_local *local)
+{
+       u32 chg;
+
+       mutex_lock(&local->iflist_mtx);
+       chg = __ieee80211_recalc_idle(local);
+       mutex_unlock(&local->iflist_mtx);
+       if (chg)
+               ieee80211_hw_config(local, chg);
+}
+
+static int netdev_notify(struct notifier_block *nb,
+                        unsigned long state,
+                        void *ndev)
+{
+       struct net_device *dev = ndev;
+       struct ieee80211_sub_if_data *sdata;
+
+       if (state != NETDEV_CHANGENAME)
+               return 0;
+
+       if (!dev->ieee80211_ptr || !dev->ieee80211_ptr->wiphy)
+               return 0;
+
+       if (dev->ieee80211_ptr->wiphy->privid != mac80211_wiphy_privid)
+               return 0;
+
+       sdata = IEEE80211_DEV_TO_SUB_IF(dev);
+
+       memcpy(sdata->name, sdata->name, IFNAMSIZ);
+
+       ieee80211_debugfs_rename_netdev(sdata);
+       return 0;
+}
+
+static struct notifier_block mac80211_netdev_notifier = {
+       .notifier_call = netdev_notify,
+};
+
+int ieee80211_iface_init(void)
+{
+       return register_netdevice_notifier(&mac80211_netdev_notifier);
+}
+
+void ieee80211_iface_exit(void)
+{
+       unregister_netdevice_notifier(&mac80211_netdev_notifier);
 }