19 files changed, 203 insertions, 153 deletions

diff --git a/drivers/net/wireless/rt2x00/rt2400pci.c b/drivers/net/wireless/rt2x00/rt2400pci.c
index 137a24e520da..5d1654a8bda8 100644
--- a/drivers/net/wireless/rt2x00/rt2400pci.c
+++ b/drivers/net/wireless/rt2x00/rt2400pci.c
@@ -1536,13 +1536,13 @@ static int rt2400pci_init_eeprom(struct rt2x00_dev *rt2x00dev)
          * Detect if this device has an hardware controlled radio.
          */
         if (rt2x00_get_field16(eeprom, EEPROM_ANTENNA_HARDWARE_RADIO))
-                __set_bit(CONFIG_SUPPORT_HW_BUTTON, &rt2x00dev->flags);
+                __set_bit(CAPABILITY_HW_BUTTON, &rt2x00dev->cap_flags);
 
         /*
          * Check if the BBP tuning should be enabled.
          */
         if (rt2x00_get_field16(eeprom, EEPROM_ANTENNA_RX_AGCVGC_TUNING))
-                __set_bit(DRIVER_SUPPORT_LINK_TUNING, &rt2x00dev->flags);
+                __set_bit(CAPABILITY_LINK_TUNING, &rt2x00dev->cap_flags);
 
         return 0;
 }
@@ -1640,9 +1640,9 @@ static int rt2400pci_probe_hw(struct rt2x00_dev *rt2x00dev)
         /*
          * This device requires the atim queue and DMA-mapped skbs.
          */
-        __set_bit(DRIVER_REQUIRE_ATIM_QUEUE, &rt2x00dev->flags);
-        __set_bit(DRIVER_REQUIRE_DMA, &rt2x00dev->flags);
-        __set_bit(DRIVER_REQUIRE_SW_SEQNO, &rt2x00dev->flags);
+        __set_bit(REQUIRE_ATIM_QUEUE, &rt2x00dev->cap_flags);
+        __set_bit(REQUIRE_DMA, &rt2x00dev->cap_flags);
+        __set_bit(REQUIRE_SW_SEQNO, &rt2x00dev->cap_flags);
 
         /*
          * Set the rssi offset.
diff --git a/drivers/net/wireless/rt2x00/rt2500pci.c b/drivers/net/wireless/rt2x00/rt2500pci.c
index 198fc0a0d77c..3da954e1b4ab 100644
--- a/drivers/net/wireless/rt2x00/rt2500pci.c
+++ b/drivers/net/wireless/rt2x00/rt2500pci.c
@@ -1687,14 +1687,14 @@ static int rt2500pci_init_eeprom(struct rt2x00_dev *rt2x00dev)
          * Detect if this device has an hardware controlled radio.
          */
         if (rt2x00_get_field16(eeprom, EEPROM_ANTENNA_HARDWARE_RADIO))
-                __set_bit(CONFIG_SUPPORT_HW_BUTTON, &rt2x00dev->flags);
+                __set_bit(CAPABILITY_HW_BUTTON, &rt2x00dev->cap_flags);
 
         /*
          * Check if the BBP tuning should be enabled.
          */
         rt2x00_eeprom_read(rt2x00dev, EEPROM_NIC, &eeprom);
         if (!rt2x00_get_field16(eeprom, EEPROM_NIC_DYN_BBP_TUNE))
-                __set_bit(DRIVER_SUPPORT_LINK_TUNING, &rt2x00dev->flags);
+                __set_bit(CAPABILITY_LINK_TUNING, &rt2x00dev->cap_flags);
 
         /*
          * Read the RSSI <-> dBm offset information.
@@ -1958,9 +1958,9 @@ static int rt2500pci_probe_hw(struct rt2x00_dev *rt2x00dev)
         /*
          * This device requires the atim queue and DMA-mapped skbs.
          */
-        __set_bit(DRIVER_REQUIRE_ATIM_QUEUE, &rt2x00dev->flags);
-        __set_bit(DRIVER_REQUIRE_DMA, &rt2x00dev->flags);
-        __set_bit(DRIVER_REQUIRE_SW_SEQNO, &rt2x00dev->flags);
+        __set_bit(REQUIRE_ATIM_QUEUE, &rt2x00dev->cap_flags);
+        __set_bit(REQUIRE_DMA, &rt2x00dev->cap_flags);
+        __set_bit(REQUIRE_SW_SEQNO, &rt2x00dev->cap_flags);
 
         /*
          * Set the rssi offset.
diff --git a/drivers/net/wireless/rt2x00/rt2500usb.c b/drivers/net/wireless/rt2x00/rt2500usb.c
index eac788160f55..dbbd8bc851f1 100644
--- a/drivers/net/wireless/rt2x00/rt2500usb.c
+++ b/drivers/net/wireless/rt2x00/rt2500usb.c
@@ -1519,7 +1519,7 @@ static int rt2500usb_init_eeprom(struct rt2x00_dev *rt2x00dev)
          * Detect if this device has an hardware controlled radio.
          */
         if (rt2x00_get_field16(eeprom, EEPROM_ANTENNA_HARDWARE_RADIO))
-                __set_bit(CONFIG_SUPPORT_HW_BUTTON, &rt2x00dev->flags);
+                __set_bit(CAPABILITY_HW_BUTTON, &rt2x00dev->cap_flags);
 
         /*
          * Read the RSSI <-> dBm offset information.
@@ -1790,13 +1790,13 @@ static int rt2500usb_probe_hw(struct rt2x00_dev *rt2x00dev)
         /*
          * This device requires the atim queue
          */
-        __set_bit(DRIVER_REQUIRE_ATIM_QUEUE, &rt2x00dev->flags);
-        __set_bit(DRIVER_REQUIRE_BEACON_GUARD, &rt2x00dev->flags);
+        __set_bit(REQUIRE_ATIM_QUEUE, &rt2x00dev->cap_flags);
+        __set_bit(REQUIRE_BEACON_GUARD, &rt2x00dev->cap_flags);
         if (!modparam_nohwcrypt) {
-                __set_bit(CONFIG_SUPPORT_HW_CRYPTO, &rt2x00dev->flags);
-                __set_bit(DRIVER_REQUIRE_COPY_IV, &rt2x00dev->flags);
+                __set_bit(CAPABILITY_HW_CRYPTO, &rt2x00dev->cap_flags);
+                __set_bit(REQUIRE_COPY_IV, &rt2x00dev->cap_flags);
         }
-        __set_bit(DRIVER_REQUIRE_SW_SEQNO, &rt2x00dev->flags);
+        __set_bit(REQUIRE_SW_SEQNO, &rt2x00dev->cap_flags);
 
         /*
          * Set the rssi offset.
diff --git a/drivers/net/wireless/rt2x00/rt2800lib.c b/drivers/net/wireless/rt2x00/rt2800lib.c
index 13ccc1bbeb4b..c6f5584128e9 100644
--- a/drivers/net/wireless/rt2x00/rt2800lib.c
+++ b/drivers/net/wireless/rt2x00/rt2800lib.c
@@ -1763,8 +1763,8 @@ static void rt2800_config_channel(struct rt2x00_dev *rt2x00dev,
 
         if (rf->channel <= 14) {
                 if (!rt2x00_rt(rt2x00dev, RT5390)) {
-                        if (test_bit(CONFIG_EXTERNAL_LNA_BG,
-                                     &rt2x00dev->flags)) {
+                        if (test_bit(CAPABILITY_EXTERNAL_LNA_BG,
+                                     &rt2x00dev->cap_flags)) {
                                 rt2800_bbp_write(rt2x00dev, 82, 0x62);
                                 rt2800_bbp_write(rt2x00dev, 75, 0x46);
                         } else {
@@ -1775,7 +1775,7 @@ static void rt2800_config_channel(struct rt2x00_dev *rt2x00dev,
         } else {
                 rt2800_bbp_write(rt2x00dev, 82, 0xf2);
 
-                if (test_bit(CONFIG_EXTERNAL_LNA_A, &rt2x00dev->flags))
+                if (test_bit(CAPABILITY_EXTERNAL_LNA_A, &rt2x00dev->cap_flags))
                         rt2800_bbp_write(rt2x00dev, 75, 0x46);
                 else
                         rt2800_bbp_write(rt2x00dev, 75, 0x50);
@@ -2008,7 +2008,7 @@ static u8 rt2800_compensate_txpower(struct rt2x00_dev *rt2x00dev, int is_rate_b,
         if (!((band == IEEE80211_BAND_5GHZ) && is_rate_b))
                 return txpower;
 
-        if (test_bit(CONFIG_SUPPORT_POWER_LIMIT, &rt2x00dev->flags)) {
+        if (test_bit(CAPABILITY_POWER_LIMIT, &rt2x00dev->cap_flags)) {
                 /*
                  * Check if eirp txpower exceed txpower_limit.
                  * We use OFDM 6M as criterion and its eirp txpower
@@ -3309,8 +3309,8 @@ static int rt2800_init_rfcsr(struct rt2x00_dev *rt2x00dev)
                     rt2x00_rt_rev_lt(rt2x00dev, RT3071, REV_RT3071E) ||
                     rt2x00_rt_rev_lt(rt2x00dev, RT3090, REV_RT3090E) ||
                     rt2x00_rt_rev_lt(rt2x00dev, RT3390, REV_RT3390E)) {
-                        if (!test_bit(CONFIG_EXTERNAL_LNA_BG,
-                                      &rt2x00dev->flags))
+                        if (!test_bit(CAPABILITY_EXTERNAL_LNA_BG,
+                                      &rt2x00dev->cap_flags))
                                 rt2x00_set_field8(&rfcsr, RFCSR17_R, 1);
                 }
                 rt2x00_eeprom_read(rt2x00dev, EEPROM_TXMIXER_GAIN_BG, &eeprom);
@@ -3733,15 +3733,15 @@ int rt2800_init_eeprom(struct rt2x00_dev *rt2x00dev)
         rt2x00_eeprom_read(rt2x00dev, EEPROM_NIC_CONF1, &eeprom);
 
         if (rt2x00_get_field16(eeprom, EEPROM_NIC_CONF1_EXTERNAL_LNA_5G))
-                __set_bit(CONFIG_EXTERNAL_LNA_A, &rt2x00dev->flags);
+                __set_bit(CAPABILITY_EXTERNAL_LNA_A, &rt2x00dev->cap_flags);
         if (rt2x00_get_field16(eeprom, EEPROM_NIC_CONF1_EXTERNAL_LNA_2G))
-                __set_bit(CONFIG_EXTERNAL_LNA_BG, &rt2x00dev->flags);
+                __set_bit(CAPABILITY_EXTERNAL_LNA_BG, &rt2x00dev->cap_flags);
 
         /*
          * Detect if this device has an hardware controlled radio.
          */
         if (rt2x00_get_field16(eeprom, EEPROM_NIC_CONF1_HW_RADIO))
-                __set_bit(CONFIG_SUPPORT_HW_BUTTON, &rt2x00dev->flags);
+                __set_bit(CAPABILITY_HW_BUTTON, &rt2x00dev->cap_flags);
 
         /*
          * Store led settings, for correct led behaviour.
@@ -3761,7 +3761,7 @@ int rt2800_init_eeprom(struct rt2x00_dev *rt2x00dev)
 
         if (rt2x00_get_field16(eeprom, EEPROM_EIRP_MAX_TX_POWER_2GHZ) <
                                         EIRP_MAX_TX_POWER_LIMIT)
-                __set_bit(CONFIG_SUPPORT_POWER_LIMIT, &rt2x00dev->flags);
+                __set_bit(CAPABILITY_POWER_LIMIT, &rt2x00dev->cap_flags);
 
         return 0;
 }
diff --git a/drivers/net/wireless/rt2x00/rt2800pci.c b/drivers/net/wireless/rt2x00/rt2800pci.c
index adc3534254df..4241f1943842 100644
--- a/drivers/net/wireless/rt2x00/rt2800pci.c
+++ b/drivers/net/wireless/rt2x00/rt2800pci.c
@@ -966,28 +966,28 @@ static int rt2800pci_probe_hw(struct rt2x00_dev *rt2x00dev)
          * This device has multiple filters for control frames
          * and has a separate filter for PS Poll frames.
          */
-        __set_bit(DRIVER_SUPPORT_CONTROL_FILTERS, &rt2x00dev->flags);
-        __set_bit(DRIVER_SUPPORT_CONTROL_FILTER_PSPOLL, &rt2x00dev->flags);
+        __set_bit(CAPABILITY_CONTROL_FILTERS, &rt2x00dev->cap_flags);
+        __set_bit(CAPABILITY_CONTROL_FILTER_PSPOLL, &rt2x00dev->cap_flags);
 
         /*
          * This device has a pre tbtt interrupt and thus fetches
          * a new beacon directly prior to transmission.
          */
-        __set_bit(DRIVER_SUPPORT_PRE_TBTT_INTERRUPT, &rt2x00dev->flags);
+        __set_bit(CAPABILITY_PRE_TBTT_INTERRUPT, &rt2x00dev->cap_flags);
 
         /*
          * This device requires firmware.
          */
         if (!rt2x00_is_soc(rt2x00dev))
-                __set_bit(DRIVER_REQUIRE_FIRMWARE, &rt2x00dev->flags);
-        __set_bit(DRIVER_REQUIRE_DMA, &rt2x00dev->flags);
-        __set_bit(DRIVER_REQUIRE_L2PAD, &rt2x00dev->flags);
-        __set_bit(DRIVER_REQUIRE_TXSTATUS_FIFO, &rt2x00dev->flags);
-        __set_bit(DRIVER_REQUIRE_TASKLET_CONTEXT, &rt2x00dev->flags);
+                __set_bit(REQUIRE_FIRMWARE, &rt2x00dev->cap_flags);
+        __set_bit(REQUIRE_DMA, &rt2x00dev->cap_flags);
+        __set_bit(REQUIRE_L2PAD, &rt2x00dev->cap_flags);
+        __set_bit(REQUIRE_TXSTATUS_FIFO, &rt2x00dev->cap_flags);
+        __set_bit(REQUIRE_TASKLET_CONTEXT, &rt2x00dev->cap_flags);
         if (!modparam_nohwcrypt)
-                __set_bit(CONFIG_SUPPORT_HW_CRYPTO, &rt2x00dev->flags);
-        __set_bit(DRIVER_SUPPORT_LINK_TUNING, &rt2x00dev->flags);
-        __set_bit(DRIVER_REQUIRE_HT_TX_DESC, &rt2x00dev->flags);
+                __set_bit(CAPABILITY_HW_CRYPTO, &rt2x00dev->cap_flags);
+        __set_bit(CAPABILITY_LINK_TUNING, &rt2x00dev->cap_flags);
+        __set_bit(REQUIRE_HT_TX_DESC, &rt2x00dev->cap_flags);
 
         /*
          * Set the rssi offset.
diff --git a/drivers/net/wireless/rt2x00/rt2800usb.c b/drivers/net/wireless/rt2x00/rt2800usb.c
index d2f5c87305a4..f3ce5e854be6 100644
--- a/drivers/net/wireless/rt2x00/rt2800usb.c
+++ b/drivers/net/wireless/rt2x00/rt2800usb.c
@@ -553,18 +553,18 @@ static int rt2800usb_probe_hw(struct rt2x00_dev *rt2x00dev)
          * This device has multiple filters for control frames
          * and has a separate filter for PS Poll frames.
          */
-        __set_bit(DRIVER_SUPPORT_CONTROL_FILTERS, &rt2x00dev->flags);
-        __set_bit(DRIVER_SUPPORT_CONTROL_FILTER_PSPOLL, &rt2x00dev->flags);
+        __set_bit(CAPABILITY_CONTROL_FILTERS, &rt2x00dev->cap_flags);
+        __set_bit(CAPABILITY_CONTROL_FILTER_PSPOLL, &rt2x00dev->cap_flags);
 
         /*
          * This device requires firmware.
          */
-        __set_bit(DRIVER_REQUIRE_FIRMWARE, &rt2x00dev->flags);
-        __set_bit(DRIVER_REQUIRE_L2PAD, &rt2x00dev->flags);
+        __set_bit(REQUIRE_FIRMWARE, &rt2x00dev->cap_flags);
+        __set_bit(REQUIRE_L2PAD, &rt2x00dev->cap_flags);
         if (!modparam_nohwcrypt)
-                __set_bit(CONFIG_SUPPORT_HW_CRYPTO, &rt2x00dev->flags);
-        __set_bit(DRIVER_SUPPORT_LINK_TUNING, &rt2x00dev->flags);
-        __set_bit(DRIVER_REQUIRE_HT_TX_DESC, &rt2x00dev->flags);
+                __set_bit(CAPABILITY_HW_CRYPTO, &rt2x00dev->cap_flags);
+        __set_bit(CAPABILITY_LINK_TUNING, &rt2x00dev->cap_flags);
+        __set_bit(REQUIRE_HT_TX_DESC, &rt2x00dev->cap_flags);
 
         /*
          * Set the rssi offset.
diff --git a/drivers/net/wireless/rt2x00/rt2x00.h b/drivers/net/wireless/rt2x00/rt2x00.h
index dd0f66ade6e8..79c385accfac 100644
--- a/drivers/net/wireless/rt2x00/rt2x00.h
+++ b/drivers/net/wireless/rt2x00/rt2x00.h
@@ -643,11 +643,11 @@ struct rt2x00_ops {
 };
 
 /*
- * rt2x00 device flags
+ * rt2x00 state flags
  */
-enum rt2x00_flags {
+enum rt2x00_state_flags {
         /*
-         * Device state flags
+         * Device flags
          */
         DEVICE_STATE_PRESENT,
         DEVICE_STATE_REGISTERED_HW,
@@ -657,42 +657,47 @@ enum rt2x00_flags {
         DEVICE_STATE_SCANNING,
 
         /*
-         * Driver requirements
-         */
-        DRIVER_REQUIRE_FIRMWARE,
-        DRIVER_REQUIRE_BEACON_GUARD,
-        DRIVER_REQUIRE_ATIM_QUEUE,
-        DRIVER_REQUIRE_DMA,
-        DRIVER_REQUIRE_COPY_IV,
-        DRIVER_REQUIRE_L2PAD,
-        DRIVER_REQUIRE_TXSTATUS_FIFO,
-        DRIVER_REQUIRE_TASKLET_CONTEXT,
-        DRIVER_REQUIRE_SW_SEQNO,
-        DRIVER_REQUIRE_HT_TX_DESC,
-
-        /*
-         * Driver features
-         */
-        CONFIG_SUPPORT_HW_BUTTON,
-        CONFIG_SUPPORT_HW_CRYPTO,
-        CONFIG_SUPPORT_POWER_LIMIT,
-        DRIVER_SUPPORT_CONTROL_FILTERS,
-        DRIVER_SUPPORT_CONTROL_FILTER_PSPOLL,
-        DRIVER_SUPPORT_PRE_TBTT_INTERRUPT,
-        DRIVER_SUPPORT_LINK_TUNING,
-
-        /*
          * Driver configuration
          */
-        CONFIG_FRAME_TYPE,
-        CONFIG_RF_SEQUENCE,
-        CONFIG_EXTERNAL_LNA_A,
-        CONFIG_EXTERNAL_LNA_BG,
-        CONFIG_DOUBLE_ANTENNA,
         CONFIG_CHANNEL_HT40,
 };
 
 /*
+ * rt2x00 capability flags
+ */
+enum rt2x00_capability_flags {
+        /*
+         * Requirements
+         */
+        REQUIRE_FIRMWARE,
+        REQUIRE_BEACON_GUARD,
+        REQUIRE_ATIM_QUEUE,
+        REQUIRE_DMA,
+        REQUIRE_COPY_IV,
+        REQUIRE_L2PAD,
+        REQUIRE_TXSTATUS_FIFO,
+        REQUIRE_TASKLET_CONTEXT,
+        REQUIRE_SW_SEQNO,
+        REQUIRE_HT_TX_DESC,
+
+        /*
+         * Capabilities
+         */
+        CAPABILITY_HW_BUTTON,
+        CAPABILITY_HW_CRYPTO,
+        CAPABILITY_POWER_LIMIT,
+        CAPABILITY_CONTROL_FILTERS,
+        CAPABILITY_CONTROL_FILTER_PSPOLL,
+        CAPABILITY_PRE_TBTT_INTERRUPT,
+        CAPABILITY_LINK_TUNING,
+        CAPABILITY_FRAME_TYPE,
+        CAPABILITY_RF_SEQUENCE,
+        CAPABILITY_EXTERNAL_LNA_A,
+        CAPABILITY_EXTERNAL_LNA_BG,
+        CAPABILITY_DOUBLE_ANTENNA,
+};
+
+/*
  * rt2x00 device structure.
  */
 struct rt2x00_dev {
@@ -738,13 +743,20 @@ struct rt2x00_dev {
 #endif /* CONFIG_RT2X00_LIB_LEDS */
 
         /*
-         * Device flags.
-         * In these flags the current status and some
-         * of the device capabilities are stored.
+         * Device state flags.
+         * In these flags the current status is stored.
+         * Access to these flags should occur atomically.
          */
         unsigned long flags;
 
         /*
+         * Device capabiltiy flags.
+         * In these flags the device/driver capabilities are stored.
+         * Access to these flags should occur non-atomically.
+         */
+        unsigned long cap_flags;
+
+        /*
          * Device information, Bus IRQ and name (PCI, SoC)
          */
         int irq;
diff --git a/drivers/net/wireless/rt2x00/rt2x00config.c b/drivers/net/wireless/rt2x00/rt2x00config.c
index e7f67d5eda52..e225a66f59a0 100644
--- a/drivers/net/wireless/rt2x00/rt2x00config.c
+++ b/drivers/net/wireless/rt2x00/rt2x00config.c
@@ -176,10 +176,10 @@ void rt2x00lib_config(struct rt2x00_dev *rt2x00dev,
 
         if (ieee80211_flags & IEEE80211_CONF_CHANGE_CHANNEL) {
                 if (conf_is_ht40(conf)) {
-                        __set_bit(CONFIG_CHANNEL_HT40, &rt2x00dev->flags);
+                        set_bit(CONFIG_CHANNEL_HT40, &rt2x00dev->flags);
                         hw_value = rt2x00ht_center_channel(rt2x00dev, conf);
                 } else {
-                        __clear_bit(CONFIG_CHANNEL_HT40, &rt2x00dev->flags);
+                        clear_bit(CONFIG_CHANNEL_HT40, &rt2x00dev->flags);
                         hw_value = conf->channel->hw_value;
                 }
 
diff --git a/drivers/net/wireless/rt2x00/rt2x00crypto.c b/drivers/net/wireless/rt2x00/rt2x00crypto.c
index 5e9074bf2b8e..e1e0c51fcde8 100644
--- a/drivers/net/wireless/rt2x00/rt2x00crypto.c
+++ b/drivers/net/wireless/rt2x00/rt2x00crypto.c
@@ -52,7 +52,7 @@ void rt2x00crypto_create_tx_descriptor(struct queue_entry *entry,
         struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(entry->skb);
         struct ieee80211_key_conf *hw_key = tx_info->control.hw_key;
 
-        if (!test_bit(CONFIG_SUPPORT_HW_CRYPTO, &rt2x00dev->flags) || !hw_key)
+        if (!test_bit(CAPABILITY_HW_CRYPTO, &rt2x00dev->cap_flags) || !hw_key)
                 return;
 
         __set_bit(ENTRY_TXD_ENCRYPT, &txdesc->flags);
@@ -80,7 +80,7 @@ unsigned int rt2x00crypto_tx_overhead(struct rt2x00_dev *rt2x00dev,
         struct ieee80211_key_conf *key = tx_info->control.hw_key;
         unsigned int overhead = 0;
 
-        if (!test_bit(CONFIG_SUPPORT_HW_CRYPTO, &rt2x00dev->flags) || !key)
+        if (!test_bit(CAPABILITY_HW_CRYPTO, &rt2x00dev->cap_flags) || !key)
                 return overhead;
 
         /*
diff --git a/drivers/net/wireless/rt2x00/rt2x00debug.c b/drivers/net/wireless/rt2x00/rt2x00debug.c
index 66166ef037f5..78787fcc919e 100644
--- a/drivers/net/wireless/rt2x00/rt2x00debug.c
+++ b/drivers/net/wireless/rt2x00/rt2x00debug.c
@@ -63,7 +63,8 @@ struct rt2x00debug_intf {
          * - driver folder
          *   - driver file
          *   - chipset file
-         *   - device flags file
+         *   - device state flags file
+         *   - device capability flags file
          *   - register folder
          *     - csr offset/value files
          *     - eeprom offset/value files
@@ -78,6 +79,7 @@ struct rt2x00debug_intf {
         struct dentry *driver_entry;
         struct dentry *chipset_entry;
         struct dentry *dev_flags;
+        struct dentry *cap_flags;
         struct dentry *register_folder;
         struct dentry *csr_off_entry;
         struct dentry *csr_val_entry;
@@ -553,6 +555,35 @@ static const struct file_operations rt2x00debug_fop_dev_flags = {
         .llseek         = default_llseek,
 };
 
+static ssize_t rt2x00debug_read_cap_flags(struct file *file,
+                                          char __user *buf,
+                                          size_t length,
+                                          loff_t *offset)
+{
+        struct rt2x00debug_intf *intf = file->private_data;
+        char line[16];
+        size_t size;
+
+        if (*offset)
+                return 0;
+
+        size = sprintf(line, "0x%.8x\n", (unsigned int)intf->rt2x00dev->cap_flags);
+
+        if (copy_to_user(buf, line, size))
+                return -EFAULT;
+
+        *offset += size;
+        return size;
+}
+
+static const struct file_operations rt2x00debug_fop_cap_flags = {
+        .owner          = THIS_MODULE,
+        .read           = rt2x00debug_read_cap_flags,
+        .open           = rt2x00debug_file_open,
+        .release        = rt2x00debug_file_release,
+        .llseek         = default_llseek,
+};
+
 static struct dentry *rt2x00debug_create_file_driver(const char *name,
                                                      struct rt2x00debug_intf
                                                      *intf,
@@ -652,6 +683,12 @@ void rt2x00debug_register(struct rt2x00_dev *rt2x00dev)
         if (IS_ERR(intf->dev_flags) || !intf->dev_flags)
                 goto exit;
 
+        intf->cap_flags = debugfs_create_file("cap_flags", S_IRUSR,
+                                              intf->driver_folder, intf,
+                                              &rt2x00debug_fop_cap_flags);
+        if (IS_ERR(intf->cap_flags) || !intf->cap_flags)
+                goto exit;
+
         intf->register_folder =
             debugfs_create_dir("register", intf->driver_folder);
         if (IS_ERR(intf->register_folder) || !intf->register_folder)
@@ -705,7 +742,7 @@ void rt2x00debug_register(struct rt2x00_dev *rt2x00dev)
                                 intf, &rt2x00debug_fop_queue_stats);
 
 #ifdef CONFIG_RT2X00_LIB_CRYPTO
-        if (test_bit(CONFIG_SUPPORT_HW_CRYPTO, &rt2x00dev->flags))
+        if (test_bit(CAPABILITY_HW_CRYPTO, &rt2x00dev->cap_flags))
                 intf->crypto_stats_entry =
                     debugfs_create_file("crypto", S_IRUGO, intf->queue_folder,
                                         intf, &rt2x00debug_fop_crypto_stats);
@@ -743,6 +780,7 @@ void rt2x00debug_deregister(struct rt2x00_dev *rt2x00dev)
         debugfs_remove(intf->csr_off_entry);
         debugfs_remove(intf->register_folder);
         debugfs_remove(intf->dev_flags);
+        debugfs_remove(intf->cap_flags);
         debugfs_remove(intf->chipset_entry);
         debugfs_remove(intf->driver_entry);
         debugfs_remove(intf->driver_folder);
diff --git a/drivers/net/wireless/rt2x00/rt2x00dev.c b/drivers/net/wireless/rt2x00/rt2x00dev.c
index 9bffe8438d1f..af25b0152cbc 100644
--- a/drivers/net/wireless/rt2x00/rt2x00dev.c
+++ b/drivers/net/wireless/rt2x00/rt2x00dev.c
@@ -200,7 +200,7 @@ void rt2x00lib_beacondone(struct rt2x00_dev *rt2x00dev)
          * here as they will fetch the next beacon directly prior to
          * transmission.
          */
-        if (test_bit(DRIVER_SUPPORT_PRE_TBTT_INTERRUPT, &rt2x00dev->flags))
+        if (test_bit(CAPABILITY_PRE_TBTT_INTERRUPT, &rt2x00dev->cap_flags))
                 return;
 
         /* fetch next beacon */
@@ -271,7 +271,7 @@ void rt2x00lib_txdone(struct queue_entry *entry,
         /*
          * Remove L2 padding which was added during
          */
-        if (test_bit(DRIVER_REQUIRE_L2PAD, &rt2x00dev->flags))
+        if (test_bit(REQUIRE_L2PAD, &rt2x00dev->cap_flags))
                 rt2x00queue_remove_l2pad(entry->skb, header_length);
 
         /*
@@ -280,7 +280,7 @@ void rt2x00lib_txdone(struct queue_entry *entry,
          * mac80211 will expect the same data to be present it the
          * frame as it was passed to us.
          */
-        if (test_bit(CONFIG_SUPPORT_HW_CRYPTO, &rt2x00dev->flags))
+        if (test_bit(CAPABILITY_HW_CRYPTO, &rt2x00dev->cap_flags))
                 rt2x00crypto_tx_insert_iv(entry->skb, header_length);
 
         /*
@@ -377,7 +377,7 @@ void rt2x00lib_txdone(struct queue_entry *entry,
          * send the status report back.
          */
         if (!(skbdesc_flags & SKBDESC_NOT_MAC80211)) {
-                if (test_bit(DRIVER_REQUIRE_TASKLET_CONTEXT, &rt2x00dev->flags))
+                if (test_bit(REQUIRE_TASKLET_CONTEXT, &rt2x00dev->cap_flags))
                         ieee80211_tx_status(rt2x00dev->hw, entry->skb);
                 else
                         ieee80211_tx_status_ni(rt2x00dev->hw, entry->skb);
@@ -806,15 +806,15 @@ static int rt2x00lib_probe_hw(struct rt2x00_dev *rt2x00dev)
         /*
          * Take TX headroom required for alignment into account.
          */
-        if (test_bit(DRIVER_REQUIRE_L2PAD, &rt2x00dev->flags))
+        if (test_bit(REQUIRE_L2PAD, &rt2x00dev->cap_flags))
                 rt2x00dev->hw->extra_tx_headroom += RT2X00_L2PAD_SIZE;
-        else if (test_bit(DRIVER_REQUIRE_DMA, &rt2x00dev->flags))
+        else if (test_bit(REQUIRE_DMA, &rt2x00dev->cap_flags))
                 rt2x00dev->hw->extra_tx_headroom += RT2X00_ALIGN_SIZE;
 
         /*
          * Allocate tx status FIFO for driver use.
          */
-        if (test_bit(DRIVER_REQUIRE_TXSTATUS_FIFO, &rt2x00dev->flags)) {
+        if (test_bit(REQUIRE_TXSTATUS_FIFO, &rt2x00dev->cap_flags)) {
                 /*
                  * Allocate the txstatus fifo. In the worst case the tx
                  * status fifo has to hold the tx status of all entries
diff --git a/drivers/net/wireless/rt2x00/rt2x00firmware.c b/drivers/net/wireless/rt2x00/rt2x00firmware.c
index be0ff78c1b16..f316aad30612 100644
--- a/drivers/net/wireless/rt2x00/rt2x00firmware.c
+++ b/drivers/net/wireless/rt2x00/rt2x00firmware.c
@@ -99,7 +99,7 @@ int rt2x00lib_load_firmware(struct rt2x00_dev *rt2x00dev)
 {
         int retval;
 
-        if (!test_bit(DRIVER_REQUIRE_FIRMWARE, &rt2x00dev->flags))
+        if (!test_bit(REQUIRE_FIRMWARE, &rt2x00dev->cap_flags))
                 return 0;
 
         if (!rt2x00dev->fw) {
diff --git a/drivers/net/wireless/rt2x00/rt2x00lib.h b/drivers/net/wireless/rt2x00/rt2x00lib.h
index 88f2f9275528..bbee2cd40993 100644
--- a/drivers/net/wireless/rt2x00/rt2x00lib.h
+++ b/drivers/net/wireless/rt2x00/rt2x00lib.h
@@ -416,13 +416,13 @@ static inline u16 rt2x00ht_center_channel(struct rt2x00_dev *rt2x00dev,
  */
 static inline void rt2x00rfkill_register(struct rt2x00_dev *rt2x00dev)
 {
-        if (test_bit(CONFIG_SUPPORT_HW_BUTTON, &rt2x00dev->flags))
+        if (test_bit(CAPABILITY_HW_BUTTON, &rt2x00dev->cap_flags))
                 wiphy_rfkill_start_polling(rt2x00dev->hw->wiphy);
 }
 
 static inline void rt2x00rfkill_unregister(struct rt2x00_dev *rt2x00dev)
 {
-        if (test_bit(CONFIG_SUPPORT_HW_BUTTON, &rt2x00dev->flags))
+        if (test_bit(CAPABILITY_HW_BUTTON, &rt2x00dev->cap_flags))
                 wiphy_rfkill_stop_polling(rt2x00dev->hw->wiphy);
 }
 
diff --git a/drivers/net/wireless/rt2x00/rt2x00link.c b/drivers/net/wireless/rt2x00/rt2x00link.c
index 128b3615c08c..ba0bb766e59e 100644
--- a/drivers/net/wireless/rt2x00/rt2x00link.c
+++ b/drivers/net/wireless/rt2x00/rt2x00link.c
@@ -383,7 +383,7 @@ static void rt2x00link_tuner(struct work_struct *work)
          * do not support link tuning at all, while other devices can disable
          * the feature from the EEPROM.
          */
-        if (test_bit(DRIVER_SUPPORT_LINK_TUNING, &rt2x00dev->flags))
+        if (test_bit(CAPABILITY_LINK_TUNING, &rt2x00dev->cap_flags))
                 rt2x00dev->ops->lib->link_tuner(rt2x00dev, qual, link->count);
 
         /*
diff --git a/drivers/net/wireless/rt2x00/rt2x00mac.c b/drivers/net/wireless/rt2x00/rt2x00mac.c
index 4a1c41b59fea..4770156df1a8 100644
--- a/drivers/net/wireless/rt2x00/rt2x00mac.c
+++ b/drivers/net/wireless/rt2x00/rt2x00mac.c
@@ -119,7 +119,7 @@ void rt2x00mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
          * Use the ATIM queue if appropriate and present.
          */
         if (tx_info->flags & IEEE80211_TX_CTL_SEND_AFTER_DTIM &&
-            test_bit(DRIVER_REQUIRE_ATIM_QUEUE, &rt2x00dev->flags))
+            test_bit(REQUIRE_ATIM_QUEUE, &rt2x00dev->cap_flags))
                 qid = QID_ATIM;
 
         queue = rt2x00queue_get_tx_queue(rt2x00dev, qid);
@@ -411,11 +411,11 @@ void rt2x00mac_configure_filter(struct ieee80211_hw *hw,
          * of different types, but has no a separate filter for PS Poll frames,
          * FIF_CONTROL flag implies FIF_PSPOLL.
          */
-        if (!test_bit(DRIVER_SUPPORT_CONTROL_FILTERS, &rt2x00dev->flags)) {
+        if (!test_bit(CAPABILITY_CONTROL_FILTERS, &rt2x00dev->cap_flags)) {
                 if (*total_flags & FIF_CONTROL || *total_flags & FIF_PSPOLL)
                         *total_flags |= FIF_CONTROL | FIF_PSPOLL;
         }
-        if (!test_bit(DRIVER_SUPPORT_CONTROL_FILTER_PSPOLL, &rt2x00dev->flags)) {
+        if (!test_bit(CAPABILITY_CONTROL_FILTER_PSPOLL, &rt2x00dev->cap_flags)) {
                 if (*total_flags & FIF_CONTROL)
                         *total_flags |= FIF_PSPOLL;
         }
@@ -496,7 +496,7 @@ int rt2x00mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
 
         if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags))
                 return 0;
-        else if (!test_bit(CONFIG_SUPPORT_HW_CRYPTO, &rt2x00dev->flags))
+        else if (!test_bit(CAPABILITY_HW_CRYPTO, &rt2x00dev->cap_flags))
                 return -EOPNOTSUPP;
         else if (key->keylen > 32)
                 return -ENOSPC;
@@ -562,7 +562,7 @@ EXPORT_SYMBOL_GPL(rt2x00mac_set_key);
 void rt2x00mac_sw_scan_start(struct ieee80211_hw *hw)
 {
         struct rt2x00_dev *rt2x00dev = hw->priv;
-        __set_bit(DEVICE_STATE_SCANNING, &rt2x00dev->flags);
+        set_bit(DEVICE_STATE_SCANNING, &rt2x00dev->flags);
         rt2x00link_stop_tuner(rt2x00dev);
 }
 EXPORT_SYMBOL_GPL(rt2x00mac_sw_scan_start);
@@ -570,7 +570,7 @@ EXPORT_SYMBOL_GPL(rt2x00mac_sw_scan_start);
 void rt2x00mac_sw_scan_complete(struct ieee80211_hw *hw)
 {
         struct rt2x00_dev *rt2x00dev = hw->priv;
-        __clear_bit(DEVICE_STATE_SCANNING, &rt2x00dev->flags);
+        clear_bit(DEVICE_STATE_SCANNING, &rt2x00dev->flags);
         rt2x00link_start_tuner(rt2x00dev);
 }
 EXPORT_SYMBOL_GPL(rt2x00mac_sw_scan_complete);
diff --git a/drivers/net/wireless/rt2x00/rt2x00queue.c b/drivers/net/wireless/rt2x00/rt2x00queue.c
index 9fc4a1ec4b43..d03eef28f036 100644
--- a/drivers/net/wireless/rt2x00/rt2x00queue.c
+++ b/drivers/net/wireless/rt2x00/rt2x00queue.c
@@ -60,7 +60,7 @@ struct sk_buff *rt2x00queue_alloc_rxskb(struct queue_entry *entry)
          * at least 8 bytes bytes available in headroom for IV/EIV
          * and 8 bytes for ICV data as tailroon.
          */
-        if (test_bit(CONFIG_SUPPORT_HW_CRYPTO, &rt2x00dev->flags)) {
+        if (test_bit(CAPABILITY_HW_CRYPTO, &rt2x00dev->cap_flags)) {
                 head_size += 8;
                 tail_size += 8;
         }
@@ -86,7 +86,7 @@ struct sk_buff *rt2x00queue_alloc_rxskb(struct queue_entry *entry)
         memset(skbdesc, 0, sizeof(*skbdesc));
         skbdesc->entry = entry;
 
-        if (test_bit(DRIVER_REQUIRE_DMA, &rt2x00dev->flags)) {
+        if (test_bit(REQUIRE_DMA, &rt2x00dev->cap_flags)) {
                 skbdesc->skb_dma = dma_map_single(rt2x00dev->dev,
                                                   skb->data,
                                                   skb->len,
@@ -213,7 +213,7 @@ static void rt2x00queue_create_tx_descriptor_seq(struct queue_entry *entry,
 
         __set_bit(ENTRY_TXD_GENERATE_SEQ, &txdesc->flags);
 
-        if (!test_bit(DRIVER_REQUIRE_SW_SEQNO, &entry->queue->rt2x00dev->flags))
+        if (!test_bit(REQUIRE_SW_SEQNO, &entry->queue->rt2x00dev->cap_flags))
                 return;
 
         /*
@@ -396,7 +396,7 @@ static void rt2x00queue_create_tx_descriptor(struct queue_entry *entry,
         rt2x00crypto_create_tx_descriptor(entry, txdesc);
         rt2x00queue_create_tx_descriptor_seq(entry, txdesc);
 
-        if (test_bit(DRIVER_REQUIRE_HT_TX_DESC, &rt2x00dev->flags))
+        if (test_bit(REQUIRE_HT_TX_DESC, &rt2x00dev->cap_flags))
                 rt2x00ht_create_tx_descriptor(entry, txdesc, hwrate);
         else
                 rt2x00queue_create_tx_descriptor_plcp(entry, txdesc, hwrate);
@@ -436,7 +436,7 @@ static int rt2x00queue_write_tx_data(struct queue_entry *entry,
         /*
          * Map the skb to DMA.
          */
-        if (test_bit(DRIVER_REQUIRE_DMA, &rt2x00dev->flags))
+        if (test_bit(REQUIRE_DMA, &rt2x00dev->cap_flags))
                 rt2x00queue_map_txskb(entry);
 
         return 0;
@@ -529,7 +529,7 @@ int rt2x00queue_write_tx_frame(struct data_queue *queue, struct sk_buff *skb,
          */
         if (test_bit(ENTRY_TXD_ENCRYPT, &txdesc.flags) &&
             !test_bit(ENTRY_TXD_ENCRYPT_IV, &txdesc.flags)) {
-                if (test_bit(DRIVER_REQUIRE_COPY_IV, &queue->rt2x00dev->flags))
+                if (test_bit(REQUIRE_COPY_IV, &queue->rt2x00dev->cap_flags))
                         rt2x00crypto_tx_copy_iv(skb, &txdesc);
                 else
                         rt2x00crypto_tx_remove_iv(skb, &txdesc);
@@ -543,9 +543,9 @@ int rt2x00queue_write_tx_frame(struct data_queue *queue, struct sk_buff *skb,
          * PCI and USB devices, while header alignment only is valid
          * for PCI devices.
          */
-        if (test_bit(DRIVER_REQUIRE_L2PAD, &queue->rt2x00dev->flags))
+        if (test_bit(REQUIRE_L2PAD, &queue->rt2x00dev->cap_flags))
                 rt2x00queue_insert_l2pad(entry->skb, txdesc.header_length);
-        else if (test_bit(DRIVER_REQUIRE_DMA, &queue->rt2x00dev->flags))
+        else if (test_bit(REQUIRE_DMA, &queue->rt2x00dev->cap_flags))
                 rt2x00queue_align_frame(entry->skb);
 
         /*
@@ -1069,7 +1069,7 @@ int rt2x00queue_initialize(struct rt2x00_dev *rt2x00dev)
         if (status)
                 goto exit;
 
-        if (test_bit(DRIVER_REQUIRE_ATIM_QUEUE, &rt2x00dev->flags)) {
+        if (test_bit(REQUIRE_ATIM_QUEUE, &rt2x00dev->cap_flags)) {
                 status = rt2x00queue_alloc_entries(rt2x00dev->atim,
                                                    rt2x00dev->ops->atim);
                 if (status)
@@ -1121,7 +1121,7 @@ int rt2x00queue_allocate(struct rt2x00_dev *rt2x00dev)
         struct data_queue *queue;
         enum data_queue_qid qid;
         unsigned int req_atim =
-            !!test_bit(DRIVER_REQUIRE_ATIM_QUEUE, &rt2x00dev->flags);
+            !!test_bit(REQUIRE_ATIM_QUEUE, &rt2x00dev->cap_flags);
 
         /*
          * We need the following queues:
diff --git a/drivers/net/wireless/rt2x00/rt2x00usb.c b/drivers/net/wireless/rt2x00/rt2x00usb.c
index fbe735f5b352..94047e9b2ec6 100644
--- a/drivers/net/wireless/rt2x00/rt2x00usb.c
+++ b/drivers/net/wireless/rt2x00/rt2x00usb.c
@@ -387,7 +387,7 @@ static void rt2x00usb_flush_entry(struct queue_entry *entry)
          * Kill guardian urb (if required by driver).
          */
         if ((entry->queue->qid == QID_BEACON) &&
-            (test_bit(DRIVER_REQUIRE_BEACON_GUARD, &rt2x00dev->flags)))
+            (test_bit(REQUIRE_BEACON_GUARD, &rt2x00dev->cap_flags)))
                 usb_kill_urb(bcn_priv->guardian_urb);
 }
 
@@ -583,7 +583,7 @@ static int rt2x00usb_alloc_entries(struct data_queue *queue)
          * then we are done.
          */
         if (queue->qid != QID_BEACON ||
-            !test_bit(DRIVER_REQUIRE_BEACON_GUARD, &rt2x00dev->flags))
+            !test_bit(REQUIRE_BEACON_GUARD, &rt2x00dev->cap_flags))
                 return 0;
 
         for (i = 0; i < queue->limit; i++) {
@@ -618,7 +618,7 @@ static void rt2x00usb_free_entries(struct data_queue *queue)
          * then we are done.
          */
         if (queue->qid != QID_BEACON ||
-            !test_bit(DRIVER_REQUIRE_BEACON_GUARD, &rt2x00dev->flags))
+            !test_bit(REQUIRE_BEACON_GUARD, &rt2x00dev->cap_flags))
                 return;
 
         for (i = 0; i < queue->limit; i++) {
diff --git a/drivers/net/wireless/rt2x00/rt61pci.c b/drivers/net/wireless/rt2x00/rt61pci.c
index 8ee1514a7943..c16c1501df18 100644
--- a/drivers/net/wireless/rt2x00/rt61pci.c
+++ b/drivers/net/wireless/rt2x00/rt61pci.c
@@ -683,7 +683,7 @@ static void rt61pci_config_antenna_2x(struct rt2x00_dev *rt2x00dev,
 
         rt2x00_set_field8(&r3, BBP_R3_SMART_MODE, rt2x00_rf(rt2x00dev, RF2529));
         rt2x00_set_field8(&r4, BBP_R4_RX_FRAME_END,
-                          !test_bit(CONFIG_FRAME_TYPE, &rt2x00dev->flags));
+                          !test_bit(CAPABILITY_FRAME_TYPE, &rt2x00dev->cap_flags));
 
         /*
          * Configure the RX antenna.
@@ -811,10 +811,10 @@ static void rt61pci_config_ant(struct rt2x00_dev *rt2x00dev,
 
         if (rt2x00dev->curr_band == IEEE80211_BAND_5GHZ) {
                 sel = antenna_sel_a;
-                lna = test_bit(CONFIG_EXTERNAL_LNA_A, &rt2x00dev->flags);
+                lna = test_bit(CAPABILITY_EXTERNAL_LNA_A, &rt2x00dev->cap_flags);
         } else {
                 sel = antenna_sel_bg;
-                lna = test_bit(CONFIG_EXTERNAL_LNA_BG, &rt2x00dev->flags);
+                lna = test_bit(CAPABILITY_EXTERNAL_LNA_BG, &rt2x00dev->cap_flags);
         }
 
         for (i = 0; i < ARRAY_SIZE(antenna_sel_a); i++)
@@ -834,7 +834,7 @@ static void rt61pci_config_ant(struct rt2x00_dev *rt2x00dev,
         else if (rt2x00_rf(rt2x00dev, RF2527))
                 rt61pci_config_antenna_2x(rt2x00dev, ant);
         else if (rt2x00_rf(rt2x00dev, RF2529)) {
-                if (test_bit(CONFIG_DOUBLE_ANTENNA, &rt2x00dev->flags))
+                if (test_bit(CAPABILITY_DOUBLE_ANTENNA, &rt2x00dev->cap_flags))
                         rt61pci_config_antenna_2x(rt2x00dev, ant);
                 else
                         rt61pci_config_antenna_2529(rt2x00dev, ant);
@@ -848,13 +848,13 @@ static void rt61pci_config_lna_gain(struct rt2x00_dev *rt2x00dev,
         short lna_gain = 0;
 
         if (libconf->conf->channel->band == IEEE80211_BAND_2GHZ) {
-                if (test_bit(CONFIG_EXTERNAL_LNA_BG, &rt2x00dev->flags))
+                if (test_bit(CAPABILITY_EXTERNAL_LNA_BG, &rt2x00dev->cap_flags))
                         lna_gain += 14;
 
                 rt2x00_eeprom_read(rt2x00dev, EEPROM_RSSI_OFFSET_BG, &eeprom);
                 lna_gain -= rt2x00_get_field16(eeprom, EEPROM_RSSI_OFFSET_BG_1);
         } else {
-                if (test_bit(CONFIG_EXTERNAL_LNA_A, &rt2x00dev->flags))
+                if (test_bit(CAPABILITY_EXTERNAL_LNA_A, &rt2x00dev->cap_flags))
                         lna_gain += 14;
 
                 rt2x00_eeprom_read(rt2x00dev, EEPROM_RSSI_OFFSET_A, &eeprom);
@@ -1050,14 +1050,14 @@ static void rt61pci_link_tuner(struct rt2x00_dev *rt2x00dev,
         if (rt2x00dev->curr_band == IEEE80211_BAND_5GHZ) {
                 low_bound = 0x28;
                 up_bound = 0x48;
-                if (test_bit(CONFIG_EXTERNAL_LNA_A, &rt2x00dev->flags)) {
+                if (test_bit(CAPABILITY_EXTERNAL_LNA_A, &rt2x00dev->cap_flags)) {
                         low_bound += 0x10;
                         up_bound += 0x10;
                 }
         } else {
                 low_bound = 0x20;
                 up_bound = 0x40;
-                if (test_bit(CONFIG_EXTERNAL_LNA_BG, &rt2x00dev->flags)) {
+                if (test_bit(CAPABILITY_EXTERNAL_LNA_BG, &rt2x00dev->cap_flags)) {
                         low_bound += 0x10;
                         up_bound += 0x10;
                 }
@@ -2537,7 +2537,7 @@ static int rt61pci_init_eeprom(struct rt2x00_dev *rt2x00dev)
          * Determine number of antennas.
          */
         if (rt2x00_get_field16(eeprom, EEPROM_ANTENNA_NUM) == 2)
-                __set_bit(CONFIG_DOUBLE_ANTENNA, &rt2x00dev->flags);
+                __set_bit(CAPABILITY_DOUBLE_ANTENNA, &rt2x00dev->cap_flags);
 
         /*
          * Identify default antenna configuration.
@@ -2551,20 +2551,20 @@ static int rt61pci_init_eeprom(struct rt2x00_dev *rt2x00dev)
          * Read the Frame type.
          */
         if (rt2x00_get_field16(eeprom, EEPROM_ANTENNA_FRAME_TYPE))
-                __set_bit(CONFIG_FRAME_TYPE, &rt2x00dev->flags);
+                __set_bit(CAPABILITY_FRAME_TYPE, &rt2x00dev->cap_flags);
 
         /*
          * Detect if this device has a hardware controlled radio.
          */
         if (rt2x00_get_field16(eeprom, EEPROM_ANTENNA_HARDWARE_RADIO))
-                __set_bit(CONFIG_SUPPORT_HW_BUTTON, &rt2x00dev->flags);
+                __set_bit(CAPABILITY_HW_BUTTON, &rt2x00dev->cap_flags);
 
         /*
          * Read frequency offset and RF programming sequence.
          */
         rt2x00_eeprom_read(rt2x00dev, EEPROM_FREQ, &eeprom);
         if (rt2x00_get_field16(eeprom, EEPROM_FREQ_SEQ))
-                __set_bit(CONFIG_RF_SEQUENCE, &rt2x00dev->flags);
+                __set_bit(CAPABILITY_RF_SEQUENCE, &rt2x00dev->cap_flags);
 
         rt2x00dev->freq_offset = rt2x00_get_field16(eeprom, EEPROM_FREQ_OFFSET);
 
@@ -2574,9 +2574,9 @@ static int rt61pci_init_eeprom(struct rt2x00_dev *rt2x00dev)
         rt2x00_eeprom_read(rt2x00dev, EEPROM_NIC, &eeprom);
 
         if (rt2x00_get_field16(eeprom, EEPROM_NIC_EXTERNAL_LNA_A))
-                __set_bit(CONFIG_EXTERNAL_LNA_A, &rt2x00dev->flags);
+                __set_bit(CAPABILITY_EXTERNAL_LNA_A, &rt2x00dev->cap_flags);
         if (rt2x00_get_field16(eeprom, EEPROM_NIC_EXTERNAL_LNA_BG))
-                __set_bit(CONFIG_EXTERNAL_LNA_BG, &rt2x00dev->flags);
+                __set_bit(CAPABILITY_EXTERNAL_LNA_BG, &rt2x00dev->cap_flags);
 
         /*
          * When working with a RF2529 chip without double antenna,
@@ -2584,7 +2584,7 @@ static int rt61pci_init_eeprom(struct rt2x00_dev *rt2x00dev)
          * eeprom word.
          */
         if (rt2x00_rf(rt2x00dev, RF2529) &&
-            !test_bit(CONFIG_DOUBLE_ANTENNA, &rt2x00dev->flags)) {
+            !test_bit(CAPABILITY_DOUBLE_ANTENNA, &rt2x00dev->cap_flags)) {
                 rt2x00dev->default_ant.rx =
                     ANTENNA_A + rt2x00_get_field16(eeprom, EEPROM_NIC_RX_FIXED);
                 rt2x00dev->default_ant.tx =
@@ -2799,7 +2799,7 @@ static int rt61pci_probe_hw_mode(struct rt2x00_dev *rt2x00dev)
         spec->supported_bands = SUPPORT_BAND_2GHZ;
         spec->supported_rates = SUPPORT_RATE_CCK | SUPPORT_RATE_OFDM;
 
-        if (!test_bit(CONFIG_RF_SEQUENCE, &rt2x00dev->flags)) {
+        if (!test_bit(CAPABILITY_RF_SEQUENCE, &rt2x00dev->cap_flags)) {
                 spec->num_channels = 14;
                 spec->channels = rf_vals_noseq;
         } else {
@@ -2869,16 +2869,16 @@ static int rt61pci_probe_hw(struct rt2x00_dev *rt2x00dev)
          * This device has multiple filters for control frames,
          * but has no a separate filter for PS Poll frames.
          */
-        __set_bit(DRIVER_SUPPORT_CONTROL_FILTERS, &rt2x00dev->flags);
+        __set_bit(CAPABILITY_CONTROL_FILTERS, &rt2x00dev->cap_flags);
 
         /*
          * This device requires firmware and DMA mapped skbs.
          */
-        __set_bit(DRIVER_REQUIRE_FIRMWARE, &rt2x00dev->flags);
-        __set_bit(DRIVER_REQUIRE_DMA, &rt2x00dev->flags);
+        __set_bit(REQUIRE_FIRMWARE, &rt2x00dev->cap_flags);
+        __set_bit(REQUIRE_DMA, &rt2x00dev->cap_flags);
         if (!modparam_nohwcrypt)
-                __set_bit(CONFIG_SUPPORT_HW_CRYPTO, &rt2x00dev->flags);
-        __set_bit(DRIVER_SUPPORT_LINK_TUNING, &rt2x00dev->flags);
+                __set_bit(CAPABILITY_HW_CRYPTO, &rt2x00dev->cap_flags);
+        __set_bit(CAPABILITY_LINK_TUNING, &rt2x00dev->cap_flags);
 
         /*
          * Set the rssi offset.
diff --git a/drivers/net/wireless/rt2x00/rt73usb.c b/drivers/net/wireless/rt2x00/rt73usb.c
index 6593059f9c7e..cdb026d076db 100644
--- a/drivers/net/wireless/rt2x00/rt73usb.c
+++ b/drivers/net/wireless/rt2x00/rt73usb.c
@@ -595,7 +595,7 @@ static void rt73usb_config_antenna_5x(struct rt2x00_dev *rt2x00dev,
         switch (ant->rx) {
         case ANTENNA_HW_DIVERSITY:
                 rt2x00_set_field8(&r4, BBP_R4_RX_ANTENNA_CONTROL, 2);
-                temp = !test_bit(CONFIG_FRAME_TYPE, &rt2x00dev->flags)
+                temp = !test_bit(CAPABILITY_FRAME_TYPE, &rt2x00dev->cap_flags)
                        && (rt2x00dev->curr_band != IEEE80211_BAND_5GHZ);
                 rt2x00_set_field8(&r4, BBP_R4_RX_FRAME_END, temp);
                 break;
@@ -636,7 +636,7 @@ static void rt73usb_config_antenna_2x(struct rt2x00_dev *rt2x00dev,
 
         rt2x00_set_field8(&r3, BBP_R3_SMART_MODE, 0);
         rt2x00_set_field8(&r4, BBP_R4_RX_FRAME_END,
-                          !test_bit(CONFIG_FRAME_TYPE, &rt2x00dev->flags));
+                          !test_bit(CAPABILITY_FRAME_TYPE, &rt2x00dev->cap_flags));
 
         /*
          * Configure the RX antenna.
@@ -709,10 +709,10 @@ static void rt73usb_config_ant(struct rt2x00_dev *rt2x00dev,
 
         if (rt2x00dev->curr_band == IEEE80211_BAND_5GHZ) {
                 sel = antenna_sel_a;
-                lna = test_bit(CONFIG_EXTERNAL_LNA_A, &rt2x00dev->flags);
+                lna = test_bit(CAPABILITY_EXTERNAL_LNA_A, &rt2x00dev->cap_flags);
         } else {
                 sel = antenna_sel_bg;
-                lna = test_bit(CONFIG_EXTERNAL_LNA_BG, &rt2x00dev->flags);
+                lna = test_bit(CAPABILITY_EXTERNAL_LNA_BG, &rt2x00dev->cap_flags);
         }
 
         for (i = 0; i < ARRAY_SIZE(antenna_sel_a); i++)
@@ -740,7 +740,7 @@ static void rt73usb_config_lna_gain(struct rt2x00_dev *rt2x00dev,
         short lna_gain = 0;
 
         if (libconf->conf->channel->band == IEEE80211_BAND_2GHZ) {
-                if (test_bit(CONFIG_EXTERNAL_LNA_BG, &rt2x00dev->flags))
+                if (test_bit(CAPABILITY_EXTERNAL_LNA_BG, &rt2x00dev->cap_flags))
                         lna_gain += 14;
 
                 rt2x00_eeprom_read(rt2x00dev, EEPROM_RSSI_OFFSET_BG, &eeprom);
@@ -930,7 +930,7 @@ static void rt73usb_link_tuner(struct rt2x00_dev *rt2x00dev,
                 low_bound = 0x28;
                 up_bound = 0x48;
 
-                if (test_bit(CONFIG_EXTERNAL_LNA_A, &rt2x00dev->flags)) {
+                if (test_bit(CAPABILITY_EXTERNAL_LNA_A, &rt2x00dev->cap_flags)) {
                         low_bound += 0x10;
                         up_bound += 0x10;
                 }
@@ -946,7 +946,7 @@ static void rt73usb_link_tuner(struct rt2x00_dev *rt2x00dev,
                         up_bound = 0x1c;
                 }
 
-                if (test_bit(CONFIG_EXTERNAL_LNA_BG, &rt2x00dev->flags)) {
+                if (test_bit(CAPABILITY_EXTERNAL_LNA_BG, &rt2x00dev->cap_flags)) {
                         low_bound += 0x14;
                         up_bound += 0x10;
                 }
@@ -1661,7 +1661,7 @@ static int rt73usb_agc_to_rssi(struct rt2x00_dev *rt2x00dev, int rxd_w1)
         }
 
         if (rt2x00dev->curr_band == IEEE80211_BAND_5GHZ) {
-                if (test_bit(CONFIG_EXTERNAL_LNA_A, &rt2x00dev->flags)) {
+                if (test_bit(CAPABILITY_EXTERNAL_LNA_A, &rt2x00dev->cap_flags)) {
                         if (lna == 3 || lna == 2)
                                 offset += 10;
                 } else {
@@ -1899,13 +1899,13 @@ static int rt73usb_init_eeprom(struct rt2x00_dev *rt2x00dev)
          * Read the Frame type.
          */
         if (rt2x00_get_field16(eeprom, EEPROM_ANTENNA_FRAME_TYPE))
-                __set_bit(CONFIG_FRAME_TYPE, &rt2x00dev->flags);
+                __set_bit(CAPABILITY_FRAME_TYPE, &rt2x00dev->cap_flags);
 
         /*
          * Detect if this device has an hardware controlled radio.
          */
         if (rt2x00_get_field16(eeprom, EEPROM_ANTENNA_HARDWARE_RADIO))
-                __set_bit(CONFIG_SUPPORT_HW_BUTTON, &rt2x00dev->flags);
+                __set_bit(CAPABILITY_HW_BUTTON, &rt2x00dev->cap_flags);
 
         /*
          * Read frequency offset.
@@ -1919,8 +1919,8 @@ static int rt73usb_init_eeprom(struct rt2x00_dev *rt2x00dev)
         rt2x00_eeprom_read(rt2x00dev, EEPROM_NIC, &eeprom);
 
         if (rt2x00_get_field16(eeprom, EEPROM_NIC_EXTERNAL_LNA)) {
-                __set_bit(CONFIG_EXTERNAL_LNA_A, &rt2x00dev->flags);
-                __set_bit(CONFIG_EXTERNAL_LNA_BG, &rt2x00dev->flags);
+                __set_bit(CAPABILITY_EXTERNAL_LNA_A, &rt2x00dev->cap_flags);
+                __set_bit(CAPABILITY_EXTERNAL_LNA_BG, &rt2x00dev->cap_flags);
         }
 
         /*
@@ -2200,15 +2200,15 @@ static int rt73usb_probe_hw(struct rt2x00_dev *rt2x00dev)
          * This device has multiple filters for control frames,
          * but has no a separate filter for PS Poll frames.
          */
-        __set_bit(DRIVER_SUPPORT_CONTROL_FILTERS, &rt2x00dev->flags);
+        __set_bit(CAPABILITY_CONTROL_FILTERS, &rt2x00dev->cap_flags);
 
         /*
          * This device requires firmware.
          */
-        __set_bit(DRIVER_REQUIRE_FIRMWARE, &rt2x00dev->flags);
+        __set_bit(REQUIRE_FIRMWARE, &rt2x00dev->cap_flags);
         if (!modparam_nohwcrypt)
-                __set_bit(CONFIG_SUPPORT_HW_CRYPTO, &rt2x00dev->flags);
-        __set_bit(DRIVER_SUPPORT_LINK_TUNING, &rt2x00dev->flags);
+                __set_bit(CAPABILITY_HW_CRYPTO, &rt2x00dev->cap_flags);
+        __set_bit(CAPABILITY_LINK_TUNING, &rt2x00dev->cap_flags);
 
         /*
          * Set the rssi offset.