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 55f77ad..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
  *
@@ -54,7 +70,7 @@ MODULE_PARM_DESC(radios, "Number of simulated radios");
  *     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 acomplish
+ * @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
@@ -279,10 +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;
        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
@@ -291,6 +310,7 @@ struct mac80211_hwsim_data {
        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
@@ -298,6 +318,8 @@ struct mac80211_hwsim_data {
         */
        u64 group;
        struct dentry *debugfs_group;
+
+       int power_level;
 };
 
 
@@ -307,10 +329,37 @@ 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);
@@ -362,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)
 {
@@ -390,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;
@@ -399,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) {
@@ -417,7 +640,9 @@ static bool mac80211_hwsim_tx_frame(struct ieee80211_hw *hw,
                if (data == data2)
                        continue;
 
-               if (!data2->started || !hwsim_ps_rx_ok(data2, skb) ||
+               if (data2->idle || !data2->started ||
+                   !hwsim_ps_rx_ok(data2, skb) ||
+                   !data->channel || !data2->channel ||
                    data->channel->center_freq != data2->channel->center_freq ||
                    !(data->group & data2->group))
                        continue;
@@ -426,31 +651,43 @@ static bool mac80211_hwsim_tx_frame(struct ieee80211_hw *hw,
                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)
 {
        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;
        }
 
-       ack = mac80211_hwsim_tx_frame(hw, skb);
+       /* wmediumd mode check */
+       _pid = wmediumd_pid;
+
+       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);
 
@@ -463,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;
 }
@@ -481,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);
 }
 
 
@@ -513,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);
@@ -526,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);
 }
 
@@ -546,19 +806,37 @@ 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 idle=%d ps=%d)\n",
-              wiphy_name(hw->wiphy), __func__,
-              conf->channel->center_freq,
-              !!(conf->flags & IEEE80211_CONF_IDLE),
-              !!(conf->flags & IEEE80211_CONF_PS));
+       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->power_level = conf->power_level;
        if (!data->started || !data->beacon_int)
                del_timer(&data->beacon_timer);
        else
@@ -570,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)
@@ -597,76 +873,92 @@ static void mac80211_hwsim_bss_info_changed(struct ieee80211_hw *hw,
 
        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) {
-               printk(KERN_DEBUG "%s:%s: BSSID changed: %pM\n",
-                      wiphy_name(hw->wiphy), __func__,
-                      info->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) {
-               printk(KERN_DEBUG "  %s: BCNINT: %d\n",
-                      wiphy_name(hw->wiphy), info->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;
        }
 }
 
@@ -679,36 +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 const struct ieee80211_ops mac80211_hwsim_ops =
+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;
+}
+
+#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,
        .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);
 
@@ -717,7 +1213,7 @@ 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);
@@ -756,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)
@@ -776,8 +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 (!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);
 }
 
@@ -786,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)
@@ -807,7 +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 (!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);
 }
@@ -887,6 +1399,273 @@ 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;
@@ -898,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);
 
@@ -931,20 +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->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);
@@ -963,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 |
@@ -993,6 +1798,11 @@ static int __init init_mac80211_hwsim(void)
                }
                /* 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) {
@@ -1007,46 +1817,46 @@ static int __init init_mac80211_hwsim(void)
                        break;
                case HWSIM_REGTEST_WORLD_ROAM:
                        if (i == 0) {
-                               hw->wiphy->custom_regulatory = true;
+                               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->custom_regulatory = true;
+                       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->custom_regulatory = true;
+                               hw->wiphy->flags |= WIPHY_FLAG_CUSTOM_REGULATORY;
                                wiphy_apply_custom_regulatory(hw->wiphy,
                                        &hwsim_world_regdom_custom_01);
                        } else if (i == 1) {
-                               hw->wiphy->custom_regulatory = true;
+                               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->strict_regulatory = true;
+                       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->strict_regulatory = true;
+                               hw->wiphy->flags |= WIPHY_FLAG_STRICT_REGULATORY;
                        break;
                case HWSIM_REGTEST_ALL:
                        if (i == 0) {
-                               hw->wiphy->custom_regulatory = true;
+                               hw->wiphy->flags |= WIPHY_FLAG_CUSTOM_REGULATORY;
                                wiphy_apply_custom_regulatory(hw->wiphy,
                                        &hwsim_world_regdom_custom_01);
                        } else if (i == 1) {
-                               hw->wiphy->custom_regulatory = true;
+                               hw->wiphy->flags |= WIPHY_FLAG_CUSTOM_REGULATORY;
                                wiphy_apply_custom_regulatory(hw->wiphy,
                                        &hwsim_world_regdom_custom_02);
                        } else if (i == 4)
-                               hw->wiphy->strict_regulatory = true;
+                               hw->wiphy->flags |= WIPHY_FLAG_STRICT_REGULATORY;
                        break;
                default:
                        break;
@@ -1108,9 +1918,8 @@ static int __init init_mac80211_hwsim(void)
                        break;
                }
 
-               printk(KERN_DEBUG "%s: hwaddr %pM registered\n",
-                      wiphy_name(hw->wiphy),
-                      hw->wiphy->perm_addr);
+               wiphy_debug(hw->wiphy, "hwaddr %pm registered\n",
+                           hw->wiphy->perm_addr);
 
                data->debugfs = debugfs_create_dir("hwsim",
                                                   hw->wiphy->debugfsdir);
@@ -1144,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);
@@ -1166,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);
 }