Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/linville/wireless-next into for-davem

40 files changed, 565 insertions, 678 deletions

diff --git a/net/mac80211/Kconfig b/net/mac80211/Kconfig
index 7d3b438755f0..96ddb72760b9 100644
--- a/net/mac80211/Kconfig
+++ b/net/mac80211/Kconfig
@@ -247,15 +247,3 @@ config MAC80211_DEBUG_COUNTERS
           and show them in debugfs.
 
           If unsure, say N.
-
-config MAC80211_DRIVER_API_TRACER
-        bool "Driver API tracer"
-        depends on MAC80211_DEBUG_MENU
-        depends on EVENT_TRACING
-        help
-          Say Y here to make mac80211 register with the ftrace
-          framework for the driver API -- you can then see which
-          driver methods it is calling and which API functions
-          drivers are calling by looking at the trace.
-
-          If unsure, say Y.
diff --git a/net/mac80211/Makefile b/net/mac80211/Makefile
index fdb54e61d637..d540c3b160f3 100644
--- a/net/mac80211/Makefile
+++ b/net/mac80211/Makefile
@@ -24,7 +24,8 @@ mac80211-y := \
         util.o \
         wme.o \
         event.o \
-        chan.o
+        chan.o \
+        driver-trace.o
 
 mac80211-$(CONFIG_MAC80211_LEDS) += led.o
 mac80211-$(CONFIG_MAC80211_DEBUGFS) += \
@@ -41,7 +42,6 @@ mac80211-$(CONFIG_MAC80211_MESH) += \
 
 mac80211-$(CONFIG_PM) += pm.o
 
-mac80211-$(CONFIG_MAC80211_DRIVER_API_TRACER) += driver-trace.o
 CFLAGS_driver-trace.o := -I$(src)
 
 # objects for PID algorithm
diff --git a/net/mac80211/agg-rx.c b/net/mac80211/agg-rx.c
index 476b106c0b1c..e844e5a38408 100644
--- a/net/mac80211/agg-rx.c
+++ b/net/mac80211/agg-rx.c
@@ -73,8 +73,11 @@ void ___ieee80211_stop_rx_ba_session(struct sta_info *sta, u16 tid,
         RCU_INIT_POINTER(sta->ampdu_mlme.tid_rx[tid], NULL);
 
 #ifdef CONFIG_MAC80211_HT_DEBUG
-        printk(KERN_DEBUG "Rx BA session stop requested for %pM tid %u\n",
-               sta->sta.addr, tid);
+        printk(KERN_DEBUG
+               "Rx BA session stop requested for %pM tid %u %s reason: %d\n",
+               sta->sta.addr, tid,
+               initiator == WLAN_BACK_RECIPIENT ? "recipient" : "inititator",
+               (int)reason);
 #endif /* CONFIG_MAC80211_HT_DEBUG */
 
         if (drv_ampdu_action(local, sta->sdata, IEEE80211_AMPDU_RX_STOP,
@@ -85,7 +88,7 @@ void ___ieee80211_stop_rx_ba_session(struct sta_info *sta, u16 tid,
         /* check if this is a self generated aggregation halt */
         if (initiator == WLAN_BACK_RECIPIENT && tx)
                 ieee80211_send_delba(sta->sdata, sta->sta.addr,
-                                     tid, 0, reason);
+                                     tid, WLAN_BACK_RECIPIENT, reason);
 
         del_timer_sync(&tid_rx->session_timer);
         del_timer_sync(&tid_rx->reorder_timer);
@@ -109,7 +112,7 @@ void ieee80211_stop_rx_ba_session(struct ieee80211_vif *vif, u16 ba_rx_bitmap,
         int i;
 
         rcu_read_lock();
-        sta = sta_info_get(sdata, addr);
+        sta = sta_info_get_bss(sdata, addr);
         if (!sta) {
                 rcu_read_unlock();
                 return;
diff --git a/net/mac80211/agg-tx.c b/net/mac80211/agg-tx.c
index 556765749b9c..2c2e9519a2e7 100644
--- a/net/mac80211/agg-tx.c
+++ b/net/mac80211/agg-tx.c
@@ -186,6 +186,7 @@ int ___ieee80211_stop_tx_ba_session(struct sta_info *sta, u16 tid,
 #endif /* CONFIG_MAC80211_HT_DEBUG */
 
         del_timer_sync(&tid_tx->addba_resp_timer);
+        del_timer_sync(&tid_tx->session_timer);
 
         /*
          * After this packets are no longer handed right through
@@ -369,6 +370,28 @@ void ieee80211_tx_ba_session_handle_start(struct sta_info *sta, int tid)
                                      tid_tx->timeout);
 }
 
+/*
+ * After accepting the AddBA Response we activated a timer,
+ * resetting it after each frame that we send.
+ */
+static void sta_tx_agg_session_timer_expired(unsigned long data)
+{
+        /* not an elegant detour, but there is no choice as the timer passes
+         * only one argument, and various sta_info are needed here, so init
+         * flow in sta_info_create gives the TID as data, while the timer_to_id
+         * array gives the sta through container_of */
+        u8 *ptid = (u8 *)data;
+        u8 *timer_to_id = ptid - *ptid;
+        struct sta_info *sta = container_of(timer_to_id, struct sta_info,
+                                         timer_to_tid[0]);
+
+#ifdef CONFIG_MAC80211_HT_DEBUG
+        printk(KERN_DEBUG "tx session timer expired on tid %d\n", (u16)*ptid);
+#endif
+
+        ieee80211_stop_tx_ba_session(&sta->sta, *ptid);
+}
+
 int ieee80211_start_tx_ba_session(struct ieee80211_sta *pubsta, u16 tid,
                                   u16 timeout)
 {
@@ -438,11 +461,16 @@ int ieee80211_start_tx_ba_session(struct ieee80211_sta *pubsta, u16 tid,
 
         tid_tx->timeout = timeout;
 
-        /* Tx timer */
+        /* response timer */
         tid_tx->addba_resp_timer.function = sta_addba_resp_timer_expired;
         tid_tx->addba_resp_timer.data = (unsigned long)&sta->timer_to_tid[tid];
         init_timer(&tid_tx->addba_resp_timer);
 
+        /* tx timer */
+        tid_tx->session_timer.function = sta_tx_agg_session_timer_expired;
+        tid_tx->session_timer.data = (unsigned long)&sta->timer_to_tid[tid];
+        init_timer(&tid_tx->session_timer);
+
         /* assign a dialog token */
         sta->ampdu_mlme.dialog_token_allocator++;
         tid_tx->dialog_token = sta->ampdu_mlme.dialog_token_allocator;
@@ -547,7 +575,7 @@ void ieee80211_start_tx_ba_cb(struct ieee80211_vif *vif, u8 *ra, u16 tid)
         }
 
         mutex_lock(&local->sta_mtx);
-        sta = sta_info_get(sdata, ra);
+        sta = sta_info_get_bss(sdata, ra);
         if (!sta) {
                 mutex_unlock(&local->sta_mtx);
 #ifdef CONFIG_MAC80211_HT_DEBUG
@@ -676,7 +704,7 @@ void ieee80211_stop_tx_ba_cb(struct ieee80211_vif *vif, u8 *ra, u8 tid)
 
         mutex_lock(&local->sta_mtx);
 
-        sta = sta_info_get(sdata, ra);
+        sta = sta_info_get_bss(sdata, ra);
         if (!sta) {
 #ifdef CONFIG_MAC80211_HT_DEBUG
                 printk(KERN_DEBUG "Could not find station: %pM\n", ra);
@@ -814,6 +842,11 @@ void ieee80211_process_addba_resp(struct ieee80211_local *local,
                         ieee80211_agg_tx_operational(local, sta, tid);
 
                 sta->ampdu_mlme.addba_req_num[tid] = 0;
+
+                if (tid_tx->timeout)
+                        mod_timer(&tid_tx->session_timer,
+                                  TU_TO_EXP_TIME(tid_tx->timeout));
+
         } else {
                 ___ieee80211_stop_tx_ba_session(sta, tid, WLAN_BACK_INITIATOR,
                                                 true);
diff --git a/net/mac80211/cfg.c b/net/mac80211/cfg.c
index 2577c45069e5..393b2a4445b8 100644
--- a/net/mac80211/cfg.c
+++ b/net/mac80211/cfg.c
@@ -102,6 +102,16 @@ static int ieee80211_change_iface(struct wiphy *wiphy,
         return 0;
 }
 
+static int ieee80211_set_noack_map(struct wiphy *wiphy,
+                                  struct net_device *dev,
+                                  u16 noack_map)
+{
+        struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
+
+        sdata->noack_map = noack_map;
+        return 0;
+}
+
 static int ieee80211_add_key(struct wiphy *wiphy, struct net_device *dev,
                              u8 key_idx, bool pairwise, const u8 *mac_addr,
                              struct key_params *params)
@@ -499,7 +509,7 @@ static int ieee80211_set_probe_resp(struct ieee80211_sub_if_data *sdata,
         if (!resp || !resp_len)
                 return -EINVAL;
 
-        old = sdata->u.ap.probe_resp;
+        old = rtnl_dereference(sdata->u.ap.probe_resp);
 
         new = dev_alloc_skb(resp_len);
         if (!new)
@@ -1185,6 +1195,8 @@ static int copy_mesh_setup(struct ieee80211_if_mesh *ifmsh,
 {
         u8 *new_ie;
         const u8 *old_ie;
+        struct ieee80211_sub_if_data *sdata = container_of(ifmsh,
+                                        struct ieee80211_sub_if_data, u.mesh);
 
         /* allocate information elements */
         new_ie = NULL;
@@ -1211,6 +1223,10 @@ static int copy_mesh_setup(struct ieee80211_if_mesh *ifmsh,
         if (setup->is_secure)
                 ifmsh->security |= IEEE80211_MESH_SEC_SECURED;
 
+        /* mcast rate setting in Mesh Node */
+        memcpy(sdata->vif.bss_conf.mcast_rate, setup->mcast_rate,
+                                                sizeof(setup->mcast_rate));
+
         return 0;
 }
 
@@ -1256,6 +1272,9 @@ static int ieee80211_update_mesh_config(struct wiphy *wiphy,
         if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL, mask))
                 conf->dot11MeshHWMPpreqMinInterval =
                         nconf->dot11MeshHWMPpreqMinInterval;
+        if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL, mask))
+                conf->dot11MeshHWMPperrMinInterval =
+                        nconf->dot11MeshHWMPperrMinInterval;
         if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
                            mask))
                 conf->dot11MeshHWMPnetDiameterTraversalTime =
@@ -2698,4 +2717,5 @@ struct cfg80211_ops mac80211_config_ops = {
         .tdls_mgmt = ieee80211_tdls_mgmt,
         .probe_client = ieee80211_probe_client,
         .get_channel = ieee80211_wiphy_get_channel,
+        .set_noack_map = ieee80211_set_noack_map,
 };
diff --git a/net/mac80211/debugfs.c b/net/mac80211/debugfs.c
index 00cefcb493eb..90baea53e7c5 100644
--- a/net/mac80211/debugfs.c
+++ b/net/mac80211/debugfs.c
@@ -97,40 +97,6 @@ static const struct file_operations reset_ops = {
         .llseek = noop_llseek,
 };
 
-static ssize_t noack_read(struct file *file, char __user *user_buf,
-                          size_t count, loff_t *ppos)
-{
-        struct ieee80211_local *local = file->private_data;
-
-        return mac80211_format_buffer(user_buf, count, ppos, "%d\n",
-                                      local->wifi_wme_noack_test);
-}
-
-static ssize_t noack_write(struct file *file,
-                           const char __user *user_buf,
-                           size_t count, loff_t *ppos)
-{
-        struct ieee80211_local *local = file->private_data;
-        char buf[10];
-        size_t len;
-
-        len = min(count, sizeof(buf) - 1);
-        if (copy_from_user(buf, user_buf, len))
-                return -EFAULT;
-        buf[len] = '\0';
-
-        local->wifi_wme_noack_test = !!simple_strtoul(buf, NULL, 0);
-
-        return count;
-}
-
-static const struct file_operations noack_ops = {
-        .read = noack_read,
-        .write = noack_write,
-        .open = mac80211_open_file_generic,
-        .llseek = default_llseek,
-};
-
 static ssize_t uapsd_queues_read(struct file *file, char __user *user_buf,
                                  size_t count, loff_t *ppos)
 {
@@ -398,7 +364,6 @@ void debugfs_hw_add(struct ieee80211_local *local)
         DEBUGFS_ADD(wep_iv);
         DEBUGFS_ADD(queues);
         DEBUGFS_ADD_MODE(reset, 0200);
-        DEBUGFS_ADD(noack);
         DEBUGFS_ADD(uapsd_queues);
         DEBUGFS_ADD(uapsd_max_sp_len);
         DEBUGFS_ADD(channel_type);
diff --git a/net/mac80211/debugfs_netdev.c b/net/mac80211/debugfs_netdev.c
index 9352819a986b..8df28910b8ee 100644
--- a/net/mac80211/debugfs_netdev.c
+++ b/net/mac80211/debugfs_netdev.c
@@ -405,6 +405,8 @@ IEEE80211_IF_FILE(dot11MeshHWMPactivePathTimeout,
                 u.mesh.mshcfg.dot11MeshHWMPactivePathTimeout, DEC);
 IEEE80211_IF_FILE(dot11MeshHWMPpreqMinInterval,
                 u.mesh.mshcfg.dot11MeshHWMPpreqMinInterval, DEC);
+IEEE80211_IF_FILE(dot11MeshHWMPperrMinInterval,
+                u.mesh.mshcfg.dot11MeshHWMPperrMinInterval, DEC);
 IEEE80211_IF_FILE(dot11MeshHWMPnetDiameterTraversalTime,
                 u.mesh.mshcfg.dot11MeshHWMPnetDiameterTraversalTime, DEC);
 IEEE80211_IF_FILE(dot11MeshHWMPmaxPREQretries,
@@ -534,6 +536,7 @@ static void add_mesh_config(struct ieee80211_sub_if_data *sdata)
         MESHPARAMS_ADD(dot11MeshMaxPeerLinks);
         MESHPARAMS_ADD(dot11MeshHWMPactivePathTimeout);
         MESHPARAMS_ADD(dot11MeshHWMPpreqMinInterval);
+        MESHPARAMS_ADD(dot11MeshHWMPperrMinInterval);
         MESHPARAMS_ADD(dot11MeshHWMPnetDiameterTraversalTime);
         MESHPARAMS_ADD(dot11MeshHWMPmaxPREQretries);
         MESHPARAMS_ADD(path_refresh_time);
diff --git a/net/mac80211/driver-ops.h b/net/mac80211/driver-ops.h
index 49cc5e0e8a6a..e8960ae39861 100644
--- a/net/mac80211/driver-ops.h
+++ b/net/mac80211/driver-ops.h
@@ -10,6 +10,16 @@ static inline void check_sdata_in_driver(struct ieee80211_sub_if_data *sdata)
         WARN_ON(!(sdata->flags & IEEE80211_SDATA_IN_DRIVER));
 }
 
+static inline struct ieee80211_sub_if_data *
+get_bss_sdata(struct ieee80211_sub_if_data *sdata)
+{
+        if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
+                sdata = container_of(sdata->bss, struct ieee80211_sub_if_data,
+                                     u.ap);
+
+        return sdata;
+}
+
 static inline void drv_tx(struct ieee80211_local *local, struct sk_buff *skb)
 {
         local->ops->tx(&local->hw, skb);
@@ -421,6 +431,7 @@ static inline void drv_sta_notify(struct ieee80211_local *local,
                                   enum sta_notify_cmd cmd,
                                   struct ieee80211_sta *sta)
 {
+        sdata = get_bss_sdata(sdata);
         check_sdata_in_driver(sdata);
 
         trace_drv_sta_notify(local, sdata, cmd, sta);
@@ -437,6 +448,7 @@ static inline int drv_sta_add(struct ieee80211_local *local,
 
         might_sleep();
 
+        sdata = get_bss_sdata(sdata);
         check_sdata_in_driver(sdata);
 
         trace_drv_sta_add(local, sdata, sta);
@@ -454,6 +466,7 @@ static inline void drv_sta_remove(struct ieee80211_local *local,
 {
         might_sleep();
 
+        sdata = get_bss_sdata(sdata);
         check_sdata_in_driver(sdata);
 
         trace_drv_sta_remove(local, sdata, sta);
@@ -547,6 +560,7 @@ static inline int drv_ampdu_action(struct ieee80211_local *local,
 
         might_sleep();
 
+        sdata = get_bss_sdata(sdata);
         check_sdata_in_driver(sdata);
 
         trace_drv_ampdu_action(local, sdata, action, sta, tid, ssn, buf_size);
diff --git a/net/mac80211/driver-trace.h b/net/mac80211/driver-trace.h
index 2af4fca55337..6e9df8fd8fb8 100644
--- a/net/mac80211/driver-trace.h
+++ b/net/mac80211/driver-trace.h
@@ -5,17 +5,6 @@
 #include <net/mac80211.h>
 #include "ieee80211_i.h"
 
-#if !defined(CONFIG_MAC80211_DRIVER_API_TRACER) || defined(__CHECKER__)
-#undef TRACE_EVENT
-#define TRACE_EVENT(name, proto, ...) \
-static inline void trace_ ## name(proto) {}
-#undef DECLARE_EVENT_CLASS
-#define DECLARE_EVENT_CLASS(...)
-#undef DEFINE_EVENT
-#define DEFINE_EVENT(evt_class, name, proto, ...) \
-static inline void trace_ ## name(proto) {}
-#endif
-
 #undef TRACE_SYSTEM
 #define TRACE_SYSTEM mac80211
 
diff --git a/net/mac80211/ht.c b/net/mac80211/ht.c
index 810cfbea6ad1..d3eafaefb16b 100644
--- a/net/mac80211/ht.c
+++ b/net/mac80211/ht.c
@@ -28,9 +28,9 @@ bool ieee80111_cfg_override_disables_ht40(struct ieee80211_sub_if_data *sdata)
         return false;
 }
 
-void __check_htcap_disable(struct ieee80211_sub_if_data *sdata,
-                           struct ieee80211_sta_ht_cap *ht_cap,
-                           u16 flag)
+static void __check_htcap_disable(struct ieee80211_sub_if_data *sdata,
+                                  struct ieee80211_sta_ht_cap *ht_cap,
+                                  u16 flag)
 {
         __le16 le_flag = cpu_to_le16(flag);
         if (sdata->u.mgd.ht_capa_mask.cap_info & le_flag) {
diff --git a/net/mac80211/ieee80211_i.h b/net/mac80211/ieee80211_i.h
index 762243e469df..bdefa6ba3f4c 100644
--- a/net/mac80211/ieee80211_i.h
+++ b/net/mac80211/ieee80211_i.h
@@ -514,7 +514,9 @@ struct ieee80211_if_mesh {
         atomic_t mpaths;
         /* Timestamp of last SN update */
         unsigned long last_sn_update;
-        /* Timestamp of last SN sent */
+        /* Time when it's ok to send next PERR */
+        unsigned long next_perr;
+        /* Timestamp of last PREQ sent */
         unsigned long last_preq;
         struct mesh_rmc *rmc;
         spinlock_t mesh_preq_queue_lock;
@@ -611,6 +613,9 @@ struct ieee80211_sub_if_data {
         struct ieee80211_fragment_entry fragments[IEEE80211_FRAGMENT_MAX];
         unsigned int fragment_next;
 
+        /* TID bitmap for NoAck policy */
+        u16 noack_map;
+
         struct ieee80211_key __rcu *keys[NUM_DEFAULT_KEYS + NUM_DEFAULT_MGMT_KEYS];
         struct ieee80211_key __rcu *default_unicast_key;
         struct ieee80211_key __rcu *default_multicast_key;
@@ -961,7 +966,6 @@ struct ieee80211_local {
         int total_ps_buffered; /* total number of all buffered unicast and
                                 * multicast packets for power saving stations
                                 */
-        int wifi_wme_noack_test;
         unsigned int wmm_acm; /* bit field of ACM bits (BIT(802.1D tag)) */
 
         /*
@@ -1216,13 +1220,11 @@ int ieee80211_request_sched_scan_stop(struct ieee80211_sub_if_data *sdata);
 void ieee80211_sched_scan_stopped_work(struct work_struct *work);
 
 /* off-channel helpers */
-bool ieee80211_cfg_on_oper_channel(struct ieee80211_local *local);
 void ieee80211_offchannel_enable_all_ps(struct ieee80211_local *local,
                                         bool tell_ap);
 void ieee80211_offchannel_stop_vifs(struct ieee80211_local *local,
                                     bool offchannel_ps_enable);
 void ieee80211_offchannel_return(struct ieee80211_local *local,
-                                 bool enable_beaconing,
                                  bool offchannel_ps_disable);
 void ieee80211_hw_roc_setup(struct ieee80211_local *local);
 
diff --git a/net/mac80211/iface.c b/net/mac80211/iface.c
index b34ca0cbdf6c..3d3bb5e9d8fa 100644
--- a/net/mac80211/iface.c
+++ b/net/mac80211/iface.c
@@ -672,7 +672,6 @@ static u16 ieee80211_monitor_select_queue(struct net_device *dev,
         struct ieee80211_local *local = sdata->local;
         struct ieee80211_hdr *hdr;
         struct ieee80211_radiotap_header *rtap = (void *)skb->data;
-        u8 *p;
 
         if (local->hw.queues < 4)
                 return 0;
@@ -683,19 +682,7 @@ static u16 ieee80211_monitor_select_queue(struct net_device *dev,
 
         hdr = (void *)((u8 *)skb->data + le16_to_cpu(rtap->it_len));
 
-        if (!ieee80211_is_data(hdr->frame_control)) {
-                skb->priority = 7;
-                return ieee802_1d_to_ac[skb->priority];
-        }
-        if (!ieee80211_is_data_qos(hdr->frame_control)) {
-                skb->priority = 0;
-                return ieee802_1d_to_ac[skb->priority];
-        }
-
-        p = ieee80211_get_qos_ctl(hdr);
-        skb->priority = *p & IEEE80211_QOS_CTL_TAG1D_MASK;
-
-        return ieee80211_downgrade_queue(local, skb);
+        return ieee80211_select_queue_80211(local, skb, hdr);
 }
 
 static const struct net_device_ops ieee80211_monitorif_ops = {
@@ -866,6 +853,8 @@ static void ieee80211_setup_sdata(struct ieee80211_sub_if_data *sdata,
         sdata->control_port_protocol = cpu_to_be16(ETH_P_PAE);
         sdata->control_port_no_encrypt = false;
 
+        sdata->noack_map = 0;
+
         /* only monitor differs */
         sdata->dev->type = ARPHRD_ETHER;
 
diff --git a/net/mac80211/main.c b/net/mac80211/main.c
index dddedfad5404..24cc50b963a9 100644
--- a/net/mac80211/main.c
+++ b/net/mac80211/main.c
@@ -92,47 +92,6 @@ static void ieee80211_reconfig_filter(struct work_struct *work)
         ieee80211_configure_filter(local);
 }
 
-/*
- * Returns true if we are logically configured to be on
- * the operating channel AND the hardware-conf is currently
- * configured on the operating channel.  Compares channel-type
- * as well.
- */
-bool ieee80211_cfg_on_oper_channel(struct ieee80211_local *local)
-{
-        struct ieee80211_channel *chan;
-        enum nl80211_channel_type channel_type;
-
-        /* This logic needs to match logic in ieee80211_hw_config */
-        if (local->scan_channel) {
-                chan = local->scan_channel;
-                /* If scanning on oper channel, use whatever channel-type
-                 * is currently in use.
-                 */
-                if (chan == local->oper_channel)
-                        channel_type = local->_oper_channel_type;
-                else
-                        channel_type = NL80211_CHAN_NO_HT;
-        } else if (local->tmp_channel) {
-                chan = local->tmp_channel;
-                channel_type = local->tmp_channel_type;
-        } else {
-                chan = local->oper_channel;
-                channel_type = local->_oper_channel_type;
-        }
-
-        if (chan != local->oper_channel ||
-            channel_type != local->_oper_channel_type)
-                return false;
-
-        /* Check current hardware-config against oper_channel. */
-        if (local->oper_channel != local->hw.conf.channel ||
-            local->_oper_channel_type != local->hw.conf.channel_type)
-                return false;
-
-        return true;
-}
-
 int ieee80211_hw_config(struct ieee80211_local *local, u32 changed)
 {
         struct ieee80211_channel *chan;
@@ -779,6 +738,12 @@ int ieee80211_register_hw(struct ieee80211_hw *hw)
         if (!local->int_scan_req)
                 return -ENOMEM;
 
+        for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
+                if (!local->hw.wiphy->bands[band])
+                        continue;
+                local->int_scan_req->rates[band] = (u32) -1;
+        }
+
         /* if low-level driver supports AP, we also support VLAN */
         if (local->hw.wiphy->interface_modes & BIT(NL80211_IFTYPE_AP)) {
                 hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_AP_VLAN);
diff --git a/net/mac80211/mesh.c b/net/mac80211/mesh.c
index ee82d2f7f114..c707c8bf6d2c 100644
--- a/net/mac80211/mesh.c
+++ b/net/mac80211/mesh.c
@@ -749,6 +749,7 @@ void ieee80211_mesh_init_sdata(struct ieee80211_sub_if_data *sdata)
         atomic_set(&ifmsh->mpaths, 0);
         mesh_rmc_init(sdata);
         ifmsh->last_preq = jiffies;
+        ifmsh->next_perr = jiffies;
         /* Allocate all mesh structures when creating the first mesh interface. */
         if (!mesh_allocated)
                 ieee80211s_init();
diff --git a/net/mac80211/mesh.h b/net/mac80211/mesh.h
index 622cc96eb4de..bd14bd26a2b6 100644
--- a/net/mac80211/mesh.h
+++ b/net/mac80211/mesh.h
@@ -233,6 +233,8 @@ void ieee80211_mesh_root_setup(struct ieee80211_if_mesh *ifmsh);
 /* Mesh paths */
 int mesh_nexthop_lookup(struct sk_buff *skb,
                 struct ieee80211_sub_if_data *sdata);
+int mesh_nexthop_resolve(struct sk_buff *skb,
+                         struct ieee80211_sub_if_data *sdata);
 void mesh_path_start_discovery(struct ieee80211_sub_if_data *sdata);
 struct mesh_path *mesh_path_lookup(u8 *dst,
                 struct ieee80211_sub_if_data *sdata);
diff --git a/net/mac80211/mesh_hwmp.c b/net/mac80211/mesh_hwmp.c
index ce3db2735d7c..73abb7524b2c 100644
--- a/net/mac80211/mesh_hwmp.c
+++ b/net/mac80211/mesh_hwmp.c
@@ -241,11 +241,15 @@ int mesh_path_error_tx(u8 ttl, u8 *target, __le32 target_sn,
 {
         struct ieee80211_local *local = sdata->local;
         struct sk_buff *skb;
+        struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
         struct ieee80211_mgmt *mgmt;
         u8 *pos, ie_len;
         int hdr_len = offsetof(struct ieee80211_mgmt, u.action.u.mesh_action) +
                       sizeof(mgmt->u.action.u.mesh_action);
 
+        if (time_before(jiffies, ifmsh->next_perr))
+                return -EAGAIN;
+
         skb = dev_alloc_skb(local->hw.extra_tx_headroom +
                             hdr_len +
                             2 + 15 /* PERR IE */);
@@ -290,6 +294,8 @@ int mesh_path_error_tx(u8 ttl, u8 *target, __le32 target_sn,
 
         /* see note in function header */
         prepare_frame_for_deferred_tx(sdata, skb);
+        ifmsh->next_perr = TU_TO_EXP_TIME(
+                                   ifmsh->mshcfg.dot11MeshHWMPperrMinInterval);
         ieee80211_add_pending_skb(local, skb);
         return 0;
 }
@@ -393,15 +399,13 @@ static u32 hwmp_route_info_get(struct ieee80211_sub_if_data *sdata,
                 orig_metric = PREQ_IE_METRIC(hwmp_ie);
                 break;
         case MPATH_PREP:
-                /* Originator here refers to the MP that was the destination in
-                 * the Path Request. The draft refers to that MP as the
-                 * destination address, even though usually it is the origin of
-                 * the PREP frame. We divert from the nomenclature in the draft
+                /* Originator here refers to the MP that was the target in the
+                 * Path Request. We divert from the nomenclature in the draft
                  * so that we can easily use a single function to gather path
                  * information from both PREQ and PREP frames.
                  */
-                orig_addr = PREP_IE_ORIG_ADDR(hwmp_ie);
-                orig_sn = PREP_IE_ORIG_SN(hwmp_ie);
+                orig_addr = PREP_IE_TARGET_ADDR(hwmp_ie);
+                orig_sn = PREP_IE_TARGET_SN(hwmp_ie);
                 orig_lifetime = PREP_IE_LIFETIME(hwmp_ie);
                 orig_metric = PREP_IE_METRIC(hwmp_ie);
                 break;
@@ -562,9 +566,9 @@ static void hwmp_preq_frame_process(struct ieee80211_sub_if_data *sdata,
                 ttl = ifmsh->mshcfg.element_ttl;
                 if (ttl != 0) {
                         mhwmp_dbg("replying to the PREQ");
-                        mesh_path_sel_frame_tx(MPATH_PREP, 0, target_addr,
-                                cpu_to_le32(target_sn), 0, orig_addr,
-                                cpu_to_le32(orig_sn), mgmt->sa, 0, ttl,
+                        mesh_path_sel_frame_tx(MPATH_PREP, 0, orig_addr,
+                                cpu_to_le32(orig_sn), 0, target_addr,
+                                cpu_to_le32(target_sn), mgmt->sa, 0, ttl,
                                 cpu_to_le32(lifetime), cpu_to_le32(metric),
                                 0, sdata);
                 } else
@@ -618,14 +622,8 @@ static void hwmp_prep_frame_process(struct ieee80211_sub_if_data *sdata,
 
         mhwmp_dbg("received PREP from %pM", PREP_IE_ORIG_ADDR(prep_elem));
 
-        /* Note that we divert from the draft nomenclature and denominate
-         * destination to what the draft refers to as origininator. So in this
-         * function destnation refers to the final destination of the PREP,
-         * which corresponds with the originator of the PREQ which this PREP
-         * replies
-         */
-        target_addr = PREP_IE_TARGET_ADDR(prep_elem);
-        if (memcmp(target_addr, sdata->vif.addr, ETH_ALEN) == 0)
+        orig_addr = PREP_IE_ORIG_ADDR(prep_elem);
+        if (memcmp(orig_addr, sdata->vif.addr, ETH_ALEN) == 0)
                 /* destination, no forwarding required */
                 return;
 
@@ -636,7 +634,7 @@ static void hwmp_prep_frame_process(struct ieee80211_sub_if_data *sdata,
         }
 
         rcu_read_lock();
-        mpath = mesh_path_lookup(target_addr, sdata);
+        mpath = mesh_path_lookup(orig_addr, sdata);
         if (mpath)
                 spin_lock_bh(&mpath->state_lock);
         else
@@ -651,7 +649,7 @@ static void hwmp_prep_frame_process(struct ieee80211_sub_if_data *sdata,
         flags = PREP_IE_FLAGS(prep_elem);
         lifetime = PREP_IE_LIFETIME(prep_elem);
         hopcount = PREP_IE_HOPCOUNT(prep_elem) + 1;
-        orig_addr = PREP_IE_ORIG_ADDR(prep_elem);
+        target_addr = PREP_IE_TARGET_ADDR(prep_elem);
         target_sn = PREP_IE_TARGET_SN(prep_elem);
         orig_sn = PREP_IE_ORIG_SN(prep_elem);
 
@@ -984,71 +982,97 @@ enddiscovery:
         kfree(preq_node);
 }
 
-/**
- * mesh_nexthop_lookup - put the appropriate next hop on a mesh frame
+/* mesh_nexthop_resolve - lookup next hop for given skb and start path
+ * discovery if no forwarding information is found.
  *
  * @skb: 802.11 frame to be sent
  * @sdata: network subif the frame will be sent through
  *
- * Returns: 0 if the next hop was found. Nonzero otherwise. If no next hop is
- * found, the function will start a path discovery and queue the frame so it is
- * sent when the path is resolved. This means the caller must not free the skb
- * in this case.
+ * Returns: 0 if the next hop was found and -ENOENT if the frame was queued.
+ * skb is freeed here if no mpath could be allocated.
  */
-int mesh_nexthop_lookup(struct sk_buff *skb,
-                        struct ieee80211_sub_if_data *sdata)
+int mesh_nexthop_resolve(struct sk_buff *skb,
+                         struct ieee80211_sub_if_data *sdata)
 {
-        struct sk_buff *skb_to_free = NULL;
-        struct mesh_path *mpath;
-        struct sta_info *next_hop;
         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
+        struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
+        struct mesh_path *mpath;
+        struct sk_buff *skb_to_free = NULL;
         u8 *target_addr = hdr->addr3;
         int err = 0;
 
         rcu_read_lock();
-        mpath = mesh_path_lookup(target_addr, sdata);
+        err = mesh_nexthop_lookup(skb, sdata);
+        if (!err)
+                goto endlookup;
 
+        /* no nexthop found, start resolving */
+        mpath = mesh_path_lookup(target_addr, sdata);
         if (!mpath) {
                 mesh_path_add(target_addr, sdata);
                 mpath = mesh_path_lookup(target_addr, sdata);
                 if (!mpath) {
-                        sdata->u.mesh.mshstats.dropped_frames_no_route++;
+                        mesh_path_discard_frame(skb, sdata);
                         err = -ENOSPC;
                         goto endlookup;
                 }
         }
 
-        if (mpath->flags & MESH_PATH_ACTIVE) {
-                if (time_after(jiffies,
-                               mpath->exp_time -
-                               msecs_to_jiffies(sdata->u.mesh.mshcfg.path_refresh_time)) &&
-                    !memcmp(sdata->vif.addr, hdr->addr4, ETH_ALEN) &&
-                    !(mpath->flags & MESH_PATH_RESOLVING) &&
-                    !(mpath->flags & MESH_PATH_FIXED)) {
-                        mesh_queue_preq(mpath,
-                                        PREQ_Q_F_START | PREQ_Q_F_REFRESH);
-                }
-                next_hop = rcu_dereference(mpath->next_hop);
-                if (next_hop)
-                        memcpy(hdr->addr1, next_hop->sta.addr, ETH_ALEN);
-                else
-                        err = -ENOENT;
-        } else {
-                struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
-                if (!(mpath->flags & MESH_PATH_RESOLVING)) {
-                        /* Start discovery only if it is not running yet */
-                        mesh_queue_preq(mpath, PREQ_Q_F_START);
-                }
+        if (!(mpath->flags & MESH_PATH_RESOLVING))
+                mesh_queue_preq(mpath, PREQ_Q_F_START);
+
+        if (skb_queue_len(&mpath->frame_queue) >= MESH_FRAME_QUEUE_LEN)
+                skb_to_free = skb_dequeue(&mpath->frame_queue);
 
-                if (skb_queue_len(&mpath->frame_queue) >= MESH_FRAME_QUEUE_LEN)
-                        skb_to_free = skb_dequeue(&mpath->frame_queue);
+        info->flags |= IEEE80211_TX_INTFL_NEED_TXPROCESSING;
+        ieee80211_set_qos_hdr(sdata, skb);
+        skb_queue_tail(&mpath->frame_queue, skb);
+        err = -ENOENT;
+        if (skb_to_free)
+                mesh_path_discard_frame(skb_to_free, sdata);
+
+endlookup:
+        rcu_read_unlock();
+        return err;
+}
+/**
+ * mesh_nexthop_lookup - put the appropriate next hop on a mesh frame. Calling
+ * this function is considered "using" the associated mpath, so preempt a path
+ * refresh if this mpath expires soon.
+ *
+ * @skb: 802.11 frame to be sent
+ * @sdata: network subif the frame will be sent through
+ *
+ * Returns: 0 if the next hop was found. Nonzero otherwise.
+ */
+int mesh_nexthop_lookup(struct sk_buff *skb,
+                        struct ieee80211_sub_if_data *sdata)
+{
+        struct mesh_path *mpath;
+        struct sta_info *next_hop;
+        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
+        u8 *target_addr = hdr->addr3;
+        int err = -ENOENT;
+
+        rcu_read_lock();
+        mpath = mesh_path_lookup(target_addr, sdata);
+
+        if (!mpath || !(mpath->flags & MESH_PATH_ACTIVE))
+                goto endlookup;
+
+        if (time_after(jiffies,
+                       mpath->exp_time -
+                       msecs_to_jiffies(sdata->u.mesh.mshcfg.path_refresh_time)) &&
+            !memcmp(sdata->vif.addr, hdr->addr4, ETH_ALEN) &&
+            !(mpath->flags & MESH_PATH_RESOLVING) &&
+            !(mpath->flags & MESH_PATH_FIXED))
+                mesh_queue_preq(mpath, PREQ_Q_F_START | PREQ_Q_F_REFRESH);
 
-                info->flags |= IEEE80211_TX_INTFL_NEED_TXPROCESSING;
-                ieee80211_set_qos_hdr(sdata, skb);
-                skb_queue_tail(&mpath->frame_queue, skb);
-                if (skb_to_free)
-                        mesh_path_discard_frame(skb_to_free, sdata);
-                err = -ENOENT;
+        next_hop = rcu_dereference(mpath->next_hop);
+        if (next_hop) {
+                memcpy(hdr->addr1, next_hop->sta.addr, ETH_ALEN);
+                memcpy(hdr->addr2, sdata->vif.addr, ETH_ALEN);
+                err = 0;
         }
 
 endlookup:
diff --git a/net/mac80211/mesh_pathtbl.c b/net/mac80211/mesh_pathtbl.c
index 7bd2a76aef0e..edf167e3b8f3 100644
--- a/net/mac80211/mesh_pathtbl.c
+++ b/net/mac80211/mesh_pathtbl.c
@@ -221,6 +221,7 @@ void mesh_path_assign_nexthop(struct mesh_path *mpath, struct sta_info *sta)
         while ((skb = __skb_dequeue(&mpath->frame_queue)) != NULL) {
                 hdr = (struct ieee80211_hdr *) skb->data;
                 memcpy(hdr->addr1, sta->sta.addr, ETH_ALEN);
+                memcpy(hdr->addr2, mpath->sdata->vif.addr, ETH_ALEN);
                 __skb_queue_tail(&tmpq, skb);
         }
 
@@ -264,6 +265,7 @@ static void prepare_for_gate(struct sk_buff *skb, char *dst_addr,
         next_hop = rcu_dereference(gate_mpath->next_hop)->sta.addr;
         memcpy(hdr->addr1, next_hop, ETH_ALEN);
         rcu_read_unlock();
+        memcpy(hdr->addr2, gate_mpath->sdata->vif.addr, ETH_ALEN);
         memcpy(hdr->addr3, dst_addr, ETH_ALEN);
 }
 
@@ -971,38 +973,11 @@ int mesh_path_send_to_gates(struct mesh_path *mpath)
  * @skb: frame to discard
  * @sdata: network subif the frame was to be sent through
  *
- * If the frame was being forwarded from another MP, a PERR frame will be sent
- * to the precursor.  The precursor's address (i.e. the previous hop) was saved
- * in addr1 of the frame-to-be-forwarded, and would only be overwritten once
- * the destination is successfully resolved.
- *
  * Locking: the function must me called within a rcu_read_lock region
  */
 void mesh_path_discard_frame(struct sk_buff *skb,
                              struct ieee80211_sub_if_data *sdata)
 {
-        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
-        struct mesh_path *mpath;
-        u32 sn = 0;
-        __le16 reason = cpu_to_le16(WLAN_REASON_MESH_PATH_NOFORWARD);
-
-        if (memcmp(hdr->addr4, sdata->vif.addr, ETH_ALEN) != 0) {
-                u8 *ra, *da;
-
-                da = hdr->addr3;
-                ra = hdr->addr1;
-                rcu_read_lock();
-                mpath = mesh_path_lookup(da, sdata);
-                if (mpath) {
-                        spin_lock_bh(&mpath->state_lock);
-                        sn = ++mpath->sn;
-                        spin_unlock_bh(&mpath->state_lock);
-                }
-                rcu_read_unlock();
-                mesh_path_error_tx(sdata->u.mesh.mshcfg.element_ttl, skb->data,
-                                   cpu_to_le32(sn), reason, ra, sdata);
-        }
-
         kfree_skb(skb);
         sdata->u.mesh.mshstats.dropped_frames_no_route++;
 }
diff --git a/net/mac80211/offchannel.c b/net/mac80211/offchannel.c
index ebd8cccac8f2..e4330d843575 100644
--- a/net/mac80211/offchannel.c
+++ b/net/mac80211/offchannel.c
@@ -156,7 +156,6 @@ void ieee80211_offchannel_enable_all_ps(struct ieee80211_local *local,
 }
 
 void ieee80211_offchannel_return(struct ieee80211_local *local,
-                                 bool enable_beaconing,
                                  bool offchannel_ps_disable)
 {
         struct ieee80211_sub_if_data *sdata;
@@ -188,11 +187,9 @@ void ieee80211_offchannel_return(struct ieee80211_local *local,
                         netif_tx_wake_all_queues(sdata->dev);
                 }
 
-                /* Check to see if we should re-enable beaconing */
-                if (enable_beaconing &&
-                    (sdata->vif.type == NL80211_IFTYPE_AP ||
-                     sdata->vif.type == NL80211_IFTYPE_ADHOC ||
-                     sdata->vif.type == NL80211_IFTYPE_MESH_POINT))
+                if (sdata->vif.type == NL80211_IFTYPE_AP ||
+                    sdata->vif.type == NL80211_IFTYPE_ADHOC ||
+                    sdata->vif.type == NL80211_IFTYPE_MESH_POINT)
                         ieee80211_bss_info_change_notify(
                                 sdata, BSS_CHANGED_BEACON_ENABLED);
         }
diff --git a/net/mac80211/rx.c b/net/mac80211/rx.c
index d1a8869fe05d..daf5cde65b30 100644
--- a/net/mac80211/rx.c
+++ b/net/mac80211/rx.c
@@ -1895,13 +1895,16 @@ ieee80211_rx_h_amsdu(struct ieee80211_rx_data *rx)
 static ieee80211_rx_result
 ieee80211_rx_h_mesh_fwding(struct ieee80211_rx_data *rx)
 {
-        struct ieee80211_hdr *hdr;
+        struct ieee80211_hdr *fwd_hdr, *hdr;
+        struct ieee80211_tx_info *info;
         struct ieee80211s_hdr *mesh_hdr;
-        unsigned int hdrlen;
         struct sk_buff *skb = rx->skb, *fwd_skb;
         struct ieee80211_local *local = rx->local;
         struct ieee80211_sub_if_data *sdata = rx->sdata;
         struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
+        struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
+        __le16 reason = cpu_to_le16(WLAN_REASON_MESH_PATH_NOFORWARD);
+        u16 q, hdrlen;
 
         hdr = (struct ieee80211_hdr *) skb->data;
         hdrlen = ieee80211_hdrlen(hdr->frame_control);
@@ -1917,14 +1920,7 @@ ieee80211_rx_h_mesh_fwding(struct ieee80211_rx_data *rx)
                 return RX_CONTINUE;
 
         if (!mesh_hdr->ttl)
-                /* illegal frame */
-                return RX_DROP_MONITOR;
-
-        if (ieee80211_queue_stopped(&local->hw, skb_get_queue_mapping(skb))) {
-                IEEE80211_IFSTA_MESH_CTR_INC(&sdata->u.mesh,
-                                                dropped_frames_congestion);
                 return RX_DROP_MONITOR;
-        }
 
         if (mesh_hdr->flags & MESH_FLAGS_AE) {
                 struct mesh_path *mppath;
@@ -1957,59 +1953,50 @@ ieee80211_rx_h_mesh_fwding(struct ieee80211_rx_data *rx)
             compare_ether_addr(sdata->vif.addr, hdr->addr3) == 0)
                 return RX_CONTINUE;
 
-        skb_set_queue_mapping(skb, ieee80211_select_queue(sdata, skb));
-        mesh_hdr->ttl--;
+        q = ieee80211_select_queue_80211(local, skb, hdr);
+        if (ieee80211_queue_stopped(&local->hw, q)) {
+                IEEE80211_IFSTA_MESH_CTR_INC(ifmsh, dropped_frames_congestion);
+                return RX_DROP_MONITOR;
+        }
+        skb_set_queue_mapping(skb, q);
 
-        if (status->rx_flags & IEEE80211_RX_RA_MATCH) {
-                if (!mesh_hdr->ttl)
-                        IEEE80211_IFSTA_MESH_CTR_INC(&rx->sdata->u.mesh,
-                                                     dropped_frames_ttl);
-                else {
-                        struct ieee80211_hdr *fwd_hdr;
-                        struct ieee80211_tx_info *info;
-
-                        fwd_skb = skb_copy(skb, GFP_ATOMIC);
-
-                        if (!fwd_skb && net_ratelimit())
-                                printk(KERN_DEBUG "%s: failed to clone mesh frame\n",
-                                                   sdata->name);
-                        if (!fwd_skb)
-                                goto out;
-
-                        fwd_hdr =  (struct ieee80211_hdr *) fwd_skb->data;
-                        memcpy(fwd_hdr->addr2, sdata->vif.addr, ETH_ALEN);
-                        info = IEEE80211_SKB_CB(fwd_skb);
-                        memset(info, 0, sizeof(*info));
-                        info->flags |= IEEE80211_TX_INTFL_NEED_TXPROCESSING;
-                        info->control.vif = &rx->sdata->vif;
-                        info->control.jiffies = jiffies;
-                        if (is_multicast_ether_addr(fwd_hdr->addr1)) {
-                                IEEE80211_IFSTA_MESH_CTR_INC(&sdata->u.mesh,
-                                                                fwded_mcast);
-                        } else {
-                                int err;
-                                /*
-                                 * Save TA to addr1 to send TA a path error if a
-                                 * suitable next hop is not found
-                                 */
-                                memcpy(fwd_hdr->addr1, fwd_hdr->addr2,
-                                                ETH_ALEN);
-                                err = mesh_nexthop_lookup(fwd_skb, sdata);
-                                /* Failed to immediately resolve next hop:
-                                 * fwded frame was dropped or will be added
-                                 * later to the pending skb queue.  */
-                                if (err)
-                                        return RX_DROP_MONITOR;
-
-                                IEEE80211_IFSTA_MESH_CTR_INC(&sdata->u.mesh,
-                                                                fwded_unicast);
-                        }
-                        IEEE80211_IFSTA_MESH_CTR_INC(&sdata->u.mesh,
-                                                     fwded_frames);
-                        ieee80211_add_pending_skb(local, fwd_skb);
-                }
+        if (!(status->rx_flags & IEEE80211_RX_RA_MATCH))
+                goto out;
+
+        if (!--mesh_hdr->ttl) {
+                IEEE80211_IFSTA_MESH_CTR_INC(ifmsh, dropped_frames_ttl);
+                return RX_DROP_MONITOR;
+        }
+
+        fwd_skb = skb_copy(skb, GFP_ATOMIC);
+        if (!fwd_skb) {
+                if (net_ratelimit())
+                        printk(KERN_DEBUG "%s: failed to clone mesh frame\n",
+                                        sdata->name);
+                goto out;
+        }
+
+        fwd_hdr =  (struct ieee80211_hdr *) fwd_skb->data;
+        info = IEEE80211_SKB_CB(fwd_skb);
+        memset(info, 0, sizeof(*info));
+        info->flags |= IEEE80211_TX_INTFL_NEED_TXPROCESSING;
+        info->control.vif = &rx->sdata->vif;
+        info->control.jiffies = jiffies;
+        if (is_multicast_ether_addr(fwd_hdr->addr1)) {
+                IEEE80211_IFSTA_MESH_CTR_INC(ifmsh, fwded_mcast);
+                memcpy(fwd_hdr->addr2, sdata->vif.addr, ETH_ALEN);
+        } else if (!mesh_nexthop_lookup(fwd_skb, sdata)) {
+                IEEE80211_IFSTA_MESH_CTR_INC(ifmsh, fwded_unicast);
+        } else {
+                /* unable to resolve next hop */
+                mesh_path_error_tx(ifmsh->mshcfg.element_ttl, fwd_hdr->addr3,
+                                    0, reason, fwd_hdr->addr2, sdata);
+                IEEE80211_IFSTA_MESH_CTR_INC(ifmsh, dropped_frames_no_route);
+                return RX_DROP_MONITOR;
         }
 
+        IEEE80211_IFSTA_MESH_CTR_INC(ifmsh, fwded_frames);
+        ieee80211_add_pending_skb(local, fwd_skb);
  out:
         if (is_multicast_ether_addr(hdr->addr1) ||
             sdata->dev->flags & IFF_PROMISC)
diff --git a/net/mac80211/scan.c b/net/mac80211/scan.c
index 81863031e0a3..2c5041cc71f8 100644
--- a/net/mac80211/scan.c
+++ b/net/mac80211/scan.c
@@ -297,7 +297,7 @@ static void __ieee80211_scan_completed(struct ieee80211_hw *hw, bool aborted,
         if (!was_hw_scan) {
                 ieee80211_configure_filter(local);
                 drv_sw_scan_complete(local);
-                ieee80211_offchannel_return(local, true, true);
+                ieee80211_offchannel_return(local, true);
         }
 
         ieee80211_recalc_idle(local);
@@ -602,7 +602,7 @@ static void ieee80211_scan_state_suspend(struct ieee80211_local *local,
          * in off-channel state..will put that back
          * on-channel at the end of scanning.
          */
-        ieee80211_offchannel_return(local, true, false);
+        ieee80211_offchannel_return(local, false);
 
         *next_delay = HZ / 5;
         /* afterwards, resume scan & go to next channel */
diff --git a/net/mac80211/sta_info.c b/net/mac80211/sta_info.c
index 8eaa746ec7a2..f98235262006 100644
--- a/net/mac80211/sta_info.c
+++ b/net/mac80211/sta_info.c
@@ -351,10 +351,6 @@ static int sta_info_finish_insert(struct sta_info *sta,
 
         if (!sta->dummy || dummy_reinsert) {
                 /* notify driver */
-                if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
-                        sdata = container_of(sdata->bss,
-                                             struct ieee80211_sub_if_data,
-                                             u.ap);
                 err = drv_sta_add(local, sdata, &sta->sta);
                 if (err) {
                         if (!async)
diff --git a/net/mac80211/sta_info.h b/net/mac80211/sta_info.h
index 6280e8bca49d..1a14fab4bc9a 100644
--- a/net/mac80211/sta_info.h
+++ b/net/mac80211/sta_info.h
@@ -88,6 +88,7 @@ enum ieee80211_sta_info_flags {
  * struct tid_ampdu_tx - TID aggregation information (Tx).
  *
  * @rcu_head: rcu head for freeing structure
+ * @session_timer: check if we keep Tx-ing on the TID (by timeout value)
  * @addba_resp_timer: timer for peer's response to addba request
  * @pending: pending frames queue -- use sta's spinlock to protect
  * @dialog_token: dialog token for aggregation session
@@ -110,6 +111,7 @@ enum ieee80211_sta_info_flags {
  */
 struct tid_ampdu_tx {
         struct rcu_head rcu_head;
+        struct timer_list session_timer;
         struct timer_list addba_resp_timer;
         struct sk_buff_head pending;
         unsigned long state;
@@ -497,7 +499,6 @@ struct sta_info *sta_info_alloc(struct ieee80211_sub_if_data *sdata,
  */
 int sta_info_insert(struct sta_info *sta);
 int sta_info_insert_rcu(struct sta_info *sta) __acquires(RCU);
-int sta_info_insert_atomic(struct sta_info *sta);
 int sta_info_reinsert(struct sta_info *sta);
 
 int sta_info_destroy_addr(struct ieee80211_sub_if_data *sdata,
diff --git a/net/mac80211/tx.c b/net/mac80211/tx.c
index 8d31933abe6a..c4cb4a536e27 100644
--- a/net/mac80211/tx.c
+++ b/net/mac80211/tx.c
@@ -151,11 +151,15 @@ static __le16 ieee80211_duration(struct ieee80211_tx_data *tx,
                 rate = mrate;
         }
 
-        /* Time needed to transmit ACK
-         * (10 bytes + 4-byte FCS = 112 bits) plus SIFS; rounded up
-         * to closest integer */
-
-        dur = ieee80211_frame_duration(local, 10, rate, erp,
+        /* Don't calculate ACKs for QoS Frames with NoAck Policy set */
+        if (ieee80211_is_data_qos(hdr->frame_control) &&
+            *(ieee80211_get_qos_ctl(hdr)) | IEEE80211_QOS_CTL_ACK_POLICY_NOACK)
+                dur = 0;
+        else
+                /* Time needed to transmit ACK
+                 * (10 bytes + 4-byte FCS = 112 bits) plus SIFS; rounded up
+                 * to closest integer */
+                dur = ieee80211_frame_duration(local, 10, rate, erp,
                                 tx->sdata->vif.bss_conf.use_short_preamble);
 
         if (next_frag_len) {
@@ -636,6 +640,7 @@ ieee80211_tx_h_rate_ctrl(struct ieee80211_tx_data *tx)
         else
                 txrc.max_rate_idx = fls(txrc.rate_idx_mask) - 1;
         txrc.bss = (tx->sdata->vif.type == NL80211_IFTYPE_AP ||
+                    tx->sdata->vif.type == NL80211_IFTYPE_MESH_POINT ||
                     tx->sdata->vif.type == NL80211_IFTYPE_ADHOC);
 
         /* set up RTS protection if desired */
@@ -1063,9 +1068,11 @@ static bool ieee80211_tx_prep_agg(struct ieee80211_tx_data *tx,
                                   int tid)
 {
         bool queued = false;
+        bool reset_agg_timer = false;
 
         if (test_bit(HT_AGG_STATE_OPERATIONAL, &tid_tx->state)) {
                 info->flags |= IEEE80211_TX_CTL_AMPDU;
+                reset_agg_timer = true;
         } else if (test_bit(HT_AGG_STATE_WANT_START, &tid_tx->state)) {
                 /*
                  * nothing -- this aggregation session is being started
@@ -1097,6 +1104,7 @@ static bool ieee80211_tx_prep_agg(struct ieee80211_tx_data *tx,
                         /* do nothing, let packet pass through */
                 } else if (test_bit(HT_AGG_STATE_OPERATIONAL, &tid_tx->state)) {
                         info->flags |= IEEE80211_TX_CTL_AMPDU;
+                        reset_agg_timer = true;
                 } else {
                         queued = true;
                         info->control.vif = &tx->sdata->vif;
@@ -1106,6 +1114,11 @@ static bool ieee80211_tx_prep_agg(struct ieee80211_tx_data *tx,
                 spin_unlock(&tx->sta->lock);
         }
 
+        /* reset session timer */
+        if (reset_agg_timer && tid_tx->timeout)
+                mod_timer(&tid_tx->session_timer,
+                          TU_TO_EXP_TIME(tid_tx->timeout));
+
         return queued;
 }
 
@@ -1173,16 +1186,8 @@ ieee80211_tx_prepare(struct ieee80211_sub_if_data *sdata,
         if (is_multicast_ether_addr(hdr->addr1)) {
                 tx->flags &= ~IEEE80211_TX_UNICAST;
                 info->flags |= IEEE80211_TX_CTL_NO_ACK;
-        } else {
+        } else
                 tx->flags |= IEEE80211_TX_UNICAST;
-                if (unlikely(local->wifi_wme_noack_test))
-                        info->flags |= IEEE80211_TX_CTL_NO_ACK;
-                /*
-                 * Flags are initialized to 0. Hence, no need to
-                 * explicitly unset IEEE80211_TX_CTL_NO_ACK since
-                 * it might already be set for injected frames.
-                 */
-        }
 
         if (!(info->flags & IEEE80211_TX_CTL_DONTFRAG)) {
                 if (!(tx->flags & IEEE80211_TX_UNICAST) ||
@@ -1223,9 +1228,10 @@ static bool ieee80211_tx_frags(struct ieee80211_local *local,
                          * queue is woken again.
                          */
                         if (txpending)
-                                skb_queue_splice(skbs, &local->pending[q]);
+                                skb_queue_splice_init(skbs, &local->pending[q]);
                         else
-                                skb_queue_splice_tail(skbs, &local->pending[q]);
+                                skb_queue_splice_tail_init(skbs,
+                                                           &local->pending[q]);
 
                         spin_unlock_irqrestore(&local->queue_stop_reason_lock,
                                                flags);
@@ -1297,7 +1303,7 @@ static bool __ieee80211_tx(struct ieee80211_local *local,
         ieee80211_tpt_led_trig_tx(local, fc, led_len);
         ieee80211_led_tx(local, 1);
 
-        WARN_ON(!skb_queue_empty(skbs));
+        WARN_ON_ONCE(!skb_queue_empty(skbs));
 
         return result;
 }
@@ -1458,7 +1464,7 @@ void ieee80211_xmit(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb)
         if (ieee80211_vif_is_mesh(&sdata->vif) &&
             ieee80211_is_data(hdr->frame_control) &&
                 !is_multicast_ether_addr(hdr->addr1))
-                        if (mesh_nexthop_lookup(skb, sdata)) {
+                        if (mesh_nexthop_resolve(skb, sdata)) {
                                 /* skb queued: don't free */
                                 rcu_read_unlock();
                                 return;
@@ -2260,10 +2266,10 @@ static void ieee80211_beacon_add_tim(struct ieee80211_if_ap *bss,
                 /* Bitmap control */
                 *pos++ = n1 | aid0;
                 /* Part Virt Bitmap */
+                skb_put(skb, n2 - n1);
                 memcpy(pos, bss->tim + n1, n2 - n1 + 1);
 
                 tim[1] = n2 - n1 + 4;
-                skb_put(skb, n2 - n1);
         } else {
                 *pos++ = aid0; /* Bitmap control */
                 *pos++ = 0; /* Part Virt Bitmap */
diff --git a/net/mac80211/util.c b/net/mac80211/util.c
index 3b9b492e9403..5243c2cadeef 100644
--- a/net/mac80211/util.c
+++ b/net/mac80211/util.c
@@ -1192,7 +1192,6 @@ int ieee80211_reconfig(struct ieee80211_local *local)
                                              struct ieee80211_sub_if_data,
                                              u.ap);
 
-                        memset(&sta->sta.drv_priv, 0, hw->sta_data_size);
                         WARN_ON(drv_sta_add(local, sdata, &sta->sta));
                 }
         }
@@ -1244,8 +1243,11 @@ int ieee80211_reconfig(struct ieee80211_local *local)
                         changed |= BSS_CHANGED_IBSS;
                         /* fall through */
                 case NL80211_IFTYPE_AP:
-                        changed |= BSS_CHANGED_SSID |
-                                   BSS_CHANGED_AP_PROBE_RESP;
+                        changed |= BSS_CHANGED_SSID;
+
+                        if (sdata->vif.type == NL80211_IFTYPE_AP)
+                                changed |= BSS_CHANGED_AP_PROBE_RESP;
+
                         /* fall through */
                 case NL80211_IFTYPE_MESH_POINT:
                         changed |= BSS_CHANGED_BEACON |
diff --git a/net/mac80211/wme.c b/net/mac80211/wme.c
index 43327115b490..89511be3111e 100644
--- a/net/mac80211/wme.c
+++ b/net/mac80211/wme.c
@@ -52,6 +52,30 @@ static int wme_downgrade_ac(struct sk_buff *skb)
         }
 }
 
+/* Indicate which queue to use for this fully formed 802.11 frame */
+u16 ieee80211_select_queue_80211(struct ieee80211_local *local,
+                                 struct sk_buff *skb,
+                                 struct ieee80211_hdr *hdr)
+{
+        u8 *p;
+
+        if (local->hw.queues < 4)
+                return 0;
+
+        if (!ieee80211_is_data(hdr->frame_control)) {
+                skb->priority = 7;
+                return ieee802_1d_to_ac[skb->priority];
+        }
+        if (!ieee80211_is_data_qos(hdr->frame_control)) {
+                skb->priority = 0;
+                return ieee802_1d_to_ac[skb->priority];
+        }
+
+        p = ieee80211_get_qos_ctl(hdr);
+        skb->priority = *p & IEEE80211_QOS_CTL_TAG1D_MASK;
+
+        return ieee80211_downgrade_queue(local, skb);
+}
 
 /* Indicate which queue to use. */
 u16 ieee80211_select_queue(struct ieee80211_sub_if_data *sdata,
@@ -139,6 +163,7 @@ void ieee80211_set_qos_hdr(struct ieee80211_sub_if_data *sdata,
                            struct sk_buff *skb)
 {
         struct ieee80211_hdr *hdr = (void *)skb->data;
+        struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
 
         /* Fill in the QoS header if there is one. */
         if (ieee80211_is_data_qos(hdr->frame_control)) {
@@ -150,9 +175,12 @@ void ieee80211_set_qos_hdr(struct ieee80211_sub_if_data *sdata,
                 /* preserve EOSP bit */
                 ack_policy = *p & IEEE80211_QOS_CTL_EOSP;
 
-                if (unlikely(sdata->local->wifi_wme_noack_test) ||
-                    is_multicast_ether_addr(hdr->addr1))
+                if (is_multicast_ether_addr(hdr->addr1) ||
+                    sdata->noack_map & BIT(tid)) {
                         ack_policy |= IEEE80211_QOS_CTL_ACK_POLICY_NOACK;
+                        info->flags |= IEEE80211_TX_CTL_NO_ACK;
+                }
+
                 /* qos header is 2 bytes */
                 *p++ = ack_policy | tid;
                 *p = ieee80211_vif_is_mesh(&sdata->vif) ?
diff --git a/net/mac80211/wme.h b/net/mac80211/wme.h
index 34e166fbf4d4..94edceb617ff 100644
--- a/net/mac80211/wme.h
+++ b/net/mac80211/wme.h
@@ -15,6 +15,9 @@
 
 extern const int ieee802_1d_to_ac[8];
 
+u16 ieee80211_select_queue_80211(struct ieee80211_local *local,
+                                 struct sk_buff *skb,
+                                 struct ieee80211_hdr *hdr);
 u16 ieee80211_select_queue(struct ieee80211_sub_if_data *sdata,
                            struct sk_buff *skb);
 void ieee80211_set_qos_hdr(struct ieee80211_sub_if_data *sdata,
diff --git a/net/mac80211/work.c b/net/mac80211/work.c
index 6884a2d986dc..c6dd01a05291 100644
--- a/net/mac80211/work.c
+++ b/net/mac80211/work.c
@@ -862,44 +862,6 @@ static void ieee80211_work_rx_queued_mgmt(struct ieee80211_local *local,
         kfree_skb(skb);
 }
 
-static bool ieee80211_work_ct_coexists(enum nl80211_channel_type wk_ct,
-                                       enum nl80211_channel_type oper_ct)
-{
-        switch (wk_ct) {
-        case NL80211_CHAN_NO_HT:
-                return true;
-        case NL80211_CHAN_HT20:
-                if (oper_ct != NL80211_CHAN_NO_HT)
-                        return true;
-                return false;
-        case NL80211_CHAN_HT40MINUS:
-        case NL80211_CHAN_HT40PLUS:
-                return (wk_ct == oper_ct);
-        }
-        WARN_ON(1); /* shouldn't get here */
-        return false;
-}
-
-static enum nl80211_channel_type
-ieee80211_calc_ct(enum nl80211_channel_type wk_ct,
-                  enum nl80211_channel_type oper_ct)
-{
-        switch (wk_ct) {
-        case NL80211_CHAN_NO_HT:
-                return oper_ct;
-        case NL80211_CHAN_HT20:
-                if (oper_ct != NL80211_CHAN_NO_HT)
-                        return oper_ct;
-                return wk_ct;
-        case NL80211_CHAN_HT40MINUS:
-        case NL80211_CHAN_HT40PLUS:
-                return wk_ct;
-        }
-        WARN_ON(1); /* shouldn't get here */
-        return wk_ct;
-}
-
-
 static void ieee80211_work_timer(unsigned long data)
 {
         struct ieee80211_local *local = (void *) data;
@@ -950,40 +912,12 @@ static void ieee80211_work_work(struct work_struct *work)
                 }
 
                 if (!started && !local->tmp_channel) {
-                        bool on_oper_chan, on_oper_chan2;
-                        enum nl80211_channel_type wk_ct;
-
-                        on_oper_chan = ieee80211_cfg_on_oper_channel(local);
-
-                        /* Work with existing channel type if possible. */
-                        wk_ct = wk->chan_type;
-                        if (wk->chan == local->hw.conf.channel)
-                                wk_ct = ieee80211_calc_ct(wk->chan_type,
-                                                local->hw.conf.channel_type);
+                        ieee80211_offchannel_stop_vifs(local, true);
 
                         local->tmp_channel = wk->chan;
-                        local->tmp_channel_type = wk_ct;
-                        /*
-                         * Leave the station vifs in awake mode if they
-                         * happen to be on the same channel as
-                         * the requested channel.
-                         */
-                        on_oper_chan2 = ieee80211_cfg_on_oper_channel(local);
-                        if (on_oper_chan != on_oper_chan2) {
-                                if (on_oper_chan2) {
-                                        /* going off oper channel, PS too */
-                                        ieee80211_offchannel_stop_vifs(local,
-                                                                       true);
-                                        ieee80211_hw_config(local, 0);
-                                } else {
-                                        /* going on channel, but leave PS
-                                         * off-channel. */
-                                        ieee80211_hw_config(local, 0);
-                                        ieee80211_offchannel_return(local,
-                                                                    true,
-                                                                    false);
-                                }
-                        }
+                        local->tmp_channel_type = wk->chan_type;
+
+                        ieee80211_hw_config(local, 0);
 
                         started = true;
                         wk->timeout = jiffies;
@@ -1052,34 +986,17 @@ static void ieee80211_work_work(struct work_struct *work)
         list_for_each_entry(wk, &local->work_list, list) {
                 if (!wk->started)
                         continue;
-                if (wk->chan != local->tmp_channel)
-                        continue;
-                if (!ieee80211_work_ct_coexists(wk->chan_type,
-                                                local->tmp_channel_type))
+                if (wk->chan != local->tmp_channel ||
+                    wk->chan_type != local->tmp_channel_type)
                         continue;
                 remain_off_channel = true;
         }
 
         if (!remain_off_channel && local->tmp_channel) {
                 local->tmp_channel = NULL;
-                /* If tmp_channel wasn't operating channel, then
-                 * we need to go back on-channel.
-                 * NOTE:  If we can ever be here while scannning,
-                 * or if the hw_config() channel config logic changes,
-                 * then we may need to do a more thorough check to see if
-                 * we still need to do a hardware config.  Currently,
-                 * we cannot be here while scanning, however.
-                 */
-                if (!ieee80211_cfg_on_oper_channel(local))
-                        ieee80211_hw_config(local, 0);
+                ieee80211_hw_config(local, 0);
 
-                /* At the least, we need to disable offchannel_ps,
-                 * so just go ahead and run the entire offchannel
-                 * return logic here.  We *could* skip enabling
-                 * beaconing if we were already on-oper-channel
-                 * as a future optimization.
-                 */
-                ieee80211_offchannel_return(local, true, true);
+                ieee80211_offchannel_return(local, true);
 
                 /* give connection some time to breathe */
                 run_again(local, jiffies + HZ/2);
diff --git a/net/nfc/core.c b/net/nfc/core.c
index 47e02c1b8c02..3ebc6b3aabac 100644
--- a/net/nfc/core.c
+++ b/net/nfc/core.c
@@ -21,6 +21,8 @@
  * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
@@ -33,25 +35,6 @@
 int nfc_devlist_generation;
 DEFINE_MUTEX(nfc_devlist_mutex);
 
-int nfc_printk(const char *level, const char *format, ...)
-{
-        struct va_format vaf;
-        va_list args;
-        int r;
-
-        va_start(args, format);
-
-        vaf.fmt = format;
-        vaf.va = &args;
-
-        r = printk("%sNFC: %pV\n", level, &vaf);
-
-        va_end(args);
-
-        return r;
-}
-EXPORT_SYMBOL(nfc_printk);
-
 /**
  * nfc_dev_up - turn on the NFC device
  *
@@ -63,7 +46,7 @@ int nfc_dev_up(struct nfc_dev *dev)
 {
         int rc = 0;
 
-        nfc_dbg("dev_name=%s", dev_name(&dev->dev));
+        pr_debug("dev_name=%s\n", dev_name(&dev->dev));
 
         device_lock(&dev->dev);
 
@@ -97,7 +80,7 @@ int nfc_dev_down(struct nfc_dev *dev)
 {
         int rc = 0;
 
-        nfc_dbg("dev_name=%s", dev_name(&dev->dev));
+        pr_debug("dev_name=%s\n", dev_name(&dev->dev));
 
         device_lock(&dev->dev);
 
@@ -139,7 +122,8 @@ int nfc_start_poll(struct nfc_dev *dev, u32 protocols)
 {
         int rc;
 
-        nfc_dbg("dev_name=%s protocols=0x%x", dev_name(&dev->dev), protocols);
+        pr_debug("dev_name=%s protocols=0x%x\n",
+                 dev_name(&dev->dev), protocols);
 
         if (!protocols)
                 return -EINVAL;
@@ -174,7 +158,7 @@ int nfc_stop_poll(struct nfc_dev *dev)
 {
         int rc = 0;
 
-        nfc_dbg("dev_name=%s", dev_name(&dev->dev));
+        pr_debug("dev_name=%s\n", dev_name(&dev->dev));
 
         device_lock(&dev->dev);
 
@@ -207,8 +191,8 @@ int nfc_activate_target(struct nfc_dev *dev, u32 target_idx, u32 protocol)
 {
         int rc;
 
-        nfc_dbg("dev_name=%s target_idx=%u protocol=%u", dev_name(&dev->dev),
-                                                        target_idx, protocol);
+        pr_debug("dev_name=%s target_idx=%u protocol=%u\n",
+                 dev_name(&dev->dev), target_idx, protocol);
 
         device_lock(&dev->dev);
 
@@ -236,7 +220,8 @@ int nfc_deactivate_target(struct nfc_dev *dev, u32 target_idx)
 {
         int rc = 0;
 
-        nfc_dbg("dev_name=%s target_idx=%u", dev_name(&dev->dev), target_idx);
+        pr_debug("dev_name=%s target_idx=%u\n",
+                 dev_name(&dev->dev), target_idx);
 
         device_lock(&dev->dev);
 
@@ -271,8 +256,8 @@ int nfc_data_exchange(struct nfc_dev *dev, u32 target_idx,
 {
         int rc;
 
-        nfc_dbg("dev_name=%s target_idx=%u skb->len=%u", dev_name(&dev->dev),
-                                                        target_idx, skb->len);
+        pr_debug("dev_name=%s target_idx=%u skb->len=%u\n",
+                 dev_name(&dev->dev), target_idx, skb->len);
 
         device_lock(&dev->dev);
 
@@ -326,7 +311,7 @@ int nfc_targets_found(struct nfc_dev *dev, struct nfc_target *targets,
 {
         int i;
 
-        nfc_dbg("dev_name=%s n_targets=%d", dev_name(&dev->dev), n_targets);
+        pr_debug("dev_name=%s n_targets=%d\n", dev_name(&dev->dev), n_targets);
 
         dev->polling = false;
 
@@ -360,7 +345,7 @@ static void nfc_release(struct device *d)
 {
         struct nfc_dev *dev = to_nfc_dev(d);
 
-        nfc_dbg("dev_name=%s", dev_name(&dev->dev));
+        pr_debug("dev_name=%s\n", dev_name(&dev->dev));
 
         nfc_genl_data_exit(&dev->genl_data);
         kfree(dev->targets);
@@ -446,7 +431,7 @@ int nfc_register_device(struct nfc_dev *dev)
 {
         int rc;
 
-        nfc_dbg("dev_name=%s", dev_name(&dev->dev));
+        pr_debug("dev_name=%s\n", dev_name(&dev->dev));
 
         mutex_lock(&nfc_devlist_mutex);
         nfc_devlist_generation++;
@@ -458,9 +443,8 @@ int nfc_register_device(struct nfc_dev *dev)
 
         rc = nfc_genl_device_added(dev);
         if (rc)
-                nfc_dbg("The userspace won't be notified that the device %s was"
-                                                " added", dev_name(&dev->dev));
-
+                pr_debug("The userspace won't be notified that the device %s was added\n",
+                         dev_name(&dev->dev));
 
         return 0;
 }
@@ -475,7 +459,7 @@ void nfc_unregister_device(struct nfc_dev *dev)
 {
         int rc;
 
-        nfc_dbg("dev_name=%s", dev_name(&dev->dev));
+        pr_debug("dev_name=%s\n", dev_name(&dev->dev));
 
         mutex_lock(&nfc_devlist_mutex);
         nfc_devlist_generation++;
@@ -490,8 +474,8 @@ void nfc_unregister_device(struct nfc_dev *dev)
 
         rc = nfc_genl_device_removed(dev);
         if (rc)
-                nfc_dbg("The userspace won't be notified that the device %s"
-                                        " was removed", dev_name(&dev->dev));
+                pr_debug("The userspace won't be notified that the device %s was removed\n",
+                         dev_name(&dev->dev));
 
 }
 EXPORT_SYMBOL(nfc_unregister_device);
@@ -500,7 +484,7 @@ static int __init nfc_init(void)
 {
         int rc;
 
-        nfc_info("NFC Core ver %s", VERSION);
+        pr_info("NFC Core ver %s\n", VERSION);
 
         rc = class_register(&nfc_class);
         if (rc)
diff --git a/net/nfc/nci/core.c b/net/nfc/nci/core.c
index fe5ca89abfce..37de28e97330 100644
--- a/net/nfc/nci/core.c
+++ b/net/nfc/nci/core.c
@@ -25,6 +25,8 @@
  *
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/types.h>
 #include <linux/workqueue.h>
 #include <linux/completion.h>
@@ -79,7 +81,7 @@ static int __nci_request(struct nci_dev *ndev,
                                                         &ndev->req_completion,
                                                         timeout);
 
-        nfc_dbg("wait_for_completion return %ld", completion_rc);
+        pr_debug("wait_for_completion return %ld\n", completion_rc);
 
         if (completion_rc > 0) {
                 switch (ndev->req_status) {
@@ -96,8 +98,8 @@ static int __nci_request(struct nci_dev *ndev,
                         break;
                 }
         } else {
-                nfc_err("wait_for_completion_interruptible_timeout failed %ld",
-                        completion_rc);
+                pr_err("wait_for_completion_interruptible_timeout failed %ld\n",
+                       completion_rc);
 
                 rc = ((completion_rc == 0) ? (-ETIMEDOUT) : (completion_rc));
         }
@@ -323,8 +325,6 @@ static void nci_cmd_timer(unsigned long arg)
 {
         struct nci_dev *ndev = (void *) arg;
 
-        nfc_dbg("entry");
-
         atomic_set(&ndev->cmd_cnt, 1);
         queue_work(ndev->cmd_wq, &ndev->cmd_work);
 }
@@ -333,8 +333,6 @@ static int nci_dev_up(struct nfc_dev *nfc_dev)
 {
         struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
 
-        nfc_dbg("entry");
-
         return nci_open_device(ndev);
 }
 
@@ -342,8 +340,6 @@ static int nci_dev_down(struct nfc_dev *nfc_dev)
 {
         struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
 
-        nfc_dbg("entry");
-
         return nci_close_device(ndev);
 }
 
@@ -352,20 +348,18 @@ static int nci_start_poll(struct nfc_dev *nfc_dev, __u32 protocols)
         struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
         int rc;
 
-        nfc_dbg("entry");
-
         if (test_bit(NCI_DISCOVERY, &ndev->flags)) {
-                nfc_err("unable to start poll, since poll is already active");
+                pr_err("unable to start poll, since poll is already active\n");
                 return -EBUSY;
         }
 
         if (ndev->target_active_prot) {
-                nfc_err("there is an active target");
+                pr_err("there is an active target\n");
                 return -EBUSY;
         }
 
         if (test_bit(NCI_POLL_ACTIVE, &ndev->flags)) {
-                nfc_dbg("target is active, implicitly deactivate...");
+                pr_debug("target is active, implicitly deactivate...\n");
 
                 rc = nci_request(ndev, nci_rf_deactivate_req, 0,
                         msecs_to_jiffies(NCI_RF_DEACTIVATE_TIMEOUT));
@@ -386,10 +380,8 @@ static void nci_stop_poll(struct nfc_dev *nfc_dev)
 {
         struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
 
-        nfc_dbg("entry");
-
         if (!test_bit(NCI_DISCOVERY, &ndev->flags)) {
-                nfc_err("unable to stop poll, since poll is not active");
+                pr_err("unable to stop poll, since poll is not active\n");
                 return;
         }
 
@@ -402,21 +394,21 @@ static int nci_activate_target(struct nfc_dev *nfc_dev, __u32 target_idx,
 {
         struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
 
-        nfc_dbg("entry, target_idx %d, protocol 0x%x", target_idx, protocol);
+        pr_debug("target_idx %d, protocol 0x%x\n", target_idx, protocol);
 
         if (!test_bit(NCI_POLL_ACTIVE, &ndev->flags)) {
-                nfc_err("there is no available target to activate");
+                pr_err("there is no available target to activate\n");
                 return -EINVAL;
         }
 
         if (ndev->target_active_prot) {
-                nfc_err("there is already an active target");
+                pr_err("there is already an active target\n");
                 return -EBUSY;
         }
 
         if (!(ndev->target_available_prots & (1 << protocol))) {
-                nfc_err("target does not support the requested protocol 0x%x",
-                        protocol);
+                pr_err("target does not support the requested protocol 0x%x\n",
+                       protocol);
                 return -EINVAL;
         }
 
@@ -430,10 +422,10 @@ static void nci_deactivate_target(struct nfc_dev *nfc_dev, __u32 target_idx)
 {
         struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
 
-        nfc_dbg("entry, target_idx %d", target_idx);
+        pr_debug("target_idx %d\n", target_idx);
 
         if (!ndev->target_active_prot) {
-                nfc_err("unable to deactivate target, no active target");
+                pr_err("unable to deactivate target, no active target\n");
                 return;
         }
 
@@ -453,10 +445,10 @@ static int nci_data_exchange(struct nfc_dev *nfc_dev, __u32 target_idx,
         struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
         int rc;
 
-        nfc_dbg("entry, target_idx %d, len %d", target_idx, skb->len);
+        pr_debug("target_idx %d, len %d\n", target_idx, skb->len);
 
         if (!ndev->target_active_prot) {
-                nfc_err("unable to exchange data, no active target");
+                pr_err("unable to exchange data, no active target\n");
                 return -EINVAL;
         }
 
@@ -499,7 +491,7 @@ struct nci_dev *nci_allocate_device(struct nci_ops *ops,
 {
         struct nci_dev *ndev;
 
-        nfc_dbg("entry, supported_protocols 0x%x", supported_protocols);
+        pr_debug("supported_protocols 0x%x\n", supported_protocols);
 
         if (!ops->open || !ops->close || !ops->send)
                 return NULL;
@@ -539,8 +531,6 @@ EXPORT_SYMBOL(nci_allocate_device);
  */
 void nci_free_device(struct nci_dev *ndev)
 {
-        nfc_dbg("entry");
-
         nfc_free_device(ndev->nfc_dev);
         kfree(ndev);
 }
@@ -557,8 +547,6 @@ int nci_register_device(struct nci_dev *ndev)
         struct device *dev = &ndev->nfc_dev->dev;
         char name[32];
 
-        nfc_dbg("entry");
-
         rc = nfc_register_device(ndev->nfc_dev);
         if (rc)
                 goto exit;
@@ -621,8 +609,6 @@ EXPORT_SYMBOL(nci_register_device);
  */
 void nci_unregister_device(struct nci_dev *ndev)
 {
-        nfc_dbg("entry");
-
         nci_close_device(ndev);
 
         destroy_workqueue(ndev->cmd_wq);
@@ -642,7 +628,7 @@ int nci_recv_frame(struct sk_buff *skb)
 {
         struct nci_dev *ndev = (struct nci_dev *) skb->dev;
 
-        nfc_dbg("entry, len %d", skb->len);
+        pr_debug("len %d\n", skb->len);
 
         if (!ndev || (!test_bit(NCI_UP, &ndev->flags)
                 && !test_bit(NCI_INIT, &ndev->flags))) {
@@ -662,7 +648,7 @@ static int nci_send_frame(struct sk_buff *skb)
 {
         struct nci_dev *ndev = (struct nci_dev *) skb->dev;
 
-        nfc_dbg("entry, len %d", skb->len);
+        pr_debug("len %d\n", skb->len);
 
         if (!ndev) {
                 kfree_skb(skb);
@@ -681,11 +667,11 @@ int nci_send_cmd(struct nci_dev *ndev, __u16 opcode, __u8 plen, void *payload)
         struct nci_ctrl_hdr *hdr;
         struct sk_buff *skb;
 
-        nfc_dbg("entry, opcode 0x%x, plen %d", opcode, plen);
+        pr_debug("opcode 0x%x, plen %d\n", opcode, plen);
 
         skb = nci_skb_alloc(ndev, (NCI_CTRL_HDR_SIZE + plen), GFP_KERNEL);
         if (!skb) {
-                nfc_err("no memory for command");
+                pr_err("no memory for command\n");
                 return -ENOMEM;
         }
 
@@ -715,7 +701,7 @@ static void nci_tx_work(struct work_struct *work)
         struct nci_dev *ndev = container_of(work, struct nci_dev, tx_work);
         struct sk_buff *skb;
 
-        nfc_dbg("entry, credits_cnt %d", atomic_read(&ndev->credits_cnt));
+        pr_debug("credits_cnt %d\n", atomic_read(&ndev->credits_cnt));
 
         /* Send queued tx data */
         while (atomic_read(&ndev->credits_cnt)) {
@@ -728,10 +714,10 @@ static void nci_tx_work(struct work_struct *work)
                                 NCI_DATA_FLOW_CONTROL_NOT_USED)
                         atomic_dec(&ndev->credits_cnt);
 
-                nfc_dbg("NCI TX: MT=data, PBF=%d, conn_id=%d, plen=%d",
-                                nci_pbf(skb->data),
-                                nci_conn_id(skb->data),
-                                nci_plen(skb->data));
+                pr_debug("NCI TX: MT=data, PBF=%d, conn_id=%d, plen=%d\n",
+                         nci_pbf(skb->data),
+                         nci_conn_id(skb->data),
+                         nci_plen(skb->data));
 
                 nci_send_frame(skb);
         }
@@ -760,7 +746,7 @@ static void nci_rx_work(struct work_struct *work)
                         break;
 
                 default:
-                        nfc_err("unknown MT 0x%x", nci_mt(skb->data));
+                        pr_err("unknown MT 0x%x\n", nci_mt(skb->data));
                         kfree_skb(skb);
                         break;
                 }
@@ -774,7 +760,7 @@ static void nci_cmd_work(struct work_struct *work)
         struct nci_dev *ndev = container_of(work, struct nci_dev, cmd_work);
         struct sk_buff *skb;
 
-        nfc_dbg("entry, cmd_cnt %d", atomic_read(&ndev->cmd_cnt));
+        pr_debug("cmd_cnt %d\n", atomic_read(&ndev->cmd_cnt));
 
         /* Send queued command */
         if (atomic_read(&ndev->cmd_cnt)) {
@@ -784,11 +770,11 @@ static void nci_cmd_work(struct work_struct *work)
 
                 atomic_dec(&ndev->cmd_cnt);
 
-                nfc_dbg("NCI TX: MT=cmd, PBF=%d, GID=0x%x, OID=0x%x, plen=%d",
-                                nci_pbf(skb->data),
-                                nci_opcode_gid(nci_opcode(skb->data)),
-                                nci_opcode_oid(nci_opcode(skb->data)),
-                                nci_plen(skb->data));
+                pr_debug("NCI TX: MT=cmd, PBF=%d, GID=0x%x, OID=0x%x, plen=%d\n",
+                         nci_pbf(skb->data),
+                         nci_opcode_gid(nci_opcode(skb->data)),
+                         nci_opcode_oid(nci_opcode(skb->data)),
+                         nci_plen(skb->data));
 
                 nci_send_frame(skb);
 
diff --git a/net/nfc/nci/data.c b/net/nfc/nci/data.c
index 511fb96e21bc..1e040feb2f84 100644
--- a/net/nfc/nci/data.c
+++ b/net/nfc/nci/data.c
@@ -21,6 +21,8 @@
  *
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/types.h>
 #include <linux/interrupt.h>
 #include <linux/wait.h>
@@ -40,7 +42,7 @@ void nci_data_exchange_complete(struct nci_dev *ndev,
         data_exchange_cb_t cb = ndev->data_exchange_cb;
         void *cb_context = ndev->data_exchange_cb_context;
 
-        nfc_dbg("entry, len %d, err %d", ((skb) ? (skb->len) : (0)), err);
+        pr_debug("len %d, err %d\n", skb ? skb->len : 0, err);
 
         if (cb) {
                 ndev->data_exchange_cb = NULL;
@@ -49,7 +51,7 @@ void nci_data_exchange_complete(struct nci_dev *ndev,
                 /* forward skb to nfc core */
                 cb(cb_context, skb, err);
         } else if (skb) {
-                nfc_err("no rx callback, dropping rx data...");
+                pr_err("no rx callback, dropping rx data...\n");
 
                 /* no waiting callback, free skb */
                 kfree_skb(skb);
@@ -90,7 +92,7 @@ static int nci_queue_tx_data_frags(struct nci_dev *ndev,
         int frag_len;
         int rc = 0;
 
-        nfc_dbg("entry, conn_id 0x%x, total_len %d", conn_id, total_len);
+        pr_debug("conn_id 0x%x, total_len %d\n", conn_id, total_len);
 
         __skb_queue_head_init(&frags_q);
 
@@ -119,8 +121,8 @@ static int nci_queue_tx_data_frags(struct nci_dev *ndev,
                 data += frag_len;
                 total_len -= frag_len;
 
-                nfc_dbg("frag_len %d, remaining total_len %d",
-                        frag_len, total_len);
+                pr_debug("frag_len %d, remaining total_len %d\n",
+                         frag_len, total_len);
         }
 
         /* queue all fragments atomically */
@@ -149,7 +151,7 @@ int nci_send_data(struct nci_dev *ndev, __u8 conn_id, struct sk_buff *skb)
 {
         int rc = 0;
 
-        nfc_dbg("entry, conn_id 0x%x, plen %d", conn_id, skb->len);
+        pr_debug("conn_id 0x%x, plen %d\n", conn_id, skb->len);
 
         /* check if the packet need to be fragmented */
         if (skb->len <= ndev->max_data_pkt_payload_size) {
@@ -161,7 +163,7 @@ int nci_send_data(struct nci_dev *ndev, __u8 conn_id, struct sk_buff *skb)
                 /* fragment packet and queue the fragments */
                 rc = nci_queue_tx_data_frags(ndev, conn_id, skb);
                 if (rc) {
-                        nfc_err("failed to fragment tx data packet");
+                        pr_err("failed to fragment tx data packet\n");
                         goto free_exit;
                 }
         }
@@ -191,7 +193,7 @@ static void nci_add_rx_data_frag(struct nci_dev *ndev,
 
                 /* first, make enough room for the already accumulated data */
                 if (skb_cow_head(skb, reassembly_len)) {
-                        nfc_err("error adding room for accumulated rx data");
+                        pr_err("error adding room for accumulated rx data\n");
 
                         kfree_skb(skb);
                         skb = 0;
@@ -228,19 +230,19 @@ void nci_rx_data_packet(struct nci_dev *ndev, struct sk_buff *skb)
 {
         __u8 pbf = nci_pbf(skb->data);
 
-        nfc_dbg("entry, len %d", skb->len);
+        pr_debug("len %d\n", skb->len);
 
-        nfc_dbg("NCI RX: MT=data, PBF=%d, conn_id=%d, plen=%d",
-                        nci_pbf(skb->data),
-                        nci_conn_id(skb->data),
-                        nci_plen(skb->data));
+        pr_debug("NCI RX: MT=data, PBF=%d, conn_id=%d, plen=%d\n",
+                 nci_pbf(skb->data),
+                 nci_conn_id(skb->data),
+                 nci_plen(skb->data));
 
         /* strip the nci data header */
         skb_pull(skb, NCI_DATA_HDR_SIZE);
 
         if (ndev->target_active_prot == NFC_PROTO_MIFARE) {
                 /* frame I/F => remove the status byte */
-                nfc_dbg("NFC_PROTO_MIFARE => remove the status byte");
+                pr_debug("NFC_PROTO_MIFARE => remove the status byte\n");
                 skb_trim(skb, (skb->len - 1));
         }
 
diff --git a/net/nfc/nci/ntf.c b/net/nfc/nci/ntf.c
index c1bf54172c25..c36bd4a09abb 100644
--- a/net/nfc/nci/ntf.c
+++ b/net/nfc/nci/ntf.c
@@ -25,6 +25,8 @@
  *
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/types.h>
 #include <linux/interrupt.h>
 #include <linux/bitops.h>
@@ -43,16 +45,16 @@ static void nci_core_conn_credits_ntf_packet(struct nci_dev *ndev,
         struct nci_core_conn_credit_ntf *ntf = (void *) skb->data;
         int i;
 
-        nfc_dbg("entry, num_entries %d", ntf->num_entries);
+        pr_debug("num_entries %d\n", ntf->num_entries);
 
         if (ntf->num_entries > NCI_MAX_NUM_CONN)
                 ntf->num_entries = NCI_MAX_NUM_CONN;
 
         /* update the credits */
         for (i = 0; i < ntf->num_entries; i++) {
-                nfc_dbg("entry[%d]: conn_id %d, credits %d", i,
-                        ntf->conn_entries[i].conn_id,
-                        ntf->conn_entries[i].credits);
+                pr_debug("entry[%d]: conn_id %d, credits %d\n",
+                         i, ntf->conn_entries[i].conn_id,
+                         ntf->conn_entries[i].credits);
 
                 if (ntf->conn_entries[i].conn_id == NCI_STATIC_RF_CONN_ID) {
                         /* found static rf connection */
@@ -78,9 +80,8 @@ static __u8 *nci_extract_rf_params_nfca_passive_poll(struct nci_dev *ndev,
 
         nfca_poll->nfcid1_len = *data++;
 
-        nfc_dbg("sens_res 0x%x, nfcid1_len %d",
-                nfca_poll->sens_res,
-                nfca_poll->nfcid1_len);
+        pr_debug("sens_res 0x%x, nfcid1_len %d\n",
+                 nfca_poll->sens_res, nfca_poll->nfcid1_len);
 
         memcpy(nfca_poll->nfcid1, data, nfca_poll->nfcid1_len);
         data += nfca_poll->nfcid1_len;
@@ -90,9 +91,9 @@ static __u8 *nci_extract_rf_params_nfca_passive_poll(struct nci_dev *ndev,
         if (nfca_poll->sel_res_len != 0)
                 nfca_poll->sel_res = *data++;
 
-        nfc_dbg("sel_res_len %d, sel_res 0x%x",
-                nfca_poll->sel_res_len,
-                nfca_poll->sel_res);
+        pr_debug("sel_res_len %d, sel_res 0x%x\n",
+                 nfca_poll->sel_res_len,
+                 nfca_poll->sel_res);
 
         return data;
 }
@@ -114,8 +115,8 @@ static int nci_extract_activation_params_iso_dep(struct nci_dev *ndev,
                 break;
 
         default:
-                nfc_err("unsupported activation_rf_tech_and_mode 0x%x",
-                        ntf->activation_rf_tech_and_mode);
+                pr_err("unsupported activation_rf_tech_and_mode 0x%x\n",
+                       ntf->activation_rf_tech_and_mode);
                 return -EPROTO;
         }
 
@@ -138,12 +139,12 @@ static void nci_target_found(struct nci_dev *ndev,
         nfc_tgt.sel_res = ntf->rf_tech_specific_params.nfca_poll.sel_res;
 
         if (!(nfc_tgt.supported_protocols & ndev->poll_prots)) {
-                nfc_dbg("the target found does not have the desired protocol");
+                pr_debug("the target found does not have the desired protocol\n");
                 return;
         }
 
-        nfc_dbg("new target found,  supported_protocols 0x%x",
-                nfc_tgt.supported_protocols);
+        pr_debug("new target found,  supported_protocols 0x%x\n",
+                 nfc_tgt.supported_protocols);
 
         ndev->target_available_prots = nfc_tgt.supported_protocols;
 
@@ -166,13 +167,13 @@ static void nci_rf_intf_activated_ntf_packet(struct nci_dev *ndev,
         ntf.activation_rf_tech_and_mode = *data++;
         ntf.rf_tech_specific_params_len = *data++;
 
-        nfc_dbg("rf_discovery_id %d", ntf.rf_discovery_id);
-        nfc_dbg("rf_interface_type 0x%x", ntf.rf_interface_type);
-        nfc_dbg("rf_protocol 0x%x", ntf.rf_protocol);
-        nfc_dbg("activation_rf_tech_and_mode 0x%x",
-                ntf.activation_rf_tech_and_mode);
-        nfc_dbg("rf_tech_specific_params_len %d",
-                ntf.rf_tech_specific_params_len);
+        pr_debug("rf_discovery_id %d\n", ntf.rf_discovery_id);
+        pr_debug("rf_interface_type 0x%x\n", ntf.rf_interface_type);
+        pr_debug("rf_protocol 0x%x\n", ntf.rf_protocol);
+        pr_debug("activation_rf_tech_and_mode 0x%x\n",
+                 ntf.activation_rf_tech_and_mode);
+        pr_debug("rf_tech_specific_params_len %d\n",
+                 ntf.rf_tech_specific_params_len);
 
         if (ntf.rf_tech_specific_params_len > 0) {
                 switch (ntf.activation_rf_tech_and_mode) {
@@ -182,8 +183,8 @@ static void nci_rf_intf_activated_ntf_packet(struct nci_dev *ndev,
                         break;
 
                 default:
-                        nfc_err("unsupported activation_rf_tech_and_mode 0x%x",
-                                ntf.activation_rf_tech_and_mode);
+                        pr_err("unsupported activation_rf_tech_and_mode 0x%x\n",
+                               ntf.activation_rf_tech_and_mode);
                         return;
                 }
         }
@@ -193,14 +194,14 @@ static void nci_rf_intf_activated_ntf_packet(struct nci_dev *ndev,
         ntf.data_exch_rx_bit_rate = *data++;
         ntf.activation_params_len = *data++;
 
-        nfc_dbg("data_exch_rf_tech_and_mode 0x%x",
-                ntf.data_exch_rf_tech_and_mode);
-        nfc_dbg("data_exch_tx_bit_rate 0x%x",
-                ntf.data_exch_tx_bit_rate);
-        nfc_dbg("data_exch_rx_bit_rate 0x%x",
-                ntf.data_exch_rx_bit_rate);
-        nfc_dbg("activation_params_len %d",
-                ntf.activation_params_len);
+        pr_debug("data_exch_rf_tech_and_mode 0x%x\n",
+                 ntf.data_exch_rf_tech_and_mode);
+        pr_debug("data_exch_tx_bit_rate 0x%x\n",
+                 ntf.data_exch_tx_bit_rate);
+        pr_debug("data_exch_rx_bit_rate 0x%x\n",
+                 ntf.data_exch_rx_bit_rate);
+        pr_debug("activation_params_len %d\n",
+                 ntf.activation_params_len);
 
         if (ntf.activation_params_len > 0) {
                 switch (ntf.rf_interface_type) {
@@ -214,8 +215,8 @@ static void nci_rf_intf_activated_ntf_packet(struct nci_dev *ndev,
                         break;
 
                 default:
-                        nfc_err("unsupported rf_interface_type 0x%x",
-                                ntf.rf_interface_type);
+                        pr_err("unsupported rf_interface_type 0x%x\n",
+                               ntf.rf_interface_type);
                         return;
                 }
         }
@@ -229,7 +230,7 @@ static void nci_rf_deactivate_ntf_packet(struct nci_dev *ndev,
 {
         struct nci_rf_deactivate_ntf *ntf = (void *) skb->data;
 
-        nfc_dbg("entry, type 0x%x, reason 0x%x", ntf->type, ntf->reason);
+        pr_debug("entry, type 0x%x, reason 0x%x\n", ntf->type, ntf->reason);
 
         clear_bit(NCI_POLL_ACTIVE, &ndev->flags);
         ndev->target_active_prot = 0;
@@ -255,11 +256,11 @@ void nci_ntf_packet(struct nci_dev *ndev, struct sk_buff *skb)
 {
         __u16 ntf_opcode = nci_opcode(skb->data);
 
-        nfc_dbg("NCI RX: MT=ntf, PBF=%d, GID=0x%x, OID=0x%x, plen=%d",
-                        nci_pbf(skb->data),
-                        nci_opcode_gid(ntf_opcode),
-                        nci_opcode_oid(ntf_opcode),
-                        nci_plen(skb->data));
+        pr_debug("NCI RX: MT=ntf, PBF=%d, GID=0x%x, OID=0x%x, plen=%d\n",
+                 nci_pbf(skb->data),
+                 nci_opcode_gid(ntf_opcode),
+                 nci_opcode_oid(ntf_opcode),
+                 nci_plen(skb->data));
 
         /* strip the nci control header */
         skb_pull(skb, NCI_CTRL_HDR_SIZE);
@@ -278,7 +279,7 @@ void nci_ntf_packet(struct nci_dev *ndev, struct sk_buff *skb)
                 break;
 
         default:
-                nfc_err("unknown ntf opcode 0x%x", ntf_opcode);
+                pr_err("unknown ntf opcode 0x%x\n", ntf_opcode);
                 break;
         }
 
diff --git a/net/nfc/nci/rsp.c b/net/nfc/nci/rsp.c
index 0591f5aff89f..ca611c52aaaa 100644
--- a/net/nfc/nci/rsp.c
+++ b/net/nfc/nci/rsp.c
@@ -25,6 +25,8 @@
  *
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/types.h>
 #include <linux/interrupt.h>
 #include <linux/bitops.h>
@@ -40,12 +42,12 @@ static void nci_core_reset_rsp_packet(struct nci_dev *ndev, struct sk_buff *skb)
 {
         struct nci_core_reset_rsp *rsp = (void *) skb->data;
 
-        nfc_dbg("entry, status 0x%x", rsp->status);
+        pr_debug("status 0x%x\n", rsp->status);
 
         if (rsp->status == NCI_STATUS_OK) {
                 ndev->nci_ver = rsp->nci_ver;
-                nfc_dbg("nci_ver 0x%x, config_status 0x%x",
-                        rsp->nci_ver, rsp->config_status);
+                pr_debug("nci_ver 0x%x, config_status 0x%x\n",
+                         rsp->nci_ver, rsp->config_status);
         }
 
         nci_req_complete(ndev, rsp->status);
@@ -56,7 +58,7 @@ static void nci_core_init_rsp_packet(struct nci_dev *ndev, struct sk_buff *skb)
         struct nci_core_init_rsp_1 *rsp_1 = (void *) skb->data;
         struct nci_core_init_rsp_2 *rsp_2;
 
-        nfc_dbg("entry, status 0x%x", rsp_1->status);
+        pr_debug("status 0x%x\n", rsp_1->status);
 
         if (rsp_1->status != NCI_STATUS_OK)
                 goto exit;
@@ -95,34 +97,34 @@ static void nci_core_init_rsp_packet(struct nci_dev *ndev, struct sk_buff *skb)
 
         atomic_set(&ndev->credits_cnt, ndev->initial_num_credits);
 
-        nfc_dbg("nfcc_features 0x%x",
-                ndev->nfcc_features);
-        nfc_dbg("num_supported_rf_interfaces %d",
-                ndev->num_supported_rf_interfaces);
-        nfc_dbg("supported_rf_interfaces[0] 0x%x",
-                ndev->supported_rf_interfaces[0]);
-        nfc_dbg("supported_rf_interfaces[1] 0x%x",
-                ndev->supported_rf_interfaces[1]);
-        nfc_dbg("supported_rf_interfaces[2] 0x%x",
-                ndev->supported_rf_interfaces[2]);
-        nfc_dbg("supported_rf_interfaces[3] 0x%x",
-                ndev->supported_rf_interfaces[3]);
-        nfc_dbg("max_logical_connections %d",
-                ndev->max_logical_connections);
-        nfc_dbg("max_routing_table_size %d",
-                ndev->max_routing_table_size);
-        nfc_dbg("max_ctrl_pkt_payload_len %d",
-                ndev->max_ctrl_pkt_payload_len);
-        nfc_dbg("max_size_for_large_params %d",
-                ndev->max_size_for_large_params);
-        nfc_dbg("max_data_pkt_payload_size %d",
-                ndev->max_data_pkt_payload_size);
-        nfc_dbg("initial_num_credits %d",
-                ndev->initial_num_credits);
-        nfc_dbg("manufact_id 0x%x",
-                ndev->manufact_id);
-        nfc_dbg("manufact_specific_info 0x%x",
-                ndev->manufact_specific_info);
+        pr_debug("nfcc_features 0x%x\n",
+                 ndev->nfcc_features);
+        pr_debug("num_supported_rf_interfaces %d\n",
+                 ndev->num_supported_rf_interfaces);
+        pr_debug("supported_rf_interfaces[0] 0x%x\n",
+                 ndev->supported_rf_interfaces[0]);
+        pr_debug("supported_rf_interfaces[1] 0x%x\n",
+                 ndev->supported_rf_interfaces[1]);
+        pr_debug("supported_rf_interfaces[2] 0x%x\n",
+                 ndev->supported_rf_interfaces[2]);
+        pr_debug("supported_rf_interfaces[3] 0x%x\n",
+                 ndev->supported_rf_interfaces[3]);
+        pr_debug("max_logical_connections %d\n",
+                 ndev->max_logical_connections);
+        pr_debug("max_routing_table_size %d\n",
+                 ndev->max_routing_table_size);
+        pr_debug("max_ctrl_pkt_payload_len %d\n",
+                 ndev->max_ctrl_pkt_payload_len);
+        pr_debug("max_size_for_large_params %d\n",
+                 ndev->max_size_for_large_params);
+        pr_debug("max_data_pkt_payload_size %d\n",
+                 ndev->max_data_pkt_payload_size);
+        pr_debug("initial_num_credits %d\n",
+                 ndev->initial_num_credits);
+        pr_debug("manufact_id 0x%x\n",
+                 ndev->manufact_id);
+        pr_debug("manufact_specific_info 0x%x\n",
+                 ndev->manufact_specific_info);
 
 exit:
         nci_req_complete(ndev, rsp_1->status);
@@ -133,7 +135,7 @@ static void nci_rf_disc_map_rsp_packet(struct nci_dev *ndev,
 {
         __u8 status = skb->data[0];
 
-        nfc_dbg("entry, status 0x%x", status);
+        pr_debug("status 0x%x\n", status);
 
         nci_req_complete(ndev, status);
 }
@@ -142,7 +144,7 @@ static void nci_rf_disc_rsp_packet(struct nci_dev *ndev, struct sk_buff *skb)
 {
         __u8 status = skb->data[0];
 
-        nfc_dbg("entry, status 0x%x", status);
+        pr_debug("status 0x%x\n", status);
 
         if (status == NCI_STATUS_OK)
                 set_bit(NCI_DISCOVERY, &ndev->flags);
@@ -155,7 +157,7 @@ static void nci_rf_deactivate_rsp_packet(struct nci_dev *ndev,
 {
         __u8 status = skb->data[0];
 
-        nfc_dbg("entry, status 0x%x", status);
+        pr_debug("status 0x%x\n", status);
 
         clear_bit(NCI_DISCOVERY, &ndev->flags);
 
@@ -169,11 +171,11 @@ void nci_rsp_packet(struct nci_dev *ndev, struct sk_buff *skb)
         /* we got a rsp, stop the cmd timer */
         del_timer(&ndev->cmd_timer);
 
-        nfc_dbg("NCI RX: MT=rsp, PBF=%d, GID=0x%x, OID=0x%x, plen=%d",
-                        nci_pbf(skb->data),
-                        nci_opcode_gid(rsp_opcode),
-                        nci_opcode_oid(rsp_opcode),
-                        nci_plen(skb->data));
+        pr_debug("NCI RX: MT=rsp, PBF=%d, GID=0x%x, OID=0x%x, plen=%d\n",
+                 nci_pbf(skb->data),
+                 nci_opcode_gid(rsp_opcode),
+                 nci_opcode_oid(rsp_opcode),
+                 nci_plen(skb->data));
 
         /* strip the nci control header */
         skb_pull(skb, NCI_CTRL_HDR_SIZE);
@@ -200,7 +202,7 @@ void nci_rsp_packet(struct nci_dev *ndev, struct sk_buff *skb)
                 break;
 
         default:
-                nfc_err("unknown rsp opcode 0x%x", rsp_opcode);
+                pr_err("unknown rsp opcode 0x%x\n", rsp_opcode);
                 break;
         }
 
diff --git a/net/nfc/netlink.c b/net/nfc/netlink.c
index 03f8818e1f16..c10e9b8c5ad9 100644
--- a/net/nfc/netlink.c
+++ b/net/nfc/netlink.c
@@ -21,6 +21,8 @@
  * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <net/genetlink.h>
 #include <linux/nfc.h>
 #include <linux/slab.h>
@@ -51,8 +53,6 @@ static int nfc_genl_send_target(struct sk_buff *msg, struct nfc_target *target,
 {
         void *hdr;
 
-        nfc_dbg("entry");
-
         hdr = genlmsg_put(msg, NETLINK_CB(cb->skb).pid, cb->nlh->nlmsg_seq,
                                 &nfc_genl_family, flags, NFC_CMD_GET_TARGET);
         if (!hdr)
@@ -105,8 +105,6 @@ static int nfc_genl_dump_targets(struct sk_buff *skb,
         struct nfc_dev *dev = (struct nfc_dev *) cb->args[1];
         int rc;
 
-        nfc_dbg("entry");
-
         if (!dev) {
                 dev = __get_device_from_cb(cb);
                 if (IS_ERR(dev))
@@ -139,8 +137,6 @@ static int nfc_genl_dump_targets_done(struct netlink_callback *cb)
 {
         struct nfc_dev *dev = (struct nfc_dev *) cb->args[1];
 
-        nfc_dbg("entry");
-
         if (dev)
                 nfc_put_device(dev);
 
@@ -152,8 +148,6 @@ int nfc_genl_targets_found(struct nfc_dev *dev)
         struct sk_buff *msg;
         void *hdr;
 
-        nfc_dbg("entry");
-
         dev->genl_data.poll_req_pid = 0;
 
         msg = nlmsg_new(NLMSG_GOODSIZE, GFP_ATOMIC);
@@ -183,8 +177,6 @@ int nfc_genl_device_added(struct nfc_dev *dev)
         struct sk_buff *msg;
         void *hdr;
 
-        nfc_dbg("entry");
-
         msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
         if (!msg)
                 return -ENOMEM;
@@ -216,8 +208,6 @@ int nfc_genl_device_removed(struct nfc_dev *dev)
         struct sk_buff *msg;
         void *hdr;
 
-        nfc_dbg("entry");
-
         msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
         if (!msg)
                 return -ENOMEM;
@@ -249,8 +239,6 @@ static int nfc_genl_send_device(struct sk_buff *msg, struct nfc_dev *dev,
 {
         void *hdr;
 
-        nfc_dbg("entry");
-
         hdr = genlmsg_put(msg, pid, seq, &nfc_genl_family, flags,
                                                         NFC_CMD_GET_DEVICE);
         if (!hdr)
@@ -277,8 +265,6 @@ static int nfc_genl_dump_devices(struct sk_buff *skb,
         struct nfc_dev *dev = (struct nfc_dev *) cb->args[1];
         bool first_call = false;
 
-        nfc_dbg("entry");
-
         if (!iter) {
                 first_call = true;
                 iter = kmalloc(sizeof(struct class_dev_iter), GFP_KERNEL);
@@ -319,8 +305,6 @@ static int nfc_genl_dump_devices_done(struct netlink_callback *cb)
 {
         struct class_dev_iter *iter = (struct class_dev_iter *) cb->args[0];
 
-        nfc_dbg("entry");
-
         nfc_device_iter_exit(iter);
         kfree(iter);
 
@@ -334,8 +318,6 @@ static int nfc_genl_get_device(struct sk_buff *skb, struct genl_info *info)
         u32 idx;
         int rc = -ENOBUFS;
 
-        nfc_dbg("entry");
-
         if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
                 return -EINVAL;
 
@@ -373,8 +355,6 @@ static int nfc_genl_dev_up(struct sk_buff *skb, struct genl_info *info)
         int rc;
         u32 idx;
 
-        nfc_dbg("entry");
-
         if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
                 return -EINVAL;
 
@@ -396,8 +376,6 @@ static int nfc_genl_dev_down(struct sk_buff *skb, struct genl_info *info)
         int rc;
         u32 idx;
 
-        nfc_dbg("entry");
-
         if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
                 return -EINVAL;
 
@@ -420,8 +398,6 @@ static int nfc_genl_start_poll(struct sk_buff *skb, struct genl_info *info)
         u32 idx;
         u32 protocols;
 
-        nfc_dbg("entry");
-
         if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
                 !info->attrs[NFC_ATTR_PROTOCOLS])
                 return -EINVAL;
@@ -451,8 +427,6 @@ static int nfc_genl_stop_poll(struct sk_buff *skb, struct genl_info *info)
         int rc;
         u32 idx;
 
-        nfc_dbg("entry");
-
         if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
                 return -EINVAL;
 
@@ -524,7 +498,7 @@ static int nfc_genl_rcv_nl_event(struct notifier_block *this,
         if (event != NETLINK_URELEASE || n->protocol != NETLINK_GENERIC)
                 goto out;
 
-        nfc_dbg("NETLINK_URELEASE event from id %d", n->pid);
+        pr_debug("NETLINK_URELEASE event from id %d\n", n->pid);
 
         nfc_device_iter_init(&iter);
         dev = nfc_device_iter_next(&iter);
diff --git a/net/nfc/nfc.h b/net/nfc/nfc.h
index d86583f4831d..67d605015304 100644
--- a/net/nfc/nfc.h
+++ b/net/nfc/nfc.h
@@ -27,13 +27,6 @@
 #include <net/nfc/nfc.h>
 #include <net/sock.h>
 
-__printf(2, 3)
-int nfc_printk(const char *level, const char *fmt, ...);
-
-#define nfc_info(fmt, arg...) nfc_printk(KERN_INFO, fmt, ##arg)
-#define nfc_err(fmt, arg...) nfc_printk(KERN_ERR, fmt, ##arg)
-#define nfc_dbg(fmt, arg...) pr_debug(fmt "\n", ##arg)
-
 struct nfc_protocol {
         int id;
         struct proto *proto;
diff --git a/net/nfc/rawsock.c b/net/nfc/rawsock.c
index ee7b2b365ef2..68ecf3fa94e0 100644
--- a/net/nfc/rawsock.c
+++ b/net/nfc/rawsock.c
@@ -21,6 +21,8 @@
  * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <net/tcp_states.h>
 #include <linux/nfc.h>
 #include <linux/export.h>
@@ -29,7 +31,7 @@
 
 static void rawsock_write_queue_purge(struct sock *sk)
 {
-        nfc_dbg("sk=%p", sk);
+        pr_debug("sk=%p\n", sk);
 
         spin_lock_bh(&sk->sk_write_queue.lock);
         __skb_queue_purge(&sk->sk_write_queue);
@@ -39,7 +41,7 @@ static void rawsock_write_queue_purge(struct sock *sk)
 
 static void rawsock_report_error(struct sock *sk, int err)
 {
-        nfc_dbg("sk=%p err=%d", sk, err);
+        pr_debug("sk=%p err=%d\n", sk, err);
 
         sk->sk_shutdown = SHUTDOWN_MASK;
         sk->sk_err = -err;
@@ -52,7 +54,7 @@ static int rawsock_release(struct socket *sock)
 {
         struct sock *sk = sock->sk;
 
-        nfc_dbg("sock=%p", sock);
+        pr_debug("sock=%p\n", sock);
 
         sock_orphan(sk);
         sock_put(sk);
@@ -68,14 +70,14 @@ static int rawsock_connect(struct socket *sock, struct sockaddr *_addr,
         struct nfc_dev *dev;
         int rc = 0;
 
-        nfc_dbg("sock=%p sk=%p flags=%d", sock, sk, flags);
+        pr_debug("sock=%p sk=%p flags=%d\n", sock, sk, flags);
 
         if (!addr || len < sizeof(struct sockaddr_nfc) ||
                 addr->sa_family != AF_NFC)
                 return -EINVAL;
 
-        nfc_dbg("addr dev_idx=%u target_idx=%u protocol=%u", addr->dev_idx,
-                                        addr->target_idx, addr->nfc_protocol);
+        pr_debug("addr dev_idx=%u target_idx=%u protocol=%u\n",
+                 addr->dev_idx, addr->target_idx, addr->nfc_protocol);
 
         lock_sock(sk);
 
@@ -136,7 +138,7 @@ static void rawsock_data_exchange_complete(void *context, struct sk_buff *skb,
 
         BUG_ON(in_irq());
 
-        nfc_dbg("sk=%p err=%d", sk, err);
+        pr_debug("sk=%p err=%d\n", sk, err);
 
         if (err)
                 goto error;
@@ -172,7 +174,7 @@ static void rawsock_tx_work(struct work_struct *work)
         struct sk_buff *skb;
         int rc;
 
-        nfc_dbg("sk=%p target_idx=%u", sk, target_idx);
+        pr_debug("sk=%p target_idx=%u\n", sk, target_idx);
 
         if (sk->sk_shutdown & SEND_SHUTDOWN) {
                 rawsock_write_queue_purge(sk);
@@ -198,7 +200,7 @@ static int rawsock_sendmsg(struct kiocb *iocb, struct socket *sock,
         struct sk_buff *skb;
         int rc;
 
-        nfc_dbg("sock=%p sk=%p len=%zu", sock, sk, len);
+        pr_debug("sock=%p sk=%p len=%zu\n", sock, sk, len);
 
         if (msg->msg_namelen)
                 return -EOPNOTSUPP;
@@ -239,7 +241,7 @@ static int rawsock_recvmsg(struct kiocb *iocb, struct socket *sock,
         int copied;
         int rc;
 
-        nfc_dbg("sock=%p sk=%p len=%zu flags=%d", sock, sk, len, flags);
+        pr_debug("sock=%p sk=%p len=%zu flags=%d\n", sock, sk, len, flags);
 
         skb = skb_recv_datagram(sk, flags, noblock, &rc);
         if (!skb)
@@ -283,7 +285,7 @@ static const struct proto_ops rawsock_ops = {
 
 static void rawsock_destruct(struct sock *sk)
 {
-        nfc_dbg("sk=%p", sk);
+        pr_debug("sk=%p\n", sk);
 
         if (sk->sk_state == TCP_ESTABLISHED) {
                 nfc_deactivate_target(nfc_rawsock(sk)->dev,
@@ -294,7 +296,7 @@ static void rawsock_destruct(struct sock *sk)
         skb_queue_purge(&sk->sk_receive_queue);
 
         if (!sock_flag(sk, SOCK_DEAD)) {
-                nfc_err("Freeing alive NFC raw socket %p", sk);
+                pr_err("Freeing alive NFC raw socket %p\n", sk);
                 return;
         }
 }
@@ -304,7 +306,7 @@ static int rawsock_create(struct net *net, struct socket *sock,
 {
         struct sock *sk;
 
-        nfc_dbg("sock=%p", sock);
+        pr_debug("sock=%p\n", sock);
 
         if (sock->type != SOCK_SEQPACKET)
                 return -ESOCKTNOSUPPORT;
diff --git a/net/rfkill/rfkill-gpio.c b/net/rfkill/rfkill-gpio.c
index 128677d69056..ca355e7e58b4 100644
--- a/net/rfkill/rfkill-gpio.c
+++ b/net/rfkill/rfkill-gpio.c
@@ -220,18 +220,7 @@ static struct platform_driver rfkill_gpio_driver = {
         },
 };
 
-static int __init rfkill_gpio_init(void)
-{
-        return platform_driver_register(&rfkill_gpio_driver);
-}
-
-static void __exit rfkill_gpio_exit(void)
-{
-        platform_driver_unregister(&rfkill_gpio_driver);
-}
-
-module_init(rfkill_gpio_init);
-module_exit(rfkill_gpio_exit);
+module_platform_driver(rfkill_gpio_driver);
 
 MODULE_DESCRIPTION("gpio rfkill");
 MODULE_AUTHOR("NVIDIA");
diff --git a/net/rfkill/rfkill-regulator.c b/net/rfkill/rfkill-regulator.c
index 3ca7277a3c36..2ebfe8d0e873 100644
--- a/net/rfkill/rfkill-regulator.c
+++ b/net/rfkill/rfkill-regulator.c
@@ -144,17 +144,7 @@ static struct platform_driver rfkill_regulator_driver = {
         },
 };
 
-static int __init rfkill_regulator_init(void)
-{
-        return platform_driver_register(&rfkill_regulator_driver);
-}
-module_init(rfkill_regulator_init);
-
-static void __exit rfkill_regulator_exit(void)
-{
-        platform_driver_unregister(&rfkill_regulator_driver);
-}
-module_exit(rfkill_regulator_exit);
+module_platform_driver(rfkill_regulator_driver);
 
 MODULE_AUTHOR("Guiming Zhuo <gmzhuo@gmail.com>");
 MODULE_AUTHOR("Antonio Ospite <ospite@studenti.unina.it>");
diff --git a/net/wireless/mesh.c b/net/wireless/mesh.c
index b7b7868f4128..8c550df13037 100644
--- a/net/wireless/mesh.c
+++ b/net/wireless/mesh.c
@@ -20,6 +20,7 @@
  * interface
  */
 #define MESH_PREQ_MIN_INT       10
+#define MESH_PERR_MIN_INT       100
 #define MESH_DIAM_TRAVERSAL_TIME 50
 
 /*
@@ -47,6 +48,7 @@ const struct mesh_config default_mesh_config = {
         .dot11MeshMaxPeerLinks = MESH_MAX_ESTAB_PLINKS,
         .dot11MeshHWMPactivePathTimeout = MESH_PATH_TIMEOUT,
         .dot11MeshHWMPpreqMinInterval = MESH_PREQ_MIN_INT,
+        .dot11MeshHWMPperrMinInterval = MESH_PERR_MIN_INT,
         .dot11MeshHWMPnetDiameterTraversalTime = MESH_DIAM_TRAVERSAL_TIME,
         .dot11MeshHWMPmaxPREQretries = MESH_MAX_PREQ_RETRIES,
         .path_refresh_time = MESH_PATH_REFRESH_TIME,
diff --git a/net/wireless/nl80211.c b/net/wireless/nl80211.c
index eee9ccc7adaf..8a9b4d817ae6 100644
--- a/net/wireless/nl80211.c
+++ b/net/wireless/nl80211.c
@@ -204,6 +204,7 @@ static const struct nla_policy nl80211_policy[NL80211_ATTR_MAX+1] = {
         [NL80211_ATTR_HT_CAPABILITY_MASK] = {
                 .len = NL80211_HT_CAPABILITY_LEN
         },
+        [NL80211_ATTR_NOACK_MAP] = { .type = NLA_U16 },
 };
 
 /* policy for the key attributes */
@@ -904,6 +905,7 @@ static int nl80211_send_wiphy(struct sk_buff *msg, u32 pid, u32 seq, int flags,
         if (dev->wiphy.flags & WIPHY_FLAG_SUPPORTS_SCHED_SCAN)
                 CMD(sched_scan_start, START_SCHED_SCAN);
         CMD(probe_client, PROBE_CLIENT);
+        CMD(set_noack_map, SET_NOACK_MAP);
         if (dev->wiphy.flags & WIPHY_FLAG_REPORTS_OBSS) {
                 i++;
                 NLA_PUT_U32(msg, i, NL80211_CMD_REGISTER_BEACONS);
@@ -1759,6 +1761,23 @@ static int nl80211_del_interface(struct sk_buff *skb, struct genl_info *info)
         return rdev->ops->del_virtual_intf(&rdev->wiphy, dev);
 }
 
+static int nl80211_set_noack_map(struct sk_buff *skb, struct genl_info *info)
+{
+        struct cfg80211_registered_device *rdev = info->user_ptr[0];
+        struct net_device *dev = info->user_ptr[1];
+        u16 noack_map;
+
+        if (!info->attrs[NL80211_ATTR_NOACK_MAP])
+                return -EINVAL;
+
+        if (!rdev->ops->set_noack_map)
+                return -EOPNOTSUPP;
+
+        noack_map = nla_get_u16(info->attrs[NL80211_ATTR_NOACK_MAP]);
+
+        return rdev->ops->set_noack_map(&rdev->wiphy, dev, noack_map);
+}
+
 struct get_key_cookie {
         struct sk_buff *msg;
         int error;
@@ -3176,6 +3195,8 @@ static int nl80211_get_mesh_config(struct sk_buff *skb,
                         cur_params.dot11MeshHWMPactivePathTimeout);
         NLA_PUT_U16(msg, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
                         cur_params.dot11MeshHWMPpreqMinInterval);
+        NLA_PUT_U16(msg, NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL,
+                        cur_params.dot11MeshHWMPperrMinInterval);
         NLA_PUT_U16(msg, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
                         cur_params.dot11MeshHWMPnetDiameterTraversalTime);
         NLA_PUT_U8(msg, NL80211_MESHCONF_HWMP_ROOTMODE,
@@ -3210,6 +3231,7 @@ static const struct nla_policy nl80211_meshconf_params_policy[NL80211_MESHCONF_A
         [NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT] = { .type = NLA_U16 },
         [NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT] = { .type = NLA_U32 },
         [NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL] = { .type = NLA_U16 },
+        [NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL] = { .type = NLA_U16 },
         [NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME] = { .type = NLA_U16 },
         [NL80211_MESHCONF_HWMP_ROOTMODE] = { .type = NLA_U8 },
         [NL80211_MESHCONF_HWMP_RANN_INTERVAL] = { .type = NLA_U16 },
@@ -3284,6 +3306,9 @@ do {\
         FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPpreqMinInterval,
                         mask, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
                         nla_get_u16);
+        FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPperrMinInterval,
+                        mask, NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL,
+                        nla_get_u16);
         FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
                         dot11MeshHWMPnetDiameterTraversalTime,
                         mask, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
@@ -5648,6 +5673,11 @@ static int nl80211_join_mesh(struct sk_buff *skb, struct genl_info *info)
         setup.mesh_id = nla_data(info->attrs[NL80211_ATTR_MESH_ID]);
         setup.mesh_id_len = nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
 
+        if (info->attrs[NL80211_ATTR_MCAST_RATE] &&
+            !nl80211_parse_mcast_rate(rdev, setup.mcast_rate,
+                            nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE])))
+                        return -EINVAL;
+
         if (info->attrs[NL80211_ATTR_MESH_SETUP]) {
                 /* parse additional setup parameters if given */
                 err = nl80211_parse_mesh_setup(info, &setup);
@@ -6604,6 +6634,15 @@ static struct genl_ops nl80211_ops[] = {
                 .internal_flags = NL80211_FLAG_NEED_WIPHY |
                                   NL80211_FLAG_NEED_RTNL,
         },
+        {
+                .cmd = NL80211_CMD_SET_NOACK_MAP,
+                .doit = nl80211_set_noack_map,
+                .policy = nl80211_policy,
+                .flags = GENL_ADMIN_PERM,
+                .internal_flags = NL80211_FLAG_NEED_NETDEV |
+                                  NL80211_FLAG_NEED_RTNL,
+        },
+
 };
 
 static struct genl_multicast_group nl80211_mlme_mcgrp = {
diff --git a/net/wireless/reg.c b/net/wireless/reg.c
index 76b35df39623..70b171a52aea 100644
--- a/net/wireless/reg.c
+++ b/net/wireless/reg.c
@@ -57,8 +57,17 @@
 #define REG_DBG_PRINT(args...)
 #endif
 
+static struct regulatory_request core_request_world = {
+        .initiator = NL80211_REGDOM_SET_BY_CORE,
+        .alpha2[0] = '0',
+        .alpha2[1] = '0',
+        .intersect = false,
+        .processed = true,
+        .country_ie_env = ENVIRON_ANY,
+};
+
 /* Receipt of information from last regulatory request */
-static struct regulatory_request *last_request;
+static struct regulatory_request *last_request = &core_request_world;
 
 /* To trigger userspace events */
 static struct platform_device *reg_pdev;
@@ -150,7 +159,7 @@ static char user_alpha2[2];
 module_param(ieee80211_regdom, charp, 0444);
 MODULE_PARM_DESC(ieee80211_regdom, "IEEE 802.11 regulatory domain code");
 
-static void reset_regdomains(void)
+static void reset_regdomains(bool full_reset)
 {
         /* avoid freeing static information or freeing something twice */
         if (cfg80211_regdomain == cfg80211_world_regdom)
@@ -165,6 +174,13 @@ static void reset_regdomains(void)
 
         cfg80211_world_regdom = &world_regdom;
         cfg80211_regdomain = NULL;
+
+        if (!full_reset)
+                return;
+
+        if (last_request != &core_request_world)
+                kfree(last_request);
+        last_request = &core_request_world;
 }
 
 /*
@@ -175,7 +191,7 @@ static void update_world_regdomain(const struct ieee80211_regdomain *rd)
 {
         BUG_ON(!last_request);
 
-        reset_regdomains();
+        reset_regdomains(false);
 
         cfg80211_world_regdom = rd;
         cfg80211_regdomain = rd;
@@ -1409,7 +1425,8 @@ static int __regulatory_hint(struct wiphy *wiphy,
         }
 
 new_request:
-        kfree(last_request);
+        if (last_request != &core_request_world)
+                kfree(last_request);
 
         last_request = pending_request;
         last_request->intersect = intersect;
@@ -1579,9 +1596,6 @@ static int regulatory_hint_core(const char *alpha2)
 {
         struct regulatory_request *request;
 
-        kfree(last_request);
-        last_request = NULL;
-
         request = kzalloc(sizeof(struct regulatory_request),
                           GFP_KERNEL);
         if (!request)
@@ -1779,7 +1793,7 @@ static void restore_regulatory_settings(bool reset_user)
         mutex_lock(&cfg80211_mutex);
         mutex_lock(&reg_mutex);
 
-        reset_regdomains();
+        reset_regdomains(true);
         restore_alpha2(alpha2, reset_user);
 
         /*
@@ -2076,8 +2090,10 @@ static int __set_regdom(const struct ieee80211_regdomain *rd)
         }
 
         request_wiphy = wiphy_idx_to_wiphy(last_request->wiphy_idx);
-        if (!request_wiphy) {
-                reg_set_request_processed();
+        if (!request_wiphy &&
+            (last_request->initiator == NL80211_REGDOM_SET_BY_DRIVER ||
+             last_request->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE)) {
+                schedule_delayed_work(&reg_timeout, 0);
                 return -ENODEV;
         }
 
@@ -2085,7 +2101,7 @@ static int __set_regdom(const struct ieee80211_regdomain *rd)
                 int r;
 
                 if (last_request->initiator != NL80211_REGDOM_SET_BY_DRIVER) {
-                        reset_regdomains();
+                        reset_regdomains(false);
                         cfg80211_regdomain = rd;
                         return 0;
                 }
@@ -2106,7 +2122,7 @@ static int __set_regdom(const struct ieee80211_regdomain *rd)
                 if (r)
                         return r;
 
-                reset_regdomains();
+                reset_regdomains(false);
                 cfg80211_regdomain = rd;
                 return 0;
         }
@@ -2131,7 +2147,7 @@ static int __set_regdom(const struct ieee80211_regdomain *rd)
 
                 rd = NULL;
 
-                reset_regdomains();
+                reset_regdomains(false);
                 cfg80211_regdomain = intersected_rd;
 
                 return 0;
@@ -2151,7 +2167,7 @@ static int __set_regdom(const struct ieee80211_regdomain *rd)
         kfree(rd);
         rd = NULL;
 
-        reset_regdomains();
+        reset_regdomains(false);
         cfg80211_regdomain = intersected_rd;
 
         return 0;
@@ -2304,11 +2320,8 @@ void /* __init_or_exit */ regulatory_exit(void)
         mutex_lock(&cfg80211_mutex);
         mutex_lock(&reg_mutex);
 
-        reset_regdomains();
-
-        kfree(last_request);
+        reset_regdomains(true);
 
-        last_request = NULL;
         dev_set_uevent_suppress(&reg_pdev->dev, true);
 
         platform_device_unregister(reg_pdev);