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

11 files changed, 488 insertions, 346 deletions

diff --git a/drivers/net/wireless/ath/ath9k/ar9003_eeprom.c b/drivers/net/wireless/ath/ath9k/ar9003_eeprom.c
index 8a79550dff71..23eb60ea5455 100644
--- a/drivers/net/wireless/ath/ath9k/ar9003_eeprom.c
+++ b/drivers/net/wireless/ath/ath9k/ar9003_eeprom.c
@@ -38,6 +38,9 @@
 #define AR_SWITCH_TABLE_ALL (0xfff)
 #define AR_SWITCH_TABLE_ALL_S (0)
 
+#define LE16(x) __constant_cpu_to_le16(x)
+#define LE32(x) __constant_cpu_to_le32(x)
+
 static const struct ar9300_eeprom ar9300_default = {
         .eepromVersion = 2,
         .templateVersion = 2,
@@ -45,7 +48,7 @@ static const struct ar9300_eeprom ar9300_default = {
         .custData = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                      0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
         .baseEepHeader = {
-                .regDmn = {0, 0x1f},
+                .regDmn = { LE16(0), LE16(0x1f) },
                 .txrxMask =  0x77, /* 4 bits tx and 4 bits rx */
                 .opCapFlags = {
                         .opFlags = AR9300_OPFLAGS_11G | AR9300_OPFLAGS_11A,
@@ -76,15 +79,15 @@ static const struct ar9300_eeprom ar9300_default = {
         .modalHeader2G = {
         /* ar9300_modal_eep_header  2g */
                 /* 4 idle,t1,t2,b(4 bits per setting) */
-                .antCtrlCommon = 0x110,
+                .antCtrlCommon = LE32(0x110),
                 /* 4 ra1l1, ra2l1, ra1l2, ra2l2, ra12 */
-                .antCtrlCommon2 = 0x22222,
+                .antCtrlCommon2 = LE32(0x22222),
 
                 /*
                  * antCtrlChain[AR9300_MAX_CHAINS]; 6 idle, t, r,
                  * rx1, rx12, b (2 bits each)
                  */
-                .antCtrlChain = {0x150, 0x150, 0x150},
+                .antCtrlChain = { LE16(0x150), LE16(0x150), LE16(0x150) },
 
                 /*
                  * xatten1DB[AR9300_MAX_CHAINS];  3 xatten1_db
@@ -287,12 +290,12 @@ static const struct ar9300_eeprom ar9300_default = {
          },
         .modalHeader5G = {
                 /* 4 idle,t1,t2,b (4 bits per setting) */
-                .antCtrlCommon = 0x110,
+                .antCtrlCommon = LE32(0x110),
                 /* 4 ra1l1, ra2l1, ra1l2,ra2l2,ra12 */
-                .antCtrlCommon2 = 0x22222,
+                .antCtrlCommon2 = LE32(0x22222),
                  /* antCtrlChain 6 idle, t,r,rx1,rx12,b (2 bits each) */
                 .antCtrlChain = {
-                        0x000, 0x000, 0x000,
+                        LE16(0x000), LE16(0x000), LE16(0x000),
                 },
                  /* xatten1DB 3 xatten1_db for AR9280 (0xa20c/b20c 5:0) */
                 .xatten1DB = {0, 0, 0},
@@ -620,9 +623,9 @@ static u32 ath9k_hw_ar9300_get_eeprom(struct ath_hw *ah,
         case EEP_MAC_MSW:
                 return eep->macAddr[4] << 8 | eep->macAddr[5];
         case EEP_REG_0:
-                return pBase->regDmn[0];
+                return le16_to_cpu(pBase->regDmn[0]);
         case EEP_REG_1:
-                return pBase->regDmn[1];
+                return le16_to_cpu(pBase->regDmn[1]);
         case EEP_OP_CAP:
                 return pBase->deviceCap;
         case EEP_OP_MODE:
@@ -640,93 +643,80 @@ static u32 ath9k_hw_ar9300_get_eeprom(struct ath_hw *ah,
                 /* Bit 4 is internal regulator flag */
                 return (pBase->featureEnable & 0x10) >> 4;
         case EEP_SWREG:
-                return pBase->swreg;
+                return le32_to_cpu(pBase->swreg);
         default:
                 return 0;
         }
 }
 
-#ifdef __BIG_ENDIAN
-static void ar9300_swap_eeprom(struct ar9300_eeprom *eep)
+static bool ar9300_eeprom_read_byte(struct ath_common *common, int address,
+                                    u8 *buffer)
 {
-        u32 dword;
-        u16 word;
-        int i;
-
-        word = swab16(eep->baseEepHeader.regDmn[0]);
-        eep->baseEepHeader.regDmn[0] = word;
-
-        word = swab16(eep->baseEepHeader.regDmn[1]);
-        eep->baseEepHeader.regDmn[1] = word;
-
-        dword = swab32(eep->baseEepHeader.swreg);
-        eep->baseEepHeader.swreg = dword;
+        u16 val;
 
-        dword = swab32(eep->modalHeader2G.antCtrlCommon);
-        eep->modalHeader2G.antCtrlCommon = dword;
+        if (unlikely(!ath9k_hw_nvram_read(common, address / 2, &val)))
+                return false;
 
-        dword = swab32(eep->modalHeader2G.antCtrlCommon2);
-        eep->modalHeader2G.antCtrlCommon2 = dword;
+        *buffer = (val >> (8 * (address % 2))) & 0xff;
+        return true;
+}
 
-        dword = swab32(eep->modalHeader5G.antCtrlCommon);
-        eep->modalHeader5G.antCtrlCommon = dword;
+static bool ar9300_eeprom_read_word(struct ath_common *common, int address,
+                                    u8 *buffer)
+{
+        u16 val;
 
-        dword = swab32(eep->modalHeader5G.antCtrlCommon2);
-        eep->modalHeader5G.antCtrlCommon2 = dword;
+        if (unlikely(!ath9k_hw_nvram_read(common, address / 2, &val)))
+                return false;
 
-        for (i = 0; i < AR9300_MAX_CHAINS; i++) {
-                word = swab16(eep->modalHeader2G.antCtrlChain[i]);
-                eep->modalHeader2G.antCtrlChain[i] = word;
+        buffer[0] = val >> 8;
+        buffer[1] = val & 0xff;
 
-                word = swab16(eep->modalHeader5G.antCtrlChain[i]);
-                eep->modalHeader5G.antCtrlChain[i] = word;
-        }
+        return true;
 }
-#endif
 
-static bool ar9300_hw_read_eeprom(struct ath_hw *ah,
-                                  long address, u8 *buffer, int many)
+static bool ar9300_read_eeprom(struct ath_hw *ah, int address, u8 *buffer,
+                               int count)
 {
-        int i;
-        u8 value[2];
-        unsigned long eepAddr;
-        unsigned long byteAddr;
-        u16 *svalue;
         struct ath_common *common = ath9k_hw_common(ah);
+        int i;
 
-        if ((address < 0) || ((address + many) > AR9300_EEPROM_SIZE - 1)) {
+        if ((address < 0) || ((address + count) / 2 > AR9300_EEPROM_SIZE - 1)) {
                 ath_print(common, ATH_DBG_EEPROM,
                           "eeprom address not in range\n");
                 return false;
         }
 
-        for (i = 0; i < many; i++) {
-                eepAddr = (u16) (address + i) / 2;
-                byteAddr = (u16) (address + i) % 2;
-                svalue = (u16 *) value;
-                if (!ath9k_hw_nvram_read(common, eepAddr, svalue)) {
-                        ath_print(common, ATH_DBG_EEPROM,
-                                  "unable to read eeprom region\n");
-                        return false;
-                }
-                *svalue = le16_to_cpu(*svalue);
-                buffer[i] = value[byteAddr];
+        /*
+         * Since we're reading the bytes in reverse order from a little-endian
+         * word stream, an even address means we only use the lower half of
+         * the 16-bit word at that address
+         */
+        if (address % 2 == 0) {
+                if (!ar9300_eeprom_read_byte(common, address--, buffer++))
+                        goto error;
+
+                count--;
         }
 
-        return true;
-}
+        for (i = 0; i < count / 2; i++) {
+                if (!ar9300_eeprom_read_word(common, address, buffer))
+                        goto error;
 
-static bool ar9300_read_eeprom(struct ath_hw *ah,
-                               int address, u8 *buffer, int many)
-{
-        int it;
+                address -= 2;
+                buffer += 2;
+        }
+
+        if (count % 2)
+                if (!ar9300_eeprom_read_byte(common, address, buffer))
+                        goto error;
 
-        for (it = 0; it < many; it++)
-                if (!ar9300_hw_read_eeprom(ah,
-                                           (address - it),
-                                           (buffer + it), 1))
-                        return false;
         return true;
+
+error:
+        ath_print(common, ATH_DBG_EEPROM,
+                  "unable to read eeprom region at offset %d\n", address);
+        return false;
 }
 
 static void ar9300_comp_hdr_unpack(u8 *best, int *code, int *reference,
@@ -927,30 +917,13 @@ fail:
  */
 static bool ath9k_hw_ar9300_fill_eeprom(struct ath_hw *ah)
 {
-        u8 *mptr = NULL;
-        int mdata_size;
+        u8 *mptr = (u8 *) &ah->eeprom.ar9300_eep;
 
-        mptr = (u8 *) &ah->eeprom.ar9300_eep;
-        mdata_size = sizeof(struct ar9300_eeprom);
+        if (ar9300_eeprom_restore_internal(ah, mptr,
+                        sizeof(struct ar9300_eeprom)) < 0)
+                return false;
 
-        if (mptr && mdata_size > 0) {
-                /* At this point, mptr points to the eeprom data structure
-                 * in it's "default" state. If this is big endian, swap the
-                 * data structures back to "little endian"
-                 */
-                /* First swap, default to Little Endian */
-#ifdef __BIG_ENDIAN
-                ar9300_swap_eeprom((struct ar9300_eeprom *)mptr);
-#endif
-                if (ar9300_eeprom_restore_internal(ah, mptr, mdata_size) >= 0)
-                        return true;
-
-                /* Second Swap, back to Big Endian */
-#ifdef __BIG_ENDIAN
-                ar9300_swap_eeprom((struct ar9300_eeprom *)mptr);
-#endif
-        }
-        return false;
+        return true;
 }
 
 /* XXX: review hardware docs */
@@ -998,21 +971,25 @@ static void ar9003_hw_xpa_bias_level_apply(struct ath_hw *ah, bool is2ghz)
 static u32 ar9003_hw_ant_ctrl_common_get(struct ath_hw *ah, bool is2ghz)
 {
         struct ar9300_eeprom *eep = &ah->eeprom.ar9300_eep;
+        __le32 val;
 
         if (is2ghz)
-                return eep->modalHeader2G.antCtrlCommon;
+                val = eep->modalHeader2G.antCtrlCommon;
         else
-                return eep->modalHeader5G.antCtrlCommon;
+                val = eep->modalHeader5G.antCtrlCommon;
+        return le32_to_cpu(val);
 }
 
 static u32 ar9003_hw_ant_ctrl_common_2_get(struct ath_hw *ah, bool is2ghz)
 {
         struct ar9300_eeprom *eep = &ah->eeprom.ar9300_eep;
+        __le32 val;
 
         if (is2ghz)
-                return eep->modalHeader2G.antCtrlCommon2;
+                val = eep->modalHeader2G.antCtrlCommon2;
         else
-                return eep->modalHeader5G.antCtrlCommon2;
+                val = eep->modalHeader5G.antCtrlCommon2;
+        return le32_to_cpu(val);
 }
 
 static u16 ar9003_hw_ant_ctrl_chain_get(struct ath_hw *ah,
@@ -1020,15 +997,16 @@ static u16 ar9003_hw_ant_ctrl_chain_get(struct ath_hw *ah,
                                         bool is2ghz)
 {
         struct ar9300_eeprom *eep = &ah->eeprom.ar9300_eep;
+        __le16 val = 0;
 
         if (chain >= 0 && chain < AR9300_MAX_CHAINS) {
                 if (is2ghz)
-                        return eep->modalHeader2G.antCtrlChain[chain];
+                        val = eep->modalHeader2G.antCtrlChain[chain];
                 else
-                        return eep->modalHeader5G.antCtrlChain[chain];
+                        val = eep->modalHeader5G.antCtrlChain[chain];
         }
 
-        return 0;
+        return le16_to_cpu(val);
 }
 
 static void ar9003_hw_ant_ctrl_apply(struct ath_hw *ah, bool is2ghz)
diff --git a/drivers/net/wireless/ath/ath9k/ar9003_eeprom.h b/drivers/net/wireless/ath/ath9k/ar9003_eeprom.h
index d8c0318f416f..23fb353c3bba 100644
--- a/drivers/net/wireless/ath/ath9k/ar9003_eeprom.h
+++ b/drivers/net/wireless/ath/ath9k/ar9003_eeprom.h
@@ -169,7 +169,7 @@ enum CompressAlgorithm {
 };
 
 struct ar9300_base_eep_hdr {
-        u16 regDmn[2];
+        __le16 regDmn[2];
         /* 4 bits tx and 4 bits rx */
         u8 txrxMask;
         struct eepFlags opCapFlags;
@@ -199,16 +199,16 @@ struct ar9300_base_eep_hdr {
         u8 rxBandSelectGpio;
         u8 txrxgain;
         /* SW controlled internal regulator fields */
-        u32 swreg;
+        __le32 swreg;
 } __packed;
 
 struct ar9300_modal_eep_header {
         /* 4 idle, t1, t2, b (4 bits per setting) */
-        u32 antCtrlCommon;
+        __le32 antCtrlCommon;
         /* 4 ra1l1, ra2l1, ra1l2, ra2l2, ra12 */
-        u32 antCtrlCommon2;
+        __le32 antCtrlCommon2;
         /* 6 idle, t, r, rx1, rx12, b (2 bits each) */
-        u16 antCtrlChain[AR9300_MAX_CHAINS];
+        __le16 antCtrlChain[AR9300_MAX_CHAINS];
         /* 3 xatten1_db for AR9280 (0xa20c/b20c 5:0) */
         u8 xatten1DB[AR9300_MAX_CHAINS];
         /* 3  xatten1_margin for merlin (0xa20c/b20c 16:12 */
diff --git a/drivers/net/wireless/ath/ath9k/ar9003_initvals.h b/drivers/net/wireless/ath/ath9k/ar9003_initvals.h
index ef6116e13033..db019dd220b7 100644
--- a/drivers/net/wireless/ath/ath9k/ar9003_initvals.h
+++ b/drivers/net/wireless/ath/ath9k/ar9003_initvals.h
@@ -25,8 +25,11 @@ static const u32 ar9300_2p0_radio_postamble[][5] = {
         {0x000160ac, 0xa4653c00, 0xa4653c00, 0x24652800, 0x24652800},
         {0x000160b0, 0x03284f3e, 0x03284f3e, 0x05d08f20, 0x05d08f20},
         {0x0001610c, 0x08000000, 0x00000000, 0x00000000, 0x00000000},
+        {0x00016140, 0x10804008, 0x10804008, 0x50804008, 0x50804008},
         {0x0001650c, 0x08000000, 0x00000000, 0x00000000, 0x00000000},
+        {0x00016540, 0x10804008, 0x10804008, 0x50804008, 0x50804008},
         {0x0001690c, 0x08000000, 0x00000000, 0x00000000, 0x00000000},
+        {0x00016940, 0x10804008, 0x10804008, 0x50804008, 0x50804008},
 };
 
 static const u32 ar9300Modes_lowest_ob_db_tx_gain_table_2p0[][5] = {
@@ -97,13 +100,13 @@ static const u32 ar9300Modes_lowest_ob_db_tx_gain_table_2p0[][5] = {
         {0x0000a5f8, 0x778a308c, 0x778a308c, 0x5d801eec, 0x5d801eec},
         {0x0000a5fc, 0x778a308c, 0x778a308c, 0x5d801eec, 0x5d801eec},
         {0x00016044, 0x012492d4, 0x012492d4, 0x012492d4, 0x012492d4},
-        {0x00016048, 0x60001a61, 0x60001a61, 0x60001a61, 0x60001a61},
+        {0x00016048, 0x62480001, 0x62480001, 0x62480001, 0x62480001},
         {0x00016068, 0x6db6db6c, 0x6db6db6c, 0x6db6db6c, 0x6db6db6c},
         {0x00016444, 0x012492d4, 0x012492d4, 0x012492d4, 0x012492d4},
-        {0x00016448, 0x60001a61, 0x60001a61, 0x60001a61, 0x60001a61},
+        {0x00016448, 0x62480001, 0x62480001, 0x62480001, 0x62480001},
         {0x00016468, 0x6db6db6c, 0x6db6db6c, 0x6db6db6c, 0x6db6db6c},
         {0x00016844, 0x012492d4, 0x012492d4, 0x012492d4, 0x012492d4},
-        {0x00016848, 0x60001a61, 0x60001a61, 0x60001a61, 0x60001a61},
+        {0x00016848, 0x62480001, 0x62480001, 0x62480001, 0x62480001},
         {0x00016868, 0x6db6db6c, 0x6db6db6c, 0x6db6db6c, 0x6db6db6c},
 };
 
@@ -129,7 +132,7 @@ static const u32 ar9300_2p0_radio_core[][2] = {
         {0x00016040, 0x7f80fff8},
         {0x0001604c, 0x76d005b5},
         {0x00016050, 0x556cf031},
-        {0x00016054, 0x43449440},
+        {0x00016054, 0x13449440},
         {0x00016058, 0x0c51c92c},
         {0x0001605c, 0x3db7fffc},
         {0x00016060, 0xfffffffc},
@@ -152,12 +155,11 @@ static const u32 ar9300_2p0_radio_core[][2] = {
         {0x00016100, 0x3fffbe01},
         {0x00016104, 0xfff80000},
         {0x00016108, 0x00080010},
-        {0x00016140, 0x10804008},
         {0x00016144, 0x02084080},
         {0x00016148, 0x00000000},
         {0x00016280, 0x058a0001},
         {0x00016284, 0x3d840208},
-        {0x00016288, 0x01a20408},
+        {0x00016288, 0x05a20408},
         {0x0001628c, 0x00038c07},
         {0x00016290, 0x40000004},
         {0x00016294, 0x458aa14f},
@@ -190,7 +192,7 @@ static const u32 ar9300_2p0_radio_core[][2] = {
         {0x00016440, 0x7f80fff8},
         {0x0001644c, 0x76d005b5},
         {0x00016450, 0x556cf031},
-        {0x00016454, 0x43449440},
+        {0x00016454, 0x13449440},
         {0x00016458, 0x0c51c92c},
         {0x0001645c, 0x3db7fffc},
         {0x00016460, 0xfffffffc},
@@ -199,7 +201,6 @@ static const u32 ar9300_2p0_radio_core[][2] = {
         {0x00016500, 0x3fffbe01},
         {0x00016504, 0xfff80000},
         {0x00016508, 0x00080010},
-        {0x00016540, 0x10804008},
         {0x00016544, 0x02084080},
         {0x00016548, 0x00000000},
         {0x00016780, 0x00000000},
@@ -231,7 +232,7 @@ static const u32 ar9300_2p0_radio_core[][2] = {
         {0x00016840, 0x7f80fff8},
         {0x0001684c, 0x76d005b5},
         {0x00016850, 0x556cf031},
-        {0x00016854, 0x43449440},
+        {0x00016854, 0x13449440},
         {0x00016858, 0x0c51c92c},
         {0x0001685c, 0x3db7fffc},
         {0x00016860, 0xfffffffc},
@@ -240,7 +241,6 @@ static const u32 ar9300_2p0_radio_core[][2] = {
         {0x00016900, 0x3fffbe01},
         {0x00016904, 0xfff80000},
         {0x00016908, 0x00080010},
-        {0x00016940, 0x10804008},
         {0x00016944, 0x02084080},
         {0x00016948, 0x00000000},
         {0x00016b80, 0x00000000},
@@ -588,12 +588,12 @@ static const u32 ar9200_merlin_2p0_radio_core[][2] = {
 
 static const u32 ar9300_2p0_baseband_postamble[][5] = {
         /* Addr      5G_HT20     5G_HT40     2G_HT40     2G_HT20   */
-        {0x00009810, 0xd00a8005, 0xd00a8005, 0xd00a8005, 0xd00a800b},
+        {0x00009810, 0xd00a8005, 0xd00a8005, 0xd00a8011, 0xd00a8011},
         {0x00009820, 0x206a022e, 0x206a022e, 0x206a012e, 0x206a012e},
         {0x00009824, 0x5ac640d0, 0x5ac640d0, 0x5ac640d0, 0x5ac640d0},
         {0x00009828, 0x06903081, 0x06903081, 0x06903881, 0x06903881},
         {0x0000982c, 0x05eea6d4, 0x05eea6d4, 0x05eea6d4, 0x05eea6d4},
-        {0x00009830, 0x0000059c, 0x0000059c, 0x0000059c, 0x00000b9c},
+        {0x00009830, 0x0000059c, 0x0000059c, 0x0000119c, 0x0000119c},
         {0x00009c00, 0x00000044, 0x000000c4, 0x000000c4, 0x00000044},
         {0x00009e00, 0x0372161e, 0x0372161e, 0x037216a0, 0x037216a0},
         {0x00009e04, 0x00802020, 0x00802020, 0x00802020, 0x00802020},
@@ -604,8 +604,8 @@ static const u32 ar9300_2p0_baseband_postamble[][5] = {
         {0x00009e1c, 0x0001cf9c, 0x0001cf9c, 0x00021f9c, 0x00021f9c},
         {0x00009e20, 0x000003b5, 0x000003b5, 0x000003ce, 0x000003ce},
         {0x00009e2c, 0x0000001c, 0x0000001c, 0x00000021, 0x00000021},
-        {0x00009e44, 0x02321e27, 0x02321e27, 0x02282324, 0x02282324},
-        {0x00009e48, 0x5030201a, 0x5030201a, 0x50302010, 0x50302010},
+        {0x00009e44, 0x02321e27, 0x02321e27, 0x02291e27, 0x02291e27},
+        {0x00009e48, 0x5030201a, 0x5030201a, 0x50302012, 0x50302012},
         {0x00009fc8, 0x0003f000, 0x0003f000, 0x0001a000, 0x0001a000},
         {0x0000a204, 0x000037c0, 0x000037c4, 0x000037c4, 0x000037c0},
         {0x0000a208, 0x00000104, 0x00000104, 0x00000004, 0x00000004},
@@ -674,7 +674,7 @@ static const u32 ar9300_2p0_baseband_core[][2] = {
         {0x00009d10, 0x01834061},
         {0x00009d14, 0x00c0040b},
         {0x00009d18, 0x00000000},
-        {0x00009e08, 0x0038233c},
+        {0x00009e08, 0x0038230c},
         {0x00009e24, 0x990bb515},
         {0x00009e28, 0x0c6f0000},
         {0x00009e30, 0x06336f77},
@@ -901,13 +901,13 @@ static const u32 ar9300Modes_high_power_tx_gain_table_2p0[][5] = {
         {0x0000a5f8, 0x7584ff56, 0x7584ff56, 0x56801eec, 0x56801eec},
         {0x0000a5fc, 0x7584ff56, 0x7584ff56, 0x56801eec, 0x56801eec},
         {0x00016044, 0x056db2e6, 0x056db2e6, 0x056db2e6, 0x056db2e6},
-        {0x00016048, 0xae481a61, 0xae481a61, 0xae481a61, 0xae481a61},
+        {0x00016048, 0xae480001, 0xae480001, 0xae480001, 0xae480001},
         {0x00016068, 0x6eb6db6c, 0x6eb6db6c, 0x6eb6db6c, 0x6eb6db6c},
         {0x00016444, 0x056db2e6, 0x056db2e6, 0x056db2e6, 0x056db2e6},
-        {0x00016448, 0xae481a61, 0xae481a61, 0xae481a61, 0xae481a61},
+        {0x00016448, 0xae480001, 0xae480001, 0xae480001, 0xae480001},
         {0x00016468, 0x6eb6db6c, 0x6eb6db6c, 0x6eb6db6c, 0x6eb6db6c},
         {0x00016844, 0x056db2e6, 0x056db2e6, 0x056db2e6, 0x056db2e6},
-        {0x00016848, 0xae481a61, 0xae481a61, 0xae481a61, 0xae481a61},
+        {0x00016848, 0xae480001, 0xae480001, 0xae480001, 0xae480001},
         {0x00016868, 0x6eb6db6c, 0x6eb6db6c, 0x6eb6db6c, 0x6eb6db6c},
 };
 
@@ -979,13 +979,13 @@ static const u32 ar9300Modes_high_ob_db_tx_gain_table_2p0[][5] = {
         {0x0000a5f8, 0x7584ff56, 0x7584ff56, 0x56801eec, 0x56801eec},
         {0x0000a5fc, 0x7584ff56, 0x7584ff56, 0x56801eec, 0x56801eec},
         {0x00016044, 0x056db2e4, 0x056db2e4, 0x056db2e4, 0x056db2e4},
-        {0x00016048, 0x8e481a61, 0x8e481a61, 0x8e481a61, 0x8e481a61},
+        {0x00016048, 0x8e480001, 0x8e480001, 0x8e480001, 0x8e480001},
         {0x00016068, 0x6db6db6c, 0x6db6db6c, 0x6db6db6c, 0x6db6db6c},
         {0x00016444, 0x056db2e4, 0x056db2e4, 0x056db2e4, 0x056db2e4},
-        {0x00016448, 0x8e481a61, 0x8e481a61, 0x8e481a61, 0x8e481a61},
+        {0x00016448, 0x8e480001, 0x8e480001, 0x8e480001, 0x8e480001},
         {0x00016468, 0x6db6db6c, 0x6db6db6c, 0x6db6db6c, 0x6db6db6c},
         {0x00016844, 0x056db2e4, 0x056db2e4, 0x056db2e4, 0x056db2e4},
-        {0x00016848, 0x8e481a61, 0x8e481a61, 0x8e481a61, 0x8e481a61},
+        {0x00016848, 0x8e480001, 0x8e480001, 0x8e480001, 0x8e480001},
         {0x00016868, 0x6db6db6c, 0x6db6db6c, 0x6db6db6c, 0x6db6db6c},
 };
 
@@ -995,22 +995,22 @@ static const u32 ar9300Common_rx_gain_table_2p0[][2] = {
         {0x0000a004, 0x00030002},
         {0x0000a008, 0x00050004},
         {0x0000a00c, 0x00810080},
-        {0x0000a010, 0x01800082},
-        {0x0000a014, 0x01820181},
-        {0x0000a018, 0x01840183},
-        {0x0000a01c, 0x01880185},
-        {0x0000a020, 0x018a0189},
-        {0x0000a024, 0x02850284},
-        {0x0000a028, 0x02890288},
-        {0x0000a02c, 0x028b028a},
-        {0x0000a030, 0x028d028c},
-        {0x0000a034, 0x02910290},
-        {0x0000a038, 0x02930292},
-        {0x0000a03c, 0x03910390},
-        {0x0000a040, 0x03930392},
-        {0x0000a044, 0x03950394},
-        {0x0000a048, 0x00000396},
-        {0x0000a04c, 0x00000000},
+        {0x0000a010, 0x00830082},
+        {0x0000a014, 0x01810180},
+        {0x0000a018, 0x01830182},
+        {0x0000a01c, 0x01850184},
+        {0x0000a020, 0x01890188},
+        {0x0000a024, 0x018b018a},
+        {0x0000a028, 0x018d018c},
+        {0x0000a02c, 0x01910190},
+        {0x0000a030, 0x01930192},
+        {0x0000a034, 0x01950194},
+        {0x0000a038, 0x038a0196},
+        {0x0000a03c, 0x038c038b},
+        {0x0000a040, 0x0390038d},
+        {0x0000a044, 0x03920391},
+        {0x0000a048, 0x03940393},
+        {0x0000a04c, 0x03960395},
         {0x0000a050, 0x00000000},
         {0x0000a054, 0x00000000},
         {0x0000a058, 0x00000000},
@@ -1023,14 +1023,14 @@ static const u32 ar9300Common_rx_gain_table_2p0[][2] = {
         {0x0000a074, 0x00000000},
         {0x0000a078, 0x00000000},
         {0x0000a07c, 0x00000000},
-        {0x0000a080, 0x28282828},
-        {0x0000a084, 0x21212128},
-        {0x0000a088, 0x21212121},
-        {0x0000a08c, 0x1c1c1c21},
-        {0x0000a090, 0x1c1c1c1c},
-        {0x0000a094, 0x17171c1c},
-        {0x0000a098, 0x02020212},
-        {0x0000a09c, 0x02020202},
+        {0x0000a080, 0x22222229},
+        {0x0000a084, 0x1d1d1d1d},
+        {0x0000a088, 0x1d1d1d1d},
+        {0x0000a08c, 0x1d1d1d1d},
+        {0x0000a090, 0x171d1d1d},
+        {0x0000a094, 0x11111717},
+        {0x0000a098, 0x00030311},
+        {0x0000a09c, 0x00000000},
         {0x0000a0a0, 0x00000000},
         {0x0000a0a4, 0x00000000},
         {0x0000a0a8, 0x00000000},
@@ -1040,26 +1040,26 @@ static const u32 ar9300Common_rx_gain_table_2p0[][2] = {
         {0x0000a0b8, 0x00000000},
         {0x0000a0bc, 0x00000000},
         {0x0000a0c0, 0x001f0000},
-        {0x0000a0c4, 0x011f0100},
-        {0x0000a0c8, 0x011d011e},
-        {0x0000a0cc, 0x011b011c},
+        {0x0000a0c4, 0x01000101},
+        {0x0000a0c8, 0x011e011f},
+        {0x0000a0cc, 0x011c011d},
         {0x0000a0d0, 0x02030204},
         {0x0000a0d4, 0x02010202},
         {0x0000a0d8, 0x021f0200},
-        {0x0000a0dc, 0x021d021e},
-        {0x0000a0e0, 0x03010302},
-        {0x0000a0e4, 0x031f0300},
-        {0x0000a0e8, 0x0402031e},
+        {0x0000a0dc, 0x0302021e},
+        {0x0000a0e0, 0x03000301},
+        {0x0000a0e4, 0x031e031f},
+        {0x0000a0e8, 0x0402031d},
         {0x0000a0ec, 0x04000401},
         {0x0000a0f0, 0x041e041f},
-        {0x0000a0f4, 0x05010502},
-        {0x0000a0f8, 0x051f0500},
-        {0x0000a0fc, 0x0602051e},
-        {0x0000a100, 0x06000601},
-        {0x0000a104, 0x061e061f},
-        {0x0000a108, 0x0703061d},
-        {0x0000a10c, 0x07010702},
-        {0x0000a110, 0x00000700},
+        {0x0000a0f4, 0x0502041d},
+        {0x0000a0f8, 0x05000501},
+        {0x0000a0fc, 0x051e051f},
+        {0x0000a100, 0x06010602},
+        {0x0000a104, 0x061f0600},
+        {0x0000a108, 0x061d061e},
+        {0x0000a10c, 0x07020703},
+        {0x0000a110, 0x07000701},
         {0x0000a114, 0x00000000},
         {0x0000a118, 0x00000000},
         {0x0000a11c, 0x00000000},
@@ -1072,26 +1072,26 @@ static const u32 ar9300Common_rx_gain_table_2p0[][2] = {
         {0x0000a138, 0x00000000},
         {0x0000a13c, 0x00000000},
         {0x0000a140, 0x001f0000},
-        {0x0000a144, 0x011f0100},
-        {0x0000a148, 0x011d011e},
-        {0x0000a14c, 0x011b011c},
+        {0x0000a144, 0x01000101},
+        {0x0000a148, 0x011e011f},
+        {0x0000a14c, 0x011c011d},
         {0x0000a150, 0x02030204},
         {0x0000a154, 0x02010202},
         {0x0000a158, 0x021f0200},
-        {0x0000a15c, 0x021d021e},
-        {0x0000a160, 0x03010302},
-        {0x0000a164, 0x031f0300},
-        {0x0000a168, 0x0402031e},
+        {0x0000a15c, 0x0302021e},
+        {0x0000a160, 0x03000301},
+        {0x0000a164, 0x031e031f},
+        {0x0000a168, 0x0402031d},
         {0x0000a16c, 0x04000401},
         {0x0000a170, 0x041e041f},
-        {0x0000a174, 0x05010502},
-        {0x0000a178, 0x051f0500},
-        {0x0000a17c, 0x0602051e},
-        {0x0000a180, 0x06000601},
-        {0x0000a184, 0x061e061f},
-        {0x0000a188, 0x0703061d},
-        {0x0000a18c, 0x07010702},
-        {0x0000a190, 0x00000700},
+        {0x0000a174, 0x0502041d},
+        {0x0000a178, 0x05000501},
+        {0x0000a17c, 0x051e051f},
+        {0x0000a180, 0x06010602},
+        {0x0000a184, 0x061f0600},
+        {0x0000a188, 0x061d061e},
+        {0x0000a18c, 0x07020703},
+        {0x0000a190, 0x07000701},
         {0x0000a194, 0x00000000},
         {0x0000a198, 0x00000000},
         {0x0000a19c, 0x00000000},
@@ -1317,13 +1317,13 @@ static const u32 ar9300Modes_low_ob_db_tx_gain_table_2p0[][5] = {
         {0x0000a5f8, 0x778a308c, 0x778a308c, 0x5d801eec, 0x5d801eec},
         {0x0000a5fc, 0x778a308c, 0x778a308c, 0x5d801eec, 0x5d801eec},
         {0x00016044, 0x012492d4, 0x012492d4, 0x012492d4, 0x012492d4},
-        {0x00016048, 0x64001a61, 0x64001a61, 0x64001a61, 0x64001a61},
+        {0x00016048, 0x64000001, 0x64000001, 0x64000001, 0x64000001},
         {0x00016068, 0x6db6db6c, 0x6db6db6c, 0x6db6db6c, 0x6db6db6c},
         {0x00016444, 0x012492d4, 0x012492d4, 0x012492d4, 0x012492d4},
-        {0x00016448, 0x64001a61, 0x64001a61, 0x64001a61, 0x64001a61},
+        {0x00016448, 0x64000001, 0x64000001, 0x64000001, 0x64000001},
         {0x00016468, 0x6db6db6c, 0x6db6db6c, 0x6db6db6c, 0x6db6db6c},
         {0x00016844, 0x012492d4, 0x012492d4, 0x012492d4, 0x012492d4},
-        {0x00016848, 0x64001a61, 0x64001a61, 0x64001a61, 0x64001a61},
+        {0x00016848, 0x64000001, 0x64000001, 0x64000001, 0x64000001},
         {0x00016868, 0x6db6db6c, 0x6db6db6c, 0x6db6db6c, 0x6db6db6c},
 };
 
@@ -1497,22 +1497,22 @@ static const u32 ar9300Common_wo_xlna_rx_gain_table_2p0[][2] = {
         {0x0000a004, 0x00030002},
         {0x0000a008, 0x00050004},
         {0x0000a00c, 0x00810080},
-        {0x0000a010, 0x01800082},
-        {0x0000a014, 0x01820181},
-        {0x0000a018, 0x01840183},
-        {0x0000a01c, 0x01880185},
-        {0x0000a020, 0x018a0189},
-        {0x0000a024, 0x02850284},
-        {0x0000a028, 0x02890288},
-        {0x0000a02c, 0x03850384},
-        {0x0000a030, 0x03890388},
-        {0x0000a034, 0x038b038a},
-        {0x0000a038, 0x038d038c},
-        {0x0000a03c, 0x03910390},
-        {0x0000a040, 0x03930392},
-        {0x0000a044, 0x03950394},
-        {0x0000a048, 0x00000396},
-        {0x0000a04c, 0x00000000},
+        {0x0000a010, 0x00830082},
+        {0x0000a014, 0x01810180},
+        {0x0000a018, 0x01830182},
+        {0x0000a01c, 0x01850184},
+        {0x0000a020, 0x01890188},
+        {0x0000a024, 0x018b018a},
+        {0x0000a028, 0x018d018c},
+        {0x0000a02c, 0x03820190},
+        {0x0000a030, 0x03840383},
+        {0x0000a034, 0x03880385},
+        {0x0000a038, 0x038a0389},
+        {0x0000a03c, 0x038c038b},
+        {0x0000a040, 0x0390038d},
+        {0x0000a044, 0x03920391},
+        {0x0000a048, 0x03940393},
+        {0x0000a04c, 0x03960395},
         {0x0000a050, 0x00000000},
         {0x0000a054, 0x00000000},
         {0x0000a058, 0x00000000},
@@ -1525,15 +1525,15 @@ static const u32 ar9300Common_wo_xlna_rx_gain_table_2p0[][2] = {
         {0x0000a074, 0x00000000},
         {0x0000a078, 0x00000000},
         {0x0000a07c, 0x00000000},
-        {0x0000a080, 0x28282828},
-        {0x0000a084, 0x28282828},
-        {0x0000a088, 0x28282828},
-        {0x0000a08c, 0x28282828},
-        {0x0000a090, 0x28282828},
-        {0x0000a094, 0x21212128},
-        {0x0000a098, 0x171c1c1c},
-        {0x0000a09c, 0x02020212},
-        {0x0000a0a0, 0x00000202},
+        {0x0000a080, 0x29292929},
+        {0x0000a084, 0x29292929},
+        {0x0000a088, 0x29292929},
+        {0x0000a08c, 0x29292929},
+        {0x0000a090, 0x22292929},
+        {0x0000a094, 0x1d1d2222},
+        {0x0000a098, 0x0c111117},
+        {0x0000a09c, 0x00030303},
+        {0x0000a0a0, 0x00000000},
         {0x0000a0a4, 0x00000000},
         {0x0000a0a8, 0x00000000},
         {0x0000a0ac, 0x00000000},
@@ -1542,26 +1542,26 @@ static const u32 ar9300Common_wo_xlna_rx_gain_table_2p0[][2] = {
         {0x0000a0b8, 0x00000000},
         {0x0000a0bc, 0x00000000},
         {0x0000a0c0, 0x001f0000},
-        {0x0000a0c4, 0x011f0100},
-        {0x0000a0c8, 0x011d011e},
-        {0x0000a0cc, 0x011b011c},
+        {0x0000a0c4, 0x01000101},
+        {0x0000a0c8, 0x011e011f},
+        {0x0000a0cc, 0x011c011d},
         {0x0000a0d0, 0x02030204},
         {0x0000a0d4, 0x02010202},
         {0x0000a0d8, 0x021f0200},
-        {0x0000a0dc, 0x021d021e},
-        {0x0000a0e0, 0x03010302},
-        {0x0000a0e4, 0x031f0300},
-        {0x0000a0e8, 0x0402031e},
+        {0x0000a0dc, 0x0302021e},
+        {0x0000a0e0, 0x03000301},
+        {0x0000a0e4, 0x031e031f},
+        {0x0000a0e8, 0x0402031d},
         {0x0000a0ec, 0x04000401},
         {0x0000a0f0, 0x041e041f},
-        {0x0000a0f4, 0x05010502},
-        {0x0000a0f8, 0x051f0500},
-        {0x0000a0fc, 0x0602051e},
-        {0x0000a100, 0x06000601},
-        {0x0000a104, 0x061e061f},
-        {0x0000a108, 0x0703061d},
-        {0x0000a10c, 0x07010702},
-        {0x0000a110, 0x00000700},
+        {0x0000a0f4, 0x0502041d},
+        {0x0000a0f8, 0x05000501},
+        {0x0000a0fc, 0x051e051f},
+        {0x0000a100, 0x06010602},
+        {0x0000a104, 0x061f0600},
+        {0x0000a108, 0x061d061e},
+        {0x0000a10c, 0x07020703},
+        {0x0000a110, 0x07000701},
         {0x0000a114, 0x00000000},
         {0x0000a118, 0x00000000},
         {0x0000a11c, 0x00000000},
@@ -1574,26 +1574,26 @@ static const u32 ar9300Common_wo_xlna_rx_gain_table_2p0[][2] = {
         {0x0000a138, 0x00000000},
         {0x0000a13c, 0x00000000},
         {0x0000a140, 0x001f0000},
-        {0x0000a144, 0x011f0100},
-        {0x0000a148, 0x011d011e},
-        {0x0000a14c, 0x011b011c},
+        {0x0000a144, 0x01000101},
+        {0x0000a148, 0x011e011f},
+        {0x0000a14c, 0x011c011d},
         {0x0000a150, 0x02030204},
         {0x0000a154, 0x02010202},
         {0x0000a158, 0x021f0200},
-        {0x0000a15c, 0x021d021e},
-        {0x0000a160, 0x03010302},
-        {0x0000a164, 0x031f0300},
-        {0x0000a168, 0x0402031e},
+        {0x0000a15c, 0x0302021e},
+        {0x0000a160, 0x03000301},
+        {0x0000a164, 0x031e031f},
+        {0x0000a168, 0x0402031d},
         {0x0000a16c, 0x04000401},
         {0x0000a170, 0x041e041f},
-        {0x0000a174, 0x05010502},
-        {0x0000a178, 0x051f0500},
-        {0x0000a17c, 0x0602051e},
-        {0x0000a180, 0x06000601},
-        {0x0000a184, 0x061e061f},
-        {0x0000a188, 0x0703061d},
-        {0x0000a18c, 0x07010702},
-        {0x0000a190, 0x00000700},
+        {0x0000a174, 0x0502041d},
+        {0x0000a178, 0x05000501},
+        {0x0000a17c, 0x051e051f},
+        {0x0000a180, 0x06010602},
+        {0x0000a184, 0x061f0600},
+        {0x0000a188, 0x061d061e},
+        {0x0000a18c, 0x07020703},
+        {0x0000a190, 0x07000701},
         {0x0000a194, 0x00000000},
         {0x0000a198, 0x00000000},
         {0x0000a19c, 0x00000000},
@@ -1620,7 +1620,7 @@ static const u32 ar9300Common_wo_xlna_rx_gain_table_2p0[][2] = {
         {0x0000a1f0, 0x00000396},
         {0x0000a1f4, 0x00000396},
         {0x0000a1f8, 0x00000396},
-        {0x0000a1fc, 0x00000296},
+        {0x0000a1fc, 0x00000196},
         {0x0000b000, 0x00010000},
         {0x0000b004, 0x00030002},
         {0x0000b008, 0x00050004},
diff --git a/drivers/net/wireless/ath/ath9k/debug.c b/drivers/net/wireless/ath/ath9k/debug.c
index 64e30cd45d05..29898f8d1893 100644
--- a/drivers/net/wireless/ath/ath9k/debug.c
+++ b/drivers/net/wireless/ath/ath9k/debug.c
@@ -78,6 +78,90 @@ static const struct file_operations fops_debug = {
 
 #define DMA_BUF_LEN 1024
 
+static ssize_t read_file_tx_chainmask(struct file *file, char __user *user_buf,
+                             size_t count, loff_t *ppos)
+{
+        struct ath_softc *sc = file->private_data;
+        struct ath_common *common = ath9k_hw_common(sc->sc_ah);
+        char buf[32];
+        unsigned int len;
+
+        len = snprintf(buf, sizeof(buf), "0x%08x\n", common->tx_chainmask);
+        return simple_read_from_buffer(user_buf, count, ppos, buf, len);
+}
+
+static ssize_t write_file_tx_chainmask(struct file *file, const char __user *user_buf,
+                             size_t count, loff_t *ppos)
+{
+        struct ath_softc *sc = file->private_data;
+        struct ath_common *common = ath9k_hw_common(sc->sc_ah);
+        unsigned long mask;
+        char buf[32];
+        ssize_t len;
+
+        len = min(count, sizeof(buf) - 1);
+        if (copy_from_user(buf, user_buf, len))
+                return -EINVAL;
+
+        buf[len] = '\0';
+        if (strict_strtoul(buf, 0, &mask))
+                return -EINVAL;
+
+        common->tx_chainmask = mask;
+        sc->sc_ah->caps.tx_chainmask = mask;
+        return count;
+}
+
+static const struct file_operations fops_tx_chainmask = {
+        .read = read_file_tx_chainmask,
+        .write = write_file_tx_chainmask,
+        .open = ath9k_debugfs_open,
+        .owner = THIS_MODULE
+};
+
+
+static ssize_t read_file_rx_chainmask(struct file *file, char __user *user_buf,
+                             size_t count, loff_t *ppos)
+{
+        struct ath_softc *sc = file->private_data;
+        struct ath_common *common = ath9k_hw_common(sc->sc_ah);
+        char buf[32];
+        unsigned int len;
+
+        len = snprintf(buf, sizeof(buf), "0x%08x\n", common->rx_chainmask);
+        return simple_read_from_buffer(user_buf, count, ppos, buf, len);
+}
+
+static ssize_t write_file_rx_chainmask(struct file *file, const char __user *user_buf,
+                             size_t count, loff_t *ppos)
+{
+        struct ath_softc *sc = file->private_data;
+        struct ath_common *common = ath9k_hw_common(sc->sc_ah);
+        unsigned long mask;
+        char buf[32];
+        ssize_t len;
+
+        len = min(count, sizeof(buf) - 1);
+        if (copy_from_user(buf, user_buf, len))
+                return -EINVAL;
+
+        buf[len] = '\0';
+        if (strict_strtoul(buf, 0, &mask))
+                return -EINVAL;
+
+        common->rx_chainmask = mask;
+        sc->sc_ah->caps.rx_chainmask = mask;
+        return count;
+}
+
+static const struct file_operations fops_rx_chainmask = {
+        .read = read_file_rx_chainmask,
+        .write = write_file_rx_chainmask,
+        .open = ath9k_debugfs_open,
+        .owner = THIS_MODULE
+};
+
+
 static ssize_t read_file_dma(struct file *file, char __user *user_buf,
                              size_t count, loff_t *ppos)
 {
@@ -711,6 +795,86 @@ static const struct file_operations fops_recv = {
         .owner = THIS_MODULE
 };
 
+static ssize_t read_file_regidx(struct file *file, char __user *user_buf,
+                                size_t count, loff_t *ppos)
+{
+        struct ath_softc *sc = file->private_data;
+        char buf[32];
+        unsigned int len;
+
+        len = snprintf(buf, sizeof(buf), "0x%08x\n", sc->debug.regidx);
+        return simple_read_from_buffer(user_buf, count, ppos, buf, len);
+}
+
+static ssize_t write_file_regidx(struct file *file, const char __user *user_buf,
+                             size_t count, loff_t *ppos)
+{
+        struct ath_softc *sc = file->private_data;
+        unsigned long regidx;
+        char buf[32];
+        ssize_t len;
+
+        len = min(count, sizeof(buf) - 1);
+        if (copy_from_user(buf, user_buf, len))
+                return -EINVAL;
+
+        buf[len] = '\0';
+        if (strict_strtoul(buf, 0, &regidx))
+                return -EINVAL;
+
+        sc->debug.regidx = regidx;
+        return count;
+}
+
+static const struct file_operations fops_regidx = {
+        .read = read_file_regidx,
+        .write = write_file_regidx,
+        .open = ath9k_debugfs_open,
+        .owner = THIS_MODULE
+};
+
+static ssize_t read_file_regval(struct file *file, char __user *user_buf,
+                             size_t count, loff_t *ppos)
+{
+        struct ath_softc *sc = file->private_data;
+        struct ath_hw *ah = sc->sc_ah;
+        char buf[32];
+        unsigned int len;
+        u32 regval;
+
+        regval = REG_READ_D(ah, sc->debug.regidx);
+        len = snprintf(buf, sizeof(buf), "0x%08x\n", regval);
+        return simple_read_from_buffer(user_buf, count, ppos, buf, len);
+}
+
+static ssize_t write_file_regval(struct file *file, const char __user *user_buf,
+                             size_t count, loff_t *ppos)
+{
+        struct ath_softc *sc = file->private_data;
+        struct ath_hw *ah = sc->sc_ah;
+        unsigned long regval;
+        char buf[32];
+        ssize_t len;
+
+        len = min(count, sizeof(buf) - 1);
+        if (copy_from_user(buf, user_buf, len))
+                return -EINVAL;
+
+        buf[len] = '\0';
+        if (strict_strtoul(buf, 0, &regval))
+                return -EINVAL;
+
+        REG_WRITE_D(ah, sc->debug.regidx, regval);
+        return count;
+}
+
+static const struct file_operations fops_regval = {
+        .read = read_file_regval,
+        .write = write_file_regval,
+        .open = ath9k_debugfs_open,
+        .owner = THIS_MODULE
+};
+
 int ath9k_init_debug(struct ath_hw *ah)
 {
         struct ath_common *common = ath9k_hw_common(ah);
@@ -722,54 +886,55 @@ int ath9k_init_debug(struct ath_hw *ah)
         sc->debug.debugfs_phy = debugfs_create_dir(wiphy_name(sc->hw->wiphy),
                                                       ath9k_debugfs_root);
         if (!sc->debug.debugfs_phy)
-                goto err;
+                return -ENOMEM;
 
 #ifdef CONFIG_ATH_DEBUG
-        sc->debug.debugfs_debug = debugfs_create_file("debug",
-                S_IRUSR | S_IWUSR, sc->debug.debugfs_phy, sc, &fops_debug);
-        if (!sc->debug.debugfs_debug)
+        if (!debugfs_create_file("debug", S_IRUSR | S_IWUSR,
+                        sc->debug.debugfs_phy, sc, &fops_debug))
                 goto err;
 #endif
 
-        sc->debug.debugfs_dma = debugfs_create_file("dma", S_IRUSR,
-                                       sc->debug.debugfs_phy, sc, &fops_dma);
-        if (!sc->debug.debugfs_dma)
+        if (!debugfs_create_file("dma", S_IRUSR, sc->debug.debugfs_phy,
+                        sc, &fops_dma))
+                goto err;
+
+        if (!debugfs_create_file("interrupt", S_IRUSR, sc->debug.debugfs_phy,
+                        sc, &fops_interrupt))
+                goto err;
+
+        if (!debugfs_create_file("rcstat", S_IRUSR, sc->debug.debugfs_phy,
+                        sc, &fops_rcstat))
+                goto err;
+
+        if (!debugfs_create_file("wiphy", S_IRUSR | S_IWUSR,
+                        sc->debug.debugfs_phy, sc, &fops_wiphy))
+                goto err;
+
+        if (!debugfs_create_file("xmit", S_IRUSR, sc->debug.debugfs_phy,
+                        sc, &fops_xmit))
                 goto err;
 
-        sc->debug.debugfs_interrupt = debugfs_create_file("interrupt",
-                                                     S_IRUSR,
-                                                     sc->debug.debugfs_phy,
-                                                     sc, &fops_interrupt);
-        if (!sc->debug.debugfs_interrupt)
+        if (!debugfs_create_file("recv", S_IRUSR, sc->debug.debugfs_phy,
+                        sc, &fops_recv))
                 goto err;
 
-        sc->debug.debugfs_rcstat = debugfs_create_file("rcstat",
-                                                  S_IRUSR,
-                                                  sc->debug.debugfs_phy,
-                                                  sc, &fops_rcstat);
-        if (!sc->debug.debugfs_rcstat)
+        if (!debugfs_create_file("rx_chainmask", S_IRUSR | S_IWUSR,
+                        sc->debug.debugfs_phy, sc, &fops_rx_chainmask))
                 goto err;
 
-        sc->debug.debugfs_wiphy = debugfs_create_file(
-                "wiphy", S_IRUSR | S_IWUSR, sc->debug.debugfs_phy, sc,
-                &fops_wiphy);
-        if (!sc->debug.debugfs_wiphy)
+        if (!debugfs_create_file("tx_chainmask", S_IRUSR | S_IWUSR,
+                        sc->debug.debugfs_phy, sc, &fops_tx_chainmask))
                 goto err;
 
-        sc->debug.debugfs_xmit = debugfs_create_file("xmit",
-                                                     S_IRUSR,
-                                                     sc->debug.debugfs_phy,
-                                                     sc, &fops_xmit);
-        if (!sc->debug.debugfs_xmit)
+        if (!debugfs_create_file("regidx", S_IRUSR | S_IWUSR,
+                        sc->debug.debugfs_phy, sc, &fops_regidx))
                 goto err;
 
-        sc->debug.debugfs_recv = debugfs_create_file("recv",
-                                                     S_IRUSR,
-                                                     sc->debug.debugfs_phy,
-                                                     sc, &fops_recv);
-        if (!sc->debug.debugfs_recv)
+        if (!debugfs_create_file("regval", S_IRUSR | S_IWUSR,
+                        sc->debug.debugfs_phy, sc, &fops_regval))
                 goto err;
 
+        sc->debug.regidx = 0;
         return 0;
 err:
         ath9k_exit_debug(ah);
@@ -781,14 +946,7 @@ void ath9k_exit_debug(struct ath_hw *ah)
         struct ath_common *common = ath9k_hw_common(ah);
         struct ath_softc *sc = (struct ath_softc *) common->priv;
 
-        debugfs_remove(sc->debug.debugfs_recv);
-        debugfs_remove(sc->debug.debugfs_xmit);
-        debugfs_remove(sc->debug.debugfs_wiphy);
-        debugfs_remove(sc->debug.debugfs_rcstat);
-        debugfs_remove(sc->debug.debugfs_interrupt);
-        debugfs_remove(sc->debug.debugfs_dma);
-        debugfs_remove(sc->debug.debugfs_debug);
-        debugfs_remove(sc->debug.debugfs_phy);
+        debugfs_remove_recursive(sc->debug.debugfs_phy);
 }
 
 int ath9k_debug_create_root(void)
diff --git a/drivers/net/wireless/ath/ath9k/debug.h b/drivers/net/wireless/ath/ath9k/debug.h
index c545960e7ec5..5147b8709e10 100644
--- a/drivers/net/wireless/ath/ath9k/debug.h
+++ b/drivers/net/wireless/ath/ath9k/debug.h
@@ -153,13 +153,7 @@ struct ath_stats {
 
 struct ath9k_debug {
         struct dentry *debugfs_phy;
-        struct dentry *debugfs_debug;
-        struct dentry *debugfs_dma;
-        struct dentry *debugfs_interrupt;
-        struct dentry *debugfs_rcstat;
-        struct dentry *debugfs_wiphy;
-        struct dentry *debugfs_xmit;
-        struct dentry *debugfs_recv;
+        u32 regidx;
         struct ath_stats stats;
 };
 
diff --git a/drivers/net/wireless/ath/ath9k/hif_usb.c b/drivers/net/wireless/ath/ath9k/hif_usb.c
index 74872ca76f9a..46dc41a16faa 100644
--- a/drivers/net/wireless/ath/ath9k/hif_usb.c
+++ b/drivers/net/wireless/ath/ath9k/hif_usb.c
@@ -735,6 +735,14 @@ err:
         return -ENOMEM;
 }
 
+static void ath9k_hif_usb_dealloc_urbs(struct hif_device_usb *hif_dev)
+{
+        usb_kill_anchored_urbs(&hif_dev->regout_submitted);
+        ath9k_hif_usb_dealloc_reg_in_urb(hif_dev);
+        ath9k_hif_usb_dealloc_tx_urbs(hif_dev);
+        ath9k_hif_usb_dealloc_rx_urbs(hif_dev);
+}
+
 static int ath9k_hif_usb_download_fw(struct hif_device_usb *hif_dev)
 {
         int transfer, err;
@@ -794,14 +802,6 @@ static int ath9k_hif_usb_dev_init(struct hif_device_usb *hif_dev,
                 goto err_fw_req;
         }
 
-        /* Download firmware */
-        ret = ath9k_hif_usb_download_fw(hif_dev);
-        if (ret) {
-                dev_err(&hif_dev->udev->dev,
-                        "ath9k_htc: Firmware - %s download failed\n", fw_name);
-                goto err_fw_download;
-        }
-
         /* Alloc URBs */
         ret = ath9k_hif_usb_alloc_urbs(hif_dev);
         if (ret) {
@@ -810,25 +810,25 @@ static int ath9k_hif_usb_dev_init(struct hif_device_usb *hif_dev,
                 goto err_urb;
         }
 
+        /* Download firmware */
+        ret = ath9k_hif_usb_download_fw(hif_dev);
+        if (ret) {
+                dev_err(&hif_dev->udev->dev,
+                        "ath9k_htc: Firmware - %s download failed\n", fw_name);
+                goto err_fw_download;
+        }
+
         return 0;
 
-err_urb:
-        /* Nothing */
 err_fw_download:
+        ath9k_hif_usb_dealloc_urbs(hif_dev);
+err_urb:
         release_firmware(hif_dev->firmware);
 err_fw_req:
         hif_dev->firmware = NULL;
         return ret;
 }
 
-static void ath9k_hif_usb_dealloc_urbs(struct hif_device_usb *hif_dev)
-{
-        usb_kill_anchored_urbs(&hif_dev->regout_submitted);
-        ath9k_hif_usb_dealloc_reg_in_urb(hif_dev);
-        ath9k_hif_usb_dealloc_tx_urbs(hif_dev);
-        ath9k_hif_usb_dealloc_rx_urbs(hif_dev);
-}
-
 static void ath9k_hif_usb_dev_deinit(struct hif_device_usb *hif_dev)
 {
         ath9k_hif_usb_dealloc_urbs(hif_dev);
@@ -859,21 +859,21 @@ static int ath9k_hif_usb_probe(struct usb_interface *interface,
 #endif
         usb_set_intfdata(interface, hif_dev);
 
+        hif_dev->htc_handle = ath9k_htc_hw_alloc(hif_dev, &hif_usb,
+                                                 &hif_dev->udev->dev);
+        if (hif_dev->htc_handle == NULL) {
+                ret = -ENOMEM;
+                goto err_htc_hw_alloc;
+        }
+
         ret = ath9k_hif_usb_dev_init(hif_dev, fw_name);
         if (ret) {
                 ret = -EINVAL;
                 goto err_hif_init_usb;
         }
 
-        hif_dev->htc_handle = ath9k_htc_hw_alloc(hif_dev);
-        if (hif_dev->htc_handle == NULL) {
-                ret = -ENOMEM;
-                goto err_htc_hw_alloc;
-        }
-
-        ret = ath9k_htc_hw_init(&hif_usb, hif_dev->htc_handle, hif_dev,
-                                &hif_dev->udev->dev, hif_dev->device_id,
-                                ATH9K_HIF_USB);
+        ret = ath9k_htc_hw_init(hif_dev->htc_handle,
+                                &hif_dev->udev->dev, hif_dev->device_id);
         if (ret) {
                 ret = -EINVAL;
                 goto err_htc_hw_init;
@@ -884,10 +884,10 @@ static int ath9k_hif_usb_probe(struct usb_interface *interface,
         return 0;
 
 err_htc_hw_init:
-        ath9k_htc_hw_free(hif_dev->htc_handle);
-err_htc_hw_alloc:
         ath9k_hif_usb_dev_deinit(hif_dev);
 err_hif_init_usb:
+        ath9k_htc_hw_free(hif_dev->htc_handle);
+err_htc_hw_alloc:
         usb_set_intfdata(interface, NULL);
         kfree(hif_dev);
         usb_put_dev(udev);
diff --git a/drivers/net/wireless/ath/ath9k/htc_drv_init.c b/drivers/net/wireless/ath/ath9k/htc_drv_init.c
index 17111fc1d2cc..dc015077a8d9 100644
--- a/drivers/net/wireless/ath/ath9k/htc_drv_init.c
+++ b/drivers/net/wireless/ath/ath9k/htc_drv_init.c
@@ -81,6 +81,11 @@ static int ath9k_htc_wait_for_target(struct ath9k_htc_priv *priv)
 {
         int time_left;
 
+        if (atomic_read(&priv->htc->tgt_ready) > 0) {
+                atomic_dec(&priv->htc->tgt_ready);
+                return 0;
+        }
+
         /* Firmware can take up to 50ms to get ready, to be safe use 1 second */
         time_left = wait_for_completion_timeout(&priv->htc->target_wait, HZ);
         if (!time_left) {
@@ -88,6 +93,8 @@ static int ath9k_htc_wait_for_target(struct ath9k_htc_priv *priv)
                 return -ETIMEDOUT;
         }
 
+        atomic_dec(&priv->htc->tgt_ready);
+
         return 0;
 }
 
diff --git a/drivers/net/wireless/ath/ath9k/htc_drv_main.c b/drivers/net/wireless/ath/ath9k/htc_drv_main.c
index 6c386dad1d40..9d371c18eb41 100644
--- a/drivers/net/wireless/ath/ath9k/htc_drv_main.c
+++ b/drivers/net/wireless/ath/ath9k/htc_drv_main.c
@@ -1452,6 +1452,8 @@ static void ath9k_htc_sta_notify(struct ieee80211_hw *hw,
         struct ath9k_htc_priv *priv = hw->priv;
         int ret;
 
+        mutex_lock(&priv->mutex);
+
         switch (cmd) {
         case STA_NOTIFY_ADD:
                 ret = ath9k_htc_add_station(priv, vif, sta);
@@ -1464,6 +1466,8 @@ static void ath9k_htc_sta_notify(struct ieee80211_hw *hw,
         default:
                 break;
         }
+
+        mutex_unlock(&priv->mutex);
 }
 
 static int ath9k_htc_conf_tx(struct ieee80211_hw *hw, u16 queue,
diff --git a/drivers/net/wireless/ath/ath9k/htc_hst.c b/drivers/net/wireless/ath/ath9k/htc_hst.c
index 7bf6ce1e7e2e..064397fd738e 100644
--- a/drivers/net/wireless/ath/ath9k/htc_hst.c
+++ b/drivers/net/wireless/ath/ath9k/htc_hst.c
@@ -39,7 +39,7 @@ static struct htc_endpoint *get_next_avail_ep(struct htc_endpoint *endpoint)
 {
         enum htc_endpoint_id avail_epid;
 
-        for (avail_epid = ENDPOINT_MAX; avail_epid > ENDPOINT0; avail_epid--)
+        for (avail_epid = (ENDPOINT_MAX - 1); avail_epid > ENDPOINT0; avail_epid--)
                 if (endpoint[avail_epid].service_id == 0)
                         return &endpoint[avail_epid];
         return NULL;
@@ -95,6 +95,7 @@ static void htc_process_target_rdy(struct htc_target *target,
         endpoint = &target->endpoint[ENDPOINT0];
         endpoint->service_id = HTC_CTRL_RSVD_SVC;
         endpoint->max_msglen = HTC_MAX_CONTROL_MESSAGE_LENGTH;
+        atomic_inc(&target->tgt_ready);
         complete(&target->target_wait);
 }
 
@@ -116,7 +117,7 @@ static void htc_process_conn_rsp(struct htc_target *target,
                 max_msglen = be16_to_cpu(svc_rspmsg->max_msg_len);
                 endpoint = &target->endpoint[epid];
 
-                for (tepid = ENDPOINT_MAX; tepid > ENDPOINT0; tepid--) {
+                for (tepid = (ENDPOINT_MAX - 1); tepid > ENDPOINT0; tepid--) {
                         tmp_endpoint = &target->endpoint[tepid];
                         if (tmp_endpoint->service_id == service_id) {
                                 tmp_endpoint->service_id = 0;
@@ -124,7 +125,7 @@ static void htc_process_conn_rsp(struct htc_target *target,
                         }
                 }
 
-                if (!tmp_endpoint)
+                if (tepid == ENDPOINT0)
                         return;
 
                 endpoint->service_id = service_id;
@@ -297,7 +298,7 @@ void htc_stop(struct htc_target *target)
         enum htc_endpoint_id epid;
         struct htc_endpoint *endpoint;
 
-        for (epid = ENDPOINT0; epid <= ENDPOINT_MAX; epid++) {
+        for (epid = ENDPOINT0; epid < ENDPOINT_MAX; epid++) {
                 endpoint = &target->endpoint[epid];
                 if (endpoint->service_id != 0)
                         target->hif->stop(target->hif_dev, endpoint->ul_pipeid);
@@ -309,7 +310,7 @@ void htc_start(struct htc_target *target)
         enum htc_endpoint_id epid;
         struct htc_endpoint *endpoint;
 
-        for (epid = ENDPOINT0; epid <= ENDPOINT_MAX; epid++) {
+        for (epid = ENDPOINT0; epid < ENDPOINT_MAX; epid++) {
                 endpoint = &target->endpoint[epid];
                 if (endpoint->service_id != 0)
                         target->hif->start(target->hif_dev,
@@ -425,29 +426,19 @@ void ath9k_htc_rx_msg(struct htc_target *htc_handle,
         }
 }
 
-struct htc_target *ath9k_htc_hw_alloc(void *hif_handle)
+struct htc_target *ath9k_htc_hw_alloc(void *hif_handle,
+                                      struct ath9k_htc_hif *hif,
+                                      struct device *dev)
 {
+        struct htc_endpoint *endpoint;
         struct htc_target *target;
 
         target = kzalloc(sizeof(struct htc_target), GFP_KERNEL);
-        if (!target)
+        if (!target) {
                 printk(KERN_ERR "Unable to allocate memory for"
                         "target device\n");
-
-        return target;
-}
-
-void ath9k_htc_hw_free(struct htc_target *htc)
-{
-        kfree(htc);
-}
-
-int ath9k_htc_hw_init(struct ath9k_htc_hif *hif, struct htc_target *target,
-                      void *hif_handle, struct device *dev, u16 devid,
-                      enum ath9k_hif_transports transport)
-{
-        struct htc_endpoint *endpoint;
-        int err = 0;
+                return NULL;
+        }
 
         init_completion(&target->target_wait);
         init_completion(&target->cmd_wait);
@@ -461,8 +452,20 @@ int ath9k_htc_hw_init(struct ath9k_htc_hif *hif, struct htc_target *target,
         endpoint->ul_pipeid = hif->control_ul_pipe;
         endpoint->dl_pipeid = hif->control_dl_pipe;
 
-        err = ath9k_htc_probe_device(target, dev, devid);
-        if (err) {
+        atomic_set(&target->tgt_ready, 0);
+
+        return target;
+}
+
+void ath9k_htc_hw_free(struct htc_target *htc)
+{
+        kfree(htc);
+}
+
+int ath9k_htc_hw_init(struct htc_target *target,
+                      struct device *dev, u16 devid)
+{
+        if (ath9k_htc_probe_device(target, dev, devid)) {
                 printk(KERN_ERR "Failed to initialize the device\n");
                 return -ENODEV;
         }
diff --git a/drivers/net/wireless/ath/ath9k/htc_hst.h b/drivers/net/wireless/ath/ath9k/htc_hst.h
index ea50ab032d20..faba6790328b 100644
--- a/drivers/net/wireless/ath/ath9k/htc_hst.h
+++ b/drivers/net/wireless/ath/ath9k/htc_hst.h
@@ -123,9 +123,6 @@ struct htc_endpoint {
 #define HTC_CONTROL_BUFFER_SIZE \
         (HTC_MAX_CONTROL_MESSAGE_LENGTH + sizeof(struct htc_frame_hdr))
 
-#define NUM_CONTROL_BUFFERS 8
-#define HST_ENDPOINT_MAX 8
-
 struct htc_control_buf {
         struct htc_packet htc_pkt;
         u8 buf[HTC_CONTROL_BUFFER_SIZE];
@@ -139,7 +136,7 @@ struct htc_target {
         struct ath9k_htc_priv *drv_priv;
         struct device *dev;
         struct ath9k_htc_hif *hif;
-        struct htc_endpoint endpoint[HST_ENDPOINT_MAX];
+        struct htc_endpoint endpoint[ENDPOINT_MAX];
         struct completion target_wait;
         struct completion cmd_wait;
         struct list_head list;
@@ -147,6 +144,7 @@ struct htc_target {
         u16 credits;
         u16 credit_size;
         u8 htc_flags;
+        atomic_t tgt_ready;
 };
 
 enum htc_msg_id {
@@ -236,11 +234,12 @@ void ath9k_htc_rx_msg(struct htc_target *htc_handle,
 void ath9k_htc_txcompletion_cb(struct htc_target *htc_handle,
                                struct sk_buff *skb, bool txok);
 
-struct htc_target *ath9k_htc_hw_alloc(void *hif_handle);
+struct htc_target *ath9k_htc_hw_alloc(void *hif_handle,
+                                      struct ath9k_htc_hif *hif,
+                                      struct device *dev);
 void ath9k_htc_hw_free(struct htc_target *htc);
-int ath9k_htc_hw_init(struct ath9k_htc_hif *hif, struct htc_target *target,
-                      void *hif_handle, struct device *dev, u16 devid,
-                      enum ath9k_hif_transports transport);
+int ath9k_htc_hw_init(struct htc_target *target,
+                      struct device *dev, u16 devid);
 void ath9k_htc_hw_deinit(struct htc_target *target, bool hot_unplug);
 
 #endif /* HTC_HST_H */
diff --git a/drivers/net/wireless/ath/ath9k/recv.c b/drivers/net/wireless/ath/ath9k/recv.c
index ac60c4ee62d3..ba139132c85f 100644
--- a/drivers/net/wireless/ath/ath9k/recv.c
+++ b/drivers/net/wireless/ath/ath9k/recv.c
@@ -150,11 +150,9 @@ static bool ath_rx_edma_buf_link(struct ath_softc *sc,
 static void ath_rx_addbuffer_edma(struct ath_softc *sc,
                                   enum ath9k_rx_qtype qtype, int size)
 {
-        struct ath_rx_edma *rx_edma;
         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
         u32 nbuf = 0;
 
-        rx_edma = &sc->rx.rx_edma[qtype];
         if (list_empty(&sc->rx.rxbuf)) {
                 ath_print(common, ATH_DBG_QUEUE, "No free rx buf available\n");
                 return;
@@ -718,6 +716,7 @@ static bool ath_edma_get_buffers(struct ath_softc *sc,
                 __skb_unlink(skb, &rx_edma->rx_fifo);
                 list_add_tail(&bf->list, &sc->rx.rxbuf);
                 ath_rx_edma_buf_link(sc, qtype);
+                return true;
         }
         skb_queue_tail(&rx_edma->rx_buffers, skb);