mac80211: add rate control rewrite and enhance the performance of the minstrel algorithm for non-mrr configurations

git-svn-id: svn://svn.openwrt.org/openwrt/trunk@12948 3c298f89-4303-0410-b956-a3cf2f4a3e73

22 files changed, 7636 insertions, 129 deletions

diff --git a/package/mac80211/patches/300-minstrel_no_mrr.patch b/package/mac80211/patches/300-minstrel_no_mrr.patch
deleted file mode 100644
index d4c04c4d8b..0000000000
--- a/package/mac80211/patches/300-minstrel_no_mrr.patch
+++ /dev/null
@@ -1,31 +0,0 @@
-This fixes tx status processing for drivers that do not support mrr.
-If the retry count is bigger than the maximum retry count configured in
-the hardware, do not count the rate attempt as successful, the hardware
-has probably switched to a lower rate.
-
-Signed-off-by: Felix Fietkau <nbd@openwrt.org>
-
---- a/net/mac80211/rc80211_minstrel.c
-+++ b/net/mac80211/rc80211_minstrel.c
-@@ -171,6 +171,7 @@ minstrel_tx_status(void *priv, struct ie
- 	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
- 	struct ieee80211_tx_altrate *ar = info->status.retries;
- 	struct minstrel_priv *mp = priv;
-+	struct ieee80211_local *local = hw_to_local(mp->hw);
- 	int i, ndx, tries;
- 	int success = 0;
- 
-@@ -180,6 +181,13 @@ minstrel_tx_status(void *priv, struct ie
- 	if (!mp->has_mrr || (ar[0].rate_idx < 0)) {
- 		ndx = rix_to_ndx(mi, info->tx_rate_idx);
- 		tries = info->status.retry_count + 1;
-+
-+		/* If the driver does not support the MRR API, but uses
-+		 * a fallback rate, use the long retry limit as indication
-+		 * that a rate switch has happened */
-+		if (!mp->has_mrr && (tries >= local->long_retry_limit))
-+			success = 0;
-+
- 		mi->r[ndx].success += success;
- 		mi->r[ndx].attempts += tries;
- 		return;
diff --git a/package/mac80211/patches/310-b43_txstatus.patch b/package/mac80211/patches/310-b43_txstatus.patch
deleted file mode 100644
index db731e584a..0000000000
--- a/package/mac80211/patches/310-b43_txstatus.patch
+++ /dev/null
@@ -1,98 +0,0 @@
-Fix the b43 tx status reporting.
-
-If the hardware uses RTS/CTS reporting and the actual RTS/CTS
-handshake failed, it will switch to the fallback rate, even
-though the main rate was never actually attempted.
-Make sure that this does not screw up rate control statistics.
-
-Signed-off-by: Felix Fietkau <nbd@openwrt.org>
-
---- a/drivers/net/wireless/b43/b43.h
-+++ b/drivers/net/wireless/b43/b43.h
-@@ -778,6 +778,9 @@ struct b43_wldev {
- #ifdef CONFIG_B43_DEBUG
- 	struct b43_dfsentry *dfsentry;
- #endif
-+
-+	/* necessary for figuring out the correct tx status */
-+	int short_retry;
- };
- 
- static inline struct b43_wl *hw_to_b43_wl(struct ieee80211_hw *hw)
---- a/drivers/net/wireless/b43/dma.c
-+++ b/drivers/net/wireless/b43/dma.c
-@@ -1393,7 +1393,7 @@ void b43_dma_handle_txstatus(struct b43_
- 			 * Call back to inform the ieee80211 subsystem about
- 			 * the status of the transmission.
- 			 */
--			frame_succeed = b43_fill_txstatus_report(info, status);
-+			frame_succeed = b43_fill_txstatus_report(dev, info, status);
- #ifdef CONFIG_B43_DEBUG
- 			if (frame_succeed)
- 				ring->nr_succeed_tx_packets++;
---- a/drivers/net/wireless/b43/main.c
-+++ b/drivers/net/wireless/b43/main.c
-@@ -3892,6 +3892,7 @@ static void b43_set_retry_limits(struct 
- 			short_retry);
- 	b43_shm_write16(dev, B43_SHM_SCRATCH, B43_SHM_SC_LRLIMIT,
- 			long_retry);
-+	dev->short_retry = short_retry;
- }
- 
- static void b43_set_synth_pu_delay(struct b43_wldev *dev, bool idle)
---- a/drivers/net/wireless/b43/pio.c
-+++ b/drivers/net/wireless/b43/pio.c
-@@ -589,7 +589,7 @@ void b43_pio_handle_txstatus(struct b43_
- 	info = IEEE80211_SKB_CB(pack->skb);
- 	memset(&info->status, 0, sizeof(info->status));
- 
--	b43_fill_txstatus_report(info, status);
-+	b43_fill_txstatus_report(dev, info, status);
- 
- 	total_len = pack->skb->len + b43_txhdr_size(dev);
- 	total_len = roundup(total_len, 4);
---- a/drivers/net/wireless/b43/xmit.c
-+++ b/drivers/net/wireless/b43/xmit.c
-@@ -687,7 +687,8 @@ void b43_handle_txstatus(struct b43_wlde
- /* Fill out the mac80211 TXstatus report based on the b43-specific
-  * txstatus report data. This returns a boolean whether the frame was
-  * successfully transmitted. */
--bool b43_fill_txstatus_report(struct ieee80211_tx_info *report,
-+bool b43_fill_txstatus_report(struct b43_wldev *dev,
-+			      struct ieee80211_tx_info *report,
- 			      const struct b43_txstatus *status)
- {
- 	bool frame_success = 1;
-@@ -706,8 +707,19 @@ bool b43_fill_txstatus_report(struct iee
- 	if (status->frame_count == 0) {
- 		/* The frame was not transmitted at all. */
- 		report->status.retry_count = 0;
--	} else
-+	} else if (status->rts_count > dev->short_retry) {
-+		/*
-+		 * If the short retries (RTS, not data frame) have exceeded
-+		 * the limit, the hw will not have tried the selected rate,
-+		 * but will have used the fallback rate instead.
-+		 * Don't let the rate control count attempts for the selected
-+		 * rate in this case, otherwise the statistics will be off.
-+		 */
-+		report->tx_rate_idx = 0;
-+		report->status.retry_count = 0;
-+	} else {
- 		report->status.retry_count = status->frame_count - 1;
-+	}
- 
- 	return frame_success;
- }
---- a/drivers/net/wireless/b43/xmit.h
-+++ b/drivers/net/wireless/b43/xmit.h
-@@ -294,7 +294,8 @@ void b43_rx(struct b43_wldev *dev, struc
- 
- void b43_handle_txstatus(struct b43_wldev *dev,
- 			 const struct b43_txstatus *status);
--bool b43_fill_txstatus_report(struct ieee80211_tx_info *report,
-+bool b43_fill_txstatus_report(struct b43_wldev *dev,
-+			      struct ieee80211_tx_info *report,
- 			      const struct b43_txstatus *status);
- 
- void b43_tx_suspend(struct b43_wldev *dev);
diff --git a/package/mac80211/patches/407-debugfs-sta-work-fix.patch b/package/mac80211/patches/407-debugfs-sta-work-fix.patch
new file mode 100644
index 0000000000..4dbdba998b
--- /dev/null
+++ b/package/mac80211/patches/407-debugfs-sta-work-fix.patch
@@ -0,0 +1,68 @@
+Subject: mac80211: fix debugfs lockup
+
+When debugfs_create_dir fails, sta_info_debugfs_add_work will not
+terminate because it will find the same station again and again.
+This is possible whenever debugfs fails for whatever reason; one
+reason is a race condition in mac80211, unfortunately we cannot
+do much about it, so just document it, it just means some station
+may be missing from debugfs.
+
+Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
+Cc: Robin Holt <holt@sgi.com>
+---
+ net/mac80211/debugfs_sta.c |   11 +++++++++++
+ net/mac80211/sta_info.c    |    7 ++++++-
+ net/mac80211/sta_info.h    |    1 +
+ 3 files changed, 18 insertions(+), 1 deletion(-)
+
+--- everything.orig/net/mac80211/debugfs_sta.c	2008-10-07 20:05:29.000000000 +0200
++++ everything/net/mac80211/debugfs_sta.c	2008-10-07 20:06:39.000000000 +0200
+@@ -249,11 +249,22 @@ void ieee80211_sta_debugfs_add(struct st
+ 	DECLARE_MAC_BUF(mbuf);
+ 	u8 *mac;
+ 
++	sta->debugfs.add_has_run = true;
++
+ 	if (!stations_dir)
+ 		return;
+ 
+ 	mac = print_mac(mbuf, sta->sta.addr);
+ 
++	/*
++	 * This might fail due to a race condition:
++	 * When mac80211 unlinks a station, the debugfs entries
++	 * remain, but it is already possible to link a new
++	 * station with the same address which triggers adding
++	 * it to debugfs; therefore, if the old station isn't
++	 * destroyed quickly enough the old station's debugfs
++	 * dir might still be around.
++	 */
+ 	sta->debugfs.dir = debugfs_create_dir(mac, stations_dir);
+ 	if (!sta->debugfs.dir)
+ 		return;
+--- everything.orig/net/mac80211/sta_info.c	2008-10-07 20:05:29.000000000 +0200
++++ everything/net/mac80211/sta_info.c	2008-10-07 20:06:39.000000000 +0200
+@@ -635,7 +635,12 @@ static void sta_info_debugfs_add_work(st
+ 
+ 		spin_lock_irqsave(&local->sta_lock, flags);
+ 		list_for_each_entry(tmp, &local->sta_list, list) {
+-			if (!tmp->debugfs.dir) {
++			/*
++			 * debugfs.add_has_run will be set by
++			 * ieee80211_sta_debugfs_add regardless
++			 * of what else it does.
++			 */
++			if (!tmp->debugfs.add_has_run) {
+ 				sta = tmp;
+ 				__sta_info_pin(sta);
+ 				break;
+--- everything.orig/net/mac80211/sta_info.h	2008-10-07 20:05:29.000000000 +0200
++++ everything/net/mac80211/sta_info.h	2008-10-07 20:06:39.000000000 +0200
+@@ -300,6 +300,7 @@ struct sta_info {
+ 		struct dentry *inactive_ms;
+ 		struct dentry *last_seq_ctrl;
+ 		struct dentry *agg_status;
++		bool add_has_run;
+ 	} debugfs;
+ #endif
+ 
diff --git a/package/mac80211/patches/408-mac80211-remove-agg-debugfs.patch b/package/mac80211/patches/408-mac80211-remove-agg-debugfs.patch
new file mode 100644
index 0000000000..5cbab6889a
--- /dev/null
+++ b/package/mac80211/patches/408-mac80211-remove-agg-debugfs.patch
@@ -0,0 +1,98 @@
+Subject: mac80211: remove aggregation status write support from debugfs
+
+This code uses static variables and thus cannot be kept.
+
+Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
+---
+ net/mac80211/debugfs_sta.c |   73 ---------------------------------------------
+ 1 file changed, 1 insertion(+), 72 deletions(-)
+
+--- everything.orig/net/mac80211/debugfs_sta.c	2008-10-07 20:06:39.000000000 +0200
++++ everything/net/mac80211/debugfs_sta.c	2008-10-07 20:06:40.000000000 +0200
+@@ -39,13 +39,6 @@ static const struct file_operations sta_
+ 	.open = mac80211_open_file_generic,				\
+ }
+ 
+-#define STA_OPS_WR(name)						\
+-static const struct file_operations sta_ ##name## _ops = {		\
+-	.read = sta_##name##_read,					\
+-	.write = sta_##name##_write,					\
+-	.open = mac80211_open_file_generic,				\
+-}
+-
+ #define STA_FILE(name, field, format)					\
+ 		STA_READ_##format(name, field)				\
+ 		STA_OPS(name)
+@@ -168,71 +161,7 @@ static ssize_t sta_agg_status_read(struc
+ 
+ 	return simple_read_from_buffer(userbuf, count, ppos, buf, p - buf);
+ }
+-
+-static ssize_t sta_agg_status_write(struct file *file,
+-		const char __user *user_buf, size_t count, loff_t *ppos)
+-{
+-	struct sta_info *sta = file->private_data;
+-	struct ieee80211_local *local = sta->sdata->local;
+-	struct ieee80211_hw *hw = &local->hw;
+-	u8 *da = sta->sta.addr;
+-	static int tid_static_tx[16] = {0, 0, 0, 0, 0, 0, 0, 0,
+-					0, 0, 0, 0, 0, 0, 0, 0};
+-	static int tid_static_rx[16] = {1, 1, 1, 1, 1, 1, 1, 1,
+-					1, 1, 1, 1, 1, 1, 1, 1};
+-	char *endp;
+-	char buf[32];
+-	int buf_size, rs;
+-	unsigned int tid_num;
+-	char state[4];
+-
+-	memset(buf, 0x00, sizeof(buf));
+-	buf_size = min(count, (sizeof(buf)-1));
+-	if (copy_from_user(buf, user_buf, buf_size))
+-		return -EFAULT;
+-
+-	tid_num = simple_strtoul(buf, &endp, 0);
+-	if (endp == buf)
+-		return -EINVAL;
+-
+-	if ((tid_num >= 100) && (tid_num <= 115)) {
+-		/* toggle Rx aggregation command */
+-		tid_num = tid_num - 100;
+-		if (tid_static_rx[tid_num] == 1) {
+-			strcpy(state, "off ");
+-			ieee80211_sta_stop_rx_ba_session(sta->sdata, da, tid_num, 0,
+-					WLAN_REASON_QSTA_REQUIRE_SETUP);
+-			sta->ampdu_mlme.tid_state_rx[tid_num] |=
+-					HT_AGG_STATE_DEBUGFS_CTL;
+-			tid_static_rx[tid_num] = 0;
+-		} else {
+-			strcpy(state, "on ");
+-			sta->ampdu_mlme.tid_state_rx[tid_num] &=
+-					~HT_AGG_STATE_DEBUGFS_CTL;
+-			tid_static_rx[tid_num] = 1;
+-		}
+-		printk(KERN_DEBUG "debugfs - try switching tid %u %s\n",
+-				tid_num, state);
+-	} else if ((tid_num >= 0) && (tid_num <= 15)) {
+-		/* toggle Tx aggregation command */
+-		if (tid_static_tx[tid_num] == 0) {
+-			strcpy(state, "on ");
+-			rs =  ieee80211_start_tx_ba_session(hw, da, tid_num);
+-			if (rs == 0)
+-				tid_static_tx[tid_num] = 1;
+-		} else {
+-			strcpy(state, "off");
+-			rs =  ieee80211_stop_tx_ba_session(hw, da, tid_num, 1);
+-			if (rs == 0)
+-				tid_static_tx[tid_num] = 0;
+-		}
+-		printk(KERN_DEBUG "debugfs - switching tid %u %s, return=%d\n",
+-				tid_num, state, rs);
+-	}
+-
+-	return count;
+-}
+-STA_OPS_WR(agg_status);
++STA_OPS(agg_status);
+ 
+ #define DEBUGFS_ADD(name) \
+ 	sta->debugfs.name = debugfs_create_file(#name, 0400, \
diff --git a/package/mac80211/patches/409-mac80211-remove-mesh-debugfs.patch b/package/mac80211/patches/409-mac80211-remove-mesh-debugfs.patch
new file mode 100644
index 0000000000..77c4701495
--- /dev/null
+++ b/package/mac80211/patches/409-mac80211-remove-mesh-debugfs.patch
@@ -0,0 +1,155 @@
+Subject: mac80211: remove writable debugs mesh parameters
+
+These parameters shouldn't be configurable via debugfs, if they
+need to be configurable nl80211 support has to be added, if not
+then they don't need to be writable here either.
+
+Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
+Cc: Javier Cardona <javier@cozybit.com>
+Cc: Luis Carlos Cobo <luisca@cozybit.com>
+---
+ net/mac80211/debugfs_netdev.c |  112 +++++++++---------------------------------
+ 1 file changed, 24 insertions(+), 88 deletions(-)
+
+--- everything.orig/net/mac80211/debugfs_netdev.c	2008-10-07 20:05:28.000000000 +0200
++++ everything/net/mac80211/debugfs_netdev.c	2008-10-07 20:06:40.000000000 +0200
+@@ -41,29 +41,6 @@ static ssize_t ieee80211_if_read(
+ 	return ret;
+ }
+ 
+-#ifdef CONFIG_MAC80211_MESH
+-static ssize_t ieee80211_if_write(
+-	struct ieee80211_sub_if_data *sdata,
+-	char const __user *userbuf,
+-	size_t count, loff_t *ppos,
+-	int (*format)(struct ieee80211_sub_if_data *, char *))
+-{
+-	char buf[10];
+-	int buf_size;
+-
+-	memset(buf, 0x00, sizeof(buf));
+-	buf_size = min(count, (sizeof(buf)-1));
+-	if (copy_from_user(buf, userbuf, buf_size))
+-		return count;
+-	read_lock(&dev_base_lock);
+-	if (sdata->dev->reg_state == NETREG_REGISTERED)
+-		(*format)(sdata, buf);
+-	read_unlock(&dev_base_lock);
+-
+-	return count;
+-}
+-#endif
+-
+ #define IEEE80211_IF_FMT(name, field, format_string)			\
+ static ssize_t ieee80211_if_fmt_##name(					\
+ 	const struct ieee80211_sub_if_data *sdata, char *buf,		\
+@@ -71,19 +48,6 @@ static ssize_t ieee80211_if_fmt_##name(	
+ {									\
+ 	return scnprintf(buf, buflen, format_string, sdata->field);	\
+ }
+-#define IEEE80211_IF_WFMT(name, field, type)				\
+-static int ieee80211_if_wfmt_##name(					\
+-	struct ieee80211_sub_if_data *sdata, char *buf)			\
+-{									\
+-	unsigned long tmp;						\
+-	char *endp;							\
+-									\
+-	tmp = simple_strtoul(buf, &endp, 0);				\
+-	if ((endp == buf) || ((type)tmp != tmp))			\
+-		return -EINVAL;						\
+-	sdata->field = tmp;						\
+-	return 0;							\
+-}
+ #define IEEE80211_IF_FMT_DEC(name, field)				\
+ 		IEEE80211_IF_FMT(name, field, "%d\n")
+ #define IEEE80211_IF_FMT_HEX(name, field)				\
+@@ -126,34 +90,6 @@ static const struct file_operations name
+ 		IEEE80211_IF_FMT_##format(name, field)			\
+ 		__IEEE80211_IF_FILE(name)
+ 
+-#define __IEEE80211_IF_WFILE(name)					\
+-static ssize_t ieee80211_if_read_##name(struct file *file,		\
+-					char __user *userbuf,		\
+-					size_t count, loff_t *ppos)	\
+-{									\
+-	return ieee80211_if_read(file->private_data,			\
+-				 userbuf, count, ppos,			\
+-				 ieee80211_if_fmt_##name);		\
+-}									\
+-static ssize_t ieee80211_if_write_##name(struct file *file,		\
+-					const char __user *userbuf,	\
+-					size_t count, loff_t *ppos)	\
+-{									\
+-	return ieee80211_if_write(file->private_data,			\
+-				 userbuf, count, ppos,			\
+-				 ieee80211_if_wfmt_##name);		\
+-}									\
+-static const struct file_operations name##_ops = {			\
+-	.read = ieee80211_if_read_##name,				\
+-	.write = ieee80211_if_write_##name,				\
+-	.open = mac80211_open_file_generic,				\
+-}
+-
+-#define IEEE80211_IF_WFILE(name, field, format, type)			\
+-		IEEE80211_IF_FMT_##format(name, field)			\
+-		IEEE80211_IF_WFMT(name, field, type)			\
+-		__IEEE80211_IF_WFILE(name)
+-
+ /* common attributes */
+ IEEE80211_IF_FILE(drop_unencrypted, drop_unencrypted, DEC);
+ IEEE80211_IF_FILE(force_unicast_rateidx, force_unicast_rateidx, DEC);
+@@ -212,30 +148,30 @@ IEEE80211_IF_FILE(dropped_frames_no_rout
+ IEEE80211_IF_FILE(estab_plinks, u.mesh.mshstats.estab_plinks, ATOMIC);
+ 
+ /* Mesh parameters */
+-IEEE80211_IF_WFILE(dot11MeshMaxRetries,
+-		u.mesh.mshcfg.dot11MeshMaxRetries, DEC, u8);
+-IEEE80211_IF_WFILE(dot11MeshRetryTimeout,
+-		u.mesh.mshcfg.dot11MeshRetryTimeout, DEC, u16);
+-IEEE80211_IF_WFILE(dot11MeshConfirmTimeout,
+-		u.mesh.mshcfg.dot11MeshConfirmTimeout, DEC, u16);
+-IEEE80211_IF_WFILE(dot11MeshHoldingTimeout,
+-		u.mesh.mshcfg.dot11MeshHoldingTimeout, DEC, u16);
+-IEEE80211_IF_WFILE(dot11MeshTTL, u.mesh.mshcfg.dot11MeshTTL, DEC, u8);
+-IEEE80211_IF_WFILE(auto_open_plinks, u.mesh.mshcfg.auto_open_plinks, DEC, u8);
+-IEEE80211_IF_WFILE(dot11MeshMaxPeerLinks,
+-		u.mesh.mshcfg.dot11MeshMaxPeerLinks, DEC, u16);
+-IEEE80211_IF_WFILE(dot11MeshHWMPactivePathTimeout,
+-		u.mesh.mshcfg.dot11MeshHWMPactivePathTimeout, DEC, u32);
+-IEEE80211_IF_WFILE(dot11MeshHWMPpreqMinInterval,
+-		u.mesh.mshcfg.dot11MeshHWMPpreqMinInterval, DEC, u16);
+-IEEE80211_IF_WFILE(dot11MeshHWMPnetDiameterTraversalTime,
+-		u.mesh.mshcfg.dot11MeshHWMPnetDiameterTraversalTime, DEC, u16);
+-IEEE80211_IF_WFILE(dot11MeshHWMPmaxPREQretries,
+-		u.mesh.mshcfg.dot11MeshHWMPmaxPREQretries, DEC, u8);
+-IEEE80211_IF_WFILE(path_refresh_time,
+-		u.mesh.mshcfg.path_refresh_time, DEC, u32);
+-IEEE80211_IF_WFILE(min_discovery_timeout,
+-		u.mesh.mshcfg.min_discovery_timeout, DEC, u16);
++IEEE80211_IF_FILE(dot11MeshMaxRetries,
++		u.mesh.mshcfg.dot11MeshMaxRetries, DEC);
++IEEE80211_IF_FILE(dot11MeshRetryTimeout,
++		u.mesh.mshcfg.dot11MeshRetryTimeout, DEC);
++IEEE80211_IF_FILE(dot11MeshConfirmTimeout,
++		u.mesh.mshcfg.dot11MeshConfirmTimeout, DEC);
++IEEE80211_IF_FILE(dot11MeshHoldingTimeout,
++		u.mesh.mshcfg.dot11MeshHoldingTimeout, DEC);
++IEEE80211_IF_FILE(dot11MeshTTL, u.mesh.mshcfg.dot11MeshTTL, DEC);
++IEEE80211_IF_FILE(auto_open_plinks, u.mesh.mshcfg.auto_open_plinks, DEC);
++IEEE80211_IF_FILE(dot11MeshMaxPeerLinks,
++		u.mesh.mshcfg.dot11MeshMaxPeerLinks, DEC);
++IEEE80211_IF_FILE(dot11MeshHWMPactivePathTimeout,
++		u.mesh.mshcfg.dot11MeshHWMPactivePathTimeout, DEC);
++IEEE80211_IF_FILE(dot11MeshHWMPpreqMinInterval,
++		u.mesh.mshcfg.dot11MeshHWMPpreqMinInterval, DEC);
++IEEE80211_IF_FILE(dot11MeshHWMPnetDiameterTraversalTime,
++		u.mesh.mshcfg.dot11MeshHWMPnetDiameterTraversalTime, DEC);
++IEEE80211_IF_FILE(dot11MeshHWMPmaxPREQretries,
++		u.mesh.mshcfg.dot11MeshHWMPmaxPREQretries, DEC);
++IEEE80211_IF_FILE(path_refresh_time,
++		u.mesh.mshcfg.path_refresh_time, DEC);
++IEEE80211_IF_FILE(min_discovery_timeout,
++		u.mesh.mshcfg.min_discovery_timeout, DEC);
+ #endif
+ 
+ 
diff --git a/package/mac80211/patches/410-mac80211-cleanups.patch b/package/mac80211/patches/410-mac80211-cleanups.patch
new file mode 100644
index 0000000000..bd66d04a9d
--- /dev/null
+++ b/package/mac80211/patches/410-mac80211-cleanups.patch
@@ -0,0 +1,364 @@
+Subject: mac80211: minor code cleanups
+
+Nothing very interesting, some checkpatch inspired stuff,
+some other things.
+
+Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
+---
+ net/mac80211/debugfs_sta.c |    6 +++---
+ net/mac80211/main.c        |    2 +-
+ net/mac80211/mesh.c        |    2 +-
+ net/mac80211/rc80211_pid.h |    2 +-
+ net/mac80211/rx.c          |   24 +++++++++++++-----------
+ net/mac80211/sta_info.c    |    4 ++--
+ net/mac80211/wep.c         |   26 +++++++++++++-------------
+ net/mac80211/wep.h         |    2 +-
+ net/mac80211/wpa.c         |   29 ++++++++++-------------------
+ 9 files changed, 45 insertions(+), 52 deletions(-)
+
+--- everything.orig/net/mac80211/wep.c	2008-10-07 20:05:49.000000000 +0200
++++ everything/net/mac80211/wep.c	2008-10-07 20:06:41.000000000 +0200
+@@ -49,17 +49,19 @@ void ieee80211_wep_free(struct ieee80211
+ 	crypto_free_blkcipher(local->wep_rx_tfm);
+ }
+ 
+-static inline int ieee80211_wep_weak_iv(u32 iv, int keylen)
++static inline bool ieee80211_wep_weak_iv(u32 iv, int keylen)
+ {
+-	/* Fluhrer, Mantin, and Shamir have reported weaknesses in the
++	/*
++	 * Fluhrer, Mantin, and Shamir have reported weaknesses in the
+ 	 * key scheduling algorithm of RC4. At least IVs (KeyByte + 3,
+-	 * 0xff, N) can be used to speedup attacks, so avoid using them. */
++	 * 0xff, N) can be used to speedup attacks, so avoid using them.
++	 */
+ 	if ((iv & 0xff00) == 0xff00) {
+ 		u8 B = (iv >> 16) & 0xff;
+ 		if (B >= 3 && B < 3 + keylen)
+-			return 1;
++			return true;
+ 	}
+-	return 0;
++	return false;
+ }
+ 
+ 
+@@ -268,7 +270,7 @@ int ieee80211_wep_decrypt(struct ieee802
+ }
+ 
+ 
+-u8 * ieee80211_wep_is_weak_iv(struct sk_buff *skb, struct ieee80211_key *key)
++bool ieee80211_wep_is_weak_iv(struct sk_buff *skb, struct ieee80211_key *key)
+ {
+ 	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
+ 	unsigned int hdrlen;
+@@ -276,16 +278,13 @@ u8 * ieee80211_wep_is_weak_iv(struct sk_
+ 	u32 iv;
+ 
+ 	if (!ieee80211_has_protected(hdr->frame_control))
+-		return NULL;
++		return false;
+ 
+ 	hdrlen = ieee80211_hdrlen(hdr->frame_control);
+ 	ivpos = skb->data + hdrlen;
+ 	iv = (ivpos[0] << 16) | (ivpos[1] << 8) | ivpos[2];
+ 
+-	if (ieee80211_wep_weak_iv(iv, key->conf.keylen))
+-		return ivpos;
+-
+-	return NULL;
++	return ieee80211_wep_weak_iv(iv, key->conf.keylen);
+ }
+ 
+ ieee80211_rx_result
+@@ -329,6 +328,8 @@ static int wep_encrypt_skb(struct ieee80
+ ieee80211_tx_result
+ ieee80211_crypto_wep_encrypt(struct ieee80211_tx_data *tx)
+ {
++	int i;
++
+ 	ieee80211_tx_set_protected(tx);
+ 
+ 	if (wep_encrypt_skb(tx, tx->skb) < 0) {
+@@ -337,9 +338,8 @@ ieee80211_crypto_wep_encrypt(struct ieee
+ 	}
+ 
+ 	if (tx->extra_frag) {
+-		int i;
+ 		for (i = 0; i < tx->num_extra_frag; i++) {
+-			if (wep_encrypt_skb(tx, tx->extra_frag[i]) < 0) {
++			if (wep_encrypt_skb(tx, tx->extra_frag[i])) {
+ 				I802_DEBUG_INC(tx->local->
+ 					       tx_handlers_drop_wep);
+ 				return TX_DROP;
+--- everything.orig/net/mac80211/wep.h	2008-10-07 20:05:28.000000000 +0200
++++ everything/net/mac80211/wep.h	2008-10-07 20:06:41.000000000 +0200
+@@ -26,7 +26,7 @@ int ieee80211_wep_encrypt(struct ieee802
+ 			  struct ieee80211_key *key);
+ int ieee80211_wep_decrypt(struct ieee80211_local *local, struct sk_buff *skb,
+ 			  struct ieee80211_key *key);
+-u8 *ieee80211_wep_is_weak_iv(struct sk_buff *skb, struct ieee80211_key *key);
++bool ieee80211_wep_is_weak_iv(struct sk_buff *skb, struct ieee80211_key *key);
+ 
+ ieee80211_rx_result
+ ieee80211_crypto_wep_decrypt(struct ieee80211_rx_data *rx);
+--- everything.orig/net/mac80211/wpa.c	2008-10-07 20:05:49.000000000 +0200
++++ everything/net/mac80211/wpa.c	2008-10-07 20:06:41.000000000 +0200
+@@ -49,8 +49,7 @@ ieee80211_tx_h_michael_mic_add(struct ie
+ 	    !(tx->flags & IEEE80211_TX_FRAGMENTED) &&
+ 	    !(tx->key->conf.flags & IEEE80211_KEY_FLAG_GENERATE_MMIC) &&
+ 	    !wpa_test) {
+-		/* hwaccel - with no need for preallocated room for Michael MIC
+-		 */
++		/* hwaccel - with no need for preallocated room for MMIC */
+ 		return TX_CONTINUE;
+ 	}
+ 
+@@ -67,8 +66,6 @@ ieee80211_tx_h_michael_mic_add(struct ie
+ #else
+ 	authenticator = 1;
+ #endif
+-	/* At this point we know we're using ALG_TKIP. To get the MIC key
+-	 * we now will rely on the offset from the ieee80211_key_conf::key */
+ 	key_offset = authenticator ?
+ 		NL80211_TKIP_DATA_OFFSET_TX_MIC_KEY :
+ 		NL80211_TKIP_DATA_OFFSET_RX_MIC_KEY;
+@@ -92,9 +89,7 @@ ieee80211_rx_h_michael_mic_verify(struct
+ 	int authenticator = 1, wpa_test = 0;
+ 	DECLARE_MAC_BUF(mac);
+ 
+-	/*
+-	 * No way to verify the MIC if the hardware stripped it
+-	 */
++	/* No way to verify the MIC if the hardware stripped it */
+ 	if (rx->status->flag & RX_FLAG_MMIC_STRIPPED)
+ 		return RX_CONTINUE;
+ 
+@@ -116,8 +111,6 @@ ieee80211_rx_h_michael_mic_verify(struct
+ #else
+ 	authenticator = 1;
+ #endif
+-	/* At this point we know we're using ALG_TKIP. To get the MIC key
+-	 * we now will rely on the offset from the ieee80211_key_conf::key */
+ 	key_offset = authenticator ?
+ 		NL80211_TKIP_DATA_OFFSET_RX_MIC_KEY :
+ 		NL80211_TKIP_DATA_OFFSET_TX_MIC_KEY;
+@@ -202,6 +195,7 @@ ieee80211_tx_result
+ ieee80211_crypto_tkip_encrypt(struct ieee80211_tx_data *tx)
+ {
+ 	struct sk_buff *skb = tx->skb;
++	int i;
+ 
+ 	ieee80211_tx_set_protected(tx);
+ 
+@@ -209,9 +203,8 @@ ieee80211_crypto_tkip_encrypt(struct iee
+ 		return TX_DROP;
+ 
+ 	if (tx->extra_frag) {
+-		int i;
+ 		for (i = 0; i < tx->num_extra_frag; i++) {
+-			if (tkip_encrypt_skb(tx, tx->extra_frag[i]) < 0)
++			if (tkip_encrypt_skb(tx, tx->extra_frag[i]))
+ 				return TX_DROP;
+ 		}
+ 	}
+@@ -350,7 +343,7 @@ static inline void ccmp_pn2hdr(u8 *hdr, 
+ }
+ 
+ 
+-static inline int ccmp_hdr2pn(u8 *pn, u8 *hdr)
++static inline void ccmp_hdr2pn(u8 *pn, u8 *hdr)
+ {
+ 	pn[0] = hdr[7];
+ 	pn[1] = hdr[6];
+@@ -358,7 +351,6 @@ static inline int ccmp_hdr2pn(u8 *pn, u8
+ 	pn[3] = hdr[4];
+ 	pn[4] = hdr[1];
+ 	pn[5] = hdr[0];
+-	return (hdr[3] >> 6) & 0x03;
+ }
+ 
+ 
+@@ -373,7 +365,7 @@ static int ccmp_encrypt_skb(struct ieee8
+ 
+ 	if ((tx->key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE) &&
+ 	    !(tx->key->conf.flags & IEEE80211_KEY_FLAG_GENERATE_IV)) {
+-		/* hwaccel - with no need for preallocated room for CCMP "
++		/* hwaccel - with no need for preallocated room for CCMP
+ 		 * header or MIC fields */
+ 		info->control.hw_key = &tx->key->conf;
+ 		return 0;
+@@ -426,6 +418,7 @@ ieee80211_tx_result
+ ieee80211_crypto_ccmp_encrypt(struct ieee80211_tx_data *tx)
+ {
+ 	struct sk_buff *skb = tx->skb;
++	int i;
+ 
+ 	ieee80211_tx_set_protected(tx);
+ 
+@@ -433,9 +426,8 @@ ieee80211_crypto_ccmp_encrypt(struct iee
+ 		return TX_DROP;
+ 
+ 	if (tx->extra_frag) {
+-		int i;
+ 		for (i = 0; i < tx->num_extra_frag; i++) {
+-			if (ccmp_encrypt_skb(tx, tx->extra_frag[i]) < 0)
++			if (ccmp_encrypt_skb(tx, tx->extra_frag[i]))
+ 				return TX_DROP;
+ 		}
+ 	}
+@@ -468,7 +460,7 @@ ieee80211_crypto_ccmp_decrypt(struct iee
+ 	    (rx->status->flag & RX_FLAG_IV_STRIPPED))
+ 		return RX_CONTINUE;
+ 
+-	(void) ccmp_hdr2pn(pn, skb->data + hdrlen);
++	ccmp_hdr2pn(pn, skb->data + hdrlen);
+ 
+ 	if (memcmp(pn, key->u.ccmp.rx_pn[rx->queue], CCMP_PN_LEN) <= 0) {
+ 		key->u.ccmp.replays++;
+@@ -483,9 +475,8 @@ ieee80211_crypto_ccmp_decrypt(struct iee
+ 			    key->u.ccmp.tfm, key->u.ccmp.rx_crypto_buf,
+ 			    skb->data + hdrlen + CCMP_HDR_LEN, data_len,
+ 			    skb->data + skb->len - CCMP_MIC_LEN,
+-			    skb->data + hdrlen + CCMP_HDR_LEN)) {
++			    skb->data + hdrlen + CCMP_HDR_LEN))
+ 			return RX_DROP_UNUSABLE;
+-		}
+ 	}
+ 
+ 	memcpy(key->u.ccmp.rx_pn[rx->queue], pn, CCMP_PN_LEN);
+--- everything.orig/net/mac80211/debugfs_sta.c	2008-10-07 20:06:40.000000000 +0200
++++ everything/net/mac80211/debugfs_sta.c	2008-10-07 20:06:41.000000000 +0200
+@@ -137,7 +137,7 @@ static ssize_t sta_agg_status_read(struc
+ 	p += scnprintf(p, sizeof(buf)+buf-p, "\n DTKN:");
+ 	for (i = 0; i < STA_TID_NUM; i++)
+ 		p += scnprintf(p, sizeof(buf)+buf-p, "%5d",
+-			sta->ampdu_mlme.tid_state_rx[i]?
++			sta->ampdu_mlme.tid_state_rx[i] ?
+ 			sta->ampdu_mlme.tid_rx[i]->dialog_token : 0);
+ 
+ 	p += scnprintf(p, sizeof(buf)+buf-p, "\n TX  :");
+@@ -148,13 +148,13 @@ static ssize_t sta_agg_status_read(struc
+ 	p += scnprintf(p, sizeof(buf)+buf-p, "\n DTKN:");
+ 	for (i = 0; i < STA_TID_NUM; i++)
+ 		p += scnprintf(p, sizeof(buf)+buf-p, "%5d",
+-			sta->ampdu_mlme.tid_state_tx[i]?
++			sta->ampdu_mlme.tid_state_tx[i] ?
+ 			sta->ampdu_mlme.tid_tx[i]->dialog_token : 0);
+ 
+ 	p += scnprintf(p, sizeof(buf)+buf-p, "\n SSN :");
+ 	for (i = 0; i < STA_TID_NUM; i++)
+ 		p += scnprintf(p, sizeof(buf)+buf-p, "%5d",
+-			sta->ampdu_mlme.tid_state_tx[i]?
++			sta->ampdu_mlme.tid_state_tx[i] ?
+ 			sta->ampdu_mlme.tid_tx[i]->ssn : 0);
+ 
+ 	p += scnprintf(p, sizeof(buf)+buf-p, "\n");
+--- everything.orig/net/mac80211/main.c	2008-10-07 20:05:49.000000000 +0200
++++ everything/net/mac80211/main.c	2008-10-07 20:06:41.000000000 +0200
+@@ -1013,7 +1013,7 @@ static int __init ieee80211_init(void)
+ 
+ 	BUILD_BUG_ON(sizeof(struct ieee80211_tx_info) > sizeof(skb->cb));
+ 	BUILD_BUG_ON(offsetof(struct ieee80211_tx_info, driver_data) +
+-	             IEEE80211_TX_INFO_DRIVER_DATA_SIZE > sizeof(skb->cb));
++		     IEEE80211_TX_INFO_DRIVER_DATA_SIZE > sizeof(skb->cb));
+ 
+ 	ret = rc80211_minstrel_init();
+ 	if (ret)
+--- everything.orig/net/mac80211/mesh.c	2008-10-07 20:05:28.000000000 +0200
++++ everything/net/mac80211/mesh.c	2008-10-07 20:06:41.000000000 +0200
+@@ -473,7 +473,7 @@ static void ieee80211_mesh_rx_bcn_presp(
+ 					size_t len,
+ 					struct ieee80211_rx_status *rx_status)
+ {
+-	struct ieee80211_local *local= sdata->local;
++	struct ieee80211_local *local = sdata->local;
+ 	struct ieee802_11_elems elems;
+ 	struct ieee80211_channel *channel;
+ 	u64 supp_rates = 0;
+--- everything.orig/net/mac80211/rc80211_pid.h	2008-10-07 20:05:28.000000000 +0200
++++ everything/net/mac80211/rc80211_pid.h	2008-10-07 20:06:41.000000000 +0200
+@@ -49,7 +49,7 @@
+ 
+ /* Arithmetic right shift for positive and negative values for ISO C. */
+ #define RC_PID_DO_ARITH_RIGHT_SHIFT(x, y) \
+-	(x) < 0 ? -((-(x)) >> (y)) : (x) >> (y)
++	((x) < 0 ? -((-(x)) >> (y)) : (x) >> (y))
+ 
+ enum rc_pid_event_type {
+ 	RC_PID_EVENT_TYPE_TX_STATUS,
+--- everything.orig/net/mac80211/rx.c	2008-10-07 20:06:38.000000000 +0200
++++ everything/net/mac80211/rx.c	2008-10-07 20:06:41.000000000 +0200
+@@ -26,10 +26,11 @@
+ #include "tkip.h"
+ #include "wme.h"
+ 
+-u8 ieee80211_sta_manage_reorder_buf(struct ieee80211_hw *hw,
+-				struct tid_ampdu_rx *tid_agg_rx,
+-				struct sk_buff *skb, u16 mpdu_seq_num,
+-				int bar_req);
++static u8 ieee80211_sta_manage_reorder_buf(struct ieee80211_hw *hw,
++					   struct tid_ampdu_rx *tid_agg_rx,
++					   struct sk_buff *skb,
++					   u16 mpdu_seq_num,
++					   int bar_req);
+ /*
+  * monitor mode reception
+  *
+@@ -2000,17 +2001,17 @@ static void __ieee80211_rx_handle_packet
+ 
+ static inline int seq_less(u16 sq1, u16 sq2)
+ {
+-	return (((sq1 - sq2) & SEQ_MASK) > (SEQ_MODULO >> 1));
++	return ((sq1 - sq2) & SEQ_MASK) > (SEQ_MODULO >> 1);
+ }
+ 
+ static inline u16 seq_inc(u16 sq)
+ {
+-	return ((sq + 1) & SEQ_MASK);
++	return (sq + 1) & SEQ_MASK;
+ }
+ 
+ static inline u16 seq_sub(u16 sq1, u16 sq2)
+ {
+-	return ((sq1 - sq2) & SEQ_MASK);
++	return (sq1 - sq2) & SEQ_MASK;
+ }
+ 
+ 
+@@ -2018,10 +2019,11 @@ static inline u16 seq_sub(u16 sq1, u16 s
+  * As it function blongs to Rx path it must be called with
+  * the proper rcu_read_lock protection for its flow.
+  */
+-u8 ieee80211_sta_manage_reorder_buf(struct ieee80211_hw *hw,
+-				struct tid_ampdu_rx *tid_agg_rx,
+-				struct sk_buff *skb, u16 mpdu_seq_num,
+-				int bar_req)
++static u8 ieee80211_sta_manage_reorder_buf(struct ieee80211_hw *hw,
++					   struct tid_ampdu_rx *tid_agg_rx,
++					   struct sk_buff *skb,
++					   u16 mpdu_seq_num,
++					   int bar_req)
+ {
+ 	struct ieee80211_local *local = hw_to_local(hw);
+ 	struct ieee80211_rx_status status;
+--- everything.orig/net/mac80211/sta_info.c	2008-10-07 20:06:39.000000000 +0200
++++ everything/net/mac80211/sta_info.c	2008-10-07 20:06:41.000000000 +0200
+@@ -294,7 +294,7 @@ int sta_info_insert(struct sta_info *sta
+ 	}
+ 
+ 	if (WARN_ON(compare_ether_addr(sta->sta.addr, sdata->dev->dev_addr) == 0 ||
+-	            is_multicast_ether_addr(sta->sta.addr))) {
++		    is_multicast_ether_addr(sta->sta.addr))) {
+ 		err = -EINVAL;
+ 		goto out_free;
+ 	}
+@@ -830,7 +830,7 @@ void ieee80211_sta_expire(struct ieee802
+ }
+ 
+ struct ieee80211_sta *ieee80211_find_sta(struct ieee80211_hw *hw,
+-                                         const u8 *addr)
++					 const u8 *addr)
+ {
+ 	struct sta_info *sta = sta_info_get(hw_to_local(hw), addr);
+ 
diff --git a/package/mac80211/patches/411-mac80211-remove-wiphy-to-hw.patch b/package/mac80211/patches/411-mac80211-remove-wiphy-to-hw.patch
new file mode 100644
index 0000000000..c8a1a225b6
--- /dev/null
+++ b/package/mac80211/patches/411-mac80211-remove-wiphy-to-hw.patch
@@ -0,0 +1,38 @@
+Subject: mac80211: remove wiphy_to_hw
+
+This isn't used by anyone, if we ever need it we can add
+it back, until then it's useless.
+
+Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
+---
+ include/net/mac80211.h |    2 --
+ net/mac80211/cfg.c     |    7 -------
+ 2 files changed, 9 deletions(-)
+
+--- everything.orig/include/net/mac80211.h	2008-10-07 20:05:49.000000000 +0200
++++ everything/include/net/mac80211.h	2008-10-07 20:06:42.000000000 +0200
+@@ -867,8 +867,6 @@ struct ieee80211_hw {
+ 	u8 max_altrate_tries;
+ };
+ 
+-struct ieee80211_hw *wiphy_to_hw(struct wiphy *wiphy);
+-
+ /**
+  * SET_IEEE80211_DEV - set device for 802.11 hardware
+  *
+--- everything.orig/net/mac80211/cfg.c	2008-10-07 20:06:37.000000000 +0200
++++ everything/net/mac80211/cfg.c	2008-10-07 20:06:42.000000000 +0200
+@@ -17,13 +17,6 @@
+ #include "rate.h"
+ #include "mesh.h"
+ 
+-struct ieee80211_hw *wiphy_to_hw(struct wiphy *wiphy)
+-{
+-	struct ieee80211_local *local = wiphy_priv(wiphy);
+-	return &local->hw;
+-}
+-EXPORT_SYMBOL(wiphy_to_hw);
+-
+ static bool nl80211_type_check(enum nl80211_iftype type)
+ {
+ 	switch (type) {
diff --git a/package/mac80211/patches/412-mac80211-warn-ieee80211_hw_config-failure.patch b/package/mac80211/patches/412-mac80211-warn-ieee80211_hw_config-failure.patch
new file mode 100644
index 0000000000..f18569b936
--- /dev/null
+++ b/package/mac80211/patches/412-mac80211-warn-ieee80211_hw_config-failure.patch
@@ -0,0 +1,113 @@
+Subject: mac80211: clean up ieee80211_hw_config errors
+
+Warn when ieee80211_hw_config returns an error, it shouldn't
+happen; remove a number of printks that would happen in such
+a case and one printk that is user-triggerable.
+
+Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
+---
+ net/mac80211/cfg.c  |    3 +--
+ net/mac80211/main.c |    8 +++++++-
+ net/mac80211/scan.c |   16 +++-------------
+ net/mac80211/util.c |    5 +----
+ net/mac80211/wext.c |    6 +-----
+ 5 files changed, 13 insertions(+), 25 deletions(-)
+
+--- everything.orig/net/mac80211/cfg.c	2008-10-07 20:06:42.000000000 +0200
++++ everything/net/mac80211/cfg.c	2008-10-07 20:06:43.000000000 +0200
+@@ -396,8 +396,7 @@ static int ieee80211_config_beacon(struc
+ 	 */
+ 	if (params->interval) {
+ 		sdata->local->hw.conf.beacon_int = params->interval;
+-		if (ieee80211_hw_config(sdata->local))
+-			return -EINVAL;
++		ieee80211_hw_config(sdata->local);
+ 		/*
+ 		 * We updated some parameter so if below bails out
+ 		 * it's not an error.
+--- everything.orig/net/mac80211/main.c	2008-10-07 20:06:41.000000000 +0200
++++ everything/net/mac80211/main.c	2008-10-07 20:06:43.000000000 +0200
+@@ -222,8 +222,14 @@ int ieee80211_hw_config(struct ieee80211
+ 	       wiphy_name(local->hw.wiphy), chan->center_freq);
+ #endif
+ 
+-	if (local->open_count)
++	if (local->open_count) {
+ 		ret = local->ops->config(local_to_hw(local), &local->hw.conf);
++		/*
++		 * HW reconfiguration should never fail, the driver has told
++		 * us what it can support so it should live up to that promise.
++		 */
++		WARN_ON(ret);
++	}
+ 
+ 	return ret;
+ }
+--- everything.orig/net/mac80211/scan.c	2008-10-07 20:05:27.000000000 +0200
++++ everything/net/mac80211/scan.c	2008-10-07 20:06:43.000000000 +0200
+@@ -447,18 +447,12 @@ void ieee80211_scan_completed(struct iee
+ 
+ 	if (local->hw_scanning) {
+ 		local->hw_scanning = false;
+-		if (ieee80211_hw_config(local))
+-			printk(KERN_DEBUG "%s: failed to restore operational "
+-			       "channel after scan\n", wiphy_name(local->hw.wiphy));
+-
++		ieee80211_hw_config(local);
+ 		goto done;
+ 	}
+ 
+ 	local->sw_scanning = false;
+-	if (ieee80211_hw_config(local))
+-		printk(KERN_DEBUG "%s: failed to restore operational "
+-		       "channel after scan\n", wiphy_name(local->hw.wiphy));
+-
++	ieee80211_hw_config(local);
+ 
+ 	netif_tx_lock_bh(local->mdev);
+ 	netif_addr_lock(local->mdev);
+@@ -545,12 +539,8 @@ void ieee80211_scan_work(struct work_str
+ 
+ 		if (!skip) {
+ 			local->scan_channel = chan;
+-			if (ieee80211_hw_config(local)) {
+-				printk(KERN_DEBUG "%s: failed to set freq to "
+-				       "%d MHz for scan\n", wiphy_name(local->hw.wiphy),
+-				       chan->center_freq);
++			if (ieee80211_hw_config(local))
+ 				skip = 1;
+-			}
+ 		}
+ 
+ 		/* advance state machine to next channel/band */
+--- everything.orig/net/mac80211/util.c	2008-10-07 20:05:27.000000000 +0200
++++ everything/net/mac80211/util.c	2008-10-07 20:06:43.000000000 +0200
+@@ -638,11 +638,8 @@ int ieee80211_set_freq(struct ieee80211_
+ 
+ 	if (chan && !(chan->flags & IEEE80211_CHAN_DISABLED)) {
+ 		if (sdata->vif.type == NL80211_IFTYPE_ADHOC &&
+-		    chan->flags & IEEE80211_CHAN_NO_IBSS) {
+-			printk(KERN_DEBUG "%s: IBSS not allowed on frequency "
+-				"%d MHz\n", sdata->dev->name, chan->center_freq);
++		    chan->flags & IEEE80211_CHAN_NO_IBSS)
+ 			return ret;
+-		}
+ 		local->oper_channel = chan;
+ 
+ 		if (local->sw_scanning || local->hw_scanning)
+--- everything.orig/net/mac80211/wext.c	2008-10-07 20:05:27.000000000 +0200
++++ everything/net/mac80211/wext.c	2008-10-07 20:06:43.000000000 +0200
+@@ -689,12 +689,8 @@ static int ieee80211_ioctl_siwtxpower(st
+ 		ieee80211_led_radio(local, local->hw.conf.radio_enabled);
+ 	}
+ 
+-	if (need_reconfig) {
++	if (need_reconfig)
+ 		ieee80211_hw_config(local);
+-		/* The return value of hw_config is not of big interest here,
+-		 * as it doesn't say that it failed because of _this_ config
+-		 * change or something else. Ignore it. */
+-	}
+ 
+ 	return 0;
+ }
diff --git a/package/mac80211/patches/413-mac80211-remove-antgain-cfg.patch b/package/mac80211/patches/413-mac80211-remove-antgain-cfg.patch
new file mode 100644
index 0000000000..a7d8a9534a
--- /dev/null
+++ b/package/mac80211/patches/413-mac80211-remove-antgain-cfg.patch
@@ -0,0 +1,41 @@
+Subject: mac80211: remove max_antenna_gain config
+
+The antenna gain isn't exactly configurable, despite the belief of
+some unnamed individual who thinks that the EEPROM might influence
+it.
+
+Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
+---
+ include/net/mac80211.h |    2 --
+ net/mac80211/main.c    |    2 --
+ 2 files changed, 4 deletions(-)
+
+--- everything.orig/include/net/mac80211.h	2008-10-07 20:06:42.000000000 +0200
++++ everything/include/net/mac80211.h	2008-10-07 20:06:43.000000000 +0200
+@@ -470,7 +470,6 @@ enum ieee80211_conf_flags {
+  * @listen_interval: listen interval in units of beacon interval
+  * @flags: configuration flags defined above
+  * @power_level: requested transmit power (in dBm)
+- * @max_antenna_gain: maximum antenna gain (in dBi)
+  * @antenna_sel_tx: transmit antenna selection, 0: default/diversity,
+  *	1/2: antenna 0/1
+  * @antenna_sel_rx: receive antenna selection, like @antenna_sel_tx
+@@ -485,7 +484,6 @@ struct ieee80211_conf {
+ 	u16 listen_interval;
+ 	u32 flags;
+ 	int power_level;
+-	int max_antenna_gain;
+ 	u8 antenna_sel_tx;
+ 	u8 antenna_sel_rx;
+ 
+--- everything.orig/net/mac80211/main.c	2008-10-07 20:06:43.000000000 +0200
++++ everything/net/mac80211/main.c	2008-10-07 20:06:43.000000000 +0200
+@@ -215,8 +215,6 @@ int ieee80211_hw_config(struct ieee80211
+ 		local->hw.conf.power_level = min(chan->max_power,
+ 					       local->hw.conf.power_level);
+ 
+-	local->hw.conf.max_antenna_gain = chan->max_antenna_gain;
+-
+ #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
+ 	printk(KERN_DEBUG "%s: HW CONFIG: freq=%d\n",
+ 	       wiphy_name(local->hw.wiphy), chan->center_freq);
diff --git a/package/mac80211/patches/414-mac80211-slot-time.patch b/package/mac80211/patches/414-mac80211-slot-time.patch
new file mode 100644
index 0000000000..145e273e5b
--- /dev/null
+++ b/package/mac80211/patches/414-mac80211-slot-time.patch
@@ -0,0 +1,201 @@
+Subject: mac80211: fix short slot handling
+
+This patch makes mac80211 handle short slot requests from the AP
+properly. Also warn about uses of IEEE80211_CONF_SHORT_SLOT_TIME
+and optimise out the code since it cannot ever be hit anyway.
+
+Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
+---
+ include/net/mac80211.h |   28 ++++++++++--------
+ net/mac80211/main.c    |    9 +++--
+ net/mac80211/mlme.c    |   74 ++++++++++++++++++++++++++-----------------------
+ 3 files changed, 62 insertions(+), 49 deletions(-)
+
+--- everything.orig/net/mac80211/main.c	2008-10-07 20:06:43.000000000 +0200
++++ everything/net/mac80211/main.c	2008-10-08 10:56:29.000000000 +0200
+@@ -346,9 +346,12 @@ void ieee80211_bss_info_change_notify(st
+ 
+ u32 ieee80211_reset_erp_info(struct ieee80211_sub_if_data *sdata)
+ {
+-	sdata->bss_conf.use_cts_prot = 0;
+-	sdata->bss_conf.use_short_preamble = 0;
+-	return BSS_CHANGED_ERP_CTS_PROT | BSS_CHANGED_ERP_PREAMBLE;
++	sdata->bss_conf.use_cts_prot = false;
++	sdata->bss_conf.use_short_preamble = false;
++	sdata->bss_conf.use_short_slot = false;
++	return BSS_CHANGED_ERP_CTS_PROT |
++	       BSS_CHANGED_ERP_PREAMBLE |
++	       BSS_CHANGED_ERP_SLOT;
+ }
+ 
+ void ieee80211_tx_status_irqsafe(struct ieee80211_hw *hw,
+--- everything.orig/net/mac80211/mlme.c	2008-10-07 20:05:49.000000000 +0200
++++ everything/net/mac80211/mlme.c	2008-10-08 10:56:38.000000000 +0200
+@@ -568,9 +568,8 @@ static void ieee80211_sta_wmm_params(str
+ 	}
+ }
+ 
+-static u32 ieee80211_handle_protect_preamb(struct ieee80211_sub_if_data *sdata,
+-					   bool use_protection,
+-					   bool use_short_preamble)
++static u32 ieee80211_handle_bss_capability(struct ieee80211_sub_if_data *sdata,
++					   u16 capab, bool erp_valid, u8 erp)
+ {
+ 	struct ieee80211_bss_conf *bss_conf = &sdata->bss_conf;
+ #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
+@@ -578,6 +577,19 @@ static u32 ieee80211_handle_protect_prea
+ 	DECLARE_MAC_BUF(mac);
+ #endif
+ 	u32 changed = 0;
++	bool use_protection;
++	bool use_short_preamble;
++	bool use_short_slot;
++
++	if (erp_valid) {
++		use_protection = (erp & WLAN_ERP_USE_PROTECTION) != 0;
++		use_short_preamble = (erp & WLAN_ERP_BARKER_PREAMBLE) == 0;
++	} else {
++		use_protection = false;
++		use_short_preamble = !!(capab & WLAN_CAPABILITY_SHORT_PREAMBLE);
++	}
++
++	use_short_slot = !!(capab & WLAN_CAPABILITY_SHORT_SLOT_TIME);
+ 
+ 	if (use_protection != bss_conf->use_cts_prot) {
+ #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
+@@ -607,30 +619,18 @@ static u32 ieee80211_handle_protect_prea
+ 		changed |= BSS_CHANGED_ERP_PREAMBLE;
+ 	}
+ 
+-	return changed;
+-}
+-
+-static u32 ieee80211_handle_erp_ie(struct ieee80211_sub_if_data *sdata,
+-				   u8 erp_value)
+-{
+-	bool use_protection = (erp_value & WLAN_ERP_USE_PROTECTION) != 0;
+-	bool use_short_preamble = (erp_value & WLAN_ERP_BARKER_PREAMBLE) == 0;
+-
+-	return ieee80211_handle_protect_preamb(sdata,
+-			use_protection, use_short_preamble);
+-}
+-
+-static u32 ieee80211_handle_bss_capability(struct ieee80211_sub_if_data *sdata,
+-					   struct ieee80211_bss *bss)
+-{
+-	u32 changed = 0;
+-
+-	if (bss->has_erp_value)
+-		changed |= ieee80211_handle_erp_ie(sdata, bss->erp_value);
+-	else {
+-		u16 capab = bss->capability;
+-		changed |= ieee80211_handle_protect_preamb(sdata, false,
+-				(capab & WLAN_CAPABILITY_SHORT_PREAMBLE) != 0);
++	if (use_short_slot != bss_conf->use_short_slot) {
++#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
++		if (net_ratelimit()) {
++			printk(KERN_DEBUG "%s: switched to %s slot"
++			       " (BSSID=%s)\n",
++			       sdata->dev->name,
++			       use_short_slot ? "short" : "long",
++			       print_mac(mac, ifsta->bssid));
++		}
++#endif
++		bss_conf->use_short_slot = use_short_slot;
++		changed |= BSS_CHANGED_ERP_SLOT;
+ 	}
+ 
+ 	return changed;
+@@ -723,7 +723,8 @@ static void ieee80211_set_associated(str
+ 		sdata->bss_conf.timestamp = bss->timestamp;
+ 		sdata->bss_conf.dtim_period = bss->dtim_period;
+ 
+-		changed |= ieee80211_handle_bss_capability(sdata, bss);
++		changed |= ieee80211_handle_bss_capability(sdata,
++			bss->capability, bss->has_erp_value, bss->erp_value);
+ 
+ 		ieee80211_rx_bss_put(local, bss);
+ 	}
+@@ -1675,6 +1676,8 @@ static void ieee80211_rx_mgmt_beacon(str
+ 	struct ieee80211_local *local = sdata->local;
+ 	struct ieee80211_conf *conf = &local->hw.conf;
+ 	u32 changed = 0;
++	bool erp_valid;
++	u8 erp_value = 0;
+ 
+ 	/* Process beacon from the current BSS */
+ 	baselen = (u8 *) mgmt->u.beacon.variable - (u8 *) mgmt;
+@@ -1696,13 +1699,16 @@ static void ieee80211_rx_mgmt_beacon(str
+ 	ieee80211_sta_wmm_params(local, ifsta, elems.wmm_param,
+ 				 elems.wmm_param_len);
+ 
+-	if (elems.erp_info && elems.erp_info_len >= 1)
+-		changed |= ieee80211_handle_erp_ie(sdata, elems.erp_info[0]);
+-	else {
+-		u16 capab = le16_to_cpu(mgmt->u.beacon.capab_info);
+-		changed |= ieee80211_handle_protect_preamb(sdata, false,
+-				(capab & WLAN_CAPABILITY_SHORT_PREAMBLE) != 0);
++
++	if (elems.erp_info && elems.erp_info_len >= 1) {
++		erp_valid = true;
++		erp_value = elems.erp_info[0];
++	} else {
++		erp_valid = false;
+ 	}
++	changed |= ieee80211_handle_bss_capability(sdata,
++			le16_to_cpu(mgmt->u.beacon.capab_info),
++			erp_valid, erp_value);
+ 
+ 	if (elems.ht_cap_elem && elems.ht_info_elem &&
+ 	    elems.wmm_param && conf->flags & IEEE80211_CONF_SUPPORT_HT_MODE) {
+--- everything.orig/include/net/mac80211.h	2008-10-07 20:06:43.000000000 +0200
++++ everything/include/net/mac80211.h	2008-10-08 10:57:06.000000000 +0200
+@@ -180,8 +180,12 @@ enum ieee80211_bss_change {
+  * @assoc: association status
+  * @aid: association ID number, valid only when @assoc is true
+  * @use_cts_prot: use CTS protection
+- * @use_short_preamble: use 802.11b short preamble
+- * @use_short_slot: use short slot time (only relevant for ERP)
++ * @use_short_preamble: use 802.11b short preamble;
++ *	if the hardware cannot handle this it must set the
++ *	IEEE80211_HW_2GHZ_SHORT_PREAMBLE_INCAPABLE hardware flag
++ * @use_short_slot: use short slot time (only relevant for ERP);
++ *	if the hardware cannot handle this it must set the
++ *	IEEE80211_HW_2GHZ_SHORT_SLOT_INCAPABLE hardware flag
+  * @dtim_period: num of beacons before the next DTIM, for PSM
+  * @timestamp: beacon timestamp
+  * @beacon_int: beacon interval
+@@ -442,23 +446,23 @@ struct ieee80211_rx_status {
+  *
+  * Flags to define PHY configuration options
+  *
+- * @IEEE80211_CONF_SHORT_SLOT_TIME: use 802.11g short slot time
+  * @IEEE80211_CONF_RADIOTAP: add radiotap header at receive time (if supported)
+  * @IEEE80211_CONF_SUPPORT_HT_MODE: use 802.11n HT capabilities (if supported)
+  * @IEEE80211_CONF_PS: Enable 802.11 power save mode
+  */
+ enum ieee80211_conf_flags {
+-	/*
+-	 * TODO: IEEE80211_CONF_SHORT_SLOT_TIME will be removed once drivers
+-	 * have been converted to use bss_info_changed() for slot time
+-	 * configuration
+-	 */
+-	IEEE80211_CONF_SHORT_SLOT_TIME	= (1<<0),
+-	IEEE80211_CONF_RADIOTAP		= (1<<1),
+-	IEEE80211_CONF_SUPPORT_HT_MODE	= (1<<2),
+-	IEEE80211_CONF_PS		= (1<<3),
++	IEEE80211_CONF_RADIOTAP		= (1<<0),
++	IEEE80211_CONF_SUPPORT_HT_MODE	= (1<<1),
++	IEEE80211_CONF_PS		= (1<<2),
+ };
+ 
++/* XXX: remove all this once drivers stop trying to use it */
++static inline int __deprecated __IEEE80211_CONF_SHORT_SLOT_TIME(void)
++{
++	return 0;
++}
++#define IEEE80211_CONF_SHORT_SLOT_TIME (__IEEE80211_CONF_SHORT_SLOT_TIME())
++
+ /**
+  * struct ieee80211_conf - configuration of the device
+  *
diff --git a/package/mac80211/patches/415-mac80211-fix-exploit.patch b/package/mac80211/patches/415-mac80211-fix-exploit.patch
new file mode 100644
index 0000000000..114c94390b
--- /dev/null
+++ b/package/mac80211/patches/415-mac80211-fix-exploit.patch
@@ -0,0 +1,77 @@
+Subject: mac80211: fix HT information element parsing
+
+There's no checking that the HT IEs are of the right length
+which can be used by an attacker to cause an out-of-bounds
+access by sending a too short HT information/capability IE.
+Fix it by simply pretending those IEs didn't exist when too
+short.
+
+Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
+---
+ net/mac80211/ieee80211_i.h |    6 ++----
+ net/mac80211/mlme.c        |    3 ---
+ net/mac80211/util.c        |    8 ++++----
+ 3 files changed, 6 insertions(+), 11 deletions(-)
+
+--- everything.orig/net/mac80211/ieee80211_i.h	2008-10-07 20:05:26.000000000 +0200
++++ everything/net/mac80211/ieee80211_i.h	2008-10-07 20:06:45.000000000 +0200
+@@ -816,8 +816,8 @@ struct ieee802_11_elems {
+ 	u8 *ext_supp_rates;
+ 	u8 *wmm_info;
+ 	u8 *wmm_param;
+-	u8 *ht_cap_elem;
+-	u8 *ht_info_elem;
++	struct ieee80211_ht_cap *ht_cap_elem;
++	struct ieee80211_ht_addt_info *ht_info_elem;
+ 	u8 *mesh_config;
+ 	u8 *mesh_id;
+ 	u8 *peer_link;
+@@ -844,8 +844,6 @@ struct ieee802_11_elems {
+ 	u8 ext_supp_rates_len;
+ 	u8 wmm_info_len;
+ 	u8 wmm_param_len;
+-	u8 ht_cap_elem_len;
+-	u8 ht_info_elem_len;
+ 	u8 mesh_config_len;
+ 	u8 mesh_id_len;
+ 	u8 peer_link_len;
+--- everything.orig/net/mac80211/mlme.c	2008-10-07 20:06:44.000000000 +0200
++++ everything/net/mac80211/mlme.c	2008-10-07 20:06:45.000000000 +0200
+@@ -1349,10 +1349,8 @@ static void ieee80211_rx_mgmt_assoc_resp
+ 	    (ifsta->flags & IEEE80211_STA_WMM_ENABLED)) {
+ 		struct ieee80211_ht_bss_info bss_info;
+ 		ieee80211_ht_cap_ie_to_ht_info(
+-				(struct ieee80211_ht_cap *)
+ 				elems.ht_cap_elem, &sta->sta.ht_info);
+ 		ieee80211_ht_addt_info_ie_to_ht_bss_info(
+-				(struct ieee80211_ht_addt_info *)
+ 				elems.ht_info_elem, &bss_info);
+ 		ieee80211_handle_ht(local, 1, &sta->sta.ht_info, &bss_info);
+ 	}
+@@ -1715,7 +1713,6 @@ static void ieee80211_rx_mgmt_beacon(str
+ 		struct ieee80211_ht_bss_info bss_info;
+ 
+ 		ieee80211_ht_addt_info_ie_to_ht_bss_info(
+-				(struct ieee80211_ht_addt_info *)
+ 				elems.ht_info_elem, &bss_info);
+ 		changed |= ieee80211_handle_ht(local, 1, &conf->ht_conf,
+ 					       &bss_info);
+--- everything.orig/net/mac80211/util.c	2008-10-07 20:06:43.000000000 +0200
++++ everything/net/mac80211/util.c	2008-10-07 20:06:45.000000000 +0200
+@@ -529,12 +529,12 @@ void ieee802_11_parse_elems(u8 *start, s
+ 			elems->ext_supp_rates_len = elen;
+ 			break;
+ 		case WLAN_EID_HT_CAPABILITY:
+-			elems->ht_cap_elem = pos;
+-			elems->ht_cap_elem_len = elen;
++			if (elen >= sizeof(struct ieee80211_ht_cap))
++				elems->ht_cap_elem = (void *)pos;
+ 			break;
+ 		case WLAN_EID_HT_EXTRA_INFO:
+-			elems->ht_info_elem = pos;
+-			elems->ht_info_elem_len = elen;
++			if (elen >= sizeof(struct ieee80211_ht_addt_info))
++				elems->ht_info_elem = (void *)pos;
+ 			break;
+ 		case WLAN_EID_MESH_ID:
+ 			elems->mesh_id = pos;
diff --git a/package/mac80211/patches/416-mac80211-fix-netdev-notifier.patch b/package/mac80211/patches/416-mac80211-fix-netdev-notifier.patch
new file mode 100644
index 0000000000..aee45825ea
--- /dev/null
+++ b/package/mac80211/patches/416-mac80211-fix-netdev-notifier.patch
@@ -0,0 +1,27 @@
+Subject: mac80211: fix debugfs netdev rename
+
+If, for some reason, a netdev has no debugfs dir, we shouldn't
+try to rename that dir.
+
+Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
+Cc: Robin Holt <holt@sgi.com>
+---
+ net/mac80211/debugfs_netdev.c |    6 +++++-
+ 1 file changed, 5 insertions(+), 1 deletion(-)
+
+--- everything.orig/net/mac80211/debugfs_netdev.c	2008-10-08 10:08:23.000000000 +0200
++++ everything/net/mac80211/debugfs_netdev.c	2008-10-08 10:22:52.000000000 +0200
+@@ -481,8 +481,12 @@ static int netdev_notify(struct notifier
+ 
+ 	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
+ 
+-	sprintf(buf, "netdev:%s", dev->name);
+ 	dir = sdata->debugfsdir;
++
++	if (!dir)
++		return 0;
++
++	sprintf(buf, "netdev:%s", dev->name);
+ 	if (!debugfs_rename(dir->d_parent, dir, dir->d_parent, buf))
+ 		printk(KERN_ERR "mac80211: debugfs: failed to rename debugfs "
+ 		       "dir to %s\n", buf);
diff --git a/package/mac80211/patches/417-cfg80211-fix-rename.patch b/package/mac80211/patches/417-cfg80211-fix-rename.patch
new file mode 100644
index 0000000000..3cfab61325
--- /dev/null
+++ b/package/mac80211/patches/417-cfg80211-fix-rename.patch
@@ -0,0 +1,32 @@
+Subject: cfg80211: fix debugfs error handling
+
+If something goes wrong creating the debugfs dir or when
+debugfs is not compiled in, the current code might lead to
+trouble; make it more robust.
+
+Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
+---
+ net/wireless/core.c |    5 ++++-
+ 1 file changed, 4 insertions(+), 1 deletion(-)
+
+--- everything.orig/net/wireless/core.c	2008-10-08 10:13:49.000000000 +0200
++++ everything/net/wireless/core.c	2008-10-08 10:19:10.000000000 +0200
+@@ -185,7 +185,8 @@ int cfg80211_dev_rename(struct cfg80211_
+ 	if (result)
+ 		goto out_unlock;
+ 
+-	if (!debugfs_rename(rdev->wiphy.debugfsdir->d_parent,
++	if (rdev->wiphy.debugfsdir &&
++	    !debugfs_rename(rdev->wiphy.debugfsdir->d_parent,
+ 			    rdev->wiphy.debugfsdir,
+ 			    rdev->wiphy.debugfsdir->d_parent,
+ 			    newname))
+@@ -318,6 +319,8 @@ int wiphy_register(struct wiphy *wiphy)
+ 	drv->wiphy.debugfsdir =
+ 		debugfs_create_dir(wiphy_name(&drv->wiphy),
+ 				   ieee80211_debugfs_dir);
++	if (IS_ERR(drv->wiphy.debugfsdir))
++		drv->wiphy.debugfsdir = NULL;
+ 
+ 	res = 0;
+ out_unlock:
diff --git a/package/mac80211/patches/418-ieee80211-cleanup-ht-terminology.patch b/package/mac80211/patches/418-ieee80211-cleanup-ht-terminology.patch
new file mode 100644
index 0000000000..61ae15a885
--- /dev/null
+++ b/package/mac80211/patches/418-ieee80211-cleanup-ht-terminology.patch
@@ -0,0 +1,1427 @@
+Subject: 802.11: clean up/fix HT support
+
+This patch cleans up a number of things:
+ * the unusable definition of the HT capabilities/HT information
+   information elements
+ * variable names that are hard to understand
+ * mac80211: move ieee80211_handle_ht to ht.c and remove the unused
+             enable_ht parameter
+ * mac80211: fix bug with MCS rate 32 in ieee80211_handle_ht
+ * mac80211: fix bug with casting the result of ieee80211_bss_get_ie
+             to an information element _contents_ rather than the
+             whole element, add size checking (another out-of-bounds
+             access bug fixed!)
+ * mac80211: remove some unused return values in favour of BUG_ON
+             checking
+ * a few minor other things
+
+Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
+---
+ drivers/net/wireless/ath9k/main.c         |   57 +++++------
+ drivers/net/wireless/ath9k/rc.c           |   10 -
+ drivers/net/wireless/ath9k/rc.h           |    1 
+ drivers/net/wireless/ath9k/recv.c         |    2 
+ drivers/net/wireless/ath9k/xmit.c         |    2 
+ drivers/net/wireless/iwlwifi/iwl-agn-rs.c |   18 +--
+ drivers/net/wireless/iwlwifi/iwl-agn.c    |   20 +--
+ drivers/net/wireless/iwlwifi/iwl-core.c   |   71 +++++++-------
+ drivers/net/wireless/iwlwifi/iwl-core.h   |    2 
+ drivers/net/wireless/iwlwifi/iwl-dev.h    |    4 
+ drivers/net/wireless/iwlwifi/iwl-scan.c   |   12 +-
+ drivers/net/wireless/iwlwifi/iwl-sta.c    |    6 -
+ drivers/net/wireless/mac80211_hwsim.c     |   19 +--
+ include/linux/ieee80211.h                 |  133 ++++++++++++++++++--------
+ include/net/mac80211.h                    |   12 +-
+ include/net/wireless.h                    |   15 +-
+ net/mac80211/cfg.c                        |    7 -
+ net/mac80211/ht.c                         |  151 +++++++++++++++++++++++++-----
+ net/mac80211/ieee80211_i.h                |   16 +--
+ net/mac80211/main.c                       |   94 ------------------
+ net/mac80211/mlme.c                       |   45 ++++----
+ net/mac80211/util.c                       |    4 
+ net/mac80211/wext.c                       |    4 
+ 23 files changed, 386 insertions(+), 319 deletions(-)
+
+--- everything.orig/include/linux/ieee80211.h	2008-10-08 20:44:47.000000000 +0200
++++ everything/include/linux/ieee80211.h	2008-10-09 02:16:21.000000000 +0200
+@@ -685,28 +685,88 @@ struct ieee80211_bar {
+ #define IEEE80211_BAR_CTRL_ACK_POLICY_NORMAL     0x0000
+ #define IEEE80211_BAR_CTRL_CBMTID_COMPRESSED_BA  0x0004
+ 
++
++#define IEEE80211_HT_MCS_MASK_LEN		10
++
++/**
++ * struct ieee80211_mcs_info - MCS information
++ * @rx_mask: RX mask
++ * @rx_highest: highest supported RX rate
++ * @tx_params: TX parameters
++ */
++struct ieee80211_mcs_info {
++	u8 rx_mask[IEEE80211_HT_MCS_MASK_LEN];
++	__le16 rx_highest;
++	u8 tx_params;
++	u8 reserved[3];
++} __attribute__((packed));
++
++/* 802.11n HT capability MSC set */
++#define IEEE80211_HT_MCS_RX_HIGHEST_MASK	0x3ff
++#define IEEE80211_HT_MCS_TX_DEFINED		0x01
++#define IEEE80211_HT_MCS_TX_RX_DIFF		0x02
++/* value 0 == 1 stream etc */
++#define IEEE80211_HT_MCS_TX_MAX_STREAMS_MASK	0x0C
++#define IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT	2
++#define		IEEE80211_HT_MCS_TX_MAX_STREAMS	4
++#define IEEE80211_HT_MCS_TX_UNEQUAL_MODULATION	0x10
++
++/*
++ * 802.11n D5.0 20.3.5 / 20.6 says:
++ * - indices 0 to 7 and 32 are single spatial stream
++ * - 8 to 31 are multiple spatial streams using equal modulation
++ *   [8..15 for two streams, 16..23 for three and 24..31 for four]
++ * - remainder are multiple spatial streams using unequal modulation
++ */
++#define IEEE80211_HT_MCS_UNEQUAL_MODULATION_START 33
++#define IEEE80211_HT_MCS_UNEQUAL_MODULATION_START_BYTE \
++	(IEEE80211_HT_MCS_UNEQUAL_MODULATION_START / 8)
++
+ /**
+  * struct ieee80211_ht_cap - HT capabilities
+  *
+- * This structure refers to "HT capabilities element" as
+- * described in 802.11n draft section 7.3.2.52
++ * This structure is the "HT capabilities element" as
++ * described in 802.11n D5.0 7.3.2.57
+  */
+ struct ieee80211_ht_cap {
+ 	__le16 cap_info;
+ 	u8 ampdu_params_info;
+-	u8 supp_mcs_set[16];
++
++	/* 16 bytes MCS information */
++	struct ieee80211_mcs_info mcs;
++
+ 	__le16 extended_ht_cap_info;
+ 	__le32 tx_BF_cap_info;
+ 	u8 antenna_selection_info;
+ } __attribute__ ((packed));
+ 
++/* 802.11n HT capabilities masks (for cap_info) */
++#define IEEE80211_HT_CAP_LDPC_CODING		0x0001
++#define IEEE80211_HT_CAP_SUP_WIDTH_20_40	0x0002
++#define IEEE80211_HT_CAP_SM_PS			0x000C
++#define IEEE80211_HT_CAP_GRN_FLD		0x0010
++#define IEEE80211_HT_CAP_SGI_20			0x0020
++#define IEEE80211_HT_CAP_SGI_40			0x0040
++#define IEEE80211_HT_CAP_TX_STBC		0x0080
++#define IEEE80211_HT_CAP_RX_STBC		0x0300
++#define IEEE80211_HT_CAP_DELAY_BA		0x0400
++#define IEEE80211_HT_CAP_MAX_AMSDU		0x0800
++#define IEEE80211_HT_CAP_DSSSCCK40		0x1000
++#define IEEE80211_HT_CAP_PSMP_SUPPORT		0x2000
++#define IEEE80211_HT_CAP_40MHZ_INTOLERANT	0x4000
++#define IEEE80211_HT_CAP_LSIG_TXOP_PROT		0x8000
++
++/* 802.11n HT capability AMPDU settings (for ampdu_params_info) */
++#define IEEE80211_HT_AMPDU_PARM_FACTOR		0x03
++#define IEEE80211_HT_AMPDU_PARM_DENSITY		0x1C
++
+ /**
+- * struct ieee80211_ht_cap - HT additional information
++ * struct ieee80211_ht_info - HT information
+  *
+- * This structure refers to "HT information element" as
+- * described in 802.11n draft section 7.3.2.53
++ * This structure is the "HT information element" as
++ * described in 802.11n D5.0 7.3.2.58
+  */
+-struct ieee80211_ht_addt_info {
++struct ieee80211_ht_info {
+ 	u8 control_chan;
+ 	u8 ht_param;
+ 	__le16 operation_mode;
+@@ -714,36 +774,33 @@ struct ieee80211_ht_addt_info {
+ 	u8 basic_set[16];
+ } __attribute__ ((packed));
+ 
+-/* 802.11n HT capabilities masks */
+-#define IEEE80211_HT_CAP_SUP_WIDTH		0x0002
+-#define IEEE80211_HT_CAP_SM_PS			0x000C
+-#define IEEE80211_HT_CAP_GRN_FLD		0x0010
+-#define IEEE80211_HT_CAP_SGI_20			0x0020
+-#define IEEE80211_HT_CAP_SGI_40			0x0040
+-#define IEEE80211_HT_CAP_DELAY_BA		0x0400
+-#define IEEE80211_HT_CAP_MAX_AMSDU		0x0800
+-#define IEEE80211_HT_CAP_DSSSCCK40		0x1000
+-/* 802.11n HT capability AMPDU settings */
+-#define IEEE80211_HT_CAP_AMPDU_FACTOR		0x03
+-#define IEEE80211_HT_CAP_AMPDU_DENSITY		0x1C
+-/* 802.11n HT capability MSC set */
+-#define IEEE80211_SUPP_MCS_SET_UEQM		4
+-#define IEEE80211_HT_CAP_MAX_STREAMS		4
+-#define IEEE80211_SUPP_MCS_SET_LEN		10
+-/* maximum streams the spec allows */
+-#define IEEE80211_HT_CAP_MCS_TX_DEFINED		0x01
+-#define IEEE80211_HT_CAP_MCS_TX_RX_DIFF		0x02
+-#define IEEE80211_HT_CAP_MCS_TX_STREAMS		0x0C
+-#define IEEE80211_HT_CAP_MCS_TX_UEQM		0x10
+-/* 802.11n HT IE masks */
+-#define IEEE80211_HT_IE_CHA_SEC_OFFSET		0x03
+-#define IEEE80211_HT_IE_CHA_SEC_NONE	 	0x00
+-#define IEEE80211_HT_IE_CHA_SEC_ABOVE 		0x01
+-#define IEEE80211_HT_IE_CHA_SEC_BELOW 		0x03
+-#define IEEE80211_HT_IE_CHA_WIDTH		0x04
+-#define IEEE80211_HT_IE_HT_PROTECTION		0x0003
+-#define IEEE80211_HT_IE_NON_GF_STA_PRSNT	0x0004
+-#define IEEE80211_HT_IE_NON_HT_STA_PRSNT	0x0010
++/* for ht_param */
++#define IEEE80211_HT_PARAM_CHA_SEC_OFFSET		0x03
++#define		IEEE80211_HT_PARAM_CHA_SEC_NONE		0x00
++#define		IEEE80211_HT_PARAM_CHA_SEC_ABOVE	0x01
++#define		IEEE80211_HT_PARAM_CHA_SEC_BELOW	0x03
++#define IEEE80211_HT_PARAM_CHAN_WIDTH_ANY		0x04
++#define IEEE80211_HT_PARAM_RIFS_MODE			0x08
++#define IEEE80211_HT_PARAM_SPSMP_SUPPORT		0x10
++#define IEEE80211_HT_PARAM_SERV_INTERVAL_GRAN		0xE0
++
++/* for operation_mode */
++#define IEEE80211_HT_OP_MODE_PROTECTION			0x0003
++#define		IEEE80211_HT_OP_MODE_PROTECTION_NONE		0
++#define		IEEE80211_HT_OP_MODE_PROTECTION_NONMEMBER	1
++#define		IEEE80211_HT_OP_MODE_PROTECTION_20MHZ		2
++#define		IEEE80211_HT_OP_MODE_PROTECTION_NONHT_MIXED	3
++#define IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT		0x0004
++#define IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT		0x0010
++
++/* for stbc_param */
++#define IEEE80211_HT_STBC_PARAM_DUAL_BEACON		0x0040
++#define IEEE80211_HT_STBC_PARAM_DUAL_CTS_PROT		0x0080
++#define IEEE80211_HT_STBC_PARAM_STBC_BEACON		0x0100
++#define IEEE80211_HT_STBC_PARAM_LSIG_TXOP_FULLPROT	0x0200
++#define IEEE80211_HT_STBC_PARAM_PCO_ACTIVE		0x0400
++#define IEEE80211_HT_STBC_PARAM_PCO_PHASE		0x0800
++
+ 
+ /* block-ack parameters */
+ #define IEEE80211_ADDBA_PARAM_POLICY_MASK 0x0002
+@@ -949,7 +1006,7 @@ enum ieee80211_eid {
+ 	WLAN_EID_EXT_SUPP_RATES = 50,
+ 	/* 802.11n */
+ 	WLAN_EID_HT_CAPABILITY = 45,
+-	WLAN_EID_HT_EXTRA_INFO = 61,
++	WLAN_EID_HT_INFORMATION = 61,
+ 	/* 802.11i */
+ 	WLAN_EID_RSN = 48,
+ 	WLAN_EID_WPA = 221,
+--- everything.orig/include/net/wireless.h	2008-10-08 20:44:46.000000000 +0200
++++ everything/include/net/wireless.h	2008-10-09 02:16:20.000000000 +0200
+@@ -10,6 +10,7 @@
+ #include <linux/netdevice.h>
+ #include <linux/debugfs.h>
+ #include <linux/list.h>
++#include <linux/ieee80211.h>
+ #include <net/cfg80211.h>
+ 
+ /**
+@@ -133,23 +134,23 @@ struct ieee80211_rate {
+ };
+ 
+ /**
+- * struct ieee80211_ht_info - describing STA's HT capabilities
++ * struct ieee80211_sta_ht_cap - STA's HT capabilities
+  *
+  * This structure describes most essential parameters needed
+  * to describe 802.11n HT capabilities for an STA.
+  *
+- * @ht_supported: is HT supported by STA, 0: no, 1: yes
++ * @ht_supported: is HT supported by the STA
+  * @cap: HT capabilities map as described in 802.11n spec
+  * @ampdu_factor: Maximum A-MPDU length factor
+  * @ampdu_density: Minimum A-MPDU spacing
+- * @supp_mcs_set: Supported MCS set as described in 802.11n spec
++ * @mcs: Supported MCS rates
+  */
+-struct ieee80211_ht_info {
++struct ieee80211_sta_ht_cap {
+ 	u16 cap; /* use IEEE80211_HT_CAP_ */
+-	u8 ht_supported;
++	bool ht_supported;
+ 	u8 ampdu_factor;
+ 	u8 ampdu_density;
+-	u8 supp_mcs_set[16];
++	struct ieee80211_mcs_info mcs;
+ };
+ 
+ /**
+@@ -173,7 +174,7 @@ struct ieee80211_supported_band {
+ 	enum ieee80211_band band;
+ 	int n_channels;
+ 	int n_bitrates;
+-	struct ieee80211_ht_info ht_info;
++	struct ieee80211_sta_ht_cap ht_cap;
+ };
+ 
+ /**
+--- everything.orig/net/mac80211/main.c	2008-10-08 20:45:06.000000000 +0200
++++ everything/net/mac80211/main.c	2008-10-09 02:16:29.000000000 +0200
+@@ -232,100 +232,6 @@ int ieee80211_hw_config(struct ieee80211
+ 	return ret;
+ }
+ 
+-/**
+- * ieee80211_handle_ht should be used only after legacy configuration
+- * has been determined namely band, as ht configuration depends upon
+- * the hardware's HT abilities for a _specific_ band.
+- */
+-u32 ieee80211_handle_ht(struct ieee80211_local *local, int enable_ht,
+-			   struct ieee80211_ht_info *req_ht_cap,
+-			   struct ieee80211_ht_bss_info *req_bss_cap)
+-{
+-	struct ieee80211_conf *conf = &local->hw.conf;
+-	struct ieee80211_supported_band *sband;
+-	struct ieee80211_ht_info ht_conf;
+-	struct ieee80211_ht_bss_info ht_bss_conf;
+-	u32 changed = 0;
+-	int i;
+-	u8 max_tx_streams = IEEE80211_HT_CAP_MAX_STREAMS;
+-	u8 tx_mcs_set_cap;
+-
+-	sband = local->hw.wiphy->bands[conf->channel->band];
+-
+-	memset(&ht_conf, 0, sizeof(struct ieee80211_ht_info));
+-	memset(&ht_bss_conf, 0, sizeof(struct ieee80211_ht_bss_info));
+-
+-	/* HT is not supported */
+-	if (!sband->ht_info.ht_supported) {
+-		conf->flags &= ~IEEE80211_CONF_SUPPORT_HT_MODE;
+-		goto out;
+-	}
+-
+-	/* disable HT */
+-	if (!enable_ht) {
+-		if (conf->flags & IEEE80211_CONF_SUPPORT_HT_MODE)
+-			changed |= BSS_CHANGED_HT;
+-		conf->flags &= ~IEEE80211_CONF_SUPPORT_HT_MODE;
+-		conf->ht_conf.ht_supported = 0;
+-		goto out;
+-	}
+-
+-
+-	if (!(conf->flags & IEEE80211_CONF_SUPPORT_HT_MODE))
+-		changed |= BSS_CHANGED_HT;
+-
+-	conf->flags |= IEEE80211_CONF_SUPPORT_HT_MODE;
+-	ht_conf.ht_supported = 1;
+-
+-	ht_conf.cap = req_ht_cap->cap & sband->ht_info.cap;
+-	ht_conf.cap &= ~(IEEE80211_HT_CAP_SM_PS);
+-	ht_conf.cap |= sband->ht_info.cap & IEEE80211_HT_CAP_SM_PS;
+-	ht_bss_conf.primary_channel = req_bss_cap->primary_channel;
+-	ht_bss_conf.bss_cap = req_bss_cap->bss_cap;
+-	ht_bss_conf.bss_op_mode = req_bss_cap->bss_op_mode;
+-
+-	ht_conf.ampdu_factor = req_ht_cap->ampdu_factor;
+-	ht_conf.ampdu_density = req_ht_cap->ampdu_density;
+-
+-	/* Bits 96-100 */
+-	tx_mcs_set_cap = sband->ht_info.supp_mcs_set[12];
+-
+-	/* configure suppoerted Tx MCS according to requested MCS
+-	 * (based in most cases on Rx capabilities of peer) and self
+-	 * Tx MCS capabilities (as defined by low level driver HW
+-	 * Tx capabilities) */
+-	if (!(tx_mcs_set_cap & IEEE80211_HT_CAP_MCS_TX_DEFINED))
+-		goto check_changed;
+-
+-	/* Counting from 0 therfore + 1 */
+-	if (tx_mcs_set_cap & IEEE80211_HT_CAP_MCS_TX_RX_DIFF)
+-		max_tx_streams = ((tx_mcs_set_cap &
+-				IEEE80211_HT_CAP_MCS_TX_STREAMS) >> 2) + 1;
+-
+-	for (i = 0; i < max_tx_streams; i++)
+-		ht_conf.supp_mcs_set[i] =
+-			sband->ht_info.supp_mcs_set[i] &
+-					req_ht_cap->supp_mcs_set[i];
+-
+-	if (tx_mcs_set_cap & IEEE80211_HT_CAP_MCS_TX_UEQM)
+-		for (i = IEEE80211_SUPP_MCS_SET_UEQM;
+-		     i < IEEE80211_SUPP_MCS_SET_LEN; i++)
+-			ht_conf.supp_mcs_set[i] =
+-				sband->ht_info.supp_mcs_set[i] &
+-					req_ht_cap->supp_mcs_set[i];
+-
+-check_changed:
+-	/* if bss configuration changed store the new one */
+-	if (memcmp(&conf->ht_conf, &ht_conf, sizeof(ht_conf)) ||
+-	    memcmp(&conf->ht_bss_conf, &ht_bss_conf, sizeof(ht_bss_conf))) {
+-		changed |= BSS_CHANGED_HT;
+-		memcpy(&conf->ht_conf, &ht_conf, sizeof(ht_conf));
+-		memcpy(&conf->ht_bss_conf, &ht_bss_conf, sizeof(ht_bss_conf));
+-	}
+-out:
+-	return changed;
+-}
+-
+ void ieee80211_bss_info_change_notify(struct ieee80211_sub_if_data *sdata,
+ 				      u32 changed)
+ {
+--- everything.orig/include/net/mac80211.h	2008-10-08 20:45:06.000000000 +0200
++++ everything/include/net/mac80211.h	2008-10-09 02:16:30.000000000 +0200
+@@ -191,7 +191,7 @@ enum ieee80211_bss_change {
+  * @beacon_int: beacon interval
+  * @assoc_capability: capabilities taken from assoc resp
+  * @assoc_ht: association in HT mode
+- * @ht_conf: ht capabilities
++ * @ht_cap: ht capabilities
+  * @ht_bss_conf: ht extended capabilities
+  * @basic_rates: bitmap of basic rates, each bit stands for an
+  *	index into the rate table configured by the driver in
+@@ -212,7 +212,7 @@ struct ieee80211_bss_conf {
+ 	u64 basic_rates;
+ 	/* ht related data */
+ 	bool assoc_ht;
+-	struct ieee80211_ht_info *ht_conf;
++	struct ieee80211_sta_ht_cap *ht_cap;
+ 	struct ieee80211_ht_bss_info *ht_bss_conf;
+ };
+ 
+@@ -477,7 +477,7 @@ static inline int __deprecated __IEEE802
+  * @antenna_sel_tx: transmit antenna selection, 0: default/diversity,
+  *	1/2: antenna 0/1
+  * @antenna_sel_rx: receive antenna selection, like @antenna_sel_tx
+- * @ht_conf: describes current self configuration of 802.11n HT capabilies
++ * @ht_cap: describes current self configuration of 802.11n HT capabilities
+  * @ht_bss_conf: describes current BSS configuration of 802.11n HT parameters
+  * @channel: the channel to tune to
+  */
+@@ -493,7 +493,7 @@ struct ieee80211_conf {
+ 
+ 	struct ieee80211_channel *channel;
+ 
+-	struct ieee80211_ht_info ht_conf;
++	struct ieee80211_sta_ht_cap ht_cap;
+ 	struct ieee80211_ht_bss_info ht_bss_conf;
+ };
+ 
+@@ -686,7 +686,7 @@ enum set_key_cmd {
+  * @addr: MAC address
+  * @aid: AID we assigned to the station if we're an AP
+  * @supp_rates: Bitmap of supported rates (per band)
+- * @ht_info: HT capabilities of this STA
++ * @ht_cap: HT capabilities of this STA
+  * @drv_priv: data area for driver use, will always be aligned to
+  *	sizeof(void *), size is determined in hw information.
+  */
+@@ -694,7 +694,7 @@ struct ieee80211_sta {
+ 	u64 supp_rates[IEEE80211_NUM_BANDS];
+ 	u8 addr[ETH_ALEN];
+ 	u16 aid;
+-	struct ieee80211_ht_info ht_info;
++	struct ieee80211_sta_ht_cap ht_cap;
+ 
+ 	/* must be last */
+ 	u8 drv_priv[0] __attribute__((__aligned__(sizeof(void *))));
+--- everything.orig/net/mac80211/ieee80211_i.h	2008-10-08 20:45:06.000000000 +0200
++++ everything/net/mac80211/ieee80211_i.h	2008-10-09 02:16:30.000000000 +0200
+@@ -817,7 +817,7 @@ struct ieee802_11_elems {
+ 	u8 *wmm_info;
+ 	u8 *wmm_param;
+ 	struct ieee80211_ht_cap *ht_cap_elem;
+-	struct ieee80211_ht_addt_info *ht_info_elem;
++	struct ieee80211_ht_info *ht_info_elem;
+ 	u8 *mesh_config;
+ 	u8 *mesh_id;
+ 	u8 *peer_link;
+@@ -885,9 +885,6 @@ static inline int ieee80211_bssid_match(
+ int ieee80211_hw_config(struct ieee80211_local *local);
+ int ieee80211_if_config(struct ieee80211_sub_if_data *sdata, u32 changed);
+ void ieee80211_tx_set_protected(struct ieee80211_tx_data *tx);
+-u32 ieee80211_handle_ht(struct ieee80211_local *local, int enable_ht,
+-			struct ieee80211_ht_info *req_ht_cap,
+-			struct ieee80211_ht_bss_info *req_bss_cap);
+ void ieee80211_bss_info_change_notify(struct ieee80211_sub_if_data *sdata,
+ 				      u32 changed);
+ void ieee80211_configure_filter(struct ieee80211_local *local);
+@@ -968,11 +965,14 @@ int ieee80211_monitor_start_xmit(struct 
+ int ieee80211_subif_start_xmit(struct sk_buff *skb, struct net_device *dev);
+ 
+ /* HT */
+-int ieee80211_ht_cap_ie_to_ht_info(struct ieee80211_ht_cap *ht_cap_ie,
+-				   struct ieee80211_ht_info *ht_info);
+-int ieee80211_ht_addt_info_ie_to_ht_bss_info(
+-			struct ieee80211_ht_addt_info *ht_add_info_ie,
++void ieee80211_ht_cap_ie_to_sta_ht_cap(struct ieee80211_ht_cap *ht_cap_ie,
++				       struct ieee80211_sta_ht_cap *ht_cap);
++void ieee80211_ht_info_ie_to_ht_bss_info(
++			struct ieee80211_ht_info *ht_add_info_ie,
+ 			struct ieee80211_ht_bss_info *bss_info);
++u32 ieee80211_handle_ht(struct ieee80211_local *local,
++			struct ieee80211_sta_ht_cap *req_ht_cap,
++			struct ieee80211_ht_bss_info *req_bss_cap);
+ void ieee80211_send_bar(struct ieee80211_sub_if_data *sdata, u8 *ra, u16 tid, u16 ssn);
+ 
+ void ieee80211_sta_stop_rx_ba_session(struct ieee80211_sub_if_data *sdata, u8 *da,
+--- everything.orig/net/mac80211/wext.c	2008-10-08 20:45:06.000000000 +0200
++++ everything/net/mac80211/wext.c	2008-10-09 02:16:28.000000000 +0200
+@@ -147,7 +147,7 @@ static int ieee80211_ioctl_giwname(struc
+ 	sband = local->hw.wiphy->bands[IEEE80211_BAND_5GHZ];
+ 	if (sband) {
+ 		is_a = 1;
+-		is_ht |= sband->ht_info.ht_supported;
++		is_ht |= sband->ht_cap.ht_supported;
+ 	}
+ 
+ 	sband = local->hw.wiphy->bands[IEEE80211_BAND_2GHZ];
+@@ -160,7 +160,7 @@ static int ieee80211_ioctl_giwname(struc
+ 			if (sband->bitrates[i].bitrate == 60)
+ 				is_g = 1;
+ 		}
+-		is_ht |= sband->ht_info.ht_supported;
++		is_ht |= sband->ht_cap.ht_supported;
+ 	}
+ 
+ 	strcpy(name, "IEEE 802.11");
+--- everything.orig/net/mac80211/ht.c	2008-10-08 20:44:47.000000000 +0200
++++ everything/net/mac80211/ht.c	2008-10-09 02:16:26.000000000 +0200
+@@ -20,37 +20,33 @@
+ #include "sta_info.h"
+ #include "wme.h"
+ 
+-int ieee80211_ht_cap_ie_to_ht_info(struct ieee80211_ht_cap *ht_cap_ie,
+-				   struct ieee80211_ht_info *ht_info)
++void ieee80211_ht_cap_ie_to_sta_ht_cap(struct ieee80211_ht_cap *ht_cap_ie,
++				       struct ieee80211_sta_ht_cap *ht_cap)
+ {
+ 
+-	if (ht_info == NULL)
+-		return -EINVAL;
++	BUG_ON(!ht_cap);
+ 
+-	memset(ht_info, 0, sizeof(*ht_info));
++	memset(ht_cap, 0, sizeof(*ht_cap));
+ 
+ 	if (ht_cap_ie) {
+ 		u8 ampdu_info = ht_cap_ie->ampdu_params_info;
+ 
+-		ht_info->ht_supported = 1;
+-		ht_info->cap = le16_to_cpu(ht_cap_ie->cap_info);
+-		ht_info->ampdu_factor =
+-			ampdu_info & IEEE80211_HT_CAP_AMPDU_FACTOR;
+-		ht_info->ampdu_density =
+-			(ampdu_info & IEEE80211_HT_CAP_AMPDU_DENSITY) >> 2;
+-		memcpy(ht_info->supp_mcs_set, ht_cap_ie->supp_mcs_set, 16);
++		ht_cap->ht_supported = true;
++		ht_cap->cap = le16_to_cpu(ht_cap_ie->cap_info);
++		ht_cap->ampdu_factor =
++			ampdu_info & IEEE80211_HT_AMPDU_PARM_FACTOR;
++		ht_cap->ampdu_density =
++			(ampdu_info & IEEE80211_HT_AMPDU_PARM_DENSITY) >> 2;
++		memcpy(&ht_cap->mcs, &ht_cap_ie->mcs, sizeof(ht_cap->mcs));
+ 	} else
+-		ht_info->ht_supported = 0;
+-
+-	return 0;
++		ht_cap->ht_supported = false;
+ }
+ 
+-int ieee80211_ht_addt_info_ie_to_ht_bss_info(
+-			struct ieee80211_ht_addt_info *ht_add_info_ie,
++void ieee80211_ht_info_ie_to_ht_bss_info(
++			struct ieee80211_ht_info *ht_add_info_ie,
+ 			struct ieee80211_ht_bss_info *bss_info)
+ {
+-	if (bss_info == NULL)
+-		return -EINVAL;
++	BUG_ON(!bss_info);
+ 
+ 	memset(bss_info, 0, sizeof(*bss_info));
+ 
+@@ -62,8 +58,119 @@ int ieee80211_ht_addt_info_ie_to_ht_bss_
+ 		bss_info->bss_cap = ht_add_info_ie->ht_param;
+ 		bss_info->bss_op_mode = (u8)(op_mode & 0xff);
+ 	}
++}
++
++/*
++ * ieee80211_handle_ht should be called only after the operating band
++ * has been determined as ht configuration depends on the hw's
++ * HT abilities for a specific band.
++ */
++u32 ieee80211_handle_ht(struct ieee80211_local *local,
++			struct ieee80211_sta_ht_cap *req_ht_cap,
++			struct ieee80211_ht_bss_info *req_bss_cap)
++{
++	struct ieee80211_conf *conf = &local->hw.conf;
++	struct ieee80211_supported_band *sband;
++	struct ieee80211_sta_ht_cap ht_cap;
++	struct ieee80211_ht_bss_info ht_bss_conf;
++	u32 changed = 0;
++	int i;
++	u8 max_tx_streams;
++	u8 tx_mcs_set_cap;
++	bool enable_ht = true;
++
++	sband = local->hw.wiphy->bands[conf->channel->band];
++
++	memset(&ht_cap, 0, sizeof(ht_cap));
++	memset(&ht_bss_conf, 0, sizeof(struct ieee80211_ht_bss_info));
++
++	/* HT is not supported */
++	if (!sband->ht_cap.ht_supported)
++		enable_ht = false;
++
++	/* disable HT */
++	if (!enable_ht) {
++		if (conf->flags & IEEE80211_CONF_SUPPORT_HT_MODE)
++			changed |= BSS_CHANGED_HT;
++		conf->flags &= ~IEEE80211_CONF_SUPPORT_HT_MODE;
++		conf->ht_cap.ht_supported = false;
++		return changed;
++	}
++
++
++	if (!(conf->flags & IEEE80211_CONF_SUPPORT_HT_MODE))
++		changed |= BSS_CHANGED_HT;
++
++	conf->flags |= IEEE80211_CONF_SUPPORT_HT_MODE;
++	ht_cap.ht_supported = true;
++
++	ht_cap.cap = req_ht_cap->cap & sband->ht_cap.cap;
++	ht_cap.cap &= ~IEEE80211_HT_CAP_SM_PS;
++	ht_cap.cap |= sband->ht_cap.cap & IEEE80211_HT_CAP_SM_PS;
++
++	ht_bss_conf.primary_channel = req_bss_cap->primary_channel;
++	ht_bss_conf.bss_cap = req_bss_cap->bss_cap;
++	ht_bss_conf.bss_op_mode = req_bss_cap->bss_op_mode;
++
++	ht_cap.ampdu_factor = req_ht_cap->ampdu_factor;
++	ht_cap.ampdu_density = req_ht_cap->ampdu_density;
++
++	/* own MCS TX capabilities */
++	tx_mcs_set_cap = sband->ht_cap.mcs.tx_params;
++
++	/*
++	 * configure supported Tx MCS according to requested MCS
++	 * (based in most cases on Rx capabilities of peer) and self
++	 * Tx MCS capabilities (as defined by low level driver HW
++	 * Tx capabilities)
++	 */
++
++	/* can we TX with MCS rates? */
++	if (!(tx_mcs_set_cap & IEEE80211_HT_MCS_TX_DEFINED))
++		goto check_changed;
++
++	/* Counting from 0, therefore +1 */
++	if (tx_mcs_set_cap & IEEE80211_HT_MCS_TX_RX_DIFF)
++		max_tx_streams =
++			((tx_mcs_set_cap & IEEE80211_HT_MCS_TX_MAX_STREAMS_MASK)
++				>> IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT) + 1;
++	else
++		max_tx_streams = IEEE80211_HT_MCS_TX_MAX_STREAMS;
++
++	/*
++	 * 802.11n D5.0 20.3.5 / 20.6 says:
++	 * - indices 0 to 7 and 32 are single spatial stream
++	 * - 8 to 31 are multiple spatial streams using equal modulation
++	 *   [8..15 for two streams, 16..23 for three and 24..31 for four]
++	 * - remainder are multiple spatial streams using unequal modulation
++	 */
++	for (i = 0; i < max_tx_streams; i++)
++		ht_cap.mcs.rx_mask[i] =
++			sband->ht_cap.mcs.rx_mask[i] &
++					req_ht_cap->mcs.rx_mask[i];
++
++	if (tx_mcs_set_cap & IEEE80211_HT_MCS_TX_UNEQUAL_MODULATION)
++		for (i = IEEE80211_HT_MCS_UNEQUAL_MODULATION_START_BYTE;
++		     i < IEEE80211_HT_MCS_MASK_LEN; i++)
++			ht_cap.mcs.rx_mask[i] =
++				sband->ht_cap.mcs.rx_mask[i] &
++					req_ht_cap->mcs.rx_mask[i];
++
++	/* handle MCS rate 32 too */
++	if (sband->ht_cap.mcs.rx_mask[32/8] &
++	    req_ht_cap->mcs.rx_mask[32/8] & 1)
++		ht_cap.mcs.rx_mask[32/8] |= 1;
++
++ check_changed:
++	/* if bss configuration changed store the new one */
++	if (memcmp(&conf->ht_cap, &ht_cap, sizeof(ht_cap)) ||
++	    memcmp(&conf->ht_bss_conf, &ht_bss_conf, sizeof(ht_bss_conf))) {
++		changed |= BSS_CHANGED_HT;
++		memcpy(&conf->ht_cap, &ht_cap, sizeof(ht_cap));
++		memcpy(&conf->ht_bss_conf, &ht_bss_conf, sizeof(ht_bss_conf));
++	}
+ 
+-	return 0;
++	return changed;
+ }
+ 
+ static void ieee80211_send_addba_request(struct ieee80211_sub_if_data *sdata,
+@@ -802,7 +909,7 @@ void ieee80211_process_addba_request(str
+ 	 * check if configuration can support the BA policy
+ 	 * and if buffer size does not exceeds max value */
+ 	if (((ba_policy != 1)
+-		&& (!(conf->ht_conf.cap & IEEE80211_HT_CAP_DELAY_BA)))
++		&& (!(conf->ht_cap.cap & IEEE80211_HT_CAP_DELAY_BA)))
+ 		|| (buf_size > IEEE80211_MAX_AMPDU_BUF)) {
+ 		status = WLAN_STATUS_INVALID_QOS_PARAM;
+ #ifdef CONFIG_MAC80211_HT_DEBUG
+@@ -820,7 +927,7 @@ void ieee80211_process_addba_request(str
+ 
+ 		sband = local->hw.wiphy->bands[conf->channel->band];
+ 		buf_size = IEEE80211_MIN_AMPDU_BUF;
+-		buf_size = buf_size << sband->ht_info.ampdu_factor;
++		buf_size = buf_size << sband->ht_cap.ampdu_factor;
+ 	}
+ 
+ 
+--- everything.orig/net/mac80211/mlme.c	2008-10-08 20:45:06.000000000 +0200
++++ everything/net/mac80211/mlme.c	2008-10-09 02:16:26.000000000 +0200
+@@ -236,7 +236,7 @@ static void ieee80211_send_assoc(struct 
+ 	struct ieee80211_local *local = sdata->local;
+ 	struct sk_buff *skb;
+ 	struct ieee80211_mgmt *mgmt;
+-	u8 *pos, *ies, *ht_add_ie;
++	u8 *pos, *ies, *ht_ie;
+ 	int i, len, count, rates_len, supp_rates_len;
+ 	u16 capab;
+ 	struct ieee80211_bss *bss;
+@@ -393,24 +393,25 @@ static void ieee80211_send_assoc(struct 
+ 
+ 	/* wmm support is a must to HT */
+ 	if (wmm && (ifsta->flags & IEEE80211_STA_WMM_ENABLED) &&
+-	    sband->ht_info.ht_supported &&
+-	    (ht_add_ie = ieee80211_bss_get_ie(bss, WLAN_EID_HT_EXTRA_INFO))) {
+-		struct ieee80211_ht_addt_info *ht_add_info =
+-			(struct ieee80211_ht_addt_info *)ht_add_ie;
+-		u16 cap = sband->ht_info.cap;
++	    sband->ht_cap.ht_supported &&
++	    (ht_ie = ieee80211_bss_get_ie(bss, WLAN_EID_HT_INFORMATION)) &&
++	    ht_ie[1] >= sizeof(struct ieee80211_ht_info)) {
++		struct ieee80211_ht_info *ht_info =
++			(struct ieee80211_ht_info *)(ht_ie + 2);
++		u16 cap = sband->ht_cap.cap;
+ 		__le16 tmp;
+ 		u32 flags = local->hw.conf.channel->flags;
+ 
+-		switch (ht_add_info->ht_param & IEEE80211_HT_IE_CHA_SEC_OFFSET) {
+-		case IEEE80211_HT_IE_CHA_SEC_ABOVE:
++		switch (ht_info->ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) {
++		case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
+ 			if (flags & IEEE80211_CHAN_NO_FAT_ABOVE) {
+-				cap &= ~IEEE80211_HT_CAP_SUP_WIDTH;
++				cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
+ 				cap &= ~IEEE80211_HT_CAP_SGI_40;
+ 			}
+ 			break;
+-		case IEEE80211_HT_IE_CHA_SEC_BELOW:
++		case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
+ 			if (flags & IEEE80211_CHAN_NO_FAT_BELOW) {
+-				cap &= ~IEEE80211_HT_CAP_SUP_WIDTH;
++				cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
+ 				cap &= ~IEEE80211_HT_CAP_SGI_40;
+ 			}
+ 			break;
+@@ -424,9 +425,9 @@ static void ieee80211_send_assoc(struct 
+ 		memcpy(pos, &tmp, sizeof(u16));
+ 		pos += sizeof(u16);
+ 		/* TODO: needs a define here for << 2 */
+-		*pos++ = sband->ht_info.ampdu_factor |
+-			 (sband->ht_info.ampdu_density << 2);
+-		memcpy(pos, sband->ht_info.supp_mcs_set, 16);
++		*pos++ = sband->ht_cap.ampdu_factor |
++			 (sband->ht_cap.ampdu_density << 2);
++		memcpy(pos, &sband->ht_cap.mcs, sizeof(sband->ht_cap.mcs));
+ 	}
+ 
+ 	kfree(ifsta->assocreq_ies);
+@@ -732,7 +733,7 @@ static void ieee80211_set_associated(str
+ 	if (conf->flags & IEEE80211_CONF_SUPPORT_HT_MODE) {
+ 		changed |= BSS_CHANGED_HT;
+ 		sdata->bss_conf.assoc_ht = 1;
+-		sdata->bss_conf.ht_conf = &conf->ht_conf;
++		sdata->bss_conf.ht_cap = &conf->ht_cap;
+ 		sdata->bss_conf.ht_bss_conf = &conf->ht_bss_conf;
+ 	}
+ 
+@@ -856,7 +857,7 @@ static void ieee80211_set_disassoc(struc
+ 		changed |= BSS_CHANGED_HT;
+ 
+ 	sdata->bss_conf.assoc_ht = 0;
+-	sdata->bss_conf.ht_conf = NULL;
++	sdata->bss_conf.ht_cap = NULL;
+ 	sdata->bss_conf.ht_bss_conf = NULL;
+ 
+ 	ieee80211_led_assoc(local, 0);
+@@ -1348,11 +1349,11 @@ static void ieee80211_rx_mgmt_assoc_resp
+ 	if (elems.ht_cap_elem && elems.ht_info_elem && elems.wmm_param &&
+ 	    (ifsta->flags & IEEE80211_STA_WMM_ENABLED)) {
+ 		struct ieee80211_ht_bss_info bss_info;
+-		ieee80211_ht_cap_ie_to_ht_info(
+-				elems.ht_cap_elem, &sta->sta.ht_info);
+-		ieee80211_ht_addt_info_ie_to_ht_bss_info(
++		ieee80211_ht_cap_ie_to_sta_ht_cap(
++				elems.ht_cap_elem, &sta->sta.ht_cap);
++		ieee80211_ht_info_ie_to_ht_bss_info(
+ 				elems.ht_info_elem, &bss_info);
+-		ieee80211_handle_ht(local, 1, &sta->sta.ht_info, &bss_info);
++		ieee80211_handle_ht(local, &sta->sta.ht_cap, &bss_info);
+ 	}
+ 
+ 	rate_control_rate_init(sta);
+@@ -1712,9 +1713,9 @@ static void ieee80211_rx_mgmt_beacon(str
+ 	    elems.wmm_param && conf->flags & IEEE80211_CONF_SUPPORT_HT_MODE) {
+ 		struct ieee80211_ht_bss_info bss_info;
+ 
+-		ieee80211_ht_addt_info_ie_to_ht_bss_info(
++		ieee80211_ht_info_ie_to_ht_bss_info(
+ 				elems.ht_info_elem, &bss_info);
+-		changed |= ieee80211_handle_ht(local, 1, &conf->ht_conf,
++		changed |= ieee80211_handle_ht(local, &conf->ht_cap,
+ 					       &bss_info);
+ 	}
+ 
+--- everything.orig/net/mac80211/util.c	2008-10-08 20:45:06.000000000 +0200
++++ everything/net/mac80211/util.c	2008-10-09 02:16:28.000000000 +0200
+@@ -532,8 +532,8 @@ void ieee802_11_parse_elems(u8 *start, s
+ 			if (elen >= sizeof(struct ieee80211_ht_cap))
+ 				elems->ht_cap_elem = (void *)pos;
+ 			break;
+-		case WLAN_EID_HT_EXTRA_INFO:
+-			if (elen >= sizeof(struct ieee80211_ht_addt_info))
++		case WLAN_EID_HT_INFORMATION:
++			if (elen >= sizeof(struct ieee80211_ht_info))
+ 				elems->ht_info_elem = (void *)pos;
+ 			break;
+ 		case WLAN_EID_MESH_ID:
+--- everything.orig/net/mac80211/cfg.c	2008-10-08 20:45:06.000000000 +0200
++++ everything/net/mac80211/cfg.c	2008-10-09 02:16:29.000000000 +0200
+@@ -635,10 +635,9 @@ static void sta_apply_parameters(struct 
+ 		sta->sta.supp_rates[local->oper_channel->band] = rates;
+ 	}
+ 
+-	if (params->ht_capa) {
+-		ieee80211_ht_cap_ie_to_ht_info(params->ht_capa,
+-					       &sta->sta.ht_info);
+-	}
++	if (params->ht_capa)
++		ieee80211_ht_cap_ie_to_sta_ht_cap(params->ht_capa,
++						  &sta->sta.ht_cap);
+ 
+ 	if (ieee80211_vif_is_mesh(&sdata->vif) && params->plink_action) {
+ 		switch (params->plink_action) {
+--- everything.orig/drivers/net/wireless/iwlwifi/iwl-agn-rs.c	2008-10-08 20:44:47.000000000 +0200
++++ everything/drivers/net/wireless/iwlwifi/iwl-agn-rs.c	2008-10-09 02:16:27.000000000 +0200
+@@ -1136,10 +1136,10 @@ static int rs_switch_to_mimo2(struct iwl
+ 	s8 is_green = lq_sta->is_green;
+ 
+ 	if (!(conf->flags & IEEE80211_CONF_SUPPORT_HT_MODE) ||
+-	    !sta->ht_info.ht_supported)
++	    !sta->ht_cap.ht_supported)
+ 		return -1;
+ 
+-	if (((sta->ht_info.cap & IEEE80211_HT_CAP_SM_PS) >> 2)
++	if (((sta->ht_cap.cap & IEEE80211_HT_CAP_SM_PS) >> 2)
+ 						== WLAN_HT_CAP_SM_PS_STATIC)
+ 		return -1;
+ 
+@@ -1204,7 +1204,7 @@ static int rs_switch_to_siso(struct iwl_
+ 	s32 rate;
+ 
+ 	if (!(conf->flags & IEEE80211_CONF_SUPPORT_HT_MODE) ||
+-	    !sta->ht_info.ht_supported)
++	    !sta->ht_cap.ht_supported)
+ 		return -1;
+ 
+ 	IWL_DEBUG_RATE("LQ: try to switch to SISO\n");
+@@ -2244,19 +2244,19 @@ static void rs_rate_init(void *priv_r, s
+ 	 * active_siso_rate mask includes 9 MBits (bit 5), and CCK (bits 0-3),
+ 	 * supp_rates[] does not; shift to convert format, force 9 MBits off.
+ 	 */
+-	lq_sta->active_siso_rate = conf->ht_conf.supp_mcs_set[0] << 1;
+-	lq_sta->active_siso_rate |= conf->ht_conf.supp_mcs_set[0] & 0x1;
++	lq_sta->active_siso_rate = conf->ht_cap.mcs.rx_mask[0] << 1;
++	lq_sta->active_siso_rate |= conf->ht_cap.mcs.rx_mask[0] & 0x1;
+ 	lq_sta->active_siso_rate &= ~((u16)0x2);
+ 	lq_sta->active_siso_rate <<= IWL_FIRST_OFDM_RATE;
+ 
+ 	/* Same here */
+-	lq_sta->active_mimo2_rate = conf->ht_conf.supp_mcs_set[1] << 1;
+-	lq_sta->active_mimo2_rate |= conf->ht_conf.supp_mcs_set[1] & 0x1;
++	lq_sta->active_mimo2_rate = conf->ht_cap.mcs.rx_mask[1] << 1;
++	lq_sta->active_mimo2_rate |= conf->ht_cap.mcs.rx_mask[1] & 0x1;
+ 	lq_sta->active_mimo2_rate &= ~((u16)0x2);
+ 	lq_sta->active_mimo2_rate <<= IWL_FIRST_OFDM_RATE;
+ 
+-	lq_sta->active_mimo3_rate = conf->ht_conf.supp_mcs_set[2] << 1;
+-	lq_sta->active_mimo3_rate |= conf->ht_conf.supp_mcs_set[2] & 0x1;
++	lq_sta->active_mimo3_rate = conf->ht_cap.mcs.rx_mask[2] << 1;
++	lq_sta->active_mimo3_rate |= conf->ht_cap.mcs.rx_mask[2] & 0x1;
+ 	lq_sta->active_mimo3_rate &= ~((u16)0x2);
+ 	lq_sta->active_mimo3_rate <<= IWL_FIRST_OFDM_RATE;
+ 
+--- everything.orig/drivers/net/wireless/iwlwifi/iwl-agn.c	2008-10-08 20:44:48.000000000 +0200
++++ everything/drivers/net/wireless/iwlwifi/iwl-agn.c	2008-10-09 02:16:29.000000000 +0200
+@@ -553,7 +553,7 @@ static int iwl4965_send_beacon_cmd(struc
+ static void iwl4965_ht_conf(struct iwl_priv *priv,
+ 			    struct ieee80211_bss_conf *bss_conf)
+ {
+-	struct ieee80211_ht_info *ht_conf = bss_conf->ht_conf;
++	struct ieee80211_sta_ht_cap *ht_conf = bss_conf->ht_cap;
+ 	struct ieee80211_ht_bss_info *ht_bss_conf = bss_conf->ht_bss_conf;
+ 	struct iwl_ht_info *iwl_conf = &priv->current_ht_config;
+ 
+@@ -574,27 +574,27 @@ static void iwl4965_ht_conf(struct iwl_p
+ 		!!(ht_conf->cap & IEEE80211_HT_CAP_MAX_AMSDU);
+ 
+ 	iwl_conf->supported_chan_width =
+-		!!(ht_conf->cap & IEEE80211_HT_CAP_SUP_WIDTH);
++		!!(ht_conf->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40);
+ 	iwl_conf->extension_chan_offset =
+-		ht_bss_conf->bss_cap & IEEE80211_HT_IE_CHA_SEC_OFFSET;
++		ht_bss_conf->bss_cap & IEEE80211_HT_PARAM_CHA_SEC_OFFSET;
+ 	/* If no above or below channel supplied disable FAT channel */
+-	if (iwl_conf->extension_chan_offset != IEEE80211_HT_IE_CHA_SEC_ABOVE &&
+-	    iwl_conf->extension_chan_offset != IEEE80211_HT_IE_CHA_SEC_BELOW) {
+-		iwl_conf->extension_chan_offset = IEEE80211_HT_IE_CHA_SEC_NONE;
++	if (iwl_conf->extension_chan_offset != IEEE80211_HT_PARAM_CHA_SEC_ABOVE &&
++	    iwl_conf->extension_chan_offset != IEEE80211_HT_PARAM_CHA_SEC_BELOW) {
++		iwl_conf->extension_chan_offset = IEEE80211_HT_PARAM_CHA_SEC_NONE;
+ 		iwl_conf->supported_chan_width = 0;
+ 	}
+ 
+ 	iwl_conf->sm_ps = (u8)((ht_conf->cap & IEEE80211_HT_CAP_SM_PS) >> 2);
+ 
+-	memcpy(iwl_conf->supp_mcs_set, ht_conf->supp_mcs_set, 16);
++	memcpy(&iwl_conf->mcs, &ht_conf->mcs, 16);
+ 
+ 	iwl_conf->control_channel = ht_bss_conf->primary_channel;
+ 	iwl_conf->tx_chan_width =
+-		!!(ht_bss_conf->bss_cap & IEEE80211_HT_IE_CHA_WIDTH);
++		!!(ht_bss_conf->bss_cap & IEEE80211_HT_PARAM_CHAN_WIDTH_ANY);
+ 	iwl_conf->ht_protection =
+-		ht_bss_conf->bss_op_mode & IEEE80211_HT_IE_HT_PROTECTION;
++		ht_bss_conf->bss_op_mode & IEEE80211_HT_OP_MODE_PROTECTION;
+ 	iwl_conf->non_GF_STA_present =
+-		!!(ht_bss_conf->bss_op_mode & IEEE80211_HT_IE_NON_GF_STA_PRSNT);
++		!!(ht_bss_conf->bss_op_mode & IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT);
+ 
+ 	IWL_DEBUG_MAC80211("control channel %d\n", iwl_conf->control_channel);
+ 	IWL_DEBUG_MAC80211("leave\n");
+--- everything.orig/drivers/net/wireless/iwlwifi/iwl-core.c	2008-10-08 20:44:47.000000000 +0200
++++ everything/drivers/net/wireless/iwlwifi/iwl-core.c	2008-10-09 02:16:26.000000000 +0200
+@@ -382,10 +382,10 @@ void iwl_reset_qos(struct iwl_priv *priv
+ }
+ EXPORT_SYMBOL(iwl_reset_qos);
+ 
+-#define MAX_BIT_RATE_40_MHZ 0x96 /* 150 Mbps */
+-#define MAX_BIT_RATE_20_MHZ 0x48 /* 72 Mbps */
++#define MAX_BIT_RATE_40_MHZ 150 /* Mbps */
++#define MAX_BIT_RATE_20_MHZ 72 /* Mbps */
+ static void iwlcore_init_ht_hw_capab(const struct iwl_priv *priv,
+-			      struct ieee80211_ht_info *ht_info,
++			      struct ieee80211_sta_ht_cap *ht_info,
+ 			      enum ieee80211_band band)
+ {
+ 	u16 max_bit_rate = 0;
+@@ -393,45 +393,46 @@ static void iwlcore_init_ht_hw_capab(con
+ 	u8 tx_chains_num = priv->hw_params.tx_chains_num;
+ 
+ 	ht_info->cap = 0;
+-	memset(ht_info->supp_mcs_set, 0, 16);
++	memset(&ht_info->mcs, 0, sizeof(ht_info->mcs));
+ 
+-	ht_info->ht_supported = 1;
++	ht_info->ht_supported = true;
+ 
+-	ht_info->cap |= (u16)IEEE80211_HT_CAP_GRN_FLD;
+-	ht_info->cap |= (u16)IEEE80211_HT_CAP_SGI_20;
+-	ht_info->cap |= (u16)(IEEE80211_HT_CAP_SM_PS &
++	ht_info->cap |= IEEE80211_HT_CAP_GRN_FLD;
++	ht_info->cap |= IEEE80211_HT_CAP_SGI_20;
++	ht_info->cap |= (IEEE80211_HT_CAP_SM_PS &
+ 			     (WLAN_HT_CAP_SM_PS_DISABLED << 2));
+ 
+ 	max_bit_rate = MAX_BIT_RATE_20_MHZ;
+ 	if (priv->hw_params.fat_channel & BIT(band)) {
+-		ht_info->cap |= (u16)IEEE80211_HT_CAP_SUP_WIDTH;
+-		ht_info->cap |= (u16)IEEE80211_HT_CAP_SGI_40;
+-		ht_info->supp_mcs_set[4] = 0x01;
++		ht_info->cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
++		ht_info->cap |= IEEE80211_HT_CAP_SGI_40;
++		ht_info->mcs.rx_mask[4] = 0x01;
+ 		max_bit_rate = MAX_BIT_RATE_40_MHZ;
+ 	}
+ 
+ 	if (priv->cfg->mod_params->amsdu_size_8K)
+-		ht_info->cap |= (u16)IEEE80211_HT_CAP_MAX_AMSDU;
++		ht_info->cap |= IEEE80211_HT_CAP_MAX_AMSDU;
+ 
+ 	ht_info->ampdu_factor = CFG_HT_RX_AMPDU_FACTOR_DEF;
+ 	ht_info->ampdu_density = CFG_HT_MPDU_DENSITY_DEF;
+ 
+-	ht_info->supp_mcs_set[0] = 0xFF;
++	ht_info->mcs.rx_mask[0] = 0xFF;
+ 	if (rx_chains_num >= 2)
+-		ht_info->supp_mcs_set[1] = 0xFF;
++		ht_info->mcs.rx_mask[1] = 0xFF;
+ 	if (rx_chains_num >= 3)
+-		ht_info->supp_mcs_set[2] = 0xFF;
++		ht_info->mcs.rx_mask[2] = 0xFF;
+ 
+ 	/* Highest supported Rx data rate */
+ 	max_bit_rate *= rx_chains_num;
+-	ht_info->supp_mcs_set[10] = (u8)(max_bit_rate & 0x00FF);
+-	ht_info->supp_mcs_set[11] = (u8)((max_bit_rate & 0xFF00) >> 8);
++	WARN_ON(max_bit_rate & ~IEEE80211_HT_MCS_RX_HIGHEST_MASK);
++	ht_info->mcs.rx_highest = cpu_to_le16(max_bit_rate);
+ 
+ 	/* Tx MCS capabilities */
+-	ht_info->supp_mcs_set[12] = IEEE80211_HT_CAP_MCS_TX_DEFINED;
++	ht_info->mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED;
+ 	if (tx_chains_num != rx_chains_num) {
+-		ht_info->supp_mcs_set[12] |= IEEE80211_HT_CAP_MCS_TX_RX_DIFF;
+-		ht_info->supp_mcs_set[12] |= ((tx_chains_num - 1) << 2);
++		ht_info->mcs.tx_params |= IEEE80211_HT_MCS_TX_RX_DIFF;
++		ht_info->mcs.tx_params |= ((tx_chains_num - 1) <<
++				IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT);
+ 	}
+ }
+ 
+@@ -495,7 +496,7 @@ static int iwlcore_init_geos(struct iwl_
+ 	sband->n_bitrates = IWL_RATE_COUNT - IWL_FIRST_OFDM_RATE;
+ 
+ 	if (priv->cfg->sku & IWL_SKU_N)
+-		iwlcore_init_ht_hw_capab(priv, &sband->ht_info,
++		iwlcore_init_ht_hw_capab(priv, &sband->ht_cap,
+ 					 IEEE80211_BAND_5GHZ);
+ 
+ 	sband = &priv->bands[IEEE80211_BAND_2GHZ];
+@@ -505,7 +506,7 @@ static int iwlcore_init_geos(struct iwl_
+ 	sband->n_bitrates = IWL_RATE_COUNT;
+ 
+ 	if (priv->cfg->sku & IWL_SKU_N)
+-		iwlcore_init_ht_hw_capab(priv, &sband->ht_info,
++		iwlcore_init_ht_hw_capab(priv, &sband->ht_cap,
+ 					 IEEE80211_BAND_2GHZ);
+ 
+ 	priv->ieee_channels = channels;
+@@ -595,8 +596,8 @@ static void iwlcore_free_geos(struct iwl
+ static bool is_single_rx_stream(struct iwl_priv *priv)
+ {
+ 	return !priv->current_ht_config.is_ht ||
+-	       ((priv->current_ht_config.supp_mcs_set[1] == 0) &&
+-		(priv->current_ht_config.supp_mcs_set[2] == 0));
++	       ((priv->current_ht_config.mcs.rx_mask[1] == 0) &&
++		(priv->current_ht_config.mcs.rx_mask[2] == 0));
+ }
+ 
+ static u8 iwl_is_channel_extension(struct iwl_priv *priv,
+@@ -609,10 +610,10 @@ static u8 iwl_is_channel_extension(struc
+ 	if (!is_channel_valid(ch_info))
+ 		return 0;
+ 
+-	if (extension_chan_offset == IEEE80211_HT_IE_CHA_SEC_ABOVE)
++	if (extension_chan_offset == IEEE80211_HT_PARAM_CHA_SEC_ABOVE)
+ 		return !(ch_info->fat_extension_channel &
+ 					IEEE80211_CHAN_NO_FAT_ABOVE);
+-	else if (extension_chan_offset == IEEE80211_HT_IE_CHA_SEC_BELOW)
++	else if (extension_chan_offset == IEEE80211_HT_PARAM_CHA_SEC_BELOW)
+ 		return !(ch_info->fat_extension_channel &
+ 					IEEE80211_CHAN_NO_FAT_BELOW);
+ 
+@@ -620,18 +621,18 @@ static u8 iwl_is_channel_extension(struc
+ }
+ 
+ u8 iwl_is_fat_tx_allowed(struct iwl_priv *priv,
+-			     struct ieee80211_ht_info *sta_ht_inf)
++			 struct ieee80211_sta_ht_cap *sta_ht_inf)
+ {
+ 	struct iwl_ht_info *iwl_ht_conf = &priv->current_ht_config;
+ 
+ 	if ((!iwl_ht_conf->is_ht) ||
+ 	   (iwl_ht_conf->supported_chan_width != IWL_CHANNEL_WIDTH_40MHZ) ||
+-	   (iwl_ht_conf->extension_chan_offset == IEEE80211_HT_IE_CHA_SEC_NONE))
++	   (iwl_ht_conf->extension_chan_offset == IEEE80211_HT_PARAM_CHA_SEC_NONE))
+ 		return 0;
+ 
+ 	if (sta_ht_inf) {
+ 		if ((!sta_ht_inf->ht_supported) ||
+-		   (!(sta_ht_inf->cap & IEEE80211_HT_CAP_SUP_WIDTH)))
++		   (!(sta_ht_inf->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40)))
+ 			return 0;
+ 	}
+ 
+@@ -671,13 +672,13 @@ void iwl_set_rxon_ht(struct iwl_priv *pr
+ 
+ 	/* Note: control channel is opposite of extension channel */
+ 	switch (ht_info->extension_chan_offset) {
+-	case IEEE80211_HT_IE_CHA_SEC_ABOVE:
++	case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
+ 		rxon->flags &= ~(RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK);
+ 		break;
+-	case IEEE80211_HT_IE_CHA_SEC_BELOW:
++	case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
+ 		rxon->flags |= RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK;
+ 		break;
+-	case IEEE80211_HT_IE_CHA_SEC_NONE:
++	case IEEE80211_HT_PARAM_CHA_SEC_NONE:
+ 	default:
+ 		rxon->flags &= ~RXON_FLG_CHANNEL_MODE_MIXED_MSK;
+ 		break;
+@@ -693,9 +694,9 @@ void iwl_set_rxon_ht(struct iwl_priv *pr
+ 			"rxon flags 0x%X operation mode :0x%X "
+ 			"extension channel offset 0x%x "
+ 			"control chan %d\n",
+-			ht_info->supp_mcs_set[0],
+-			ht_info->supp_mcs_set[1],
+-			ht_info->supp_mcs_set[2],
++			ht_info->mcs.rx_mask[0],
++			ht_info->mcs.rx_mask[1],
++			ht_info->mcs.rx_mask[2],
+ 			le32_to_cpu(rxon->flags), ht_info->ht_protection,
+ 			ht_info->extension_chan_offset,
+ 			ht_info->control_channel);
+--- everything.orig/drivers/net/wireless/iwlwifi/iwl-core.h	2008-10-08 20:44:47.000000000 +0200
++++ everything/drivers/net/wireless/iwlwifi/iwl-core.h	2008-10-08 20:45:06.000000000 +0200
+@@ -190,7 +190,7 @@ void iwl_set_rxon_chain(struct iwl_priv 
+ int iwl_set_rxon_channel(struct iwl_priv *priv, struct ieee80211_channel *ch);
+ void iwl_set_rxon_ht(struct iwl_priv *priv, struct iwl_ht_info *ht_info);
+ u8 iwl_is_fat_tx_allowed(struct iwl_priv *priv,
+-			 struct ieee80211_ht_info *sta_ht_inf);
++			 struct ieee80211_sta_ht_cap *sta_ht_inf);
+ int iwl_hw_nic_init(struct iwl_priv *priv);
+ int iwl_setup_mac(struct iwl_priv *priv);
+ int iwl_set_hw_params(struct iwl_priv *priv);
+--- everything.orig/drivers/net/wireless/iwlwifi/iwl-dev.h	2008-10-08 20:44:47.000000000 +0200
++++ everything/drivers/net/wireless/iwlwifi/iwl-dev.h	2008-10-09 02:16:27.000000000 +0200
+@@ -412,7 +412,7 @@ struct iwl_ht_info {
+ 	u8 max_amsdu_size;
+ 	u8 ampdu_factor;
+ 	u8 mpdu_density;
+-	u8 supp_mcs_set[16];
++	struct ieee80211_mcs_info mcs;
+ 	/* BSS related data */
+ 	u8 control_channel;
+ 	u8 extension_chan_offset;
+@@ -584,7 +584,7 @@ struct iwl_addsta_cmd;
+ extern int iwl_send_add_sta(struct iwl_priv *priv,
+ 			    struct iwl_addsta_cmd *sta, u8 flags);
+ extern u8 iwl_add_station_flags(struct iwl_priv *priv, const u8 *addr,
+-			int is_ap, u8 flags, struct ieee80211_ht_info *ht_info);
++			int is_ap, u8 flags, struct ieee80211_sta_ht_cap *ht_info);
+ extern void iwl4965_update_chain_flags(struct iwl_priv *priv);
+ extern int iwl4965_set_pwr_src(struct iwl_priv *priv, enum iwl_pwr_src src);
+ extern const u8 iwl_bcast_addr[ETH_ALEN];
+--- everything.orig/drivers/net/wireless/iwlwifi/iwl-sta.c	2008-10-08 20:44:47.000000000 +0200
++++ everything/drivers/net/wireless/iwlwifi/iwl-sta.c	2008-10-09 02:16:29.000000000 +0200
+@@ -183,7 +183,7 @@ int iwl_send_add_sta(struct iwl_priv *pr
+ EXPORT_SYMBOL(iwl_send_add_sta);
+ 
+ static void iwl_set_ht_add_station(struct iwl_priv *priv, u8 index,
+-				   struct ieee80211_ht_info *sta_ht_inf)
++				   struct ieee80211_sta_ht_cap *sta_ht_inf)
+ {
+ 	__le32 sta_flags;
+ 	u8 mimo_ps_mode;
+@@ -231,7 +231,7 @@ static void iwl_set_ht_add_station(struc
+  * iwl_add_station_flags - Add station to tables in driver and device
+  */
+ u8 iwl_add_station_flags(struct iwl_priv *priv, const u8 *addr, int is_ap,
+-			 u8 flags, struct ieee80211_ht_info *ht_info)
++			 u8 flags, struct ieee80211_sta_ht_cap *ht_info)
+ {
+ 	int i;
+ 	int sta_id = IWL_INVALID_STATION;
+@@ -900,7 +900,7 @@ int iwl_rxon_add_station(struct iwl_priv
+ 
+ 	/* Add station to device's station table */
+ 	struct ieee80211_conf *conf = &priv->hw->conf;
+-	struct ieee80211_ht_info *cur_ht_config = &conf->ht_conf;
++	struct ieee80211_sta_ht_cap *cur_ht_config = &conf->ht_cap;
+ 
+ 	if ((is_ap) &&
+ 	    (conf->flags & IEEE80211_CONF_SUPPORT_HT_MODE) &&
+--- everything.orig/drivers/net/wireless/iwlwifi/iwl-scan.c	2008-10-08 20:44:47.000000000 +0200
++++ everything/drivers/net/wireless/iwlwifi/iwl-scan.c	2008-10-08 20:45:06.000000000 +0200
+@@ -550,7 +550,7 @@ static void iwl_ht_cap_to_ie(const struc
+ {
+ 	struct ieee80211_ht_cap *ht_cap;
+ 
+-	if (!sband || !sband->ht_info.ht_supported)
++	if (!sband || !sband->ht_cap.ht_supported)
+ 		return;
+ 
+ 	if (*left < sizeof(struct ieee80211_ht_cap))
+@@ -559,12 +559,12 @@ static void iwl_ht_cap_to_ie(const struc
+ 	*pos++ = sizeof(struct ieee80211_ht_cap);
+ 	ht_cap = (struct ieee80211_ht_cap *) pos;
+ 
+-	ht_cap->cap_info = cpu_to_le16(sband->ht_info.cap);
+-	memcpy(ht_cap->supp_mcs_set, sband->ht_info.supp_mcs_set, 16);
++	ht_cap->cap_info = cpu_to_le16(sband->ht_cap.cap);
++	memcpy(&ht_cap->mcs, &sband->ht_cap.mcs, 16);
+ 	ht_cap->ampdu_params_info =
+-		(sband->ht_info.ampdu_factor & IEEE80211_HT_CAP_AMPDU_FACTOR) |
+-		((sband->ht_info.ampdu_density << 2) &
+-			IEEE80211_HT_CAP_AMPDU_DENSITY);
++		(sband->ht_cap.ampdu_factor & IEEE80211_HT_AMPDU_PARM_FACTOR) |
++		((sband->ht_cap.ampdu_density << 2) &
++			IEEE80211_HT_AMPDU_PARM_DENSITY);
+ 	*left -= sizeof(struct ieee80211_ht_cap);
+ }
+ 
+--- everything.orig/drivers/net/wireless/ath9k/main.c	2008-10-08 20:44:48.000000000 +0200
++++ everything/drivers/net/wireless/ath9k/main.c	2008-10-09 02:16:30.000000000 +0200
+@@ -61,24 +61,24 @@ static u32 ath_get_extchanmode(struct at
+ 
+ 	switch (chan->band) {
+ 	case IEEE80211_BAND_2GHZ:
+-		if ((ext_chan_offset == IEEE80211_HT_IE_CHA_SEC_NONE) &&
++		if ((ext_chan_offset == IEEE80211_HT_PARAM_CHA_SEC_NONE) &&
+ 		    (tx_chan_width == ATH9K_HT_MACMODE_20))
+ 			chanmode = CHANNEL_G_HT20;
+-		if ((ext_chan_offset == IEEE80211_HT_IE_CHA_SEC_ABOVE) &&
++		if ((ext_chan_offset == IEEE80211_HT_PARAM_CHA_SEC_ABOVE) &&
+ 		    (tx_chan_width == ATH9K_HT_MACMODE_2040))
+ 			chanmode = CHANNEL_G_HT40PLUS;
+-		if ((ext_chan_offset == IEEE80211_HT_IE_CHA_SEC_BELOW) &&
++		if ((ext_chan_offset == IEEE80211_HT_PARAM_CHA_SEC_BELOW) &&
+ 		    (tx_chan_width == ATH9K_HT_MACMODE_2040))
+ 			chanmode = CHANNEL_G_HT40MINUS;
+ 		break;
+ 	case IEEE80211_BAND_5GHZ:
+-		if ((ext_chan_offset == IEEE80211_HT_IE_CHA_SEC_NONE) &&
++		if ((ext_chan_offset == IEEE80211_HT_PARAM_CHA_SEC_NONE) &&
+ 		    (tx_chan_width == ATH9K_HT_MACMODE_20))
+ 			chanmode = CHANNEL_A_HT20;
+-		if ((ext_chan_offset == IEEE80211_HT_IE_CHA_SEC_ABOVE) &&
++		if ((ext_chan_offset == IEEE80211_HT_PARAM_CHA_SEC_ABOVE) &&
+ 		    (tx_chan_width == ATH9K_HT_MACMODE_2040))
+ 			chanmode = CHANNEL_A_HT40PLUS;
+-		if ((ext_chan_offset == IEEE80211_HT_IE_CHA_SEC_BELOW) &&
++		if ((ext_chan_offset == IEEE80211_HT_PARAM_CHA_SEC_BELOW) &&
+ 		    (tx_chan_width == ATH9K_HT_MACMODE_2040))
+ 			chanmode = CHANNEL_A_HT40MINUS;
+ 		break;
+@@ -215,24 +215,24 @@ static void ath_key_delete(struct ath_so
+ 	ath_key_reset(sc, key->keyidx, freeslot);
+ }
+ 
+-static void setup_ht_cap(struct ieee80211_ht_info *ht_info)
++static void setup_ht_cap(struct ieee80211_sta_ht_cap *ht_info)
+ {
+ #define	ATH9K_HT_CAP_MAXRXAMPDU_65536 0x3	/* 2 ^ 16 */
+ #define	ATH9K_HT_CAP_MPDUDENSITY_8 0x6		/* 8 usec */
+ 
+-	ht_info->ht_supported = 1;
+-	ht_info->cap = (u16)IEEE80211_HT_CAP_SUP_WIDTH
+-			|(u16)IEEE80211_HT_CAP_SM_PS
+-			|(u16)IEEE80211_HT_CAP_SGI_40
+-			|(u16)IEEE80211_HT_CAP_DSSSCCK40;
++	ht_info->ht_supported = true;
++	ht_info->cap = IEEE80211_HT_CAP_SUP_WIDTH_20_40 |
++		       IEEE80211_HT_CAP_SM_PS |
++		       IEEE80211_HT_CAP_SGI_40 |
++		       IEEE80211_HT_CAP_DSSSCCK40;
+ 
+ 	ht_info->ampdu_factor = ATH9K_HT_CAP_MAXRXAMPDU_65536;
+ 	ht_info->ampdu_density = ATH9K_HT_CAP_MPDUDENSITY_8;
+-	/* setup supported mcs set */
+-	memset(ht_info->supp_mcs_set, 0, 16);
+-	ht_info->supp_mcs_set[0] = 0xff;
+-	ht_info->supp_mcs_set[1] = 0xff;
+-	ht_info->supp_mcs_set[12] = IEEE80211_HT_CAP_MCS_TX_DEFINED;
++	/* set up supported mcs set */
++	memset(&ht_info->mcs, 0, sizeof(ht_info->mcs));
++	ht_info->mcs.rx_mask[0] = 0xff;
++	ht_info->mcs.rx_mask[1] = 0xff;
++	ht_info->mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED;
+ }
+ 
+ static int ath_rate2idx(struct ath_softc *sc, int rate)
+@@ -328,31 +328,28 @@ static u8 parse_mpdudensity(u8 mpdudensi
+ static void ath9k_ht_conf(struct ath_softc *sc,
+ 			  struct ieee80211_bss_conf *bss_conf)
+ {
+-#define IEEE80211_HT_CAP_40MHZ_INTOLERANT BIT(14)
+ 	struct ath_ht_info *ht_info = &sc->sc_ht_info;
+ 
+ 	if (bss_conf->assoc_ht) {
+ 		ht_info->ext_chan_offset =
+ 			bss_conf->ht_bss_conf->bss_cap &
+-				IEEE80211_HT_IE_CHA_SEC_OFFSET;
++				IEEE80211_HT_PARAM_CHA_SEC_OFFSET;
+ 
+-		if (!(bss_conf->ht_conf->cap &
++		if (!(bss_conf->ht_cap->cap &
+ 			IEEE80211_HT_CAP_40MHZ_INTOLERANT) &&
+ 			    (bss_conf->ht_bss_conf->bss_cap &
+-				IEEE80211_HT_IE_CHA_WIDTH))
++				IEEE80211_HT_PARAM_CHAN_WIDTH_ANY))
+ 			ht_info->tx_chan_width = ATH9K_HT_MACMODE_2040;
+ 		else
+ 			ht_info->tx_chan_width = ATH9K_HT_MACMODE_20;
+ 
+ 		ath9k_hw_set11nmac2040(sc->sc_ah, ht_info->tx_chan_width);
+ 		ht_info->maxampdu = 1 << (IEEE80211_HTCAP_MAXRXAMPDU_FACTOR +
+-					bss_conf->ht_conf->ampdu_factor);
++					bss_conf->ht_cap->ampdu_factor);
+ 		ht_info->mpdudensity =
+-			parse_mpdudensity(bss_conf->ht_conf->ampdu_density);
++			parse_mpdudensity(bss_conf->ht_cap->ampdu_density);
+ 
+ 	}
+-
+-#undef IEEE80211_HT_CAP_40MHZ_INTOLERANT
+ }
+ 
+ static void ath9k_bss_assoc_info(struct ath_softc *sc,
+@@ -412,7 +409,7 @@ static void ath9k_bss_assoc_info(struct 
+ 			return;
+ 		}
+ 
+-		if (hw->conf.ht_conf.ht_supported)
++		if (hw->conf.ht_cap.ht_supported)
+ 			sc->sc_ah->ah_channels[pos].chanmode =
+ 				ath_get_extchanmode(sc, curchan);
+ 		else
+@@ -535,7 +532,7 @@ int _ath_rx_indicate(struct ath_softc *s
+ 
+ 	if (an) {
+ 		ath_rx_input(sc, an,
+-			     hw->conf.ht_conf.ht_supported,
++			     hw->conf.ht_cap.ht_supported,
+ 			     skb, status, &st);
+ 	}
+ 	if (!an || (st != ATH_RX_CONSUMED))
+@@ -944,7 +941,7 @@ static int ath_attach(u16 devid,
+ 
+ 	if (sc->sc_ah->ah_caps.hw_caps & ATH9K_HW_CAP_HT)
+ 		/* Setup HT capabilities for 2.4Ghz*/
+-		setup_ht_cap(&sc->sbands[IEEE80211_BAND_2GHZ].ht_info);
++		setup_ht_cap(&sc->sbands[IEEE80211_BAND_2GHZ].ht_cap);
+ 
+ 	hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
+ 		&sc->sbands[IEEE80211_BAND_2GHZ];
+@@ -959,7 +956,7 @@ static int ath_attach(u16 devid,
+ 
+ 		if (sc->sc_ah->ah_caps.hw_caps & ATH9K_HW_CAP_HT)
+ 			/* Setup HT capabilities for 5Ghz*/
+-			setup_ht_cap(&sc->sbands[IEEE80211_BAND_5GHZ].ht_info);
++			setup_ht_cap(&sc->sbands[IEEE80211_BAND_5GHZ].ht_cap);
+ 
+ 		hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
+ 			&sc->sbands[IEEE80211_BAND_5GHZ];
+@@ -1255,7 +1252,7 @@ static int ath9k_config(struct ieee80211
+ 		(curchan->band == IEEE80211_BAND_2GHZ) ?
+ 		CHANNEL_G : CHANNEL_A;
+ 
+-	if (sc->sc_curaid && hw->conf.ht_conf.ht_supported)
++	if (sc->sc_curaid && hw->conf.ht_cap.ht_supported)
+ 		sc->sc_ah->ah_channels[pos].chanmode =
+ 			ath_get_extchanmode(sc, curchan);
+ 
+--- everything.orig/drivers/net/wireless/ath9k/rc.c	2008-10-08 20:44:48.000000000 +0200
++++ everything/drivers/net/wireless/ath9k/rc.c	2008-10-09 02:16:27.000000000 +0200
+@@ -1838,7 +1838,7 @@ void ath_rc_node_update(struct ieee80211
+ 	struct ath_softc *sc = hw->priv;
+ 	u32 capflag = 0;
+ 
+-	if (hw->conf.ht_conf.ht_supported) {
++	if (hw->conf.ht_cap.ht_supported) {
+ 		capflag |= ATH_RC_HT_FLAG | ATH_RC_DS_FLAG;
+ 		if (sc->sc_ht_info.tx_chan_width == ATH9K_HT_MACMODE_2040)
+ 			capflag |= ATH_RC_CW40_FLAG;
+@@ -1910,7 +1910,7 @@ static void ath_tx_aggr_resp(struct ath_
+ 	 */
+ 	si = container_of(sta, struct sta_info, sta);
+ 	buffersize = IEEE80211_MIN_AMPDU_BUF <<
+-		sband->ht_info.ampdu_factor; /* FIXME */
++		sband->ht_cap.ampdu_factor; /* FIXME */
+ 	state = si->ampdu_mlme.tid_state_tx[tidno];
+ 
+ 	if (state & HT_ADDBA_RECEIVED_MSK) {
+@@ -1980,7 +1980,7 @@ static void ath_get_rate(void *priv, str
+ 
+ 	/* Check if aggregation has to be enabled for this tid */
+ 
+-	if (hw->conf.ht_conf.ht_supported) {
++	if (hw->conf.ht_cap.ht_supported) {
+ 		if (ieee80211_is_data_qos(fc)) {
+ 			qc = ieee80211_get_qos_ctl(hdr);
+ 			tid = qc[0] & 0xf;
+@@ -2028,8 +2028,8 @@ static void ath_rate_init(void *priv, st
+ 
+ 	ath_setup_rates(sc, sband, sta, ath_rc_priv);
+ 	if (sc->hw->conf.flags & IEEE80211_CONF_SUPPORT_HT_MODE) {
+-		for (i = 0; i < MCS_SET_SIZE; i++) {
+-			if (sc->hw->conf.ht_conf.supp_mcs_set[i/8] & (1<<(i%8)))
++		for (i = 0; i < 77; i++) {
++			if (sc->hw->conf.ht_cap.mcs.rx_mask[i/8] & (1<<(i%8)))
+ 				ath_rc_priv->neg_ht_rates.rs_rates[j++] = i;
+ 			if (j == ATH_RATE_MAX)
+ 				break;
+--- everything.orig/drivers/net/wireless/ath9k/recv.c	2008-10-08 20:44:48.000000000 +0200
++++ everything/drivers/net/wireless/ath9k/recv.c	2008-10-09 02:16:27.000000000 +0200
+@@ -1119,7 +1119,7 @@ int ath_rx_aggr_start(struct ath_softc *
+ 
+ 	sband = hw->wiphy->bands[hw->conf.channel->band];
+ 	buffersize = IEEE80211_MIN_AMPDU_BUF <<
+-		sband->ht_info.ampdu_factor; /* FIXME */
++		sband->ht_cap.ampdu_factor; /* FIXME */
+ 
+ 	rxtid = &an->an_aggr.rx.tid[tid];
+ 
+--- everything.orig/drivers/net/wireless/ath9k/xmit.c	2008-10-08 20:44:48.000000000 +0200
++++ everything/drivers/net/wireless/ath9k/xmit.c	2008-10-09 02:16:27.000000000 +0200
+@@ -300,7 +300,7 @@ static int ath_tx_prepare(struct ath_sof
+ 	if (ieee80211_is_data(fc) && !txctl->use_minrate) {
+ 
+ 		/* Enable HT only for DATA frames and not for EAPOL */
+-		txctl->ht = (hw->conf.ht_conf.ht_supported &&
++		txctl->ht = (hw->conf.ht_cap.ht_supported &&
+ 			    (tx_info->flags & IEEE80211_TX_CTL_AMPDU));
+ 
+ 		if (is_multicast_ether_addr(hdr->addr1)) {
+--- everything.orig/drivers/net/wireless/ath9k/rc.h	2008-10-08 20:44:48.000000000 +0200
++++ everything/drivers/net/wireless/ath9k/rc.h	2008-10-08 20:45:06.000000000 +0200
+@@ -59,7 +59,6 @@ struct ath_softc;
+ #define FALSE 0
+ 
+ #define ATH_RATE_MAX	30
+-#define MCS_SET_SIZE	128
+ 
+ enum ieee80211_fixed_rate_mode {
+ 	IEEE80211_FIXED_RATE_NONE  = 0,
+--- everything.orig/drivers/net/wireless/mac80211_hwsim.c	2008-10-08 20:44:48.000000000 +0200
++++ everything/drivers/net/wireless/mac80211_hwsim.c	2008-10-09 02:16:30.000000000 +0200
+@@ -566,19 +566,18 @@ static int __init init_mac80211_hwsim(vo
+ 		data->band.n_channels = ARRAY_SIZE(hwsim_channels);
+ 		data->band.bitrates = data->rates;
+ 		data->band.n_bitrates = ARRAY_SIZE(hwsim_rates);
+-		data->band.ht_info.ht_supported = 1;
+-		data->band.ht_info.cap = IEEE80211_HT_CAP_SUP_WIDTH |
++		data->band.ht_cap.ht_supported = true;
++		data->band.ht_cap.cap = IEEE80211_HT_CAP_SUP_WIDTH_20_40 |
+ 			IEEE80211_HT_CAP_GRN_FLD |
+ 			IEEE80211_HT_CAP_SGI_40 |
+ 			IEEE80211_HT_CAP_DSSSCCK40;
+-		data->band.ht_info.ampdu_factor = 0x3;
+-		data->band.ht_info.ampdu_density = 0x6;
+-		memset(data->band.ht_info.supp_mcs_set, 0,
+-		       sizeof(data->band.ht_info.supp_mcs_set));
+-		data->band.ht_info.supp_mcs_set[0] = 0xff;
+-		data->band.ht_info.supp_mcs_set[1] = 0xff;
+-		data->band.ht_info.supp_mcs_set[12] =
+-			IEEE80211_HT_CAP_MCS_TX_DEFINED;
++		data->band.ht_cap.ampdu_factor = 0x3;
++		data->band.ht_cap.ampdu_density = 0x6;
++		memset(&data->band.ht_cap.mcs, 0,
++		       sizeof(data->band.ht_cap.mcs));
++		data->band.ht_cap.mcs.rx_mask[0] = 0xff;
++		data->band.ht_cap.mcs.rx_mask[1] = 0xff;
++		data->band.ht_cap.mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED;
+ 		hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &data->band;
+ 
+ 		err = ieee80211_register_hw(hw);
diff --git a/package/mac80211/patches/419-mac80211-remove-antenna-sel.patch b/package/mac80211/patches/419-mac80211-remove-antenna-sel.patch
new file mode 100644
index 0000000000..dbdd64aa23
--- /dev/null
+++ b/package/mac80211/patches/419-mac80211-remove-antenna-sel.patch
@@ -0,0 +1,259 @@
+Subject: mac80211: kill hw.conf.antenna_sel_{rx,tx}
+
+Never actually used.
+
+Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
+---
+ drivers/net/wireless/b43/main.c            |   25 +++----------------------
+ drivers/net/wireless/b43legacy/main.c      |   18 ++----------------
+ drivers/net/wireless/p54/p54common.c       |    3 +--
+ drivers/net/wireless/rt2x00/rt2x00config.c |   20 ++++----------------
+ drivers/net/wireless/rt2x00/rt2x00dev.c    |    6 ++----
+ include/net/mac80211.h                     |    7 +------
+ net/mac80211/debugfs.c                     |    8 --------
+ net/mac80211/ieee80211_i.h                 |    2 --
+ net/mac80211/tx.c                          |    1 -
+ 9 files changed, 13 insertions(+), 77 deletions(-)
+
+--- everything.orig/net/mac80211/debugfs.c	2008-10-08 22:35:20.000000000 +0200
++++ everything/net/mac80211/debugfs.c	2008-10-08 22:35:26.000000000 +0200
+@@ -47,10 +47,6 @@ static const struct file_operations name
+ 
+ DEBUGFS_READONLY_FILE(frequency, 20, "%d",
+ 		      local->hw.conf.channel->center_freq);
+-DEBUGFS_READONLY_FILE(antenna_sel_tx, 20, "%d",
+-		      local->hw.conf.antenna_sel_tx);
+-DEBUGFS_READONLY_FILE(antenna_sel_rx, 20, "%d",
+-		      local->hw.conf.antenna_sel_rx);
+ DEBUGFS_READONLY_FILE(rts_threshold, 20, "%d",
+ 		      local->rts_threshold);
+ DEBUGFS_READONLY_FILE(fragmentation_threshold, 20, "%d",
+@@ -202,8 +198,6 @@ void debugfs_hw_add(struct ieee80211_loc
+ 	local->debugfs.keys = debugfs_create_dir("keys", phyd);
+ 
+ 	DEBUGFS_ADD(frequency);
+-	DEBUGFS_ADD(antenna_sel_tx);
+-	DEBUGFS_ADD(antenna_sel_rx);
+ 	DEBUGFS_ADD(rts_threshold);
+ 	DEBUGFS_ADD(fragmentation_threshold);
+ 	DEBUGFS_ADD(short_retry_limit);
+@@ -258,8 +252,6 @@ void debugfs_hw_add(struct ieee80211_loc
+ void debugfs_hw_del(struct ieee80211_local *local)
+ {
+ 	DEBUGFS_DEL(frequency);
+-	DEBUGFS_DEL(antenna_sel_tx);
+-	DEBUGFS_DEL(antenna_sel_rx);
+ 	DEBUGFS_DEL(rts_threshold);
+ 	DEBUGFS_DEL(fragmentation_threshold);
+ 	DEBUGFS_DEL(short_retry_limit);
+--- everything.orig/net/mac80211/ieee80211_i.h	2008-10-08 22:35:01.000000000 +0200
++++ everything/net/mac80211/ieee80211_i.h	2008-10-08 22:35:10.000000000 +0200
+@@ -727,8 +727,6 @@ struct ieee80211_local {
+ 		struct dentry *rcdir;
+ 		struct dentry *rcname;
+ 		struct dentry *frequency;
+-		struct dentry *antenna_sel_tx;
+-		struct dentry *antenna_sel_rx;
+ 		struct dentry *rts_threshold;
+ 		struct dentry *fragmentation_threshold;
+ 		struct dentry *short_retry_limit;
+--- everything.orig/include/net/mac80211.h	2008-10-08 22:35:30.000000000 +0200
++++ everything/include/net/mac80211.h	2008-10-08 22:39:56.000000000 +0200
+@@ -324,7 +324,7 @@ struct ieee80211_tx_altrate {
+  * @flags: transmit info flags, defined above
+  * @band: TBD
+  * @tx_rate_idx: TBD
+- * @antenna_sel_tx: TBD
++ * @antenna_sel_tx: antenna to use, 0 for automatic diversity
+  * @control: union for control data
+  * @status: union for status data
+  * @driver_data: array of driver_data pointers
+@@ -474,9 +474,6 @@ static inline int __deprecated __IEEE802
+  * @listen_interval: listen interval in units of beacon interval
+  * @flags: configuration flags defined above
+  * @power_level: requested transmit power (in dBm)
+- * @antenna_sel_tx: transmit antenna selection, 0: default/diversity,
+- *	1/2: antenna 0/1
+- * @antenna_sel_rx: receive antenna selection, like @antenna_sel_tx
+  * @ht_cap: describes current self configuration of 802.11n HT capabilities
+  * @ht_bss_conf: describes current BSS configuration of 802.11n HT parameters
+  * @channel: the channel to tune to
+@@ -488,8 +485,6 @@ struct ieee80211_conf {
+ 	u16 listen_interval;
+ 	u32 flags;
+ 	int power_level;
+-	u8 antenna_sel_tx;
+-	u8 antenna_sel_rx;
+ 
+ 	struct ieee80211_channel *channel;
+ 
+--- everything.orig/net/mac80211/tx.c	2008-10-08 22:37:05.000000000 +0200
++++ everything/net/mac80211/tx.c	2008-10-08 22:37:22.000000000 +0200
+@@ -1975,7 +1975,6 @@ struct sk_buff *ieee80211_beacon_get(str
+ 	    sband->bitrates[rsel.rate_idx].flags & IEEE80211_RATE_SHORT_PREAMBLE)
+ 		info->flags |= IEEE80211_TX_CTL_SHORT_PREAMBLE;
+ 
+-	info->antenna_sel_tx = local->hw.conf.antenna_sel_tx;
+ 	info->control.retry_limit = 1;
+ 
+ out:
+--- everything.orig/drivers/net/wireless/b43/main.c	2008-10-08 22:40:06.000000000 +0200
++++ everything/drivers/net/wireless/b43/main.c	2008-10-08 22:40:45.000000000 +0200
+@@ -1339,25 +1339,6 @@ u8 b43_ieee80211_antenna_sanitize(struct
+ 	return antenna_nr;
+ }
+ 
+-static int b43_antenna_from_ieee80211(struct b43_wldev *dev, u8 antenna)
+-{
+-	antenna = b43_ieee80211_antenna_sanitize(dev, antenna);
+-	switch (antenna) {
+-	case 0:		/* default/diversity */
+-		return B43_ANTENNA_DEFAULT;
+-	case 1:		/* Antenna 0 */
+-		return B43_ANTENNA0;
+-	case 2:		/* Antenna 1 */
+-		return B43_ANTENNA1;
+-	case 3:		/* Antenna 2 */
+-		return B43_ANTENNA2;
+-	case 4:		/* Antenna 3 */
+-		return B43_ANTENNA3;
+-	default:
+-		return B43_ANTENNA_DEFAULT;
+-	}
+-}
+-
+ /* Convert a b43 antenna number value to the PHY TX control value. */
+ static u16 b43_antenna_to_phyctl(int antenna)
+ {
+@@ -1399,7 +1380,7 @@ static void b43_write_beacon_template(st
+ 				  len, ram_offset, shm_size_offset, rate);
+ 
+ 	/* Write the PHY TX control parameters. */
+-	antenna = b43_antenna_from_ieee80211(dev, info->antenna_sel_tx);
++	antenna = B43_ANTENNA_DEFAULT;
+ 	antenna = b43_antenna_to_phyctl(antenna);
+ 	ctl = b43_shm_read16(dev, B43_SHM_SHARED, B43_SHM_SH_BEACPHYCTL);
+ 	/* We can't send beacons with short preamble. Would get PHY errors. */
+@@ -3399,9 +3380,9 @@ static int b43_op_config(struct ieee8021
+ 	}
+ 
+ 	/* Antennas for RX and management frame TX. */
+-	antenna = b43_antenna_from_ieee80211(dev, conf->antenna_sel_tx);
++	antenna = B43_ANTENNA_DEFAULT;
+ 	b43_mgmtframe_txantenna(dev, antenna);
+-	antenna = b43_antenna_from_ieee80211(dev, conf->antenna_sel_rx);
++	antenna = B43_ANTENNA_DEFAULT;
+ 	if (phy->ops->set_rx_antenna)
+ 		phy->ops->set_rx_antenna(dev, antenna);
+ 
+--- everything.orig/drivers/net/wireless/b43legacy/main.c	2008-10-08 22:41:36.000000000 +0200
++++ everything/drivers/net/wireless/b43legacy/main.c	2008-10-08 22:41:59.000000000 +0200
+@@ -2556,20 +2556,6 @@ init_failure:
+ 	return err;
+ }
+ 
+-static int b43legacy_antenna_from_ieee80211(u8 antenna)
+-{
+-	switch (antenna) {
+-	case 0: /* default/diversity */
+-		return B43legacy_ANTENNA_DEFAULT;
+-	case 1: /* Antenna 0 */
+-		return B43legacy_ANTENNA0;
+-	case 2: /* Antenna 1 */
+-		return B43legacy_ANTENNA1;
+-	default:
+-		return B43legacy_ANTENNA_DEFAULT;
+-	}
+-}
+-
+ static int b43legacy_op_dev_config(struct ieee80211_hw *hw,
+ 				   struct ieee80211_conf *conf)
+ {
+@@ -2583,8 +2569,8 @@ static int b43legacy_op_dev_config(struc
+ 	int err = 0;
+ 	u32 savedirqs;
+ 
+-	antenna_tx = b43legacy_antenna_from_ieee80211(conf->antenna_sel_tx);
+-	antenna_rx = b43legacy_antenna_from_ieee80211(conf->antenna_sel_rx);
++	antenna_tx = B43legacy_ANTENNA_DEFAULT;
++	antenna_rx = B43legacy_ANTENNA_DEFAULT;
+ 
+ 	mutex_lock(&wl->mutex);
+ 	dev = wl->current_dev;
+--- everything.orig/drivers/net/wireless/p54/p54common.c	2008-10-08 22:43:54.000000000 +0200
++++ everything/drivers/net/wireless/p54/p54common.c	2008-10-08 22:44:12.000000000 +0200
+@@ -1211,8 +1211,7 @@ static int p54_config(struct ieee80211_h
+ 	struct p54_common *priv = dev->priv;
+ 
+ 	mutex_lock(&priv->conf_mutex);
+-	priv->rx_antenna = (conf->antenna_sel_rx == 0) ?
+-		2 : conf->antenna_sel_tx - 1;
++	priv->rx_antenna = 2; /* automatic */
+ 	priv->output_power = conf->power_level << 2;
+ 	ret = p54_set_freq(dev, cpu_to_le16(conf->channel->center_freq));
+ 	p54_set_vdcf(dev);
+--- everything.orig/drivers/net/wireless/rt2x00/rt2x00config.c	2008-10-08 22:44:57.000000000 +0200
++++ everything/drivers/net/wireless/rt2x00/rt2x00config.c	2008-10-08 22:45:36.000000000 +0200
+@@ -199,23 +199,15 @@ void rt2x00lib_config(struct rt2x00_dev 
+ 	 * to work with untill the link tuner decides that an antenna
+ 	 * switch should be performed.
+ 	 */
+-	if (!conf->antenna_sel_rx &&
+-	    default_ant->rx != ANTENNA_SW_DIVERSITY &&
++	if (default_ant->rx != ANTENNA_SW_DIVERSITY &&
+ 	    default_ant->rx != active_ant->rx)
+ 		flags |= CONFIG_UPDATE_ANTENNA;
+-	else if (conf->antenna_sel_rx &&
+-		 conf->antenna_sel_rx != active_ant->rx)
+-		flags |= CONFIG_UPDATE_ANTENNA;
+ 	else if (active_ant->rx == ANTENNA_SW_DIVERSITY)
+ 		flags |= CONFIG_UPDATE_ANTENNA;
+ 
+-	if (!conf->antenna_sel_tx &&
+-	    default_ant->tx != ANTENNA_SW_DIVERSITY &&
++	if (default_ant->tx != ANTENNA_SW_DIVERSITY &&
+ 	    default_ant->tx != active_ant->tx)
+ 		flags |= CONFIG_UPDATE_ANTENNA;
+-	else if (conf->antenna_sel_tx &&
+-		 conf->antenna_sel_tx != active_ant->tx)
+-		flags |= CONFIG_UPDATE_ANTENNA;
+ 	else if (active_ant->tx == ANTENNA_SW_DIVERSITY)
+ 		flags |= CONFIG_UPDATE_ANTENNA;
+ 
+@@ -252,18 +244,14 @@ config:
+ 	}
+ 
+ 	if (flags & CONFIG_UPDATE_ANTENNA) {
+-		if (conf->antenna_sel_rx)
+-			libconf.ant.rx = conf->antenna_sel_rx;
+-		else if (default_ant->rx != ANTENNA_SW_DIVERSITY)
++		if (default_ant->rx != ANTENNA_SW_DIVERSITY)
+ 			libconf.ant.rx = default_ant->rx;
+ 		else if (active_ant->rx == ANTENNA_SW_DIVERSITY)
+ 			libconf.ant.rx = ANTENNA_B;
+ 		else
+ 			libconf.ant.rx = active_ant->rx;
+ 
+-		if (conf->antenna_sel_tx)
+-			libconf.ant.tx = conf->antenna_sel_tx;
+-		else if (default_ant->tx != ANTENNA_SW_DIVERSITY)
++		if (default_ant->tx != ANTENNA_SW_DIVERSITY)
+ 			libconf.ant.tx = default_ant->tx;
+ 		else if (active_ant->tx == ANTENNA_SW_DIVERSITY)
+ 			libconf.ant.tx = ANTENNA_B;
+--- everything.orig/drivers/net/wireless/rt2x00/rt2x00dev.c	2008-10-08 22:44:28.000000000 +0200
++++ everything/drivers/net/wireless/rt2x00/rt2x00dev.c	2008-10-08 22:44:43.000000000 +0200
+@@ -249,11 +249,9 @@ static void rt2x00lib_evaluate_antenna(s
+ 	rt2x00dev->link.ant.flags &= ~ANTENNA_RX_DIVERSITY;
+ 	rt2x00dev->link.ant.flags &= ~ANTENNA_TX_DIVERSITY;
+ 
+-	if (rt2x00dev->hw->conf.antenna_sel_rx == 0 &&
+-	    rt2x00dev->default_ant.rx == ANTENNA_SW_DIVERSITY)
++	if (rt2x00dev->default_ant.rx == ANTENNA_SW_DIVERSITY)
+ 		rt2x00dev->link.ant.flags |= ANTENNA_RX_DIVERSITY;
+-	if (rt2x00dev->hw->conf.antenna_sel_tx == 0 &&
+-	    rt2x00dev->default_ant.tx == ANTENNA_SW_DIVERSITY)
++	if (rt2x00dev->default_ant.tx == ANTENNA_SW_DIVERSITY)
+ 		rt2x00dev->link.ant.flags |= ANTENNA_TX_DIVERSITY;
+ 
+ 	if (!(rt2x00dev->link.ant.flags & ANTENNA_RX_DIVERSITY) &&
diff --git a/package/mac80211/patches/420-mac80211-hw-conf-change-flags.patch b/package/mac80211/patches/420-mac80211-hw-conf-change-flags.patch
new file mode 100644
index 0000000000..4bae8cbb59
--- /dev/null
+++ b/package/mac80211/patches/420-mac80211-hw-conf-change-flags.patch
@@ -0,0 +1,616 @@
+Subject: mac80211: introduce hw config change flags
+
+This makes mac80211 notify the driver which configuration
+actually changed, e.g. channel etc.
+
+No driver changes, this is just plumbing, driver authors are
+expected to act on this if they want to.
+
+Also remove the HW CONFIG debug printk, it's incorrect, often
+we configure something else.
+
+Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
+---
+ drivers/net/wireless/adm8211.c              |    3 +-
+ drivers/net/wireless/at76_usb.c             |    3 +-
+ drivers/net/wireless/ath5k/base.c           |    7 ++----
+ drivers/net/wireless/ath9k/main.c           |    4 +--
+ drivers/net/wireless/b43/main.c             |    3 +-
+ drivers/net/wireless/b43legacy/main.c       |    3 +-
+ drivers/net/wireless/iwlwifi/iwl-agn.c      |    3 +-
+ drivers/net/wireless/iwlwifi/iwl3945-base.c |    7 +++---
+ drivers/net/wireless/libertas_tf/main.c     |    4 ++-
+ drivers/net/wireless/mac80211_hwsim.c       |    4 +--
+ drivers/net/wireless/p54/p54common.c        |    3 +-
+ drivers/net/wireless/rt2x00/rt2x00.h        |    2 -
+ drivers/net/wireless/rt2x00/rt2x00dev.c     |    2 -
+ drivers/net/wireless/rt2x00/rt2x00mac.c     |    3 +-
+ drivers/net/wireless/rtl8180_dev.c          |    3 +-
+ drivers/net/wireless/rtl8187_dev.c          |    3 +-
+ drivers/net/wireless/zd1211rw/zd_mac.c      |    4 ++-
+ include/net/mac80211.h                      |   30 +++++++++++++++++++++++-----
+ net/mac80211/cfg.c                          |    3 +-
+ net/mac80211/ieee80211_i.h                  |    2 -
+ net/mac80211/iface.c                        |   25 +++++++++++++++++------
+ net/mac80211/main.c                         |   29 ++++++++++++++-------------
+ net/mac80211/scan.c                         |   12 ++++++++---
+ net/mac80211/util.c                         |    3 +-
+ net/mac80211/wext.c                         |   14 ++++++-------
+ 25 files changed, 118 insertions(+), 61 deletions(-)
+
+--- a/include/net/mac80211.h
++++ b/include/net/mac80211.h
+@@ -464,12 +464,32 @@ static inline int __deprecated __IEEE802
+ #define IEEE80211_CONF_SHORT_SLOT_TIME (__IEEE80211_CONF_SHORT_SLOT_TIME())
+ 
+ /**
++ * enum ieee80211_conf_changed - denotes which configuration changed
++ *
++ * @IEEE80211_CONF_CHANGE_RADIO_ENABLED: the value of radio_enabled changed
++ * @IEEE80211_CONF_CHANGE_BEACON_INTERVAL: the beacon interval changed
++ * @IEEE80211_CONF_CHANGE_LISTEN_INTERVAL: the listen interval changed
++ * @IEEE80211_CONF_CHANGE_RADIOTAP: the radiotap flag changed
++ * @IEEE80211_CONF_CHANGE_PS: the PS flag changed
++ * @IEEE80211_CONF_CHANGE_POWER: the TX power changed
++ * @IEEE80211_CONF_CHANGE_CHANNEL: the channel changed
++ */
++enum ieee80211_conf_changed {
++	IEEE80211_CONF_CHANGE_RADIO_ENABLED	= BIT(0),
++	IEEE80211_CONF_CHANGE_BEACON_INTERVAL	= BIT(1),
++	IEEE80211_CONF_CHANGE_LISTEN_INTERVAL	= BIT(2),
++	IEEE80211_CONF_CHANGE_RADIOTAP		= BIT(3),
++	IEEE80211_CONF_CHANGE_PS		= BIT(4),
++	IEEE80211_CONF_CHANGE_POWER		= BIT(5),
++	IEEE80211_CONF_CHANGE_CHANNEL		= BIT(6),
++};
++
++/**
+  * struct ieee80211_conf - configuration of the device
+  *
+  * This struct indicates how the driver shall configure the hardware.
+  *
+  * @radio_enabled: when zero, driver is required to switch off the radio.
+- *	TODO make a flag
+  * @beacon_int: beacon interval (TODO make interface config)
+  * @listen_interval: listen interval in units of beacon interval
+  * @flags: configuration flags defined above
+@@ -479,13 +499,13 @@ static inline int __deprecated __IEEE802
+  * @channel: the channel to tune to
+  */
+ struct ieee80211_conf {
+-	int radio_enabled;
+-
+ 	int beacon_int;
+-	u16 listen_interval;
+ 	u32 flags;
+ 	int power_level;
+ 
++	u16 listen_interval;
++	bool radio_enabled;
++
+ 	struct ieee80211_channel *channel;
+ 
+ 	struct ieee80211_sta_ht_cap ht_cap;
+@@ -1213,7 +1233,7 @@ struct ieee80211_ops {
+ 			     struct ieee80211_if_init_conf *conf);
+ 	void (*remove_interface)(struct ieee80211_hw *hw,
+ 				 struct ieee80211_if_init_conf *conf);
+-	int (*config)(struct ieee80211_hw *hw, struct ieee80211_conf *conf);
++	int (*config)(struct ieee80211_hw *hw, u32 changed);
+ 	int (*config_interface)(struct ieee80211_hw *hw,
+ 				struct ieee80211_vif *vif,
+ 				struct ieee80211_if_conf *conf);
+--- a/net/mac80211/cfg.c
++++ b/net/mac80211/cfg.c
+@@ -394,7 +394,8 @@ static int ieee80211_config_beacon(struc
+ 	 */
+ 	if (params->interval) {
+ 		sdata->local->hw.conf.beacon_int = params->interval;
+-		ieee80211_hw_config(sdata->local);
++		ieee80211_hw_config(sdata->local,
++				    IEEE80211_CONF_CHANGE_BEACON_INTERVAL);
+ 		/*
+ 		 * We updated some parameter so if below bails out
+ 		 * it's not an error.
+--- a/net/mac80211/ieee80211_i.h
++++ b/net/mac80211/ieee80211_i.h
+@@ -880,7 +880,7 @@ static inline int ieee80211_bssid_match(
+ }
+ 
+ 
+-int ieee80211_hw_config(struct ieee80211_local *local);
++int ieee80211_hw_config(struct ieee80211_local *local, u32 changed);
+ int ieee80211_if_config(struct ieee80211_sub_if_data *sdata, u32 changed);
+ void ieee80211_tx_set_protected(struct ieee80211_tx_data *tx);
+ void ieee80211_bss_info_change_notify(struct ieee80211_sub_if_data *sdata,
+--- a/net/mac80211/iface.c
++++ b/net/mac80211/iface.c
+@@ -65,7 +65,7 @@ static int ieee80211_open(struct net_dev
+ 	struct ieee80211_if_init_conf conf;
+ 	u32 changed = 0;
+ 	int res;
+-	bool need_hw_reconfig = 0;
++	u32 hw_reconf_flags = 0;
+ 	u8 null_addr[ETH_ALEN] = {0};
+ 
+ 	/* fail early if user set an invalid address */
+@@ -152,7 +152,8 @@ static int ieee80211_open(struct net_dev
+ 			res = local->ops->start(local_to_hw(local));
+ 		if (res)
+ 			goto err_del_bss;
+-		need_hw_reconfig = 1;
++		/* we're brought up, everything changes */
++		hw_reconf_flags = ~0;
+ 		ieee80211_led_radio(local, local->hw.conf.radio_enabled);
+ 	}
+ 
+@@ -198,8 +199,10 @@ static int ieee80211_open(struct net_dev
+ 
+ 		/* must be before the call to ieee80211_configure_filter */
+ 		local->monitors++;
+-		if (local->monitors == 1)
++		if (local->monitors == 1) {
+ 			local->hw.conf.flags |= IEEE80211_CONF_RADIOTAP;
++			hw_reconf_flags |= IEEE80211_CONF_CHANGE_RADIOTAP;
++		}
+ 
+ 		if (sdata->u.mntr_flags & MONITOR_FLAG_FCSFAIL)
+ 			local->fif_fcsfail++;
+@@ -279,8 +282,8 @@ static int ieee80211_open(struct net_dev
+ 		atomic_inc(&local->iff_promiscs);
+ 
+ 	local->open_count++;
+-	if (need_hw_reconfig) {
+-		ieee80211_hw_config(local);
++	if (hw_reconf_flags) {
++		ieee80211_hw_config(local, hw_reconf_flags);
+ 		/*
+ 		 * set default queue parameters so drivers don't
+ 		 * need to initialise the hardware if the hardware
+@@ -322,6 +325,7 @@ static int ieee80211_stop(struct net_dev
+ 	struct ieee80211_local *local = sdata->local;
+ 	struct ieee80211_if_init_conf conf;
+ 	struct sta_info *sta;
++	u32 hw_reconf_flags = 0;
+ 
+ 	/*
+ 	 * Stop TX on this interface first.
+@@ -405,8 +409,10 @@ static int ieee80211_stop(struct net_dev
+ 		}
+ 
+ 		local->monitors--;
+-		if (local->monitors == 0)
++		if (local->monitors == 0) {
+ 			local->hw.conf.flags &= ~IEEE80211_CONF_RADIOTAP;
++			hw_reconf_flags |= IEEE80211_CONF_CHANGE_RADIOTAP;
++		}
+ 
+ 		if (sdata->u.mntr_flags & MONITOR_FLAG_FCSFAIL)
+ 			local->fif_fcsfail--;
+@@ -504,8 +510,15 @@ static int ieee80211_stop(struct net_dev
+ 
+ 		tasklet_disable(&local->tx_pending_tasklet);
+ 		tasklet_disable(&local->tasklet);
++
++		/* no reconfiguring after stop! */
++		hw_reconf_flags = 0;
+ 	}
+ 
++	/* do after stop to avoid reconfiguring when we stop anyway */
++	if (hw_reconf_flags)
++		ieee80211_hw_config(local, hw_reconf_flags);
++
+ 	return 0;
+ }
+ 
+--- a/net/mac80211/main.c
++++ b/net/mac80211/main.c
+@@ -197,31 +197,34 @@ int ieee80211_if_config(struct ieee80211
+ 					    &sdata->vif, &conf);
+ }
+ 
+-int ieee80211_hw_config(struct ieee80211_local *local)
++int ieee80211_hw_config(struct ieee80211_local *local, u32 changed)
+ {
+ 	struct ieee80211_channel *chan;
+ 	int ret = 0;
++	int power;
+ 
+ 	if (local->sw_scanning)
+ 		chan = local->scan_channel;
+ 	else
+ 		chan = local->oper_channel;
+ 
+-	local->hw.conf.channel = chan;
++	if (chan != local->hw.conf.channel) {
++		local->hw.conf.channel = chan;
++		changed |= IEEE80211_CONF_CHANGE_CHANNEL;
++	}
++
+ 
+ 	if (!local->hw.conf.power_level)
+-		local->hw.conf.power_level = chan->max_power;
++		power = chan->max_power;
+ 	else
+-		local->hw.conf.power_level = min(chan->max_power,
+-					       local->hw.conf.power_level);
+-
+-#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
+-	printk(KERN_DEBUG "%s: HW CONFIG: freq=%d\n",
+-	       wiphy_name(local->hw.wiphy), chan->center_freq);
+-#endif
++		power = min(chan->max_power, local->hw.conf.power_level);
++	if (local->hw.conf.power_level != power) {
++		changed |= IEEE80211_CONF_CHANGE_POWER;
++		local->hw.conf.power_level = power;
++	}
+ 
+-	if (local->open_count) {
+-		ret = local->ops->config(local_to_hw(local), &local->hw.conf);
++	if (changed && local->open_count) {
++		ret = local->ops->config(local_to_hw(local), changed);
+ 		/*
+ 		 * HW reconfiguration should never fail, the driver has told
+ 		 * us what it can support so it should live up to that promise.
+@@ -672,7 +675,7 @@ struct ieee80211_hw *ieee80211_alloc_hw(
+ 	local->fragmentation_threshold = IEEE80211_MAX_FRAG_THRESHOLD;
+ 	local->short_retry_limit = 7;
+ 	local->long_retry_limit = 4;
+-	local->hw.conf.radio_enabled = 1;
++	local->hw.conf.radio_enabled = true;
+ 
+ 	INIT_LIST_HEAD(&local->interfaces);
+ 
+--- a/net/mac80211/scan.c
++++ b/net/mac80211/scan.c
+@@ -447,12 +447,17 @@ void ieee80211_scan_completed(struct iee
+ 
+ 	if (local->hw_scanning) {
+ 		local->hw_scanning = false;
+-		ieee80211_hw_config(local);
++		/*
++		 * Somebody might have requested channel change during scan
++		 * that we won't have acted upon, try now. ieee80211_hw_config
++		 * will set the flag based on actual changes.
++		 */
++		ieee80211_hw_config(local, 0);
+ 		goto done;
+ 	}
+ 
+ 	local->sw_scanning = false;
+-	ieee80211_hw_config(local);
++	ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_CHANNEL);
+ 
+ 	netif_tx_lock_bh(local->mdev);
+ 	netif_addr_lock(local->mdev);
+@@ -539,7 +544,8 @@ void ieee80211_scan_work(struct work_str
+ 
+ 		if (!skip) {
+ 			local->scan_channel = chan;
+-			if (ieee80211_hw_config(local))
++			if (ieee80211_hw_config(local,
++						IEEE80211_CONF_CHANGE_CHANNEL))
+ 				skip = 1;
+ 		}
+ 
+--- a/net/mac80211/util.c
++++ b/net/mac80211/util.c
+@@ -645,7 +645,8 @@ int ieee80211_set_freq(struct ieee80211_
+ 		if (local->sw_scanning || local->hw_scanning)
+ 			ret = 0;
+ 		else
+-			ret = ieee80211_hw_config(local);
++			ret = ieee80211_hw_config(
++				local, IEEE80211_CONF_CHANGE_CHANNEL);
+ 
+ 		rate_control_clear(local);
+ 	}
+--- a/net/mac80211/wext.c
++++ b/net/mac80211/wext.c
+@@ -656,7 +656,7 @@ static int ieee80211_ioctl_siwtxpower(st
+ 				      union iwreq_data *data, char *extra)
+ {
+ 	struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
+-	bool need_reconfig = 0;
++	u32 reconf_flags = 0;
+ 	int new_power_level;
+ 
+ 	if ((data->txpower.flags & IW_TXPOW_TYPE) != IW_TXPOW_DBM)
+@@ -680,17 +680,17 @@ static int ieee80211_ioctl_siwtxpower(st
+ 
+ 	if (local->hw.conf.power_level != new_power_level) {
+ 		local->hw.conf.power_level = new_power_level;
+-		need_reconfig = 1;
++		reconf_flags |= IEEE80211_CONF_CHANGE_POWER;
+ 	}
+ 
+ 	if (local->hw.conf.radio_enabled != !(data->txpower.disabled)) {
+ 		local->hw.conf.radio_enabled = !(data->txpower.disabled);
+-		need_reconfig = 1;
++		reconf_flags |= IEEE80211_CONF_CHANGE_RADIO_ENABLED;
+ 		ieee80211_led_radio(local, local->hw.conf.radio_enabled);
+ 	}
+ 
+-	if (need_reconfig)
+-		ieee80211_hw_config(local);
++	if (reconf_flags)
++		ieee80211_hw_config(local, reconf_flags);
+ 
+ 	return 0;
+ }
+@@ -976,7 +976,7 @@ static int ieee80211_ioctl_siwpower(stru
+ 
+ 	if (wrq->disabled) {
+ 		conf->flags &= ~IEEE80211_CONF_PS;
+-		return ieee80211_hw_config(local);
++		return ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
+ 	}
+ 
+ 	switch (wrq->flags & IW_POWER_MODE) {
+@@ -989,7 +989,7 @@ static int ieee80211_ioctl_siwpower(stru
+ 		return -EINVAL;
+ 	}
+ 
+-	return ieee80211_hw_config(local);
++	return ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
+ }
+ 
+ static int ieee80211_ioctl_giwpower(struct net_device *dev,
+--- a/drivers/net/wireless/adm8211.c
++++ b/drivers/net/wireless/adm8211.c
+@@ -1314,9 +1314,10 @@ static int adm8211_set_ssid(struct ieee8
+ 	return 0;
+ }
+ 
+-static int adm8211_config(struct ieee80211_hw *dev, struct ieee80211_conf *conf)
++static int adm8211_config(struct ieee80211_hw *dev, u32 changed)
+ {
+ 	struct adm8211_priv *priv = dev->priv;
++	struct ieee80211_conf *conf = &dev->conf;
+ 	int channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
+ 
+ 	if (channel != priv->channel) {
+--- a/drivers/net/wireless/at76_usb.c
++++ b/drivers/net/wireless/at76_usb.c
+@@ -2057,9 +2057,10 @@ exit:
+ 	return 0;
+ }
+ 
+-static int at76_config(struct ieee80211_hw *hw, struct ieee80211_conf *conf)
++static int at76_config(struct ieee80211_hw *hw, u32 changed)
+ {
+ 	struct at76_priv *priv = hw->priv;
++	struct ieee80211_conf *conf = &hw->conf;
+ 
+ 	at76_dbg(DBG_MAC80211, "%s(): channel %d radio %d",
+ 		 __func__, conf->channel->hw_value, conf->radio_enabled);
+--- a/drivers/net/wireless/ath5k/base.c
++++ b/drivers/net/wireless/ath5k/base.c
+@@ -219,8 +219,7 @@ static int ath5k_add_interface(struct ie
+ 		struct ieee80211_if_init_conf *conf);
+ static void ath5k_remove_interface(struct ieee80211_hw *hw,
+ 		struct ieee80211_if_init_conf *conf);
+-static int ath5k_config(struct ieee80211_hw *hw,
+-		struct ieee80211_conf *conf);
++static int ath5k_config(struct ieee80211_hw *hw, u32 changed);
+ static int ath5k_config_interface(struct ieee80211_hw *hw,
+ 		struct ieee80211_vif *vif,
+ 		struct ieee80211_if_conf *conf);
+@@ -2767,10 +2766,10 @@ end:
+  * TODO: Phy disable/diversity etc
+  */
+ static int
+-ath5k_config(struct ieee80211_hw *hw,
+-			struct ieee80211_conf *conf)
++ath5k_config(struct ieee80211_hw *hw, u32 changed)
+ {
+ 	struct ath5k_softc *sc = hw->priv;
++	struct ieee80211_conf *conf = &hw->conf;
+ 
+ 	sc->bintval = conf->beacon_int;
+ 	sc->power_level = conf->power_level;
+--- a/drivers/net/wireless/ath9k/main.c
++++ b/drivers/net/wireless/ath9k/main.c
+@@ -1231,11 +1231,11 @@ static void ath9k_remove_interface(struc
+ 			__func__, error);
+ }
+ 
+-static int ath9k_config(struct ieee80211_hw *hw,
+-			struct ieee80211_conf *conf)
++static int ath9k_config(struct ieee80211_hw *hw, u32 changed)
+ {
+ 	struct ath_softc *sc = hw->priv;
+ 	struct ieee80211_channel *curchan = hw->conf.channel;
++	struct ieee80211_conf *conf = &hw->conf;
+ 	int pos;
+ 
+ 	DPRINTF(sc, ATH_DBG_CONFIG, "%s: Set channel: %d MHz\n",
+--- a/drivers/net/wireless/b43/main.c
++++ b/drivers/net/wireless/b43/main.c
+@@ -3320,11 +3320,12 @@ init_failure:
+ 	return err;
+ }
+ 
+-static int b43_op_config(struct ieee80211_hw *hw, struct ieee80211_conf *conf)
++static int b43_op_config(struct ieee80211_hw *hw, u32 changed)
+ {
+ 	struct b43_wl *wl = hw_to_b43_wl(hw);
+ 	struct b43_wldev *dev;
+ 	struct b43_phy *phy;
++	struct ieee80211_conf *conf = &hw->conf;
+ 	unsigned long flags;
+ 	int antenna;
+ 	int err = 0;
+--- a/drivers/net/wireless/b43legacy/main.c
++++ b/drivers/net/wireless/b43legacy/main.c
+@@ -2557,11 +2557,12 @@ init_failure:
+ }
+ 
+ static int b43legacy_op_dev_config(struct ieee80211_hw *hw,
+-				   struct ieee80211_conf *conf)
++				   u32 changed)
+ {
+ 	struct b43legacy_wl *wl = hw_to_b43legacy_wl(hw);
+ 	struct b43legacy_wldev *dev;
+ 	struct b43legacy_phy *phy;
++	struct ieee80211_conf *conf = &hw->conf;
+ 	unsigned long flags;
+ 	unsigned int new_phymode = 0xFFFF;
+ 	int antenna_tx;
+--- a/drivers/net/wireless/iwlwifi/iwl-agn.c
++++ b/drivers/net/wireless/iwlwifi/iwl-agn.c
+@@ -2760,10 +2760,11 @@ static int iwl4965_mac_add_interface(str
+  * be set inappropriately and the driver currently sets the hardware up to
+  * use it whenever needed.
+  */
+-static int iwl4965_mac_config(struct ieee80211_hw *hw, struct ieee80211_conf *conf)
++static int iwl4965_mac_config(struct ieee80211_hw *hw, u32 changed)
+ {
+ 	struct iwl_priv *priv = hw->priv;
+ 	const struct iwl_channel_info *ch_info;
++	struct ieee80211_conf *conf = &hw->conf;
+ 	unsigned long flags;
+ 	int ret = 0;
+ 	u16 channel;
+--- a/drivers/net/wireless/iwlwifi/iwl3945-base.c
++++ b/drivers/net/wireless/iwlwifi/iwl3945-base.c
+@@ -6427,7 +6427,7 @@ static void iwl3945_bg_abort_scan(struct
+ 	mutex_unlock(&priv->mutex);
+ }
+ 
+-static int iwl3945_mac_config(struct ieee80211_hw *hw, struct ieee80211_conf *conf);
++static int iwl3945_mac_config(struct ieee80211_hw *hw, u32 changed);
+ 
+ static void iwl3945_bg_scan_completed(struct work_struct *work)
+ {
+@@ -6440,7 +6440,7 @@ static void iwl3945_bg_scan_completed(st
+ 		return;
+ 
+ 	if (test_bit(STATUS_CONF_PENDING, &priv->status))
+-		iwl3945_mac_config(priv->hw, ieee80211_get_hw_conf(priv->hw));
++		iwl3945_mac_config(priv->hw, 0);
+ 
+ 	ieee80211_scan_completed(priv->hw);
+ 
+@@ -6629,10 +6629,11 @@ static int iwl3945_mac_add_interface(str
+  * be set inappropriately and the driver currently sets the hardware up to
+  * use it whenever needed.
+  */
+-static int iwl3945_mac_config(struct ieee80211_hw *hw, struct ieee80211_conf *conf)
++static int iwl3945_mac_config(struct ieee80211_hw *hw, u32 changed)
+ {
+ 	struct iwl3945_priv *priv = hw->priv;
+ 	const struct iwl3945_channel_info *ch_info;
++	struct ieee80211_conf *conf = &hw->conf;
+ 	unsigned long flags;
+ 	int ret = 0;
+ 
+--- a/drivers/net/wireless/mac80211_hwsim.c
++++ b/drivers/net/wireless/mac80211_hwsim.c
+@@ -361,10 +361,10 @@ static void mac80211_hwsim_beacon(unsign
+ }
+ 
+ 
+-static int mac80211_hwsim_config(struct ieee80211_hw *hw,
+-				 struct ieee80211_conf *conf)
++static int mac80211_hwsim_config(struct ieee80211_hw *hw, u32 changed)
+ {
+ 	struct mac80211_hwsim_data *data = hw->priv;
++	struct ieee80211_conf *conf = &hw->conf;
+ 
+ 	printk(KERN_DEBUG "%s:%s (freq=%d radio_enabled=%d beacon_int=%d)\n",
+ 	       wiphy_name(hw->wiphy), __func__,
+--- a/drivers/net/wireless/p54/p54common.c
++++ b/drivers/net/wireless/p54/p54common.c
+@@ -1205,10 +1205,11 @@ static void p54_remove_interface(struct 
+ 	p54_set_filter(dev, 0, NULL);
+ }
+ 
+-static int p54_config(struct ieee80211_hw *dev, struct ieee80211_conf *conf)
++static int p54_config(struct ieee80211_hw *dev, u32 changed)
+ {
+ 	int ret;
+ 	struct p54_common *priv = dev->priv;
++	struct ieee80211_conf *conf = &dev->conf;
+ 
+ 	mutex_lock(&priv->conf_mutex);
+ 	priv->rx_antenna = 2; /* automatic */
+--- a/drivers/net/wireless/rt2x00/rt2x00.h
++++ b/drivers/net/wireless/rt2x00/rt2x00.h
+@@ -997,7 +997,7 @@ int rt2x00mac_add_interface(struct ieee8
+ 			    struct ieee80211_if_init_conf *conf);
+ void rt2x00mac_remove_interface(struct ieee80211_hw *hw,
+ 				struct ieee80211_if_init_conf *conf);
+-int rt2x00mac_config(struct ieee80211_hw *hw, struct ieee80211_conf *conf);
++int rt2x00mac_config(struct ieee80211_hw *hw, u32 changed);
+ int rt2x00mac_config_interface(struct ieee80211_hw *hw,
+ 			       struct ieee80211_vif *vif,
+ 			       struct ieee80211_if_conf *conf);
+--- a/drivers/net/wireless/rt2x00/rt2x00mac.c
++++ b/drivers/net/wireless/rt2x00/rt2x00mac.c
+@@ -335,9 +335,10 @@ void rt2x00mac_remove_interface(struct i
+ }
+ EXPORT_SYMBOL_GPL(rt2x00mac_remove_interface);
+ 
+-int rt2x00mac_config(struct ieee80211_hw *hw, struct ieee80211_conf *conf)
++int rt2x00mac_config(struct ieee80211_hw *hw, u32 changed)
+ {
+ 	struct rt2x00_dev *rt2x00dev = hw->priv;
++	struct ieee80211_conf *conf = &hw->conf;
+ 	int radio_on;
+ 	int status;
+ 
+--- a/drivers/net/wireless/rtl8180_dev.c
++++ b/drivers/net/wireless/rtl8180_dev.c
+@@ -692,9 +692,10 @@ static void rtl8180_remove_interface(str
+ 	priv->vif = NULL;
+ }
+ 
+-static int rtl8180_config(struct ieee80211_hw *dev, struct ieee80211_conf *conf)
++static int rtl8180_config(struct ieee80211_hw *dev, u32 changed)
+ {
+ 	struct rtl8180_priv *priv = dev->priv;
++	struct ieee80211_conf *conf = &dev->conf;
+ 
+ 	priv->rf->set_chan(dev, conf);
+ 
+--- a/drivers/net/wireless/rtl8187_dev.c
++++ b/drivers/net/wireless/rtl8187_dev.c
+@@ -870,9 +870,10 @@ static void rtl8187_remove_interface(str
+ 	mutex_unlock(&priv->conf_mutex);
+ }
+ 
+-static int rtl8187_config(struct ieee80211_hw *dev, struct ieee80211_conf *conf)
++static int rtl8187_config(struct ieee80211_hw *dev, u32 changed)
+ {
+ 	struct rtl8187_priv *priv = dev->priv;
++	struct ieee80211_conf *conf = &dev->conf;
+ 	u32 reg;
+ 
+ 	mutex_lock(&priv->conf_mutex);
+--- a/drivers/net/wireless/zd1211rw/zd_mac.c
++++ b/drivers/net/wireless/zd1211rw/zd_mac.c
+@@ -743,9 +743,11 @@ static void zd_op_remove_interface(struc
+ 	zd_write_mac_addr(&mac->chip, NULL);
+ }
+ 
+-static int zd_op_config(struct ieee80211_hw *hw, struct ieee80211_conf *conf)
++static int zd_op_config(struct ieee80211_hw *hw, u32 changed)
+ {
+ 	struct zd_mac *mac = zd_hw_mac(hw);
++	struct ieee80211_conf *conf = &hw->conf;
++
+ 	return zd_chip_set_channel(&mac->chip, conf->channel->hw_value);
+ }
+ 
+--- a/drivers/net/wireless/rt2x00/rt2x00dev.c
++++ b/drivers/net/wireless/rt2x00/rt2x00dev.c
+@@ -1245,7 +1245,7 @@ int rt2x00lib_resume(struct rt2x00_dev *
+ 	/*
+ 	 * Reconfigure device.
+ 	 */
+-	retval = rt2x00mac_config(rt2x00dev->hw, &rt2x00dev->hw->conf);
++	retval = rt2x00mac_config(rt2x00dev->hw, ~0);
+ 	if (retval)
+ 		goto exit;
+ 
diff --git a/package/mac80211/patches/421-nl80211-export-ht.patch b/package/mac80211/patches/421-nl80211-export-ht.patch
new file mode 100644
index 0000000000..d6f6b5a589
--- /dev/null
+++ b/package/mac80211/patches/421-nl80211-export-ht.patch
@@ -0,0 +1,64 @@
+Subject: nl80211: export HT capabilities
+
+This exports the local HT capabilities in nl80211.
+
+Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
+---
+ include/linux/nl80211.h |   12 ++++++++++++
+ net/wireless/nl80211.c  |   13 +++++++++++++
+ 2 files changed, 25 insertions(+)
+
+--- everything.orig/include/linux/nl80211.h	2008-10-09 01:31:09.000000000 +0200
++++ everything/include/linux/nl80211.h	2008-10-09 02:11:44.000000000 +0200
+@@ -452,17 +452,29 @@ enum nl80211_mpath_info {
+  *	an array of nested frequency attributes
+  * @NL80211_BAND_ATTR_RATES: supported bitrates in this band,
+  *	an array of nested bitrate attributes
++ * @NL80211_BAND_ATTR_HT_MCS_SET: 16-byte attribute containing the MCS set as
++ *	defined in 802.11n
++ * @NL80211_BAND_ATTR_HT_CAPA: HT capabilities, as in the HT information IE
++ * @NL80211_BAND_ATTR_HT_AMPDU_FACTOR: A-MPDU factor, as in 11n
++ * @NL80211_BAND_ATTR_HT_AMPDU_DENSITY: A-MPDU density, as in 11n
+  */
+ enum nl80211_band_attr {
+ 	__NL80211_BAND_ATTR_INVALID,
+ 	NL80211_BAND_ATTR_FREQS,
+ 	NL80211_BAND_ATTR_RATES,
+ 
++	NL80211_BAND_ATTR_HT_MCS_SET,
++	NL80211_BAND_ATTR_HT_CAPA,
++	NL80211_BAND_ATTR_HT_AMPDU_FACTOR,
++	NL80211_BAND_ATTR_HT_AMPDU_DENSITY,
++
+ 	/* keep last */
+ 	__NL80211_BAND_ATTR_AFTER_LAST,
+ 	NL80211_BAND_ATTR_MAX = __NL80211_BAND_ATTR_AFTER_LAST - 1
+ };
+ 
++#define NL80211_BAND_ATTR_HT_CAPA NL80211_BAND_ATTR_HT_CAPA
++
+ /**
+  * enum nl80211_frequency_attr - frequency attributes
+  * @NL80211_FREQUENCY_ATTR_FREQ: Frequency in MHz
+--- everything.orig/net/wireless/nl80211.c	2008-10-09 01:32:05.000000000 +0200
++++ everything/net/wireless/nl80211.c	2008-10-09 02:12:21.000000000 +0200
+@@ -157,6 +157,19 @@ static int nl80211_send_wiphy(struct sk_
+ 		if (!nl_band)
+ 			goto nla_put_failure;
+ 
++		/* add HT info */
++		if (dev->wiphy.bands[band]->ht_cap.ht_supported) {
++			NLA_PUT(msg, NL80211_BAND_ATTR_HT_MCS_SET,
++				sizeof(dev->wiphy.bands[band]->ht_cap.mcs),
++				&dev->wiphy.bands[band]->ht_cap.mcs);
++			NLA_PUT_U16(msg, NL80211_BAND_ATTR_HT_CAPA,
++				dev->wiphy.bands[band]->ht_cap.cap);
++			NLA_PUT_U8(msg, NL80211_BAND_ATTR_HT_AMPDU_FACTOR,
++				dev->wiphy.bands[band]->ht_cap.ampdu_factor);
++			NLA_PUT_U8(msg, NL80211_BAND_ATTR_HT_AMPDU_DENSITY,
++				dev->wiphy.bands[band]->ht_cap.ampdu_density);
++		}
++
+ 		/* add frequencies */
+ 		nl_freqs = nla_nest_start(msg, NL80211_BAND_ATTR_FREQS);
+ 		if (!nl_freqs)
diff --git a/package/mac80211/patches/422-mac80211-seqno-station.patch b/package/mac80211/patches/422-mac80211-seqno-station.patch
new file mode 100644
index 0000000000..72fbd9cb70
--- /dev/null
+++ b/package/mac80211/patches/422-mac80211-seqno-station.patch
@@ -0,0 +1,142 @@
+Subject: mac80211: provide sequence numbers
+
+I've come to think that not providing sequence numbers for
+the normal STA mode case was a mistake, at least two drivers
+now had to implement code they wouldn't otherwise need, and
+I believe at76_usb and adm8211 might be broken.
+
+This patch makes mac80211 assign a sequence number to all
+those frames that need one except beacons. That means that
+if a driver only implements modes that do not do beaconing
+it need not worry about the sequence number.
+
+Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
+---
+ drivers/net/wireless/p54/p54.h       |    1 -
+ drivers/net/wireless/p54/p54common.c |   18 +++++-------------
+ drivers/net/wireless/rtl8187.h       |    1 -
+ drivers/net/wireless/rtl8187_dev.c   |   18 ++++--------------
+ net/mac80211/ieee80211_i.h           |    2 ++
+ net/mac80211/tx.c                    |   10 ++++++++++
+ 6 files changed, 21 insertions(+), 29 deletions(-)
+
+--- everything.orig/net/mac80211/ieee80211_i.h	2008-10-10 15:45:52.000000000 +0200
++++ everything/net/mac80211/ieee80211_i.h	2008-10-10 15:45:56.000000000 +0200
+@@ -438,6 +438,8 @@ struct ieee80211_sub_if_data {
+ 	struct ieee80211_key *keys[NUM_DEFAULT_KEYS];
+ 	struct ieee80211_key *default_key;
+ 
++	u16 sequence_number;
++
+ 	/* BSS configuration for this interface. */
+ 	struct ieee80211_bss_conf bss_conf;
+ 
+--- everything.orig/net/mac80211/tx.c	2008-10-10 15:45:48.000000000 +0200
++++ everything/net/mac80211/tx.c	2008-10-10 15:45:56.000000000 +0200
+@@ -602,8 +602,18 @@ ieee80211_tx_h_sequence(struct ieee80211
+ 	if (ieee80211_hdrlen(hdr->frame_control) < 24)
+ 		return TX_CONTINUE;
+ 
++	/*
++	 * Anything but QoS data that has a sequence number field
++	 * (is long enough) gets a sequence number from the global
++	 * counter.
++	 */
+ 	if (!ieee80211_is_data_qos(hdr->frame_control)) {
++		/* driver should assign sequence number */
+ 		info->flags |= IEEE80211_TX_CTL_ASSIGN_SEQ;
++		/* for pure STA mode without beacons, we can do it */
++		hdr->seq_ctrl = cpu_to_le16(tx->sdata->sequence_number);
++		tx->sdata->sequence_number += 0x10;
++		tx->sdata->sequence_number &= IEEE80211_SCTL_SEQ;
+ 		return TX_CONTINUE;
+ 	}
+ 
+--- everything.orig/drivers/net/wireless/p54/p54.h	2008-10-10 15:45:49.000000000 +0200
++++ everything/drivers/net/wireless/p54/p54.h	2008-10-10 15:45:56.000000000 +0200
+@@ -67,7 +67,6 @@ struct p54_common {
+ 	int (*open)(struct ieee80211_hw *dev);
+ 	void (*stop)(struct ieee80211_hw *dev);
+ 	int mode;
+-	u16 seqno;
+ 	u16 rx_mtu;
+ 	u8 headroom;
+ 	u8 tailroom;
+--- everything.orig/drivers/net/wireless/p54/p54common.c	2008-10-10 15:45:49.000000000 +0200
++++ everything/drivers/net/wireless/p54/p54common.c	2008-10-10 15:45:56.000000000 +0200
+@@ -865,19 +865,6 @@ static int p54_tx(struct ieee80211_hw *d
+ 	if (padding)
+ 		txhdr->align[0] = padding;
+ 
+-	/* FIXME: The sequence that follows is needed for this driver to
+-	 * work with mac80211 since "mac80211: fix TX sequence numbers".
+-	 * As with the temporary code in rt2x00, changes will be needed
+-	 * to get proper sequence numbers on beacons. In addition, this
+-	 * patch places the sequence number in the hardware state, which
+-	 * limits us to a single virtual state.
+-	 */
+-	if (info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ) {
+-		if (info->flags & IEEE80211_TX_CTL_FIRST_FRAGMENT)
+-			priv->seqno += 0x10;
+-		ieee80211hdr->seq_ctrl &= cpu_to_le16(IEEE80211_SCTL_FRAG);
+-		ieee80211hdr->seq_ctrl |= cpu_to_le16(priv->seqno);
+-	}
+ 	/* modifies skb->cb and with it info, so must be last! */
+ 	p54_assign_address(dev, skb, hdr, skb->len);
+ 
+@@ -1391,6 +1378,11 @@ struct ieee80211_hw *p54_init_common(siz
+ 		     IEEE80211_HW_SIGNAL_DBM |
+ 		     IEEE80211_HW_NOISE_DBM;
+ 
++	/*
++	 * XXX: when this driver gets support for any mode that
++	 *	requires beacons (AP, MESH, IBSS) then it must
++	 *	implement IEEE80211_TX_CTL_ASSIGN_SEQ.
++	 */
+ 	dev->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION);
+ 
+ 	dev->channel_change_time = 1000;	/* TODO: find actual value */
+--- everything.orig/drivers/net/wireless/rtl8187_dev.c	2008-10-10 15:45:49.000000000 +0200
++++ everything/drivers/net/wireless/rtl8187_dev.c	2008-10-10 15:45:56.000000000 +0200
+@@ -238,20 +238,6 @@ static int rtl8187_tx(struct ieee80211_h
+ 			ep = epmap[skb_get_queue_mapping(skb)];
+ 	}
+ 
+-	/* FIXME: The sequence that follows is needed for this driver to
+-	 * work with mac80211 since "mac80211: fix TX sequence numbers".
+-	 * As with the temporary code in rt2x00, changes will be needed
+-	 * to get proper sequence numbers on beacons. In addition, this
+-	 * patch places the sequence number in the hardware state, which
+-	 * limits us to a single virtual state.
+-	 */
+-	if (info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ) {
+-		if (info->flags & IEEE80211_TX_CTL_FIRST_FRAGMENT)
+-			priv->seqno += 0x10;
+-		ieee80211hdr->seq_ctrl &= cpu_to_le16(IEEE80211_SCTL_FRAG);
+-		ieee80211hdr->seq_ctrl |= cpu_to_le16(priv->seqno);
+-	}
+-
+ 	info->driver_data[0] = dev;
+ 	info->driver_data[1] = urb;
+ 
+@@ -1185,6 +1171,10 @@ static int __devinit rtl8187_probe(struc
+ 		dev->max_signal = 65;
+ 	}
+ 
++	/*
++	 * XXX: Once this driver supports anything that requires
++	 *	beacons it must implement IEEE80211_TX_CTL_ASSIGN_SEQ.
++	 */
+ 	dev->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION);
+ 
+ 	if ((id->driver_info == DEVICE_RTL8187) && priv->is_rtl8187b)
+--- everything.orig/drivers/net/wireless/rtl8187.h	2008-10-10 15:45:49.000000000 +0200
++++ everything/drivers/net/wireless/rtl8187.h	2008-10-10 15:45:56.000000000 +0200
+@@ -100,7 +100,6 @@ struct rtl8187_priv {
+ 	struct usb_device *udev;
+ 	u32 rx_conf;
+ 	u16 txpwr_base;
+-	u16 seqno;
+ 	u8 asic_rev;
+ 	u8 is_rtl8187b;
+ 	enum {
diff --git a/package/mac80211/patches/423-mac80211-make-bss-conf-part-of-vif.patch b/package/mac80211/patches/423-mac80211-make-bss-conf-part-of-vif.patch
new file mode 100644
index 0000000000..556d651a0a
--- /dev/null
+++ b/package/mac80211/patches/423-mac80211-make-bss-conf-part-of-vif.patch
@@ -0,0 +1,303 @@
+Subject: mac80211: move bss_conf into vif
+
+Move bss_conf into the vif struct so that drivers can
+access it during ->tx without having to store it in
+the private data or similar. No driver updates because
+this is only for when they want to start using it.
+
+Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
+---
+ include/net/mac80211.h        |    3 +++
+ net/mac80211/cfg.c            |    6 +++---
+ net/mac80211/debugfs_netdev.c |    2 +-
+ net/mac80211/ieee80211_i.h    |    3 ---
+ net/mac80211/iface.c          |    2 +-
+ net/mac80211/main.c           |    8 ++++----
+ net/mac80211/mlme.c           |   30 +++++++++++++++---------------
+ net/mac80211/tx.c             |   16 ++++++++--------
+ net/mac80211/util.c           |    6 +++---
+ 9 files changed, 38 insertions(+), 38 deletions(-)
+
+--- everything.orig/include/net/mac80211.h	2008-10-10 17:09:04.000000000 +0200
++++ everything/include/net/mac80211.h	2008-10-10 17:09:41.000000000 +0200
+@@ -519,11 +519,14 @@ struct ieee80211_conf {
+  * use during the life of a virtual interface.
+  *
+  * @type: type of this virtual interface
++ * @bss_conf: BSS configuration for this interface, either our own
++ *	or the BSS we're associated to
+  * @drv_priv: data area for driver use, will always be aligned to
+  *	sizeof(void *).
+  */
+ struct ieee80211_vif {
+ 	enum nl80211_iftype type;
++	struct ieee80211_bss_conf bss_conf;
+ 	/* must be last */
+ 	u8 drv_priv[0] __attribute__((__aligned__(sizeof(void *))));
+ };
+--- everything.orig/net/mac80211/ieee80211_i.h	2008-10-10 17:10:40.000000000 +0200
++++ everything/net/mac80211/ieee80211_i.h	2008-10-10 17:10:45.000000000 +0200
+@@ -440,9 +440,6 @@ struct ieee80211_sub_if_data {
+ 
+ 	u16 sequence_number;
+ 
+-	/* BSS configuration for this interface. */
+-	struct ieee80211_bss_conf bss_conf;
+-
+ 	/*
+ 	 * AP this belongs to: self in AP mode and
+ 	 * corresponding AP in VLAN mode, NULL for
+--- everything.orig/net/mac80211/main.c	2008-10-10 17:10:55.000000000 +0200
++++ everything/net/mac80211/main.c	2008-10-10 17:11:10.000000000 +0200
+@@ -249,15 +249,15 @@ void ieee80211_bss_info_change_notify(st
+ 	if (local->ops->bss_info_changed)
+ 		local->ops->bss_info_changed(local_to_hw(local),
+ 					     &sdata->vif,
+-					     &sdata->bss_conf,
++					     &sdata->vif.bss_conf,
+ 					     changed);
+ }
+ 
+ u32 ieee80211_reset_erp_info(struct ieee80211_sub_if_data *sdata)
+ {
+-	sdata->bss_conf.use_cts_prot = false;
+-	sdata->bss_conf.use_short_preamble = false;
+-	sdata->bss_conf.use_short_slot = false;
++	sdata->vif.bss_conf.use_cts_prot = false;
++	sdata->vif.bss_conf.use_short_preamble = false;
++	sdata->vif.bss_conf.use_short_slot = false;
+ 	return BSS_CHANGED_ERP_CTS_PROT |
+ 	       BSS_CHANGED_ERP_PREAMBLE |
+ 	       BSS_CHANGED_ERP_SLOT;
+--- everything.orig/net/mac80211/iface.c	2008-10-10 17:12:11.000000000 +0200
++++ everything/net/mac80211/iface.c	2008-10-10 17:12:13.000000000 +0200
+@@ -695,7 +695,7 @@ int ieee80211_if_change_type(struct ieee
+ 	ieee80211_setup_sdata(sdata, type);
+ 
+ 	/* reset some values that shouldn't be kept across type changes */
+-	sdata->bss_conf.basic_rates =
++	sdata->vif.bss_conf.basic_rates =
+ 		ieee80211_mandatory_rates(sdata->local,
+ 			sdata->local->hw.conf.channel->band);
+ 	sdata->drop_unencrypted = 0;
+--- everything.orig/net/mac80211/mlme.c	2008-10-10 17:11:49.000000000 +0200
++++ everything/net/mac80211/mlme.c	2008-10-10 17:11:58.000000000 +0200
+@@ -572,7 +572,7 @@ static void ieee80211_sta_wmm_params(str
+ static u32 ieee80211_handle_bss_capability(struct ieee80211_sub_if_data *sdata,
+ 					   u16 capab, bool erp_valid, u8 erp)
+ {
+-	struct ieee80211_bss_conf *bss_conf = &sdata->bss_conf;
++	struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf;
+ #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
+ 	struct ieee80211_if_sta *ifsta = &sdata->u.sta;
+ 	DECLARE_MAC_BUF(mac);
+@@ -720,9 +720,9 @@ static void ieee80211_set_associated(str
+ 				   ifsta->ssid, ifsta->ssid_len);
+ 	if (bss) {
+ 		/* set timing information */
+-		sdata->bss_conf.beacon_int = bss->beacon_int;
+-		sdata->bss_conf.timestamp = bss->timestamp;
+-		sdata->bss_conf.dtim_period = bss->dtim_period;
++		sdata->vif.bss_conf.beacon_int = bss->beacon_int;
++		sdata->vif.bss_conf.timestamp = bss->timestamp;
++		sdata->vif.bss_conf.dtim_period = bss->dtim_period;
+ 
+ 		changed |= ieee80211_handle_bss_capability(sdata,
+ 			bss->capability, bss->has_erp_value, bss->erp_value);
+@@ -732,9 +732,9 @@ static void ieee80211_set_associated(str
+ 
+ 	if (conf->flags & IEEE80211_CONF_SUPPORT_HT_MODE) {
+ 		changed |= BSS_CHANGED_HT;
+-		sdata->bss_conf.assoc_ht = 1;
+-		sdata->bss_conf.ht_cap = &conf->ht_cap;
+-		sdata->bss_conf.ht_bss_conf = &conf->ht_bss_conf;
++		sdata->vif.bss_conf.assoc_ht = 1;
++		sdata->vif.bss_conf.ht_cap = &conf->ht_cap;
++		sdata->vif.bss_conf.ht_bss_conf = &conf->ht_bss_conf;
+ 	}
+ 
+ 	ifsta->flags |= IEEE80211_STA_PREV_BSSID_SET;
+@@ -744,7 +744,7 @@ static void ieee80211_set_associated(str
+ 	ifsta->last_probe = jiffies;
+ 	ieee80211_led_assoc(local, 1);
+ 
+-	sdata->bss_conf.assoc = 1;
++	sdata->vif.bss_conf.assoc = 1;
+ 	/*
+ 	 * For now just always ask the driver to update the basic rateset
+ 	 * when we have associated, we aren't checking whether it actually
+@@ -853,15 +853,15 @@ static void ieee80211_set_disassoc(struc
+ 	ifsta->flags &= ~IEEE80211_STA_ASSOCIATED;
+ 	changed |= ieee80211_reset_erp_info(sdata);
+ 
+-	if (sdata->bss_conf.assoc_ht)
++	if (sdata->vif.bss_conf.assoc_ht)
+ 		changed |= BSS_CHANGED_HT;
+ 
+-	sdata->bss_conf.assoc_ht = 0;
+-	sdata->bss_conf.ht_cap = NULL;
+-	sdata->bss_conf.ht_bss_conf = NULL;
++	sdata->vif.bss_conf.assoc_ht = 0;
++	sdata->vif.bss_conf.ht_cap = NULL;
++	sdata->vif.bss_conf.ht_bss_conf = NULL;
+ 
+ 	ieee80211_led_assoc(local, 0);
+-	sdata->bss_conf.assoc = 0;
++	sdata->vif.bss_conf.assoc = 0;
+ 
+ 	ieee80211_sta_send_apinfo(sdata, ifsta);
+ 
+@@ -1194,7 +1194,7 @@ static void ieee80211_rx_mgmt_assoc_resp
+ 	u64 rates, basic_rates;
+ 	u16 capab_info, status_code, aid;
+ 	struct ieee802_11_elems elems;
+-	struct ieee80211_bss_conf *bss_conf = &sdata->bss_conf;
++	struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf;
+ 	u8 *pos;
+ 	int i, j;
+ 	DECLARE_MAC_BUF(mac);
+@@ -1337,7 +1337,7 @@ static void ieee80211_rx_mgmt_assoc_resp
+ 	}
+ 
+ 	sta->sta.supp_rates[local->hw.conf.channel->band] = rates;
+-	sdata->bss_conf.basic_rates = basic_rates;
++	sdata->vif.bss_conf.basic_rates = basic_rates;
+ 
+ 	/* cf. IEEE 802.11 9.2.12 */
+ 	if (local->hw.conf.channel->band == IEEE80211_BAND_2GHZ &&
+--- everything.orig/net/mac80211/cfg.c	2008-10-10 17:12:29.000000000 +0200
++++ everything/net/mac80211/cfg.c	2008-10-10 17:12:31.000000000 +0200
+@@ -966,16 +966,16 @@ static int ieee80211_change_bss(struct w
+ 		return -EINVAL;
+ 
+ 	if (params->use_cts_prot >= 0) {
+-		sdata->bss_conf.use_cts_prot = params->use_cts_prot;
++		sdata->vif.bss_conf.use_cts_prot = params->use_cts_prot;
+ 		changed |= BSS_CHANGED_ERP_CTS_PROT;
+ 	}
+ 	if (params->use_short_preamble >= 0) {
+-		sdata->bss_conf.use_short_preamble =
++		sdata->vif.bss_conf.use_short_preamble =
+ 			params->use_short_preamble;
+ 		changed |= BSS_CHANGED_ERP_PREAMBLE;
+ 	}
+ 	if (params->use_short_slot_time >= 0) {
+-		sdata->bss_conf.use_short_slot =
++		sdata->vif.bss_conf.use_short_slot =
+ 			params->use_short_slot_time;
+ 		changed |= BSS_CHANGED_ERP_SLOT;
+ 	}
+--- everything.orig/net/mac80211/debugfs_netdev.c	2008-10-10 17:13:26.000000000 +0200
++++ everything/net/mac80211/debugfs_netdev.c	2008-10-10 17:13:28.000000000 +0200
+@@ -120,7 +120,7 @@ static ssize_t ieee80211_if_fmt_flags(
+ 		 sdata->u.sta.flags & IEEE80211_STA_AUTHENTICATED ? "AUTH\n" : "",
+ 		 sdata->u.sta.flags & IEEE80211_STA_ASSOCIATED ? "ASSOC\n" : "",
+ 		 sdata->u.sta.flags & IEEE80211_STA_PROBEREQ_POLL ? "PROBEREQ POLL\n" : "",
+-		 sdata->bss_conf.use_cts_prot ? "CTS prot\n" : "");
++		 sdata->vif.bss_conf.use_cts_prot ? "CTS prot\n" : "");
+ }
+ __IEEE80211_IF_FILE(flags);
+ 
+--- everything.orig/net/mac80211/tx.c	2008-10-10 17:12:46.000000000 +0200
++++ everything/net/mac80211/tx.c	2008-10-10 17:12:49.000000000 +0200
+@@ -116,7 +116,7 @@ static __le16 ieee80211_duration(struct 
+ 		if (r->bitrate > txrate->bitrate)
+ 			break;
+ 
+-		if (tx->sdata->bss_conf.basic_rates & BIT(i))
++		if (tx->sdata->vif.bss_conf.basic_rates & BIT(i))
+ 			rate = r->bitrate;
+ 
+ 		switch (sband->band) {
+@@ -150,7 +150,7 @@ static __le16 ieee80211_duration(struct 
+ 	 * to closest integer */
+ 
+ 	dur = ieee80211_frame_duration(local, 10, rate, erp,
+-				tx->sdata->bss_conf.use_short_preamble);
++				tx->sdata->vif.bss_conf.use_short_preamble);
+ 
+ 	if (next_frag_len) {
+ 		/* Frame is fragmented: duration increases with time needed to
+@@ -159,7 +159,7 @@ static __le16 ieee80211_duration(struct 
+ 		/* next fragment */
+ 		dur += ieee80211_frame_duration(local, next_frag_len,
+ 				txrate->bitrate, erp,
+-				tx->sdata->bss_conf.use_short_preamble);
++				tx->sdata->vif.bss_conf.use_short_preamble);
+ 	}
+ 
+ 	return cpu_to_le16(dur);
+@@ -465,7 +465,7 @@ ieee80211_tx_h_rate_ctrl(struct ieee8021
+ 	} else
+ 		info->control.retries[0].rate_idx = -1;
+ 
+-	if (tx->sdata->bss_conf.use_cts_prot &&
++	if (tx->sdata->vif.bss_conf.use_cts_prot &&
+ 	    (tx->flags & IEEE80211_TX_FRAGMENTED) && (rsel.nonerp_idx >= 0)) {
+ 		tx->last_frag_rate_idx = tx->rate_idx;
+ 		if (rsel.probe_idx >= 0)
+@@ -531,7 +531,7 @@ ieee80211_tx_h_misc(struct ieee80211_tx_
+ 	if ((tx->sdata->flags & IEEE80211_SDATA_OPERATING_GMODE) &&
+ 	    (sband->bitrates[tx->rate_idx].flags & IEEE80211_RATE_ERP_G) &&
+ 	    (tx->flags & IEEE80211_TX_UNICAST) &&
+-	    tx->sdata->bss_conf.use_cts_prot &&
++	    tx->sdata->vif.bss_conf.use_cts_prot &&
+ 	    !(info->flags & IEEE80211_TX_CTL_USE_RTS_CTS))
+ 		info->flags |= IEEE80211_TX_CTL_USE_CTS_PROTECT;
+ 
+@@ -540,7 +540,7 @@ ieee80211_tx_h_misc(struct ieee80211_tx_
+ 	 * available on the network at the current point in time. */
+ 	if (ieee80211_is_data(hdr->frame_control) &&
+ 	    (sband->bitrates[tx->rate_idx].flags & IEEE80211_RATE_SHORT_PREAMBLE) &&
+-	    tx->sdata->bss_conf.use_short_preamble &&
++	    tx->sdata->vif.bss_conf.use_short_preamble &&
+ 	    (!tx->sta || test_sta_flags(tx->sta, WLAN_STA_SHORT_PREAMBLE))) {
+ 		info->flags |= IEEE80211_TX_CTL_SHORT_PREAMBLE;
+ 	}
+@@ -560,7 +560,7 @@ ieee80211_tx_h_misc(struct ieee80211_tx_
+ 		for (idx = 0; idx < sband->n_bitrates; idx++) {
+ 			if (sband->bitrates[idx].bitrate > rate->bitrate)
+ 				continue;
+-			if (tx->sdata->bss_conf.basic_rates & BIT(idx) &&
++			if (tx->sdata->vif.bss_conf.basic_rates & BIT(idx) &&
+ 			    (baserate < 0 ||
+ 			     (sband->bitrates[baserate].bitrate
+ 			      < sband->bitrates[idx].bitrate)))
+@@ -1981,7 +1981,7 @@ struct sk_buff *ieee80211_beacon_get(str
+ 	info->flags |= IEEE80211_TX_CTL_NO_ACK;
+ 	info->flags |= IEEE80211_TX_CTL_CLEAR_PS_FILT;
+ 	info->flags |= IEEE80211_TX_CTL_ASSIGN_SEQ;
+-	if (sdata->bss_conf.use_short_preamble &&
++	if (sdata->vif.bss_conf.use_short_preamble &&
+ 	    sband->bitrates[rsel.rate_idx].flags & IEEE80211_RATE_SHORT_PREAMBLE)
+ 		info->flags |= IEEE80211_TX_CTL_SHORT_PREAMBLE;
+ 
+--- everything.orig/net/mac80211/util.c	2008-10-10 17:13:03.000000000 +0200
++++ everything/net/mac80211/util.c	2008-10-10 17:13:06.000000000 +0200
+@@ -239,7 +239,7 @@ __le16 ieee80211_generic_frame_duration(
+ 	erp = 0;
+ 	if (vif) {
+ 		sdata = vif_to_sdata(vif);
+-		short_preamble = sdata->bss_conf.use_short_preamble;
++		short_preamble = sdata->vif.bss_conf.use_short_preamble;
+ 		if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
+ 			erp = rate->flags & IEEE80211_RATE_ERP_G;
+ 	}
+@@ -272,7 +272,7 @@ __le16 ieee80211_rts_duration(struct iee
+ 	erp = 0;
+ 	if (vif) {
+ 		sdata = vif_to_sdata(vif);
+-		short_preamble = sdata->bss_conf.use_short_preamble;
++		short_preamble = sdata->vif.bss_conf.use_short_preamble;
+ 		if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
+ 			erp = rate->flags & IEEE80211_RATE_ERP_G;
+ 	}
+@@ -312,7 +312,7 @@ __le16 ieee80211_ctstoself_duration(stru
+ 	erp = 0;
+ 	if (vif) {
+ 		sdata = vif_to_sdata(vif);
+-		short_preamble = sdata->bss_conf.use_short_preamble;
++		short_preamble = sdata->vif.bss_conf.use_short_preamble;
+ 		if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
+ 			erp = rate->flags & IEEE80211_RATE_ERP_G;
+ 	}
diff --git a/package/mac80211/patches/424-mac80211-make-retry-limits-available.patch b/package/mac80211/patches/424-mac80211-make-retry-limits-available.patch
new file mode 100644
index 0000000000..084ed9a132
--- /dev/null
+++ b/package/mac80211/patches/424-mac80211-make-retry-limits-available.patch
@@ -0,0 +1,506 @@
+---
+ drivers/net/wireless/ath9k/main.c       |    1 
+ drivers/net/wireless/b43/main.c         |   67 +++++++++++++-----------------
+ drivers/net/wireless/b43legacy/main.c   |   70 ++++++++++++++------------------
+ drivers/net/wireless/rt2x00/rt2400pci.c |    2 
+ drivers/net/wireless/rt2x00/rt2500pci.c |    2 
+ drivers/net/wireless/rt2x00/rt2x00.h    |    3 +
+ drivers/net/wireless/rt2x00/rt2x00mac.c |    9 ++++
+ drivers/net/wireless/rt2x00/rt61pci.c   |    2 
+ drivers/net/wireless/rt2x00/rt73usb.c   |    2 
+ include/net/mac80211.h                  |   14 ++++--
+ net/mac80211/debugfs.c                  |    4 -
+ net/mac80211/ieee80211_i.h              |    2 
+ net/mac80211/main.c                     |    4 -
+ net/mac80211/tx.c                       |    4 -
+ net/mac80211/wext.c                     |   28 +++++-------
+ 15 files changed, 106 insertions(+), 108 deletions(-)
+
+--- everything.orig/include/net/mac80211.h	2008-10-10 23:27:46.000000000 +0200
++++ everything/include/net/mac80211.h	2008-10-10 23:31:21.000000000 +0200
+@@ -473,6 +473,7 @@ static inline int __deprecated __IEEE802
+  * @IEEE80211_CONF_CHANGE_PS: the PS flag changed
+  * @IEEE80211_CONF_CHANGE_POWER: the TX power changed
+  * @IEEE80211_CONF_CHANGE_CHANNEL: the channel changed
++ * @IEEE80211_CONF_CHANGE_RETRY_LIMITS: retry limits changed
+  */
+ enum ieee80211_conf_changed {
+ 	IEEE80211_CONF_CHANGE_RADIO_ENABLED	= BIT(0),
+@@ -482,6 +483,7 @@ enum ieee80211_conf_changed {
+ 	IEEE80211_CONF_CHANGE_PS		= BIT(4),
+ 	IEEE80211_CONF_CHANGE_POWER		= BIT(5),
+ 	IEEE80211_CONF_CHANGE_CHANNEL		= BIT(6),
++	IEEE80211_CONF_CHANGE_RETRY_LIMITS	= BIT(7),
+ };
+ 
+ /**
+@@ -497,6 +499,12 @@ enum ieee80211_conf_changed {
+  * @ht_cap: describes current self configuration of 802.11n HT capabilities
+  * @ht_bss_conf: describes current BSS configuration of 802.11n HT parameters
+  * @channel: the channel to tune to
++ * @long_frame_max_tx_count: Maximum number of transmissions for a "long" frame
++ *	(a frame not RTS protected), called "dot11LongRetryLimit" in 802.11,
++ *	but actually means the number of transmissions not the number of retries
++ * @short_frame_max_tx_count: Maximum number of transmissions for a "short" frame,
++ *	called "dot11ShortRetryLimit" in 802.11, but actually means the number
++ *	of transmissions not the number of retries
+  */
+ struct ieee80211_conf {
+ 	int beacon_int;
+@@ -506,6 +514,8 @@ struct ieee80211_conf {
+ 	u16 listen_interval;
+ 	bool radio_enabled;
+ 
++	u8 long_frame_max_tx_count, short_frame_max_tx_count;
++
+ 	struct ieee80211_channel *channel;
+ 
+ 	struct ieee80211_sta_ht_cap ht_cap;
+@@ -1192,8 +1202,6 @@ enum ieee80211_ampdu_mlme_action {
+  *	the device does fragmentation by itself; if this method is assigned then
+  *	the stack will not do fragmentation.
+  *
+- * @set_retry_limit: Configuration of retry limits (if device needs it)
+- *
+  * @sta_notify: Notifies low level driver about addition or removal
+  *	of assocaited station or AP.
+  *
+@@ -1263,8 +1271,6 @@ struct ieee80211_ops {
+ 			     u32 *iv32, u16 *iv16);
+ 	int (*set_rts_threshold)(struct ieee80211_hw *hw, u32 value);
+ 	int (*set_frag_threshold)(struct ieee80211_hw *hw, u32 value);
+-	int (*set_retry_limit)(struct ieee80211_hw *hw,
+-			       u32 short_retry, u32 long_retr);
+ 	void (*sta_notify)(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
+ 			enum sta_notify_cmd, struct ieee80211_sta *sta);
+ 	int (*conf_tx)(struct ieee80211_hw *hw, u16 queue,
+--- everything.orig/net/mac80211/ieee80211_i.h	2008-10-10 23:27:46.000000000 +0200
++++ everything/net/mac80211/ieee80211_i.h	2008-10-10 23:31:22.000000000 +0200
+@@ -632,8 +632,6 @@ struct ieee80211_local {
+ 
+ 	int rts_threshold;
+ 	int fragmentation_threshold;
+-	int short_retry_limit; /* dot11ShortRetryLimit */
+-	int long_retry_limit; /* dot11LongRetryLimit */
+ 
+ 	struct crypto_blkcipher *wep_tx_tfm;
+ 	struct crypto_blkcipher *wep_rx_tfm;
+--- everything.orig/net/mac80211/main.c	2008-10-10 23:27:46.000000000 +0200
++++ everything/net/mac80211/main.c	2008-10-10 23:31:22.000000000 +0200
+@@ -673,8 +673,8 @@ struct ieee80211_hw *ieee80211_alloc_hw(
+ 
+ 	local->rts_threshold = IEEE80211_MAX_RTS_THRESHOLD;
+ 	local->fragmentation_threshold = IEEE80211_MAX_FRAG_THRESHOLD;
+-	local->short_retry_limit = 7;
+-	local->long_retry_limit = 4;
++	local->hw.conf.long_frame_max_tx_count = 4;
++	local->hw.conf.short_frame_max_tx_count = 7;
+ 	local->hw.conf.radio_enabled = true;
+ 
+ 	INIT_LIST_HEAD(&local->interfaces);
+--- everything.orig/net/mac80211/wext.c	2008-10-10 23:27:46.000000000 +0200
++++ everything/net/mac80211/wext.c	2008-10-10 23:31:22.000000000 +0200
+@@ -802,21 +802,16 @@ static int ieee80211_ioctl_siwretry(stru
+ 	    (retry->flags & IW_RETRY_TYPE) != IW_RETRY_LIMIT)
+ 		return -EINVAL;
+ 
+-	if (retry->flags & IW_RETRY_MAX)
+-		local->long_retry_limit = retry->value;
+-	else if (retry->flags & IW_RETRY_MIN)
+-		local->short_retry_limit = retry->value;
+-	else {
+-		local->long_retry_limit = retry->value;
+-		local->short_retry_limit = retry->value;
++	if (retry->flags & IW_RETRY_MAX) {
++		local->hw.conf.long_frame_max_tx_count = retry->value;
++	} else if (retry->flags & IW_RETRY_MIN) {
++		local->hw.conf.short_frame_max_tx_count = retry->value;
++	} else {
++		local->hw.conf.long_frame_max_tx_count = retry->value;
++		local->hw.conf.short_frame_max_tx_count = retry->value;
+ 	}
+ 
+-	if (local->ops->set_retry_limit) {
+-		return local->ops->set_retry_limit(
+-			local_to_hw(local),
+-			local->short_retry_limit,
+-			local->long_retry_limit);
+-	}
++	ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_RETRY_LIMITS);
+ 
+ 	return 0;
+ }
+@@ -833,14 +828,15 @@ static int ieee80211_ioctl_giwretry(stru
+ 		/* first return min value, iwconfig will ask max value
+ 		 * later if needed */
+ 		retry->flags |= IW_RETRY_LIMIT;
+-		retry->value = local->short_retry_limit;
+-		if (local->long_retry_limit != local->short_retry_limit)
++		retry->value = local->hw.conf.short_frame_max_tx_count;
++		if (local->hw.conf.long_frame_max_tx_count !=
++		    local->hw.conf.short_frame_max_tx_count)
+ 			retry->flags |= IW_RETRY_MIN;
+ 		return 0;
+ 	}
+ 	if (retry->flags & IW_RETRY_MAX) {
+ 		retry->flags = IW_RETRY_LIMIT | IW_RETRY_MAX;
+-		retry->value = local->long_retry_limit;
++		retry->value = local->hw.conf.long_frame_max_tx_count;
+ 	}
+ 
+ 	return 0;
+--- everything.orig/drivers/net/wireless/ath9k/main.c	2008-10-10 23:27:47.000000000 +0200
++++ everything/drivers/net/wireless/ath9k/main.c	2008-10-10 23:31:23.000000000 +0200
+@@ -1657,7 +1657,6 @@ static struct ieee80211_ops ath9k_ops = 
+ 	.get_tkip_seq       = NULL,
+ 	.set_rts_threshold  = NULL,
+ 	.set_frag_threshold = NULL,
+-	.set_retry_limit    = NULL,
+ 	.get_tsf 	    = ath9k_get_tsf,
+ 	.reset_tsf 	    = ath9k_reset_tsf,
+ 	.tx_last_beacon     = NULL,
+--- everything.orig/drivers/net/wireless/b43/main.c	2008-10-10 23:27:47.000000000 +0200
++++ everything/drivers/net/wireless/b43/main.c	2008-10-10 23:31:23.000000000 +0200
+@@ -3320,6 +3320,22 @@ init_failure:
+ 	return err;
+ }
+ 
++/* Write the short and long frame retry limit values. */
++static void b43_set_retry_limits(struct b43_wldev *dev,
++				 unsigned int short_retry,
++				 unsigned int long_retry)
++{
++	/* The retry limit is a 4-bit counter. Enforce this to avoid overflowing
++	 * the chip-internal counter. */
++	short_retry = min(short_retry, (unsigned int)0xF);
++	long_retry = min(long_retry, (unsigned int)0xF);
++
++	b43_shm_write16(dev, B43_SHM_SCRATCH, B43_SHM_SC_SRLIMIT,
++			short_retry);
++	b43_shm_write16(dev, B43_SHM_SCRATCH, B43_SHM_SC_LRLIMIT,
++			long_retry);
++}
++
+ static int b43_op_config(struct ieee80211_hw *hw, u32 changed)
+ {
+ 	struct b43_wl *wl = hw_to_b43_wl(hw);
+@@ -3333,6 +3349,20 @@ static int b43_op_config(struct ieee8021
+ 
+ 	mutex_lock(&wl->mutex);
+ 
++	if (changed & IEEE80211_CONF_CHANGE_RETRY_LIMITS) {
++		dev = wl->current_dev;
++		if (unlikely(!dev || (b43_status(dev) < B43_STAT_INITIALIZED))) {
++			err = -ENODEV;
++			goto out_unlock_mutex;
++		}
++		b43_set_retry_limits(dev, conf->short_frame_max_tx_count,
++					  conf->long_frame_max_tx_count);
++		changed &= ~IEEE80211_CONF_CHANGE_RETRY_LIMITS;
++	}
++
++	if (!changed)
++		goto out_unlock_mutex;
++
+ 	/* Switch the band (if necessary). This might change the active core. */
+ 	err = b43_switch_band(wl, conf->channel);
+ 	if (err)
+@@ -3860,22 +3890,6 @@ static void b43_imcfglo_timeouts_workaro
+ #endif /* CONFIG_SSB_DRIVER_PCICORE */
+ }
+ 
+-/* Write the short and long frame retry limit values. */
+-static void b43_set_retry_limits(struct b43_wldev *dev,
+-				 unsigned int short_retry,
+-				 unsigned int long_retry)
+-{
+-	/* The retry limit is a 4-bit counter. Enforce this to avoid overflowing
+-	 * the chip-internal counter. */
+-	short_retry = min(short_retry, (unsigned int)0xF);
+-	long_retry = min(long_retry, (unsigned int)0xF);
+-
+-	b43_shm_write16(dev, B43_SHM_SCRATCH, B43_SHM_SC_SRLIMIT,
+-			short_retry);
+-	b43_shm_write16(dev, B43_SHM_SCRATCH, B43_SHM_SC_LRLIMIT,
+-			long_retry);
+-}
+-
+ static void b43_set_synth_pu_delay(struct b43_wldev *dev, bool idle)
+ {
+ 	u16 pu_delay;
+@@ -4196,26 +4210,6 @@ static void b43_op_stop(struct ieee80211
+ 	cancel_work_sync(&(wl->txpower_adjust_work));
+ }
+ 
+-static int b43_op_set_retry_limit(struct ieee80211_hw *hw,
+-				  u32 short_retry_limit, u32 long_retry_limit)
+-{
+-	struct b43_wl *wl = hw_to_b43_wl(hw);
+-	struct b43_wldev *dev;
+-	int err = 0;
+-
+-	mutex_lock(&wl->mutex);
+-	dev = wl->current_dev;
+-	if (unlikely(!dev || (b43_status(dev) < B43_STAT_INITIALIZED))) {
+-		err = -ENODEV;
+-		goto out_unlock;
+-	}
+-	b43_set_retry_limits(dev, short_retry_limit, long_retry_limit);
+-out_unlock:
+-	mutex_unlock(&wl->mutex);
+-
+-	return err;
+-}
+-
+ static int b43_op_beacon_set_tim(struct ieee80211_hw *hw,
+ 				 struct ieee80211_sta *sta, bool set)
+ {
+@@ -4252,7 +4246,6 @@ static const struct ieee80211_ops b43_hw
+ 	.get_tx_stats		= b43_op_get_tx_stats,
+ 	.start			= b43_op_start,
+ 	.stop			= b43_op_stop,
+-	.set_retry_limit	= b43_op_set_retry_limit,
+ 	.set_tim		= b43_op_beacon_set_tim,
+ 	.sta_notify		= b43_op_sta_notify,
+ };
+--- everything.orig/drivers/net/wireless/b43legacy/main.c	2008-10-10 23:27:47.000000000 +0200
++++ everything/drivers/net/wireless/b43legacy/main.c	2008-10-10 23:31:23.000000000 +0200
+@@ -2556,6 +2556,20 @@ init_failure:
+ 	return err;
+ }
+ 
++/* Write the short and long frame retry limit values. */
++static void b43legacy_set_retry_limits(struct b43legacy_wldev *dev,
++				       unsigned int short_retry,
++				       unsigned int long_retry)
++{
++	/* The retry limit is a 4-bit counter. Enforce this to avoid overflowing
++	 * the chip-internal counter. */
++	short_retry = min(short_retry, (unsigned int)0xF);
++	long_retry = min(long_retry, (unsigned int)0xF);
++
++	b43legacy_shm_write16(dev, B43legacy_SHM_WIRELESS, 0x0006, short_retry);
++	b43legacy_shm_write16(dev, B43legacy_SHM_WIRELESS, 0x0007, long_retry);
++}
++
+ static int b43legacy_op_dev_config(struct ieee80211_hw *hw,
+ 				   u32 changed)
+ {
+@@ -2570,10 +2584,27 @@ static int b43legacy_op_dev_config(struc
+ 	int err = 0;
+ 	u32 savedirqs;
+ 
++	mutex_lock(&wl->mutex);
++	dev = wl->current_dev;
++
++	if (changed & IEEE80211_CONF_CHANGE_RETRY_LIMITS) {
++		if (unlikely(!dev ||
++			     (b43legacy_status(dev) < B43legacy_STAT_INITIALIZED))) {
++			err = -ENODEV;
++			goto out_unlock_mutex;
++		}
++		b43legacy_set_retry_limits(dev,
++					   conf->short_frame_max_tx_count,
++					   conf->long_frame_max_tx_count);
++		changed &= ~IEEE80211_CONF_CHANGE_RETRY_LIMITS;
++	}
++
++	if (!changed)
++		goto out_unlock_mutex;
++
+ 	antenna_tx = B43legacy_ANTENNA_DEFAULT;
+ 	antenna_rx = B43legacy_ANTENNA_DEFAULT;
+ 
+-	mutex_lock(&wl->mutex);
+ 	dev = wl->current_dev;
+ 	phy = &dev->phy;
+ 
+@@ -2989,20 +3020,6 @@ static void b43legacy_imcfglo_timeouts_w
+ #endif /* CONFIG_SSB_DRIVER_PCICORE */
+ }
+ 
+-/* Write the short and long frame retry limit values. */
+-static void b43legacy_set_retry_limits(struct b43legacy_wldev *dev,
+-				       unsigned int short_retry,
+-				       unsigned int long_retry)
+-{
+-	/* The retry limit is a 4-bit counter. Enforce this to avoid overflowing
+-	 * the chip-internal counter. */
+-	short_retry = min(short_retry, (unsigned int)0xF);
+-	long_retry = min(long_retry, (unsigned int)0xF);
+-
+-	b43legacy_shm_write16(dev, B43legacy_SHM_WIRELESS, 0x0006, short_retry);
+-	b43legacy_shm_write16(dev, B43legacy_SHM_WIRELESS, 0x0007, long_retry);
+-}
+-
+ static void b43legacy_set_synth_pu_delay(struct b43legacy_wldev *dev,
+ 					  bool idle) {
+ 	u16 pu_delay = 1050;
+@@ -3367,28 +3384,6 @@ static void b43legacy_op_stop(struct iee
+ 	mutex_unlock(&wl->mutex);
+ }
+ 
+-static int b43legacy_op_set_retry_limit(struct ieee80211_hw *hw,
+-					u32 short_retry_limit,
+-					u32 long_retry_limit)
+-{
+-	struct b43legacy_wl *wl = hw_to_b43legacy_wl(hw);
+-	struct b43legacy_wldev *dev;
+-	int err = 0;
+-
+-	mutex_lock(&wl->mutex);
+-	dev = wl->current_dev;
+-	if (unlikely(!dev ||
+-		     (b43legacy_status(dev) < B43legacy_STAT_INITIALIZED))) {
+-		err = -ENODEV;
+-		goto out_unlock;
+-	}
+-	b43legacy_set_retry_limits(dev, short_retry_limit, long_retry_limit);
+-out_unlock:
+-	mutex_unlock(&wl->mutex);
+-
+-	return err;
+-}
+-
+ static int b43legacy_op_beacon_set_tim(struct ieee80211_hw *hw,
+ 				       struct ieee80211_sta *sta, bool set)
+ {
+@@ -3414,7 +3409,6 @@ static const struct ieee80211_ops b43leg
+ 	.get_tx_stats		= b43legacy_op_get_tx_stats,
+ 	.start			= b43legacy_op_start,
+ 	.stop			= b43legacy_op_stop,
+-	.set_retry_limit	= b43legacy_op_set_retry_limit,
+ 	.set_tim		= b43legacy_op_beacon_set_tim,
+ };
+ 
+--- everything.orig/drivers/net/wireless/rt2x00/rt2400pci.c	2008-10-10 23:27:46.000000000 +0200
++++ everything/drivers/net/wireless/rt2x00/rt2400pci.c	2008-10-10 23:27:48.000000000 +0200
+@@ -1576,7 +1576,6 @@ static const struct ieee80211_ops rt2400
+ 	.config_interface	= rt2x00mac_config_interface,
+ 	.configure_filter	= rt2x00mac_configure_filter,
+ 	.get_stats		= rt2x00mac_get_stats,
+-	.set_retry_limit	= rt2400pci_set_retry_limit,
+ 	.bss_info_changed	= rt2x00mac_bss_info_changed,
+ 	.conf_tx		= rt2400pci_conf_tx,
+ 	.get_tx_stats		= rt2x00mac_get_tx_stats,
+@@ -1605,6 +1604,7 @@ static const struct rt2x00lib_ops rt2400
+ 	.config_intf		= rt2400pci_config_intf,
+ 	.config_erp		= rt2400pci_config_erp,
+ 	.config			= rt2400pci_config,
++	.set_retry_limit	= rt2400pci_set_retry_limit,
+ };
+ 
+ static const struct data_queue_desc rt2400pci_queue_rx = {
+--- everything.orig/drivers/net/wireless/rt2x00/rt2x00.h	2008-10-10 23:27:47.000000000 +0200
++++ everything/drivers/net/wireless/rt2x00/rt2x00.h	2008-10-10 23:27:48.000000000 +0200
+@@ -599,6 +599,9 @@ struct rt2x00lib_ops {
+ #define CONFIG_UPDATE_SLOT_TIME 	( 1 << 5 )
+ #define CONFIG_UPDATE_BEACON_INT	( 1 << 6 )
+ #define CONFIG_UPDATE_ALL		0xffff
++
++	int (*set_retry_limit) (struct ieee80211_hw *hw,
++				u32 short_limit, u32 long_limit);
+ };
+ 
+ /*
+--- everything.orig/drivers/net/wireless/rt2x00/rt2500pci.c	2008-10-10 23:27:46.000000000 +0200
++++ everything/drivers/net/wireless/rt2x00/rt2500pci.c	2008-10-10 23:27:48.000000000 +0200
+@@ -1877,7 +1877,6 @@ static const struct ieee80211_ops rt2500
+ 	.config_interface	= rt2x00mac_config_interface,
+ 	.configure_filter	= rt2x00mac_configure_filter,
+ 	.get_stats		= rt2x00mac_get_stats,
+-	.set_retry_limit	= rt2500pci_set_retry_limit,
+ 	.bss_info_changed	= rt2x00mac_bss_info_changed,
+ 	.conf_tx		= rt2x00mac_conf_tx,
+ 	.get_tx_stats		= rt2x00mac_get_tx_stats,
+@@ -1906,6 +1905,7 @@ static const struct rt2x00lib_ops rt2500
+ 	.config_intf		= rt2500pci_config_intf,
+ 	.config_erp		= rt2500pci_config_erp,
+ 	.config			= rt2500pci_config,
++	.set_retry_limit	= rt2500pci_set_retry_limit,
+ };
+ 
+ static const struct data_queue_desc rt2500pci_queue_rx = {
+--- everything.orig/drivers/net/wireless/rt2x00/rt61pci.c	2008-10-10 23:27:47.000000000 +0200
++++ everything/drivers/net/wireless/rt2x00/rt61pci.c	2008-10-10 23:27:48.000000000 +0200
+@@ -2726,7 +2726,6 @@ static const struct ieee80211_ops rt61pc
+ 	.configure_filter	= rt2x00mac_configure_filter,
+ 	.set_key		= rt2x00mac_set_key,
+ 	.get_stats		= rt2x00mac_get_stats,
+-	.set_retry_limit	= rt61pci_set_retry_limit,
+ 	.bss_info_changed	= rt2x00mac_bss_info_changed,
+ 	.conf_tx		= rt61pci_conf_tx,
+ 	.get_tx_stats		= rt2x00mac_get_tx_stats,
+@@ -2759,6 +2758,7 @@ static const struct rt2x00lib_ops rt61pc
+ 	.config_intf		= rt61pci_config_intf,
+ 	.config_erp		= rt61pci_config_erp,
+ 	.config			= rt61pci_config,
++	.set_retry_limit	= rt61pci_set_retry_limit,
+ };
+ 
+ static const struct data_queue_desc rt61pci_queue_rx = {
+--- everything.orig/drivers/net/wireless/rt2x00/rt73usb.c	2008-10-10 23:27:47.000000000 +0200
++++ everything/drivers/net/wireless/rt2x00/rt73usb.c	2008-10-10 23:27:48.000000000 +0200
+@@ -2317,7 +2317,6 @@ static const struct ieee80211_ops rt73us
+ 	.configure_filter	= rt2x00mac_configure_filter,
+ 	.set_key		= rt2x00mac_set_key,
+ 	.get_stats		= rt2x00mac_get_stats,
+-	.set_retry_limit	= rt73usb_set_retry_limit,
+ 	.bss_info_changed	= rt2x00mac_bss_info_changed,
+ 	.conf_tx		= rt73usb_conf_tx,
+ 	.get_tx_stats		= rt2x00mac_get_tx_stats,
+@@ -2349,6 +2348,7 @@ static const struct rt2x00lib_ops rt73us
+ 	.config_intf		= rt73usb_config_intf,
+ 	.config_erp		= rt73usb_config_erp,
+ 	.config			= rt73usb_config,
++	.set_retry_limit	= rt73usb_set_retry_limit,
+ };
+ 
+ static const struct data_queue_desc rt73usb_queue_rx = {
+--- everything.orig/drivers/net/wireless/rt2x00/rt2x00mac.c	2008-10-10 23:27:46.000000000 +0200
++++ everything/drivers/net/wireless/rt2x00/rt2x00mac.c	2008-10-10 23:31:23.000000000 +0200
+@@ -349,6 +349,15 @@ int rt2x00mac_config(struct ieee80211_hw
+ 	if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags))
+ 		return 0;
+ 
++	if (changed & IEEE80211_CONF_CHANGE_RETRY_LIMITS) {
++		rt2x00dev->ops->lib->set_retry_limit(hw,
++			conf->short_frame_max_tx_count,
++			conf->long_frame_max_tx_count);
++	}
++	changed &= ~IEEE80211_CONF_CHANGE_RETRY_LIMITS;
++	if (!changed)
++		return 0;
++
+ 	/*
+ 	 * Only change device state when the radio is enabled. It does not
+ 	 * matter what parameters we have configured when the radio is disabled
+--- everything.orig/net/mac80211/debugfs.c	2008-10-10 23:27:46.000000000 +0200
++++ everything/net/mac80211/debugfs.c	2008-10-10 23:27:48.000000000 +0200
+@@ -52,9 +52,9 @@ DEBUGFS_READONLY_FILE(rts_threshold, 20,
+ DEBUGFS_READONLY_FILE(fragmentation_threshold, 20, "%d",
+ 		      local->fragmentation_threshold);
+ DEBUGFS_READONLY_FILE(short_retry_limit, 20, "%d",
+-		      local->short_retry_limit);
++		      local->hw.conf.short_frame_max_tx_count);
+ DEBUGFS_READONLY_FILE(long_retry_limit, 20, "%d",
+-		      local->long_retry_limit);
++		      local->hw.conf.long_frame_max_tx_count);
+ DEBUGFS_READONLY_FILE(total_ps_buffered, 20, "%d",
+ 		      local->total_ps_buffered);
+ DEBUGFS_READONLY_FILE(wep_iv, 20, "%#06x",
+--- everything.orig/net/mac80211/tx.c	2008-10-10 23:27:46.000000000 +0200
++++ everything/net/mac80211/tx.c	2008-10-10 23:31:22.000000000 +0200
+@@ -507,10 +507,10 @@ ieee80211_tx_h_misc(struct ieee80211_tx_
+ 				info->flags |=
+ 					IEEE80211_TX_CTL_LONG_RETRY_LIMIT;
+ 				info->control.retry_limit =
+-					tx->local->long_retry_limit;
++					tx->local->hw.conf.long_frame_max_tx_count - 1;
+ 			} else {
+ 				info->control.retry_limit =
+-					tx->local->short_retry_limit;
++					tx->local->hw.conf.short_frame_max_tx_count - 1;
+ 			}
+ 		} else {
+ 			info->control.retry_limit = 1;
diff --git a/package/mac80211/patches/425-rewrite-rate-api.patch b/package/mac80211/patches/425-rewrite-rate-api.patch
new file mode 100644
index 0000000000..c0652a0b0d
--- /dev/null
+++ b/package/mac80211/patches/425-rewrite-rate-api.patch
@@ -0,0 +1,3005 @@
+Subject: mac80211/drivers: rewrite the rate control API
+
+So after the previous changes we were still unhappy with how
+convoluted the API is and decided to make things simpler for
+everybody. This completely changes the rate control API, now
+taking into account 802.11n with MCS rates and more control,
+most drivers don't support that though.
+
+Signed-off-by: Felix Fietkau <nbd@openwrt.org>
+Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
+---
+ drivers/net/wireless/adm8211.c              |   21 -
+ drivers/net/wireless/ath5k/base.c           |   34 +-
+ drivers/net/wireless/ath9k/main.c           |   18 -
+ drivers/net/wireless/ath9k/rc.c             |   40 +--
+ drivers/net/wireless/ath9k/xmit.c           |   28 +-
+ drivers/net/wireless/b43/dma.c              |    4 
+ drivers/net/wireless/b43/main.c             |    2 
+ drivers/net/wireless/b43/pio.c              |    4 
+ drivers/net/wireless/b43/xmit.c             |   60 +++-
+ drivers/net/wireless/b43/xmit.h             |    5 
+ drivers/net/wireless/b43legacy/dma.c        |   46 ++-
+ drivers/net/wireless/b43legacy/main.c       |    2 
+ drivers/net/wireless/b43legacy/pio.c        |   31 ++
+ drivers/net/wireless/b43legacy/xmit.c       |   26 +-
+ drivers/net/wireless/b43legacy/xmit.h       |    2 
+ drivers/net/wireless/iwlwifi/iwl-3945-rs.c  |   57 +---
+ drivers/net/wireless/iwlwifi/iwl-3945.c     |   62 ++++-
+ drivers/net/wireless/iwlwifi/iwl-3945.h     |    2 
+ drivers/net/wireless/iwlwifi/iwl-4965.c     |    8 
+ drivers/net/wireless/iwlwifi/iwl-5000.c     |    8 
+ drivers/net/wireless/iwlwifi/iwl-agn-rs.c   |   37 +-
+ drivers/net/wireless/iwlwifi/iwl-core.c     |   19 -
+ drivers/net/wireless/iwlwifi/iwl3945-base.c |    5 
+ drivers/net/wireless/libertas_tf/main.c     |    4 
+ drivers/net/wireless/mac80211_hwsim.c       |   12 
+ drivers/net/wireless/p54/p54common.c        |   16 -
+ drivers/net/wireless/rt2x00/rt2x00dev.c     |   11 
+ drivers/net/wireless/rt2x00/rt2x00mac.c     |   14 -
+ drivers/net/wireless/rt2x00/rt2x00queue.c   |   11 
+ drivers/net/wireless/rtl8180_dev.c          |   28 +-
+ drivers/net/wireless/rtl8187_dev.c          |   10 
+ drivers/net/wireless/zd1211rw/zd_mac.c      |   28 +-
+ include/net/mac80211.h                      |  206 +++++++++-------
+ net/mac80211/ieee80211_i.h                  |    8 
+ net/mac80211/main.c                         |   54 +++-
+ net/mac80211/mesh_hwmp.c                    |    6 
+ net/mac80211/rate.c                         |   50 +---
+ net/mac80211/rate.h                         |    5 
+ net/mac80211/rc80211_minstrel.c             |   72 ++---
+ net/mac80211/rc80211_pid.h                  |    1 
+ net/mac80211/rc80211_pid_algo.c             |   26 +-
+ net/mac80211/rc80211_pid_debugfs.c          |    5 
+ net/mac80211/sta_info.h                     |    4 
+ net/mac80211/tx.c                           |  347 +++++++++++-----------------
+ net/mac80211/wext.c                         |    4 
+ 45 files changed, 781 insertions(+), 662 deletions(-)
+
+--- a/include/net/mac80211.h
++++ b/include/net/mac80211.h
+@@ -222,29 +222,24 @@ struct ieee80211_bss_conf {
+  * These flags are used with the @flags member of &ieee80211_tx_info.
+  *
+  * @IEEE80211_TX_CTL_REQ_TX_STATUS: request TX status callback for this frame.
+- * @IEEE80211_TX_CTL_USE_RTS_CTS: use RTS-CTS before sending frame
+- * @IEEE80211_TX_CTL_USE_CTS_PROTECT: use CTS protection for the frame (e.g.,
+- *	for combined 802.11g / 802.11b networks)
++ * @IEEE80211_TX_CTL_ASSIGN_SEQ: The driver has to assign a sequence
++ *	number to this frame, taking care of not overwriting the fragment
++ *	number and increasing the sequence number only when the
++ *	IEEE80211_TX_CTL_FIRST_FRAGMENT flags is set. mac80211 will properly
++ *	assign sequence numbers to QoS-data frames but cannot do so correctly
++ *	for non-QoS-data and management frames because beacons need them from
++ *	that counter as well and mac80211 cannot guarantee proper sequencing.
++ *	If this flag is set, the driver should instruct the hardware to
++ *	assign a sequence number to the frame or assign one itself. Cf. IEEE
++ *	802.11-2007 7.1.3.4.1 paragraph 3. This flag will always be set for
++ *	beacons always be clear for frames without a sequence number field.
+  * @IEEE80211_TX_CTL_NO_ACK: tell the low level not to wait for an ack
+- * @IEEE80211_TX_CTL_RATE_CTRL_PROBE: TBD
+  * @IEEE80211_TX_CTL_CLEAR_PS_FILT: clear powersave filter for destination
+  *	station
+- * @IEEE80211_TX_CTL_REQUEUE: TBD
+  * @IEEE80211_TX_CTL_FIRST_FRAGMENT: this is a first fragment of the frame
+- * @IEEE80211_TX_CTL_SHORT_PREAMBLE: TBD
+- * @IEEE80211_TX_CTL_LONG_RETRY_LIMIT: this frame should be send using the
+- *	through set_retry_limit configured long retry value
+  * @IEEE80211_TX_CTL_SEND_AFTER_DTIM: send this frame after DTIM beacon
+  * @IEEE80211_TX_CTL_AMPDU: this frame should be sent as part of an A-MPDU
+- * @IEEE80211_TX_CTL_OFDM_HT: this frame can be sent in HT OFDM rates. number
+- *	of streams when this flag is on can be extracted from antenna_sel_tx,
+- *	so if 1 antenna is marked use SISO, 2 antennas marked use MIMO, n
+- *	antennas marked use MIMO_n.
+- * @IEEE80211_TX_CTL_GREEN_FIELD: use green field protection for this frame
+- * @IEEE80211_TX_CTL_40_MHZ_WIDTH: send this frame using 40 Mhz channel width
+- * @IEEE80211_TX_CTL_DUP_DATA: duplicate data frame on both 20 Mhz channels
+- * @IEEE80211_TX_CTL_SHORT_GI: send this frame using short guard interval
+- * @IEEE80211_TX_CTL_INJECTED: TBD
++ * @IEEE80211_TX_CTL_INJECTED: Frame was injected, internal to mac80211.
+  * @IEEE80211_TX_STAT_TX_FILTERED: The frame was not transmitted
+  *	because the destination STA was in powersave mode.
+  * @IEEE80211_TX_STAT_ACK: Frame was acknowledged
+@@ -252,42 +247,41 @@ struct ieee80211_bss_conf {
+  * 	is for the whole aggregation.
+  * @IEEE80211_TX_STAT_AMPDU_NO_BACK: no block ack was returned,
+  * 	so consider using block ack request (BAR).
+- * @IEEE80211_TX_CTL_ASSIGN_SEQ: The driver has to assign a sequence
+- *	number to this frame, taking care of not overwriting the fragment
+- *	number and increasing the sequence number only when the
+- *	IEEE80211_TX_CTL_FIRST_FRAGMENT flags is set. mac80211 will properly
+- *	assign sequence numbers to QoS-data frames but cannot do so correctly
+- *	for non-QoS-data and management frames because beacons need them from
+- *	that counter as well and mac80211 cannot guarantee proper sequencing.
+- *	If this flag is set, the driver should instruct the hardware to
+- *	assign a sequence number to the frame or assign one itself. Cf. IEEE
+- *	802.11-2007 7.1.3.4.1 paragraph 3. This flag will always be set for
+- *	beacons always be clear for frames without a sequence number field.
++ * @IEEE80211_TX_CTL_RATE_CTRL_PROBE: internal to mac80211, can be
++ *	set by rate control algorithms to indicate probe rate, will
++ *	be cleared for fragmented frames (except on the last fragment)
++ * @IEEE80211_TX_CTL_REQUEUE: REMOVE THIS
+  */
+ enum mac80211_tx_control_flags {
+ 	IEEE80211_TX_CTL_REQ_TX_STATUS		= BIT(0),
+-	IEEE80211_TX_CTL_USE_RTS_CTS		= BIT(2),
+-	IEEE80211_TX_CTL_USE_CTS_PROTECT	= BIT(3),
+-	IEEE80211_TX_CTL_NO_ACK			= BIT(4),
+-	IEEE80211_TX_CTL_RATE_CTRL_PROBE	= BIT(5),
+-	IEEE80211_TX_CTL_CLEAR_PS_FILT		= BIT(6),
+-	IEEE80211_TX_CTL_REQUEUE		= BIT(7),
+-	IEEE80211_TX_CTL_FIRST_FRAGMENT		= BIT(8),
+-	IEEE80211_TX_CTL_SHORT_PREAMBLE		= BIT(9),
+-	IEEE80211_TX_CTL_LONG_RETRY_LIMIT	= BIT(10),
+-	IEEE80211_TX_CTL_SEND_AFTER_DTIM	= BIT(12),
+-	IEEE80211_TX_CTL_AMPDU			= BIT(13),
+-	IEEE80211_TX_CTL_OFDM_HT		= BIT(14),
+-	IEEE80211_TX_CTL_GREEN_FIELD		= BIT(15),
+-	IEEE80211_TX_CTL_40_MHZ_WIDTH		= BIT(16),
+-	IEEE80211_TX_CTL_DUP_DATA		= BIT(17),
+-	IEEE80211_TX_CTL_SHORT_GI		= BIT(18),
+-	IEEE80211_TX_CTL_INJECTED		= BIT(19),
+-	IEEE80211_TX_STAT_TX_FILTERED		= BIT(20),
+-	IEEE80211_TX_STAT_ACK			= BIT(21),
+-	IEEE80211_TX_STAT_AMPDU			= BIT(22),
+-	IEEE80211_TX_STAT_AMPDU_NO_BACK		= BIT(23),
+-	IEEE80211_TX_CTL_ASSIGN_SEQ		= BIT(24),
++	IEEE80211_TX_CTL_ASSIGN_SEQ		= BIT(1),
++	IEEE80211_TX_CTL_NO_ACK			= BIT(2),
++	IEEE80211_TX_CTL_CLEAR_PS_FILT		= BIT(3),
++	IEEE80211_TX_CTL_FIRST_FRAGMENT		= BIT(4),
++	IEEE80211_TX_CTL_SEND_AFTER_DTIM	= BIT(5),
++	IEEE80211_TX_CTL_AMPDU			= BIT(6),
++	IEEE80211_TX_CTL_INJECTED		= BIT(7),
++	IEEE80211_TX_STAT_TX_FILTERED		= BIT(8),
++	IEEE80211_TX_STAT_ACK			= BIT(9),
++	IEEE80211_TX_STAT_AMPDU			= BIT(10),
++	IEEE80211_TX_STAT_AMPDU_NO_BACK		= BIT(11),
++	IEEE80211_TX_CTL_RATE_CTRL_PROBE	= BIT(12),
++
++	/* XXX: remove this */
++	IEEE80211_TX_CTL_REQUEUE		= BIT(13),
++};
++
++enum mac80211_rate_control_flags {
++	IEEE80211_TX_RC_USE_RTS_CTS		= BIT(0),
++	IEEE80211_TX_RC_USE_CTS_PROTECT		= BIT(1),
++	IEEE80211_TX_RC_USE_SHORT_PREAMBLE	= BIT(2),
++
++	/* rate index is an MCS rate number instead of an index */
++	IEEE80211_TX_RC_MCS			= BIT(3),
++	IEEE80211_TX_RC_GREEN_FIELD		= BIT(4),
++	IEEE80211_TX_RC_40_MHZ_WIDTH		= BIT(5),
++	IEEE80211_TX_RC_DUP_DATA		= BIT(6),
++	IEEE80211_TX_RC_SHORT_GI		= BIT(7),
+ };
+ 
+ 
+@@ -296,18 +290,26 @@ enum mac80211_tx_control_flags {
+ #define IEEE80211_TX_INFO_DRIVER_DATA_PTRS \
+ 	(IEEE80211_TX_INFO_DRIVER_DATA_SIZE / sizeof(void *))
+ 
+-/* maximum number of alternate rate retry stages */
+-#define IEEE80211_TX_MAX_ALTRATE	3
++/* maximum number of rate stages */
++#define IEEE80211_TX_MAX_RATES	4
+ 
+ /**
+- * struct ieee80211_tx_altrate - alternate rate selection/status
++ * struct ieee80211_tx_rate - rate selection/status
+  *
+- * @rate_idx: rate index to attempt to send with
++ * @idx: rate index to attempt to send with
++ * @flags: rate control flags (&enum mac80211_rate_control_flags)
+  * @limit: number of retries before fallback
++ *
++ * A value of -1 for @idx indicates an invalid rate and, if used
++ * in an array of retry rates, that no more rates should be tried.
++ *
++ * When used for transmit status reporting, the driver should
++ * always report the rate along with the flags it used.
+  */
+-struct ieee80211_tx_altrate {
+-	s8 rate_idx;
+-	u8 limit;
++struct ieee80211_tx_rate {
++	s8 idx;
++	u8 count;
++	u8 flags;
+ };
+ 
+ /**
+@@ -322,15 +324,12 @@ struct ieee80211_tx_altrate {
+  * it may be NULL.
+  *
+  * @flags: transmit info flags, defined above
+- * @band: TBD
+- * @tx_rate_idx: TBD
++ * @band: the band to transmit on (use for checking for races)
+  * @antenna_sel_tx: antenna to use, 0 for automatic diversity
+  * @control: union for control data
+  * @status: union for status data
+  * @driver_data: array of driver_data pointers
+  * @retry_count: number of retries
+- * @excessive_retries: set to 1 if the frame was retried many times
+- *	but not acknowledged
+  * @ampdu_ack_len: number of aggregated frames.
+  * 	relevant only if IEEE80211_TX_STATUS_AMPDU was set.
+  * @ampdu_ack_map: block ack bit map for the aggregation.
+@@ -341,28 +340,28 @@ struct ieee80211_tx_info {
+ 	/* common information */
+ 	u32 flags;
+ 	u8 band;
+-	s8 tx_rate_idx;
++
+ 	u8 antenna_sel_tx;
+ 
+-	/* 1 byte hole */
++	/* 2 byte hole */
+ 
+ 	union {
+ 		struct {
++			union {
++			struct ieee80211_tx_rate rates[IEEE80211_TX_MAX_RATES];
++			/* we need the jiffies only before rate control */
++			unsigned long jiffies;
++			};
++			s8 rts_cts_rate_idx;
+ 			/* NB: vif can be NULL for injected frames */
+ 			struct ieee80211_vif *vif;
+ 			struct ieee80211_key_conf *hw_key;
+ 			struct ieee80211_sta *sta;
+-			unsigned long jiffies;
+-			s8 rts_cts_rate_idx;
+-			u8 retry_limit;
+-			struct ieee80211_tx_altrate retries[IEEE80211_TX_MAX_ALTRATE];
+ 		} control;
+ 		struct {
++			struct ieee80211_tx_rate rates[IEEE80211_TX_MAX_RATES];
+ 			u64 ampdu_ack_map;
+ 			int ack_signal;
+-			struct ieee80211_tx_altrate retries[IEEE80211_TX_MAX_ALTRATE + 1];
+-			u8 retry_count;
+-			bool excessive_retries;
+ 			u8 ampdu_ack_len;
+ 		} status;
+ 		void *driver_data[IEEE80211_TX_INFO_DRIVER_DATA_PTRS];
+@@ -374,6 +373,22 @@ static inline struct ieee80211_tx_info *
+ 	return (struct ieee80211_tx_info *)skb->cb;
+ }
+ 
++static inline void
++ieee80211_tx_info_clear_status(struct ieee80211_tx_info *info)
++{
++	int i;
++
++	BUILD_BUG_ON(offsetof(struct ieee80211_tx_info, status.rates) !=
++		     offsetof(struct ieee80211_tx_info, control.rates));
++	/* clear the rate counts */
++	for (i = 0; i < IEEE80211_TX_MAX_RATES; i++)
++		info->status.rates[i].count = 0;
++
++	memset(&info->status.ampdu_ack_map, 0,
++	       sizeof(struct ieee80211_tx_info) -
++	       offsetof(struct ieee80211_tx_info, status.ampdu_ack_map));
++}
++
+ 
+ /**
+  * enum mac80211_rx_flags - receive flags
+@@ -875,8 +890,8 @@ enum ieee80211_hw_flags {
+  * @sta_data_size: size (in bytes) of the drv_priv data area
+  *	within &struct ieee80211_sta.
+  *
+- * @max_altrates: maximum number of alternate rate retry stages
+- * @max_altrate_tries: maximum number of tries for each stage
++ * @max_rates: maximum number of alternate rate retry stages
++ * @max_rate_tries: maximum number of tries for each stage
+  */
+ struct ieee80211_hw {
+ 	struct ieee80211_conf conf;
+@@ -893,8 +908,8 @@ struct ieee80211_hw {
+ 	u16 ampdu_queues;
+ 	u16 max_listen_interval;
+ 	s8 max_signal;
+-	u8 max_altrates;
+-	u8 max_altrate_tries;
++	u8 max_rates;
++	u8 max_rate_tries;
+ };
+ 
+ /**
+@@ -933,9 +948,9 @@ static inline struct ieee80211_rate *
+ ieee80211_get_tx_rate(const struct ieee80211_hw *hw,
+ 		      const struct ieee80211_tx_info *c)
+ {
+-	if (WARN_ON(c->tx_rate_idx < 0))
++	if (WARN_ON(c->control.rates[0].idx < 0))
+ 		return NULL;
+-	return &hw->wiphy->bands[c->band]->bitrates[c->tx_rate_idx];
++	return &hw->wiphy->bands[c->band]->bitrates[c->control.rates[0].idx];
+ }
+ 
+ static inline struct ieee80211_rate *
+@@ -951,9 +966,9 @@ static inline struct ieee80211_rate *
+ ieee80211_get_alt_retry_rate(const struct ieee80211_hw *hw,
+ 			     const struct ieee80211_tx_info *c, int idx)
+ {
+-	if (c->control.retries[idx].rate_idx < 0)
++	if (c->control.rates[idx + 1].idx < 0)
+ 		return NULL;
+-	return &hw->wiphy->bands[c->band]->bitrates[c->control.retries[idx].rate_idx];
++	return &hw->wiphy->bands[c->band]->bitrates[c->control.rates[idx + 1].idx];
+ }
+ 
+ /**
+@@ -1847,17 +1862,28 @@ struct ieee80211_sta *ieee80211_find_sta
+ 
+ 
+ /* Rate control API */
++
+ /**
+- * struct rate_selection - rate information for/from rate control algorithms
++ * struct ieee80211_tx_rate_control - rate control information for/from RC algo
+  *
+- * @rate_idx: selected transmission rate index
+- * @nonerp_idx: Non-ERP rate to use instead if ERP cannot be used
+- * @probe_idx: rate for probing (or -1)
+- * @max_rate_idx: maximum rate index that can be used, this is
+- *	input to the algorithm and will be enforced
+- */
+-struct rate_selection {
+-	s8 rate_idx, nonerp_idx, probe_idx, max_rate_idx;
++ * @sband: The band this frame is being transmitted on.
++ * @bss_conf: the current BSS configuration
++ * @reported_rate: The rate control algorithm can fill this in to indicate
++ *	which rate should be reported to userspace as the current rate and
++ *	used for rate calculations in the mesh network.
++ * @rts: whether RTS will be used for this frame because it is longer than the
++ *	RTS threshold
++ * @short_preamble: whether mac80211 will request short-preamble transmission
++ *	if the selected rate supports it
++ * @max_rate_idx: user-requested maximum rate (not MCS for now)
++ */
++struct ieee80211_tx_rate_control {
++	struct ieee80211_supported_band *sband;
++	struct ieee80211_bss_conf *bss_conf;
++	struct sk_buff *skb;
++	struct ieee80211_tx_rate reported_rate;
++	bool rts, short_preamble;
++	u8 max_rate_idx;
+ };
+ 
+ struct rate_control_ops {
+@@ -1876,10 +1902,8 @@ struct rate_control_ops {
+ 	void (*tx_status)(void *priv, struct ieee80211_supported_band *sband,
+ 			  struct ieee80211_sta *sta, void *priv_sta,
+ 			  struct sk_buff *skb);
+-	void (*get_rate)(void *priv, struct ieee80211_supported_band *sband,
+-			 struct ieee80211_sta *sta, void *priv_sta,
+-			 struct sk_buff *skb,
+-			 struct rate_selection *sel);
++	void (*get_rate)(void *priv, struct ieee80211_sta *sta, void *priv_sta,
++			 struct ieee80211_tx_rate_control *txrc);
+ 
+ 	void (*add_sta_debugfs)(void *priv, void *priv_sta,
+ 				struct dentry *dir);
+--- a/net/mac80211/main.c
++++ b/net/mac80211/main.c
+@@ -41,6 +41,8 @@
+  */
+ struct ieee80211_tx_status_rtap_hdr {
+ 	struct ieee80211_radiotap_header hdr;
++	u8 rate;
++	u8 padding_for_rate;
+ 	__le16 tx_flags;
+ 	u8 data_retries;
+ } __attribute__ ((packed));
+@@ -463,13 +465,28 @@ void ieee80211_tx_status(struct ieee8021
+ 	struct ieee80211_sub_if_data *sdata;
+ 	struct net_device *prev_dev = NULL;
+ 	struct sta_info *sta;
++	int retry_count = -1, i;
++
++	for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
++		/* the HW cannot have attempted that rate */
++		if (i >= hw->max_rates) {
++			info->status.rates[i].idx = -1;
++			info->status.rates[i].count = 0;
++		}
++
++		retry_count += info->status.rates[i].count;
++	}
++	if (retry_count < 0)
++		retry_count = 0;
+ 
+ 	rcu_read_lock();
+ 
++	sband = local->hw.wiphy->bands[info->band];
++
+ 	sta = sta_info_get(local, hdr->addr1);
+ 
+ 	if (sta) {
+-		if (info->status.excessive_retries &&
++		if (!(info->flags & IEEE80211_TX_STAT_ACK) &&
+ 		    test_sta_flags(sta, WLAN_STA_PS)) {
+ 			/*
+ 			 * The STA is in power save mode, so assume
+@@ -500,12 +517,11 @@ void ieee80211_tx_status(struct ieee8021
+ 			rcu_read_unlock();
+ 			return;
+ 		} else {
+-			if (info->status.excessive_retries)
++			if (!(info->flags & IEEE80211_TX_STAT_ACK))
+ 				sta->tx_retry_failed++;
+-			sta->tx_retry_count += info->status.retry_count;
++			sta->tx_retry_count += retry_count;
+ 		}
+ 
+-		sband = local->hw.wiphy->bands[info->band];
+ 		rate_control_tx_status(local, sband, sta, skb);
+ 	}
+ 
+@@ -526,9 +542,9 @@ void ieee80211_tx_status(struct ieee8021
+ 			local->dot11TransmittedFrameCount++;
+ 			if (is_multicast_ether_addr(hdr->addr1))
+ 				local->dot11MulticastTransmittedFrameCount++;
+-			if (info->status.retry_count > 0)
++			if (retry_count > 0)
+ 				local->dot11RetryCount++;
+-			if (info->status.retry_count > 1)
++			if (retry_count > 1)
+ 				local->dot11MultipleRetryCount++;
+ 		}
+ 
+@@ -572,19 +588,30 @@ void ieee80211_tx_status(struct ieee8021
+ 	rthdr->hdr.it_len = cpu_to_le16(sizeof(*rthdr));
+ 	rthdr->hdr.it_present =
+ 		cpu_to_le32((1 << IEEE80211_RADIOTAP_TX_FLAGS) |
+-			    (1 << IEEE80211_RADIOTAP_DATA_RETRIES));
++			    (1 << IEEE80211_RADIOTAP_DATA_RETRIES) |
++			    (1 << IEEE80211_RADIOTAP_RATE));
+ 
+ 	if (!(info->flags & IEEE80211_TX_STAT_ACK) &&
+ 	    !is_multicast_ether_addr(hdr->addr1))
+ 		rthdr->tx_flags |= cpu_to_le16(IEEE80211_RADIOTAP_F_TX_FAIL);
+ 
+-	if ((info->flags & IEEE80211_TX_CTL_USE_RTS_CTS) &&
+-	    (info->flags & IEEE80211_TX_CTL_USE_CTS_PROTECT))
++	/*
++	 * XXX: Once radiotap gets the bitmap reset thing the vendor
++	 *	extensions proposal contains, we can actually report
++	 *	the whole set of tries we did.
++	 */
++	if ((info->status.rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS) ||
++	    (info->status.rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT))
+ 		rthdr->tx_flags |= cpu_to_le16(IEEE80211_RADIOTAP_F_TX_CTS);
+-	else if (info->flags & IEEE80211_TX_CTL_USE_RTS_CTS)
++	else if (info->status.rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS)
+ 		rthdr->tx_flags |= cpu_to_le16(IEEE80211_RADIOTAP_F_TX_RTS);
++	if (info->status.rates[0].idx >= 0 &&
++	    !(info->status.rates[0].flags & IEEE80211_TX_RC_MCS))
++		rthdr->rate = sband->bitrates[
++				info->status.rates[0].idx].bitrate / 5;
+ 
+-	rthdr->data_retries = info->status.retry_count;
++	/* for now report the total retry_count */
++	rthdr->data_retries = retry_count;
+ 
+ 	/* XXX: is this sufficient for BPF? */
+ 	skb_set_mac_header(skb, 0);
+@@ -669,8 +696,9 @@ struct ieee80211_hw *ieee80211_alloc_hw(
+ 	BUG_ON(!ops->configure_filter);
+ 	local->ops = ops;
+ 
+-	local->hw.queues = 1; /* default */
+-
++	/* set up some defaults */
++	local->hw.queues = 1;
++	local->hw.max_rates = 1;
+ 	local->rts_threshold = IEEE80211_MAX_RTS_THRESHOLD;
+ 	local->fragmentation_threshold = IEEE80211_MAX_FRAG_THRESHOLD;
+ 	local->hw.conf.long_frame_max_tx_count = 4;
+--- a/net/mac80211/tx.c
++++ b/net/mac80211/tx.c
+@@ -46,13 +46,20 @@ static __le16 ieee80211_duration(struct 
+ 	struct ieee80211_local *local = tx->local;
+ 	struct ieee80211_supported_band *sband;
+ 	struct ieee80211_hdr *hdr;
++	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
++
++	/* assume HW handles this */
++	if (info->control.rates[0].flags & IEEE80211_TX_RC_MCS)
++		return 0;
++
++	/* uh huh? */
++	if (WARN_ON(info->control.rates[0].idx < 0))
++		return 0;
+ 
+ 	sband = local->hw.wiphy->bands[tx->channel->band];
+-	txrate = &sband->bitrates[tx->rate_idx];
++	txrate = &sband->bitrates[info->control.rates[0].idx];
+ 
+-	erp = 0;
+-	if (tx->sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
+-		erp = txrate->flags & IEEE80211_RATE_ERP_G;
++	erp = txrate->flags & IEEE80211_RATE_ERP_G;
+ 
+ 	/*
+ 	 * data and mgmt (except PS Poll):
+@@ -439,140 +446,123 @@ ieee80211_tx_h_select_key(struct ieee802
+ static ieee80211_tx_result debug_noinline
+ ieee80211_tx_h_rate_ctrl(struct ieee80211_tx_data *tx)
+ {
+-	struct rate_selection rsel;
+-	struct ieee80211_supported_band *sband;
+ 	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
++	struct ieee80211_hdr *hdr = (void *)tx->skb->data;
++	struct ieee80211_supported_band *sband;
++	struct ieee80211_rate *rate;
++	int i, len;
++	bool inval = false, rts = false, short_preamble = false;
++	struct ieee80211_tx_rate_control txrc;
+ 
+-	sband = tx->local->hw.wiphy->bands[tx->channel->band];
++	memset(&txrc, 0, sizeof(txrc));
+ 
+-	if (likely(tx->rate_idx < 0)) {
+-		rate_control_get_rate(tx->sdata, sband, tx->sta,
+-				      tx->skb, &rsel);
+-		if (tx->sta)
+-			tx->sta->last_txrate_idx = rsel.rate_idx;
+-		tx->rate_idx = rsel.rate_idx;
+-		if (unlikely(rsel.probe_idx >= 0)) {
+-			info->flags |= IEEE80211_TX_CTL_RATE_CTRL_PROBE;
+-			tx->flags |= IEEE80211_TX_PROBE_LAST_FRAG;
+-			info->control.retries[0].rate_idx = tx->rate_idx;
+-			info->control.retries[0].limit = tx->local->hw.max_altrate_tries;
+-			tx->rate_idx = rsel.probe_idx;
+-		} else if (info->control.retries[0].limit == 0)
+-			info->control.retries[0].rate_idx = -1;
++	sband = tx->local->hw.wiphy->bands[tx->channel->band];
+ 
+-		if (unlikely(tx->rate_idx < 0))
+-			return TX_DROP;
+-	} else
+-		info->control.retries[0].rate_idx = -1;
++	len = min_t(int, tx->skb->len + FCS_LEN,
++			 tx->local->fragmentation_threshold);
+ 
+-	if (tx->sdata->vif.bss_conf.use_cts_prot &&
+-	    (tx->flags & IEEE80211_TX_FRAGMENTED) && (rsel.nonerp_idx >= 0)) {
+-		tx->last_frag_rate_idx = tx->rate_idx;
+-		if (rsel.probe_idx >= 0)
+-			tx->flags &= ~IEEE80211_TX_PROBE_LAST_FRAG;
+-		else
+-			tx->flags |= IEEE80211_TX_PROBE_LAST_FRAG;
+-		tx->rate_idx = rsel.nonerp_idx;
+-		info->tx_rate_idx = rsel.nonerp_idx;
+-		info->flags &= ~IEEE80211_TX_CTL_RATE_CTRL_PROBE;
+-	} else {
+-		tx->last_frag_rate_idx = tx->rate_idx;
+-		info->tx_rate_idx = tx->rate_idx;
++	/* set up the tx rate control struct we give the RC algo */
++	txrc.sband = sband;
++	txrc.bss_conf = &tx->sdata->vif.bss_conf;
++	txrc.skb = tx->skb;
++	txrc.reported_rate.idx = -1;
++	txrc.max_rate_idx = tx->sdata->max_ratectrl_rateidx;
++
++	/* set up RTS protection if desired */
++	if (tx->local->rts_threshold < IEEE80211_MAX_RTS_THRESHOLD &&
++	    len > tx->local->rts_threshold) {
++		txrc.rts = rts = true;
+ 	}
+-	info->tx_rate_idx = tx->rate_idx;
+ 
+-	return TX_CONTINUE;
+-}
++	/* XXX: Is this really the right thing to check? */
++	if (ieee80211_is_data(hdr->frame_control) &&
++	    tx->sdata->vif.bss_conf.use_short_preamble &&
++	    (!tx->sta || test_sta_flags(tx->sta, WLAN_STA_SHORT_PREAMBLE)))
++		txrc.short_preamble = short_preamble = true;
+ 
+-static ieee80211_tx_result debug_noinline
+-ieee80211_tx_h_misc(struct ieee80211_tx_data *tx)
+-{
+-	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data;
+-	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
+-	struct ieee80211_supported_band *sband;
+ 
+-	sband = tx->local->hw.wiphy->bands[tx->channel->band];
++	rate_control_get_rate(tx->sdata, tx->sta, &txrc);
++
++	if (unlikely(info->control.rates[0].idx < 0))
++		return TX_DROP;
++
++	if (txrc.reported_rate.idx < 0)
++		txrc.reported_rate = info->control.rates[0];
+ 
+ 	if (tx->sta)
+-		info->control.sta = &tx->sta->sta;
++		tx->sta->last_tx_rate = txrc.reported_rate;
+ 
+-	if (!info->control.retry_limit) {
+-		if (!is_multicast_ether_addr(hdr->addr1)) {
+-			int len = min_t(int, tx->skb->len + FCS_LEN,
+-					tx->local->fragmentation_threshold);
+-			if (len > tx->local->rts_threshold
+-			    && tx->local->rts_threshold <
+-						IEEE80211_MAX_RTS_THRESHOLD) {
+-				info->flags |= IEEE80211_TX_CTL_USE_RTS_CTS;
+-				info->flags |=
+-					IEEE80211_TX_CTL_LONG_RETRY_LIMIT;
+-				info->control.retry_limit =
+-					tx->local->hw.conf.long_frame_max_tx_count - 1;
+-			} else {
+-				info->control.retry_limit =
+-					tx->local->hw.conf.short_frame_max_tx_count - 1;
+-			}
+-		} else {
+-			info->control.retry_limit = 1;
+-		}
+-	}
++	if (unlikely(!info->control.rates[0].count))
++		info->control.rates[0].count = 1;
+ 
+-	if (tx->flags & IEEE80211_TX_FRAGMENTED) {
+-		/* Do not use multiple retry rates when sending fragmented
+-		 * frames.
+-		 * TODO: The last fragment could still use multiple retry
+-		 * rates. */
+-		info->control.retries[0].rate_idx = -1;
+-	}
+-
+-	/* Use CTS protection for unicast frames sent using extended rates if
+-	 * there are associated non-ERP stations and RTS/CTS is not configured
+-	 * for the frame. */
+-	if ((tx->sdata->flags & IEEE80211_SDATA_OPERATING_GMODE) &&
+-	    (sband->bitrates[tx->rate_idx].flags & IEEE80211_RATE_ERP_G) &&
+-	    (tx->flags & IEEE80211_TX_UNICAST) &&
+-	    tx->sdata->vif.bss_conf.use_cts_prot &&
+-	    !(info->flags & IEEE80211_TX_CTL_USE_RTS_CTS))
+-		info->flags |= IEEE80211_TX_CTL_USE_CTS_PROTECT;
+-
+-	/* Transmit data frames using short preambles if the driver supports
+-	 * short preambles at the selected rate and short preambles are
+-	 * available on the network at the current point in time. */
+-	if (ieee80211_is_data(hdr->frame_control) &&
+-	    (sband->bitrates[tx->rate_idx].flags & IEEE80211_RATE_SHORT_PREAMBLE) &&
+-	    tx->sdata->vif.bss_conf.use_short_preamble &&
+-	    (!tx->sta || test_sta_flags(tx->sta, WLAN_STA_SHORT_PREAMBLE))) {
+-		info->flags |= IEEE80211_TX_CTL_SHORT_PREAMBLE;
++	if (is_multicast_ether_addr(hdr->addr1)) {
++		/*
++		 * XXX: verify the rate is in the basic rateset
++		 */
++		return TX_CONTINUE;
+ 	}
+ 
+-	if ((info->flags & IEEE80211_TX_CTL_USE_RTS_CTS) ||
+-	    (info->flags & IEEE80211_TX_CTL_USE_CTS_PROTECT)) {
+-		struct ieee80211_rate *rate;
+-		s8 baserate = -1;
+-		int idx;
++	for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
++		/*
++		 * make sure there's no valid rate following
++		 * an invalid one, just in case drivers don't
++		 * take the API seriously to stop at -1.
++		 */
++		if (inval) {
++			info->control.rates[i].idx = -1;
++			continue;
++		}
++		if (info->control.rates[i].idx < 0) {
++			inval = true;
++			continue;
++		}
+ 
+-		/* Do not use multiple retry rates when using RTS/CTS */
+-		info->control.retries[0].rate_idx = -1;
++		/*
++		 * For now assume MCS is already set up correctly, this
++		 * needs to be fixed.
++		 */
++		if (info->control.rates[i].flags & IEEE80211_TX_RC_MCS) {
++			WARN_ON(info->control.rates[i].idx > 76);
++			continue;
++		}
+ 
+-		/* Use min(data rate, max base rate) as CTS/RTS rate */
+-		rate = &sband->bitrates[tx->rate_idx];
++		/* set up RTS protection if desired */
++		if (rts) {
++			info->control.rates[i].flags |=
++				IEEE80211_TX_RC_USE_RTS_CTS;
++			rts = true;
++		}
+ 
+-		for (idx = 0; idx < sband->n_bitrates; idx++) {
+-			if (sband->bitrates[idx].bitrate > rate->bitrate)
+-				continue;
+-			if (tx->sdata->vif.bss_conf.basic_rates & BIT(idx) &&
+-			    (baserate < 0 ||
+-			     (sband->bitrates[baserate].bitrate
+-			      < sband->bitrates[idx].bitrate)))
+-				baserate = idx;
++		/* RC is busted */
++		if (WARN_ON(info->control.rates[i].idx >=
++			    sband->n_bitrates)) {
++			info->control.rates[i].idx = -1;
++			continue;
+ 		}
+ 
+-		if (baserate >= 0)
+-			info->control.rts_cts_rate_idx = baserate;
+-		else
+-			info->control.rts_cts_rate_idx = 0;
++		rate = &sband->bitrates[info->control.rates[i].idx];
++
++		/* set up short preamble */
++		if (short_preamble &&
++		    rate->flags & IEEE80211_RATE_SHORT_PREAMBLE)
++			info->control.rates[i].flags |=
++				IEEE80211_TX_RC_USE_SHORT_PREAMBLE;
++
++		/* set up G protection */
++		if (!rts && tx->sdata->vif.bss_conf.use_cts_prot &&
++		    rate->flags & IEEE80211_RATE_ERP_G)
++			info->control.rates[i].flags |=
++				IEEE80211_TX_RC_USE_CTS_PROTECT;
+ 	}
+ 
++	return TX_CONTINUE;
++}
++
++static ieee80211_tx_result debug_noinline
++ieee80211_tx_h_misc(struct ieee80211_tx_data *tx)
++{
++	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
++
+ 	if (tx->sta)
+ 		info->control.sta = &tx->sta->sta;
+ 
+@@ -680,6 +670,7 @@ ieee80211_tx_h_fragment(struct ieee80211
+ 	left = payload_len - per_fragm;
+ 	for (i = 0; i < num_fragm - 1; i++) {
+ 		struct ieee80211_hdr *fhdr;
++		struct ieee80211_tx_info *info;
+ 		size_t copylen;
+ 
+ 		if (left <= 0)
+@@ -694,20 +685,44 @@ ieee80211_tx_h_fragment(struct ieee80211
+ 				      IEEE80211_ENCRYPT_TAILROOM);
+ 		if (!frag)
+ 			goto fail;
++
+ 		/* Make sure that all fragments use the same priority so
+ 		 * that they end up using the same TX queue */
+ 		frag->priority = first->priority;
++
+ 		skb_reserve(frag, tx->local->tx_headroom +
+ 				  IEEE80211_ENCRYPT_HEADROOM);
++
++		/* copy TX information */
++		info = IEEE80211_SKB_CB(frag);
++		memcpy(info, first->cb, sizeof(frag->cb));
++
++		/* copy/fill in 802.11 header */
+ 		fhdr = (struct ieee80211_hdr *) skb_put(frag, hdrlen);
+ 		memcpy(fhdr, first->data, hdrlen);
+-		if (i == num_fragm - 2)
+-			fhdr->frame_control &= cpu_to_le16(~IEEE80211_FCTL_MOREFRAGS);
+ 		fhdr->seq_ctrl = cpu_to_le16(seq | ((i + 1) & IEEE80211_SCTL_FRAG));
++
++		if (i == num_fragm - 2) {
++			/* clear MOREFRAGS bit for the last fragment */
++			fhdr->frame_control &= cpu_to_le16(~IEEE80211_FCTL_MOREFRAGS);
++		} else {
++			/*
++			 * No multi-rate retries for fragmented frames, that
++			 * would completely throw off the NAV at other STAs.
++			 */
++			info->control.rates[1].idx = -1;
++			info->control.rates[2].idx = -1;
++			info->control.rates[3].idx = -1;
++			BUILD_BUG_ON(IEEE80211_TX_MAX_RATES != 4);
++			info->flags &= ~IEEE80211_TX_CTL_RATE_CTRL_PROBE;
++		}
++
++		/* copy data */
+ 		copylen = left > per_fragm ? per_fragm : left;
+ 		memcpy(skb_put(frag, copylen), pos, copylen);
+-		memcpy(frag->cb, first->cb, sizeof(frag->cb));
++
+ 		skb_copy_queue_mapping(frag, first);
++
+ 		frag->do_not_encrypt = first->do_not_encrypt;
+ 
+ 		pos += copylen;
+@@ -767,12 +782,10 @@ ieee80211_tx_h_calculate_duration(struct
+ 					      tx->extra_frag[0]->len);
+ 
+ 	for (i = 0; i < tx->num_extra_frag; i++) {
+-		if (i + 1 < tx->num_extra_frag) {
++		if (i + 1 < tx->num_extra_frag)
+ 			next_len = tx->extra_frag[i + 1]->len;
+-		} else {
++		else
+ 			next_len = 0;
+-			tx->rate_idx = tx->last_frag_rate_idx;
+-		}
+ 
+ 		hdr = (struct ieee80211_hdr *)tx->extra_frag[i]->data;
+ 		hdr->duration_id = ieee80211_duration(tx, 0, next_len);
+@@ -825,7 +838,6 @@ __ieee80211_parse_tx_radiotap(struct iee
+ 		(struct ieee80211_radiotap_header *) skb->data;
+ 	struct ieee80211_supported_band *sband;
+ 	int ret = ieee80211_radiotap_iterator_init(&iterator, rthdr, skb->len);
+-	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
+ 
+ 	sband = tx->local->hw.wiphy->bands[tx->channel->band];
+ 
+@@ -839,8 +851,6 @@ __ieee80211_parse_tx_radiotap(struct iee
+ 	 */
+ 
+ 	while (!ret) {
+-		int i, target_rate;
+-
+ 		ret = ieee80211_radiotap_iterator_next(&iterator);
+ 
+ 		if (ret)
+@@ -854,38 +864,6 @@ __ieee80211_parse_tx_radiotap(struct iee
+ 		 * get_unaligned((type *)iterator.this_arg) to dereference
+ 		 * iterator.this_arg for type "type" safely on all arches.
+ 		*/
+-		case IEEE80211_RADIOTAP_RATE:
+-			/*
+-			 * radiotap rate u8 is in 500kbps units eg, 0x02=1Mbps
+-			 * ieee80211 rate int is in 100kbps units eg, 0x0a=1Mbps
+-			 */
+-			target_rate = (*iterator.this_arg) * 5;
+-			for (i = 0; i < sband->n_bitrates; i++) {
+-				struct ieee80211_rate *r;
+-
+-				r = &sband->bitrates[i];
+-
+-				if (r->bitrate == target_rate) {
+-					tx->rate_idx = i;
+-					break;
+-				}
+-			}
+-			break;
+-
+-		case IEEE80211_RADIOTAP_ANTENNA:
+-			/*
+-			 * radiotap uses 0 for 1st ant, mac80211 is 1 for
+-			 * 1st ant
+-			 */
+-			info->antenna_sel_tx = (*iterator.this_arg) + 1;
+-			break;
+-
+-#if 0
+-		case IEEE80211_RADIOTAP_DBM_TX_POWER:
+-			control->power_level = *iterator.this_arg;
+-			break;
+-#endif
+-
+ 		case IEEE80211_RADIOTAP_FLAGS:
+ 			if (*iterator.this_arg & IEEE80211_RADIOTAP_F_FCS) {
+ 				/*
+@@ -951,8 +929,6 @@ __ieee80211_tx_prepare(struct ieee80211_
+ 	tx->local = local;
+ 	tx->sdata = IEEE80211_DEV_TO_SUB_IF(dev);
+ 	tx->channel = local->hw.conf.channel;
+-	tx->rate_idx = -1;
+-	tx->last_frag_rate_idx = -1;
+ 	/*
+ 	 * Set this flag (used below to indicate "automatic fragmentation"),
+ 	 * it will be cleared/left by radiotap as desired.
+@@ -1053,23 +1029,11 @@ static int __ieee80211_tx(struct ieee802
+ 			if (!tx->extra_frag[i])
+ 				continue;
+ 			info = IEEE80211_SKB_CB(tx->extra_frag[i]);
+-			info->flags &= ~(IEEE80211_TX_CTL_USE_RTS_CTS |
+-					 IEEE80211_TX_CTL_USE_CTS_PROTECT |
+-					 IEEE80211_TX_CTL_CLEAR_PS_FILT |
++			info->flags &= ~(IEEE80211_TX_CTL_CLEAR_PS_FILT |
+ 					 IEEE80211_TX_CTL_FIRST_FRAGMENT);
+ 			if (netif_subqueue_stopped(local->mdev,
+ 						   tx->extra_frag[i]))
+ 				return IEEE80211_TX_FRAG_AGAIN;
+-			if (i == tx->num_extra_frag) {
+-				info->tx_rate_idx = tx->last_frag_rate_idx;
+-
+-				if (tx->flags & IEEE80211_TX_PROBE_LAST_FRAG)
+-					info->flags |=
+-						IEEE80211_TX_CTL_RATE_CTRL_PROBE;
+-				else
+-					info->flags &=
+-						~IEEE80211_TX_CTL_RATE_CTRL_PROBE;
+-			}
+ 
+ 			ret = local->ops->tx(local_to_hw(local),
+ 					    tx->extra_frag[i]);
+@@ -1206,9 +1170,6 @@ retry:
+ 		store->skb = skb;
+ 		store->extra_frag = tx.extra_frag;
+ 		store->num_extra_frag = tx.num_extra_frag;
+-		store->last_frag_rate_idx = tx.last_frag_rate_idx;
+-		store->last_frag_rate_ctrl_probe =
+-			!!(tx.flags & IEEE80211_TX_PROBE_LAST_FRAG);
+ 	}
+  out:
+ 	rcu_read_unlock();
+@@ -1767,10 +1728,7 @@ void ieee80211_tx_pending(unsigned long 
+ 		store = &local->pending_packet[i];
+ 		tx.extra_frag = store->extra_frag;
+ 		tx.num_extra_frag = store->num_extra_frag;
+-		tx.last_frag_rate_idx = store->last_frag_rate_idx;
+ 		tx.flags = 0;
+-		if (store->last_frag_rate_ctrl_probe)
+-			tx.flags |= IEEE80211_TX_PROBE_LAST_FRAG;
+ 		ret = __ieee80211_tx(local, store->skb, &tx);
+ 		if (ret) {
+ 			if (ret == IEEE80211_TX_FRAG_AGAIN)
+@@ -1858,7 +1816,6 @@ struct sk_buff *ieee80211_beacon_get(str
+ 	struct ieee80211_sub_if_data *sdata = NULL;
+ 	struct ieee80211_if_ap *ap = NULL;
+ 	struct ieee80211_if_sta *ifsta = NULL;
+-	struct rate_selection rsel;
+ 	struct beacon_data *beacon;
+ 	struct ieee80211_supported_band *sband;
+ 	enum ieee80211_band band = local->hw.conf.channel->band;
+@@ -1962,32 +1919,22 @@ struct sk_buff *ieee80211_beacon_get(str
+ 	skb->do_not_encrypt = 1;
+ 
+ 	info->band = band;
+-	rate_control_get_rate(sdata, sband, NULL, skb, &rsel);
+-
+-	if (unlikely(rsel.rate_idx < 0)) {
+-		if (net_ratelimit()) {
+-			printk(KERN_DEBUG "%s: ieee80211_beacon_get: "
+-			       "no rate found\n",
+-			       wiphy_name(local->hw.wiphy));
+-		}
+-		dev_kfree_skb_any(skb);
+-		skb = NULL;
+-		goto out;
+-	}
++	/*
++	 * XXX: For now, always use the lowest rate
++	 */
++	info->control.rates[0].idx = 0;
++	info->control.rates[0].count = 1;
++	info->control.rates[1].idx = -1;
++	info->control.rates[2].idx = -1;
++	info->control.rates[3].idx = -1;
++	BUILD_BUG_ON(IEEE80211_TX_MAX_RATES != 4);
+ 
+ 	info->control.vif = vif;
+-	info->tx_rate_idx = rsel.rate_idx;
+ 
+ 	info->flags |= IEEE80211_TX_CTL_NO_ACK;
+ 	info->flags |= IEEE80211_TX_CTL_CLEAR_PS_FILT;
+ 	info->flags |= IEEE80211_TX_CTL_ASSIGN_SEQ;
+-	if (sdata->vif.bss_conf.use_short_preamble &&
+-	    sband->bitrates[rsel.rate_idx].flags & IEEE80211_RATE_SHORT_PREAMBLE)
+-		info->flags |= IEEE80211_TX_CTL_SHORT_PREAMBLE;
+-
+-	info->control.retry_limit = 1;
+-
+-out:
++ out:
+ 	rcu_read_unlock();
+ 	return skb;
+ }
+--- a/net/mac80211/ieee80211_i.h
++++ b/net/mac80211/ieee80211_i.h
+@@ -142,7 +142,6 @@ typedef unsigned __bitwise__ ieee80211_t
+ #define IEEE80211_TX_FRAGMENTED		BIT(0)
+ #define IEEE80211_TX_UNICAST		BIT(1)
+ #define IEEE80211_TX_PS_BUFFERED	BIT(2)
+-#define IEEE80211_TX_PROBE_LAST_FRAG	BIT(3)
+ 
+ struct ieee80211_tx_data {
+ 	struct sk_buff *skb;
+@@ -153,11 +152,6 @@ struct ieee80211_tx_data {
+ 	struct ieee80211_key *key;
+ 
+ 	struct ieee80211_channel *channel;
+-	s8 rate_idx;
+-	/* use this rate (if set) for last fragment; rate can
+-	 * be set to lower rate for the first fragments, e.g.,
+-	 * when using CTS protection with IEEE 802.11g. */
+-	s8 last_frag_rate_idx;
+ 
+ 	/* Extra fragments (in addition to the first fragment
+ 	 * in skb) */
+@@ -203,9 +197,7 @@ struct ieee80211_rx_data {
+ struct ieee80211_tx_stored_packet {
+ 	struct sk_buff *skb;
+ 	struct sk_buff **extra_frag;
+-	s8 last_frag_rate_idx;
+ 	int num_extra_frag;
+-	bool last_frag_rate_ctrl_probe;
+ };
+ 
+ struct beacon_data {
+--- a/net/mac80211/rate.c
++++ b/net/mac80211/rate.c
+@@ -199,48 +199,44 @@ static void rate_control_release(struct 
+ }
+ 
+ void rate_control_get_rate(struct ieee80211_sub_if_data *sdata,
+-			   struct ieee80211_supported_band *sband,
+-			   struct sta_info *sta, struct sk_buff *skb,
+-			   struct rate_selection *sel)
++			   struct sta_info *sta,
++			   struct ieee80211_tx_rate_control *txrc)
+ {
+ 	struct rate_control_ref *ref = sdata->local->rate_ctrl;
+ 	void *priv_sta = NULL;
+ 	struct ieee80211_sta *ista = NULL;
++	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(txrc->skb);
+ 	int i;
+ 
+-	sel->rate_idx = -1;
+-	sel->nonerp_idx = -1;
+-	sel->probe_idx = -1;
+-	sel->max_rate_idx = sdata->max_ratectrl_rateidx;
+-
+ 	if (sta) {
+ 		ista = &sta->sta;
+ 		priv_sta = sta->rate_ctrl_priv;
+ 	}
+ 
++	for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
++		info->control.rates[i].idx = -1;
++		info->control.rates[i].flags = 0;
++		info->control.rates[i].count = 1;
++	}
++
+ 	if (sta && sdata->force_unicast_rateidx > -1)
+-		sel->rate_idx = sdata->force_unicast_rateidx;
++		info->control.rates[0].idx = sdata->force_unicast_rateidx;
+ 	else
+-		ref->ops->get_rate(ref->priv, sband, ista, priv_sta, skb, sel);
++		ref->ops->get_rate(ref->priv, ista, priv_sta, txrc);
+ 
+-	if (sdata->max_ratectrl_rateidx > -1 &&
+-	    sel->rate_idx > sdata->max_ratectrl_rateidx)
+-		sel->rate_idx = sdata->max_ratectrl_rateidx;
+-
+-	BUG_ON(sel->rate_idx < 0);
+-
+-	/* Select a non-ERP backup rate. */
+-	if (sel->nonerp_idx < 0) {
+-		for (i = 0; i < sband->n_bitrates; i++) {
+-			struct ieee80211_rate *rate = &sband->bitrates[i];
+-			if (sband->bitrates[sel->rate_idx].bitrate < rate->bitrate)
+-				break;
+-
+-			if (rate_supported(ista, sband->band, i) &&
+-			    !(rate->flags & IEEE80211_RATE_ERP_G))
+-				sel->nonerp_idx = i;
+-		}
++	/*
++	 * try to enforce the maximum rate the user wanted
++	 */
++	if (sdata->max_ratectrl_rateidx > -1)
++		for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
++			if (info->control.rates[i].flags & IEEE80211_TX_RC_MCS)
++				continue;
++			info->control.rates[i].idx =
++				min_t(s8, info->control.rates[i].idx,
++				      sdata->max_ratectrl_rateidx);
+ 	}
++
++	BUG_ON(info->control.rates[0].idx < 0);
+ }
+ 
+ struct rate_control_ref *rate_control_get(struct rate_control_ref *ref)
+--- a/net/mac80211/rate.h
++++ b/net/mac80211/rate.h
+@@ -31,9 +31,8 @@ struct rate_control_ref {
+ struct rate_control_ref *rate_control_alloc(const char *name,
+ 					    struct ieee80211_local *local);
+ void rate_control_get_rate(struct ieee80211_sub_if_data *sdata,
+-			   struct ieee80211_supported_band *sband,
+-			   struct sta_info *sta, struct sk_buff *skb,
+-			   struct rate_selection *sel);
++			   struct sta_info *sta,
++			   struct ieee80211_tx_rate_control *txrc);
+ struct rate_control_ref *rate_control_get(struct rate_control_ref *ref);
+ void rate_control_put(struct rate_control_ref *ref);
+ 
+--- a/net/mac80211/sta_info.h
++++ b/net/mac80211/sta_info.h
+@@ -196,7 +196,7 @@ struct sta_ampdu_mlme {
+  * @tx_packets: number of RX/TX MSDUs
+  * @tx_bytes: TBD
+  * @tx_fragments: number of transmitted MPDUs
+- * @last_txrate_idx: Index of the last used transmit rate
++ * @last_txrate: description of the last used transmit rate
+  * @tid_seq: TBD
+  * @ampdu_mlme: TBD
+  * @timer_to_tid: identity mapping to ID timers
+@@ -267,7 +267,7 @@ struct sta_info {
+ 	unsigned long tx_packets;
+ 	unsigned long tx_bytes;
+ 	unsigned long tx_fragments;
+-	unsigned int last_txrate_idx;
++	struct ieee80211_tx_rate last_tx_rate;
+ 	u16 tid_seq[IEEE80211_QOS_CTL_TID_MASK + 1];
+ 
+ 	/*
+--- a/net/mac80211/wext.c
++++ b/net/mac80211/wext.c
+@@ -636,8 +636,8 @@ static int ieee80211_ioctl_giwrate(struc
+ 
+ 	sta = sta_info_get(local, sdata->u.sta.bssid);
+ 
+-	if (sta && sta->last_txrate_idx < sband->n_bitrates)
+-		rate->value = sband->bitrates[sta->last_txrate_idx].bitrate;
++	if (sta && !(sta->last_tx_rate.flags & IEEE80211_TX_RC_MCS))
++		rate->value = sband->bitrates[sta->last_tx_rate.idx].bitrate;
+ 	else
+ 		rate->value = 0;
+ 
+--- a/net/mac80211/mesh_hwmp.c
++++ b/net/mac80211/mesh_hwmp.c
+@@ -218,12 +218,16 @@ static u32 airtime_link_metric_get(struc
+ 
+ 	if (sta->fail_avg >= 100)
+ 		return MAX_METRIC;
++
++	if (sta->last_tx_rate.flags & IEEE80211_TX_RC_MCS)
++		return MAX_METRIC;
++
+ 	err = (sta->fail_avg << ARITH_SHIFT) / 100;
+ 
+ 	/* bitrate is in units of 100 Kbps, while we need rate in units of
+ 	 * 1Mbps. This will be corrected on tx_time computation.
+ 	 */
+-	rate = sband->bitrates[sta->last_txrate_idx].bitrate;
++	rate = sband->bitrates[sta->last_tx_rate.idx].bitrate;
+ 	tx_time = (device_constant + 10 * test_frame_len / rate);
+ 	estimated_retx = ((1 << (2 * ARITH_SHIFT)) / (s_unit - err));
+ 	result = (tx_time * estimated_retx) >> (2 * ARITH_SHIFT) ;
+--- a/net/mac80211/rc80211_pid_algo.c
++++ b/net/mac80211/rc80211_pid_algo.c
+@@ -241,7 +241,7 @@ static void rate_control_pid_tx_status(v
+ 
+ 	/* Ignore all frames that were sent with a different rate than the rate
+ 	 * we currently advise mac80211 to use. */
+-	if (info->tx_rate_idx != spinfo->txrate_idx)
++	if (info->status.rates[0].idx != spinfo->txrate_idx)
+ 		return;
+ 
+ 	spinfo->tx_num_xmit++;
+@@ -253,10 +253,10 @@ static void rate_control_pid_tx_status(v
+ 	/* We count frames that totally failed to be transmitted as two bad
+ 	 * frames, those that made it out but had some retries as one good and
+ 	 * one bad frame. */
+-	if (info->status.excessive_retries) {
++	if (!(info->flags & IEEE80211_TX_STAT_ACK)) {
+ 		spinfo->tx_num_failed += 2;
+ 		spinfo->tx_num_xmit++;
+-	} else if (info->status.retry_count) {
++	} else if (info->status.rates[0].count) {
+ 		spinfo->tx_num_failed++;
+ 		spinfo->tx_num_xmit++;
+ 	}
+@@ -270,23 +270,31 @@ static void rate_control_pid_tx_status(v
+ }
+ 
+ static void
+-rate_control_pid_get_rate(void *priv, struct ieee80211_supported_band *sband,
+-			  struct ieee80211_sta *sta, void *priv_sta,
+-			  struct sk_buff *skb,
+-			  struct rate_selection *sel)
++rate_control_pid_get_rate(void *priv, struct ieee80211_sta *sta,
++			  void *priv_sta,
++			  struct ieee80211_tx_rate_control *txrc)
+ {
++	struct sk_buff *skb = txrc->skb;
++	struct ieee80211_supported_band *sband = txrc->sband;
+ 	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
++	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
+ 	struct rc_pid_sta_info *spinfo = priv_sta;
+ 	int rateidx;
+ 	u16 fc;
+ 
++	/* XXX: Should use the user-configured values */
++	if (txrc->rts)
++		info->control.rates[0].count = 4; /* long retry count */
++	else
++		info->control.rates[0].count = 7; /* short retry count */
++
+ 	/* Send management frames and broadcast/multicast data using lowest
+ 	 * rate. */
+ 	fc = le16_to_cpu(hdr->frame_control);
+ 	if (!sta || !spinfo ||
+ 	    (fc & IEEE80211_FCTL_FTYPE) != IEEE80211_FTYPE_DATA ||
+ 	    is_multicast_ether_addr(hdr->addr1)) {
+-		sel->rate_idx = rate_lowest_index(sband, sta);
++		info->control.rates[0].idx = rate_lowest_index(sband, sta);
+ 		return;
+ 	}
+ 
+@@ -295,7 +303,7 @@ rate_control_pid_get_rate(void *priv, st
+ 	if (rateidx >= sband->n_bitrates)
+ 		rateidx = sband->n_bitrates - 1;
+ 
+-	sel->rate_idx = rateidx;
++	info->control.rates[0].idx = rateidx;
+ 
+ #ifdef CONFIG_MAC80211_DEBUGFS
+ 	rate_control_pid_event_tx_rate(&spinfo->events,
+--- a/net/mac80211/rc80211_minstrel.c
++++ b/net/mac80211/rc80211_minstrel.c
+@@ -169,30 +169,20 @@ minstrel_tx_status(void *priv, struct ie
+ {
+ 	struct minstrel_sta_info *mi = priv_sta;
+ 	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
+-	struct ieee80211_tx_altrate *ar = info->status.retries;
+-	struct minstrel_priv *mp = priv;
+-	int i, ndx, tries;
+-	int success = 0;
++	struct ieee80211_tx_rate *ar = info->status.rates;
++	int i, ndx;
++	int success;
+ 
+-	if (!info->status.excessive_retries)
+-		success = 1;
++	success = !!(info->flags & IEEE80211_TX_STAT_ACK);
+ 
+-	if (!mp->has_mrr || (ar[0].rate_idx < 0)) {
+-		ndx = rix_to_ndx(mi, info->tx_rate_idx);
+-		tries = info->status.retry_count + 1;
+-		mi->r[ndx].success += success;
+-		mi->r[ndx].attempts += tries;
+-		return;
+-	}
+-
+-	for (i = 0; i < 4; i++) {
+-		if (ar[i].rate_idx < 0)
++	for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
++		if (ar[i].idx < 0)
+ 			break;
+ 
+-		ndx = rix_to_ndx(mi, ar[i].rate_idx);
+-		mi->r[ndx].attempts += ar[i].limit + 1;
++		ndx = rix_to_ndx(mi, ar[i].idx);
++		mi->r[ndx].attempts += ar[i].count;
+ 
+-		if ((i != 3) && (ar[i + 1].rate_idx < 0))
++		if ((i != IEEE80211_TX_MAX_RATES - 1) && (ar[i + 1].idx < 0))
+ 			mi->r[ndx].success += success;
+ 	}
+ 
+@@ -210,9 +200,9 @@ minstrel_get_retry_count(struct minstrel
+ {
+ 	unsigned int retry = mr->adjusted_retry_count;
+ 
+-	if (info->flags & IEEE80211_TX_CTL_USE_RTS_CTS)
++	if (info->control.rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS)
+ 		retry = max(2U, min(mr->retry_count_rtscts, retry));
+-	else if (info->flags & IEEE80211_TX_CTL_USE_CTS_PROTECT)
++	else if (info->control.rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT)
+ 		retry = max(2U, min(mr->retry_count_cts, retry));
+ 	return retry;
+ }
+@@ -234,14 +224,15 @@ minstrel_get_next_sample(struct minstrel
+ }
+ 
+ void
+-minstrel_get_rate(void *priv, struct ieee80211_supported_band *sband,
+-                  struct ieee80211_sta *sta, void *priv_sta,
+-                  struct sk_buff *skb, struct rate_selection *sel)
++minstrel_get_rate(void *priv, struct ieee80211_sta *sta,
++		  void *priv_sta, struct ieee80211_tx_rate_control *txrc)
+ {
++	struct sk_buff *skb = txrc->skb;
++	struct ieee80211_supported_band *sband = txrc->sband;
+ 	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
+ 	struct minstrel_sta_info *mi = priv_sta;
+ 	struct minstrel_priv *mp = priv;
+-	struct ieee80211_tx_altrate *ar = info->control.retries;
++	struct ieee80211_tx_rate *ar = info->control.rates;
+ 	unsigned int ndx, sample_ndx = 0;
+ 	bool mrr;
+ 	bool sample_slower = false;
+@@ -251,16 +242,12 @@ minstrel_get_rate(void *priv, struct iee
+ 	int sample_rate;
+ 
+ 	if (!sta || !mi || use_low_rate(skb)) {
+-		sel->rate_idx = rate_lowest_index(sband, sta);
++		ar[0].idx = rate_lowest_index(sband, sta);
++		ar[0].count = mp->max_retry;
+ 		return;
+ 	}
+ 
+-	mrr = mp->has_mrr;
+-
+-	/* mac80211 does not allow mrr for RTS/CTS */
+-	if ((info->flags & IEEE80211_TX_CTL_USE_RTS_CTS) ||
+-	    (info->flags & IEEE80211_TX_CTL_USE_CTS_PROTECT))
+-		mrr = false;
++	mrr = mp->has_mrr && !txrc->rts && !txrc->bss_conf->use_cts_prot;
+ 
+ 	if (time_after(jiffies, mi->stats_update + (mp->update_interval *
+ 			HZ) / 1000))
+@@ -315,13 +302,12 @@ minstrel_get_rate(void *priv, struct iee
+ 			mi->sample_deferred++;
+ 		}
+ 	}
+-	sel->rate_idx = mi->r[ndx].rix;
+-	info->control.retry_limit = minstrel_get_retry_count(&mi->r[ndx], info);
++	ar[0].idx = mi->r[ndx].rix;
++	ar[0].count = minstrel_get_retry_count(&mi->r[ndx], info);
+ 
+ 	if (!mrr) {
+-		ar[0].rate_idx = mi->lowest_rix;
+-		ar[0].limit = mp->max_retry;
+-		ar[1].rate_idx = -1;
++		ar[1].idx = mi->lowest_rix;
++		ar[1].count = mp->max_retry;
+ 		return;
+ 	}
+ 
+@@ -336,9 +322,9 @@ minstrel_get_rate(void *priv, struct iee
+ 	}
+ 	mrr_ndx[1] = mi->max_prob_rate;
+ 	mrr_ndx[2] = 0;
+-	for (i = 0; i < 3; i++) {
+-		ar[i].rate_idx = mi->r[mrr_ndx[i]].rix;
+-		ar[i].limit = mi->r[mrr_ndx[i]].adjusted_retry_count;
++	for (i = 1; i < 4; i++) {
++		ar[i].idx = mi->r[mrr_ndx[i - 1]].rix;
++		ar[i].count = mi->r[mrr_ndx[i - 1]].adjusted_retry_count;
+ 	}
+ }
+ 
+@@ -532,13 +518,13 @@ minstrel_alloc(struct ieee80211_hw *hw, 
+ 	/* maximum time that the hw is allowed to stay in one MRR segment */
+ 	mp->segment_size = 6000;
+ 
+-	if (hw->max_altrate_tries > 0)
+-		mp->max_retry = hw->max_altrate_tries;
++	if (hw->max_rate_tries > 0)
++		mp->max_retry = hw->max_rate_tries;
+ 	else
+ 		/* safe default, does not necessarily have to match hw properties */
+ 		mp->max_retry = 7;
+ 
+-	if (hw->max_altrates >= 3)
++	if (hw->max_rates >= 4)
+ 		mp->has_mrr = true;
+ 
+ 	mp->hw = hw;
+--- a/net/mac80211/rc80211_pid_debugfs.c
++++ b/net/mac80211/rc80211_pid_debugfs.c
+@@ -43,6 +43,7 @@ void rate_control_pid_event_tx_status(st
+ {
+ 	union rc_pid_event_data evd;
+ 
++	evd.flags = stat->flags;
+ 	memcpy(&evd.tx_status, stat, sizeof(struct ieee80211_tx_info));
+ 	rate_control_pid_event(buf, RC_PID_EVENT_TYPE_TX_STATUS, &evd);
+ }
+@@ -167,8 +168,8 @@ static ssize_t rate_control_pid_events_r
+ 	switch (ev->type) {
+ 	case RC_PID_EVENT_TYPE_TX_STATUS:
+ 		p += snprintf(pb + p, length - p, "tx_status %u %u",
+-			      ev->data.tx_status.status.excessive_retries,
+-			      ev->data.tx_status.status.retry_count);
++			      !(ev->data.flags & IEEE80211_TX_STAT_ACK),
++			      ev->data.tx_status.status.rates[0].idx);
+ 		break;
+ 	case RC_PID_EVENT_TYPE_RATE_CHANGE:
+ 		p += snprintf(pb + p, length - p, "rate_change %d %d",
+--- a/net/mac80211/rc80211_pid.h
++++ b/net/mac80211/rc80211_pid.h
+@@ -61,6 +61,7 @@ enum rc_pid_event_type {
+ union rc_pid_event_data {
+ 	/* RC_PID_EVENT_TX_STATUS */
+ 	struct {
++		u32 flags;
+ 		struct ieee80211_tx_info tx_status;
+ 	};
+ 	/* RC_PID_EVENT_TYPE_RATE_CHANGE */
+--- a/drivers/net/wireless/zd1211rw/zd_mac.c
++++ b/drivers/net/wireless/zd1211rw/zd_mac.c
+@@ -296,15 +296,14 @@ static void zd_op_stop(struct ieee80211_
+  * If no status information has been requested, the skb is freed.
+  */
+ static void tx_status(struct ieee80211_hw *hw, struct sk_buff *skb,
+-		      u32 flags, int ackssi, bool success)
++		      int ackssi, bool success)
+ {
+ 	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
+ 
+-	memset(&info->status, 0, sizeof(info->status));
++	ieee80211_tx_info_clear_status(info);
+ 
+-	if (!success)
+-		info->status.excessive_retries = 1;
+-	info->flags |= flags;
++	if (success)
++		info->flags |= IEEE80211_TX_STAT_ACK;
+ 	info->status.ack_signal = ackssi;
+ 	ieee80211_tx_status_irqsafe(hw, skb);
+ }
+@@ -326,7 +325,7 @@ void zd_mac_tx_failed(struct ieee80211_h
+ 	if (skb == NULL)
+ 		return;
+ 
+-	tx_status(hw, skb, 0, 0, 0);
++	tx_status(hw, skb, 0, 0);
+ }
+ 
+ /**
+@@ -347,7 +346,7 @@ void zd_mac_tx_to_dev(struct sk_buff *sk
+ 	skb_pull(skb, sizeof(struct zd_ctrlset));
+ 	if (unlikely(error ||
+ 	    (info->flags & IEEE80211_TX_CTL_NO_ACK))) {
+-		tx_status(hw, skb, 0, 0, !error);
++		tx_status(hw, skb, 0, !error);
+ 	} else {
+ 		struct sk_buff_head *q =
+ 			&zd_hw_mac(hw)->ack_wait_queue;
+@@ -406,7 +405,8 @@ static int zd_calc_tx_length_us(u8 *serv
+ }
+ 
+ static void cs_set_control(struct zd_mac *mac, struct zd_ctrlset *cs,
+-	                   struct ieee80211_hdr *header, u32 flags)
++	                   struct ieee80211_hdr *header,
++	                   struct ieee80211_tx_info *info)
+ {
+ 	/*
+ 	 * CONTROL TODO:
+@@ -417,7 +417,7 @@ static void cs_set_control(struct zd_mac
+ 	cs->control = 0;
+ 
+ 	/* First fragment */
+-	if (flags & IEEE80211_TX_CTL_FIRST_FRAGMENT)
++	if (info->flags & IEEE80211_TX_CTL_FIRST_FRAGMENT)
+ 		cs->control |= ZD_CS_NEED_RANDOM_BACKOFF;
+ 
+ 	/* Multicast */
+@@ -428,10 +428,10 @@ static void cs_set_control(struct zd_mac
+ 	if (ieee80211_is_pspoll(header->frame_control))
+ 		cs->control |= ZD_CS_PS_POLL_FRAME;
+ 
+-	if (flags & IEEE80211_TX_CTL_USE_RTS_CTS)
++	if (info->control.rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS)
+ 		cs->control |= ZD_CS_RTS;
+ 
+-	if (flags & IEEE80211_TX_CTL_USE_CTS_PROTECT)
++	if (info->control.rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT)
+ 		cs->control |= ZD_CS_SELF_CTS;
+ 
+ 	/* FIXME: Management frame? */
+@@ -517,12 +517,12 @@ static int fill_ctrlset(struct zd_mac *m
+ 	txrate = ieee80211_get_tx_rate(mac->hw, info);
+ 
+ 	cs->modulation = txrate->hw_value;
+-	if (info->flags & IEEE80211_TX_CTL_SHORT_PREAMBLE)
++	if (info->control.rates[0].flags & IEEE80211_TX_RC_USE_SHORT_PREAMBLE)
+ 		cs->modulation = txrate->hw_value_short;
+ 
+ 	cs->tx_length = cpu_to_le16(frag_len);
+ 
+-	cs_set_control(mac, cs, hdr, info->flags);
++	cs_set_control(mac, cs, hdr, info);
+ 
+ 	packet_length = frag_len + sizeof(struct zd_ctrlset) + 10;
+ 	ZD_ASSERT(packet_length <= 0xffff);
+@@ -618,7 +618,7 @@ static int filter_ack(struct ieee80211_h
+ 		if (likely(!compare_ether_addr(tx_hdr->addr2, rx_hdr->addr1)))
+ 		{
+ 			__skb_unlink(skb, q);
+-			tx_status(hw, skb, IEEE80211_TX_STAT_ACK, stats->signal, 1);
++			tx_status(hw, skb, stats->signal, 1);
+ 			goto out;
+ 		}
+ 	}
+--- a/drivers/net/wireless/rt2x00/rt2x00dev.c
++++ b/drivers/net/wireless/rt2x00/rt2x00dev.c
+@@ -499,6 +499,7 @@ void rt2x00lib_txdone(struct queue_entry
+ 	struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
+ 	struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(entry->skb);
+ 	enum data_queue_qid qid = skb_get_queue_mapping(entry->skb);
++	bool rts;
+ 
+ 	/*
+ 	 * Unmap the skb.
+@@ -528,14 +529,14 @@ void rt2x00lib_txdone(struct queue_entry
+ 	rt2x00dev->link.qual.tx_failed +=
+ 	    test_bit(TXDONE_FAILURE, &txdesc->flags);
+ 
++        rts = !!(tx_info->control.rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS);
++
+ 	/*
+ 	 * Initialize TX status
+ 	 */
+-	memset(&tx_info->status, 0, sizeof(tx_info->status));
++	ieee80211_tx_info_clear_status(tx_info);
+ 	tx_info->status.ack_signal = 0;
+-	tx_info->status.excessive_retries =
+-	    test_bit(TXDONE_EXCESSIVE_RETRY, &txdesc->flags);
+-	tx_info->status.retry_count = txdesc->retry;
++	tx_info->status.rates[0].count = txdesc->retry + 1;
+ 
+ 	if (!(tx_info->flags & IEEE80211_TX_CTL_NO_ACK)) {
+ 		if (test_bit(TXDONE_SUCCESS, &txdesc->flags))
+@@ -544,7 +545,7 @@ void rt2x00lib_txdone(struct queue_entry
+ 			rt2x00dev->low_level_stats.dot11ACKFailureCount++;
+ 	}
+ 
+-	if (tx_info->flags & IEEE80211_TX_CTL_USE_RTS_CTS) {
++	if (rts) {
+ 		if (test_bit(TXDONE_SUCCESS, &txdesc->flags))
+ 			rt2x00dev->low_level_stats.dot11RTSSuccessCount++;
+ 		else if (test_bit(TXDONE_FAILURE, &txdesc->flags))
+--- a/drivers/net/wireless/rt2x00/rt2x00mac.c
++++ b/drivers/net/wireless/rt2x00/rt2x00mac.c
+@@ -39,7 +39,7 @@ static int rt2x00mac_tx_rts_cts(struct r
+ 	unsigned int data_length;
+ 	int retval = 0;
+ 
+-	if (tx_info->flags & IEEE80211_TX_CTL_USE_CTS_PROTECT)
++	if (tx_info->control.rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT)
+ 		data_length = sizeof(struct ieee80211_cts);
+ 	else
+ 		data_length = sizeof(struct ieee80211_rts);
+@@ -64,11 +64,11 @@ static int rt2x00mac_tx_rts_cts(struct r
+ 	 */
+ 	memcpy(skb->cb, frag_skb->cb, sizeof(skb->cb));
+ 	rts_info = IEEE80211_SKB_CB(skb);
+-	rts_info->flags &= ~IEEE80211_TX_CTL_USE_RTS_CTS;
+-	rts_info->flags &= ~IEEE80211_TX_CTL_USE_CTS_PROTECT;
++	rts_info->control.rates[0].flags &= ~IEEE80211_TX_RC_USE_RTS_CTS;
++	rts_info->control.rates[0].flags &= ~IEEE80211_TX_RC_USE_CTS_PROTECT;
+ 	rts_info->flags &= ~IEEE80211_TX_CTL_REQ_TX_STATUS;
+ 
+-	if (tx_info->flags & IEEE80211_TX_CTL_USE_CTS_PROTECT)
++	if (tx_info->control.rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT)
+ 		rts_info->flags |= IEEE80211_TX_CTL_NO_ACK;
+ 	else
+ 		rts_info->flags &= ~IEEE80211_TX_CTL_NO_ACK;
+@@ -84,7 +84,7 @@ static int rt2x00mac_tx_rts_cts(struct r
+ 		data_length += rt2x00crypto_tx_overhead(tx_info);
+ #endif /* CONFIG_RT2X00_LIB_CRYPTO */
+ 
+-	if (tx_info->flags & IEEE80211_TX_CTL_USE_CTS_PROTECT)
++	if (tx_info->control.rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT)
+ 		ieee80211_ctstoself_get(rt2x00dev->hw, tx_info->control.vif,
+ 					frag_skb->data, data_length, tx_info,
+ 					(struct ieee80211_cts *)(skb->data));
+@@ -146,8 +146,8 @@ int rt2x00mac_tx(struct ieee80211_hw *hw
+ 	 * inside the hardware.
+ 	 */
+ 	frame_control = le16_to_cpu(ieee80211hdr->frame_control);
+-	if ((tx_info->flags & (IEEE80211_TX_CTL_USE_RTS_CTS |
+-			       IEEE80211_TX_CTL_USE_CTS_PROTECT)) &&
++	if ((tx_info->control.rates[0].flags & (IEEE80211_TX_RC_USE_RTS_CTS |
++						IEEE80211_TX_RC_USE_CTS_PROTECT)) &&
+ 	    !rt2x00dev->ops->hw->set_rts_threshold) {
+ 		if (rt2x00queue_available(queue) <= 1)
+ 			goto exit_fail;
+--- a/drivers/net/wireless/rt2x00/rt2x00queue.c
++++ b/drivers/net/wireless/rt2x00/rt2x00queue.c
+@@ -230,8 +230,15 @@ static void rt2x00queue_create_tx_descri
+ 	/*
+ 	 * Determine retry information.
+ 	 */
+-	txdesc->retry_limit = tx_info->control.retry_limit;
+-	if (tx_info->flags & IEEE80211_TX_CTL_LONG_RETRY_LIMIT)
++	txdesc->retry_limit = tx_info->control.rates[0].count - 1;
++	/*
++	 * XXX: If at this point we knew whether the HW is going to use
++	 *	the RETRY_MODE bit or the retry_limit (currently all
++	 *	use the RETRY_MODE bit) we could do something like b43
++	 *	does, set the RETRY_MODE bit when the RC algorithm is
++	 *	requesting more than the long retry limit.
++	 */
++	if (tx_info->control.rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS)
+ 		__set_bit(ENTRY_TXD_RETRY_MODE, &txdesc->flags);
+ 
+ 	/*
+--- a/drivers/net/wireless/adm8211.c
++++ b/drivers/net/wireless/adm8211.c
+@@ -341,15 +341,14 @@ static void adm8211_interrupt_tci(struct
+ 		pci_unmap_single(priv->pdev, info->mapping,
+ 				 info->skb->len, PCI_DMA_TODEVICE);
+ 
+-		memset(&txi->status, 0, sizeof(txi->status));
++		ieee80211_tx_info_clear_status(txi);
++
+ 		skb_pull(skb, sizeof(struct adm8211_tx_hdr));
+ 		memcpy(skb_push(skb, info->hdrlen), skb->cb, info->hdrlen);
+-		if (!(txi->flags & IEEE80211_TX_CTL_NO_ACK)) {
+-			if (status & TDES0_STATUS_ES)
+-				txi->status.excessive_retries = 1;
+-			else
+-				txi->flags |= IEEE80211_TX_STAT_ACK;
+-		}
++		if (!(txi->flags & IEEE80211_TX_CTL_NO_ACK) &&
++		    !(status & TDES0_STATUS_ES))
++			txi->flags |= IEEE80211_TX_STAT_ACK;
++
+ 		ieee80211_tx_status_irqsafe(dev, skb);
+ 
+ 		info->skb = NULL;
+@@ -1691,8 +1690,10 @@ static int adm8211_tx(struct ieee80211_h
+ 	struct ieee80211_hdr *hdr;
+ 	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
+ 	struct ieee80211_rate *txrate = ieee80211_get_tx_rate(dev, info);
++	u8 rc_flags;
+ 
+-	short_preamble = !!(txrate->flags & IEEE80211_TX_CTL_SHORT_PREAMBLE);
++	rc_flags = info->control.rates[0].flags;
++	short_preamble = !!(rc_flags & IEEE80211_TX_RC_USE_SHORT_PREAMBLE);
+ 	plcp_signal = txrate->bitrate;
+ 
+ 	hdr = (struct ieee80211_hdr *)skb->data;
+@@ -1724,10 +1725,10 @@ static int adm8211_tx(struct ieee80211_h
+ 	if (short_preamble)
+ 		txhdr->header_control |= cpu_to_le16(ADM8211_TXHDRCTL_SHORT_PREAMBLE);
+ 
+-	if (info->flags & IEEE80211_TX_CTL_USE_RTS_CTS)
++	if (rc_flags & IEEE80211_TX_RC_USE_RTS_CTS)
+ 		txhdr->header_control |= cpu_to_le16(ADM8211_TXHDRCTL_ENABLE_RTS);
+ 
+-	txhdr->retry_limit = info->control.retry_limit;
++	txhdr->retry_limit = info->control.rates[0].count;
+ 
+ 	adm8211_tx_raw(dev, skb, plcp_signal, hdrlen);
+ 
+--- a/drivers/net/wireless/ath5k/base.c
++++ b/drivers/net/wireless/ath5k/base.c
+@@ -542,8 +542,8 @@ ath5k_pci_probe(struct pci_dev *pdev,
+ 
+ 	/* set up multi-rate retry capabilities */
+ 	if (sc->ah->ah_version == AR5K_AR5212) {
+-		hw->max_altrates = 3;
+-		hw->max_altrate_tries = 11;
++		hw->max_rates = 4;
++		hw->max_rate_tries = 11;
+ 	}
+ 
+ 	/* Finish private driver data initialization */
+@@ -1188,7 +1188,7 @@ ath5k_txbuf_setup(struct ath5k_softc *sc
+ 		ieee80211_get_hdrlen_from_skb(skb), AR5K_PKT_TYPE_NORMAL,
+ 		(sc->power_level * 2),
+ 		ieee80211_get_tx_rate(sc->hw, info)->hw_value,
+-		info->control.retry_limit, keyidx, 0, flags, 0, 0);
++		info->control.rates[0].count, keyidx, 0, flags, 0, 0);
+ 	if (ret)
+ 		goto err_unmap;
+ 
+@@ -1200,7 +1200,7 @@ ath5k_txbuf_setup(struct ath5k_softc *sc
+ 			break;
+ 
+ 		mrr_rate[i] = rate->hw_value;
+-		mrr_tries[i] = info->control.retries[i].limit;
++		mrr_tries[i] = info->control.rates[i + 1].count;
+ 	}
+ 
+ 	ah->ah_setup_mrr_tx_desc(ah, ds,
+@@ -1846,30 +1846,26 @@ ath5k_tx_processq(struct ath5k_softc *sc
+ 		pci_unmap_single(sc->pdev, bf->skbaddr, skb->len,
+ 				PCI_DMA_TODEVICE);
+ 
+-		memset(&info->status, 0, sizeof(info->status));
+-		info->tx_rate_idx = ath5k_hw_to_driver_rix(sc,
+-				ts.ts_rate[ts.ts_final_idx]);
+-		info->status.retry_count = ts.ts_longretry;
+-
++		ieee80211_tx_info_clear_status(info);
+ 		for (i = 0; i < 4; i++) {
+-			struct ieee80211_tx_altrate *r =
+-				&info->status.retries[i];
++			struct ieee80211_tx_rate *r =
++				&info->status.rates[i];
+ 
+ 			if (ts.ts_rate[i]) {
+-				r->rate_idx = ath5k_hw_to_driver_rix(sc, ts.ts_rate[i]);
+-				r->limit = ts.ts_retry[i];
++				r->idx = ath5k_hw_to_driver_rix(sc, ts.ts_rate[i]);
++				r->count = ts.ts_retry[i];
+ 			} else {
+-				r->rate_idx = -1;
+-				r->limit = 0;
++				r->idx = -1;
++				r->count = 0;
+ 			}
+ 		}
+ 
+-		info->status.excessive_retries = 0;
++		/* count the successful attempt as well */
++		info->status.rates[ts.ts_final_idx].count++;
++
+ 		if (unlikely(ts.ts_status)) {
+ 			sc->ll_stats.dot11ACKFailureCount++;
+-			if (ts.ts_status & AR5K_TXERR_XRETRY)
+-				info->status.excessive_retries = 1;
+-			else if (ts.ts_status & AR5K_TXERR_FILT)
++			if (ts.ts_status & AR5K_TXERR_FILT)
+ 				info->flags |= IEEE80211_TX_STAT_TX_FILTERED;
+ 		} else {
+ 			info->flags |= IEEE80211_TX_STAT_ACK;
+--- a/drivers/net/wireless/ath9k/main.c
++++ b/drivers/net/wireless/ath9k/main.c
+@@ -461,12 +461,13 @@ void ath_tx_complete(struct ath_softc *s
+ 	DPRINTF(sc, ATH_DBG_XMIT,
+ 		"%s: TX complete: skb: %p\n", __func__, skb);
+ 
++	ieee80211_tx_info_clear_status(tx_info);
+ 	if (tx_info->flags & IEEE80211_TX_CTL_NO_ACK ||
+ 		tx_info->flags & IEEE80211_TX_STAT_TX_FILTERED) {
+-		/* free driver's private data area of tx_info */
+-		if (tx_info->driver_data[0] != NULL)
+-			kfree(tx_info->driver_data[0]);
+-			tx_info->driver_data[0] = NULL;
++		/* free driver's private data area of tx_info, XXX: HACK! */
++		if (tx_info->control.vif != NULL)
++			kfree(tx_info->control.vif);
++			tx_info->control.vif = NULL;
+ 	}
+ 
+ 	if (tx_status->flags & ATH_TX_BAR) {
+@@ -474,17 +475,12 @@ void ath_tx_complete(struct ath_softc *s
+ 		tx_status->flags &= ~ATH_TX_BAR;
+ 	}
+ 
+-	if (tx_status->flags & (ATH_TX_ERROR | ATH_TX_XRETRY)) {
+-		if (!(tx_info->flags & IEEE80211_TX_CTL_NO_ACK)) {
+-			/* Frame was not ACKed, but an ACK was expected */
+-			tx_info->status.excessive_retries = 1;
+-		}
+-	} else {
++	if (!(tx_status->flags & (ATH_TX_ERROR | ATH_TX_XRETRY))) {
+ 		/* Frame was ACKed */
+ 		tx_info->flags |= IEEE80211_TX_STAT_ACK;
+ 	}
+ 
+-	tx_info->status.retry_count = tx_status->retries;
++	tx_info->status.rates[0].count = tx_status->retries + 1;
+ 
+ 	ieee80211_tx_status(hw, skb);
+ 	if (an)
+--- a/drivers/net/wireless/ath9k/rc.c
++++ b/drivers/net/wireless/ath9k/rc.c
+@@ -1864,24 +1864,21 @@ static void ath_tx_status(void *priv, st
+ 
+ 	hdr = (struct ieee80211_hdr *)skb->data;
+ 	fc = hdr->frame_control;
+-	tx_info_priv = (struct ath_tx_info_priv *)tx_info->driver_data[0];
++	/* XXX: UGLY HACK!! */
++	tx_info_priv = (struct ath_tx_info_priv *)tx_info->control.vif;
+ 
+ 	spin_lock_bh(&sc->node_lock);
+ 	an = ath_node_find(sc, hdr->addr1);
+ 	spin_unlock_bh(&sc->node_lock);
+ 
+-	if (!an || !priv_sta || !ieee80211_is_data(fc)) {
+-		if (tx_info->driver_data[0] != NULL) {
+-			kfree(tx_info->driver_data[0]);
+-			tx_info->driver_data[0] = NULL;
+-		}
++	if (tx_info_priv == NULL)
+ 		return;
+-	}
+-	if (tx_info->driver_data[0] != NULL) {
++
++	if (an && priv_sta && ieee80211_is_data(fc))
+ 		ath_rate_tx_complete(sc, an, priv_sta, tx_info_priv);
+-		kfree(tx_info->driver_data[0]);
+-		tx_info->driver_data[0] = NULL;
+-	}
++
++	kfree(tx_info_priv);
++	tx_info->control.vif = NULL;
+ }
+ 
+ static void ath_tx_aggr_resp(struct ath_softc *sc,
+@@ -1927,10 +1924,11 @@ static void ath_tx_aggr_resp(struct ath_
+ 	}
+ }
+ 
+-static void ath_get_rate(void *priv, struct ieee80211_supported_band *sband,
+-			 struct ieee80211_sta *sta, void *priv_sta,
+-			 struct sk_buff *skb, struct rate_selection *sel)
++static void ath_get_rate(void *priv, struct ieee80211_sta *sta, void *priv_sta,
++			 struct ieee80211_tx_rate_control *txrc)
+ {
++	struct ieee80211_supported_band *sband = txrc->sband;
++	struct sk_buff *skb = txrc->skb;
+ 	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
+ 	struct ath_softc *sc = priv;
+ 	struct ieee80211_hw *hw = sc->hw;
+@@ -1946,17 +1944,17 @@ static void ath_get_rate(void *priv, str
+ 
+ 	DPRINTF(sc, ATH_DBG_RATE, "%s\n", __func__);
+ 
+-	/* allocate driver private area of tx_info */
+-	tx_info->driver_data[0] = kzalloc(sizeof(*tx_info_priv), GFP_ATOMIC);
+-	ASSERT(tx_info->driver_data[0] != NULL);
+-	tx_info_priv = (struct ath_tx_info_priv *)tx_info->driver_data[0];
++	/* allocate driver private area of tx_info, XXX: UGLY HACK! */
++	tx_info->control.vif = kzalloc(sizeof(*tx_info_priv), GFP_ATOMIC);
++	tx_info_priv = (struct ath_tx_info_priv *)tx_info->control.vif;
++	ASSERT(tx_info_priv != NULL);
+ 
+ 	lowest_idx = rate_lowest_index(sband, sta);
+ 	tx_info_priv->min_rate = (sband->bitrates[lowest_idx].bitrate * 2) / 10;
+ 	/* lowest rate for management and multicast/broadcast frames */
+ 	if (!ieee80211_is_data(fc) ||
+ 	    is_multicast_ether_addr(hdr->addr1) || !sta) {
+-		sel->rate_idx = lowest_idx;
++		tx_info->control.rates[0].idx = lowest_idx;
+ 		return;
+ 	}
+ 
+@@ -1967,8 +1965,10 @@ static void ath_get_rate(void *priv, str
+ 			  tx_info_priv->rcs,
+ 			  &is_probe,
+ 			  false);
++#if 0
+ 	if (is_probe)
+ 		sel->probe_idx = ath_rc_priv->tx_ratectrl.probe_rate;
++#endif
+ 
+ 	/* Ratecontrol sometimes returns invalid rate index */
+ 	if (tx_info_priv->rcs[0].rix != 0xff)
+@@ -1976,7 +1976,7 @@ static void ath_get_rate(void *priv, str
+ 	else
+ 		tx_info_priv->rcs[0].rix = ath_rc_priv->prev_data_rix;
+ 
+-	sel->rate_idx = tx_info_priv->rcs[0].rix;
++	tx_info->control.rates[0].idx = tx_info_priv->rcs[0].rix;
+ 
+ 	/* Check if aggregation has to be enabled for this tid */
+ 
+--- a/drivers/net/wireless/ath9k/xmit.c
++++ b/drivers/net/wireless/ath9k/xmit.c
+@@ -168,7 +168,9 @@ static void fill_min_rates(struct sk_buf
+ 
+ 	hdr = (struct ieee80211_hdr *)skb->data;
+ 	fc = hdr->frame_control;
+-	tx_info_priv = (struct ath_tx_info_priv *)tx_info->driver_data[0];
++
++	/* XXX: HACK! */
++	tx_info_priv = (struct ath_tx_info_priv *)tx_info->control.vif;
+ 
+ 	if (ieee80211_is_mgmt(fc) || ieee80211_is_ctl(fc)) {
+ 		txctl->use_minrate = 1;
+@@ -288,13 +290,16 @@ static int ath_tx_prepare(struct ath_sof
+ 
+ 	if (tx_info->flags & IEEE80211_TX_CTL_NO_ACK)
+ 		txctl->flags |= ATH9K_TXDESC_NOACK;
+-	if (tx_info->flags & IEEE80211_TX_CTL_USE_RTS_CTS)
++
++	if (tx_info->control.rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS)
+ 		txctl->flags |= ATH9K_TXDESC_RTSENA;
+ 
+ 	/*
+ 	 * Setup for rate calculations.
+ 	 */
+-	tx_info_priv = (struct ath_tx_info_priv *)tx_info->driver_data[0];
++
++	/* XXX: HACK! */
++	tx_info_priv = (struct ath_tx_info_priv *)tx_info->control.vif;
+ 	rcs = tx_info_priv->rcs;
+ 
+ 	if (ieee80211_is_data(fc) && !txctl->use_minrate) {
+@@ -854,7 +859,9 @@ static int ath_tx_send_normal(struct ath
+ 
+ 	skb = (struct sk_buff *)bf->bf_mpdu;
+ 	tx_info = IEEE80211_SKB_CB(skb);
+-	tx_info_priv = (struct ath_tx_info_priv *)tx_info->driver_data[0];
++
++	/* XXX: HACK! */
++	tx_info_priv = (struct ath_tx_info_priv *)tx_info->control.vif;
+ 	memcpy(bf->bf_rcs, tx_info_priv->rcs, 4 * sizeof(tx_info_priv->rcs[0]));
+ 
+ 	/* update starting sequence number for subsequent ADDBA request */
+@@ -1248,8 +1255,9 @@ static int ath_tx_processq(struct ath_so
+ 		}
+ 		skb = bf->bf_mpdu;
+ 		tx_info = IEEE80211_SKB_CB(skb);
+-		tx_info_priv = (struct ath_tx_info_priv *)
+-			tx_info->driver_data[0];
++
++		/* XXX: HACK! */
++		tx_info_priv = (struct ath_tx_info_priv *) tx_info->control.vif;
+ 		if (ds->ds_txstat.ts_status & ATH9K_TXERR_FILT)
+ 			tx_info->flags |= IEEE80211_TX_STAT_TX_FILTERED;
+ 		if ((ds->ds_txstat.ts_status & ATH9K_TXERR_FILT) == 0 &&
+@@ -1430,7 +1438,8 @@ static int ath_tx_send_ampdu(struct ath_
+ 
+ 	skb = (struct sk_buff *)bf->bf_mpdu;
+ 	tx_info = IEEE80211_SKB_CB(skb);
+-	tx_info_priv = (struct ath_tx_info_priv *)tx_info->driver_data[0];
++	/* XXX: HACK! */
++	tx_info_priv = (struct ath_tx_info_priv *)tx_info->control.vif;
+ 	memcpy(bf->bf_rcs, tx_info_priv->rcs, 4 * sizeof(tx_info_priv->rcs[0]));
+ 
+ 	/* Add sub-frame to BAW */
+@@ -1464,7 +1473,7 @@ static u32 ath_lookup_rate(struct ath_so
+ 	skb = (struct sk_buff *)bf->bf_mpdu;
+ 	tx_info = IEEE80211_SKB_CB(skb);
+ 	tx_info_priv = (struct ath_tx_info_priv *)
+-		tx_info->driver_data[0];
++		tx_info->control.vif; /* XXX: HACK! */
+ 	memcpy(bf->bf_rcs,
+ 		tx_info_priv->rcs, 4 * sizeof(tx_info_priv->rcs[0]));
+ 
+@@ -1924,7 +1933,8 @@ static int ath_tx_start_dma(struct ath_s
+ 
+ 	bf->bf_flags = txctl->flags;
+ 	bf->bf_keytype = txctl->keytype;
+-	tx_info_priv = (struct ath_tx_info_priv *)tx_info->driver_data[0];
++	/* XXX: HACK! */
++	tx_info_priv = (struct ath_tx_info_priv *)tx_info->control.vif;
+ 	rcs = tx_info_priv->rcs;
+ 	bf->bf_rcs[0] = rcs[0];
+ 	bf->bf_rcs[1] = rcs[1];
+--- a/drivers/net/wireless/b43/dma.c
++++ b/drivers/net/wireless/b43/dma.c
+@@ -1387,13 +1387,13 @@ void b43_dma_handle_txstatus(struct b43_
+ 
+ 			info = IEEE80211_SKB_CB(meta->skb);
+ 
+-			memset(&info->status, 0, sizeof(info->status));
++			ieee80211_tx_info_clear_status(info);
+ 
+ 			/*
+ 			 * Call back to inform the ieee80211 subsystem about
+ 			 * the status of the transmission.
+ 			 */
+-			frame_succeed = b43_fill_txstatus_report(info, status);
++			frame_succeed = b43_fill_txstatus_report(dev, info, status);
+ #ifdef CONFIG_B43_DEBUG
+ 			if (frame_succeed)
+ 				ring->nr_succeed_tx_packets++;
+--- a/drivers/net/wireless/b43/main.c
++++ b/drivers/net/wireless/b43/main.c
+@@ -4563,7 +4563,7 @@ static int b43_wireless_init(struct ssb_
+ 		BIT(NL80211_IFTYPE_ADHOC);
+ 
+ 	hw->queues = b43_modparam_qos ? 4 : 1;
+-	hw->max_altrates = 1;
++	hw->max_rates = 2;
+ 	SET_IEEE80211_DEV(hw, dev->dev);
+ 	if (is_valid_ether_addr(sprom->et1mac))
+ 		SET_IEEE80211_PERM_ADDR(hw, sprom->et1mac);
+--- a/drivers/net/wireless/b43/pio.c
++++ b/drivers/net/wireless/b43/pio.c
+@@ -587,9 +587,9 @@ void b43_pio_handle_txstatus(struct b43_
+ 	spin_lock(&q->lock); /* IRQs are already disabled. */
+ 
+ 	info = IEEE80211_SKB_CB(pack->skb);
+-	memset(&info->status, 0, sizeof(info->status));
++	ieee80211_tx_info_clear_status(info);
+ 
+-	b43_fill_txstatus_report(info, status);
++	b43_fill_txstatus_report(dev, info, status);
+ 
+ 	total_len = pack->skb->len + b43_txhdr_size(dev);
+ 	total_len = roundup(total_len, 4);
+--- a/drivers/net/wireless/b43/xmit.c
++++ b/drivers/net/wireless/b43/xmit.c
+@@ -185,7 +185,7 @@ int b43_generate_txhdr(struct b43_wldev 
+ 		       u8 *_txhdr,
+ 		       const unsigned char *fragment_data,
+ 		       unsigned int fragment_len,
+-		       const struct ieee80211_tx_info *info,
++		       struct ieee80211_tx_info *info,
+ 		       u16 cookie)
+ {
+ 	struct b43_txhdr *txhdr = (struct b43_txhdr *)_txhdr;
+@@ -202,6 +202,7 @@ int b43_generate_txhdr(struct b43_wldev 
+ 	u16 phy_ctl = 0;
+ 	u8 extra_ft = 0;
+ 	struct ieee80211_rate *txrate;
++	struct ieee80211_tx_rate *rates;
+ 
+ 	memset(txhdr, 0, sizeof(*txhdr));
+ 
+@@ -291,7 +292,7 @@ int b43_generate_txhdr(struct b43_wldev 
+ 		phy_ctl |= B43_TXH_PHY_ENC_OFDM;
+ 	else
+ 		phy_ctl |= B43_TXH_PHY_ENC_CCK;
+-	if (info->flags & IEEE80211_TX_CTL_SHORT_PREAMBLE)
++	if (info->control.rates[0].flags & IEEE80211_TX_RC_USE_SHORT_PREAMBLE)
+ 		phy_ctl |= B43_TXH_PHY_SHORTPRMBL;
+ 
+ 	switch (b43_ieee80211_antenna_sanitize(dev, info->antenna_sel_tx)) {
+@@ -314,6 +315,7 @@ int b43_generate_txhdr(struct b43_wldev 
+ 		B43_WARN_ON(1);
+ 	}
+ 
++	rates = info->control.rates;
+ 	/* MAC control */
+ 	if (!(info->flags & IEEE80211_TX_CTL_NO_ACK))
+ 		mac_ctl |= B43_TXH_MAC_ACK;
+@@ -324,12 +326,22 @@ int b43_generate_txhdr(struct b43_wldev 
+ 		mac_ctl |= B43_TXH_MAC_STMSDU;
+ 	if (phy->type == B43_PHYTYPE_A)
+ 		mac_ctl |= B43_TXH_MAC_5GHZ;
+-	if (info->flags & IEEE80211_TX_CTL_LONG_RETRY_LIMIT)
++
++	/* Overwrite rates[0].count to make the retry calculation
++	 * in the tx status easier. need the actual retry limit to
++	 * detect whether the fallback rate was used.
++	 */
++	if ((rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS) ||
++	    (rates[0].count <= dev->wl->hw->conf.long_frame_max_tx_count)) {
++		rates[0].count = dev->wl->hw->conf.long_frame_max_tx_count;
+ 		mac_ctl |= B43_TXH_MAC_LONGFRAME;
++	} else {
++		rates[0].count = dev->wl->hw->conf.short_frame_max_tx_count;
++	}
+ 
+ 	/* Generate the RTS or CTS-to-self frame */
+-	if ((info->flags & IEEE80211_TX_CTL_USE_RTS_CTS) ||
+-	    (info->flags & IEEE80211_TX_CTL_USE_CTS_PROTECT)) {
++	if ((rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS) ||
++	    (rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT)) {
+ 		unsigned int len;
+ 		struct ieee80211_hdr *hdr;
+ 		int rts_rate, rts_rate_fb;
+@@ -344,7 +356,7 @@ int b43_generate_txhdr(struct b43_wldev 
+ 		rts_rate_fb = b43_calc_fallback_rate(rts_rate);
+ 		rts_rate_fb_ofdm = b43_is_ofdm_rate(rts_rate_fb);
+ 
+-		if (info->flags & IEEE80211_TX_CTL_USE_CTS_PROTECT) {
++		if (rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT) {
+ 			struct ieee80211_cts *cts;
+ 
+ 			if (b43_is_old_txhdr_format(dev)) {
+@@ -687,10 +699,18 @@ void b43_handle_txstatus(struct b43_wlde
+ /* Fill out the mac80211 TXstatus report based on the b43-specific
+  * txstatus report data. This returns a boolean whether the frame was
+  * successfully transmitted. */
+-bool b43_fill_txstatus_report(struct ieee80211_tx_info *report,
++bool b43_fill_txstatus_report(struct b43_wldev *dev,
++			      struct ieee80211_tx_info *report,
+ 			      const struct b43_txstatus *status)
+ {
+ 	bool frame_success = 1;
++	int retry_limit;
++
++	/* preserve the confiured retry limit before clearing the status
++	 * The xmit function has overwritten the rc's value with the actual
++	 * retry limit done by the hardware */
++	retry_limit = report->status.rates[0].count;
++	ieee80211_tx_info_clear_status(report);
+ 
+ 	if (status->acked) {
+ 		/* The frame was ACKed. */
+@@ -700,14 +720,32 @@ bool b43_fill_txstatus_report(struct iee
+ 		if (!(report->flags & IEEE80211_TX_CTL_NO_ACK)) {
+ 			/* ...but we expected an ACK. */
+ 			frame_success = 0;
+-			report->status.excessive_retries = 1;
+ 		}
+ 	}
+ 	if (status->frame_count == 0) {
+ 		/* The frame was not transmitted at all. */
+-		report->status.retry_count = 0;
+-	} else
+-		report->status.retry_count = status->frame_count - 1;
++		report->status.rates[0].count = 0;
++	} else if (status->rts_count > dev->wl->hw->conf.short_frame_max_tx_count) {
++		/*
++		 * If the short retries (RTS, not data frame) have exceeded
++		 * the limit, the hw will not have tried the selected rate,
++		 * but will have used the fallback rate instead.
++		 * Don't let the rate control count attempts for the selected
++		 * rate in this case, otherwise the statistics will be off.
++		 */
++		report->status.rates[0].count = 0;
++		report->status.rates[1].count = status->frame_count;
++	} else {
++		if (status->frame_count > retry_limit) {
++			report->status.rates[0].count = retry_limit;
++			report->status.rates[1].count = status->frame_count -
++					retry_limit;
++
++		} else {
++			report->status.rates[0].count = status->frame_count;
++			report->status.rates[1].idx = -1;
++		}
++	}
+ 
+ 	return frame_success;
+ }
+--- a/drivers/net/wireless/b43/xmit.h
++++ b/drivers/net/wireless/b43/xmit.h
+@@ -178,7 +178,7 @@ int b43_generate_txhdr(struct b43_wldev 
+ 		       u8 * txhdr,
+ 		       const unsigned char *fragment_data,
+ 		       unsigned int fragment_len,
+-		       const struct ieee80211_tx_info *txctl, u16 cookie);
++		       struct ieee80211_tx_info *txctl, u16 cookie);
+ 
+ /* Transmit Status */
+ struct b43_txstatus {
+@@ -294,7 +294,8 @@ void b43_rx(struct b43_wldev *dev, struc
+ 
+ void b43_handle_txstatus(struct b43_wldev *dev,
+ 			 const struct b43_txstatus *status);
+-bool b43_fill_txstatus_report(struct ieee80211_tx_info *report,
++bool b43_fill_txstatus_report(struct b43_wldev *dev,
++			      struct ieee80211_tx_info *report,
+ 			      const struct b43_txstatus *status);
+ 
+ void b43_tx_suspend(struct b43_wldev *dev);
+--- a/drivers/net/wireless/b43legacy/dma.c
++++ b/drivers/net/wireless/b43legacy/dma.c
+@@ -1411,6 +1411,7 @@ void b43legacy_dma_handle_txstatus(struc
+ 	struct b43legacy_dmaring *ring;
+ 	struct b43legacy_dmadesc_generic *desc;
+ 	struct b43legacy_dmadesc_meta *meta;
++	int retry_limit;
+ 	int slot;
+ 
+ 	ring = parse_cookie(dev, status->cookie, &slot);
+@@ -1437,25 +1438,42 @@ void b43legacy_dma_handle_txstatus(struc
+ 			struct ieee80211_tx_info *info;
+ 			BUG_ON(!meta->skb);
+ 			info = IEEE80211_SKB_CB(meta->skb);
+-			/* Call back to inform the ieee80211 subsystem about the
+-			 * status of the transmission.
+-			 * Some fields of txstat are already filled in dma_tx().
+-			 */
+ 
+-			memset(&info->status, 0, sizeof(info->status));
++			/* preserve the confiured retry limit before clearing the status
++			 * The xmit function has overwritten the rc's value with the actual
++			 * retry limit done by the hardware */
++			retry_limit = info->status.rates[0].count;
++			ieee80211_tx_info_clear_status(info);
+ 
+-			if (status->acked) {
++			if (status->acked)
+ 				info->flags |= IEEE80211_TX_STAT_ACK;
++
++			if (status->rts_count > dev->wl->hw->conf.short_frame_max_tx_count) {
++				/*
++				 * If the short retries (RTS, not data frame) have exceeded
++				 * the limit, the hw will not have tried the selected rate,
++				 * but will have used the fallback rate instead.
++				 * Don't let the rate control count attempts for the selected
++				 * rate in this case, otherwise the statistics will be off.
++				 */
++				info->status.rates[0].count = 0;
++				info->status.rates[1].count = status->frame_count;
+ 			} else {
+-				if (!(info->flags & IEEE80211_TX_CTL_NO_ACK))
+-					 info->status.excessive_retries = 1;
++				if (status->frame_count > retry_limit) {
++					info->status.rates[0].count = retry_limit;
++					info->status.rates[1].count = status->frame_count -
++							retry_limit;
++
++				} else {
++					info->status.rates[0].count = status->frame_count;
++					info->status.rates[1].idx = -1;
++				}
+ 			}
+-			if (status->frame_count == 0) {
+-				/* The frame was not transmitted at all. */
+-				info->status.retry_count = 0;
+-			} else
+-				info->status.retry_count = status->frame_count
+-							   - 1;
++
++			/* Call back to inform the ieee80211 subsystem about the
++			 * status of the transmission.
++			 * Some fields of txstat are already filled in dma_tx().
++			 */
+ 			ieee80211_tx_status_irqsafe(dev->wl->hw, meta->skb);
+ 			/* skb is freed by ieee80211_tx_status_irqsafe() */
+ 			meta->skb = NULL;
+--- a/drivers/net/wireless/b43legacy/main.c
++++ b/drivers/net/wireless/b43legacy/main.c
+@@ -3691,7 +3691,7 @@ static int b43legacy_wireless_init(struc
+ 		BIT(NL80211_IFTYPE_WDS) |
+ 		BIT(NL80211_IFTYPE_ADHOC);
+ 	hw->queues = 1; /* FIXME: hardware has more queues */
+-	hw->max_altrates = 1;
++	hw->max_rates = 2;
+ 	SET_IEEE80211_DEV(hw, dev->dev);
+ 	if (is_valid_ether_addr(sprom->et1mac))
+ 		SET_IEEE80211_PERM_ADDR(hw, sprom->et1mac);
+--- a/drivers/net/wireless/b43legacy/pio.c
++++ b/drivers/net/wireless/b43legacy/pio.c
+@@ -491,6 +491,7 @@ void b43legacy_pio_handle_txstatus(struc
+ 	struct b43legacy_pioqueue *queue;
+ 	struct b43legacy_pio_txpacket *packet;
+ 	struct ieee80211_tx_info *info;
++	int retry_limit;
+ 
+ 	queue = parse_cookie(dev, status->cookie, &packet);
+ 	B43legacy_WARN_ON(!queue);
+@@ -503,11 +504,37 @@ void b43legacy_pio_handle_txstatus(struc
+ 				sizeof(struct b43legacy_txhdr_fw3));
+ 
+ 	info = IEEE80211_SKB_CB(packet->skb);
+-	memset(&info->status, 0, sizeof(info->status));
++
++	/* preserve the confiured retry limit before clearing the status
++	 * The xmit function has overwritten the rc's value with the actual
++	 * retry limit done by the hardware */
++	retry_limit = info->status.rates[0].count;
++	ieee80211_tx_info_clear_status(info);
+ 
+ 	if (status->acked)
+ 		info->flags |= IEEE80211_TX_STAT_ACK;
+-	info->status.retry_count = status->frame_count - 1;
++
++	if (status->rts_count > dev->wl->hw->conf.short_frame_max_tx_count) {
++		/*
++		 * If the short retries (RTS, not data frame) have exceeded
++		 * the limit, the hw will not have tried the selected rate,
++		 * but will have used the fallback rate instead.
++		 * Don't let the rate control count attempts for the selected
++		 * rate in this case, otherwise the statistics will be off.
++		 */
++		info->status.rates[0].count = 0;
++		info->status.rates[1].count = status->frame_count;
++	} else {
++		if (status->frame_count > retry_limit) {
++			info->status.rates[0].count = retry_limit;
++			info->status.rates[1].count = status->frame_count -
++					retry_limit;
++
++		} else {
++			info->status.rates[0].count = status->frame_count;
++			info->status.rates[1].idx = -1;
++		}
++	}
+ 	ieee80211_tx_status_irqsafe(dev->wl->hw, packet->skb);
+ 	packet->skb = NULL;
+ 
+--- a/drivers/net/wireless/b43legacy/xmit.c
++++ b/drivers/net/wireless/b43legacy/xmit.c
+@@ -188,7 +188,7 @@ static int generate_txhdr_fw3(struct b43
+ 			       struct b43legacy_txhdr_fw3 *txhdr,
+ 			       const unsigned char *fragment_data,
+ 			       unsigned int fragment_len,
+-			       const struct ieee80211_tx_info *info,
++			       struct ieee80211_tx_info *info,
+ 			       u16 cookie)
+ {
+ 	const struct ieee80211_hdr *wlhdr;
+@@ -201,6 +201,7 @@ static int generate_txhdr_fw3(struct b43
+ 	u32 mac_ctl = 0;
+ 	u16 phy_ctl = 0;
+ 	struct ieee80211_rate *tx_rate;
++	struct ieee80211_tx_rate *rates;
+ 
+ 	wlhdr = (const struct ieee80211_hdr *)fragment_data;
+ 
+@@ -274,7 +275,7 @@ static int generate_txhdr_fw3(struct b43
+ 	/* PHY TX Control word */
+ 	if (rate_ofdm)
+ 		phy_ctl |= B43legacy_TX4_PHY_OFDM;
+-	if (dev->short_preamble)
++	if (info->control.rates[0].flags & IEEE80211_TX_RC_USE_SHORT_PREAMBLE)
+ 		phy_ctl |= B43legacy_TX4_PHY_SHORTPRMBL;
+ 	switch (info->antenna_sel_tx) {
+ 	case 0:
+@@ -291,6 +292,7 @@ static int generate_txhdr_fw3(struct b43
+ 	}
+ 
+ 	/* MAC control */
++	rates = info->control.rates;
+ 	if (!(info->flags & IEEE80211_TX_CTL_NO_ACK))
+ 		mac_ctl |= B43legacy_TX4_MAC_ACK;
+ 	if (info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ)
+@@ -299,12 +301,22 @@ static int generate_txhdr_fw3(struct b43
+ 		mac_ctl |= B43legacy_TX4_MAC_STMSDU;
+ 	if (rate_fb_ofdm)
+ 		mac_ctl |= B43legacy_TX4_MAC_FALLBACKOFDM;
+-	if (info->flags & IEEE80211_TX_CTL_LONG_RETRY_LIMIT)
++
++	/* Overwrite rates[0].count to make the retry calculation
++	 * in the tx status easier. need the actual retry limit to
++	 * detect whether the fallback rate was used.
++	 */
++	if ((rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS) ||
++	    (rates[0].count <= dev->wl->hw->conf.long_frame_max_tx_count)) {
++		rates[0].count = dev->wl->hw->conf.long_frame_max_tx_count;
+ 		mac_ctl |= B43legacy_TX4_MAC_LONGFRAME;
++	} else {
++		rates[0].count = dev->wl->hw->conf.short_frame_max_tx_count;
++	}
+ 
+ 	/* Generate the RTS or CTS-to-self frame */
+-	if ((info->flags & IEEE80211_TX_CTL_USE_RTS_CTS) ||
+-	    (info->flags & IEEE80211_TX_CTL_USE_CTS_PROTECT)) {
++	if ((rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS) ||
++	    (rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT)) {
+ 		unsigned int len;
+ 		struct ieee80211_hdr *hdr;
+ 		int rts_rate;
+@@ -319,7 +331,7 @@ static int generate_txhdr_fw3(struct b43
+ 		if (rts_rate_fb_ofdm)
+ 			mac_ctl |= B43legacy_TX4_MAC_CTSFALLBACKOFDM;
+ 
+-		if (info->flags & IEEE80211_TX_CTL_USE_CTS_PROTECT) {
++		if (rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT) {
+ 			ieee80211_ctstoself_get(dev->wl->hw,
+ 						info->control.vif,
+ 						fragment_data,
+@@ -362,7 +374,7 @@ int b43legacy_generate_txhdr(struct b43l
+ 			      u8 *txhdr,
+ 			      const unsigned char *fragment_data,
+ 			      unsigned int fragment_len,
+-			      const struct ieee80211_tx_info *info,
++			      struct ieee80211_tx_info *info,
+ 			      u16 cookie)
+ {
+ 	return generate_txhdr_fw3(dev, (struct b43legacy_txhdr_fw3 *)txhdr,
+--- a/drivers/net/wireless/b43legacy/xmit.h
++++ b/drivers/net/wireless/b43legacy/xmit.h
+@@ -80,7 +80,7 @@ int b43legacy_generate_txhdr(struct b43l
+ 			      u8 *txhdr,
+ 			      const unsigned char *fragment_data,
+ 			      unsigned int fragment_len,
+-			      const struct ieee80211_tx_info *info,
++			      struct ieee80211_tx_info *info,
+ 			      u16 cookie);
+ 
+ 
+--- a/drivers/net/wireless/iwlwifi/iwl-3945-rs.c
++++ b/drivers/net/wireless/iwlwifi/iwl-3945-rs.c
+@@ -422,34 +422,6 @@ static void rs_free_sta(void *priv, stru
+ }
+ 
+ 
+-/*
+- * get ieee prev rate from rate scale table.
+- * for A and B mode we need to overright prev
+- * value
+- */
+-static int rs_adjust_next_rate(struct iwl3945_priv *priv, int rate)
+-{
+-	int next_rate = iwl3945_get_prev_ieee_rate(rate);
+-
+-	switch (priv->band) {
+-	case IEEE80211_BAND_5GHZ:
+-		if (rate == IWL_RATE_12M_INDEX)
+-			next_rate = IWL_RATE_9M_INDEX;
+-		else if (rate == IWL_RATE_6M_INDEX)
+-			next_rate = IWL_RATE_6M_INDEX;
+-		break;
+-/* XXX cannot be invoked in current mac80211 so not a regression
+-	case MODE_IEEE80211B:
+-		if (rate == IWL_RATE_11M_INDEX_TABLE)
+-			next_rate = IWL_RATE_5M_INDEX_TABLE;
+-		break;
+- */
+-	default:
+-		break;
+-	}
+-
+-	return next_rate;
+-}
+ /**
+  * rs_tx_status - Update rate control values based on Tx results
+  *
+@@ -460,17 +432,21 @@ static void rs_tx_status(void *priv_rate
+ 			 struct ieee80211_sta *sta, void *priv_sta,
+ 			 struct sk_buff *skb)
+ {
+-	u8 retries, current_count;
++	u8 retries = 0, current_count;
+ 	int scale_rate_index, first_index, last_index;
+ 	unsigned long flags;
+ 	struct iwl3945_priv *priv = (struct iwl3945_priv *)priv_rate;
+ 	struct iwl3945_rs_sta *rs_sta = priv_sta;
+ 	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
++	int i;
+ 
+ 	IWL_DEBUG_RATE("enter\n");
+ 
+-	retries = info->status.retry_count;
+-	first_index = sband->bitrates[info->tx_rate_idx].hw_value;
++	for (i = 0; i < IEEE80211_TX_MAX_RATES; i++)
++		retries += info->status.rates[i].count;
++	retries--;
++
++	first_index = sband->bitrates[info->status.rates[0].idx].hw_value;
+ 	if ((first_index < 0) || (first_index >= IWL_RATE_COUNT)) {
+ 		IWL_DEBUG_RATE("leave: Rate out of bounds: %d\n", first_index);
+ 		return;
+@@ -502,7 +478,7 @@ static void rs_tx_status(void *priv_rate
+ 			last_index = scale_rate_index;
+ 		} else {
+ 			current_count = priv->retry_rate;
+-			last_index = rs_adjust_next_rate(priv,
++			last_index = iwl3945_rs_next_rate(priv,
+ 							 scale_rate_index);
+ 		}
+ 
+@@ -518,7 +494,7 @@ static void rs_tx_status(void *priv_rate
+ 
+ 		if (retries)
+ 			scale_rate_index =
+-			    rs_adjust_next_rate(priv, scale_rate_index);
++			    iwl3945_rs_next_rate(priv, scale_rate_index);
+ 	}
+ 
+ 
+@@ -630,10 +606,11 @@ static u16 iwl3945_get_adjacent_rate(str
+  * rate table and must reference the driver allocated rate table
+  *
+  */
+-static void rs_get_rate(void *priv_r, struct ieee80211_supported_band *sband,
+-			struct ieee80211_sta *sta, void *priv_sta,
+-			struct sk_buff *skb, struct rate_selection *sel)
++static void rs_get_rate(void *priv_r, struct ieee80211_sta *sta,
++			void *priv_sta,	struct ieee80211_tx_rate_control *txrc)
+ {
++	struct ieee80211_supported_band *sband = txrc->sband;
++	struct sk_buff *skb = txrc->skb;
+ 	u8 low = IWL_RATE_INVALID;
+ 	u8 high = IWL_RATE_INVALID;
+ 	u16 high_low;
+@@ -649,6 +626,7 @@ static void rs_get_rate(void *priv_r, st
+ 	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
+ 	u16 fc, rate_mask;
+ 	struct iwl3945_priv *priv = (struct iwl3945_priv *)priv_r;
++	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
+ 	DECLARE_MAC_BUF(mac);
+ 
+ 	IWL_DEBUG_RATE("enter\n");
+@@ -660,7 +638,7 @@ static void rs_get_rate(void *priv_r, st
+ 	    is_multicast_ether_addr(hdr->addr1) ||
+ 	    !sta || !priv_sta) {
+ 		IWL_DEBUG_RATE("leave: No STA priv data to update!\n");
+-		sel->rate_idx = rate_lowest_index(sband, sta);
++		info->control.rates[0].idx = rate_lowest_index(sband, sta);
+ 		return;
+ 	}
+ 
+@@ -793,9 +771,10 @@ static void rs_get_rate(void *priv_r, st
+ 
+ 	rs_sta->last_txrate_idx = index;
+ 	if (sband->band == IEEE80211_BAND_5GHZ)
+-		sel->rate_idx = rs_sta->last_txrate_idx - IWL_FIRST_OFDM_RATE;
++		info->control.rates[0].idx = rs_sta->last_txrate_idx -
++				IWL_FIRST_OFDM_RATE;
+ 	else
+-		sel->rate_idx = rs_sta->last_txrate_idx;
++		info->control.rates[0].idx = rs_sta->last_txrate_idx;
+ 
+ 	IWL_DEBUG_RATE("leave: %d\n", index);
+ }
+--- a/drivers/net/wireless/iwlwifi/iwl-3945.c
++++ b/drivers/net/wireless/iwlwifi/iwl-3945.c
+@@ -261,6 +261,35 @@ static inline const char *iwl3945_get_tx
+ }
+ #endif
+ 
++/*
++ * get ieee prev rate from rate scale table.
++ * for A and B mode we need to overright prev
++ * value
++ */
++int iwl3945_rs_next_rate(struct iwl3945_priv *priv, int rate)
++{
++	int next_rate = iwl3945_get_prev_ieee_rate(rate);
++
++	switch (priv->band) {
++	case IEEE80211_BAND_5GHZ:
++		if (rate == IWL_RATE_12M_INDEX)
++			next_rate = IWL_RATE_9M_INDEX;
++		else if (rate == IWL_RATE_6M_INDEX)
++			next_rate = IWL_RATE_6M_INDEX;
++		break;
++/* XXX cannot be invoked in current mac80211 so not a regression
++	case MODE_IEEE80211B:
++		if (rate == IWL_RATE_11M_INDEX_TABLE)
++			next_rate = IWL_RATE_5M_INDEX_TABLE;
++		break;
++ */
++	default:
++		break;
++	}
++
++	return next_rate;
++}
++
+ 
+ /**
+  * iwl3945_tx_queue_reclaim - Reclaim Tx queue entries already Tx'd
+@@ -308,6 +337,7 @@ static void iwl3945_rx_reply_tx(struct i
+ 	struct iwl3945_tx_resp *tx_resp = (void *)&pkt->u.raw[0];
+ 	u32  status = le32_to_cpu(tx_resp->status);
+ 	int rate_idx;
++	int fail, i;
+ 
+ 	if ((index >= txq->q.n_bd) || (iwl3945_x2_queue_used(&txq->q, index) == 0)) {
+ 		IWL_ERROR("Read index for DMA queue txq_id (%d) index %d "
+@@ -318,9 +348,33 @@ static void iwl3945_rx_reply_tx(struct i
+ 	}
+ 
+ 	info = IEEE80211_SKB_CB(txq->txb[txq->q.read_ptr].skb[0]);
+-	memset(&info->status, 0, sizeof(info->status));
++	ieee80211_tx_info_clear_status(info);
++
++	/* Fill the MRR chain with some info about on-chip retransmissions */
++	rate_idx = iwl3945_hwrate_to_plcp_idx(tx_resp->rate);
++	if (info->band == IEEE80211_BAND_5GHZ)
++		rate_idx -= IWL_FIRST_OFDM_RATE;
++
++	info->status.rates[0].count = tx_resp->failure_frame + 1;
++	fail = tx_resp->failure_frame;
++	for(i = 0; i < 4; i++) {
++		int next = iwl3945_rs_next_rate(priv, rate_idx);
++
++		info->status.rates[i].idx = rate_idx;
++
++		if ((rate_idx == next) || (i == 3)) {
++			info->status.rates[i].count = fail;
++			break;
++		}
++
++		info->status.rates[i].count = priv->retry_rate;
++		fail -= priv->retry_rate;
++		rate_idx = next;
++		if (fail <= 0)
++			break;
++	}
++	info->status.rates[i].count++; /* add final attempt */
+ 
+-	info->status.retry_count = tx_resp->failure_frame;
+ 	/* tx_status->rts_retry_count = tx_resp->failure_rts; */
+ 	info->flags |= ((status & TX_STATUS_MSK) == TX_STATUS_SUCCESS) ?
+ 				IEEE80211_TX_STAT_ACK : 0;
+@@ -329,10 +383,6 @@ static void iwl3945_rx_reply_tx(struct i
+ 			txq_id, iwl3945_get_tx_fail_reason(status), status,
+ 			tx_resp->rate, tx_resp->failure_frame);
+ 
+-	rate_idx = iwl3945_hwrate_to_plcp_idx(tx_resp->rate);
+-	if (info->band == IEEE80211_BAND_5GHZ)
+-		rate_idx -= IWL_FIRST_OFDM_RATE;
+-	info->tx_rate_idx = rate_idx;
+ 	IWL_DEBUG_TX_REPLY("Tx queue reclaim %d\n", index);
+ 	iwl3945_tx_queue_reclaim(priv, txq_id, index);
+ 
+--- a/drivers/net/wireless/iwlwifi/iwl-3945.h
++++ b/drivers/net/wireless/iwlwifi/iwl-3945.h
+@@ -954,6 +954,8 @@ static inline int is_channel_ibss(const 
+ extern const struct iwl3945_channel_info *iwl3945_get_channel_info(
+ 	const struct iwl3945_priv *priv, enum ieee80211_band band, u16 channel);
+ 
++extern int iwl3945_rs_next_rate(struct iwl3945_priv *priv, int rate);
++
+ /* Requires full declaration of iwl3945_priv before including */
+ #include "iwl-3945-io.h"
+ 
+--- a/drivers/net/wireless/iwlwifi/iwl-core.c
++++ b/drivers/net/wireless/iwlwifi/iwl-core.c
+@@ -88,26 +88,27 @@ EXPORT_SYMBOL(iwl_rates);
+  * translate ucode response to mac80211 tx status control values
+  */
+ void iwl_hwrate_to_tx_control(struct iwl_priv *priv, u32 rate_n_flags,
+-				  struct ieee80211_tx_info *control)
++				  struct ieee80211_tx_info *info)
+ {
+ 	int rate_index;
++	struct ieee80211_tx_rate *r = &info->control.rates[0];
+ 
+-	control->antenna_sel_tx =
++	info->antenna_sel_tx =
+ 		((rate_n_flags & RATE_MCS_ANT_ABC_MSK) >> RATE_MCS_ANT_POS);
+ 	if (rate_n_flags & RATE_MCS_HT_MSK)
+-		control->flags |= IEEE80211_TX_CTL_OFDM_HT;
++		r->flags |= IEEE80211_TX_RC_MCS;
+ 	if (rate_n_flags & RATE_MCS_GF_MSK)
+-		control->flags |= IEEE80211_TX_CTL_GREEN_FIELD;
++		r->flags |= IEEE80211_TX_RC_GREEN_FIELD;
+ 	if (rate_n_flags & RATE_MCS_FAT_MSK)
+-		control->flags |= IEEE80211_TX_CTL_40_MHZ_WIDTH;
++		r->flags |= IEEE80211_TX_RC_40_MHZ_WIDTH;
+ 	if (rate_n_flags & RATE_MCS_DUP_MSK)
+-		control->flags |= IEEE80211_TX_CTL_DUP_DATA;
++		r->flags |= IEEE80211_TX_RC_DUP_DATA;
+ 	if (rate_n_flags & RATE_MCS_SGI_MSK)
+-		control->flags |= IEEE80211_TX_CTL_SHORT_GI;
++		r->flags |= IEEE80211_TX_RC_SHORT_GI;
+ 	rate_index = iwl_hwrate_to_plcp_idx(rate_n_flags);
+-	if (control->band == IEEE80211_BAND_5GHZ)
++	if (info->band == IEEE80211_BAND_5GHZ)
+ 		rate_index -= IWL_FIRST_OFDM_RATE;
+-	control->tx_rate_idx = rate_index;
++	r->idx = rate_index;
+ }
+ EXPORT_SYMBOL(iwl_hwrate_to_tx_control);
+ 
+--- a/drivers/net/wireless/iwlwifi/iwl3945-base.c
++++ b/drivers/net/wireless/iwlwifi/iwl3945-base.c
+@@ -2397,6 +2397,7 @@ static void iwl3945_build_tx_cmd_basic(s
+ {
+ 	__le16 fc = hdr->frame_control;
+ 	__le32 tx_flags = cmd->cmd.tx.tx_flags;
++	u8 rc_flags = info->control.rates[0].flags;
+ 
+ 	cmd->cmd.tx.stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;
+ 	if (!(info->flags & IEEE80211_TX_CTL_NO_ACK)) {
+@@ -2423,10 +2424,10 @@ static void iwl3945_build_tx_cmd_basic(s
+ 		tx_flags |= TX_CMD_FLG_SEQ_CTL_MSK;
+ 	}
+ 
+-	if (info->flags & IEEE80211_TX_CTL_USE_RTS_CTS) {
++	if (rc_flags & IEEE80211_TX_RC_USE_RTS_CTS) {
+ 		tx_flags |= TX_CMD_FLG_RTS_MSK;
+ 		tx_flags &= ~TX_CMD_FLG_CTS_MSK;
+-	} else if (info->flags & IEEE80211_TX_CTL_USE_CTS_PROTECT) {
++	} else if (rc_flags & IEEE80211_TX_RC_USE_CTS_PROTECT) {
+ 		tx_flags &= ~TX_CMD_FLG_RTS_MSK;
+ 		tx_flags |= TX_CMD_FLG_CTS_MSK;
+ 	}
+--- a/drivers/net/wireless/mac80211_hwsim.c
++++ b/drivers/net/wireless/mac80211_hwsim.c
+@@ -209,7 +209,7 @@ static bool mac80211_hwsim_tx_frame(stru
+ 	/* TODO: set mactime */
+ 	rx_status.freq = data->channel->center_freq;
+ 	rx_status.band = data->channel->band;
+-	rx_status.rate_idx = info->tx_rate_idx;
++	rx_status.rate_idx = info->control.rates[0].idx;
+ 	/* TODO: simulate signal strength (and optional packet drop) */
+ 
+ 	/* Copy skb to all enabled radios that are on the current frequency */
+@@ -269,13 +269,9 @@ static int mac80211_hwsim_tx(struct ieee
+ 	if (txi->control.sta)
+ 		hwsim_check_sta_magic(txi->control.sta);
+ 
+-	memset(&txi->status, 0, sizeof(txi->status));
+-	if (!(txi->flags & IEEE80211_TX_CTL_NO_ACK)) {
+-		if (ack)
+-			txi->flags |= IEEE80211_TX_STAT_ACK;
+-		else
+-			txi->status.excessive_retries = 1;
+-	}
++	ieee80211_tx_info_clear_status(txi);
++	if (!(txi->flags & IEEE80211_TX_CTL_NO_ACK) && ack)
++		txi->flags |= IEEE80211_TX_STAT_ACK;
+ 	ieee80211_tx_status_irqsafe(hw, skb);
+ 	return NETDEV_TX_OK;
+ }
+--- a/drivers/net/wireless/rtl8180_dev.c
++++ b/drivers/net/wireless/rtl8180_dev.c
+@@ -182,15 +182,13 @@ static void rtl8180_handle_tx(struct iee
+ 				 skb->len, PCI_DMA_TODEVICE);
+ 
+ 		info = IEEE80211_SKB_CB(skb);
+-		memset(&info->status, 0, sizeof(info->status));
++		ieee80211_tx_info_clear_status(info);
+ 
+-		if (!(info->flags & IEEE80211_TX_CTL_NO_ACK)) {
+-			if (flags & RTL818X_TX_DESC_FLAG_TX_OK)
+-				info->flags |= IEEE80211_TX_STAT_ACK;
+-			else
+-				info->status.excessive_retries = 1;
+-		}
+-		info->status.retry_count = flags & 0xFF;
++		if (!(info->flags & IEEE80211_TX_CTL_NO_ACK) &&
++		    (flags & RTL818X_TX_DESC_FLAG_TX_OK))
++			info->flags |= IEEE80211_TX_STAT_ACK;
++
++		info->status.rates[0].count = (flags & 0xFF) + 1;
+ 
+ 		ieee80211_tx_status_irqsafe(dev, skb);
+ 		if (ring->entries - skb_queue_len(&ring->queue) == 2)
+@@ -243,6 +241,7 @@ static int rtl8180_tx(struct ieee80211_h
+ 	unsigned int idx, prio;
+ 	dma_addr_t mapping;
+ 	u32 tx_flags;
++	u8 rc_flags;
+ 	u16 plcp_len = 0;
+ 	__le16 rts_duration = 0;
+ 
+@@ -261,15 +260,16 @@ static int rtl8180_tx(struct ieee80211_h
+ 		tx_flags |= RTL818X_TX_DESC_FLAG_DMA |
+ 			    RTL818X_TX_DESC_FLAG_NO_ENC;
+ 
+-	if (info->flags & IEEE80211_TX_CTL_USE_RTS_CTS) {
++	rc_flags = info->control.rates[0].flags;
++	if (rc_flags & IEEE80211_TX_RC_USE_RTS_CTS) {
+ 		tx_flags |= RTL818X_TX_DESC_FLAG_RTS;
+ 		tx_flags |= ieee80211_get_rts_cts_rate(dev, info)->hw_value << 19;
+-	} else if (info->flags & IEEE80211_TX_CTL_USE_CTS_PROTECT) {
++	} else if (rc_flags & IEEE80211_TX_RC_USE_CTS_PROTECT) {
+ 		tx_flags |= RTL818X_TX_DESC_FLAG_CTS;
+ 		tx_flags |= ieee80211_get_rts_cts_rate(dev, info)->hw_value << 19;
+ 	}
+ 
+-	if (info->flags & IEEE80211_TX_CTL_USE_RTS_CTS)
++	if (rc_flags & IEEE80211_TX_RC_USE_RTS_CTS)
+ 		rts_duration = ieee80211_rts_duration(dev, priv->vif, skb->len,
+ 						      info);
+ 
+@@ -292,9 +292,9 @@ static int rtl8180_tx(struct ieee80211_h
+ 	entry->plcp_len = cpu_to_le16(plcp_len);
+ 	entry->tx_buf = cpu_to_le32(mapping);
+ 	entry->frame_len = cpu_to_le32(skb->len);
+-	entry->flags2 = info->control.retries[0].rate_idx >= 0 ?
++	entry->flags2 = info->control.rates[1].idx >= 0 ?
+ 		ieee80211_get_alt_retry_rate(dev, info, 0)->bitrate << 4 : 0;
+-	entry->retry_limit = info->control.retry_limit;
++	entry->retry_limit = info->control.rates[0].count;
+ 	entry->flags = cpu_to_le32(tx_flags);
+ 	__skb_queue_tail(&ring->queue, skb);
+ 	if (ring->entries - skb_queue_len(&ring->queue) < 2)
+@@ -856,7 +856,7 @@ static int __devinit rtl8180_probe(struc
+ 	priv = dev->priv;
+ 	priv->pdev = pdev;
+ 
+-	dev->max_altrates = 1;
++	dev->max_rates = 2;
+ 	SET_IEEE80211_DEV(dev, &pdev->dev);
+ 	pci_set_drvdata(pdev, dev);
+ 
+--- a/drivers/net/wireless/rtl8187_dev.c
++++ b/drivers/net/wireless/rtl8187_dev.c
+@@ -163,7 +163,7 @@ static void rtl8187_tx_cb(struct urb *ur
+ 	usb_free_urb(info->driver_data[1]);
+ 	skb_pull(skb, priv->is_rtl8187b ? sizeof(struct rtl8187b_tx_hdr) :
+ 					  sizeof(struct rtl8187_tx_hdr));
+-	memset(&info->status, 0, sizeof(info->status));
++	ieee80211_tx_info_clear_status(info);
+ 	info->flags |= IEEE80211_TX_STAT_ACK;
+ 	ieee80211_tx_status_irqsafe(hw, skb);
+ }
+@@ -192,12 +192,12 @@ static int rtl8187_tx(struct ieee80211_h
+ 	flags |= ieee80211_get_tx_rate(dev, info)->hw_value << 24;
+ 	if (ieee80211_has_morefrags(((struct ieee80211_hdr *)skb->data)->frame_control))
+ 		flags |= RTL818X_TX_DESC_FLAG_MOREFRAG;
+-	if (info->flags & IEEE80211_TX_CTL_USE_RTS_CTS) {
++	if (info->control.rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS) {
+ 		flags |= RTL818X_TX_DESC_FLAG_RTS;
+ 		flags |= ieee80211_get_rts_cts_rate(dev, info)->hw_value << 19;
+ 		rts_dur = ieee80211_rts_duration(dev, priv->vif,
+ 						 skb->len, info);
+-	} else if (info->flags & IEEE80211_TX_CTL_USE_CTS_PROTECT) {
++	} else if (info->control.rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT) {
+ 		flags |= RTL818X_TX_DESC_FLAG_CTS;
+ 		flags |= ieee80211_get_rts_cts_rate(dev, info)->hw_value << 19;
+ 	}
+@@ -208,7 +208,7 @@ static int rtl8187_tx(struct ieee80211_h
+ 		hdr->flags = cpu_to_le32(flags);
+ 		hdr->len = 0;
+ 		hdr->rts_duration = rts_dur;
+-		hdr->retry = cpu_to_le32(info->control.retry_limit << 8);
++		hdr->retry = cpu_to_le32((info->control.rates[0].count - 1) << 8);
+ 		buf = hdr;
+ 
+ 		ep = 2;
+@@ -226,7 +226,7 @@ static int rtl8187_tx(struct ieee80211_h
+ 		memset(hdr, 0, sizeof(*hdr));
+ 		hdr->flags = cpu_to_le32(flags);
+ 		hdr->rts_duration = rts_dur;
+-		hdr->retry = cpu_to_le32(info->control.retry_limit << 8);
++		hdr->retry = cpu_to_le32((info->control.rates[0].count - 1) << 8);
+ 		hdr->tx_duration =
+ 			ieee80211_generic_frame_duration(dev, priv->vif,
+ 							 skb->len, txrate);
+--- a/drivers/net/wireless/p54/p54common.c
++++ b/drivers/net/wireless/p54/p54common.c
+@@ -577,7 +577,7 @@ static void p54_rx_frame_sent(struct iee
+ 			__skb_unlink(entry, &priv->tx_queue);
+ 			spin_unlock_irqrestore(&priv->tx_queue.lock, flags);
+ 
+-			memset(&info->status, 0, sizeof(info->status));
++			ieee80211_tx_info_clear_status(info);
+ 			entry_hdr = (struct p54_control_hdr *) entry->data;
+ 			entry_data = (struct p54_tx_control_allocdata *) entry_hdr->data;
+ 			if ((entry_hdr->magic1 & cpu_to_le16(0x4000)) != 0)
+@@ -587,10 +587,8 @@ static void p54_rx_frame_sent(struct iee
+ 			if (!(info->flags & IEEE80211_TX_CTL_NO_ACK)) {
+ 				if (!(payload->status & 0x01))
+ 					info->flags |= IEEE80211_TX_STAT_ACK;
+-				else
+-					info->status.excessive_retries = 1;
+ 			}
+-			info->status.retry_count = payload->retries - 1;
++			info->status.rates[0].count = payload->retries;
+ 			info->status.ack_signal = p54_rssi_to_dbm(dev,
+ 					le16_to_cpu(payload->ack_rssi));
+ 			skb_pull(entry, sizeof(*hdr) + pad + sizeof(*entry_data));
+@@ -816,6 +814,7 @@ static int p54_tx(struct ieee80211_hw *d
+ 	size_t padding, len;
+ 	u8 rate;
+ 	u8 cts_rate = 0x20;
++	u8 rc_flags;
+ 
+ 	current_queue = &priv->tx_stats[skb_get_queue_mapping(skb) + 4];
+ 	if (unlikely(current_queue->len > current_queue->limit))
+@@ -838,18 +837,19 @@ static int p54_tx(struct ieee80211_hw *d
+ 		hdr->magic1 = cpu_to_le16(0x0010);
+ 	hdr->len = cpu_to_le16(len);
+ 	hdr->type = (info->flags & IEEE80211_TX_CTL_NO_ACK) ? 0 : cpu_to_le16(1);
+-	hdr->retry1 = hdr->retry2 = info->control.retry_limit;
++	hdr->retry1 = hdr->retry2 = info->control.rates[0].count;
+ 
+ 	/* TODO: add support for alternate retry TX rates */
+ 	rate = ieee80211_get_tx_rate(dev, info)->hw_value;
+-	if (info->flags & IEEE80211_TX_CTL_SHORT_PREAMBLE) {
++	rc_flags = info->control.rates[0].flags;
++	if (rc_flags & IEEE80211_TX_RC_USE_SHORT_PREAMBLE) {
+ 		rate |= 0x10;
+ 		cts_rate |= 0x10;
+ 	}
+-	if (info->flags & IEEE80211_TX_CTL_USE_RTS_CTS) {
++	if (rc_flags & IEEE80211_TX_RC_USE_RTS_CTS) {
+ 		rate |= 0x40;
+ 		cts_rate |= ieee80211_get_rts_cts_rate(dev, info)->hw_value;
+-	} else if (info->flags & IEEE80211_TX_CTL_USE_CTS_PROTECT) {
++	} else if (rc_flags & IEEE80211_TX_RC_USE_CTS_PROTECT) {
+ 		rate |= 0x20;
+ 		cts_rate |= ieee80211_get_rts_cts_rate(dev, info)->hw_value;
+ 	}
+--- a/drivers/net/wireless/iwlwifi/iwl-4965.c
++++ b/drivers/net/wireless/iwlwifi/iwl-4965.c
+@@ -619,10 +619,10 @@ static void iwl4965_gain_computation(str
+ static void iwl4965_rts_tx_cmd_flag(struct ieee80211_tx_info *info,
+ 			__le32 *tx_flags)
+ {
+-	if (info->flags & IEEE80211_TX_CTL_USE_RTS_CTS) {
++	if (info->control.rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS) {
+ 		*tx_flags |= TX_CMD_FLG_RTS_MSK;
+ 		*tx_flags &= ~TX_CMD_FLG_CTS_MSK;
+-	} else if (info->flags & IEEE80211_TX_CTL_USE_CTS_PROTECT) {
++	} else if (info->control.rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT) {
+ 		*tx_flags &= ~TX_CMD_FLG_RTS_MSK;
+ 		*tx_flags |= TX_CMD_FLG_CTS_MSK;
+ 	}
+@@ -2070,7 +2070,7 @@ static int iwl4965_tx_status_reply_tx(st
+ 				   agg->frame_count, agg->start_idx, idx);
+ 
+ 		info = IEEE80211_SKB_CB(priv->txq[txq_id].txb[idx].skb[0]);
+-		info->status.retry_count = tx_resp->failure_frame;
++		info->status.rates[0].count = tx_resp->failure_frame + 1;
+ 		info->flags &= ~IEEE80211_TX_CTL_AMPDU;
+ 		info->flags |= iwl_is_tx_success(status)?
+ 			IEEE80211_TX_STAT_ACK : 0;
+@@ -2227,7 +2227,7 @@ static void iwl4965_rx_reply_tx(struct i
+ 			iwl_txq_check_empty(priv, sta_id, tid, txq_id);
+ 		}
+ 	} else {
+-		info->status.retry_count = tx_resp->failure_frame;
++		info->status.rates[0].count = tx_resp->failure_frame + 1;
+ 		info->flags |=
+ 			iwl_is_tx_success(status) ? IEEE80211_TX_STAT_ACK : 0;
+ 		iwl_hwrate_to_tx_control(priv,
+--- a/drivers/net/wireless/iwlwifi/iwl-5000.c
++++ b/drivers/net/wireless/iwlwifi/iwl-5000.c
+@@ -390,8 +390,8 @@ static void iwl5000_chain_noise_reset(st
+ static void iwl5000_rts_tx_cmd_flag(struct ieee80211_tx_info *info,
+ 			__le32 *tx_flags)
+ {
+-	if ((info->flags & IEEE80211_TX_CTL_USE_RTS_CTS) ||
+-	    (info->flags & IEEE80211_TX_CTL_USE_CTS_PROTECT))
++	if ((info->control.rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS) ||
++	    (info->control.rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT))
+ 		*tx_flags |= TX_CMD_FLG_RTS_CTS_MSK;
+ 	else
+ 		*tx_flags &= ~TX_CMD_FLG_RTS_CTS_MSK;
+@@ -1136,7 +1136,7 @@ static int iwl5000_tx_status_reply_tx(st
+ 				   agg->frame_count, agg->start_idx, idx);
+ 
+ 		info = IEEE80211_SKB_CB(priv->txq[txq_id].txb[idx].skb[0]);
+-		info->status.retry_count = tx_resp->failure_frame;
++		info->status.rates[0].count = tx_resp->failure_frame + 1;
+ 		info->flags &= ~IEEE80211_TX_CTL_AMPDU;
+ 		info->flags |= iwl_is_tx_success(status)?
+ 			IEEE80211_TX_STAT_ACK : 0;
+@@ -1289,7 +1289,7 @@ static void iwl5000_rx_reply_tx(struct i
+ 			iwl_txq_check_empty(priv, sta_id, tid, txq_id);
+ 		}
+ 	} else {
+-		info->status.retry_count = tx_resp->failure_frame;
++		info->status.rates[0].count = tx_resp->failure_frame + 1;
+ 		info->flags =
+ 			iwl_is_tx_success(status) ? IEEE80211_TX_STAT_ACK : 0;
+ 		iwl_hwrate_to_tx_control(priv,
+--- a/drivers/net/wireless/iwlwifi/iwl-agn-rs.c
++++ b/drivers/net/wireless/iwlwifi/iwl-agn-rs.c
+@@ -800,7 +800,7 @@ static void rs_tx_status(void *priv_r, s
+ 	    !(info->flags & IEEE80211_TX_STAT_AMPDU))
+ 		return;
+ 
+-	retries = info->status.retry_count;
++	retries = info->status.rates[0].count + 1;
+ 
+ 	if (retries > 15)
+ 		retries = 15;
+@@ -832,20 +832,15 @@ static void rs_tx_status(void *priv_r, s
+ 	if (priv->band == IEEE80211_BAND_5GHZ)
+ 		rs_index -= IWL_FIRST_OFDM_RATE;
+ 
+-	if ((info->tx_rate_idx < 0) ||
+-	    (tbl_type.is_SGI ^
+-		!!(info->flags & IEEE80211_TX_CTL_SHORT_GI)) ||
+-	    (tbl_type.is_fat ^
+-		!!(info->flags & IEEE80211_TX_CTL_40_MHZ_WIDTH)) ||
+-	    (tbl_type.is_dup ^
+-		!!(info->flags & IEEE80211_TX_CTL_DUP_DATA)) ||
+-	    (tbl_type.ant_type ^ info->antenna_sel_tx) ||
+-	    (!!(tx_rate & RATE_MCS_HT_MSK) ^
+-		!!(info->flags & IEEE80211_TX_CTL_OFDM_HT)) ||
+-	    (!!(tx_rate & RATE_MCS_GF_MSK) ^
+-		!!(info->flags & IEEE80211_TX_CTL_GREEN_FIELD)) ||
++	if ((info->status.rates[0].idx < 0) ||
++	    (tbl_type.is_SGI != !!(info->status.rates[0].flags & IEEE80211_TX_RC_SHORT_GI)) ||
++	    (tbl_type.is_fat != !!(info->status.rates[0].flags & IEEE80211_TX_RC_40_MHZ_WIDTH)) ||
++	    (tbl_type.is_dup != !!(info->status.rates[0].flags & IEEE80211_TX_RC_DUP_DATA)) ||
++	    (tbl_type.ant_type != info->antenna_sel_tx) ||
++	    (!!(tx_rate & RATE_MCS_HT_MSK) != !!(info->status.rates[0].flags & IEEE80211_TX_RC_MCS)) ||
++	    (!!(tx_rate & RATE_MCS_GF_MSK) != !!(info->status.rates[0].flags & IEEE80211_TX_RC_GREEN_FIELD)) ||
+ 	    (hw->wiphy->bands[priv->band]->bitrates[rs_index].bitrate !=
+-	     hw->wiphy->bands[info->band]->bitrates[info->tx_rate_idx].bitrate)) {
++	     hw->wiphy->bands[info->band]->bitrates[info->status.rates[0].idx].bitrate)) {
+ 		IWL_DEBUG_RATE("initial rate does not match 0x%x\n", tx_rate);
+ 		goto out;
+ 	}
+@@ -2103,15 +2098,17 @@ static void rs_initialize_lq(struct iwl_
+ 	return;
+ }
+ 
+-static void rs_get_rate(void *priv_r, struct ieee80211_supported_band *sband,
+-			struct ieee80211_sta *sta, void *priv_sta,
+-			struct sk_buff *skb, struct rate_selection *sel)
++static void rs_get_rate(void *priv_r, struct ieee80211_sta *sta, void *priv_sta,
++			struct ieee80211_tx_rate_control *txrc)
+ {
+ 
+ 	int i;
++	struct sk_buff *skb = txrc->skb;
++	struct ieee80211_supported_band *sband = txrc->sband;
+ 	struct iwl_priv *priv = (struct iwl_priv *)priv_r;
+ 	struct ieee80211_conf *conf = &priv->hw->conf;
+ 	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
++	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
+ 	__le16 fc;
+ 	struct iwl_lq_sta *lq_sta;
+ 
+@@ -2122,7 +2119,7 @@ static void rs_get_rate(void *priv_r, st
+ 	fc = hdr->frame_control;
+ 	if (!ieee80211_is_data(fc) || is_multicast_ether_addr(hdr->addr1) ||
+ 	    !sta || !priv_sta) {
+-		sel->rate_idx = rate_lowest_index(sband, sta);
++		info->control.rates[0].idx = rate_lowest_index(sband, sta);
+ 		return;
+ 	}
+ 
+@@ -2149,13 +2146,13 @@ static void rs_get_rate(void *priv_r, st
+ 	}
+ 
+ 	if ((i < 0) || (i > IWL_RATE_COUNT)) {
+-		sel->rate_idx = rate_lowest_index(sband, sta);
++		info->control.rates[0].idx = rate_lowest_index(sband, sta);
+ 		return;
+ 	}
+ 
+ 	if (sband->band == IEEE80211_BAND_5GHZ)
+ 		i -= IWL_FIRST_OFDM_RATE;
+-	sel->rate_idx = i;
++	info->control.rates[0].idx = i;
+ }
+ 
+ static void *rs_alloc_sta(void *priv_rate, struct ieee80211_sta *sta,
diff --git a/package/mac80211/patches/426-minstrel_performance.patch b/package/mac80211/patches/426-minstrel_performance.patch
new file mode 100644
index 0000000000..7b95163c6c
--- /dev/null
+++ b/package/mac80211/patches/426-minstrel_performance.patch
@@ -0,0 +1,100 @@
+This patch enhances minstrel's performance for non-MRR setups,
+by preventing it from sampling slower rates with >95% success
+probability and by putting at least 1 non-sample frame between
+several sample frames.
+
+Signed-off-by: Felix Fietkau <nbd@openwrt.org>
+
+--- a/net/mac80211/rc80211_minstrel.c
++++ b/net/mac80211/rc80211_minstrel.c
+@@ -126,7 +126,9 @@ minstrel_update_stats(struct minstrel_pr
+ 			mr->adjusted_retry_count = mr->retry_count >> 1;
+ 			if (mr->adjusted_retry_count > 2)
+ 				mr->adjusted_retry_count = 2;
++			mr->sample_limit = 4;
+ 		} else {
++			mr->sample_limit = -1;
+ 			mr->adjusted_retry_count = mr->retry_count;
+ 		}
+ 		if (!mr->adjusted_retry_count)
+@@ -265,7 +267,8 @@ minstrel_get_rate(void *priv, struct iee
+ 			(mi->sample_count + mi->sample_deferred / 2);
+ 
+ 	/* delta > 0: sampling required */
+-	if (delta > 0) {
++	if ((delta > 0) && (mrr || !mi->prev_sample)) {
++		struct minstrel_rate *msr;
+ 		if (mi->packet_count >= 10000) {
+ 			mi->sample_deferred = 0;
+ 			mi->sample_count = 0;
+@@ -284,13 +287,20 @@ minstrel_get_rate(void *priv, struct iee
+ 		}
+ 
+ 		sample_ndx = minstrel_get_next_sample(mi);
++		msr = &mi->r[sample_ndx];
+ 		sample = true;
+-		sample_slower = mrr && (mi->r[sample_ndx].perfect_tx_time >
++		sample_slower = mrr && (msr->perfect_tx_time >
+ 			mi->r[ndx].perfect_tx_time);
+ 
+ 		if (!sample_slower) {
+-			ndx = sample_ndx;
+-			mi->sample_count++;
++			if (msr->sample_limit != 0) {
++				ndx = sample_ndx;
++				mi->sample_count++;
++				if (msr->sample_limit > 0)
++					msr->sample_limit--;
++			} else {
++				sample = false;
++			}
+ 		} else {
+ 			/* Only use IEEE80211_TX_CTL_RATE_CTRL_PROBE to mark
+ 			 * packets that have the sampling rate deferred to the
+@@ -302,10 +312,20 @@ minstrel_get_rate(void *priv, struct iee
+ 			mi->sample_deferred++;
+ 		}
+ 	}
++	mi->prev_sample = sample;
++
++	/* If we're not using MRR and the sampling rate already
++	 * has a probability of >95%, we shouldn't be attempting
++	 * to use it, as this only wastes precious airtime */
++	if (!mrr && sample && (mi->r[ndx].probability > 17100))
++		ndx = mi->max_tp_rate;
++
+ 	ar[0].idx = mi->r[ndx].rix;
+ 	ar[0].count = minstrel_get_retry_count(&mi->r[ndx], info);
+ 
+ 	if (!mrr) {
++		if (!sample)
++			ar[0].count = mp->max_retry;
+ 		ar[1].idx = mi->lowest_rix;
+ 		ar[1].count = mp->max_retry;
+ 		return;
+@@ -401,6 +421,7 @@ minstrel_rate_init(void *priv, struct ie
+ 
+ 		/* calculate maximum number of retransmissions before
+ 		 * fallback (based on maximum segment size) */
++		mr->sample_limit = -1;
+ 		mr->retry_count = 1;
+ 		mr->retry_count_cts = 1;
+ 		mr->retry_count_rtscts = 1;
+--- a/net/mac80211/rc80211_minstrel.h
++++ b/net/mac80211/rc80211_minstrel.h
+@@ -16,6 +16,7 @@ struct minstrel_rate {
+ 	unsigned int perfect_tx_time;
+ 	unsigned int ack_time;
+ 
++	int sample_limit;
+ 	unsigned int retry_count;
+ 	unsigned int retry_count_cts;
+ 	unsigned int retry_count_rtscts;
+@@ -57,6 +58,7 @@ struct minstrel_sta_info {
+ 
+ 	int n_rates;
+ 	struct minstrel_rate *r;
++	bool prev_sample;
+ 
+ 	/* sampling table */
+ 	u8 *sample_table;