Ignore:
Timestamp:
2010-04-15T22:37:20+02:00 (6 years ago)
Author:
nbd
Message:

ath9k: fix crash issues caused by the ar9300 support patch

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/package/mac80211/patches/300-ar9300_support.patch

    r20852 r20887  
    979979--- /dev/null 
    980980+++ b/drivers/net/wireless/ath/ath9k/ar5008_phy.c 
    981 @@ -0,0 +1,1345 @@ 
     981@@ -0,0 +1,1347 @@ 
    982982+/* 
    983983+ * Copyright (c) 2008-2010 Atheros Communications Inc. 
     
    10741074+       u32 new_bias = 0; 
    10751075+ 
    1076 +       if (!AR_SREV_5416(ah) || synth_freq >= 3000) { 
     1076+       if (!AR_SREV_5416(ah) || synth_freq >= 3000) 
    10771077+               return; 
    1078 +       } 
    10791078+ 
    10801079+       BUG_ON(AR_SREV_9280_10_OR_LATER(ah)); 
     
    11931192+ * input channel frequency and compute register settings below. 
    11941193+ */ 
    1195 +static void ar5008_hw_spur_mitigate(struct ath_hw *ah, struct ath9k_channel *chan) 
     1194+static void ar5008_hw_spur_mitigate(struct ath_hw *ah, 
     1195+                                   struct ath9k_channel *chan) 
    11961196+{ 
    11971197+       int bb_spur = AR_NO_SPUR; 
     
    17221722+       } 
    17231723+ 
    1724 +       /* Set correct baseband to analog shift setting to access analog chips */ 
     1724+       /* 
     1725+        * Set correct baseband to analog shift setting to 
     1726+        * access analog chips. 
     1727+        */ 
    17251728+       REG_WRITE(ah, AR_PHY(0), 0x00000007); 
    17261729+ 
     
    21272130+       } 
    21282131+       case ATH9K_ANI_SPUR_IMMUNITY_LEVEL:{ 
    2129 +               const int cycpwrThr1[] = 
    2130 +                       { 2, 4, 6, 8, 10, 12, 14, 16 }; 
     2132+               const int cycpwrThr1[] = { 2, 4, 6, 8, 10, 12, 14, 16 }; 
    21312133+               u32 level = param; 
    21322134+ 
     
    35843586--- /dev/null 
    35853587+++ b/drivers/net/wireless/ath/ath9k/ar9002_calib.c 
    3586 @@ -0,0 +1,988 @@ 
     3588@@ -0,0 +1,995 @@ 
    35873589+/* 
    35883590+ * Copyright (c) 2008-2010 Atheros Communications Inc. 
     
    36593661+                       ah->cal_samples++; 
    36603662+ 
    3661 +                       if (ah->cal_samples >= currCal->calData->calNumSamples) { 
     3663+                       if (ah->cal_samples >= 
     3664+                           currCal->calData->calNumSamples) { 
    36623665+                               int i, numChains = 0; 
    36633666+                               for (i = 0; i < AR5416_MAX_CHAINS; i++) { 
     
    39733976+       if (ah->initPDADC == 0 || currPDADC == 0) { 
    39743977+               /* 
    3975 +                * Zero value indicates that no frames have been transmitted yet, 
    3976 +                * can't do temperature compensation until frames are transmitted. 
     3978+                * Zero value indicates that no frames have been transmitted 
     3979+                * yet, can't do temperature compensation until frames are 
     3980+                * transmitted. 
    39773981+                */ 
    39783982+               return; 
     
    40264030+       u32 regVal; 
    40274031+       unsigned int i; 
    4028 +       u32 regList [][2] = { 
     4032+       u32 regList[][2] = { 
    40294033+               { 0x786c, 0 }, 
    40304034+               { 0x7854, 0 }, 
     
    40644068+       REG_RMW_FIELD(ah, AR9285_AN_RF2G1, AR9285_AN_RF2G1_PDPADRV1, 0); 
    40654069+       /* 7820,b24,0, pdpadrv2=0 */ 
    4066 +       REG_RMW_FIELD(ah, AR9285_AN_RF2G1,AR9285_AN_RF2G1_PDPADRV2,0); 
     4070+       REG_RMW_FIELD(ah, AR9285_AN_RF2G1, AR9285_AN_RF2G1_PDPADRV2, 0); 
    40674071+       /* 7820,b23,0, pdpaout=0 */ 
    40684072+       REG_RMW_FIELD(ah, AR9285_AN_RF2G1, AR9285_AN_RF2G1_PDPAOUT, 0); 
    40694073+       /* 783c,b14-16,7, padrvgn2tab_0=7 */ 
    4070 +       REG_RMW_FIELD(ah, AR9285_AN_RF2G8,AR9285_AN_RF2G8_PADRVGN2TAB0, 7); 
     4074+       REG_RMW_FIELD(ah, AR9285_AN_RF2G8, AR9285_AN_RF2G8_PADRVGN2TAB0, 7); 
    40714075+       /* 
    40724076+        * 7838,b29-31,0, padrvgn1tab_0=0 
    40734077+        * does not matter since we turn it off 
    40744078+        */ 
    4075 +       REG_RMW_FIELD(ah, AR9285_AN_RF2G7,AR9285_AN_RF2G7_PADRVGN2TAB0, 0); 
     4079+       REG_RMW_FIELD(ah, AR9285_AN_RF2G7, AR9285_AN_RF2G7_PADRVGN2TAB0, 0); 
    40764080+ 
    40774081+       REG_RMW_FIELD(ah, AR9285_AN_RF2G3, AR9271_AN_RF2G3_CCOMP, 0xfff); 
     
    40914095+               REG_WRITE(ah, 0x7834, regVal); 
    40924096+               udelay(1); 
    4093 +               //regVal = REG_READ(ah, 0x7834); 
     4097+               /* regVal = REG_READ(ah, 0x7834); */ 
    40944098+               regVal &= (~(0x1 << (20 + i))); 
    40954099+               regVal |= (MS(REG_READ(ah, 0x7840), AR9285_AN_RXTXBB1_SPARE9) 
     
    40984102+       } 
    40994103+ 
    4100 +       regVal = (regVal >>20) & 0x7f; 
     4104+       regVal = (regVal >> 20) & 0x7f; 
    41014105+ 
    41024106+       /* Update PA cal info */ 
     
    42884292+               ar9002_hw_olc_temp_compensation(ah); 
    42894293+ 
    4290 +               /* Get the value from the previous NF cal and update history buffer */ 
     4294+               /* 
     4295+                * Get the value from the previous NF cal and update 
     4296+                * history buffer. 
     4297+                */ 
    42914298+               ath9k_hw_getnf(ah, chan); 
    42924299+ 
    42934300+               /* 
    42944301+                * Load the NF from history buffer of the current channel. 
    4295 +                * NF is slow time-variant, so it is OK to use a historical value. 
     4302+                * NF is slow time-variant, so it is OK to use a historical 
     4303+                * value. 
    42964304+                */ 
    42974305+               ath9k_hw_loadnf(ah, ah->curchan); 
     
    44234431+ 
    44244432+               /* Poll for offset calibration complete */ 
    4425 +               if (!ath9k_hw_wait(ah, AR_PHY_AGC_CONTROL, AR_PHY_AGC_CONTROL_CAL, 
     4433+               if (!ath9k_hw_wait(ah, AR_PHY_AGC_CONTROL, 
     4434+                                  AR_PHY_AGC_CONTROL_CAL, 
    44264435+                                  0, AH_WAIT_TIMEOUT)) { 
    44274436+                       ath_print(common, ATH_DBG_CALIBRATE, 
     
    45754584--- /dev/null 
    45764585+++ b/drivers/net/wireless/ath/ath9k/ar9002_hw.c 
    4577 @@ -0,0 +1,584 @@ 
     4586@@ -0,0 +1,588 @@ 
    45784587+/* 
    45794588+ * Copyright (c) 2008-2010 Atheros Communications Inc. 
     
    47154724+                       INIT_INI_ARRAY(&ah->iniPcieSerdes, 
    47164725+                              ar9280PciePhy_clkreq_off_L1_9280, 
    4717 +                              ARRAY_SIZE(ar9280PciePhy_clkreq_off_L1_9280),2); 
     4726+                              ARRAY_SIZE(ar9280PciePhy_clkreq_off_L1_9280), 2); 
    47184727+               } else { 
    47194728+                       INIT_INI_ARRAY(&ah->iniPcieSerdes, 
     
    48134822+               INIT_INI_ARRAY(&ah->iniCckfirNormal, 
    48144823+                      ar9287Common_normal_cck_fir_coeff_92871_1, 
    4815 +                      ARRAY_SIZE(ar9287Common_normal_cck_fir_coeff_92871_1), 2); 
     4824+                      ARRAY_SIZE(ar9287Common_normal_cck_fir_coeff_92871_1), 
     4825+                      2); 
    48164826+               INIT_INI_ARRAY(&ah->iniCckfirJapan2484, 
    48174827+                      ar9287Common_japan_2484_cck_fir_coeff_92871_1, 
    4818 +                      ARRAY_SIZE(ar9287Common_japan_2484_cck_fir_coeff_92871_1), 2); 
     4828+                      ARRAY_SIZE(ar9287Common_japan_2484_cck_fir_coeff_92871_1), 
     4829+                      2); 
    48194830+       } 
    48204831+} 
     
    48244835+       u32 rxgain_type; 
    48254836+ 
    4826 +       if (ah->eep_ops->get_eeprom(ah, EEP_MINOR_REV) >= AR5416_EEP_MINOR_VER_17) { 
     4837+       if (ah->eep_ops->get_eeprom(ah, EEP_MINOR_REV) >= 
     4838+           AR5416_EEP_MINOR_VER_17) { 
    48274839+               rxgain_type = ah->eep_ops->get_eeprom(ah, EEP_RXGAIN_TYPE); 
    48284840+ 
     
    48504862+       u32 txgain_type; 
    48514863+ 
    4852 +       if (ah->eep_ops->get_eeprom(ah, EEP_MINOR_REV) >= AR5416_EEP_MINOR_VER_19) { 
     4864+       if (ah->eep_ops->get_eeprom(ah, EEP_MINOR_REV) >= 
     4865+           AR5416_EEP_MINOR_VER_19) { 
    48534866+               txgain_type = ah->eep_ops->get_eeprom(ah, EEP_TXGAIN_TYPE); 
    48544867+ 
     
    51625175--- /dev/null 
    51635176+++ b/drivers/net/wireless/ath/ath9k/ar9002_initvals.h 
    5164 @@ -0,0 +1,5229 @@ 
     5177@@ -0,0 +1,5230 @@ 
    51655178+/* 
    51665179+ * Copyright (c) 2010 Atheros Communications Inc. 
     
    93049317+/* 
    93059318+ * For Japanese regulatory requirements, 2484 MHz requires the following three 
    9306 + * registers be programmed differently from the channel between 2412 and 2472 MHz. 
     9319+ * registers be programmed differently from the channel between 2412 and 
     9320+ * 2472 MHz. 
    93079321+ */ 
    93089322+static const u_int32_t ar9287Common_normal_cck_fir_coeff_92871_1[][2] = { 
     
    1039410408--- /dev/null 
    1039510409+++ b/drivers/net/wireless/ath/ath9k/ar9002_mac.c 
    10396 @@ -0,0 +1,462 @@ 
     10410@@ -0,0 +1,480 @@ 
    1039710411+/* 
    1039810412+ * Copyright (c) 2008-2009 Atheros Communications Inc. 
     
    1041210426+ 
    1041310427+#include "hw.h" 
     10428+ 
     10429+#define AR_BufLen           0x00000fff 
    1041410430+ 
    1041510431+static void ar9002_hw_rx_enable(struct ath_hw *ah) 
     
    1083710853+               ads->ds_ctl0 &= ~AR_VirtMoreFrag; 
    1083810854+} 
     10855+ 
     10856+void ath9k_hw_setuprxdesc(struct ath_hw *ah, struct ath_desc *ds, 
     10857+                         u32 size, u32 flags) 
     10858+{ 
     10859+       struct ar5416_desc *ads = AR5416DESC(ds); 
     10860+       struct ath9k_hw_capabilities *pCap = &ah->caps; 
     10861+ 
     10862+       ads->ds_ctl1 = size & AR_BufLen; 
     10863+       if (flags & ATH9K_RXDESC_INTREQ) 
     10864+               ads->ds_ctl1 |= AR_RxIntrReq; 
     10865+ 
     10866+       ads->ds_rxstatus8 &= ~AR_RxDone; 
     10867+       if (!(pCap->hw_caps & ATH9K_HW_CAP_AUTOSLEEP)) 
     10868+               memset(&(ads->u), 0, sizeof(ads->u)); 
     10869+} 
     10870+EXPORT_SYMBOL(ath9k_hw_setuprxdesc); 
    1083910871+ 
    1084010872+void ar9002_hw_attach_mac_ops(struct ath_hw *ah) 
     
    1096410996+                       } else { 
    1096510997+                               REG_WRITE(ah, AR_PHY_CCK_TX_CTRL, 
    10966 +                                         txctl &~ AR_PHY_CCK_TX_CTRL_JAPAN); 
     10998+                                         txctl & ~AR_PHY_CCK_TX_CTRL_JAPAN); 
    1096710999+                       } 
    1096811000+               } 
     
    1097111003+               fracMode = 0; 
    1097211004+ 
    10973 +               switch(ah->eep_ops->get_eeprom(ah, EEP_FRAC_N_5G)) { 
     11005+               switch (ah->eep_ops->get_eeprom(ah, EEP_FRAC_N_5G)) { 
    1097411006+               case 0: 
    10975 +                       if ((freq % 20) == 0) { 
     11007+                       if ((freq % 20) == 0) 
    1097611008+                               aModeRefSel = 3; 
    10977 +                       } else if ((freq % 10) == 0) { 
     11009+                       else if ((freq % 10) == 0) 
    1097811010+                               aModeRefSel = 2; 
    10979 +                       } 
    1098011011+                       if (aModeRefSel) 
    1098111012+                               break; 
     
    1102511056+ * input channel frequency and compute register settings below. 
    1102611057+ */ 
    11027 +static void ar9002_hw_spur_mitigate(struct ath_hw *ah, struct ath9k_channel *chan) 
     11058+static void ar9002_hw_spur_mitigate(struct ath_hw *ah, 
     11059+                                   struct ath9k_channel *chan) 
    1102811060+{ 
    1102911061+       int bb_spur = AR_NO_SPUR; 
     
    1143311465+#define AR_PHY_FC_ENABLE_DAC_FIFO   0x00000800 
    1143411466+ 
    11435 +#define AR_PHY_TEST2               0x9808 
     11467+#define AR_PHY_TEST2                   0x9808 
    1143611468+ 
    1143711469+#define AR_PHY_TIMING2           0x9810 
     
    1194411976+#define AR_PHY_POWER_TX_RATE9   0xA3D4 
    1194511977+ 
    11946 +#define AR_PHY_XPA_CFG         0xA3D8 
     11978+#define AR_PHY_XPA_CFG         0xA3D8 
    1194711979+#define AR_PHY_FORCE_XPA_CFG   0x000000001 
    1194811980+#define AR_PHY_FORCE_XPA_CFG_S 0 
     
    1197112003--- /dev/null 
    1197212004+++ b/drivers/net/wireless/ath/ath9k/ar9003_calib.c 
    11973 @@ -0,0 +1,798 @@ 
     12005@@ -0,0 +1,802 @@ 
    1197412006+/* 
    1197512007+ * Copyright (c) 2010 Atheros Communications Inc. 
     
    1199812030+ 
    1199912031+       /* Select calibration to run */ 
    12000 +       switch(currCal->calData->calType) { 
     12032+       switch (currCal->calData->calType) { 
    1200112033+       case IQ_MISMATCH_CAL: 
    1200212034+               /* 
     
    1212412156+               /* 
    1212512157+                * Load the NF from history buffer of the current channel. 
    12126 +                * NF is slow time-variant, so it is OK to use a historical value. 
     12158+                * NF is slow time-variant, so it is OK to use a historical 
     12159+                * value. 
    1212712160+                */ 
    1212812161+               ath9k_hw_loadnf(ah, ah->curchan); 
     
    1222912262+                                 i, iCoff, qCoff); 
    1223012263+                       ath_print(common, ATH_DBG_CALIBRATE, 
    12231 +                                 "Register offset (0x%04x) " 
     12264+                                 "Register offset (0x%04x) " 
    1223212265+                                 "before update = 0x%x\n", 
    1223312266+                                 offset_array[i], 
     
    1224912282+                                 "Register offset (0x%04x) QQ COFF " 
    1225012283+                                 "(bitfields 0x%08x) after update = 0x%x\n", 
    12251 +                                 offset_array[i], AR_PHY_RX_IQCAL_CORR_IQCORR_Q_Q_COFF, 
     12284+                                 offset_array[i], 
     12285+                                 AR_PHY_RX_IQCAL_CORR_IQCORR_Q_Q_COFF, 
    1225212286+                                 REG_READ(ah, offset_array[i])); 
    1225312287+ 
     
    1226912303+ 
    1227012304+static const struct ath9k_percal_data iq_cal_single_sample = { 
    12271 +        IQ_MISMATCH_CAL, 
    12272 +        MIN_CAL_SAMPLES, 
    12273 +        PER_MAX_LOG_COUNT, 
     12305+       IQ_MISMATCH_CAL, 
     12306+       MIN_CAL_SAMPLES, 
     12307+       PER_MAX_LOG_COUNT, 
    1227412308+       ar9003_hw_iqcal_collect, 
    1227512309+       ar9003_hw_iqcalibrate 
     
    1236712401+       } 
    1236812402+ 
    12369 +       return (max_abs - (max_abs / 32) + (min_abs / 8) + (min_abs / 4)); 
     12403+       return max_abs - (max_abs / 32) + (min_abs / 8) + (min_abs / 4); 
    1237012404+} 
    1237112405+ 
     
    1265912693+ 
    1266012694+                       /* 16 bits */ 
    12661 +                       iq_res[idx+1] = 0xffff & REG_READ(ah, chan_info_tab[i] + offset); 
     12695+                       iq_res[idx+1] = 0xffff & REG_READ(ah, 
     12696+                                                         chan_info_tab[i] + 
     12697+                                                         offset); 
    1266212698+ 
    1266312699+                       ath_print(common, ATH_DBG_CALIBRATE, 
     
    1277212808--- /dev/null 
    1277312809+++ b/drivers/net/wireless/ath/ath9k/ar9003_eeprom.c 
    12774 @@ -0,0 +1,1841 @@ 
     12810@@ -0,0 +1,1856 @@ 
    1277512811+/* 
    1277612812+ * Copyright (c) 2010 Atheros Communications Inc. 
     
    1291312949+       /* ar9300_cal_data_per_freq_op_loop 2g */ 
    1291412950+       .calPierData2G = { 
    12915 +               {{0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0}}, 
    12916 +               {{0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0}}, 
    12917 +               {{0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0}}, 
     12951+               { {0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0} }, 
     12952+               { {0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0} }, 
     12953+               { {0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0} }, 
    1291812954+        }, 
    1291912955+       .calTarget_freqbin_Cck = { 
     
    1293812974+       .calTargetPowerCck = { 
    1293912975+                /* 1L-5L,5S,11L,11S */ 
    12940 +                {{36, 36, 36, 36}}, 
    12941 +                {{36, 36, 36, 36}}, 
     12976+                { {36, 36, 36, 36} }, 
     12977+                { {36, 36, 36, 36} }, 
    1294212978+       }, 
    1294312979+       .calTargetPower2G = { 
    1294412980+                /* 6-24,36,48,54 */ 
    12945 +                {{32, 32, 28, 24}}, 
    12946 +                {{32, 32, 28, 24}}, 
    12947 +                {{32, 32, 28, 24}}, 
     12981+                { {32, 32, 28, 24} }, 
     12982+                { {32, 32, 28, 24} }, 
     12983+                { {32, 32, 28, 24} }, 
    1294812984+       }, 
    1294912985+       .calTargetPower2GHT20 = { 
    12950 +               {{32, 32, 32, 32, 28, 20, 32, 32, 28, 20, 32, 32, 28, 20}}, 
    12951 +               {{32, 32, 32, 32, 28, 20, 32, 32, 28, 20, 32, 32, 28, 20}}, 
    12952 +               {{32, 32, 32, 32, 28, 20, 32, 32, 28, 20, 32, 32, 28, 20}}, 
     12986+               { {32, 32, 32, 32, 28, 20, 32, 32, 28, 20, 32, 32, 28, 20} }, 
     12987+               { {32, 32, 32, 32, 28, 20, 32, 32, 28, 20, 32, 32, 28, 20} }, 
     12988+               { {32, 32, 32, 32, 28, 20, 32, 32, 28, 20, 32, 32, 28, 20} }, 
    1295312989+       }, 
    1295412990+       .calTargetPower2GHT40 = { 
    12955 +               {{32, 32, 32, 32, 28, 20, 32, 32, 28, 20, 32, 32, 28, 20}}, 
    12956 +               {{32, 32, 32, 32, 28, 20, 32, 32, 28, 20, 32, 32, 28, 20}}, 
    12957 +               {{32, 32, 32, 32, 28, 20, 32, 32, 28, 20, 32, 32, 28, 20}}, 
     12991+               { {32, 32, 32, 32, 28, 20, 32, 32, 28, 20, 32, 32, 28, 20} }, 
     12992+               { {32, 32, 32, 32, 28, 20, 32, 32, 28, 20, 32, 32, 28, 20} }, 
     12993+               { {32, 32, 32, 32, 28, 20, 32, 32, 28, 20, 32, 32, 28, 20} }, 
    1295812994+       }, 
    1295912995+       .ctlIndex_2G =  { 
     
    1304513081+        }, 
    1304613082+       .ctlPowerData_2G = { 
    13047 +                {{{60, 0}, {60, 1}, {60, 0}, {60, 0}}}, 
    13048 +                {{{60, 0}, {60, 1}, {60, 0}, {60, 0}}}, 
    13049 +                {{{60, 1}, {60, 0}, {60, 0}, {60, 1}}}, 
    13050 + 
    13051 +                {{{60, 1}, {60, 0}, {0, 0}, {0, 0}}}, 
    13052 +                {{{60, 0}, {60, 1}, {60, 0}, {60, 0}}}, 
    13053 +                {{{60, 0}, {60, 1}, {60, 0}, {60, 0}}}, 
    13054 + 
    13055 +                {{{60, 0}, {60, 1}, {60, 1}, {60, 0}}}, 
    13056 +                {{{60, 0}, {60, 1}, {60, 0}, {60, 0}}}, 
    13057 +                {{{60, 0}, {60, 1}, {60, 0}, {60, 0}}}, 
    13058 + 
    13059 +                {{{60, 0}, {60, 1}, {60, 0}, {60, 0}}}, 
    13060 +                {{{60, 0}, {60, 1}, {60, 1}, {60, 1}}}, 
     13083+                { { {60, 0}, {60, 1}, {60, 0}, {60, 0} } }, 
     13084+                { { {60, 0}, {60, 1}, {60, 0}, {60, 0} } }, 
     13085+                { { {60, 1}, {60, 0}, {60, 0}, {60, 1} } }, 
     13086+ 
     13087+                { { {60, 1}, {60, 0}, {0, 0}, {0, 0} } }, 
     13088+                { { {60, 0}, {60, 1}, {60, 0}, {60, 0} } }, 
     13089+                { { {60, 0}, {60, 1}, {60, 0}, {60, 0} } }, 
     13090+ 
     13091+                { { {60, 0}, {60, 1}, {60, 1}, {60, 0} } }, 
     13092+                { { {60, 0}, {60, 1}, {60, 0}, {60, 0} } }, 
     13093+                { { {60, 0}, {60, 1}, {60, 0}, {60, 0} } }, 
     13094+ 
     13095+                { { {60, 0}, {60, 1}, {60, 0}, {60, 0} } }, 
     13096+                { { {60, 0}, {60, 1}, {60, 1}, {60, 1} } }, 
    1306113097+        }, 
    1306213098+       .modalHeader5G = { 
     
    1317813214+       .calTargetPower5G = { 
    1317913215+               /* 6-24,36,48,54 */ 
    13180 +               {{20, 20, 20, 10}}, 
    13181 +               {{20, 20, 20, 10}}, 
    13182 +               {{20, 20, 20, 10}}, 
    13183 +               {{20, 20, 20, 10}}, 
    13184 +               {{20, 20, 20, 10}}, 
    13185 +               {{20, 20, 20, 10}}, 
    13186 +               {{20, 20, 20, 10}}, 
    13187 +               {{20, 20, 20, 10}}, 
     13216+               { {20, 20, 20, 10} }, 
     13217+               { {20, 20, 20, 10} }, 
     13218+               { {20, 20, 20, 10} }, 
     13219+               { {20, 20, 20, 10} }, 
     13220+               { {20, 20, 20, 10} }, 
     13221+               { {20, 20, 20, 10} }, 
     13222+               { {20, 20, 20, 10} }, 
     13223+               { {20, 20, 20, 10} }, 
    1318813224+        }, 
    1318913225+       .calTargetPower5GHT20 = { 
     
    1319213228+                * 4,5,6,7,12,13,14,15,20,21,22,23 
    1319313229+                */ 
    13194 +               {{20, 20, 10, 10, 0, 0, 10, 10, 0, 0, 10, 10, 0, 0}}, 
    13195 +               {{20, 20, 10, 10, 0, 0, 10, 10, 0, 0, 10, 10, 0, 0}}, 
    13196 +               {{20, 20, 10, 10, 0, 0, 10, 10, 0, 0, 10, 10, 0, 0}}, 
    13197 +               {{20, 20, 10, 10, 0, 0, 10, 10, 0, 0, 10, 10, 0, 0}}, 
    13198 +               {{20, 20, 10, 10, 0, 0, 10, 10, 0, 0, 10, 10, 0, 0}}, 
    13199 +               {{20, 20, 10, 10, 0, 0, 10, 10, 0, 0, 10, 10, 0, 0}}, 
    13200 +               {{20, 20, 10, 10, 0, 0, 10, 10, 0, 0, 10, 10, 0, 0}}, 
    13201 +               {{20, 20, 10, 10, 0, 0, 10, 10, 0, 0, 10, 10, 0, 0}}, 
     13230+               { {20, 20, 10, 10, 0, 0, 10, 10, 0, 0, 10, 10, 0, 0} }, 
     13231+               { {20, 20, 10, 10, 0, 0, 10, 10, 0, 0, 10, 10, 0, 0} }, 
     13232+               { {20, 20, 10, 10, 0, 0, 10, 10, 0, 0, 10, 10, 0, 0} }, 
     13233+               { {20, 20, 10, 10, 0, 0, 10, 10, 0, 0, 10, 10, 0, 0} }, 
     13234+               { {20, 20, 10, 10, 0, 0, 10, 10, 0, 0, 10, 10, 0, 0} }, 
     13235+               { {20, 20, 10, 10, 0, 0, 10, 10, 0, 0, 10, 10, 0, 0} }, 
     13236+               { {20, 20, 10, 10, 0, 0, 10, 10, 0, 0, 10, 10, 0, 0} }, 
     13237+               { {20, 20, 10, 10, 0, 0, 10, 10, 0, 0, 10, 10, 0, 0} }, 
    1320213238+        }, 
    1320313239+       .calTargetPower5GHT40 =  { 
     
    1320613242+                * 4,5,6,7,12,13,14,15,20,21,22,23 
    1320713243+                */ 
    13208 +               {{20, 20, 10, 10, 0, 0, 10, 10, 0, 0, 10, 10, 0, 0}}, 
    13209 +               {{20, 20, 10, 10, 0, 0, 10, 10, 0, 0, 10, 10, 0, 0}}, 
    13210 +               {{20, 20, 10, 10, 0, 0, 10, 10, 0, 0, 10, 10, 0, 0}}, 
    13211 +               {{20, 20, 10, 10, 0, 0, 10, 10, 0, 0, 10, 10, 0, 0}}, 
    13212 +               {{20, 20, 10, 10, 0, 0, 10, 10, 0, 0, 10, 10, 0, 0}}, 
    13213 +               {{20, 20, 10, 10, 0, 0, 10, 10, 0, 0, 10, 10, 0, 0}}, 
    13214 +               {{20, 20, 10, 10, 0, 0, 10, 10, 0, 0, 10, 10, 0, 0}}, 
    13215 +               {{20, 20, 10, 10, 0, 0, 10, 10, 0, 0, 10, 10, 0, 0}}, 
     13244+               { {20, 20, 10, 10, 0, 0, 10, 10, 0, 0, 10, 10, 0, 0} }, 
     13245+               { {20, 20, 10, 10, 0, 0, 10, 10, 0, 0, 10, 10, 0, 0} }, 
     13246+               { {20, 20, 10, 10, 0, 0, 10, 10, 0, 0, 10, 10, 0, 0} }, 
     13247+               { {20, 20, 10, 10, 0, 0, 10, 10, 0, 0, 10, 10, 0, 0} }, 
     13248+               { {20, 20, 10, 10, 0, 0, 10, 10, 0, 0, 10, 10, 0, 0} }, 
     13249+               { {20, 20, 10, 10, 0, 0, 10, 10, 0, 0, 10, 10, 0, 0} }, 
     13250+               { {20, 20, 10, 10, 0, 0, 10, 10, 0, 0, 10, 10, 0, 0} }, 
     13251+               { {20, 20, 10, 10, 0, 0, 10, 10, 0, 0, 10, 10, 0, 0} }, 
    1321613252+        }, 
    1321713253+       .ctlIndex_5G =  { 
     
    1341313449+       case EEP_INTERNAL_REGULATOR: 
    1341413450+               /* Bit 4 is internal regulator flag */ 
    13415 +               return ((pBase->featureEnable & 0x10) >> 4); 
     13451+               return (pBase->featureEnable & 0x10) >> 4; 
    1341613452+       case EEP_SWREG: 
    13417 +               return (pBase->swreg); 
     13453+               return pBase->swreg; 
    1341813454+       default: 
    1341913455+               return 0; 
     
    1345713493+ 
    1345813494+static bool ar9300_hw_read_eeprom(struct ath_hw *ah, 
    13459 +                                 long address, u8 * buffer, int many) 
     13495+                                 long address, u8 *buffer, int many) 
    1346013496+{ 
    1346113497+       int i; 
     
    1346813504+       if ((address < 0) || ((address + many) > AR9300_EEPROM_SIZE - 1)) { 
    1346913505+               ath_print(common, ATH_DBG_EEPROM, 
    13470 +                         "eeprom address not in range \n"); 
     13506+                         "eeprom address not in range\n"); 
    1347113507+               return false; 
    1347213508+       } 
     
    1348913525+ 
    1349013526+static bool ar9300_read_eeprom(struct ath_hw *ah, 
    13491 +                              int address, u8 * buffer, int many) 
     13527+                              int address, u8 *buffer, int many) 
    1349213528+{ 
    1349313529+       int it; 
    1349413530+ 
    1349513531+       for (it = 0; it < many; it++) 
    13496 +               if (!ar9300_hw_read_eeprom(ah, (address - it), (buffer + it), 1)) 
     13532+               if (!ar9300_hw_read_eeprom(ah, 
     13533+                                          (address - it), 
     13534+                                          (buffer + it), 1)) 
    1349713535+                       return false; 
    1349813536+       return true; 
    1349913537+} 
    1350013538+ 
    13501 +static void ar9300_comp_hdr_unpack(u8 * best, int *code, int *reference, 
     13539+static void ar9300_comp_hdr_unpack(u8 *best, int *code, int *reference, 
    1350213540+                                  int *length, int *major, int *minor) 
    1350313541+{ 
     
    1351513553+} 
    1351613554+ 
    13517 +static u16 ar9300_comp_cksum(u8 * data, int dsize) 
     13555+static u16 ar9300_comp_cksum(u8 *data, int dsize) 
    1351813556+{ 
    1351913557+       int it, checksum = 0; 
     
    1355013588+               if (length > 0 && spot >= 0 && spot+length < mdataSize) { 
    1355113589+                       ath_print(common, ATH_DBG_EEPROM, 
    13552 +                                 "Restore at %d: spot=%d offset=%d length=%d\n", 
     13590+                                 "Restore at %d: spot=%d " 
     13591+                                 "offset=%d length=%d\n", 
    1355313592+                                  it, spot, offset, length); 
    13554 +                       memcpy(&mptr[spot],&block[it+2],length); 
     13593+                       memcpy(&mptr[spot], &block[it+2], length); 
    1355513594+                       spot += length; 
    1355613595+               } else if (length > 0) { 
    1355713596+                       ath_print(common, ATH_DBG_EEPROM, 
    13558 +                                 "Bad restore at %d: spot=%d offset=%d length=%d\n", 
     13597+                                 "Bad restore at %d: spot=%d " 
     13598+                                 "offset=%d length=%d\n", 
    1355913599+                                 it, spot, offset, length); 
    1356013600+                       return false; 
     
    1356813608+                                   int code, 
    1356913609+                                   int reference, 
    13570 +                                   u8 * mptr, 
    13571 +                                   u8 * word, int length, int mdata_size) 
     13610+                                   u8 *mptr, 
     13611+                                   u8 *word, int length, int mdata_size) 
    1357213612+{ 
    1357313613+       struct ath_common *common = ath9k_hw_common(ah); 
     
    1362013660+ */ 
    1362113661+static int ar9300_eeprom_restore_internal(struct ath_hw *ah, 
    13622 +                                         u8 * mptr, int mdata_size) 
     13662+                                         u8 *mptr, int mdata_size) 
    1362313663+{ 
    1362413664+#define MDEFAULT 15 
     
    1369813738+       int mdata_size; 
    1369913739+ 
    13700 +       mptr = (u8 *) & ah->eeprom.ar9300_eep; 
     13740+       mptr = (u8 *) &ah->eeprom.ar9300_eep; 
    1370113741+       mdata_size = sizeof(struct ar9300_eeprom); 
    1370213742+ 
     
    1376913809+       if (is2ghz) 
    1377013810+               return eep->modalHeader2G.antCtrlCommon; 
    13771 +        else 
     13811+       else 
    1377213812+               return eep->modalHeader5G.antCtrlCommon; 
    1377313813+} 
     
    1378313823+} 
    1378413824+ 
    13785 +static u16 ar9003_hw_ant_ctrl_chain_get(struct ath_hw *ah, int chain, bool is2ghz) 
     13825+static u16 ar9003_hw_ant_ctrl_chain_get(struct ath_hw *ah, 
     13826+                                       int chain, 
     13827+                                       bool is2ghz) 
    1378613828+{ 
    1378713829+       struct ar9300_eeprom *eep = &ah->eeprom.ar9300_eep; 
     
    1379013832+               if (is2ghz) 
    1379113833+                       return eep->modalHeader2G.antCtrlChain[chain]; 
    13792 +                else 
     13834+               else 
    1379313835+                       return eep->modalHeader5G.antCtrlChain[chain]; 
    1379413836+       } 
    1379513837+ 
    13796 +        return 0; 
     13838+       return 0; 
    1379713839+} 
    1379813840+ 
     
    1390513947+ */ 
    1390613948+static int ar9003_hw_power_interpolate(int32_t x, 
    13907 +                                      int32_t * px, int32_t * py, u_int16_t np) 
     13949+                                      int32_t *px, int32_t *py, u_int16_t np) 
    1390813950+{ 
    1390913951+       int ip = 0; 
     
    1395313995+       } else if (hhave)       /* only high is good, use it */ 
    1395413996+               y = hy; 
    13955 +       else                    /* nothing is good,this should never happen unless np=0, ???? */ 
     13997+       else /* nothing is good,this should never happen unless np=0, ???? */ 
    1395613998+               y = -(1 << 30); 
    1395713999+       return y; 
     
    1398814030+ 
    1398914031+       /* interpolate to get target power for given frequency */ 
    13990 +       return ((u8) ar9003_hw_power_interpolate((s32) freq, 
     14032+       return (u8) ar9003_hw_power_interpolate((s32) freq, 
    1399114033+                                                freqArray, 
    13992 +                                                targetPowerArray, numPiers)); 
     14034+                                                targetPowerArray, numPiers); 
    1399314035+} 
    1399414036+ 
     
    1402414066+ 
    1402514067+       /* interpolate to get target power for given frequency */ 
    14026 +       return ((u8) ar9003_hw_power_interpolate((s32) freq, 
     14068+       return (u8) ar9003_hw_power_interpolate((s32) freq, 
    1402714069+                                                freqArray, 
    14028 +                                                targetPowerArray, numPiers)); 
     14070+                                                targetPowerArray, numPiers); 
    1402914071+} 
    1403014072+ 
     
    1406014102+ 
    1406114103+       /* interpolate to get target power for given frequency */ 
    14062 +       return ((u8) ar9003_hw_power_interpolate((s32) freq, 
     14104+       return (u8) ar9003_hw_power_interpolate((s32) freq, 
    1406314105+                                                freqArray, 
    14064 +                                                targetPowerArray, numPiers)); 
     14106+                                                targetPowerArray, numPiers); 
    1406514107+} 
    1406614108+ 
     
    1408514127+ 
    1408614128+       /* interpolate to get target power for given frequency */ 
    14087 +       return ((u8) ar9003_hw_power_interpolate((s32) freq, 
     14129+       return (u8) ar9003_hw_power_interpolate((s32) freq, 
    1408814130+                                                freqArray, 
    14089 +                                                targetPowerArray, numPiers)); 
     14131+                                                targetPowerArray, numPiers); 
    1409014132+} 
    1409114133+ 
     
    1411914161+                 POW_SM(pPwrArray[ALL_TARGET_LEGACY_1L_5L], 24) | 
    1412014162+                 POW_SM(pPwrArray[ALL_TARGET_LEGACY_1L_5L], 16) | 
    14121 +                 // POW_SM(txPowerTimes2,  8) | /* this is reserved for AR9003 */ 
     14163+                 /* POW_SM(txPowerTimes2,  8) | this is reserved for AR9003 */ 
    1412214164+                 POW_SM(pPwrArray[ALL_TARGET_LEGACY_1L_5L], 0)); 
    1412314165+ 
     
    1416614208+           ); 
    1416714209+ 
    14168 +       /* Write the HT40 power per rate set */ 
    14169 +       // correct PAR difference between HT40 and HT20/LEGACY 
    14170 +       /* 0/8/16 (LSB), 1-3/9-11/17-19, 4, 5 (MSB) */ 
     14210+       /* 
     14211+        * Write the HT40 power per rate set 
     14212+        * correct PAR difference between HT40 and HT20/LEGACY 
     14213+        * 0/8/16 (LSB), 1-3/9-11/17-19, 4, 5 (MSB) 
     14214+        */ 
    1417114215+       REG_WRITE(ah, 0xa3d8, 
    1417214216+                 POW_SM(pPwrArray[ALL_TARGET_HT40_5], 24) | 
     
    1432914373+ 
    1433014374+               ath_print(common, ATH_DBG_EEPROM, 
    14331 +                         "TPC[%02d] 0x%08x \n", i, targetPowerValT2[i]); 
     14375+                         "TPC[%02d] 0x%08x\n", i, targetPowerValT2[i]); 
    1433214376+               i++; 
    1433314377+       } 
     
    1436114405+               if (ipier >= AR9300_NUM_5G_CAL_PIERS) { 
    1436214406+                       ath_print(common, ATH_DBG_EEPROM, 
    14363 +                                 "Invalid 5GHz cal pier index, must be less than %d\n", 
     14407+                                 "Invalid 5GHz cal pier index, must " 
     14408+                                 "be less than %d\n", 
    1436414409+                                 AR9300_NUM_5G_CAL_PIERS); 
    1436514410+                       return -1; 
     
    1447814523+                                           fdiff > 
    1447914524+                                           (frequency - hfrequency[ichain])) { 
    14480 +                                               /* new best higher frequency measurement */ 
     14525+                                               /* 
     14526+                                                * new best higher 
     14527+                                                * frequency measurement 
     14528+                                                */ 
    1448114529+                                               hfrequency[ichain] = pfrequency; 
    1448214530+                                               hcorrection[ichain] = 
     
    1449114539+                                           || fdiff < 
    1449214540+                                           (frequency - lfrequency[ichain])) { 
    14493 +                                               /* new best lower frequency measurement */ 
     14541+                                               /* 
     14542+                                                * new best lower 
     14543+                                                * frequency measurement 
     14544+                                                */ 
    1449414545+                                               lfrequency[ichain] = pfrequency; 
    1449514546+                                               lcorrection[ichain] = 
     
    1462714678+#define AR9300_EEP_MINOR_VER         AR9300_EEP_MINOR_VER_1 
    1462814679+ 
    14629 +// 16-bit offset location start of calibration struct 
     14680+/* 16-bit offset location start of calibration struct */ 
    1463014681+#define AR9300_EEP_START_LOC         256 
    1463114682+#define AR9300_NUM_5G_CAL_PIERS      8 
     
    1463614687+#define AR9300_NUM_2G_20_TARGET_POWERS  3 
    1463714688+#define AR9300_NUM_2G_40_TARGET_POWERS  3 
    14638 +//#define AR9300_NUM_CTLS              21 
     14689+/* #define AR9300_NUM_CTLS              21 */ 
    1463914690+#define AR9300_NUM_CTLS_5G           9 
    1464014691+#define AR9300_NUM_CTLS_2G           12 
     
    1466114712+#define AR9300_CUSTOMER_DATA_SIZE    20 
    1466214713+ 
    14663 +#define FREQ2FBIN(x,y) ((y) ? ((x) - 2300) : (((x) - 4800) / 5)) 
    14664 +#define FBIN2FREQ(x,y) ((y) ? (2300 + x) : (4800 + 5 * x)) 
     14714+#define FREQ2FBIN(x, y) ((y) ? ((x) - 2300) : (((x) - 4800) / 5)) 
     14715+#define FBIN2FREQ(x, y) ((y) ? (2300 + x) : (4800 + 5 * x)) 
    1466514716+#define AR9300_MAX_CHAINS            3 
    1466614717+#define AR9300_ANT_16S               25 
     
    1469414745+#define ENABLE_VOLT_COMPENSATION 0x02 
    1469514746+/* byte addressable */ 
    14696 +#define AR9300_EEPROM_SIZE 16*1024 
     14747+#define AR9300_EEPROM_SIZE (16*1024) 
    1469714748+#define FIXED_CCA_THRESHOLD 15 
    1469814749+ 
     
    1487914930+ 
    1488014931+struct cal_ctl_edge_pwr { 
    14881 +    u8 tPower :6, 
    14882 +        flag :2; 
     14932+       u8 tPower:6, 
     14933+          flag:2; 
    1488314934+} __packed; 
    1488414935+ 
     
    1496015011+ 
    1496115012+#include "hw.h" 
     15013+#include "ar9003_mac.h" 
    1496215014+#include "ar9003_initvals.h" 
    1496315015+ 
     
    1505215104+static void ar9003_tx_gain_table_apply(struct ath_hw *ah) 
    1505315105+{ 
    15054 +       switch(ar9003_hw_get_tx_gain_idx(ah)) { 
     15106+       switch (ar9003_hw_get_tx_gain_idx(ah)) { 
    1505515107+       case 0: 
    1505615108+       default: 
     
    1507715129+static void ar9003_rx_gain_table_apply(struct ath_hw *ah) 
    1507815130+{ 
    15079 +       switch(ar9003_hw_get_rx_gain_idx(ah)) 
    15080 +       { 
     15131+       switch (ar9003_hw_get_rx_gain_idx(ah)) { 
    1508115132+       case 0: 
    1508215133+       default: 
     
    1694616997--- /dev/null 
    1694716998+++ b/drivers/net/wireless/ath/ath9k/ar9003_mac.c 
    16948 @@ -0,0 +1,610 @@ 
     16999@@ -0,0 +1,611 @@ 
    1694917000+/* 
    1695017001+ * Copyright (c) 2010 Atheros Communications Inc. 
     
    1696317014+ */ 
    1696417015+#include "hw.h" 
     17016+#include "ar9003_mac.h" 
    1696517017+ 
    1696617018+static void ar9003_hw_rx_enable(struct ath_hw *hw) 
     
    1755917611--- /dev/null 
    1756017612+++ b/drivers/net/wireless/ath/ath9k/ar9003_mac.h 
    17561 @@ -0,0 +1,124 @@ 
     17613@@ -0,0 +1,120 @@ 
    1756217614+/* 
    1756317615+ * Copyright (c) 2010 Atheros Communications Inc. 
     
    1758717639+#define AR_TxQcuNum    0x00000f00 
    1758817640+#define AR_TxQcuNum_S  8 
     17641+ 
     17642+#define AR_BufLen      0x0fff0000 
    1758917643+#define AR_BufLen_S    16 
    1759017644+ 
     
    1760917663+ 
    1761017664+#define AR9003TXC_CONST(_ds) ((const struct ar9003_txc *) _ds) 
    17611 + 
    17612 +enum ath9k_rx_qtype { 
    17613 +       ATH9K_RX_QUEUE_HP, 
    17614 +       ATH9K_RX_QUEUE_LP, 
    17615 +       ATH9K_RX_QUEUE_MAX, 
    17616 +}; 
    1761717665+ 
    1761817666+struct ar9003_rxs { 
     
    1768617734--- /dev/null 
    1768717735+++ b/drivers/net/wireless/ath/ath9k/ar9003_phy.c 
    17688 @@ -0,0 +1,1138 @@ 
     17736@@ -0,0 +1,1142 @@ 
    1768917737+/* 
    1769017738+ * Copyright (c) 2010 Atheros Communications Inc. 
     
    1776617814+ 
    1776717815+       /* Program Synth. setting */ 
    17768 +       reg32 = (channelSel << 2 ) | (fracMode << 30) | 
     17816+       reg32 = (channelSel << 2) | (fracMode << 30) | 
    1776917817+               (aModeRefSel << 28) | (loadSynthChannel << 31); 
    1777017818+       REG_WRITE(ah, AR_PHY_65NM_CH0_SYNTH7, reg32); 
     
    1777217820+       /* Toggle Load Synth channel bit */ 
    1777317821+       loadSynthChannel = 1; 
    17774 +       reg32 = (channelSel << 2 ) | (fracMode << 30) | 
     17822+       reg32 = (channelSel << 2) | (fracMode << 30) | 
    1777517823+               (aModeRefSel << 28) | (loadSynthChannel << 31); 
    1777617824+       REG_WRITE(ah, AR_PHY_65NM_CH0_SYNTH7, reg32); 
     
    1780817856+               cur_bb_spur = spur_freq[i] - chan->channel; 
    1780917857+ 
    17810 +               if(cur_bb_spur < 0) { 
     17858+               if (cur_bb_spur < 0) { 
    1781117859+                       negative = 1; 
    1781217860+                       cur_bb_spur = -cur_bb_spur; 
     
    1782517873+                                     AR_PHY_CCK_SPUR_MIT_SPUR_RSSI_THR, 0x7f); 
    1782617874+                       REG_RMW_FIELD(ah, AR_PHY_CCK_SPUR_MIT, 
    17827 +                                     AR_PHY_CCK_SPUR_MIT_SPUR_FILTER_TYPE, 0x2); 
     17875+                                     AR_PHY_CCK_SPUR_MIT_SPUR_FILTER_TYPE, 
     17876+                                     0x2); 
    1782817877+                       REG_RMW_FIELD(ah, AR_PHY_CCK_SPUR_MIT, 
    17829 +                                     AR_PHY_CCK_SPUR_MIT_USE_CCK_SPUR_MIT, 0x1); 
     17878+                                     AR_PHY_CCK_SPUR_MIT_USE_CCK_SPUR_MIT, 
     17879+                                     0x1); 
    1783017880+                       REG_RMW_FIELD(ah, AR_PHY_CCK_SPUR_MIT, 
    17831 +                                     AR_PHY_CCK_SPUR_MIT_CCK_SPUR_FREQ, cck_spur_freq); 
     17881+                                     AR_PHY_CCK_SPUR_MIT_CCK_SPUR_FREQ, 
     17882+                                     cck_spur_freq); 
    1783217883+ 
    1783317884+                       return; 
     
    1818918240+        */ 
    1819018241+       val = REG_READ(ah, AR_PCU_MISC_MODE2) & (~AR_ADHOC_MCAST_KEYID_ENABLE); 
    18191 +       REG_WRITE(ah, AR_PCU_MISC_MODE2, val | AR_AGG_WEP_ENABLE_FIX | AR_AGG_WEP_ENABLE); 
     18242+       REG_WRITE(ah, AR_PCU_MISC_MODE2, 
     18243+                 val | AR_AGG_WEP_ENABLE_FIX | AR_AGG_WEP_ENABLE); 
    1819218244+} 
    1819318245+ 
     
    1848018532+                             AR_PHY_SFCORR_M2COUNT_THR, m2CountThr[on]); 
    1848118533+               REG_RMW_FIELD(ah, AR_PHY_SFCORR_LOW, 
    18482 +                             AR_PHY_SFCORR_LOW_M2COUNT_THR_LOW, m2CountThrLow[on]); 
     18534+                             AR_PHY_SFCORR_LOW_M2COUNT_THR_LOW, 
     18535+                             m2CountThrLow[on]); 
    1848318536+ 
    1848418537+               REG_RMW_FIELD(ah, AR_PHY_SFCORR_EXT, 
     
    1854518598+       } 
    1854618599+       case ATH9K_ANI_SPUR_IMMUNITY_LEVEL:{ 
    18547 +               const int cycpwrThr1[] = 
    18548 +                       { 2, 4, 6, 8, 10, 12, 14, 16 }; 
     18600+               const int cycpwrThr1[] = { 2, 4, 6, 8, 10, 12, 14, 16 }; 
    1854918601+               u32 level = param; 
    1855018602+ 
     
    1871818770+        * 1xx => Chain 2,1 and 0 enabled 
    1871918771+        */ 
    18720 +       return (chain & 0x7); 
     18772+       return chain & 0x7; 
    1872118773+} 
    1872218774+ 
     
    1885218904+#define AR_CHAN_BASE   0x9800 
    1885318905+ 
    18854 +#define AR_PHY_TIMING1      AR_CHAN_BASE + 0x0 
    18855 +#define AR_PHY_TIMING2      AR_CHAN_BASE + 0x4 
    18856 +#define AR_PHY_TIMING3      AR_CHAN_BASE + 0x8 
    18857 +#define AR_PHY_TIMING4      AR_CHAN_BASE + 0xc 
    18858 +#define AR_PHY_TIMING5      AR_CHAN_BASE + 0x10 
    18859 +#define AR_PHY_TIMING6      AR_CHAN_BASE + 0x14 
    18860 +#define AR_PHY_TIMING11     AR_CHAN_BASE + 0x18 
    18861 +#define AR_PHY_SPUR_REG     AR_CHAN_BASE + 0x1c 
    18862 +#define AR_PHY_RX_IQCAL_CORR_B0    AR_CHAN_BASE + 0xdc 
    18863 +#define AR_PHY_TX_IQCAL_CONTROL_3  AR_CHAN_BASE + 0xb0 
     18906+#define AR_PHY_TIMING1      (AR_CHAN_BASE + 0x0) 
     18907+#define AR_PHY_TIMING2      (AR_CHAN_BASE + 0x4) 
     18908+#define AR_PHY_TIMING3      (AR_CHAN_BASE + 0x8) 
     18909+#define AR_PHY_TIMING4      (AR_CHAN_BASE + 0xc) 
     18910+#define AR_PHY_TIMING5      (AR_CHAN_BASE + 0x10) 
     18911+#define AR_PHY_TIMING6      (AR_CHAN_BASE + 0x14) 
     18912+#define AR_PHY_TIMING11     (AR_CHAN_BASE + 0x18) 
     18913+#define AR_PHY_SPUR_REG     (AR_CHAN_BASE + 0x1c) 
     18914+#define AR_PHY_RX_IQCAL_CORR_B0    (AR_CHAN_BASE + 0xdc) 
     18915+#define AR_PHY_TX_IQCAL_CONTROL_3  (AR_CHAN_BASE + 0xb0) 
    1886418916+ 
    1886518917+#define AR_PHY_TIMING11_SPUR_FREQ_SD    0x3FF00000 
     
    1889318945+#define AR_PHY_TX_IQCAL_CONTROL_3_IQCORR_EN_S         31 
    1889418946+ 
    18895 +#define AR_PHY_FIND_SIG_LOW  AR_CHAN_BASE + 0x20 
    18896 + 
    18897 +#define AR_PHY_SFCORR           AR_CHAN_BASE + 0x24 
    18898 +#define AR_PHY_SFCORR_LOW       AR_CHAN_BASE + 0x28 
    18899 +#define AR_PHY_SFCORR_EXT       AR_CHAN_BASE + 0x2c 
    18900 + 
    18901 +#define AR_PHY_EXT_CCA              AR_CHAN_BASE + 0x30 
    18902 +#define AR_PHY_RADAR_0              AR_CHAN_BASE + 0x34 
    18903 +#define AR_PHY_RADAR_1              AR_CHAN_BASE + 0x38 
    18904 +#define AR_PHY_RADAR_EXT            AR_CHAN_BASE + 0x3c 
    18905 +#define AR_PHY_MULTICHAIN_CTRL      AR_CHAN_BASE + 0x80 
    18906 +#define AR_PHY_PERCHAIN_CSD         AR_CHAN_BASE + 0x84 
    18907 + 
    18908 +#define AR_PHY_TX_PHASE_RAMP_0      AR_CHAN_BASE + 0xd0 
    18909 +#define AR_PHY_ADC_GAIN_DC_CORR_0   AR_CHAN_BASE + 0xd4 
    18910 +#define AR_PHY_IQ_ADC_MEAS_0_B0     AR_CHAN_BASE + 0xc0 
    18911 +#define AR_PHY_IQ_ADC_MEAS_1_B0     AR_CHAN_BASE + 0xc4 
    18912 +#define AR_PHY_IQ_ADC_MEAS_2_B0     AR_CHAN_BASE + 0xc8 
    18913 +#define AR_PHY_IQ_ADC_MEAS_3_B0     AR_CHAN_BASE + 0xcc 
     18947+#define AR_PHY_FIND_SIG_LOW  (AR_CHAN_BASE + 0x20) 
     18948+ 
     18949+#define AR_PHY_SFCORR           (AR_CHAN_BASE + 0x24) 
     18950+#define AR_PHY_SFCORR_LOW       (AR_CHAN_BASE + 0x28) 
     18951+#define AR_PHY_SFCORR_EXT       (AR_CHAN_BASE + 0x2c) 
     18952+ 
     18953+#define AR_PHY_EXT_CCA              (AR_CHAN_BASE + 0x30) 
     18954+#define AR_PHY_RADAR_0              (AR_CHAN_BASE + 0x34) 
     18955+#define AR_PHY_RADAR_1              (AR_CHAN_BASE + 0x38) 
     18956+#define AR_PHY_RADAR_EXT            (AR_CHAN_BASE + 0x3c) 
     18957+#define AR_PHY_MULTICHAIN_CTRL      (AR_CHAN_BASE + 0x80) 
     18958+#define AR_PHY_PERCHAIN_CSD         (AR_CHAN_BASE + 0x84) 
     18959+ 
     18960+#define AR_PHY_TX_PHASE_RAMP_0      (AR_CHAN_BASE + 0xd0) 
     18961+#define AR_PHY_ADC_GAIN_DC_CORR_0   (AR_CHAN_BASE + 0xd4) 
     18962+#define AR_PHY_IQ_ADC_MEAS_0_B0     (AR_CHAN_BASE + 0xc0) 
     18963+#define AR_PHY_IQ_ADC_MEAS_1_B0     (AR_CHAN_BASE + 0xc4) 
     18964+#define AR_PHY_IQ_ADC_MEAS_2_B0     (AR_CHAN_BASE + 0xc8) 
     18965+#define AR_PHY_IQ_ADC_MEAS_3_B0     (AR_CHAN_BASE + 0xcc) 
    1891418966+ 
    1891518967+/* The following registers changed position from AR9300 1.0 to AR9300 2.0 */ 
     
    1892118973+#define AR_PHY_IQ_ADC_MEAS_3_B0_9300_10     (AR_CHAN_BASE + 0xcc + 0x8) 
    1892218974+ 
    18923 +#define AR_PHY_TX_CRC               AR_CHAN_BASE + 0xa0 
    18924 +#define AR_PHY_TST_DAC_CONST        AR_CHAN_BASE + 0xa4 
    18925 +#define AR_PHY_SPUR_REPORT_0        AR_CHAN_BASE + 0xa8 
    18926 +#define AR_PHY_CHAN_INFO_TAB_0      AR_CHAN_BASE + 0x300 
     18975+#define AR_PHY_TX_CRC               (AR_CHAN_BASE + 0xa0) 
     18976+#define AR_PHY_TST_DAC_CONST        (AR_CHAN_BASE + 0xa4) 
     18977+#define AR_PHY_SPUR_REPORT_0        (AR_CHAN_BASE + 0xa8) 
     18978+#define AR_PHY_CHAN_INFO_TAB_0      (AR_CHAN_BASE + 0x300) 
    1892718979+ 
    1892818980+/* 
     
    1904119093+#define AR_MRC_BASE    0x9c00 
    1904219094+ 
    19043 +#define AR_PHY_TIMING_3A       AR_MRC_BASE + 0x0 
    19044 +#define AR_PHY_LDPC_CNTL1      AR_MRC_BASE + 0x4 
    19045 +#define AR_PHY_LDPC_CNTL2      AR_MRC_BASE + 0x8 
    19046 +#define AR_PHY_PILOT_SPUR_MASK AR_MRC_BASE + 0xc 
    19047 +#define AR_PHY_CHAN_SPUR_MASK  AR_MRC_BASE + 0x10 
    19048 +#define AR_PHY_SGI_DELTA       AR_MRC_BASE + 0x14 
    19049 +#define AR_PHY_ML_CNTL_1       AR_MRC_BASE + 0x18 
    19050 +#define AR_PHY_ML_CNTL_2       AR_MRC_BASE + 0x1c 
    19051 +#define AR_PHY_TST_ADC         AR_MRC_BASE + 0x20 
     19095+#define AR_PHY_TIMING_3A       (AR_MRC_BASE + 0x0) 
     19096+#define AR_PHY_LDPC_CNTL1      (AR_MRC_BASE + 0x4) 
     19097+#define AR_PHY_LDPC_CNTL2      (AR_MRC_BASE + 0x8) 
     19098+#define AR_PHY_PILOT_SPUR_MASK (AR_MRC_BASE + 0xc) 
     19099+#define AR_PHY_CHAN_SPUR_MASK  (AR_MRC_BASE + 0x10) 
     19100+#define AR_PHY_SGI_DELTA       (AR_MRC_BASE + 0x14) 
     19101+#define AR_PHY_ML_CNTL_1       (AR_MRC_BASE + 0x18) 
     19102+#define AR_PHY_ML_CNTL_2       (AR_MRC_BASE + 0x1c) 
     19103+#define AR_PHY_TST_ADC         (AR_MRC_BASE + 0x20) 
    1905219104+ 
    1905319105+#define AR_PHY_PILOT_SPUR_MASK_CF_PILOT_MASK_IDX_A              0x00000FE0 
     
    1907819130+#define AR_AGC_BASE    0x9e00 
    1907919131+ 
    19080 +#define AR_PHY_SETTLING         AR_AGC_BASE + 0x0 
    19081 +#define AR_PHY_FORCEMAX_GAINS_0 AR_AGC_BASE + 0x4 
    19082 +#define AR_PHY_GAINS_MINOFF0    AR_AGC_BASE + 0x8 
    19083 +#define AR_PHY_DESIRED_SZ       AR_AGC_BASE + 0xc 
    19084 +#define AR_PHY_FIND_SIG         AR_AGC_BASE + 0x10 
    19085 +#define AR_PHY_AGC              AR_AGC_BASE + 0x14 
    19086 +#define AR_PHY_EXT_ATTEN_CTL_0  AR_AGC_BASE + 0x18 
    19087 +#define AR_PHY_CCA_0            AR_AGC_BASE + 0x1c 
    19088 +#define AR_PHY_EXT_CCA0         AR_AGC_BASE + 0x20 
    19089 +#define AR_PHY_RESTART          AR_AGC_BASE + 0x24 
    19090 +#define AR_PHY_MC_GAIN_CTRL     AR_AGC_BASE + 0x28 
    19091 +#define AR_PHY_EXTCHN_PWRTHR1   AR_AGC_BASE + 0x2c 
    19092 +#define AR_PHY_EXT_CHN_WIN      AR_AGC_BASE + 0x30 
    19093 +#define AR_PHY_20_40_DET_THR    AR_AGC_BASE + 0x34 
    19094 +#define AR_PHY_RIFS_SRCH        AR_AGC_BASE + 0x38 
    19095 +#define AR_PHY_PEAK_DET_CTRL_1  AR_AGC_BASE + 0x3c 
    19096 +#define AR_PHY_PEAK_DET_CTRL_2  AR_AGC_BASE + 0x40 
    19097 +#define AR_PHY_RX_GAIN_BOUNDS_1 AR_AGC_BASE + 0x44 
    19098 +#define AR_PHY_RX_GAIN_BOUNDS_2 AR_AGC_BASE + 0x48 
    19099 +#define AR_PHY_RSSI_0           AR_AGC_BASE + 0x180 
    19100 +#define AR_PHY_SPUR_CCK_REP0    AR_AGC_BASE + 0x184 
    19101 +#define AR_PHY_CCK_DETECT       AR_AGC_BASE + 0x1c0 
    19102 +#define AR_PHY_DAG_CTRLCCK      AR_AGC_BASE + 0x1c4 
    19103 +#define AR_PHY_IQCORR_CTRL_CCK  AR_AGC_BASE + 0x1c8 
    19104 + 
    19105 +#define AR_PHY_CCK_SPUR_MIT     AR_AGC_BASE + 0x1cc 
     19132+#define AR_PHY_SETTLING         (AR_AGC_BASE + 0x0) 
     19133+#define AR_PHY_FORCEMAX_GAINS_0 (AR_AGC_BASE + 0x4) 
     19134+#define AR_PHY_GAINS_MINOFF0    (AR_AGC_BASE + 0x8) 
     19135+#define AR_PHY_DESIRED_SZ       (AR_AGC_BASE + 0xc) 
     19136+#define AR_PHY_FIND_SIG         (AR_AGC_BASE + 0x10) 
     19137+#define AR_PHY_AGC              (AR_AGC_BASE + 0x14) 
     19138+#define AR_PHY_EXT_ATTEN_CTL_0  (AR_AGC_BASE + 0x18) 
     19139+#define AR_PHY_CCA_0            (AR_AGC_BASE + 0x1c) 
     19140+#define AR_PHY_EXT_CCA0         (AR_AGC_BASE + 0x20) 
     19141+#define AR_PHY_RESTART          (AR_AGC_BASE + 0x24) 
     19142+#define AR_PHY_MC_GAIN_CTRL     (AR_AGC_BASE + 0x28) 
     19143+#define AR_PHY_EXTCHN_PWRTHR1   (AR_AGC_BASE + 0x2c) 
     19144+#define AR_PHY_EXT_CHN_WIN      (AR_AGC_BASE + 0x30) 
     19145+#define AR_PHY_20_40_DET_THR    (AR_AGC_BASE + 0x34) 
     19146+#define AR_PHY_RIFS_SRCH        (AR_AGC_BASE + 0x38) 
     19147+#define AR_PHY_PEAK_DET_CTRL_1  (AR_AGC_BASE + 0x3c) 
     19148+#define AR_PHY_PEAK_DET_CTRL_2  (AR_AGC_BASE + 0x40) 
     19149+#define AR_PHY_RX_GAIN_BOUNDS_1 (AR_AGC_BASE + 0x44) 
     19150+#define AR_PHY_RX_GAIN_BOUNDS_2 (AR_AGC_BASE + 0x48) 
     19151+#define AR_PHY_RSSI_0           (AR_AGC_BASE + 0x180) 
     19152+#define AR_PHY_SPUR_CCK_REP0    (AR_AGC_BASE + 0x184) 
     19153+#define AR_PHY_CCK_DETECT       (AR_AGC_BASE + 0x1c0) 
     19154+#define AR_PHY_DAG_CTRLCCK      (AR_AGC_BASE + 0x1c4) 
     19155+#define AR_PHY_IQCORR_CTRL_CCK  (AR_AGC_BASE + 0x1c8) 
     19156+ 
     19157+#define AR_PHY_CCK_SPUR_MIT     (AR_AGC_BASE + 0x1cc) 
    1910619158+#define AR_PHY_CCK_SPUR_MIT_SPUR_RSSI_THR                           0x000001fe 
    1910719159+#define AR_PHY_CCK_SPUR_MIT_SPUR_RSSI_THR_S                                  1 
     
    1911319165+#define AR_PHY_CCK_SPUR_MIT_CCK_SPUR_FREQ_S                                  9 
    1911419166+ 
    19115 +#define AR_PHY_RX_OCGAIN        AR_AGC_BASE + 0x200 
     19167+#define AR_PHY_RX_OCGAIN        (AR_AGC_BASE + 0x200) 
    1911619168+ 
    1911719169+#define AR_PHY_CCA_NOM_VAL_9300_2GHZ          -110 
     
    1921219264+#define AR_SM_BASE     0xa200 
    1921319265+ 
    19214 +#define AR_PHY_D2_CHIP_ID        AR_SM_BASE + 0x0 
    19215 +#define AR_PHY_GEN_CTRL          AR_SM_BASE + 0x4 
    19216 +#define AR_PHY_MODE              AR_SM_BASE + 0x8 
    19217 +#define AR_PHY_ACTIVE            AR_SM_BASE + 0xc 
    19218 +#define AR_PHY_SPUR_MASK_A       AR_SM_BASE + 0x20 
    19219 +#define AR_PHY_SPUR_MASK_B       AR_SM_BASE + 0x24 
    19220 +#define AR_PHY_SPECTRAL_SCAN     AR_SM_BASE + 0x28 
    19221 +#define AR_PHY_RADAR_BW_FILTER   AR_SM_BASE + 0x2c 
    19222 +#define AR_PHY_SEARCH_START_DELAY AR_SM_BASE + 0x30 
    19223 +#define AR_PHY_MAX_RX_LEN        AR_SM_BASE + 0x34 
    19224 +#define AR_PHY_FRAME_CTL         AR_SM_BASE + 0x38 
    19225 +#define AR_PHY_RFBUS_REQ         AR_SM_BASE + 0x3c 
    19226 +#define AR_PHY_RFBUS_GRANT       AR_SM_BASE + 0x40 
    19227 +#define AR_PHY_RIFS              AR_SM_BASE + 0x44 
    19228 +#define AR_PHY_RX_CLR_DELAY      AR_SM_BASE + 0x50 
    19229 +#define AR_PHY_RX_DELAY          AR_SM_BASE + 0x54 
    19230 + 
    19231 +#define AR_PHY_XPA_TIMING_CTL    AR_SM_BASE + 0x64 
    19232 +#define AR_PHY_MISC_PA_CTL       AR_SM_BASE + 0x80 
    19233 +#define AR_PHY_SWITCH_CHAIN_0    AR_SM_BASE + 0x84 
    19234 +#define AR_PHY_SWITCH_COM        AR_SM_BASE + 0x88 
    19235 +#define AR_PHY_SWITCH_COM_2      AR_SM_BASE + 0x8c 
    19236 +#define AR_PHY_RX_CHAINMASK      AR_SM_BASE + 0xa0 
    19237 +#define AR_PHY_CAL_CHAINMASK     AR_SM_BASE + 0xc0 
    19238 +#define AR_PHY_CALMODE           AR_SM_BASE + 0xc8 
    19239 +#define AR_PHY_FCAL_1            AR_SM_BASE + 0xcc 
    19240 +#define AR_PHY_FCAL_2_0          AR_SM_BASE + 0xd0 
    19241 +#define AR_PHY_DFT_TONE_CTL_0    AR_SM_BASE + 0xd4 
    19242 +#define AR_PHY_CL_CAL_CTL        AR_SM_BASE + 0xd8 
    19243 +#define AR_PHY_CL_TAB_0          AR_SM_BASE + 0x100 
    19244 +#define AR_PHY_SYNTH_CONTROL     AR_SM_BASE + 0x140 
    19245 +#define AR_PHY_ADDAC_CLK_SEL     AR_SM_BASE + 0x144 
    19246 +#define AR_PHY_PLL_CTL           AR_SM_BASE + 0x148 
    19247 +#define AR_PHY_ANALOG_SWAP       AR_SM_BASE + 0x14c 
    19248 +#define AR_PHY_ADDAC_PARA_CTL    AR_SM_BASE + 0x150 
    19249 +#define AR_PHY_XPA_CFG           AR_SM_BASE + 0x158 
     19266+#define AR_PHY_D2_CHIP_ID        (AR_SM_BASE + 0x0) 
     19267+#define AR_PHY_GEN_CTRL          (AR_SM_BASE + 0x4) 
     19268+#define AR_PHY_MODE              (AR_SM_BASE + 0x8) 
     19269+#define AR_PHY_ACTIVE            (AR_SM_BASE + 0xc) 
     19270+#define AR_PHY_SPUR_MASK_A       (AR_SM_BASE + 0x20) 
     19271+#define AR_PHY_SPUR_MASK_B       (AR_SM_BASE + 0x24) 
     19272+#define AR_PHY_SPECTRAL_SCAN     (AR_SM_BASE + 0x28) 
     19273+#define AR_PHY_RADAR_BW_FILTER   (AR_SM_BASE + 0x2c) 
     19274+#define AR_PHY_SEARCH_START_DELAY (AR_SM_BASE + 0x30) 
     19275+#define AR_PHY_MAX_RX_LEN        (AR_SM_BASE + 0x34) 
     19276+#define AR_PHY_FRAME_CTL         (AR_SM_BASE + 0x38) 
     19277+#define AR_PHY_RFBUS_REQ         (AR_SM_BASE + 0x3c) 
     19278+#define AR_PHY_RFBUS_GRANT       (AR_SM_BASE + 0x40) 
     19279+#define AR_PHY_RIFS              (AR_SM_BASE + 0x44) 
     19280+#define AR_PHY_RX_CLR_DELAY      (AR_SM_BASE + 0x50) 
     19281+#define AR_PHY_RX_DELAY          (AR_SM_BASE + 0x54) 
     19282+ 
     19283+#define AR_PHY_XPA_TIMING_CTL    (AR_SM_BASE + 0x64) 
     19284+#define AR_PHY_MISC_PA_CTL       (AR_SM_BASE + 0x80) 
     19285+#define AR_PHY_SWITCH_CHAIN_0    (AR_SM_BASE + 0x84) 
     19286+#define AR_PHY_SWITCH_COM        (AR_SM_BASE + 0x88) 
     19287+#define AR_PHY_SWITCH_COM_2      (AR_SM_BASE + 0x8c) 
     19288+#define AR_PHY_RX_CHAINMASK      (AR_SM_BASE + 0xa0) 
     19289+#define AR_PHY_CAL_CHAINMASK     (AR_SM_BASE + 0xc0) 
     19290+#define AR_PHY_CALMODE           (AR_SM_BASE + 0xc8) 
     19291+#define AR_PHY_FCAL_1            (AR_SM_BASE + 0xcc) 
     19292+#define AR_PHY_FCAL_2_0          (AR_SM_BASE + 0xd0) 
     19293+#define AR_PHY_DFT_TONE_CTL_0    (AR_SM_BASE + 0xd4) 
     19294+#define AR_PHY_CL_CAL_CTL        (AR_SM_BASE + 0xd8) 
     19295+#define AR_PHY_CL_TAB_0          (AR_SM_BASE + 0x100) 
     19296+#define AR_PHY_SYNTH_CONTROL     (AR_SM_BASE + 0x140) 
     19297+#define AR_PHY_ADDAC_CLK_SEL     (AR_SM_BASE + 0x144) 
     19298+#define AR_PHY_PLL_CTL           (AR_SM_BASE + 0x148) 
     19299+#define AR_PHY_ANALOG_SWAP       (AR_SM_BASE + 0x14c) 
     19300+#define AR_PHY_ADDAC_PARA_CTL    (AR_SM_BASE + 0x150) 
     19301+#define AR_PHY_XPA_CFG           (AR_SM_BASE + 0x158) 
    1925019302+ 
    1925119303+#define AR_PHY_SPUR_MASK_A_CF_PUNC_MASK_IDX_A           0x0001FC00 
     
    1925419306+#define AR_PHY_SPUR_MASK_A_CF_PUNC_MASK_A_S                     0 
    1925519307+ 
    19256 +#define AR_PHY_TEST              AR_SM_BASE + 0x160 
     19308+#define AR_PHY_TEST              (AR_SM_BASE + 0x160) 
    1925719309+ 
    1925819310+#define AR_PHY_TEST_BBB_OBS_SEL       0x780000 
     
    1926519317+#define AR_PHY_TEST_CHAIN_SEL_S    30 
    1926619318+ 
    19267 +#define AR_PHY_TEST_CTL_STATUS   AR_SM_BASE + 0x164 
     19319+#define AR_PHY_TEST_CTL_STATUS   (AR_SM_BASE + 0x164) 
    1926819320+#define AR_PHY_TEST_CTL_TSTDAC_EN         0x1 
    1926919321+#define AR_PHY_TEST_CTL_TSTDAC_EN_S       0 
     
    1927819330+ 
    1927919331+ 
    19280 +#define AR_PHY_TSTDAC            AR_SM_BASE + 0x168 
    19281 + 
    19282 +#define AR_PHY_CHAN_STATUS       AR_SM_BASE + 0x16c 
    19283 +#define AR_PHY_CHAN_INFO_MEMORY  AR_SM_BASE + 0x170 
    19284 +#define AR_PHY_CHNINFO_NOISEPWR  AR_SM_BASE + 0x174 
    19285 +#define AR_PHY_CHNINFO_GAINDIFF  AR_SM_BASE + 0x178 
    19286 +#define AR_PHY_CHNINFO_FINETIM   AR_SM_BASE + 0x17c 
    19287 +#define AR_PHY_CHAN_INFO_GAIN_0  AR_SM_BASE + 0x180 
    19288 +#define AR_PHY_SCRAMBLER_SEED    AR_SM_BASE + 0x190 
    19289 +#define AR_PHY_CCK_TX_CTRL       AR_SM_BASE + 0x194 
    19290 + 
    19291 +#define AR_PHY_HEAVYCLIP_CTL     AR_SM_BASE + 0x1a4 
    19292 +#define AR_PHY_HEAVYCLIP_20      AR_SM_BASE + 0x1a8 
    19293 +#define AR_PHY_HEAVYCLIP_40      AR_SM_BASE + 0x1ac 
    19294 +#define AR_PHY_ILLEGAL_TXRATE    AR_SM_BASE + 0x1b0 
    19295 + 
    19296 +#define AR_PHY_PWRTX_MAX         AR_SM_BASE + 0x1f0 
    19297 +#define AR_PHY_POWER_TX_SUB      AR_SM_BASE + 0x1f4 
    19298 + 
    19299 +#define AR_PHY_TPC_4_B0          AR_SM_BASE + 0x204 
    19300 +#define AR_PHY_TPC_5_B0          AR_SM_BASE + 0x208 
    19301 +#define AR_PHY_TPC_6_B0          AR_SM_BASE + 0x20c 
    19302 +#define AR_PHY_TPC_11_B0         AR_SM_BASE + 0x220 
    19303 +#define AR_PHY_TPC_18            AR_SM_BASE + 0x23c 
    19304 +#define AR_PHY_TPC_19            AR_SM_BASE + 0x240 
    19305 + 
    19306 +#define AR_PHY_TX_FORCED_GAIN    AR_SM_BASE + 0x258 
    19307 + 
    19308 +#define AR_PHY_PDADC_TAB_0       AR_SM_BASE + 0x280 
    19309 + 
    19310 +#define AR_PHY_TX_IQCAL_CONTROL_1   AR_SM_BASE + 0x448 
    19311 +#define AR_PHY_TX_IQCAL_START       AR_SM_BASE + 0x440 
    19312 +#define AR_PHY_TX_IQCAL_STATUS_B0   AR_SM_BASE + 0x48c 
    19313 +#define AR_PHY_TX_IQCAL_CORR_COEFF_01_B0    AR_SM_BASE + 0x450 
    19314 + 
    19315 +#define AR_PHY_PANIC_WD_STATUS      AR_SM_BASE + 0x5c0 
    19316 +#define AR_PHY_PANIC_WD_CTL_1       AR_SM_BASE + 0x5c4 
    19317 +#define AR_PHY_PANIC_WD_CTL_2       AR_SM_BASE + 0x5c8 
    19318 +#define AR_PHY_BT_CTL               AR_SM_BASE + 0x5cc 
    19319 +#define AR_PHY_ONLY_WARMRESET       AR_SM_BASE + 0x5d0 
    19320 +#define AR_PHY_ONLY_CTL             AR_SM_BASE + 0x5d4 
    19321 +#define AR_PHY_ECO_CTRL             AR_SM_BASE + 0x5dc 
    19322 +#define AR_PHY_BB_THERM_ADC_1       AR_SM_BASE + 0x248 
     19332+#define AR_PHY_TSTDAC            (AR_SM_BASE + 0x168) 
     19333+ 
     19334+#define AR_PHY_CHAN_STATUS       (AR_SM_BASE + 0x16c) 
     19335+#define AR_PHY_CHAN_INFO_MEMORY  (AR_SM_BASE + 0x170) 
     19336+#define AR_PHY_CHNINFO_NOISEPWR  (AR_SM_BASE + 0x174) 
     19337+#define AR_PHY_CHNINFO_GAINDIFF  (AR_SM_BASE + 0x178) 
     19338+#define AR_PHY_CHNINFO_FINETIM   (AR_SM_BASE + 0x17c) 
     19339+#define AR_PHY_CHAN_INFO_GAIN_0  (AR_SM_BASE + 0x180) 
     19340+#define AR_PHY_SCRAMBLER_SEED    (AR_SM_BASE + 0x190) 
     19341+#define AR_PHY_CCK_TX_CTRL       (AR_SM_BASE + 0x194) 
     19342+ 
     19343+#define AR_PHY_HEAVYCLIP_CTL     (AR_SM_BASE + 0x1a4) 
     19344+#define AR_PHY_HEAVYCLIP_20      (AR_SM_BASE + 0x1a8) 
     19345+#define AR_PHY_HEAVYCLIP_40      (AR_SM_BASE + 0x1ac) 
     19346+#define AR_PHY_ILLEGAL_TXRATE    (AR_SM_BASE + 0x1b0) 
     19347+ 
     19348+#define AR_PHY_PWRTX_MAX         (AR_SM_BASE + 0x1f0) 
     19349+#define AR_PHY_POWER_TX_SUB      (AR_SM_BASE + 0x1f4) 
     19350+ 
     19351+#define AR_PHY_TPC_4_B0          (AR_SM_BASE + 0x204) 
     19352+#define AR_PHY_TPC_5_B0          (AR_SM_BASE + 0x208) 
     19353+#define AR_PHY_TPC_6_B0          (AR_SM_BASE + 0x20c) 
     19354+#define AR_PHY_TPC_11_B0         (AR_SM_BASE + 0x220) 
     19355+#define AR_PHY_TPC_18            (AR_SM_BASE + 0x23c) 
     19356+#define AR_PHY_TPC_19            (AR_SM_BASE + 0x240) 
     19357+ 
     19358+#define AR_PHY_TX_FORCED_GAIN    (AR_SM_BASE + 0x258) 
     19359+ 
     19360+#define AR_PHY_PDADC_TAB_0       (AR_SM_BASE + 0x280) 
     19361+ 
     19362+#define AR_PHY_TX_IQCAL_CONTROL_1   (AR_SM_BASE + 0x448) 
     19363+#define AR_PHY_TX_IQCAL_START       (AR_SM_BASE + 0x440) 
     19364+#define AR_PHY_TX_IQCAL_STATUS_B0   (AR_SM_BASE + 0x48c) 
     19365+#define AR_PHY_TX_IQCAL_CORR_COEFF_01_B0    (AR_SM_BASE + 0x450) 
     19366+ 
     19367+#define AR_PHY_PANIC_WD_STATUS      (AR_SM_BASE + 0x5c0) 
     19368+#define AR_PHY_PANIC_WD_CTL_1       (AR_SM_BASE + 0x5c4) 
     19369+#define AR_PHY_PANIC_WD_CTL_2       (AR_SM_BASE + 0x5c8) 
     19370+#define AR_PHY_BT_CTL               (AR_SM_BASE + 0x5cc) 
     19371+#define AR_PHY_ONLY_WARMRESET       (AR_SM_BASE + 0x5d0) 
     19372+#define AR_PHY_ONLY_CTL             (AR_SM_BASE + 0x5d4) 
     19373+#define AR_PHY_ECO_CTRL             (AR_SM_BASE + 0x5dc) 
     19374+#define AR_PHY_BB_THERM_ADC_1       (AR_SM_BASE + 0x248) 
    1932319375+ 
    1932419376+#define AR_PHY_65NM_CH0_SYNTH4      0x1608c 
     
    1950619558+#define AR_CHAN1_BASE  0xa800 
    1950719559+ 
    19508 +#define AR_PHY_EXT_CCA_1            AR_CHAN1_BASE + 0x30 
    19509 +#define AR_PHY_TX_PHASE_RAMP_1      AR_CHAN1_BASE + 0xd0 
    19510 +#define AR_PHY_ADC_GAIN_DC_CORR_1   AR_CHAN1_BASE + 0xd4 
    19511 + 
    19512 +#define AR_PHY_SPUR_REPORT_1        AR_CHAN1_BASE + 0xa8 
    19513 +#define AR_PHY_CHAN_INFO_TAB_1      AR_CHAN1_BASE + 0x300 
    19514 +#define AR_PHY_RX_IQCAL_CORR_B1     AR_CHAN1_BASE + 0xdc 
     19560+#define AR_PHY_EXT_CCA_1            (AR_CHAN1_BASE + 0x30) 
     19561+#define AR_PHY_TX_PHASE_RAMP_1      (AR_CHAN1_BASE + 0xd0) 
     19562+#define AR_PHY_ADC_GAIN_DC_CORR_1   (AR_CHAN1_BASE + 0xd4) 
     19563+ 
     19564+#define AR_PHY_SPUR_REPORT_1        (AR_CHAN1_BASE + 0xa8) 
     19565+#define AR_PHY_CHAN_INFO_TAB_1      (AR_CHAN1_BASE + 0x300) 
     19566+#define AR_PHY_RX_IQCAL_CORR_B1     (AR_CHAN1_BASE + 0xdc) 
    1951519567+ 
    1951619568+/* 
     
    1952519577+#define AR_AGC1_BASE   0xae00 
    1952619578+ 
    19527 +#define AR_PHY_FORCEMAX_GAINS_1      AR_AGC1_BASE + 0x4 
    19528 +#define AR_PHY_EXT_ATTEN_CTL_1       AR_AGC1_BASE + 0x18 
    19529 +#define AR_PHY_CCA_1                 AR_AGC1_BASE + 0x1c 
    19530 +#define AR_PHY_CCA_CTRL_1            AR_AGC1_BASE + 0x20 
    19531 +#define AR_PHY_RSSI_1                AR_AGC1_BASE + 0x180 
    19532 +#define AR_PHY_SPUR_CCK_REP_1        AR_AGC1_BASE + 0x184 
    19533 +#define AR_PHY_RX_OCGAIN_2           AR_AGC1_BASE + 0x200 
     19579+#define AR_PHY_FORCEMAX_GAINS_1      (AR_AGC1_BASE + 0x4) 
     19580+#define AR_PHY_EXT_ATTEN_CTL_1       (AR_AGC1_BASE + 0x18) 
     19581+#define AR_PHY_CCA_1                 (AR_AGC1_BASE + 0x1c) 
     19582+#define AR_PHY_CCA_CTRL_1            (AR_AGC1_BASE + 0x20) 
     19583+#define AR_PHY_RSSI_1                (AR_AGC1_BASE + 0x180) 
     19584+#define AR_PHY_SPUR_CCK_REP_1        (AR_AGC1_BASE + 0x184) 
     19585+#define AR_PHY_RX_OCGAIN_2           (AR_AGC1_BASE + 0x200) 
    1953419586+ 
    1953519587+/* 
     
    1954419596+#define AR_SM1_BASE    0xb200 
    1954519597+ 
    19546 +#define AR_PHY_SWITCH_CHAIN_1    AR_SM1_BASE + 0x84 
    19547 +#define AR_PHY_FCAL_2_1          AR_SM1_BASE + 0xd0 
    19548 +#define AR_PHY_DFT_TONE_CTL_1    AR_SM1_BASE + 0xd4 
    19549 +#define AR_PHY_CL_TAB_1          AR_SM1_BASE + 0x100 
    19550 +#define AR_PHY_CHAN_INFO_GAIN_1  AR_SM1_BASE + 0x180 
    19551 +#define AR_PHY_TPC_4_B1          AR_SM1_BASE + 0x204 
    19552 +#define AR_PHY_TPC_5_B1          AR_SM1_BASE + 0x208 
    19553 +#define AR_PHY_TPC_6_B1          AR_SM1_BASE + 0x20c 
    19554 +#define AR_PHY_TPC_11_B1         AR_SM1_BASE + 0x220 
    19555 +#define AR_PHY_PDADC_TAB_1       AR_SM1_BASE + 0x240 
    19556 +#define AR_PHY_TX_IQCAL_STATUS_B1   AR_SM1_BASE + 0x48c 
    19557 +#define AR_PHY_TX_IQCAL_CORR_COEFF_01_B1    AR_SM1_BASE + 0x450 
     19598+#define AR_PHY_SWITCH_CHAIN_1    (AR_SM1_BASE + 0x84) 
     19599+#define AR_PHY_FCAL_2_1          (AR_SM1_BASE + 0xd0) 
     19600+#define AR_PHY_DFT_TONE_CTL_1    (AR_SM1_BASE + 0xd4) 
     19601+#define AR_PHY_CL_TAB_1          (AR_SM1_BASE + 0x100) 
     19602+#define AR_PHY_CHAN_INFO_GAIN_1  (AR_SM1_BASE + 0x180) 
     19603+#define AR_PHY_TPC_4_B1          (AR_SM1_BASE + 0x204) 
     19604+#define AR_PHY_TPC_5_B1          (AR_SM1_BASE + 0x208) 
     19605+#define AR_PHY_TPC_6_B1          (AR_SM1_BASE + 0x20c) 
     19606+#define AR_PHY_TPC_11_B1         (AR_SM1_BASE + 0x220) 
     19607+#define AR_PHY_PDADC_TAB_1       (AR_SM1_BASE + 0x240) 
     19608+#define AR_PHY_TX_IQCAL_STATUS_B1   (AR_SM1_BASE + 0x48c) 
     19609+#define AR_PHY_TX_IQCAL_CORR_COEFF_01_B1    (AR_SM1_BASE + 0x450) 
    1955819610+ 
    1955919611+/* 
     
    1956219614+#define AR_CHAN2_BASE  0xb800 
    1956319615+ 
    19564 +#define AR_PHY_EXT_CCA_2            AR_CHAN2_BASE + 0x30 
    19565 +#define AR_PHY_TX_PHASE_RAMP_2      AR_CHAN2_BASE + 0xd0 
    19566 +#define AR_PHY_ADC_GAIN_DC_CORR_2   AR_CHAN2_BASE + 0xd4 
    19567 + 
    19568 +#define AR_PHY_SPUR_REPORT_2        AR_CHAN2_BASE + 0xa8 
    19569 +#define AR_PHY_CHAN_INFO_TAB_2      AR_CHAN2_BASE + 0x300 
    19570 +#define AR_PHY_RX_IQCAL_CORR_B2     AR_CHAN2_BASE + 0xdc 
     19616+#define AR_PHY_EXT_CCA_2            (AR_CHAN2_BASE + 0x30) 
     19617+#define AR_PHY_TX_PHASE_RAMP_2      (AR_CHAN2_BASE + 0xd0) 
     19618+#define AR_PHY_ADC_GAIN_DC_CORR_2   (AR_CHAN2_BASE + 0xd4) 
     19619+ 
     19620+#define AR_PHY_SPUR_REPORT_2        (AR_CHAN2_BASE + 0xa8) 
     19621+#define AR_PHY_CHAN_INFO_TAB_2      (AR_CHAN2_BASE + 0x300) 
     19622+#define AR_PHY_RX_IQCAL_CORR_B2     (AR_CHAN2_BASE + 0xdc) 
    1957119623+ 
    1957219624+/* 
     
    1958019632+#define AR_AGC2_BASE   0xbe00 
    1958119633+ 
    19582 +#define AR_PHY_FORCEMAX_GAINS_2      AR_AGC2_BASE + 0x4 
    19583 +#define AR_PHY_EXT_ATTEN_CTL_2       AR_AGC2_BASE + 0x18 
    19584 +#define AR_PHY_CCA_2                 AR_AGC2_BASE + 0x1c 
    19585 +#define AR_PHY_CCA_CTRL_2            AR_AGC2_BASE + 0x20 
    19586 +#define AR_PHY_RSSI_2                AR_AGC2_BASE + 0x180 
     19634+#define AR_PHY_FORCEMAX_GAINS_2      (AR_AGC2_BASE + 0x4) 
     19635+#define AR_PHY_EXT_ATTEN_CTL_2       (AR_AGC2_BASE + 0x18) 
     19636+#define AR_PHY_CCA_2                 (AR_AGC2_BASE + 0x1c) 
     19637+#define AR_PHY_CCA_CTRL_2            (AR_AGC2_BASE + 0x20) 
     19638+#define AR_PHY_RSSI_2                (AR_AGC2_BASE + 0x180) 
    1958719639+ 
    1958819640+/* 
     
    1959719649+#define AR_SM2_BASE    0xc200 
    1959819650+ 
    19599 +#define AR_PHY_SWITCH_CHAIN_2    AR_SM2_BASE + 0x84 
    19600 +#define AR_PHY_FCAL_2_2          AR_SM2_BASE + 0xd0 
    19601 +#define AR_PHY_DFT_TONE_CTL_2    AR_SM2_BASE + 0xd4 
    19602 +#define AR_PHY_CL_TAB_2          AR_SM2_BASE + 0x100 
    19603 +#define AR_PHY_CHAN_INFO_GAIN_2  AR_SM2_BASE + 0x180 
    19604 +#define AR_PHY_TPC_4_B2          AR_SM2_BASE + 0x204 
    19605 +#define AR_PHY_TPC_5_B2          AR_SM2_BASE + 0x208 
    19606 +#define AR_PHY_TPC_6_B2          AR_SM2_BASE + 0x20c 
    19607 +#define AR_PHY_TPC_11_B2         AR_SM2_BASE + 0x220 
    19608 +#define AR_PHY_PDADC_TAB_2       AR_SM2_BASE + 0x240 
    19609 +#define AR_PHY_TX_IQCAL_STATUS_B2   AR_SM2_BASE + 0x48c 
    19610 +#define AR_PHY_TX_IQCAL_CORR_COEFF_01_B2    AR_SM2_BASE + 0x450 
     19651+#define AR_PHY_SWITCH_CHAIN_2    (AR_SM2_BASE + 0x84) 
     19652+#define AR_PHY_FCAL_2_2          (AR_SM2_BASE + 0xd0) 
     19653+#define AR_PHY_DFT_TONE_CTL_2    (AR_SM2_BASE + 0xd4) 
     19654+#define AR_PHY_CL_TAB_2          (AR_SM2_BASE + 0x100) 
     19655+#define AR_PHY_CHAN_INFO_GAIN_2  (AR_SM2_BASE + 0x180) 
     19656+#define AR_PHY_TPC_4_B2          (AR_SM2_BASE + 0x204) 
     19657+#define AR_PHY_TPC_5_B2          (AR_SM2_BASE + 0x208) 
     19658+#define AR_PHY_TPC_6_B2          (AR_SM2_BASE + 0x20c) 
     19659+#define AR_PHY_TPC_11_B2         (AR_SM2_BASE + 0x220) 
     19660+#define AR_PHY_PDADC_TAB_2       (AR_SM2_BASE + 0x240) 
     19661+#define AR_PHY_TX_IQCAL_STATUS_B2   (AR_SM2_BASE + 0x48c) 
     19662+#define AR_PHY_TX_IQCAL_CORR_COEFF_01_B2    (AR_SM2_BASE + 0x450) 
    1961119663+ 
    1961219664+#define AR_PHY_TX_IQCAL_STATUS_B2_FAILED    0x00000001 
     
    1961719669+#define AR_AGC3_BASE   0xce00 
    1961819670+ 
    19619 +#define AR_PHY_RSSI_3            AR_AGC3_BASE + 0x180 
     19671+#define AR_PHY_RSSI_3            (AR_AGC3_BASE + 0x180) 
    1962019672+ 
    1962119673+/* 
     
    2124621298--- /dev/null 
    2124721299+++ b/drivers/net/wireless/ath/ath9k/hw-ops.h 
    21248 @@ -0,0 +1,279 @@ 
     21300@@ -0,0 +1,280 @@ 
    2124921301+/* 
    2125021302+ * Copyright (c) 2010 Atheros Communications Inc. 
     
    2144521497+} 
    2144621498+ 
    21447 +static inline void ath9k_hw_set_rfmode(struct ath_hw *ah, struct ath9k_channel *chan) 
     21499+static inline void ath9k_hw_set_rfmode(struct ath_hw *ah, 
     21500+                                      struct ath9k_channel *chan) 
    2144821501+{ 
    2144921502+       return ath9k_hw_private_ops(ah)->set_rfmode(ah, chan); 
     
    2149021543+ 
    2149121544+static inline bool ath9k_hw_ani_control(struct ath_hw *ah, 
    21492 +                                       enum ath9k_ani_cmd cmd, int param) 
     21545+                                       enum ath9k_ani_cmd cmd, int param) 
    2149321546+{ 
    2149421547+       return ath9k_hw_private_ops(ah)->ani_control(ah, cmd, param); 
     
    2153521588  * Permission to use, copy, modify, and/or distribute this software for any 
    2153621589  * purpose with or without fee is hereby granted, provided that the above 
    21537 @@ -19,15 +19,14 @@ 
     21590@@ -19,15 +19,15 @@ 
    2153821591 #include <asm/unaligned.h> 
    2153921592  
     
    2154221595 #include "rc.h" 
    2154321596-#include "initvals.h" 
     21597+#include "ar9003_mac.h" 
    2154421598  
    2154521599 #define ATH9K_CLOCK_RATE_CCK           22 
     
    2155221606 MODULE_AUTHOR("Atheros Communications"); 
    2155321607 MODULE_DESCRIPTION("Support for Atheros 802.11n wireless LAN cards."); 
    21554 @@ -46,6 +45,37 @@ static void __exit ath9k_exit(void) 
     21608@@ -46,6 +46,39 @@ static void __exit ath9k_exit(void) 
    2155521609 } 
    2155621610 module_exit(ath9k_exit); 
     
    2157021624+static bool ath9k_hw_macversion_supported(struct ath_hw *ah) 
    2157121625+{ 
    21572 +       return ath9k_hw_private_ops(ah)->macversion_supported(ah->hw_version.macVersion); 
     21626+       struct ath_hw_private_ops *priv_ops = ath9k_hw_private_ops(ah); 
     21627+ 
     21628+       return priv_ops->macversion_supported(ah->hw_version.macVersion); 
    2157321629+} 
    2157421630+ 
     
    2159021646 /* Helper Functions */ 
    2159121647 /********************/ 
    21592 @@ -233,21 +263,6 @@ static void ath9k_hw_read_revisions(stru 
     21648@@ -233,21 +266,6 @@ static void ath9k_hw_read_revisions(stru 
    2159321649        } 
    2159421650 } 
     
    2161221668 /* HW Attach, Detach, Init Routines */ 
    2161321669 /************************************/ 
    21614 @@ -270,18 +285,25 @@ static void ath9k_hw_disablepcie(struct  
     21670@@ -270,18 +288,25 @@ static void ath9k_hw_disablepcie(struct  
    2161521671        REG_WRITE(ah, AR_PCIE_SERDES2, 0x00000000); 
    2161621672 } 
     
    2162921685-       int i, j; 
    2163021686+       int i, j, loop_max; 
    21631 + 
     21687  
     21688-       for (i = 0; i < 2; i++) { 
    2163221689+       if (!AR_SREV_9300_20_OR_LATER(ah)) { 
    2163321690+               loop_max = 2; 
     
    2163521692+       } else 
    2163621693+               loop_max = 1; 
    21637   
    21638 -       for (i = 0; i < 2; i++) { 
     21694+ 
    2163921695+       for (i = 0; i < loop_max; i++) { 
    2164021696                u32 addr = regAddr[i]; 
    2164121697                u32 wrData, rdData; 
    2164221698  
    21643 @@ -369,7 +391,6 @@ static void ath9k_hw_init_config(struct  
     21699@@ -336,7 +361,13 @@ static void ath9k_hw_init_config(struct  
     21700        ah->config.ofdm_trig_high = 500; 
     21701        ah->config.cck_trig_high = 200; 
     21702        ah->config.cck_trig_low = 100; 
     21703-       ah->config.enable_ani = 1; 
     21704+ 
     21705+       /* 
     21706+        * For now ANI is disabled for AR9003, it is still 
     21707+        * being tested. 
     21708+        */ 
     21709+       if (!AR_SREV_9300_20_OR_LATER(ah)) 
     21710+               ah->config.enable_ani = 1; 
     21711  
     21712        for (i = 0; i < AR_EEPROM_MODAL_SPURS; i++) { 
     21713                ah->config.spurchans[i][0] = AR_NO_SPUR; 
     21714@@ -369,7 +400,6 @@ static void ath9k_hw_init_config(struct  
    2164421715        if (num_possible_cpus() > 1) 
    2164521716                ah->config.serialize_regmode = SER_REG_MODE_AUTO; 
     
    2164921720 static void ath9k_hw_init_defaults(struct ath_hw *ah) 
    2165021721 { 
    21651 @@ -383,8 +404,6 @@ static void ath9k_hw_init_defaults(struc 
     21722@@ -383,8 +413,6 @@ static void ath9k_hw_init_defaults(struc 
    2165221723        ah->hw_version.subvendorid = 0; 
    2165321724  
     
    2165821729                ah->ah_flags = AH_USE_EEPROM; 
    2165921730  
    21660 @@ -397,44 +416,17 @@ static void ath9k_hw_init_defaults(struc 
     21731@@ -397,44 +425,17 @@ static void ath9k_hw_init_defaults(struc 
    2166121732        ah->power_mode = ATH9K_PM_UNDEFINED; 
    2166221733 } 
     
    2170521776                common->macaddr[2 * i] = eeval >> 8; 
    2170621777                common->macaddr[2 * i + 1] = eeval & 0xff; 
    21707 @@ -445,54 +437,6 @@ static int ath9k_hw_init_macaddr(struct  
     21778@@ -445,54 +446,6 @@ static int ath9k_hw_init_macaddr(struct  
    2170821779        return 0; 
    2170921780 } 
     
    2176021831 { 
    2176121832        int ecode; 
    21762 @@ -502,9 +446,11 @@ static int ath9k_hw_post_init(struct ath 
     21833@@ -502,9 +455,11 @@ static int ath9k_hw_post_init(struct ath 
    2176321834                        return -ENODEV; 
    2176421835        } 
     
    2177521846        ecode = ath9k_hw_eeprom_init(ah); 
    2177621847        if (ecode != 0) 
    21777 @@ -515,14 +461,12 @@ static int ath9k_hw_post_init(struct ath 
     21848@@ -515,14 +470,12 @@ static int ath9k_hw_post_init(struct ath 
    2177821849                  ah->eep_ops->get_eeprom_ver(ah), 
    2177921850                  ah->eep_ops->get_eeprom_rev(ah)); 
     
    2179621867  
    2179721868        if (!AR_SREV_9100(ah)) { 
    21798 @@ -533,344 +477,22 @@ static int ath9k_hw_post_init(struct ath 
     21869@@ -533,344 +486,22 @@ static int ath9k_hw_post_init(struct ath 
    2179921870        return 0; 
    2180021871 } 
     
    2215022221        if (!ath9k_hw_set_reset_reg(ah, ATH9K_RESET_POWER_ON)) { 
    2215122222                ath_print(common, ATH_DBG_FATAL, 
    22152 @@ -878,6 +500,11 @@ int ath9k_hw_init(struct ath_hw *ah) 
     22223@@ -878,6 +509,11 @@ int ath9k_hw_init(struct ath_hw *ah) 
    2215322224                return -EIO; 
    2215422225        } 
     
    2216222233                ath_print(common, ATH_DBG_FATAL, "Couldn't wakeup chip\n"); 
    2216322234                return -EIO; 
    22164 @@ -902,7 +529,7 @@ int ath9k_hw_init(struct ath_hw *ah) 
     22235@@ -902,7 +538,7 @@ int ath9k_hw_init(struct ath_hw *ah) 
    2216522236        else 
    2216622237                ah->config.max_txtrig_level = MAX_TX_FIFO_THRESHOLD; 
     
    2217122242                          "Mac Chip Rev 0x%02x.%x is not supported by " 
    2217222243                          "this driver\n", ah->hw_version.macVersion, 
    22173 @@ -910,28 +537,19 @@ int ath9k_hw_init(struct ath_hw *ah) 
     22244@@ -910,28 +546,15 @@ int ath9k_hw_init(struct ath_hw *ah) 
    2217422245                return -EOPNOTSUPP; 
    2217522246        } 
     
    2219122262        ah->ani_function = ATH9K_ANI_ALL; 
    2219222263-       if (AR_SREV_9280_10_OR_LATER(ah)) { 
    22193 +       if (AR_SREV_9280_10_OR_LATER(ah)) 
     22264+       if (AR_SREV_9280_10_OR_LATER(ah) && !AR_SREV_9300_20_OR_LATER(ah)) 
    2219422265                ah->ani_function &= ~ATH9K_ANI_NOISE_IMMUNITY_LEVEL; 
    2219522266-               ah->ath9k_hw_rf_set_freq = &ath9k_hw_ar9280_set_channel; 
     
    2219922270-               ah->ath9k_hw_spur_mitigate_freq = &ath9k_hw_spur_mitigate; 
    2220022271-       } 
    22201 + 
    22202 +       /* this is still being tested */ 
    22203 +       if (AR_SREV_9300_20_OR_LATER(ah)) 
    22204 +               ah->ani_function = 0; 
    2220522272  
    2220622273        ath9k_hw_init_mode_regs(ah); 
    2220722274  
    22208 @@ -940,15 +558,8 @@ int ath9k_hw_init(struct ath_hw *ah) 
     22275@@ -940,15 +563,8 @@ int ath9k_hw_init(struct ath_hw *ah) 
    2220922276        else 
    2221022277                ath9k_hw_disablepcie(ah); 
     
    2222422291        r = ath9k_hw_post_init(ah); 
    2222522292        if (r) 
    22226 @@ -959,8 +570,6 @@ int ath9k_hw_init(struct ath_hw *ah) 
     22293@@ -959,8 +575,6 @@ int ath9k_hw_init(struct ath_hw *ah) 
    2222722294        if (r) 
    2222822295                return r; 
     
    2223322300        if (r) { 
    2223422301                ath_print(common, ATH_DBG_FATAL, 
    22235 @@ -973,6 +582,9 @@ int ath9k_hw_init(struct ath_hw *ah) 
     22302@@ -973,6 +587,9 @@ int ath9k_hw_init(struct ath_hw *ah) 
    2223622303        else 
    2223722304                ah->tx_trig_level = (AR_FTRIG_512B >> AR_FTRIG_S); 
     
    2224322310  
    2224422311        common->state = ATH_HW_INITIALIZED; 
    22245 @@ -980,21 +592,45 @@ int ath9k_hw_init(struct ath_hw *ah) 
     22312@@ -980,21 +597,45 @@ int ath9k_hw_init(struct ath_hw *ah) 
    2224622313        return 0; 
    2224722314 } 
     
    2229922366 static void ath9k_hw_init_qos(struct ath_hw *ah) 
    2230022367 { 
    22301 @@ -1016,64 +652,8 @@ static void ath9k_hw_init_qos(struct ath 
     22368@@ -1016,64 +657,8 @@ static void ath9k_hw_init_qos(struct ath 
    2230222369 static void ath9k_hw_init_pll(struct ath_hw *ah, 
    2230322370                              struct ath9k_channel *chan) 
    2230422371 { 
    2230522372-       u32 pll; 
    22306 +       u32 pll = ath9k_hw_compute_pll_control(ah, chan); 
    22307   
     22373- 
    2230822374-       if (AR_SREV_9100(ah)) { 
    2230922375-               if (chan && IS_CHAN_5GHZ(chan)) 
     
    2233422400-                               pll |= SM(0x2c, AR_RTC_9160_PLL_DIV); 
    2233522401-                       } 
    22336 - 
     22402+       u32 pll = ath9k_hw_compute_pll_control(ah, chan); 
     22403  
    2233722404-               } else if (AR_SREV_9160_10_OR_LATER(ah)) { 
    2233822405- 
     
    2236522432  
    2236622433        /* Switch the core clock for ar9271 to 117Mhz */ 
    22367 @@ -1087,43 +667,6 @@ static void ath9k_hw_init_pll(struct ath 
     22434@@ -1087,43 +672,6 @@ static void ath9k_hw_init_pll(struct ath 
    2236822435        REG_WRITE(ah, AR_RTC_SLEEP_CLK, AR_RTC_FORCE_DERIVED_CLK); 
    2236922436 } 
     
    2240922476                                          enum nl80211_iftype opmode) 
    2241022477 { 
    22411 @@ -1133,12 +676,24 @@ static void ath9k_hw_init_interrupt_mask 
     22478@@ -1133,12 +681,24 @@ static void ath9k_hw_init_interrupt_mask 
    2241222479                AR_IMR_RXORN | 
    2241322480                AR_IMR_BCNMISC; 
     
    2243922506        if (opmode == NL80211_IFTYPE_AP) 
    2244022507                imr_reg |= AR_IMR_MIB; 
    22441 @@ -1152,6 +707,13 @@ static void ath9k_hw_init_interrupt_mask 
     22508@@ -1152,6 +712,13 @@ static void ath9k_hw_init_interrupt_mask 
    2244222509                REG_WRITE(ah, AR_INTR_SYNC_ENABLE, AR_INTR_SYNC_DEFAULT); 
    2244322510                REG_WRITE(ah, AR_INTR_SYNC_MASK, 0); 
     
    2245322520  
    2245422521 static void ath9k_hw_setslottime(struct ath_hw *ah, u32 us) 
    22455 @@ -1220,305 +782,67 @@ void ath9k_hw_init_global_settings(struc 
    22456          * timeout issues in other cases as well. 
    22457          */ 
    22458         if (conf->channel && conf->channel->band == IEEE80211_BAND_2GHZ) 
     22522@@ -1215,310 +782,72 @@ void ath9k_hw_init_global_settings(struc 
     22523        /* 
     22524         * Workaround for early ACK timeouts, add an offset to match the 
     22525         * initval's 64us ack timeout value. 
     22526-        * This was initially only meant to work around an issue with delayed 
     22527-        * BA frames in some implementations, but it has been found to fix ACK 
     22528-        * timeout issues in other cases as well. 
     22529-        */ 
     22530-       if (conf->channel && conf->channel->band == IEEE80211_BAND_2GHZ) 
    2245922531-               acktimeout += 64 - sifstime - ah->slottime; 
    2246022532- 
     
    2266822740- 
    2266922741-               REG_WRITE(ah, reg, val); 
    22670 +               acktimeout += 64 - sifstime - ah->slottime; 
    22671   
     22742- 
    2267222743-               if (reg >= 0x7800 && reg < 0x78a0 
    2267322744-                   && ah->config.analog_shiftreg) { 
    2267422745-                       udelay(100); 
    2267522746-               } 
     22747- 
     22748-               DO_DELAY(regWrites); 
     22749-       } 
     22750- 
     22751-       if (AR_SREV_9271(ah)) { 
     22752-               if (ah->eep_ops->get_eeprom(ah, EEP_TXGAIN_TYPE) == 1) 
     22753-                       REG_WRITE_ARRAY(&ah->iniModes_high_power_tx_gain_9271, 
     22754-                                       modesIndex, regWrites); 
     22755-               else 
     22756-                       REG_WRITE_ARRAY(&ah->iniModes_normal_power_tx_gain_9271, 
     22757-                                       modesIndex, regWrites); 
     22758-       } 
     22759- 
     22760-       ath9k_hw_write_regs(ah, freqIndex, regWrites); 
     22761+        * This was initially only meant to work around an issue with delayed 
     22762+        * BA frames in some implementations, but it has been found to fix ACK 
     22763+        * timeout issues in other cases as well. 
     22764+        */ 
     22765+       if (conf->channel && conf->channel->band == IEEE80211_BAND_2GHZ) 
     22766+               acktimeout += 64 - sifstime - ah->slottime; 
     22767  
     22768-       if (AR_SREV_9280_20(ah) && IS_CHAN_A_5MHZ_SPACED(chan)) { 
     22769-               REG_WRITE_ARRAY(&ah->iniModesAdditional, modesIndex, 
     22770-                               regWrites); 
     22771-       } 
    2267622772+       ath9k_hw_setslottime(ah, slottime); 
    2267722773+       ath9k_hw_set_ack_timeout(ah, acktimeout); 
     
    2268222778+EXPORT_SYMBOL(ath9k_hw_init_global_settings); 
    2268322779  
    22684 -               DO_DELAY(regWrites); 
    22685 -       } 
     22780-       ath9k_hw_override_ini(ah, chan); 
     22781-       ath9k_hw_set_regs(ah, chan); 
     22782-       ath9k_hw_init_chain_masks(ah); 
    2268622783+void ath9k_hw_deinit(struct ath_hw *ah) 
    2268722784+{ 
    2268822785+       struct ath_common *common = ath9k_hw_common(ah); 
    2268922786  
    22690 -       if (AR_SREV_9271(ah)) { 
    22691 -               if (ah->eep_ops->get_eeprom(ah, EEP_TXGAIN_TYPE) == 1) 
    22692 -                       REG_WRITE_ARRAY(&ah->iniModes_high_power_tx_gain_9271, 
    22693 -                                       modesIndex, regWrites); 
    22694 -               else 
    22695 -                       REG_WRITE_ARRAY(&ah->iniModes_normal_power_tx_gain_9271, 
    22696 -                                       modesIndex, regWrites); 
    22697 -       } 
     22787-       if (OLC_FOR_AR9280_20_LATER) 
     22788-               ath9k_olc_init(ah); 
    2269822789+       if (common->state < ATH_HW_INITIALIZED) 
    2269922790+               goto free_hw; 
    22700   
    22701 -       ath9k_hw_write_regs(ah, freqIndex, regWrites); 
    22702 +       if (!AR_SREV_9100(ah)) 
    22703 +               ath9k_hw_ani_disable(ah); 
    22704   
    22705 -       if (AR_SREV_9280_20(ah) && IS_CHAN_A_5MHZ_SPACED(chan)) { 
    22706 -               REG_WRITE_ARRAY(&ah->iniModesAdditional, modesIndex, 
    22707 -                               regWrites); 
    22708 -       } 
    22709 +       ath9k_hw_setpower(ah, ATH9K_PM_FULL_SLEEP); 
    22710   
    22711 -       ath9k_hw_override_ini(ah, chan); 
    22712 -       ath9k_hw_set_regs(ah, chan); 
    22713 -       ath9k_hw_init_chain_masks(ah); 
    22714 +free_hw: 
    22715 +       ath9k_hw_rf_free_ext_banks(ah); 
    22716 +} 
    22717 +EXPORT_SYMBOL(ath9k_hw_deinit); 
    22718   
    22719 -       if (OLC_FOR_AR9280_20_LATER) 
    22720 -               ath9k_olc_init(ah); 
    22721 +/*******/ 
    22722 +/* INI */ 
    22723 +/*******/ 
    2272422791  
    2272522792-       /* Set TX power */ 
     
    2273022797-                                min((u32) MAX_RATE_POWER, 
    2273122798-                                (u32) regulatory->power_limit)); 
    22732 +u32 ath9k_regd_get_ctl(struct ath_regulatory *reg, struct ath9k_channel *chan) 
    22733 +{ 
    22734 +       u32 ctl = ath_regd_get_band_ctl(reg, chan->chan->band); 
     22799+       if (!AR_SREV_9100(ah)) 
     22800+               ath9k_hw_ani_disable(ah); 
    2273522801  
    2273622802-       /* Write analog registers */ 
     
    2274022806-               return -EIO; 
    2274122807-       } 
     22808+       ath9k_hw_setpower(ah, ATH9K_PM_FULL_SLEEP); 
     22809  
     22810-       return 0; 
     22811+free_hw: 
     22812+       ath9k_hw_rf_free_ext_banks(ah); 
     22813 } 
     22814+EXPORT_SYMBOL(ath9k_hw_deinit); 
     22815  
     22816-/****************************************/ 
     22817-/* Reset and Channel Switching Routines */ 
     22818-/****************************************/ 
     22819+/*******/ 
     22820+/* INI */ 
     22821+/*******/ 
     22822  
     22823-static void ath9k_hw_set_rfmode(struct ath_hw *ah, struct ath9k_channel *chan) 
     22824+u32 ath9k_regd_get_ctl(struct ath_regulatory *reg, struct ath9k_channel *chan) 
     22825 { 
     22826-       u32 rfMode = 0; 
     22827- 
     22828-       if (chan == NULL) 
     22829-               return; 
     22830- 
     22831-       rfMode |= (IS_CHAN_B(chan) || IS_CHAN_G(chan)) 
     22832-               ? AR_PHY_MODE_DYNAMIC : AR_PHY_MODE_OFDM; 
     22833- 
     22834-       if (!AR_SREV_9280_10_OR_LATER(ah)) 
     22835-               rfMode |= (IS_CHAN_5GHZ(chan)) ? 
     22836-                       AR_PHY_MODE_RF5GHZ : AR_PHY_MODE_RF2GHZ; 
     22837+       u32 ctl = ath_regd_get_band_ctl(reg, chan->chan->band); 
     22838  
     22839-       if (AR_SREV_9280_20(ah) && IS_CHAN_A_5MHZ_SPACED(chan)) 
     22840-               rfMode |= (AR_PHY_MODE_DYNAMIC | AR_PHY_MODE_DYN_CCK_DISABLE); 
    2274222841+       if (IS_CHAN_B(chan)) 
    2274322842+               ctl |= CTL_11B; 
     
    2274722846+               ctl |= CTL_11A; 
    2274822847  
    22749 -       return 0; 
     22848-       REG_WRITE(ah, AR_PHY_MODE, rfMode); 
    2275022849+       return ctl; 
    2275122850 } 
    2275222851  
    22753  /****************************************/ 
    22754  /* Reset and Channel Switching Routines */ 
    22755  /****************************************/ 
    22756   
    22757 -static void ath9k_hw_set_rfmode(struct ath_hw *ah, struct ath9k_channel *chan) 
    22758 -{ 
    22759 -       u32 rfMode = 0; 
    22760 - 
    22761 -       if (chan == NULL) 
    22762 -               return; 
    22763 - 
    22764 -       rfMode |= (IS_CHAN_B(chan) || IS_CHAN_G(chan)) 
    22765 -               ? AR_PHY_MODE_DYNAMIC : AR_PHY_MODE_OFDM; 
    22766 - 
    22767 -       if (!AR_SREV_9280_10_OR_LATER(ah)) 
    22768 -               rfMode |= (IS_CHAN_5GHZ(chan)) ? 
    22769 -                       AR_PHY_MODE_RF5GHZ : AR_PHY_MODE_RF2GHZ; 
    22770 - 
    22771 -       if (AR_SREV_9280_20(ah) && IS_CHAN_A_5MHZ_SPACED(chan)) 
    22772 -               rfMode |= (AR_PHY_MODE_DYNAMIC | AR_PHY_MODE_DYN_CCK_DISABLE); 
    22773 - 
    22774 -       REG_WRITE(ah, AR_PHY_MODE, rfMode); 
    22775 -} 
    22776 - 
    2277722852-static void ath9k_hw_mark_phy_inactive(struct ath_hw *ah) 
    2277822853-{ 
    2277922854-       REG_WRITE(ah, AR_PHY_ACTIVE, AR_PHY_ACTIVE_DIS); 
    2278022855-} 
    22781 - 
     22856+/****************************************/ 
     22857+/* Reset and Channel Switching Routines */ 
     22858+/****************************************/ 
     22859  
    2278222860 static inline void ath9k_hw_set_dma(struct ath_hw *ah) 
    2278322861 { 
     
    2279722875        /* 
    2279822876         * let mac dma reads be in 128 byte chunks 
    22799 @@ -1531,7 +855,8 @@ static inline void ath9k_hw_set_dma(stru 
     22877@@ -1531,7 +860,8 @@ static inline void ath9k_hw_set_dma(stru 
    2280022878         * The initial value depends on whether aggregation is enabled, and is 
    2280122879         * adjusted whenever underruns are detected. 
     
    2280722885        /* 
    2280822886         * let mac dma writes be in 128 byte chunks 
    22809 @@ -1544,6 +869,14 @@ static inline void ath9k_hw_set_dma(stru 
     22887@@ -1544,6 +874,14 @@ static inline void ath9k_hw_set_dma(stru 
    2281022888         */ 
    2281122889        REG_WRITE(ah, AR_RXFIFO_CFG, 0x200); 
     
    2282222900         * reduce the number of usable entries in PCU TXBUF to avoid 
    2282322901         * wrap around issues. 
    22824 @@ -1559,6 +892,9 @@ static inline void ath9k_hw_set_dma(stru 
     22902@@ -1559,6 +897,9 @@ static inline void ath9k_hw_set_dma(stru 
    2282522903                REG_WRITE(ah, AR_PCU_TXBUF_CTRL, 
    2282622904                          AR_PCU_TXBUF_CTRL_USABLE_SIZE); 
     
    2283222910  
    2283322911 static void ath9k_hw_set_operating_mode(struct ath_hw *ah, int opmode) 
    22834 @@ -1586,10 +922,8 @@ static void ath9k_hw_set_operating_mode( 
     22912@@ -1586,10 +927,8 @@ static void ath9k_hw_set_operating_mode( 
    2283522913        } 
    2283622914 } 
     
    2284522923        u32 coef_exp, coef_man; 
    2284622924  
    22847 @@ -1605,40 +939,6 @@ static inline void ath9k_hw_get_delta_sl 
     22925@@ -1605,40 +944,6 @@ static inline void ath9k_hw_get_delta_sl 
    2284822926        *coef_exponent = coef_exp - 16; 
    2284922927 } 
     
    2288622964 { 
    2288722965        u32 rst_flags; 
    22888 @@ -1663,11 +963,16 @@ static bool ath9k_hw_set_reset(struct at 
     22966@@ -1663,11 +968,16 @@ static bool ath9k_hw_set_reset(struct at 
    2288922967                if (tmpReg & 
    2289022968                    (AR_INTR_SYNC_LOCAL_TIMEOUT | 
     
    2290622984                rst_flags = AR_RTC_RC_MAC_WARM; 
    2290722985                if (type == ATH9K_RESET_COLD) 
    22908 @@ -1698,13 +1003,15 @@ static bool ath9k_hw_set_reset_power_on( 
     22986@@ -1698,13 +1008,15 @@ static bool ath9k_hw_set_reset_power_on( 
    2290922987        REG_WRITE(ah, AR_RTC_FORCE_WAKE, AR_RTC_FORCE_WAKE_EN | 
    2291022988                  AR_RTC_FORCE_WAKE_ON_INT); 
     
    2292523003  
    2292623004        REG_WRITE(ah, AR_RTC_RESET, 1); 
    22927 @@ -1740,34 +1047,6 @@ static bool ath9k_hw_set_reset_reg(struc 
     23005@@ -1740,34 +1052,6 @@ static bool ath9k_hw_set_reset_reg(struc 
    2292823006        } 
    2292923007 } 
     
    2296023038                                struct ath9k_channel *chan) 
    2296123039 { 
    22962 @@ -1793,7 +1072,7 @@ static bool ath9k_hw_channel_change(stru 
     23040@@ -1793,7 +1077,7 @@ static bool ath9k_hw_channel_change(stru 
    2296323041        struct ath_regulatory *regulatory = ath9k_hw_regulatory(ah); 
    2296423042        struct ath_common *common = ath9k_hw_common(ah); 
     
    2296923047  
    2297023048        for (qnum = 0; qnum < AR_NUM_QCU; qnum++) { 
    22971 @@ -1805,17 +1084,15 @@ static bool ath9k_hw_channel_change(stru 
     23049@@ -1805,17 +1089,15 @@ static bool ath9k_hw_channel_change(stru 
    2297223050                } 
    2297323051        } 
     
    2299023068                ath_print(common, ATH_DBG_FATAL, 
    2299123069                          "Failed to set channel\n"); 
    22992 @@ -1829,20 +1106,12 @@ static bool ath9k_hw_channel_change(stru 
     23070@@ -1829,20 +1111,12 @@ static bool ath9k_hw_channel_change(stru 
    2299323071                             min((u32) MAX_RATE_POWER, 
    2299423072                             (u32) regulatory->power_limit)); 
     
    2301323091        if (!chan->oneTimeCalsDone) 
    2301423092                chan->oneTimeCalsDone = true; 
    23015 @@ -1850,18 +1119,6 @@ static bool ath9k_hw_channel_change(stru 
     23093@@ -1850,18 +1124,6 @@ static bool ath9k_hw_channel_change(stru 
    2301623094        return true; 
    2301723095 } 
     
    2303223110                    bool bChannelChange) 
    2303323111 { 
    23034 @@ -1871,11 +1128,18 @@ int ath9k_hw_reset(struct ath_hw *ah, st 
     23112@@ -1871,11 +1133,18 @@ int ath9k_hw_reset(struct ath_hw *ah, st 
    2303523113        u32 saveDefAntenna; 
    2303623114        u32 macStaId1; 
     
    2305223130                return -EIO; 
    2305323131  
    23054 @@ -1943,16 +1207,6 @@ int ath9k_hw_reset(struct ath_hw *ah, st 
     23132@@ -1943,16 +1212,6 @@ int ath9k_hw_reset(struct ath_hw *ah, st 
    2305523133        if (AR_SREV_9280_10_OR_LATER(ah)) 
    2305623134                REG_SET_BIT(ah, AR_GPIO_INPUT_EN_VAL, AR_GPIO_JTAG_DISABLE); 
     
    2306923147        if (r) 
    2307023148                return r; 
    23071 @@ -1977,7 +1231,7 @@ int ath9k_hw_reset(struct ath_hw *ah, st 
     23149@@ -1977,7 +1236,7 @@ int ath9k_hw_reset(struct ath_hw *ah, st 
    2307223150        if (IS_CHAN_OFDM(chan) || IS_CHAN_HT(chan)) 
    2307323151                ath9k_hw_set_delta_slope(ah, chan); 
     
    2307823156  
    2307923157        REG_WRITE(ah, AR_STA_ID0, get_unaligned_le32(common->macaddr)); 
    23080 @@ -1999,7 +1253,7 @@ int ath9k_hw_reset(struct ath_hw *ah, st 
     23158@@ -1999,7 +1258,7 @@ int ath9k_hw_reset(struct ath_hw *ah, st 
    2308123159  
    2308223160        REG_WRITE(ah, AR_RSSI_THR, INIT_RSSI_THR); 
     
    2308723165                return r; 
    2308823166  
    23089 @@ -2018,25 +1272,9 @@ int ath9k_hw_reset(struct ath_hw *ah, st 
     23167@@ -2018,25 +1277,9 @@ int ath9k_hw_reset(struct ath_hw *ah, st 
    2309023168  
    2309123169        ath9k_hw_init_global_settings(ah); 
     
    2311623194  
    2311723195        REG_WRITE(ah, AR_STA_ID1, 
    23118 @@ -2051,17 +1289,17 @@ int ath9k_hw_reset(struct ath_hw *ah, st 
     23196@@ -2051,17 +1294,17 @@ int ath9k_hw_reset(struct ath_hw *ah, st 
    2311923197                REG_RMW_FIELD(ah, AR_RIMT, AR_RIMT_FIRST, 2000); 
    2312023198        } 
     
    2314023218  
    2314123219        /* 
    23142 @@ -2093,6 +1331,11 @@ int ath9k_hw_reset(struct ath_hw *ah, st 
     23220@@ -2093,6 +1336,11 @@ int ath9k_hw_reset(struct ath_hw *ah, st 
    2314323221        if (ah->btcoex_hw.enabled) 
    2314423222                ath9k_hw_btcoex_enable(ah); 
     
    2315223230 } 
    2315323231 EXPORT_SYMBOL(ath9k_hw_reset); 
    23154 @@ -2379,21 +1622,32 @@ EXPORT_SYMBOL(ath9k_hw_keyisvalid); 
     23232@@ -2379,21 +1627,35 @@ EXPORT_SYMBOL(ath9k_hw_keyisvalid); 
    2315523233 /* Power Management (Chipset) */ 
    2315623234 /******************************/ 
     
    2316423242        REG_SET_BIT(ah, AR_STA_ID1, AR_STA_ID1_PWR_SAV); 
    2316523243        if (setChip) { 
    23166 +               /* Clear the RTC force wake bit to allow the mac to go to sleep */ 
     23244+               /* 
     23245+                * Clear the RTC force wake bit to allow the 
     23246+                * mac to go to sleep. 
     23247+                */ 
    2316723248                REG_CLR_BIT(ah, AR_RTC_FORCE_WAKE, 
    2316823249                            AR_RTC_FORCE_WAKE_EN); 
     
    2318623267 { 
    2318723268        REG_SET_BIT(ah, AR_STA_ID1, AR_STA_ID1_PWR_SAV); 
    23188 @@ -2401,9 +1655,14 @@ static void ath9k_set_power_network_slee 
     23269@@ -2401,9 +1663,14 @@ static void ath9k_set_power_network_slee 
    2318923270                struct ath9k_hw_capabilities *pCap = &ah->caps; 
    2319023271  
     
    2320123282                                    AR_RTC_FORCE_WAKE_EN); 
    2320223283                } 
    23203 @@ -2422,7 +1681,8 @@ static bool ath9k_hw_set_power_awake(str 
     23284@@ -2422,7 +1689,8 @@ static bool ath9k_hw_set_power_awake(str 
    2320423285                                           ATH9K_RESET_POWER_ON) != true) { 
    2320523286                                return false; 
     
    2321123292                if (AR_SREV_9100(ah)) 
    2321223293                        REG_SET_BIT(ah, AR_RTC_RESET, 
    23213 @@ -2492,420 +1752,6 @@ bool ath9k_hw_setpower(struct ath_hw *ah 
     23294@@ -2492,420 +1760,6 @@ bool ath9k_hw_setpower(struct ath_hw *ah 
    2321423295 } 
    2321523296 EXPORT_SYMBOL(ath9k_hw_setpower); 
     
    2363223713 /* Beacon Handling */ 
    2363323714 /*******************/ 
    23634 @@ -3241,6 +2087,20 @@ int ath9k_hw_fill_cap_info(struct ath_hw 
     23715@@ -3241,6 +2095,20 @@ int ath9k_hw_fill_cap_info(struct ath_hw 
    2363523716                btcoex_hw->scheme = ATH_BTCOEX_CFG_NONE; 
    2363623717        } 
     
    2365323734 } 
    2365423735  
    23655 @@ -3273,10 +2133,6 @@ bool ath9k_hw_getcapability(struct ath_h 
     23736@@ -3273,10 +2141,6 @@ bool ath9k_hw_getcapability(struct ath_h 
    2365623737        case ATH9K_CAP_TKIP_SPLIT: 
    2365723738                return (ah->misc_mode & AR_PCU_MIC_NEW_LOC_ENA) ? 
     
    2366423745                switch (capability) { 
    2366523746                case 0: 
    23666 @@ -3319,8 +2175,6 @@ EXPORT_SYMBOL(ath9k_hw_getcapability); 
     23747@@ -3319,8 +2183,6 @@ EXPORT_SYMBOL(ath9k_hw_getcapability); 
    2366723748 bool ath9k_hw_setcapability(struct ath_hw *ah, enum ath9k_capability_type type, 
    2366823749                            u32 capability, u32 setting, int *status) 
     
    2367323754        case ATH9K_CAP_TKIP_MIC: 
    2367423755                if (setting) 
    23675 @@ -3330,14 +2184,6 @@ bool ath9k_hw_setcapability(struct ath_h 
     23756@@ -3330,14 +2192,6 @@ bool ath9k_hw_setcapability(struct ath_h 
    2367623757                        ah->sta_id1_defaults &= 
    2367723758                                ~AR_STA_ID1_CRPT_MIC_ENABLE; 
     
    2368823769                if (setting) 
    2368923770                        ah->sta_id1_defaults |= AR_STA_ID1_MCAST_KSRCH; 
    23690 @@ -3405,7 +2251,9 @@ u32 ath9k_hw_gpio_get(struct ath_hw *ah, 
     23771@@ -3405,7 +2259,9 @@ u32 ath9k_hw_gpio_get(struct ath_hw *ah, 
    2369123772        if (gpio >= ah->caps.num_gpio_pins) 
    2369223773                return 0xffffffff; 
     
    2369923780        else if (AR_SREV_9287_10_OR_LATER(ah)) 
    2370023781                return MS_REG_READ(AR9287, gpio) != 0; 
    23701 @@ -3847,6 +2695,7 @@ static struct { 
     23782@@ -3847,6 +2703,7 @@ static struct { 
    2370223783        { AR_SREV_VERSION_9285,         "9285" }, 
    2370323784        { AR_SREV_VERSION_9287,         "9287" }, 
     
    2371623797  * Permission to use, copy, modify, and/or distribute this software for any 
    2371723798  * purpose with or without fee is hereby granted, provided that the above 
    23718 @@ -28,6 +28,7 @@ 
    23719  #include "reg.h" 
    23720  #include "phy.h" 
    23721  #include "btcoex.h" 
    23722 +#include "ar9003_mac.h" 
    23723   
    23724  #include "../regd.h" 
    23725  #include "../debug.h" 
    23726 @@ -41,6 +42,9 @@ 
     23799@@ -41,6 +41,9 @@ 
    2372723800 #define AR9280_DEVID_PCIE      0x002a 
    2372823801 #define AR9285_DEVID_PCIE      0x002b 
     
    2373423807 #define AR5416_AR9100_DEVID    0x000b 
    2373523808  
    23736 @@ -48,9 +52,6 @@ 
     23809@@ -48,9 +51,6 @@ 
    2373723810 #define AR_SUBVENDOR_ID_NEW_A  0x7065 
    2373823811 #define AR5416_MAGIC           0x19641014 
     
    2374423817 #define AT9285_COEX3WIRE_SA_SUBSYSID   0x30aa 
    2374523818 #define AT9285_COEX3WIRE_DA_SUBSYSID   0x30ab 
    23746 @@ -75,6 +76,8 @@ 
     23819@@ -75,6 +75,8 @@ 
    2374723820 #define REG_RMW_FIELD(_a, _r, _f, _v) \ 
    2374823821        REG_WRITE(_a, _r, \ 
     
    2375323826        REG_WRITE(_a, _r, REG_READ(_a, _r) | _f) 
    2375423827 #define REG_CLR_BIT(_a, _r, _f) \ 
    23755 @@ -135,6 +138,16 @@ 
     23828@@ -135,6 +137,16 @@ 
    2375623829  
    2375723830 #define TU_TO_USEC(_tu)             ((_tu) << 10) 
     
    2377023843        ATH9K_MODE_11A = 0, 
    2377123844        ATH9K_MODE_11G, 
    23772 @@ -165,13 +178,15 @@ enum ath9k_hw_caps { 
     23845@@ -165,13 +177,15 @@ enum ath9k_hw_caps { 
    2377323846        ATH9K_HW_CAP_ENHANCEDPM                 = BIT(14), 
    2377423847        ATH9K_HW_CAP_AUTOSLEEP                  = BIT(15), 
     
    2378723860        ATH9K_CAP_MCAST_KEYSRCH, 
    2378823861        ATH9K_CAP_DS 
    23789 @@ -192,6 +207,11 @@ struct ath9k_hw_capabilities { 
     23862@@ -192,6 +206,11 @@ struct ath9k_hw_capabilities { 
    2379023863        u8 num_gpio_pins; 
    2379123864        u8 num_antcfg_2ghz; 
     
    2379923872  
    2380023873 struct ath9k_ops_config { 
    23801 @@ -212,6 +232,7 @@ struct ath9k_ops_config { 
     23874@@ -212,6 +231,7 @@ struct ath9k_ops_config { 
    2380223875        u32 enable_ani; 
    2380323876        int serialize_regmode; 
     
    2380723880 #define SPUR_ENABLE_IOCTL      1 
    2380823881 #define SPUR_ENABLE_EEPROM     2 
    23809 @@ -231,6 +252,8 @@ struct ath9k_ops_config { 
     23882@@ -231,6 +251,8 @@ struct ath9k_ops_config { 
    2381023883 enum ath9k_int { 
    2381123884        ATH9K_INT_RX = 0x00000001, 
     
    2381623889        ATH9K_INT_RXEOL = 0x00000010, 
    2381723890        ATH9K_INT_RXORN = 0x00000020, 
    23818 @@ -440,6 +463,124 @@ struct ath_gen_timer_table { 
     23891@@ -363,6 +385,12 @@ enum ser_reg_mode { 
     23892        SER_REG_MODE_AUTO = 2, 
     23893 }; 
     23894  
     23895+enum ath9k_rx_qtype { 
     23896+       ATH9K_RX_QUEUE_HP, 
     23897+       ATH9K_RX_QUEUE_LP, 
     23898+       ATH9K_RX_QUEUE_MAX, 
     23899+}; 
     23900+ 
     23901 struct ath9k_beacon_state { 
     23902        u32 bs_nexttbtt; 
     23903        u32 bs_nextdtim; 
     23904@@ -440,6 +468,124 @@ struct ath_gen_timer_table { 
    2381923905        } timer_mask; 
    2382023906 }; 
     
    2394124027        struct ieee80211_hw *hw; 
    2394224028        struct ath_common common; 
    23943 @@ -453,14 +594,18 @@ struct ath_hw { 
     24029@@ -453,14 +599,18 @@ struct ath_hw { 
    2394424030                struct ar5416_eeprom_def def; 
    2394524031                struct ar5416_eeprom_4k map4k; 
     
    2396124047        u32 rfkill_gpio; 
    2396224048        u32 rfkill_polarity; 
    23963 @@ -493,6 +638,7 @@ struct ath_hw { 
     24049@@ -493,6 +643,7 @@ struct ath_hw { 
    2396424050        struct ath9k_cal_list adcgain_caldata; 
    2396524051        struct ath9k_cal_list adcdc_calinitdata; 
     
    2396924055        struct ath9k_cal_list *cal_list_last; 
    2397024056        struct ath9k_cal_list *cal_list_curr; 
    23971 @@ -533,12 +679,10 @@ struct ath_hw { 
     24057@@ -533,12 +684,10 @@ struct ath_hw { 
    2397224058                DONT_USE_32KHZ, 
    2397324059        } enable_32kHz_clock; 
     
    2398624072        /* Used to program the radio on non single-chip devices */ 
    2398724073        u32 *analogBank0Data; 
    23988 @@ -592,6 +736,7 @@ struct ath_hw { 
     24074@@ -592,6 +741,7 @@ struct ath_hw { 
    2398924075        struct ar5416IniArray iniBank7; 
    2399024076        struct ar5416IniArray iniAddac; 
     
    2399424080        struct ar5416IniArray iniModesRxGain; 
    2399524081        struct ar5416IniArray iniModesTxGain; 
    23996 @@ -604,9 +749,21 @@ struct ath_hw { 
     24082@@ -604,9 +754,21 @@ struct ath_hw { 
    2399724083        struct ar5416IniArray iniModes_high_power_tx_gain_9271; 
    2399824084        struct ar5416IniArray iniModes_normal_power_tx_gain_9271; 
     
    2401624102  
    2401724103 static inline struct ath_common *ath9k_hw_common(struct ath_hw *ah) 
    24018 @@ -619,6 +776,16 @@ static inline struct ath_regulatory *ath 
     24104@@ -619,6 +781,16 @@ static inline struct ath_regulatory *ath 
    2401924105        return &(ath9k_hw_common(ah)->regulatory); 
    2402024106 } 
     
    2403324119 const char *ath9k_hw_probe(u16 vendorid, u16 devid); 
    2403424120 void ath9k_hw_deinit(struct ath_hw *ah); 
    24035 @@ -630,6 +797,7 @@ bool ath9k_hw_getcapability(struct ath_h 
     24121@@ -630,6 +802,7 @@ bool ath9k_hw_getcapability(struct ath_h 
    2403624122                            u32 capability, u32 *result); 
    2403724123 bool ath9k_hw_setcapability(struct ath_hw *ah, enum ath9k_capability_type type, 
     
    2404124127 /* Key Cache Management */ 
    2404224128 bool ath9k_hw_keyreset(struct ath_hw *ah, u16 entry); 
    24043 @@ -681,13 +849,6 @@ void ath9k_hw_set_sta_beacon_timers(stru 
     24129@@ -681,13 +854,6 @@ void ath9k_hw_set_sta_beacon_timers(stru 
    2404424130  
    2404524131 bool ath9k_hw_setpower(struct ath_hw *ah, enum ath9k_power_mode mode); 
     
    2405524141 struct ath_gen_timer *ath_gen_timer_alloc(struct ath_hw *ah, 
    2405624142                                          void (*trigger)(void *), 
    24057 @@ -709,6 +870,36 @@ void ath9k_hw_name(struct ath_hw *ah, ch 
     24143@@ -709,6 +875,36 @@ void ath9k_hw_name(struct ath_hw *ah, ch 
    2405824144 /* HTC */ 
    2405924145 void ath9k_hw_htc_resetinit(struct ath_hw *ah); 
     
    3173831824                ah->txok_interrupt_mask |= 1 << q; 
    3173931825        else 
    31740 @@ -999,12 +745,6 @@ void ath9k_hw_putrxbuf(struct ath_hw *ah 
     31826@@ -940,22 +686,6 @@ int ath9k_hw_rxprocdesc(struct ath_hw *a 
     31827 } 
     31828 EXPORT_SYMBOL(ath9k_hw_rxprocdesc); 
     31829  
     31830-void ath9k_hw_setuprxdesc(struct ath_hw *ah, struct ath_desc *ds, 
     31831-                         u32 size, u32 flags) 
     31832-{ 
     31833-       struct ar5416_desc *ads = AR5416DESC(ds); 
     31834-       struct ath9k_hw_capabilities *pCap = &ah->caps; 
     31835- 
     31836-       ads->ds_ctl1 = size & AR_BufLen; 
     31837-       if (flags & ATH9K_RXDESC_INTREQ) 
     31838-               ads->ds_ctl1 |= AR_RxIntrReq; 
     31839- 
     31840-       ads->ds_rxstatus8 &= ~AR_RxDone; 
     31841-       if (!(pCap->hw_caps & ATH9K_HW_CAP_AUTOSLEEP)) 
     31842-               memset(&(ads->u), 0, sizeof(ads->u)); 
     31843-} 
     31844-EXPORT_SYMBOL(ath9k_hw_setuprxdesc); 
     31845- 
     31846 /* 
     31847  * This can stop or re-enables RX. 
     31848  * 
     31849@@ -999,12 +729,6 @@ void ath9k_hw_putrxbuf(struct ath_hw *ah 
    3174131850 } 
    3174231851 EXPORT_SYMBOL(ath9k_hw_putrxbuf); 
     
    3175131860 { 
    3175231861        ath9k_enable_mib_counters(ah); 
    31753 @@ -1023,6 +763,14 @@ void ath9k_hw_stoppcurecv(struct ath_hw  
     31862@@ -1023,6 +747,14 @@ void ath9k_hw_stoppcurecv(struct ath_hw  
    3175431863 } 
    3175531864 EXPORT_SYMBOL(ath9k_hw_stoppcurecv); 
     
    3176631875 { 
    3176731876 #define AH_RX_STOP_DMA_TIMEOUT 10000   /* usec */ 
    31768 @@ -1068,3 +816,140 @@ int ath9k_hw_beaconq_setup(struct ath_hw 
     31877@@ -1068,3 +800,140 @@ int ath9k_hw_beaconq_setup(struct ath_hw 
    3176931878        return ath9k_hw_setuptxqueue(ah, ATH9K_TX_QUEUE_BEACON, &qi); 
    3177031879 } 
     
    3194832057 #define ATH9K_RXDESC_INTREQ            0x0020 
    3194932058  
    31950 @@ -353,7 +358,8 @@ struct ar5416_desc { 
     32059@@ -353,7 +358,6 @@ struct ar5416_desc { 
    3195132060 #define AR_DestIdxValid     0x40000000 
    3195232061 #define AR_CTSEnable        0x80000000 
    3195332062  
    3195432063-#define AR_BufLen           0x00000fff 
    31955 +#define AR_BufLen           AR_SREV_9300_20_OR_LATER(ah) ? 0x0fff0000 : \ 
    31956 +                                                          0x00000fff 
    3195732064 #define AR_TxMore           0x00001000 
    3195832065 #define AR_DestIdx          0x000fe000 
    3195932066 #define AR_DestIdx_S        13 
    31960 @@ -410,6 +416,7 @@ struct ar5416_desc { 
     32067@@ -410,6 +414,7 @@ struct ar5416_desc { 
    3196132068 #define AR_EncrType         0x0c000000 
    3196232069 #define AR_EncrType_S       26 
     
    3196632073 #define AR_2040_0           0x00000001 
    3196732074 #define AR_GI0              0x00000002 
    31968 @@ -493,7 +500,6 @@ struct ar5416_desc { 
     32075@@ -493,7 +498,6 @@ struct ar5416_desc { 
    3196932076  
    3197032077 #define AR_RxCTLRsvd00  0xffffffff 
     
    3197432081 #define AR_RxIntrReq    0x00002000 
    3197532082 #define AR_RxCtlRsvd01  0xffffc000 
    31976 @@ -686,34 +692,10 @@ struct ath9k_channel; 
     32083@@ -686,34 +690,10 @@ struct ath9k_channel; 
    3197732084 u32 ath9k_hw_gettxbuf(struct ath_hw *ah, u32 q); 
    3197832085 void ath9k_hw_puttxbuf(struct ath_hw *ah, u32 q, u32 txdp); 
     
    3201032117 bool ath9k_hw_set_txq_props(struct ath_hw *ah, int q, 
    3201132118                            const struct ath9k_tx_queue_info *qinfo); 
    32012 @@ -729,10 +711,17 @@ void ath9k_hw_setuprxdesc(struct ath_hw  
     32119@@ -729,10 +709,17 @@ void ath9k_hw_setuprxdesc(struct ath_hw  
    3201332120                          u32 size, u32 flags); 
    3201432121 bool ath9k_hw_setrxabort(struct ath_hw *ah, bool set); 
     
    3212532232        if (ah->caps.hw_caps & ATH9K_HW_CAP_GTT) 
    3212632233                ah->imask |= ATH9K_INT_GTT; 
     32234@@ -1436,7 +1468,8 @@ static int ath9k_add_interface(struct ie 
     32235        if ((vif->type == NL80211_IFTYPE_STATION) || 
     32236            (vif->type == NL80211_IFTYPE_ADHOC) || 
     32237            (vif->type == NL80211_IFTYPE_MESH_POINT)) { 
     32238-               ah->imask |= ATH9K_INT_MIB; 
     32239+               if (ah->config.enable_ani) 
     32240+                       ah->imask |= ATH9K_INT_MIB; 
     32241                ah->imask |= ATH9K_INT_TSFOOR; 
     32242        } 
     32243  
    3212732244--- a/drivers/net/wireless/ath/ath9k/pci.c 
    3212832245+++ b/drivers/net/wireless/ath/ath9k/pci.c 
     
    3375433871--- a/drivers/net/wireless/ath/ath9k/recv.c 
    3375533872+++ b/drivers/net/wireless/ath/ath9k/recv.c 
    33756 @@ -16,6 +16,8 @@ 
     33873@@ -15,6 +15,9 @@ 
     33874  */ 
    3375733875  
    3375833876 #include "ath9k.h" 
     33877+#include "ar9003_mac.h" 
     33878+ 
     33879+#define SKB_CB_ATHBUF(__skb)   (*((struct ath_buf **)__skb->cb)) 
    3375933880  
    33760 +#define SKB_CB_ATHBUF(__skb)   (*((struct ath_buf **)__skb->cb)) 
    33761 + 
    3376233881 static struct ieee80211_hw * ath_get_virt_hw(struct ath_softc *sc, 
    3376333882                                             struct ieee80211_hdr *hdr) 
    33764  { 
    33765 @@ -115,56 +117,246 @@ static void ath_opmode_init(struct ath_s 
     33883@@ -115,56 +118,246 @@ static void ath_opmode_init(struct ath_s 
    3376633884        ath9k_hw_setmcastfilter(ah, mfilt[0], mfilt[1]); 
    3376733885 } 
     
    3403734155 err: 
    3403834156        if (error) 
    34039 @@ -180,17 +372,23 @@ void ath_rx_cleanup(struct ath_softc *sc 
     34157@@ -180,17 +373,23 @@ void ath_rx_cleanup(struct ath_softc *sc 
    3404034158        struct sk_buff *skb; 
    3404134159        struct ath_buf *bf; 
     
    3407034188  
    3407134189 /* 
    34072 @@ -273,6 +471,11 @@ int ath_startrecv(struct ath_softc *sc) 
     34190@@ -273,6 +472,11 @@ int ath_startrecv(struct ath_softc *sc) 
    3407334191        struct ath_hw *ah = sc->sc_ah; 
    3407434192        struct ath_buf *bf, *tbf; 
     
    3408234200        if (list_empty(&sc->rx.rxbuf)) 
    3408334201                goto start_recv; 
    34084 @@ -306,7 +509,12 @@ bool ath_stoprecv(struct ath_softc *sc) 
     34202@@ -306,7 +510,11 @@ bool ath_stoprecv(struct ath_softc *sc) 
    3408534203        ath9k_hw_stoppcurecv(ah); 
    3408634204        ath9k_hw_setrxfilter(ah, 0); 
     
    3408834206-       sc->rx.rxlink = NULL; 
    3408934207+ 
    34090 +       if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_EDMA) { 
     34208+       if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_EDMA) 
    3409134209+               ath_edma_stop_recv(sc); 
    34092 +       } else { 
     34210+       else 
    3409334211+               sc->rx.rxlink = NULL; 
    34094 +       } 
    3409534212  
    3409634213        return stopped; 
     
    3449634613 #define AR_Q_TXE_M           0x000003FF 
    3449734614  
    34498 @@ -461,6 +478,9 @@ 
     34615@@ -461,6 +478,10 @@ 
    3449934616 #define AR_Q_RDYTIMESHDN    0x0a40 
    3450034617 #define AR_Q_RDYTIMESHDN_M  0x000003FF 
     
    3450234619+/* MAC Descriptor CRC check */ 
    3450334620+#define AR_Q_DESC_CRCCHK    0xa44 
    34504 +#define AR_Q_DESC_CRCCHK_EN 1 /* Enable CRC check on the descriptor fetched from host */ 
     34621+/* Enable CRC check on the descriptor fetched from host */ 
     34622+#define AR_Q_DESC_CRCCHK_EN 1 
    3450534623  
    3450634624 #define AR_NUM_DCU      10 
    3450734625 #define AR_DCU_0        0x0001 
    34508 @@ -759,6 +779,8 @@ 
     34626@@ -759,6 +780,8 @@ 
    3450934627 #define AR_SREV_VERSION_9271                   0x140 
    3451034628 #define AR_SREV_REVISION_9271_10               0 
     
    3451534633 #define AR_SREV_5416(_ah) \ 
    3451634634        (((_ah)->hw_version.macVersion == AR_SREV_VERSION_5416_PCI) || \ 
    34517 @@ -844,6 +866,15 @@ 
     34635@@ -844,6 +867,15 @@ 
    3451834636 #define AR_SREV_9271_11(_ah) \ 
    3451934637     (AR_SREV_9271(_ah) && \ 
     
    3453134649 #define AR_SREV_9285E_20(_ah) \ 
    3453234650     (AR_SREV_9285_12_OR_LATER(_ah) && \ 
    34533 @@ -945,6 +976,7 @@ enum { 
     34651@@ -945,6 +977,7 @@ enum { 
    3453434652 #define AR9285_NUM_GPIO                          12 
    3453534653 #define AR9287_NUM_GPIO                          11 
     
    3453934657 #define AR_GPIO_IN_OUT                           0x4048 
    3454034658 #define AR_GPIO_IN_VAL                           0x0FFFC000 
    34541 @@ -957,19 +989,21 @@ enum { 
     34659@@ -957,19 +990,21 @@ enum { 
    3454234660 #define AR9287_GPIO_IN_VAL_S                     11 
    3454334661 #define AR9271_GPIO_IN_VAL                       0xFFFF0000 
     
    3456534683 #define AR_GPIO_INPUT_EN_VAL_BT_PRIORITY_S       2 
    3456634684 #define AR_GPIO_INPUT_EN_VAL_BT_FREQUENCY_DEF    0x00000008 
    34567 @@ -987,13 +1021,13 @@ enum { 
     34685@@ -987,13 +1022,13 @@ enum { 
    3456834686 #define AR_GPIO_RTC_RESET_OVERRIDE_ENABLE        0x00010000 
    3456934687 #define AR_GPIO_JTAG_DISABLE                     0x00020000 
     
    3458134699 #define AR_GPIO_INPUT_MUX2_CLK25_S               0 
    3458234700 #define AR_GPIO_INPUT_MUX2_RFSILENT              0x000000f0 
    34583 @@ -1001,13 +1035,13 @@ enum { 
     34701@@ -1001,13 +1036,13 @@ enum { 
    3458434702 #define AR_GPIO_INPUT_MUX2_RTC_RESET             0x00000f00 
    3458534703 #define AR_GPIO_INPUT_MUX2_RTC_RESET_S           8 
     
    3460034718 #define AR_EEPROM_STATUS_DATA_VAL_S              0 
    3460134719 #define AR_EEPROM_STATUS_DATA_BUSY               0x00010000 
    34602 @@ -1015,13 +1049,24 @@ enum { 
     34720@@ -1015,13 +1050,24 @@ enum { 
    3460334721 #define AR_EEPROM_STATUS_DATA_PROT_ACCESS        0x00040000 
    3460434722 #define AR_EEPROM_STATUS_DATA_ABSENT_ACCESS      0x00080000 
     
    3462834746 #define AR_RTC_9160_PLL_DIV    0x000003ff 
    3462934747 #define AR_RTC_9160_PLL_DIV_S   0 
    34630 @@ -1039,6 +1084,16 @@ enum { 
     34748@@ -1039,6 +1085,16 @@ enum { 
    3463134749 #define AR_RTC_RC_COLD_RESET    0x00000004 
    3463234750 #define AR_RTC_RC_WARM_RESET    0x00000008 
     
    3464534763        ((AR_SREV_9100(ah)) ? (AR_RTC_BASE + 0x0014) : 0x7014) 
    3464634764  
    34647 @@ -1069,6 +1124,7 @@ enum { 
     34765@@ -1069,6 +1125,7 @@ enum { 
    3464834766 #define AR_RTC_SLEEP_CLK \ 
    3464934767        ((AR_SREV_9100(ah)) ? (AR_RTC_BASE + 0x0048) : 0x7048) 
     
    3465334771 #define AR_RTC_FORCE_WAKE \ 
    3465434772        ((AR_SREV_9100(ah)) ? (AR_RTC_BASE + 0x004c) : 0x704c) 
    34655 @@ -1533,7 +1589,7 @@ enum { 
     34773@@ -1533,7 +1590,7 @@ enum { 
    3465634774 #define AR_TSFOOR_THRESHOLD       0x813c 
    3465734775 #define AR_TSFOOR_THRESHOLD_VAL   0x0000FFFF 
     
    3466234780 #define AR_PHY_ERR_3           0x8168 
    3466334781 #define AR_PHY_ERR_3_COUNT     0x00FFFFFF 
    34664 @@ -1599,24 +1655,26 @@ enum { 
     34782@@ -1599,24 +1656,26 @@ enum { 
    3466534783 #define AR_FIRST_NDP_TIMER                  7 
    3466634784 #define AR_NDP2_PERIOD                      0x81a0 
     
    3470734825 #define AR_TIMER_MODE                       0x8240 
    3470834826 #define AR_TBTT_TIMER_EN                    0x00000001 
    34709 @@ -1730,4 +1788,32 @@ enum { 
     34827@@ -1730,4 +1789,32 @@ enum { 
    3471034828 #define AR9271_CORE_CLOCK      117   /* clock to 117Mhz */ 
    3471134829 #define AR9271_TARGET_BAUD_RATE        19200 /* 115200 */ 
     
    3474234860--- a/drivers/net/wireless/ath/ath9k/xmit.c 
    3474334861+++ b/drivers/net/wireless/ath/ath9k/xmit.c 
    34744 @@ -91,7 +91,6 @@ static int ath_max_4ms_framelen[3][16] = 
     34862@@ -15,6 +15,7 @@ 
     34863  */ 
     34864  
     34865 #include "ath9k.h" 
     34866+#include "ar9003_mac.h" 
     34867  
     34868 #define BITS_PER_BYTE           8 
     34869 #define OFDM_PLCP_BITS          22 
     34870@@ -91,7 +92,6 @@ static int ath_max_4ms_framelen[3][16] = 
    3474534871        } 
    3474634872 }; 
     
    3475034876 /* Aggregation logic */ 
    3475134877 /*********************/ 
    34752 @@ -279,7 +278,7 @@ static struct ath_buf* ath_clone_txbuf(s 
     34878@@ -279,7 +279,7 @@ static struct ath_buf* ath_clone_txbuf(s 
    3475334879        tbf->aphy = bf->aphy; 
    3475434880        tbf->bf_mpdu = bf->bf_mpdu; 
     
    3475934885        tbf->bf_dmacontext = bf->bf_dmacontext; 
    3476034886  
    34761 @@ -358,8 +357,7 @@ static void ath_tx_complete_aggr(struct  
    34762                         /* transmit completion */ 
     34887@@ -359,7 +359,7 @@ static void ath_tx_complete_aggr(struct  
    3476334888                        acked_cnt++; 
    3476434889                } else { 
    34765 -                       if (!(tid->state & AGGR_CLEANUP) && 
     34890                        if (!(tid->state & AGGR_CLEANUP) && 
    3476634891-                           ts->ts_flags != ATH9K_TX_SW_ABORTED) { 
    34767 +                       if (!(tid->state & AGGR_CLEANUP) && !bf_last->bf_tx_aborted) { 
     34892+                           !bf_last->bf_tx_aborted) { 
    3476834893                                if (bf->bf_retries < ATH_MAX_SW_RETRIES) { 
    3476934894                                        ath_tx_set_retry(sc, txq, bf); 
    3477034895                                        txpending = 1; 
    34771 @@ -378,7 +376,8 @@ static void ath_tx_complete_aggr(struct  
     34896@@ -378,7 +378,8 @@ static void ath_tx_complete_aggr(struct  
    3477234897                        } 
    3477334898                } 
     
    3477934904                         * Make sure the last desc is reclaimed if it 
    3478034905                         * not a holding desc. 
    34781 @@ -412,36 +411,38 @@ static void ath_tx_complete_aggr(struct  
     34906@@ -412,36 +413,43 @@ static void ath_tx_complete_aggr(struct  
    3478234907                                !txfail, sendbar); 
    3478334908                } else { 
     
    3479634921-                                                         bf->bf_seqno); 
    3479734922-                                       spin_unlock_bh(&txq->axq_lock); 
     34923- 
     34924-                                       bf->bf_state.bf_type |= BUF_XRETRY; 
     34925-                                       ath_tx_rc_status(bf, ts, nbad, 
     34926-                                                        0, false); 
     34927-                                       ath_tx_complete_buf(sc, bf, txq, 
     34928-                                                           &bf_head, ts, 0, 0); 
     34929-                                       break; 
    3479834930+                       if (!(sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_EDMA)) { 
    3479934931+                               if (bf->bf_next == NULL && bf_last->bf_stale) { 
     
    3480234934+                                       tbf = ath_clone_txbuf(sc, bf_last); 
    3480334935+                                       /* 
    34804 +                                        * Update tx baw and complete the frame with 
    34805 +                                        * failed status if we run out of tx buf 
     34936+                                        * Update tx baw and complete the 
     34937+                                        * frame with failed status if we 
     34938+                                        * run out of tx buf. 
    3480634939+                                        */ 
    3480734940+                                       if (!tbf) { 
     
    3481134944+                                               spin_unlock_bh(&txq->axq_lock); 
    3481234945+ 
    34813 +                                               bf->bf_state.bf_type |= BUF_XRETRY; 
     34946+                                               bf->bf_state.bf_type |= 
     34947+                                                       BUF_XRETRY; 
    3481434948+                                               ath_tx_rc_status(bf, ts, nbad, 
    3481534949+                                                               0, false); 
    3481634950+                                               ath_tx_complete_buf(sc, bf, txq, 
    34817 +                                                               &bf_head, ts, 0, 0); 
     34951+                                                                   &bf_head, 
     34952+                                                                   ts, 0, 0); 
    3481834953+                                               break; 
    3481934954+                                       } 
    34820   
    34821 -                                       bf->bf_state.bf_type |= BUF_XRETRY; 
    34822 -                                       ath_tx_rc_status(bf, ts, nbad, 
    34823 -                                                        0, false); 
    34824 -                                       ath_tx_complete_buf(sc, bf, txq, 
    34825 -                                                           &bf_head, ts, 0, 0); 
    34826 -                                       break; 
    34827 +                                       ath9k_hw_cleartxdesc(sc->sc_ah, tbf->bf_desc); 
     34955+ 
     34956+                                       ath9k_hw_cleartxdesc(sc->sc_ah, 
     34957+                                                            tbf->bf_desc); 
    3482834958+                                       list_add_tail(&tbf->list, &bf_head); 
    3482934959+                               } else { 
     
    3483234962+                                        * software retry 
    3483334963+                                        */ 
    34834 +                                       ath9k_hw_cleartxdesc(sc->sc_ah, bf->bf_desc); 
     34964+                                       ath9k_hw_cleartxdesc(sc->sc_ah, 
     34965+                                                            bf->bf_desc); 
    3483534966                                } 
    3483634967- 
     
    3484634977  
    3484734978                        /* 
    34848 @@ -665,7 +666,7 @@ static enum ATH_AGGR_STATUS ath_tx_form_ 
     34979@@ -665,7 +673,7 @@ static enum ATH_AGGR_STATUS ath_tx_form_ 
    3484934980                bpad = PADBYTES(al_delta) + (ndelim << 2); 
    3485034981  
     
    3485534986                /* link buffers of this frame to the aggregate */ 
    3485634987                ath_tx_addto_baw(sc, tid, bf); 
    34857 @@ -673,7 +674,8 @@ static enum ATH_AGGR_STATUS ath_tx_form_ 
     34988@@ -673,7 +681,8 @@ static enum ATH_AGGR_STATUS ath_tx_form_ 
    3485834989                list_move_tail(&bf->list, bf_q); 
    3485934990                if (bf_prev) { 
     
    3486534996                bf_prev = bf; 
    3486634997  
    34867 @@ -853,7 +855,7 @@ struct ath_txq *ath_txq_setup(struct ath 
     34998@@ -853,7 +862,7 @@ struct ath_txq *ath_txq_setup(struct ath 
    3486834999        struct ath_hw *ah = sc->sc_ah; 
    3486935000        struct ath_common *common = ath9k_hw_common(ah); 
     
    3487435005        memset(&qi, 0, sizeof(qi)); 
    3487535006        qi.tqi_subtype = subtype; 
    34876 @@ -877,11 +879,16 @@ struct ath_txq *ath_txq_setup(struct ath 
     35007@@ -877,11 +886,16 @@ struct ath_txq *ath_txq_setup(struct ath 
    3487735008         * The UAPSD queue is an exception, since we take a desc- 
    3487835009         * based intr on the EOSP frames. 
     
    3489635027        if (qnum == -1) { 
    3489735028                /* 
    34898 @@ -908,6 +915,11 @@ struct ath_txq *ath_txq_setup(struct ath 
     35029@@ -908,6 +922,11 @@ struct ath_txq *ath_txq_setup(struct ath 
    3489935030                txq->axq_depth = 0; 
    3490035031                txq->axq_tx_inprogress = false; 
     
    3490835039        return &sc->tx.txq[qnum]; 
    3490935040 } 
    34910 @@ -1035,36 +1047,64 @@ void ath_draintxq(struct ath_softc *sc,  
     35041@@ -1035,36 +1054,54 @@ void ath_draintxq(struct ath_softc *sc,  
    3491135042        struct ath_tx_status ts; 
    3491235043  
     
    3492535056-                       break; 
    3492635057-               } 
     35058- 
     35059-               bf = list_first_entry(&txq->axq_q, struct ath_buf, list); 
    3492735060+               if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_EDMA) { 
    3492835061+                       if (list_empty(&txq->txq_fifo[txq->txq_tailidx])) { 
    34929 +                               if (list_empty(&txq->txq_fifo_pending)) { 
    34930 +                                       txq->txq_headidx = txq->txq_tailidx = 0; 
    34931 +                                       spin_unlock_bh(&txq->axq_lock); 
    34932 +                                       break; 
    34933 +                               } 
    34934   
    34935 -               bf = list_first_entry(&txq->axq_q, struct ath_buf, list); 
    34936 +                               bf = list_first_entry(&txq->txq_fifo_pending, 
    34937 +                                     struct ath_buf, list); 
    34938   
    34939 -               if (bf->bf_stale) { 
    34940 -                       list_del(&bf->list); 
    34941 -                       spin_unlock_bh(&txq->axq_lock); 
    34942 +                               list_cut_position( 
    34943 +                                       &txq->txq_fifo[txq->txq_tailidx], 
    34944 +                                       &txq->txq_fifo_pending, 
    34945 +                                       &bf->bf_lastbf->list); 
     35062+                               txq->txq_headidx = txq->txq_tailidx = 0; 
     35063+                               spin_unlock_bh(&txq->axq_lock); 
     35064+                               break; 
    3494635065+                       } else { 
    3494735066+                               bf = list_first_entry(&txq->txq_fifo[txq->txq_tailidx], 
    34948 +                                       struct ath_buf, list); 
     35067+                                                     struct ath_buf, list); 
    3494935068+                       } 
    3495035069+               } else { 
     
    3495735076+                                             list); 
    3495835077  
     35078-               if (bf->bf_stale) { 
     35079-                       list_del(&bf->list); 
     35080-                       spin_unlock_bh(&txq->axq_lock); 
     35081+                       if (bf->bf_stale) { 
     35082+                               list_del(&bf->list); 
     35083+                               spin_unlock_bh(&txq->axq_lock); 
     35084  
    3495935085-                       spin_lock_bh(&sc->tx.txbuflock); 
    3496035086-                       list_add_tail(&bf->list, &sc->tx.txbuf); 
    3496135087-                       spin_unlock_bh(&sc->tx.txbuflock); 
    3496235088-                       continue; 
    34963 +                       if (bf->bf_stale) { 
    34964 +                               list_del(&bf->list); 
    34965 +                               spin_unlock_bh(&txq->axq_lock); 
    34966 + 
    3496735089+                               spin_lock_bh(&sc->tx.txbuflock); 
    3496835090+                               list_add_tail(&bf->list, &sc->tx.txbuf); 
     
    3499135113  
    3499235114                spin_unlock_bh(&txq->axq_lock); 
    34993 @@ -1224,25 +1264,46 @@ static void ath_tx_txqaddbuf(struct ath_ 
     35115@@ -1087,6 +1124,27 @@ void ath_draintxq(struct ath_softc *sc,  
     35116                        spin_unlock_bh(&txq->axq_lock); 
     35117                } 
     35118        } 
     35119+ 
     35120+       if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_EDMA) { 
     35121+               spin_lock_bh(&txq->axq_lock); 
     35122+               while (!list_empty(&txq->txq_fifo_pending)) { 
     35123+                       bf = list_first_entry(&txq->txq_fifo_pending, 
     35124+                                             struct ath_buf, list); 
     35125+                       list_cut_position(&bf_head, 
     35126+                                         &txq->txq_fifo_pending, 
     35127+                                         &bf->bf_lastbf->list); 
     35128+                       spin_unlock_bh(&txq->axq_lock); 
     35129+ 
     35130+                       if (bf_isampdu(bf)) 
     35131+                               ath_tx_complete_aggr(sc, txq, bf, &bf_head, 
     35132+                                                    &ts, 0); 
     35133+                       else 
     35134+                               ath_tx_complete_buf(sc, bf, txq, &bf_head, 
     35135+                                                   &ts, 0, 0); 
     35136+                       spin_lock_bh(&txq->axq_lock); 
     35137+               } 
     35138+               spin_unlock_bh(&txq->axq_lock); 
     35139+       } 
     35140 } 
     35141  
     35142 void ath_drain_all_txq(struct ath_softc *sc, bool retry_tx) 
     35143@@ -1224,25 +1282,47 @@ static void ath_tx_txqaddbuf(struct ath_ 
    3499435144  
    3499535145        bf = list_first_entry(head, struct ath_buf, list); 
     
    3500935159+               if (!list_empty(&txq->txq_fifo[txq->txq_headidx])) 
    3501035160+                       ath_print(common, ATH_DBG_XMIT, 
    35011 +                                 "Initializing tx fifo %d which is non-empty\n", 
     35161+                                 "Initializing tx fifo %d which " 
     35162+                                 "is non-empty\n", 
    3501235163+                                 txq->txq_headidx); 
    3501335164+               INIT_LIST_HEAD(&txq->txq_fifo[txq->txq_headidx]); 
     
    3504835199  
    3504935200 static struct ath_buf *ath_tx_get_buffer(struct ath_softc *sc) 
    35050 @@ -1408,8 +1469,7 @@ static void assign_aggr_tid_seqno(struct 
     35201@@ -1408,8 +1488,7 @@ static void assign_aggr_tid_seqno(struct 
    3505135202        INCR(tid->seq_next, IEEE80211_SEQ_MAX); 
    3505235203 } 
     
    3505835209        struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb); 
    3505935210        int flags = 0; 
    35060 @@ -1420,6 +1480,9 @@ static int setup_tx_flags(struct ath_sof 
     35211@@ -1420,6 +1499,9 @@ static int setup_tx_flags(struct ath_sof 
    3506135212        if (tx_info->flags & IEEE80211_TX_CTL_NO_ACK) 
    3506235213                flags |= ATH9K_TXDESC_NOACK; 
     
    3506835219 } 
    3506935220  
    35070 @@ -1571,6 +1634,7 @@ static int ath_tx_setup_buffer(struct ie 
     35221@@ -1571,6 +1653,7 @@ static int ath_tx_setup_buffer(struct ie 
    3507135222        int hdrlen; 
    3507235223        __le16 fc; 
     
    3507635227        tx_info->pad[0] = 0; 
    3507735228        switch (txctl->frame_type) { 
    35078 @@ -1597,10 +1661,13 @@ static int ath_tx_setup_buffer(struct ie 
     35229@@ -1597,10 +1680,13 @@ static int ath_tx_setup_buffer(struct ie 
    3507935230                bf->bf_frmlen -= padsize; 
    3508035231        } 
     
    3509235243        bf->bf_keytype = get_hw_crypto_keytype(skb); 
    3509335244        if (bf->bf_keytype != ATH9K_KEY_TYPE_CLEAR) { 
    35094 @@ -1659,8 +1726,7 @@ static void ath_tx_start_dma(struct ath_ 
     35245@@ -1659,8 +1745,7 @@ static void ath_tx_start_dma(struct ath_ 
    3509535246        list_add_tail(&bf->list, &bf_head); 
    3509635247  
     
    3510235253        ath9k_hw_set11n_txdesc(ah, ds, bf->bf_frmlen, frm_type, MAX_RATE_POWER, 
    3510335254                               bf->bf_keyix, bf->bf_keytype, bf->bf_flags); 
    35104 @@ -1669,7 +1735,9 @@ static void ath_tx_start_dma(struct ath_ 
     35255@@ -1669,7 +1754,9 @@ static void ath_tx_start_dma(struct ath_ 
    3510535256                            skb->len,   /* segment length */ 
    3510635257                            true,       /* first segment */ 
     
    3511335264        spin_lock_bh(&txctl->txq->axq_lock); 
    3511435265  
    35115 @@ -1896,7 +1964,7 @@ static int ath_tx_num_badfrms(struct ath 
     35266@@ -1896,7 +1983,7 @@ static int ath_tx_num_badfrms(struct ath 
    3511635267        int nbad = 0; 
    3511735268        int isaggr = 0; 
     
    3512235273  
    3512335274        isaggr = bf_isaggr(bf); 
    35124 @@ -2138,10 +2206,119 @@ void ath_tx_tasklet(struct ath_softc *sc 
     35275@@ -2138,10 +2225,119 @@ void ath_tx_tasklet(struct ath_softc *sc 
    3512535276        } 
    3512635277 } 
     
    3524235393 { 
    3524335394        struct ath_common *common = ath9k_hw_common(sc->sc_ah); 
    35244 @@ -2150,7 +2327,7 @@ int ath_tx_init(struct ath_softc *sc, in 
     35395@@ -2150,7 +2346,7 @@ int ath_tx_init(struct ath_softc *sc, in 
    3524535396        spin_lock_init(&sc->tx.txbuflock); 
    3524635397  
     
    3525135402                ath_print(common, ATH_DBG_FATAL, 
    3525235403                          "Failed to allocate tx descriptors: %d\n", error); 
    35253 @@ -2158,7 +2335,7 @@ int ath_tx_init(struct ath_softc *sc, in 
     35404@@ -2158,7 +2354,7 @@ int ath_tx_init(struct ath_softc *sc, in 
    3525435405        } 
    3525535406  
     
    3526035411                ath_print(common, ATH_DBG_FATAL, 
    3526135412                          "Failed to allocate beacon descriptors: %d\n", error); 
    35262 @@ -2167,6 +2344,12 @@ int ath_tx_init(struct ath_softc *sc, in 
     35413@@ -2167,6 +2363,12 @@ int ath_tx_init(struct ath_softc *sc, in 
    3526335414  
    3526435415        INIT_DELAYED_WORK(&sc->tx_complete_work, ath_tx_complete_poll_work); 
     
    3527335424        if (error != 0) 
    3527435425                ath_tx_cleanup(sc); 
    35275 @@ -2181,6 +2364,9 @@ void ath_tx_cleanup(struct ath_softc *sc 
     35426@@ -2181,6 +2383,9 @@ void ath_tx_cleanup(struct ath_softc *sc 
    3527635427  
    3527735428        if (sc->tx.txdma.dd_desc_len != 0) 
Note: See TracChangeset for help on using the changeset viewer.