Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux
[linux-2.6.git] / drivers / net / wireless / mac80211_hwsim.c
index d8716be..6cf6d6d 100644 (file)
@@ -1,6 +1,7 @@
 /*
  * mac80211_hwsim - software simulator of 802.11 radio(s) for mac80211
  * Copyright (c) 2008, Jouni Malinen <j@w1.fi>
+ * Copyright (c) 2011, Javier Lopez <jlopex@gmail.com>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
 
 /*
  * TODO:
- * - IBSS mode simulation (Beacon transmission with competition for "air time")
+ * - Add TSF sync and fix IBSS beacon transmission by adding
+ *   competition for "air time" at TBTT
  * - RX filtering based on filter configuration (data->rx_filter)
  */
 
 #include <linux/list.h>
+#include <linux/slab.h>
 #include <linux/spinlock.h>
+#include <net/dst.h>
+#include <net/xfrm.h>
 #include <net/mac80211.h>
 #include <net/ieee80211_radiotap.h>
 #include <linux/if_arp.h>
 #include <linux/rtnetlink.h>
 #include <linux/etherdevice.h>
 #include <linux/debugfs.h>
+#include <linux/module.h>
+#include <net/genetlink.h>
+#include "mac80211_hwsim.h"
+
+#define WARN_QUEUE 100
+#define MAX_QUEUE 200
 
 MODULE_AUTHOR("Jouni Malinen");
 MODULE_DESCRIPTION("Software simulator of 802.11 radio(s) for mac80211");
 MODULE_LICENSE("GPL");
 
+int wmediumd_pid;
 static int radios = 2;
 module_param(radios, int, 0444);
 MODULE_PARM_DESC(radios, "Number of simulated radios");
 
+static bool fake_hw_scan;
+module_param(fake_hw_scan, bool, 0444);
+MODULE_PARM_DESC(fake_hw_scan, "Install fake (no-op) hw-scan handler");
+
+/**
+ * enum hwsim_regtest - the type of regulatory tests we offer
+ *
+ * These are the different values you can use for the regtest
+ * module parameter. This is useful to help test world roaming
+ * and the driver regulatory_hint() call and combinations of these.
+ * If you want to do specific alpha2 regulatory domain tests simply
+ * use the userspace regulatory request as that will be respected as
+ * well without the need of this module parameter. This is designed
+ * only for testing the driver regulatory request, world roaming
+ * and all possible combinations.
+ *
+ * @HWSIM_REGTEST_DISABLED: No regulatory tests are performed,
+ *     this is the default value.
+ * @HWSIM_REGTEST_DRIVER_REG_FOLLOW: Used for testing the driver regulatory
+ *     hint, only one driver regulatory hint will be sent as such the
+ *     secondary radios are expected to follow.
+ * @HWSIM_REGTEST_DRIVER_REG_ALL: Used for testing the driver regulatory
+ *     request with all radios reporting the same regulatory domain.
+ * @HWSIM_REGTEST_DIFF_COUNTRY: Used for testing the drivers calling
+ *     different regulatory domains requests. Expected behaviour is for
+ *     an intersection to occur but each device will still use their
+ *     respective regulatory requested domains. Subsequent radios will
+ *     use the resulting intersection.
+ * @HWSIM_REGTEST_WORLD_ROAM: Used for testing the world roaming. We accomplish
+ *     this by using a custom beacon-capable regulatory domain for the first
+ *     radio. All other device world roam.
+ * @HWSIM_REGTEST_CUSTOM_WORLD: Used for testing the custom world regulatory
+ *     domain requests. All radios will adhere to this custom world regulatory
+ *     domain.
+ * @HWSIM_REGTEST_CUSTOM_WORLD_2: Used for testing 2 custom world regulatory
+ *     domain requests. The first radio will adhere to the first custom world
+ *     regulatory domain, the second one to the second custom world regulatory
+ *     domain. All other devices will world roam.
+ * @HWSIM_REGTEST_STRICT_FOLLOW_: Used for testing strict regulatory domain
+ *     settings, only the first radio will send a regulatory domain request
+ *     and use strict settings. The rest of the radios are expected to follow.
+ * @HWSIM_REGTEST_STRICT_ALL: Used for testing strict regulatory domain
+ *     settings. All radios will adhere to this.
+ * @HWSIM_REGTEST_STRICT_AND_DRIVER_REG: Used for testing strict regulatory
+ *     domain settings, combined with secondary driver regulatory domain
+ *     settings. The first radio will get a strict regulatory domain setting
+ *     using the first driver regulatory request and the second radio will use
+ *     non-strict settings using the second driver regulatory request. All
+ *     other devices should follow the intersection created between the
+ *     first two.
+ * @HWSIM_REGTEST_ALL: Used for testing every possible mix. You will need
+ *     at least 6 radios for a complete test. We will test in this order:
+ *     1 - driver custom world regulatory domain
+ *     2 - second custom world regulatory domain
+ *     3 - first driver regulatory domain request
+ *     4 - second driver regulatory domain request
+ *     5 - strict regulatory domain settings using the third driver regulatory
+ *         domain request
+ *     6 and on - should follow the intersection of the 3rd, 4rth and 5th radio
+ *                regulatory requests.
+ */
+enum hwsim_regtest {
+       HWSIM_REGTEST_DISABLED = 0,
+       HWSIM_REGTEST_DRIVER_REG_FOLLOW = 1,
+       HWSIM_REGTEST_DRIVER_REG_ALL = 2,
+       HWSIM_REGTEST_DIFF_COUNTRY = 3,
+       HWSIM_REGTEST_WORLD_ROAM = 4,
+       HWSIM_REGTEST_CUSTOM_WORLD = 5,
+       HWSIM_REGTEST_CUSTOM_WORLD_2 = 6,
+       HWSIM_REGTEST_STRICT_FOLLOW = 7,
+       HWSIM_REGTEST_STRICT_ALL = 8,
+       HWSIM_REGTEST_STRICT_AND_DRIVER_REG = 9,
+       HWSIM_REGTEST_ALL = 10,
+};
+
+/* Set to one of the HWSIM_REGTEST_* values above */
+static int regtest = HWSIM_REGTEST_DISABLED;
+module_param(regtest, int, 0444);
+MODULE_PARM_DESC(regtest, "The type of regulatory test we want to run");
+
+static const char *hwsim_alpha2s[] = {
+       "FI",
+       "AL",
+       "US",
+       "DE",
+       "JP",
+       "AL",
+};
+
+static const struct ieee80211_regdomain hwsim_world_regdom_custom_01 = {
+       .n_reg_rules = 4,
+       .alpha2 =  "99",
+       .reg_rules = {
+               REG_RULE(2412-10, 2462+10, 40, 0, 20, 0),
+               REG_RULE(2484-10, 2484+10, 40, 0, 20, 0),
+               REG_RULE(5150-10, 5240+10, 40, 0, 30, 0),
+               REG_RULE(5745-10, 5825+10, 40, 0, 30, 0),
+       }
+};
+
+static const struct ieee80211_regdomain hwsim_world_regdom_custom_02 = {
+       .n_reg_rules = 2,
+       .alpha2 =  "99",
+       .reg_rules = {
+               REG_RULE(2412-10, 2462+10, 40, 0, 20, 0),
+               REG_RULE(5725-10, 5850+10, 40, 0, 30,
+                       NL80211_RRF_PASSIVE_SCAN | NL80211_RRF_NO_IBSS),
+       }
+};
+
 struct hwsim_vif_priv {
        u32 magic;
        u8 bssid[ETH_ALEN];
@@ -173,11 +295,13 @@ struct mac80211_hwsim_data {
        struct ieee80211_channel channels_5ghz[ARRAY_SIZE(hwsim_channels_5ghz)];
        struct ieee80211_rate rates[ARRAY_SIZE(hwsim_rates)];
 
+       struct mac_address addresses[2];
+
        struct ieee80211_channel *channel;
-       int radio_enabled;
        unsigned long beacon_int; /* in jiffies unit */
        unsigned int rx_filter;
-       int started;
+       bool started, idle, scanning;
+       struct mutex mutex;
        struct timer_list beacon_timer;
        enum ps_mode {
                PS_DISABLED, PS_ENABLED, PS_AUTO_POLL, PS_MANUAL_POLL
@@ -185,6 +309,17 @@ struct mac80211_hwsim_data {
        bool ps_poll_pending;
        struct dentry *debugfs;
        struct dentry *debugfs_ps;
+
+       struct sk_buff_head pending;    /* packets pending */
+       /*
+        * Only radios in the same group can communicate together (the
+        * channel has to match too). Each bit represents a group. A
+        * radio can be in more then one group.
+        */
+       u64 group;
+       struct dentry *debugfs_group;
+
+       int power_level;
 };
 
 
@@ -194,14 +329,41 @@ struct hwsim_radiotap_hdr {
        u8 rt_rate;
        __le16 rt_channel;
        __le16 rt_chbitmask;
-} __attribute__ ((packed));
+} __packed;
+
+/* MAC80211_HWSIM netlinf family */
+static struct genl_family hwsim_genl_family = {
+       .id = GENL_ID_GENERATE,
+       .hdrsize = 0,
+       .name = "MAC80211_HWSIM",
+       .version = 1,
+       .maxattr = HWSIM_ATTR_MAX,
+};
 
+/* MAC80211_HWSIM netlink policy */
+
+static struct nla_policy hwsim_genl_policy[HWSIM_ATTR_MAX + 1] = {
+       [HWSIM_ATTR_ADDR_RECEIVER] = { .type = NLA_UNSPEC,
+                                      .len = 6*sizeof(u8) },
+       [HWSIM_ATTR_ADDR_TRANSMITTER] = { .type = NLA_UNSPEC,
+                                         .len = 6*sizeof(u8) },
+       [HWSIM_ATTR_FRAME] = { .type = NLA_BINARY,
+                              .len = IEEE80211_MAX_DATA_LEN },
+       [HWSIM_ATTR_FLAGS] = { .type = NLA_U32 },
+       [HWSIM_ATTR_RX_RATE] = { .type = NLA_U32 },
+       [HWSIM_ATTR_SIGNAL] = { .type = NLA_U32 },
+       [HWSIM_ATTR_TX_INFO] = { .type = NLA_UNSPEC,
+                                .len = IEEE80211_TX_MAX_RATES*sizeof(
+                                       struct hwsim_tx_rate)},
+       [HWSIM_ATTR_COOKIE] = { .type = NLA_U64 },
+};
 
-static int hwsim_mon_xmit(struct sk_buff *skb, struct net_device *dev)
+static netdev_tx_t hwsim_mon_xmit(struct sk_buff *skb,
+                                       struct net_device *dev)
 {
        /* TODO: allow packet injection */
        dev_kfree_skb(skb);
-       return 0;
+       return NETDEV_TX_OK;
 }
 
 
@@ -249,6 +411,49 @@ static void mac80211_hwsim_monitor_rx(struct ieee80211_hw *hw,
 }
 
 
+static void mac80211_hwsim_monitor_ack(struct ieee80211_hw *hw, const u8 *addr)
+{
+       struct mac80211_hwsim_data *data = hw->priv;
+       struct sk_buff *skb;
+       struct hwsim_radiotap_hdr *hdr;
+       u16 flags;
+       struct ieee80211_hdr *hdr11;
+
+       if (!netif_running(hwsim_mon))
+               return;
+
+       skb = dev_alloc_skb(100);
+       if (skb == NULL)
+               return;
+
+       hdr = (struct hwsim_radiotap_hdr *) skb_put(skb, sizeof(*hdr));
+       hdr->hdr.it_version = PKTHDR_RADIOTAP_VERSION;
+       hdr->hdr.it_pad = 0;
+       hdr->hdr.it_len = cpu_to_le16(sizeof(*hdr));
+       hdr->hdr.it_present = cpu_to_le32((1 << IEEE80211_RADIOTAP_FLAGS) |
+                                         (1 << IEEE80211_RADIOTAP_CHANNEL));
+       hdr->rt_flags = 0;
+       hdr->rt_rate = 0;
+       hdr->rt_channel = cpu_to_le16(data->channel->center_freq);
+       flags = IEEE80211_CHAN_2GHZ;
+       hdr->rt_chbitmask = cpu_to_le16(flags);
+
+       hdr11 = (struct ieee80211_hdr *) skb_put(skb, 10);
+       hdr11->frame_control = cpu_to_le16(IEEE80211_FTYPE_CTL |
+                                          IEEE80211_STYPE_ACK);
+       hdr11->duration_id = cpu_to_le16(0);
+       memcpy(hdr11->addr1, addr, ETH_ALEN);
+
+       skb->dev = hwsim_mon;
+       skb_set_mac_header(skb, 0);
+       skb->ip_summed = CHECKSUM_UNNECESSARY;
+       skb->pkt_type = PACKET_OTHERHOST;
+       skb->protocol = htons(ETH_P_802_2);
+       memset(skb->cb, 0, sizeof(skb->cb));
+       netif_rx(skb);
+}
+
+
 static bool hwsim_ps_rx_ok(struct mac80211_hwsim_data *data,
                           struct sk_buff *skb)
 {
@@ -277,8 +482,120 @@ static bool hwsim_ps_rx_ok(struct mac80211_hwsim_data *data,
 }
 
 
-static bool mac80211_hwsim_tx_frame(struct ieee80211_hw *hw,
-                                   struct sk_buff *skb)
+struct mac80211_hwsim_addr_match_data {
+       bool ret;
+       const u8 *addr;
+};
+
+static void mac80211_hwsim_addr_iter(void *data, u8 *mac,
+                                    struct ieee80211_vif *vif)
+{
+       struct mac80211_hwsim_addr_match_data *md = data;
+       if (memcmp(mac, md->addr, ETH_ALEN) == 0)
+               md->ret = true;
+}
+
+
+static bool mac80211_hwsim_addr_match(struct mac80211_hwsim_data *data,
+                                     const u8 *addr)
+{
+       struct mac80211_hwsim_addr_match_data md;
+
+       if (memcmp(addr, data->hw->wiphy->perm_addr, ETH_ALEN) == 0)
+               return true;
+
+       md.ret = false;
+       md.addr = addr;
+       ieee80211_iterate_active_interfaces_atomic(data->hw,
+                                                  mac80211_hwsim_addr_iter,
+                                                  &md);
+
+       return md.ret;
+}
+
+static void mac80211_hwsim_tx_frame_nl(struct ieee80211_hw *hw,
+                                      struct sk_buff *my_skb,
+                                      int dst_pid)
+{
+       struct sk_buff *skb;
+       struct mac80211_hwsim_data *data = hw->priv;
+       struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) my_skb->data;
+       struct ieee80211_tx_info *info = IEEE80211_SKB_CB(my_skb);
+       void *msg_head;
+       unsigned int hwsim_flags = 0;
+       int i;
+       struct hwsim_tx_rate tx_attempts[IEEE80211_TX_MAX_RATES];
+
+       if (data->idle) {
+               wiphy_debug(hw->wiphy, "Trying to TX when idle - reject\n");
+               dev_kfree_skb(my_skb);
+               return;
+       }
+
+       if (data->ps != PS_DISABLED)
+               hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM);
+       /* If the queue contains MAX_QUEUE skb's drop some */
+       if (skb_queue_len(&data->pending) >= MAX_QUEUE) {
+               /* Droping until WARN_QUEUE level */
+               while (skb_queue_len(&data->pending) >= WARN_QUEUE)
+                       skb_dequeue(&data->pending);
+       }
+
+       skb = genlmsg_new(NLMSG_GOODSIZE, GFP_ATOMIC);
+       if (skb == NULL)
+               goto nla_put_failure;
+
+       msg_head = genlmsg_put(skb, 0, 0, &hwsim_genl_family, 0,
+                              HWSIM_CMD_FRAME);
+       if (msg_head == NULL) {
+               printk(KERN_DEBUG "mac80211_hwsim: problem with msg_head\n");
+               goto nla_put_failure;
+       }
+
+       NLA_PUT(skb, HWSIM_ATTR_ADDR_TRANSMITTER,
+                    sizeof(struct mac_address), data->addresses[1].addr);
+
+       /* We get the skb->data */
+       NLA_PUT(skb, HWSIM_ATTR_FRAME, my_skb->len, my_skb->data);
+
+       /* We get the flags for this transmission, and we translate them to
+          wmediumd flags  */
+
+       if (info->flags & IEEE80211_TX_CTL_REQ_TX_STATUS)
+               hwsim_flags |= HWSIM_TX_CTL_REQ_TX_STATUS;
+
+       if (info->flags & IEEE80211_TX_CTL_NO_ACK)
+               hwsim_flags |= HWSIM_TX_CTL_NO_ACK;
+
+       NLA_PUT_U32(skb, HWSIM_ATTR_FLAGS, hwsim_flags);
+
+       /* We get the tx control (rate and retries) info*/
+
+       for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
+               tx_attempts[i].idx = info->status.rates[i].idx;
+               tx_attempts[i].count = info->status.rates[i].count;
+       }
+
+       NLA_PUT(skb, HWSIM_ATTR_TX_INFO,
+                    sizeof(struct hwsim_tx_rate)*IEEE80211_TX_MAX_RATES,
+                    tx_attempts);
+
+       /* We create a cookie to identify this skb */
+       NLA_PUT_U64(skb, HWSIM_ATTR_COOKIE, (unsigned long) my_skb);
+
+       genlmsg_end(skb, msg_head);
+       genlmsg_unicast(&init_net, skb, dst_pid);
+
+       /* Enqueue the packet */
+       skb_queue_tail(&data->pending, my_skb);
+       return;
+
+nla_put_failure:
+       printk(KERN_DEBUG "mac80211_hwsim: error occured in %s\n", __func__);
+}
+
+static bool mac80211_hwsim_tx_frame_no_nl(struct ieee80211_hw *hw,
+                                         struct sk_buff *skb)
 {
        struct mac80211_hwsim_data *data = hw->priv, *data2;
        bool ack = false;
@@ -286,16 +603,35 @@ static bool mac80211_hwsim_tx_frame(struct ieee80211_hw *hw,
        struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
        struct ieee80211_rx_status rx_status;
 
+       if (data->idle) {
+               wiphy_debug(hw->wiphy, "Trying to TX when idle - reject\n");
+               return false;
+       }
+
        memset(&rx_status, 0, sizeof(rx_status));
        /* TODO: set mactime */
        rx_status.freq = data->channel->center_freq;
        rx_status.band = data->channel->band;
        rx_status.rate_idx = info->control.rates[0].idx;
-       /* TODO: simulate signal strength (and optional packet drop) */
+       if (info->control.rates[0].flags & IEEE80211_TX_RC_MCS)
+               rx_status.flag |= RX_FLAG_HT;
+       if (info->control.rates[0].flags & IEEE80211_TX_RC_40_MHZ_WIDTH)
+               rx_status.flag |= RX_FLAG_40MHZ;
+       if (info->control.rates[0].flags & IEEE80211_TX_RC_SHORT_GI)
+               rx_status.flag |= RX_FLAG_SHORT_GI;
+       /* TODO: simulate real signal strength (and optional packet loss) */
+       rx_status.signal = data->power_level - 50;
 
        if (data->ps != PS_DISABLED)
                hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM);
 
+       /* release the skb's source info */
+       skb_orphan(skb);
+       skb_dst_drop(skb);
+       skb->mark = 0;
+       secpath_reset(skb);
+       nf_reset(skb);
+
        /* Copy skb to all enabled radios that are on the current frequency */
        spin_lock(&hwsim_radio_lock);
        list_for_each_entry(data2, &hwsim_radios, list) {
@@ -304,48 +640,54 @@ static bool mac80211_hwsim_tx_frame(struct ieee80211_hw *hw,
                if (data == data2)
                        continue;
 
-               if (!data2->started || !data2->radio_enabled ||
+               if (data2->idle || !data2->started ||
                    !hwsim_ps_rx_ok(data2, skb) ||
-                   data->channel->center_freq != data2->channel->center_freq)
+                   !data->channel || !data2->channel ||
+                   data->channel->center_freq != data2->channel->center_freq ||
+                   !(data->group & data2->group))
                        continue;
 
                nskb = skb_copy(skb, GFP_ATOMIC);
                if (nskb == NULL)
                        continue;
 
-               if (memcmp(hdr->addr1, data2->hw->wiphy->perm_addr,
-                          ETH_ALEN) == 0)
+               if (mac80211_hwsim_addr_match(data2, hdr->addr1))
                        ack = true;
-               ieee80211_rx_irqsafe(data2->hw, nskb, &rx_status);
+               memcpy(IEEE80211_SKB_RXCB(nskb), &rx_status, sizeof(rx_status));
+               ieee80211_rx_irqsafe(data2->hw, nskb);
        }
        spin_unlock(&hwsim_radio_lock);
 
        return ack;
 }
 
-
-static int mac80211_hwsim_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
+static void mac80211_hwsim_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
 {
-       struct mac80211_hwsim_data *data = hw->priv;
        bool ack;
        struct ieee80211_tx_info *txi;
+       int _pid;
 
        mac80211_hwsim_monitor_rx(hw, skb);
 
        if (skb->len < 10) {
                /* Should not happen; just a sanity check for addr1 use */
                dev_kfree_skb(skb);
-               return NETDEV_TX_OK;
+               return;
        }
 
-       if (!data->radio_enabled) {
-               printk(KERN_DEBUG "%s: dropped TX frame since radio "
-                      "disabled\n", wiphy_name(hw->wiphy));
-               dev_kfree_skb(skb);
-               return NETDEV_TX_OK;
-       }
+       /* wmediumd mode check */
+       _pid = wmediumd_pid;
 
-       ack = mac80211_hwsim_tx_frame(hw, skb);
+       if (_pid)
+               return mac80211_hwsim_tx_frame_nl(hw, skb, _pid);
+
+       /* NO wmediumd detected, perfect medium simulation */
+       ack = mac80211_hwsim_tx_frame_no_nl(hw, skb);
+
+       if (ack && skb->len >= 16) {
+               struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
+               mac80211_hwsim_monitor_ack(hw, hdr->addr2);
+       }
 
        txi = IEEE80211_SKB_CB(skb);
 
@@ -358,14 +700,13 @@ static int mac80211_hwsim_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
        if (!(txi->flags & IEEE80211_TX_CTL_NO_ACK) && ack)
                txi->flags |= IEEE80211_TX_STAT_ACK;
        ieee80211_tx_status_irqsafe(hw, skb);
-       return NETDEV_TX_OK;
 }
 
 
 static int mac80211_hwsim_start(struct ieee80211_hw *hw)
 {
        struct mac80211_hwsim_data *data = hw->priv;
-       printk(KERN_DEBUG "%s:%s\n", wiphy_name(hw->wiphy), __func__);
+       wiphy_debug(hw->wiphy, "%s\n", __func__);
        data->started = 1;
        return 0;
 }
@@ -376,29 +717,44 @@ static void mac80211_hwsim_stop(struct ieee80211_hw *hw)
        struct mac80211_hwsim_data *data = hw->priv;
        data->started = 0;
        del_timer(&data->beacon_timer);
-       printk(KERN_DEBUG "%s:%s\n", wiphy_name(hw->wiphy), __func__);
+       wiphy_debug(hw->wiphy, "%s\n", __func__);
 }
 
 
 static int mac80211_hwsim_add_interface(struct ieee80211_hw *hw,
-                                       struct ieee80211_if_init_conf *conf)
+                                       struct ieee80211_vif *vif)
 {
-       printk(KERN_DEBUG "%s:%s (type=%d mac_addr=%pM)\n",
-              wiphy_name(hw->wiphy), __func__, conf->type,
-              conf->mac_addr);
-       hwsim_set_magic(conf->vif);
+       wiphy_debug(hw->wiphy, "%s (type=%d mac_addr=%pM)\n",
+                   __func__, ieee80211_vif_type_p2p(vif),
+                   vif->addr);
+       hwsim_set_magic(vif);
        return 0;
 }
 
 
+static int mac80211_hwsim_change_interface(struct ieee80211_hw *hw,
+                                          struct ieee80211_vif *vif,
+                                          enum nl80211_iftype newtype,
+                                          bool newp2p)
+{
+       newtype = ieee80211_iftype_p2p(newtype, newp2p);
+       wiphy_debug(hw->wiphy,
+                   "%s (old type=%d, new type=%d, mac_addr=%pM)\n",
+                   __func__, ieee80211_vif_type_p2p(vif),
+                   newtype, vif->addr);
+       hwsim_check_magic(vif);
+
+       return 0;
+}
+
 static void mac80211_hwsim_remove_interface(
-       struct ieee80211_hw *hw, struct ieee80211_if_init_conf *conf)
+       struct ieee80211_hw *hw, struct ieee80211_vif *vif)
 {
-       printk(KERN_DEBUG "%s:%s (type=%d mac_addr=%pM)\n",
-              wiphy_name(hw->wiphy), __func__, conf->type,
-              conf->mac_addr);
-       hwsim_check_magic(conf->vif);
-       hwsim_clear_magic(conf->vif);
+       wiphy_debug(hw->wiphy, "%s (type=%d mac_addr=%pM)\n",
+                   __func__, ieee80211_vif_type_p2p(vif),
+                   vif->addr);
+       hwsim_check_magic(vif);
+       hwsim_clear_magic(vif);
 }
 
 
@@ -408,11 +764,13 @@ static void mac80211_hwsim_beacon_tx(void *arg, u8 *mac,
        struct ieee80211_hw *hw = arg;
        struct sk_buff *skb;
        struct ieee80211_tx_info *info;
+       int _pid;
 
        hwsim_check_magic(vif);
 
        if (vif->type != NL80211_IFTYPE_AP &&
-           vif->type != NL80211_IFTYPE_MESH_POINT)
+           vif->type != NL80211_IFTYPE_MESH_POINT &&
+           vif->type != NL80211_IFTYPE_ADHOC)
                return;
 
        skb = ieee80211_beacon_get(hw, vif);
@@ -421,7 +779,14 @@ static void mac80211_hwsim_beacon_tx(void *arg, u8 *mac,
        info = IEEE80211_SKB_CB(skb);
 
        mac80211_hwsim_monitor_rx(hw, skb);
-       mac80211_hwsim_tx_frame(hw, skb);
+
+       /* wmediumd mode check */
+       _pid = wmediumd_pid;
+
+       if (_pid)
+               return mac80211_hwsim_tx_frame_nl(hw, skb, _pid);
+
+       mac80211_hwsim_tx_frame_no_nl(hw, skb);
        dev_kfree_skb(skb);
 }
 
@@ -431,7 +796,7 @@ static void mac80211_hwsim_beacon(unsigned long arg)
        struct ieee80211_hw *hw = (struct ieee80211_hw *) arg;
        struct mac80211_hwsim_data *data = hw->priv;
 
-       if (!data->started || !data->radio_enabled)
+       if (!data->started)
                return;
 
        ieee80211_iterate_active_interfaces_atomic(
@@ -441,24 +806,38 @@ static void mac80211_hwsim_beacon(unsigned long arg)
        add_timer(&data->beacon_timer);
 }
 
+static const char *hwsim_chantypes[] = {
+       [NL80211_CHAN_NO_HT] = "noht",
+       [NL80211_CHAN_HT20] = "ht20",
+       [NL80211_CHAN_HT40MINUS] = "ht40-",
+       [NL80211_CHAN_HT40PLUS] = "ht40+",
+};
 
 static int mac80211_hwsim_config(struct ieee80211_hw *hw, u32 changed)
 {
        struct mac80211_hwsim_data *data = hw->priv;
        struct ieee80211_conf *conf = &hw->conf;
-
-       printk(KERN_DEBUG "%s:%s (freq=%d radio_enabled=%d beacon_int=%d)\n",
-              wiphy_name(hw->wiphy), __func__,
-              conf->channel->center_freq, conf->radio_enabled,
-              conf->beacon_int);
+       static const char *smps_modes[IEEE80211_SMPS_NUM_MODES] = {
+               [IEEE80211_SMPS_AUTOMATIC] = "auto",
+               [IEEE80211_SMPS_OFF] = "off",
+               [IEEE80211_SMPS_STATIC] = "static",
+               [IEEE80211_SMPS_DYNAMIC] = "dynamic",
+       };
+
+       wiphy_debug(hw->wiphy,
+                   "%s (freq=%d/%s idle=%d ps=%d smps=%s)\n",
+                   __func__,
+                   conf->channel->center_freq,
+                   hwsim_chantypes[conf->channel_type],
+                   !!(conf->flags & IEEE80211_CONF_IDLE),
+                   !!(conf->flags & IEEE80211_CONF_PS),
+                   smps_modes[conf->smps_mode]);
+
+       data->idle = !!(conf->flags & IEEE80211_CONF_IDLE);
 
        data->channel = conf->channel;
-       data->radio_enabled = conf->radio_enabled;
-       data->beacon_int = 1024 * conf->beacon_int / 1000 * HZ / 1000;
-       if (data->beacon_int < 1)
-               data->beacon_int = 1;
-
-       if (!data->started || !data->radio_enabled)
+       data->power_level = conf->power_level;
+       if (!data->started || !data->beacon_int)
                del_timer(&data->beacon_timer);
        else
                mod_timer(&data->beacon_timer, jiffies + data->beacon_int);
@@ -469,13 +848,11 @@ static int mac80211_hwsim_config(struct ieee80211_hw *hw, u32 changed)
 
 static void mac80211_hwsim_configure_filter(struct ieee80211_hw *hw,
                                            unsigned int changed_flags,
-                                           unsigned int *total_flags,
-                                           int mc_count,
-                                           struct dev_addr_list *mc_list)
+                                           unsigned int *total_flags,u64 multicast)
 {
        struct mac80211_hwsim_data *data = hw->priv;
 
-       printk(KERN_DEBUG "%s:%s\n", wiphy_name(hw->wiphy), __func__);
+       wiphy_debug(hw->wiphy, "%s\n", __func__);
 
        data->rx_filter = 0;
        if (*total_flags & FIF_PROMISC_IN_BSS)
@@ -486,87 +863,102 @@ static void mac80211_hwsim_configure_filter(struct ieee80211_hw *hw,
        *total_flags = data->rx_filter;
 }
 
-static int mac80211_hwsim_config_interface(struct ieee80211_hw *hw,
-                                          struct ieee80211_vif *vif,
-                                          struct ieee80211_if_conf *conf)
-{
-       struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
-
-       hwsim_check_magic(vif);
-       if (conf->changed & IEEE80211_IFCC_BSSID) {
-               DECLARE_MAC_BUF(mac);
-               printk(KERN_DEBUG "%s:%s: BSSID changed: %pM\n",
-                      wiphy_name(hw->wiphy), __func__,
-                      conf->bssid);
-               memcpy(vp->bssid, conf->bssid, ETH_ALEN);
-       }
-       return 0;
-}
-
 static void mac80211_hwsim_bss_info_changed(struct ieee80211_hw *hw,
                                            struct ieee80211_vif *vif,
                                            struct ieee80211_bss_conf *info,
                                            u32 changed)
 {
        struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
+       struct mac80211_hwsim_data *data = hw->priv;
 
        hwsim_check_magic(vif);
 
-       printk(KERN_DEBUG "%s:%s(changed=0x%x)\n",
-              wiphy_name(hw->wiphy), __func__, changed);
+       wiphy_debug(hw->wiphy, "%s(changed=0x%x)\n", __func__, changed);
+
+       if (changed & BSS_CHANGED_BSSID) {
+               wiphy_debug(hw->wiphy, "%s: BSSID changed: %pM\n",
+                           __func__, info->bssid);
+               memcpy(vp->bssid, info->bssid, ETH_ALEN);
+       }
 
        if (changed & BSS_CHANGED_ASSOC) {
-               printk(KERN_DEBUG "  %s: ASSOC: assoc=%d aid=%d\n",
-                      wiphy_name(hw->wiphy), info->assoc, info->aid);
+               wiphy_debug(hw->wiphy, "  ASSOC: assoc=%d aid=%d\n",
+                           info->assoc, info->aid);
                vp->assoc = info->assoc;
                vp->aid = info->aid;
        }
 
+       if (changed & BSS_CHANGED_BEACON_INT) {
+               wiphy_debug(hw->wiphy, "  BCNINT: %d\n", info->beacon_int);
+               data->beacon_int = 1024 * info->beacon_int / 1000 * HZ / 1000;
+               if (WARN_ON(!data->beacon_int))
+                       data->beacon_int = 1;
+               if (data->started)
+                       mod_timer(&data->beacon_timer,
+                                 jiffies + data->beacon_int);
+       }
+
        if (changed & BSS_CHANGED_ERP_CTS_PROT) {
-               printk(KERN_DEBUG "  %s: ERP_CTS_PROT: %d\n",
-                      wiphy_name(hw->wiphy), info->use_cts_prot);
+               wiphy_debug(hw->wiphy, "  ERP_CTS_PROT: %d\n",
+                           info->use_cts_prot);
        }
 
        if (changed & BSS_CHANGED_ERP_PREAMBLE) {
-               printk(KERN_DEBUG "  %s: ERP_PREAMBLE: %d\n",
-                      wiphy_name(hw->wiphy), info->use_short_preamble);
+               wiphy_debug(hw->wiphy, "  ERP_PREAMBLE: %d\n",
+                           info->use_short_preamble);
        }
 
        if (changed & BSS_CHANGED_ERP_SLOT) {
-               printk(KERN_DEBUG "  %s: ERP_SLOT: %d\n",
-                      wiphy_name(hw->wiphy), info->use_short_slot);
+               wiphy_debug(hw->wiphy, "  ERP_SLOT: %d\n", info->use_short_slot);
        }
 
        if (changed & BSS_CHANGED_HT) {
-               printk(KERN_DEBUG "  %s: HT: op_mode=0x%x\n",
-                      wiphy_name(hw->wiphy),
-                      info->ht.operation_mode);
+               wiphy_debug(hw->wiphy, "  HT: op_mode=0x%x, chantype=%s\n",
+                           info->ht_operation_mode,
+                           hwsim_chantypes[info->channel_type]);
        }
 
        if (changed & BSS_CHANGED_BASIC_RATES) {
-               printk(KERN_DEBUG "  %s: BASIC_RATES: 0x%llx\n",
-                      wiphy_name(hw->wiphy),
-                      (unsigned long long) info->basic_rates);
+               wiphy_debug(hw->wiphy, "  BASIC_RATES: 0x%llx\n",
+                           (unsigned long long) info->basic_rates);
        }
 }
 
+static int mac80211_hwsim_sta_add(struct ieee80211_hw *hw,
+                                 struct ieee80211_vif *vif,
+                                 struct ieee80211_sta *sta)
+{
+       hwsim_check_magic(vif);
+       hwsim_set_sta_magic(sta);
+
+       return 0;
+}
+
+static int mac80211_hwsim_sta_remove(struct ieee80211_hw *hw,
+                                    struct ieee80211_vif *vif,
+                                    struct ieee80211_sta *sta)
+{
+       hwsim_check_magic(vif);
+       hwsim_clear_sta_magic(sta);
+
+       return 0;
+}
+
 static void mac80211_hwsim_sta_notify(struct ieee80211_hw *hw,
                                      struct ieee80211_vif *vif,
                                      enum sta_notify_cmd cmd,
                                      struct ieee80211_sta *sta)
 {
        hwsim_check_magic(vif);
+
        switch (cmd) {
-       case STA_NOTIFY_ADD:
-               hwsim_set_sta_magic(sta);
-               break;
-       case STA_NOTIFY_REMOVE:
-               hwsim_clear_sta_magic(sta);
-               break;
        case STA_NOTIFY_SLEEP:
        case STA_NOTIFY_AWAKE:
                /* TODO: make good use of these flags */
                break;
+       default:
+               WARN(1, "Invalid sta notify: %d\n", cmd);
+               break;
        }
 }
 
@@ -579,37 +971,240 @@ static int mac80211_hwsim_set_tim(struct ieee80211_hw *hw,
 }
 
 static int mac80211_hwsim_conf_tx(
-       struct ieee80211_hw *hw, u16 queue,
+       struct ieee80211_hw *hw,
+       struct ieee80211_vif *vif, u16 queue,
        const struct ieee80211_tx_queue_params *params)
 {
-       printk(KERN_DEBUG "%s:%s (queue=%d txop=%d cw_min=%d cw_max=%d "
-              "aifs=%d)\n",
-              wiphy_name(hw->wiphy), __func__, queue,
-              params->txop, params->cw_min, params->cw_max, params->aifs);
+       wiphy_debug(hw->wiphy,
+                   "%s (queue=%d txop=%d cw_min=%d cw_max=%d aifs=%d)\n",
+                   __func__, queue,
+                   params->txop, params->cw_min,
+                   params->cw_max, params->aifs);
+       return 0;
+}
+
+static int mac80211_hwsim_get_survey(
+       struct ieee80211_hw *hw, int idx,
+       struct survey_info *survey)
+{
+       struct ieee80211_conf *conf = &hw->conf;
+
+       wiphy_debug(hw->wiphy, "%s (idx=%d)\n", __func__, idx);
+
+       if (idx != 0)
+               return -ENOENT;
+
+       /* Current channel */
+       survey->channel = conf->channel;
+
+       /*
+        * Magically conjured noise level --- this is only ok for simulated hardware.
+        *
+        * A real driver which cannot determine the real channel noise MUST NOT
+        * report any noise, especially not a magically conjured one :-)
+        */
+       survey->filled = SURVEY_INFO_NOISE_DBM;
+       survey->noise = -92;
+
        return 0;
 }
 
-static const struct ieee80211_ops mac80211_hwsim_ops =
+#ifdef CONFIG_NL80211_TESTMODE
+/*
+ * This section contains example code for using netlink
+ * attributes with the testmode command in nl80211.
+ */
+
+/* These enums need to be kept in sync with userspace */
+enum hwsim_testmode_attr {
+       __HWSIM_TM_ATTR_INVALID = 0,
+       HWSIM_TM_ATTR_CMD       = 1,
+       HWSIM_TM_ATTR_PS        = 2,
+
+       /* keep last */
+       __HWSIM_TM_ATTR_AFTER_LAST,
+       HWSIM_TM_ATTR_MAX       = __HWSIM_TM_ATTR_AFTER_LAST - 1
+};
+
+enum hwsim_testmode_cmd {
+       HWSIM_TM_CMD_SET_PS             = 0,
+       HWSIM_TM_CMD_GET_PS             = 1,
+};
+
+static const struct nla_policy hwsim_testmode_policy[HWSIM_TM_ATTR_MAX + 1] = {
+       [HWSIM_TM_ATTR_CMD] = { .type = NLA_U32 },
+       [HWSIM_TM_ATTR_PS] = { .type = NLA_U32 },
+};
+
+static int hwsim_fops_ps_write(void *dat, u64 val);
+
+static int mac80211_hwsim_testmode_cmd(struct ieee80211_hw *hw,
+                                      void *data, int len)
+{
+       struct mac80211_hwsim_data *hwsim = hw->priv;
+       struct nlattr *tb[HWSIM_TM_ATTR_MAX + 1];
+       struct sk_buff *skb;
+       int err, ps;
+
+       err = nla_parse(tb, HWSIM_TM_ATTR_MAX, data, len,
+                       hwsim_testmode_policy);
+       if (err)
+               return err;
+
+       if (!tb[HWSIM_TM_ATTR_CMD])
+               return -EINVAL;
+
+       switch (nla_get_u32(tb[HWSIM_TM_ATTR_CMD])) {
+       case HWSIM_TM_CMD_SET_PS:
+               if (!tb[HWSIM_TM_ATTR_PS])
+                       return -EINVAL;
+               ps = nla_get_u32(tb[HWSIM_TM_ATTR_PS]);
+               return hwsim_fops_ps_write(hwsim, ps);
+       case HWSIM_TM_CMD_GET_PS:
+               skb = cfg80211_testmode_alloc_reply_skb(hw->wiphy,
+                                               nla_total_size(sizeof(u32)));
+               if (!skb)
+                       return -ENOMEM;
+               NLA_PUT_U32(skb, HWSIM_TM_ATTR_PS, hwsim->ps);
+               return cfg80211_testmode_reply(skb);
+       default:
+               return -EOPNOTSUPP;
+       }
+
+ nla_put_failure:
+       kfree_skb(skb);
+       return -ENOBUFS;
+}
+#endif
+
+static int mac80211_hwsim_ampdu_action(struct ieee80211_hw *hw,
+                                      struct ieee80211_vif *vif,
+                                      enum ieee80211_ampdu_mlme_action action,
+                                      struct ieee80211_sta *sta, u16 tid, u16 *ssn,
+                                      u8 buf_size)
+{
+       switch (action) {
+       case IEEE80211_AMPDU_TX_START:
+               ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid);
+               break;
+       case IEEE80211_AMPDU_TX_STOP:
+               ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
+               break;
+       case IEEE80211_AMPDU_TX_OPERATIONAL:
+               break;
+       case IEEE80211_AMPDU_RX_START:
+       case IEEE80211_AMPDU_RX_STOP:
+               break;
+       default:
+               return -EOPNOTSUPP;
+       }
+
+       return 0;
+}
+
+static void mac80211_hwsim_flush(struct ieee80211_hw *hw, bool drop)
+{
+       /* Not implemented, queues only on kernel side */
+}
+
+struct hw_scan_done {
+       struct delayed_work w;
+       struct ieee80211_hw *hw;
+};
+
+static void hw_scan_done(struct work_struct *work)
+{
+       struct hw_scan_done *hsd =
+               container_of(work, struct hw_scan_done, w.work);
+
+       ieee80211_scan_completed(hsd->hw, false);
+       kfree(hsd);
+}
+
+static int mac80211_hwsim_hw_scan(struct ieee80211_hw *hw,
+                                 struct ieee80211_vif *vif,
+                                 struct cfg80211_scan_request *req)
+{
+       struct hw_scan_done *hsd = kzalloc(sizeof(*hsd), GFP_KERNEL);
+       int i;
+
+       if (!hsd)
+               return -ENOMEM;
+
+       hsd->hw = hw;
+       INIT_DELAYED_WORK(&hsd->w, hw_scan_done);
+
+       printk(KERN_DEBUG "hwsim hw_scan request\n");
+       for (i = 0; i < req->n_channels; i++)
+               printk(KERN_DEBUG "hwsim hw_scan freq %d\n",
+                       req->channels[i]->center_freq);
+       print_hex_dump(KERN_DEBUG, "scan IEs: ", DUMP_PREFIX_OFFSET,
+                       16, 1, req->ie, req->ie_len, 1);
+
+       ieee80211_queue_delayed_work(hw, &hsd->w, 2 * HZ);
+
+       return 0;
+}
+
+static void mac80211_hwsim_sw_scan(struct ieee80211_hw *hw)
+{
+       struct mac80211_hwsim_data *hwsim = hw->priv;
+
+       mutex_lock(&hwsim->mutex);
+
+       if (hwsim->scanning) {
+               printk(KERN_DEBUG "two hwsim sw_scans detected!\n");
+               goto out;
+       }
+
+       printk(KERN_DEBUG "hwsim sw_scan request, prepping stuff\n");
+       hwsim->scanning = true;
+
+out:
+       mutex_unlock(&hwsim->mutex);
+}
+
+static void mac80211_hwsim_sw_scan_complete(struct ieee80211_hw *hw)
+{
+       struct mac80211_hwsim_data *hwsim = hw->priv;
+
+       mutex_lock(&hwsim->mutex);
+
+       printk(KERN_DEBUG "hwsim sw_scan_complete\n");
+       hwsim->scanning = false;
+
+       mutex_unlock(&hwsim->mutex);
+}
+
+static struct ieee80211_ops mac80211_hwsim_ops =
 {
        .tx = mac80211_hwsim_tx,
        .start = mac80211_hwsim_start,
        .stop = mac80211_hwsim_stop,
        .add_interface = mac80211_hwsim_add_interface,
+       .change_interface = mac80211_hwsim_change_interface,
        .remove_interface = mac80211_hwsim_remove_interface,
        .config = mac80211_hwsim_config,
        .configure_filter = mac80211_hwsim_configure_filter,
-       .config_interface = mac80211_hwsim_config_interface,
        .bss_info_changed = mac80211_hwsim_bss_info_changed,
+       .sta_add = mac80211_hwsim_sta_add,
+       .sta_remove = mac80211_hwsim_sta_remove,
        .sta_notify = mac80211_hwsim_sta_notify,
        .set_tim = mac80211_hwsim_set_tim,
        .conf_tx = mac80211_hwsim_conf_tx,
+       .get_survey = mac80211_hwsim_get_survey,
+       CFG80211_TESTMODE_CMD(mac80211_hwsim_testmode_cmd)
+       .ampdu_action = mac80211_hwsim_ampdu_action,
+       .sw_scan_start = mac80211_hwsim_sw_scan,
+       .sw_scan_complete = mac80211_hwsim_sw_scan_complete,
+       .flush = mac80211_hwsim_flush,
 };
 
 
 static void mac80211_hwsim_free(void)
 {
        struct list_head tmplist, *i, *tmp;
-       struct mac80211_hwsim_data *data;
+       struct mac80211_hwsim_data *data, *tmpdata;
 
        INIT_LIST_HEAD(&tmplist);
 
@@ -618,7 +1213,8 @@ static void mac80211_hwsim_free(void)
                list_move(i, &tmplist);
        spin_unlock_bh(&hwsim_radio_lock);
 
-       list_for_each_entry(data, &tmplist, list) {
+       list_for_each_entry_safe(data, tmpdata, &tmplist, list) {
+               debugfs_remove(data->debugfs_group);
                debugfs_remove(data->debugfs_ps);
                debugfs_remove(data->debugfs);
                ieee80211_unregister_hw(data->hw);
@@ -633,10 +1229,16 @@ static struct device_driver mac80211_hwsim_driver = {
        .name = "mac80211_hwsim"
 };
 
+static const struct net_device_ops hwsim_netdev_ops = {
+       .ndo_start_xmit         = hwsim_mon_xmit,
+       .ndo_change_mtu         = eth_change_mtu,
+       .ndo_set_mac_address    = eth_mac_addr,
+       .ndo_validate_addr      = eth_validate_addr,
+};
 
 static void hwsim_mon_setup(struct net_device *dev)
 {
-       dev->hard_start_xmit = hwsim_mon_xmit;
+       dev->netdev_ops = &hwsim_netdev_ops;
        dev->destructor = free_netdev;
        ether_setup(dev);
        dev->tx_queue_len = 0;
@@ -650,15 +1252,16 @@ static void hwsim_send_ps_poll(void *dat, u8 *mac, struct ieee80211_vif *vif)
 {
        struct mac80211_hwsim_data *data = dat;
        struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
-       DECLARE_MAC_BUF(buf);
        struct sk_buff *skb;
        struct ieee80211_pspoll *pspoll;
+       int _pid;
 
        if (!vp->assoc)
                return;
 
-       printk(KERN_DEBUG "%s:%s: send PS-Poll to %pM for aid %d\n",
-              wiphy_name(data->hw->wiphy), __func__, vp->bssid, vp->aid);
+       wiphy_debug(data->hw->wiphy,
+                   "%s: send PS-Poll to %pM for aid %d\n",
+                   __func__, vp->bssid, vp->aid);
 
        skb = dev_alloc_skb(sizeof(*pspoll));
        if (!skb)
@@ -670,9 +1273,15 @@ static void hwsim_send_ps_poll(void *dat, u8 *mac, struct ieee80211_vif *vif)
        pspoll->aid = cpu_to_le16(0xc000 | vp->aid);
        memcpy(pspoll->bssid, vp->bssid, ETH_ALEN);
        memcpy(pspoll->ta, mac, ETH_ALEN);
-       if (data->radio_enabled &&
-           !mac80211_hwsim_tx_frame(data->hw, skb))
-               printk(KERN_DEBUG "%s: PS-Poll frame not ack'ed\n", __func__);
+
+       /* wmediumd mode check */
+       _pid = wmediumd_pid;
+
+       if (_pid)
+               return mac80211_hwsim_tx_frame_nl(data->hw, skb, _pid);
+
+       if (!mac80211_hwsim_tx_frame_no_nl(data->hw, skb))
+               printk(KERN_DEBUG "%s: PS-poll frame not ack'ed\n", __func__);
        dev_kfree_skb(skb);
 }
 
@@ -681,15 +1290,16 @@ static void hwsim_send_nullfunc(struct mac80211_hwsim_data *data, u8 *mac,
                                struct ieee80211_vif *vif, int ps)
 {
        struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
-       DECLARE_MAC_BUF(buf);
        struct sk_buff *skb;
        struct ieee80211_hdr *hdr;
+       int _pid;
 
        if (!vp->assoc)
                return;
 
-       printk(KERN_DEBUG "%s:%s: send data::nullfunc to %pM ps=%d\n",
-              wiphy_name(data->hw->wiphy), __func__, vp->bssid, ps);
+       wiphy_debug(data->hw->wiphy,
+                   "%s: send data::nullfunc to %pM ps=%d\n",
+                   __func__, vp->bssid, ps);
 
        skb = dev_alloc_skb(sizeof(*hdr));
        if (!skb)
@@ -702,8 +1312,14 @@ static void hwsim_send_nullfunc(struct mac80211_hwsim_data *data, u8 *mac,
        memcpy(hdr->addr1, vp->bssid, ETH_ALEN);
        memcpy(hdr->addr2, mac, ETH_ALEN);
        memcpy(hdr->addr3, vp->bssid, ETH_ALEN);
-       if (data->radio_enabled &&
-           !mac80211_hwsim_tx_frame(data->hw, skb))
+
+       /* wmediumd mode check */
+       _pid = wmediumd_pid;
+
+       if (_pid)
+               return mac80211_hwsim_tx_frame_nl(data->hw, skb, _pid);
+
+       if (!mac80211_hwsim_tx_frame_no_nl(data->hw, skb))
                printk(KERN_DEBUG "%s: nullfunc frame not ack'ed\n", __func__);
        dev_kfree_skb(skb);
 }
@@ -765,6 +1381,291 @@ DEFINE_SIMPLE_ATTRIBUTE(hwsim_fops_ps, hwsim_fops_ps_read, hwsim_fops_ps_write,
                        "%llu\n");
 
 
+static int hwsim_fops_group_read(void *dat, u64 *val)
+{
+       struct mac80211_hwsim_data *data = dat;
+       *val = data->group;
+       return 0;
+}
+
+static int hwsim_fops_group_write(void *dat, u64 val)
+{
+       struct mac80211_hwsim_data *data = dat;
+       data->group = val;
+       return 0;
+}
+
+DEFINE_SIMPLE_ATTRIBUTE(hwsim_fops_group,
+                       hwsim_fops_group_read, hwsim_fops_group_write,
+                       "%llx\n");
+
+struct mac80211_hwsim_data *get_hwsim_data_ref_from_addr(
+                            struct mac_address *addr)
+{
+       struct mac80211_hwsim_data *data;
+       bool _found = false;
+
+       spin_lock_bh(&hwsim_radio_lock);
+       list_for_each_entry(data, &hwsim_radios, list) {
+               if (memcmp(data->addresses[1].addr, addr,
+                         sizeof(struct mac_address)) == 0) {
+                       _found = true;
+                       break;
+               }
+       }
+       spin_unlock_bh(&hwsim_radio_lock);
+
+       if (!_found)
+               return NULL;
+
+       return data;
+}
+
+static int hwsim_tx_info_frame_received_nl(struct sk_buff *skb_2,
+                                          struct genl_info *info)
+{
+
+       struct ieee80211_hdr *hdr;
+       struct mac80211_hwsim_data *data2;
+       struct ieee80211_tx_info *txi;
+       struct hwsim_tx_rate *tx_attempts;
+       struct sk_buff __user *ret_skb;
+       struct sk_buff *skb, *tmp;
+       struct mac_address *src;
+       unsigned int hwsim_flags;
+
+       int i;
+       bool found = false;
+
+       if (!info->attrs[HWSIM_ATTR_ADDR_TRANSMITTER] ||
+          !info->attrs[HWSIM_ATTR_FLAGS] ||
+          !info->attrs[HWSIM_ATTR_COOKIE] ||
+          !info->attrs[HWSIM_ATTR_TX_INFO])
+               goto out;
+
+       src = (struct mac_address *)nla_data(
+                                  info->attrs[HWSIM_ATTR_ADDR_TRANSMITTER]);
+       hwsim_flags = nla_get_u32(info->attrs[HWSIM_ATTR_FLAGS]);
+
+       ret_skb = (struct sk_buff __user *)
+                 (unsigned long) nla_get_u64(info->attrs[HWSIM_ATTR_COOKIE]);
+
+       data2 = get_hwsim_data_ref_from_addr(src);
+
+       if (data2 == NULL)
+               goto out;
+
+       /* look for the skb matching the cookie passed back from user */
+       skb_queue_walk_safe(&data2->pending, skb, tmp) {
+               if (skb == ret_skb) {
+                       skb_unlink(skb, &data2->pending);
+                       found = true;
+                       break;
+               }
+       }
+
+       /* not found */
+       if (!found)
+               goto out;
+
+       /* Tx info received because the frame was broadcasted on user space,
+        so we get all the necessary info: tx attempts and skb control buff */
+
+       tx_attempts = (struct hwsim_tx_rate *)nla_data(
+                      info->attrs[HWSIM_ATTR_TX_INFO]);
+
+       /* now send back TX status */
+       txi = IEEE80211_SKB_CB(skb);
+
+       if (txi->control.vif)
+               hwsim_check_magic(txi->control.vif);
+       if (txi->control.sta)
+               hwsim_check_sta_magic(txi->control.sta);
+
+       ieee80211_tx_info_clear_status(txi);
+
+       for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
+               txi->status.rates[i].idx = tx_attempts[i].idx;
+               txi->status.rates[i].count = tx_attempts[i].count;
+               /*txi->status.rates[i].flags = 0;*/
+       }
+
+       txi->status.ack_signal = nla_get_u32(info->attrs[HWSIM_ATTR_SIGNAL]);
+
+       if (!(hwsim_flags & HWSIM_TX_CTL_NO_ACK) &&
+          (hwsim_flags & HWSIM_TX_STAT_ACK)) {
+               if (skb->len >= 16) {
+                       hdr = (struct ieee80211_hdr *) skb->data;
+                       mac80211_hwsim_monitor_ack(data2->hw, hdr->addr2);
+               }
+       }
+       ieee80211_tx_status_irqsafe(data2->hw, skb);
+       return 0;
+out:
+       return -EINVAL;
+
+}
+
+static int hwsim_cloned_frame_received_nl(struct sk_buff *skb_2,
+                                         struct genl_info *info)
+{
+
+       struct mac80211_hwsim_data  *data2;
+       struct ieee80211_rx_status rx_status;
+       struct mac_address *dst;
+       int frame_data_len;
+       char *frame_data;
+       struct sk_buff *skb = NULL;
+
+       if (!info->attrs[HWSIM_ATTR_ADDR_RECEIVER] ||
+          !info->attrs[HWSIM_ATTR_FRAME] ||
+          !info->attrs[HWSIM_ATTR_RX_RATE] ||
+          !info->attrs[HWSIM_ATTR_SIGNAL])
+               goto out;
+
+       dst = (struct mac_address *)nla_data(
+                                  info->attrs[HWSIM_ATTR_ADDR_RECEIVER]);
+
+       frame_data_len = nla_len(info->attrs[HWSIM_ATTR_FRAME]);
+       frame_data = (char *)nla_data(info->attrs[HWSIM_ATTR_FRAME]);
+
+       /* Allocate new skb here */
+       skb = alloc_skb(frame_data_len, GFP_KERNEL);
+       if (skb == NULL)
+               goto err;
+
+       if (frame_data_len <= IEEE80211_MAX_DATA_LEN) {
+               /* Copy the data */
+               memcpy(skb_put(skb, frame_data_len), frame_data,
+                      frame_data_len);
+       } else
+               goto err;
+
+       data2 = get_hwsim_data_ref_from_addr(dst);
+
+       if (data2 == NULL)
+               goto out;
+
+       /* check if radio is configured properly */
+
+       if (data2->idle || !data2->started || !data2->channel)
+               goto out;
+
+       /*A frame is received from user space*/
+       memset(&rx_status, 0, sizeof(rx_status));
+       rx_status.freq = data2->channel->center_freq;
+       rx_status.band = data2->channel->band;
+       rx_status.rate_idx = nla_get_u32(info->attrs[HWSIM_ATTR_RX_RATE]);
+       rx_status.signal = nla_get_u32(info->attrs[HWSIM_ATTR_SIGNAL]);
+
+       memcpy(IEEE80211_SKB_RXCB(skb), &rx_status, sizeof(rx_status));
+       ieee80211_rx_irqsafe(data2->hw, skb);
+
+       return 0;
+err:
+       printk(KERN_DEBUG "mac80211_hwsim: error occured in %s\n", __func__);
+       goto out;
+out:
+       dev_kfree_skb(skb);
+       return -EINVAL;
+}
+
+static int hwsim_register_received_nl(struct sk_buff *skb_2,
+                                     struct genl_info *info)
+{
+       if (info == NULL)
+               goto out;
+
+       wmediumd_pid = info->snd_pid;
+
+       printk(KERN_DEBUG "mac80211_hwsim: received a REGISTER, "
+       "switching to wmediumd mode with pid %d\n", info->snd_pid);
+
+       return 0;
+out:
+       printk(KERN_DEBUG "mac80211_hwsim: error occured in %s\n", __func__);
+       return -EINVAL;
+}
+
+/* Generic Netlink operations array */
+static struct genl_ops hwsim_ops[] = {
+       {
+               .cmd = HWSIM_CMD_REGISTER,
+               .policy = hwsim_genl_policy,
+               .doit = hwsim_register_received_nl,
+               .flags = GENL_ADMIN_PERM,
+       },
+       {
+               .cmd = HWSIM_CMD_FRAME,
+               .policy = hwsim_genl_policy,
+               .doit = hwsim_cloned_frame_received_nl,
+       },
+       {
+               .cmd = HWSIM_CMD_TX_INFO_FRAME,
+               .policy = hwsim_genl_policy,
+               .doit = hwsim_tx_info_frame_received_nl,
+       },
+};
+
+static int mac80211_hwsim_netlink_notify(struct notifier_block *nb,
+                                        unsigned long state,
+                                        void *_notify)
+{
+       struct netlink_notify *notify = _notify;
+
+       if (state != NETLINK_URELEASE)
+               return NOTIFY_DONE;
+
+       if (notify->pid == wmediumd_pid) {
+               printk(KERN_INFO "mac80211_hwsim: wmediumd released netlink"
+                      " socket, switching to perfect channel medium\n");
+               wmediumd_pid = 0;
+       }
+       return NOTIFY_DONE;
+
+}
+
+static struct notifier_block hwsim_netlink_notifier = {
+       .notifier_call = mac80211_hwsim_netlink_notify,
+};
+
+static int hwsim_init_netlink(void)
+{
+       int rc;
+       printk(KERN_INFO "mac80211_hwsim: initializing netlink\n");
+
+       wmediumd_pid = 0;
+
+       rc = genl_register_family_with_ops(&hwsim_genl_family,
+               hwsim_ops, ARRAY_SIZE(hwsim_ops));
+       if (rc)
+               goto failure;
+
+       rc = netlink_register_notifier(&hwsim_netlink_notifier);
+       if (rc)
+               goto failure;
+
+       return 0;
+
+failure:
+       printk(KERN_DEBUG "mac80211_hwsim: error occured in %s\n", __func__);
+       return -EINVAL;
+}
+
+static void hwsim_exit_netlink(void)
+{
+       int ret;
+
+       printk(KERN_INFO "mac80211_hwsim: closing netlink\n");
+       /* unregister the notifier */
+       netlink_unregister_notifier(&hwsim_netlink_notifier);
+       /* unregister the family */
+       ret = genl_unregister_family(&hwsim_genl_family);
+       if (ret)
+               printk(KERN_DEBUG "mac80211_hwsim: "
+                      "unregister family %i\n", ret);
+}
+
 static int __init init_mac80211_hwsim(void)
 {
        int i, err = 0;
@@ -776,6 +1677,12 @@ static int __init init_mac80211_hwsim(void)
        if (radios < 1 || radios > 100)
                return -EINVAL;
 
+       if (fake_hw_scan) {
+               mac80211_hwsim_ops.hw_scan = mac80211_hwsim_hw_scan;
+               mac80211_hwsim_ops.sw_scan_start = NULL;
+               mac80211_hwsim_ops.sw_scan_complete = NULL;
+       }
+
        spin_lock_init(&hwsim_radio_lock);
        INIT_LIST_HEAD(&hwsim_radios);
 
@@ -809,21 +1716,39 @@ static int __init init_mac80211_hwsim(void)
                        goto failed_drvdata;
                }
                data->dev->driver = &mac80211_hwsim_driver;
+               skb_queue_head_init(&data->pending);
 
                SET_IEEE80211_DEV(hw, data->dev);
                addr[3] = i >> 8;
                addr[4] = i;
-               SET_IEEE80211_PERM_ADDR(hw, addr);
+               memcpy(data->addresses[0].addr, addr, ETH_ALEN);
+               memcpy(data->addresses[1].addr, addr, ETH_ALEN);
+               data->addresses[1].addr[0] |= 0x40;
+               hw->wiphy->n_addresses = 2;
+               hw->wiphy->addresses = data->addresses;
+
+               if (fake_hw_scan) {
+                       hw->wiphy->max_scan_ssids = 255;
+                       hw->wiphy->max_scan_ie_len = IEEE80211_MAX_DATA_LEN;
+               }
 
                hw->channel_change_time = 1;
                hw->queues = 4;
                hw->wiphy->interface_modes =
                        BIT(NL80211_IFTYPE_STATION) |
                        BIT(NL80211_IFTYPE_AP) |
+                       BIT(NL80211_IFTYPE_P2P_CLIENT) |
+                       BIT(NL80211_IFTYPE_P2P_GO) |
+                       BIT(NL80211_IFTYPE_ADHOC) |
                        BIT(NL80211_IFTYPE_MESH_POINT);
-               hw->ampdu_queues = 1;
 
-               hw->flags = IEEE80211_HW_MFP_CAPABLE;
+               hw->flags = IEEE80211_HW_MFP_CAPABLE |
+                           IEEE80211_HW_SIGNAL_DBM |
+                           IEEE80211_HW_SUPPORTS_STATIC_SMPS |
+                           IEEE80211_HW_SUPPORTS_DYNAMIC_SMPS |
+                           IEEE80211_HW_AMPDU_AGGREGATION;
+
+               hw->wiphy->flags |= WIPHY_FLAG_SUPPORTS_TDLS;
 
                /* ask mac80211 to reserve space for magic */
                hw->vif_data_size = sizeof(struct hwsim_vif_priv);
@@ -842,19 +1767,20 @@ static int __init init_mac80211_hwsim(void)
                                sband->channels = data->channels_2ghz;
                                sband->n_channels =
                                        ARRAY_SIZE(hwsim_channels_2ghz);
+                               sband->bitrates = data->rates;
+                               sband->n_bitrates = ARRAY_SIZE(hwsim_rates);
                                break;
                        case IEEE80211_BAND_5GHZ:
                                sband->channels = data->channels_5ghz;
                                sband->n_channels =
                                        ARRAY_SIZE(hwsim_channels_5ghz);
+                               sband->bitrates = data->rates + 4;
+                               sband->n_bitrates = ARRAY_SIZE(hwsim_rates) - 4;
                                break;
                        default:
                                break;
                        }
 
-                       sband->bitrates = data->rates;
-                       sband->n_bitrates = ARRAY_SIZE(hwsim_rates);
-
                        sband->ht_cap.ht_supported = true;
                        sband->ht_cap.cap = IEEE80211_HT_CAP_SUP_WIDTH_20_40 |
                                IEEE80211_HT_CAP_GRN_FLD |
@@ -870,7 +1796,75 @@ static int __init init_mac80211_hwsim(void)
 
                        hw->wiphy->bands[band] = sband;
                }
+               /* By default all radios are belonging to the first group */
+               data->group = 1;
+               mutex_init(&data->mutex);
+
+               /* Enable frame retransmissions for lossy channels */
+               hw->max_rates = 4;
+               hw->max_rate_tries = 11;
+
+               /* Work to be done prior to ieee80211_register_hw() */
+               switch (regtest) {
+               case HWSIM_REGTEST_DISABLED:
+               case HWSIM_REGTEST_DRIVER_REG_FOLLOW:
+               case HWSIM_REGTEST_DRIVER_REG_ALL:
+               case HWSIM_REGTEST_DIFF_COUNTRY:
+                       /*
+                        * Nothing to be done for driver regulatory domain
+                        * hints prior to ieee80211_register_hw()
+                        */
+                       break;
+               case HWSIM_REGTEST_WORLD_ROAM:
+                       if (i == 0) {
+                               hw->wiphy->flags |= WIPHY_FLAG_CUSTOM_REGULATORY;
+                               wiphy_apply_custom_regulatory(hw->wiphy,
+                                       &hwsim_world_regdom_custom_01);
+                       }
+                       break;
+               case HWSIM_REGTEST_CUSTOM_WORLD:
+                       hw->wiphy->flags |= WIPHY_FLAG_CUSTOM_REGULATORY;
+                       wiphy_apply_custom_regulatory(hw->wiphy,
+                               &hwsim_world_regdom_custom_01);
+                       break;
+               case HWSIM_REGTEST_CUSTOM_WORLD_2:
+                       if (i == 0) {
+                               hw->wiphy->flags |= WIPHY_FLAG_CUSTOM_REGULATORY;
+                               wiphy_apply_custom_regulatory(hw->wiphy,
+                                       &hwsim_world_regdom_custom_01);
+                       } else if (i == 1) {
+                               hw->wiphy->flags |= WIPHY_FLAG_CUSTOM_REGULATORY;
+                               wiphy_apply_custom_regulatory(hw->wiphy,
+                                       &hwsim_world_regdom_custom_02);
+                       }
+                       break;
+               case HWSIM_REGTEST_STRICT_ALL:
+                       hw->wiphy->flags |= WIPHY_FLAG_STRICT_REGULATORY;
+                       break;
+               case HWSIM_REGTEST_STRICT_FOLLOW:
+               case HWSIM_REGTEST_STRICT_AND_DRIVER_REG:
+                       if (i == 0)
+                               hw->wiphy->flags |= WIPHY_FLAG_STRICT_REGULATORY;
+                       break;
+               case HWSIM_REGTEST_ALL:
+                       if (i == 0) {
+                               hw->wiphy->flags |= WIPHY_FLAG_CUSTOM_REGULATORY;
+                               wiphy_apply_custom_regulatory(hw->wiphy,
+                                       &hwsim_world_regdom_custom_01);
+                       } else if (i == 1) {
+                               hw->wiphy->flags |= WIPHY_FLAG_CUSTOM_REGULATORY;
+                               wiphy_apply_custom_regulatory(hw->wiphy,
+                                       &hwsim_world_regdom_custom_02);
+                       } else if (i == 4)
+                               hw->wiphy->flags |= WIPHY_FLAG_STRICT_REGULATORY;
+                       break;
+               default:
+                       break;
+               }
 
+               /* give the regulatory workqueue a chance to run */
+               if (regtest)
+                       schedule_timeout_interruptible(1);
                err = ieee80211_register_hw(hw);
                if (err < 0) {
                        printk(KERN_DEBUG "mac80211_hwsim: "
@@ -878,15 +1872,63 @@ static int __init init_mac80211_hwsim(void)
                        goto failed_hw;
                }
 
-               printk(KERN_DEBUG "%s: hwaddr %pM registered\n",
-                      wiphy_name(hw->wiphy),
-                      hw->wiphy->perm_addr);
+               /* Work to be done after to ieee80211_register_hw() */
+               switch (regtest) {
+               case HWSIM_REGTEST_WORLD_ROAM:
+               case HWSIM_REGTEST_DISABLED:
+                       break;
+               case HWSIM_REGTEST_DRIVER_REG_FOLLOW:
+                       if (!i)
+                               regulatory_hint(hw->wiphy, hwsim_alpha2s[0]);
+                       break;
+               case HWSIM_REGTEST_DRIVER_REG_ALL:
+               case HWSIM_REGTEST_STRICT_ALL:
+                       regulatory_hint(hw->wiphy, hwsim_alpha2s[0]);
+                       break;
+               case HWSIM_REGTEST_DIFF_COUNTRY:
+                       if (i < ARRAY_SIZE(hwsim_alpha2s))
+                               regulatory_hint(hw->wiphy, hwsim_alpha2s[i]);
+                       break;
+               case HWSIM_REGTEST_CUSTOM_WORLD:
+               case HWSIM_REGTEST_CUSTOM_WORLD_2:
+                       /*
+                        * Nothing to be done for custom world regulatory
+                        * domains after to ieee80211_register_hw
+                        */
+                       break;
+               case HWSIM_REGTEST_STRICT_FOLLOW:
+                       if (i == 0)
+                               regulatory_hint(hw->wiphy, hwsim_alpha2s[0]);
+                       break;
+               case HWSIM_REGTEST_STRICT_AND_DRIVER_REG:
+                       if (i == 0)
+                               regulatory_hint(hw->wiphy, hwsim_alpha2s[0]);
+                       else if (i == 1)
+                               regulatory_hint(hw->wiphy, hwsim_alpha2s[1]);
+                       break;
+               case HWSIM_REGTEST_ALL:
+                       if (i == 2)
+                               regulatory_hint(hw->wiphy, hwsim_alpha2s[0]);
+                       else if (i == 3)
+                               regulatory_hint(hw->wiphy, hwsim_alpha2s[1]);
+                       else if (i == 4)
+                               regulatory_hint(hw->wiphy, hwsim_alpha2s[2]);
+                       break;
+               default:
+                       break;
+               }
+
+               wiphy_debug(hw->wiphy, "hwaddr %pm registered\n",
+                           hw->wiphy->perm_addr);
 
                data->debugfs = debugfs_create_dir("hwsim",
                                                   hw->wiphy->debugfsdir);
                data->debugfs_ps = debugfs_create_file("ps", 0666,
                                                       data->debugfs, data,
                                                       &hwsim_fops_ps);
+               data->debugfs_group = debugfs_create_file("group", 0666,
+                                                       data->debugfs, data,
+                                                       &hwsim_fops_group);
 
                setup_timer(&data->beacon_timer, mac80211_hwsim_beacon,
                            (unsigned long) hw);
@@ -911,8 +1953,16 @@ static int __init init_mac80211_hwsim(void)
 
        rtnl_unlock();
 
+       err = hwsim_init_netlink();
+       if (err < 0)
+               goto failed_nl;
+
        return 0;
 
+failed_nl:
+       printk(KERN_DEBUG "mac_80211_hwsim: failed initializing netlink\n");
+       return err;
+
 failed_mon:
        rtnl_unlock();
        free_netdev(hwsim_mon);
@@ -933,8 +1983,10 @@ static void __exit exit_mac80211_hwsim(void)
 {
        printk(KERN_DEBUG "mac80211_hwsim: unregister radios\n");
 
-       unregister_netdev(hwsim_mon);
+       hwsim_exit_netlink();
+
        mac80211_hwsim_free();
+       unregister_netdev(hwsim_mon);
 }