source: trunk/package/mac80211/patches/581-ath9k_cleanup_txpower_handling.patch @ 28260

Last change on this file since 28260 was 28260, checked in by nbd, 5 years ago

ath9k: fix handling configured tx power limits

File size: 20.5 KB
  • drivers/net/wireless/ath/ath.h

    a b struct ath_regulatory { 
    7171        char alpha2[2]; 
    7272        u16 country_code; 
    7373        u16 max_power_level; 
    74         u32 tp_scale; 
    7574        u16 current_rd; 
    7675        u16 current_rd_ext; 
    7776        int16_t power_limit; 
  • drivers/net/wireless/ath/ath9k/ar9003_eeprom.c

    a b static u32 ath9k_hw_ar9300_get_eeprom(st 
    30403040                return (pBase->miscConfiguration >> 0x3) & 0x1; 
    30413041        case EEP_ANT_DIV_CTL1: 
    30423042                return eep->base_ext1.ant_div_control; 
     3043        case EEP_ANTENNA_GAIN_5G: 
     3044                return eep->modalHeader5G.antennaGain; 
     3045        case EEP_ANTENNA_GAIN_2G: 
     3046                return eep->modalHeader2G.antennaGain; 
    30433047        default: 
    30443048                return 0; 
    30453049        } 
    static u16 ar9003_hw_get_max_edge_power( 
    47274731static void ar9003_hw_set_power_per_rate_table(struct ath_hw *ah, 
    47284732                                               struct ath9k_channel *chan, 
    47294733                                               u8 *pPwrArray, u16 cfgCtl, 
    4730                                                u8 twiceAntennaReduction, 
    4731                                                u8 twiceMaxRegulatoryPower, 
     4734                                               u8 antenna_reduction, 
    47324735                                               u16 powerLimit) 
    47334736{ 
    4734         struct ath_regulatory *regulatory = ath9k_hw_regulatory(ah); 
    47354737        struct ath_common *common = ath9k_hw_common(ah); 
    47364738        struct ar9300_eeprom *pEepData = &ah->eeprom.ar9300_eep; 
    47374739        u16 twiceMaxEdgePower = MAX_RATE_POWER; 
    4738         static const u16 tpScaleReductionTable[5] = { 
    4739                 0, 3, 6, 9, MAX_RATE_POWER 
    4740         }; 
    47414740        int i; 
    4742         int16_t  twiceLargestAntenna; 
    4743         u16 scaledPower = 0, minCtlPower, maxRegAllowedPower; 
     4741        u16 scaledPower = 0, minCtlPower; 
    47444742        static const u16 ctlModesFor11a[] = { 
    47454743                CTL_11A, CTL_5GHT20, CTL_11A_EXT, CTL_5GHT40 
    47464744        }; 
    static void ar9003_hw_set_power_per_rate 
    47584756        bool is2ghz = IS_CHAN_2GHZ(chan); 
    47594757 
    47604758        ath9k_hw_get_channel_centers(ah, chan, &centers); 
    4761  
    4762         /* Compute TxPower reduction due to Antenna Gain */ 
    4763         if (is2ghz) 
    4764                 twiceLargestAntenna = pEepData->modalHeader2G.antennaGain; 
    4765         else 
    4766                 twiceLargestAntenna = pEepData->modalHeader5G.antennaGain; 
    4767  
    4768         twiceLargestAntenna = (int16_t)min((twiceAntennaReduction) - 
    4769                                 twiceLargestAntenna, 0); 
    4770  
    4771         /* 
    4772          * scaledPower is the minimum of the user input power level 
    4773          * and the regulatory allowed power level 
    4774          */ 
    4775         maxRegAllowedPower = twiceMaxRegulatoryPower + twiceLargestAntenna; 
    4776  
    4777         if (regulatory->tp_scale != ATH9K_TP_SCALE_MAX) { 
    4778                 maxRegAllowedPower -= 
    4779                         (tpScaleReductionTable[(regulatory->tp_scale)] * 2); 
    4780         } 
    4781  
    4782         scaledPower = min(powerLimit, maxRegAllowedPower); 
     4759        scaledPower = powerLimit - antenna_reduction; 
    47834760 
    47844761        /* 
    47854762         * Reduce scaled Power by number of chains active to get 
    static inline u8 mcsidx_to_tgtpwridx(uns 
    49664943static void ath9k_hw_ar9300_set_txpower(struct ath_hw *ah, 
    49674944                                        struct ath9k_channel *chan, u16 cfgCtl, 
    49684945                                        u8 twiceAntennaReduction, 
    4969                                         u8 twiceMaxRegulatoryPower, 
    49704946                                        u8 powerLimit, bool test) 
    49714947{ 
    49724948        struct ath_regulatory *regulatory = ath9k_hw_regulatory(ah); 
    static void ath9k_hw_ar9300_set_txpower( 
    50194995        ar9003_hw_set_power_per_rate_table(ah, chan, 
    50204996                                           targetPowerValT2, cfgCtl, 
    50214997                                           twiceAntennaReduction, 
    5022                                            twiceMaxRegulatoryPower, 
    50234998                                           powerLimit); 
    50244999 
    50255000        if (ah->eep_ops->get_eeprom(ah, EEP_PAPRD)) { 
  • drivers/net/wireless/ath/ath9k/hw.c

    a b static void ath9k_hw_init_defaults(struc 
    429429 
    430430        regulatory->country_code = CTRY_DEFAULT; 
    431431        regulatory->power_limit = MAX_RATE_POWER; 
    432         regulatory->tp_scale = ATH9K_TP_SCALE_MAX; 
    433432 
    434433        ah->hw_version.magic = AR5416_MAGIC; 
    435434        ah->hw_version.subvendorid = 0; 
    static bool ath9k_hw_chip_reset(struct a 
    13961395static bool ath9k_hw_channel_change(struct ath_hw *ah, 
    13971396                                    struct ath9k_channel *chan) 
    13981397{ 
    1399         struct ath_regulatory *regulatory = ath9k_hw_regulatory(ah); 
    14001398        struct ath_common *common = ath9k_hw_common(ah); 
    1401         struct ieee80211_channel *channel = chan->chan; 
    14021399        u32 qnum; 
    14031400        int r; 
    14041401 
    static bool ath9k_hw_channel_change(stru 
    14231420                return false; 
    14241421        } 
    14251422        ath9k_hw_set_clockrate(ah); 
    1426  
    1427         ah->eep_ops->set_txpower(ah, chan, 
    1428                              ath9k_regd_get_ctl(regulatory, chan), 
    1429                              channel->max_antenna_gain * 2, 
    1430                              channel->max_power * 2, 
    1431                              min((u32) MAX_RATE_POWER, 
    1432                              (u32) regulatory->power_limit), false); 
    1433  
     1423        ath9k_hw_apply_txpower(ah, chan); 
    14341424        ath9k_hw_rfbus_done(ah); 
    14351425 
    14361426        if (IS_CHAN_OFDM(chan) || IS_CHAN_HT(chan)) 
    bool ath9k_hw_disable(struct ath_hw *ah) 
    24662456} 
    24672457EXPORT_SYMBOL(ath9k_hw_disable); 
    24682458 
     2459static int get_antenna_gain(struct ath_hw *ah, struct ath9k_channel *chan) 
     2460{ 
     2461        enum eeprom_param gain_param; 
     2462 
     2463        if (IS_CHAN_2GHZ(chan)) 
     2464                gain_param = EEP_ANTENNA_GAIN_2G; 
     2465        else 
     2466                gain_param = EEP_ANTENNA_GAIN_5G; 
     2467 
     2468        return ah->eep_ops->get_eeprom(ah, gain_param); 
     2469} 
     2470 
     2471void ath9k_hw_apply_txpower(struct ath_hw *ah, struct ath9k_channel *chan) 
     2472{ 
     2473        struct ath_regulatory *reg = ath9k_hw_regulatory(ah); 
     2474        struct ieee80211_channel *channel; 
     2475        int chan_pwr, new_pwr, max_gain; 
     2476        int ant_gain, ant_reduction = 0; 
     2477 
     2478        if (!chan) 
     2479                return; 
     2480 
     2481        channel = chan->chan; 
     2482        chan_pwr = min_t(int, channel->max_power * 2, MAX_RATE_POWER); 
     2483        new_pwr = min_t(int, chan_pwr, reg->power_limit); 
     2484        max_gain = new_pwr - chan_pwr + channel->max_antenna_gain * 2; 
     2485 
     2486        ant_gain = get_antenna_gain(ah, chan); 
     2487        if (ant_gain > max_gain) 
     2488                ant_reduction = ant_gain - max_gain; 
     2489 
     2490        ah->eep_ops->set_txpower(ah, chan, 
     2491                                 ath9k_regd_get_ctl(reg, chan), 
     2492                                 ant_reduction, new_pwr, false); 
     2493} 
     2494 
    24692495void ath9k_hw_set_txpowerlimit(struct ath_hw *ah, u32 limit, bool test) 
    24702496{ 
    2471         struct ath_regulatory *regulatory = ath9k_hw_regulatory(ah); 
     2497        struct ath_regulatory *reg = ath9k_hw_regulatory(ah); 
    24722498        struct ath9k_channel *chan = ah->curchan; 
    24732499        struct ieee80211_channel *channel = chan->chan; 
    2474         int reg_pwr = min_t(int, MAX_RATE_POWER, limit); 
    2475         int chan_pwr = channel->max_power * 2; 
    24762500 
     2501        reg->power_limit = min_t(int, limit * 2, MAX_RATE_POWER); 
    24772502        if (test) 
    2478                 reg_pwr = chan_pwr = MAX_RATE_POWER; 
     2503                channel->max_power = MAX_RATE_POWER / 2; 
    24792504 
    2480         regulatory->power_limit = reg_pwr; 
     2505        ath9k_hw_apply_txpower(ah, chan); 
    24812506 
    2482         ah->eep_ops->set_txpower(ah, chan, 
    2483                                  ath9k_regd_get_ctl(regulatory, chan), 
    2484                                  channel->max_antenna_gain * 2, 
    2485                                  chan_pwr, reg_pwr, test); 
     2507        if (test) 
     2508                channel->max_power = DIV_ROUND_UP(reg->max_power_level, 2); 
    24862509} 
    24872510EXPORT_SYMBOL(ath9k_hw_set_txpowerlimit); 
    24882511 
  • drivers/net/wireless/ath/ath9k/hw.h

    a b enum ath9k_power_mode { 
    389389        ATH9K_PM_UNDEFINED 
    390390}; 
    391391 
    392 enum ath9k_tp_scale { 
    393         ATH9K_TP_SCALE_MAX = 0, 
    394         ATH9K_TP_SCALE_50, 
    395         ATH9K_TP_SCALE_25, 
    396         ATH9K_TP_SCALE_12, 
    397         ATH9K_TP_SCALE_MIN 
    398 }; 
    399  
    400392enum ser_reg_mode { 
    401393        SER_REG_MODE_OFF = 0, 
    402394        SER_REG_MODE_ON = 1, 
    void ath9k_hw_htc_resetinit(struct ath_h 
    964956/* PHY */ 
    965957void ath9k_hw_get_delta_slope_vals(struct ath_hw *ah, u32 coef_scaled, 
    966958                                   u32 *coef_mantissa, u32 *coef_exponent); 
     959void ath9k_hw_apply_txpower(struct ath_hw *ah, struct ath9k_channel *chan); 
    967960 
    968961/* 
    969962 * Code Specific to AR5008, AR9001 or AR9002, 
  • drivers/net/wireless/ath/ath9k/eeprom_4k.c

    a b static u32 ath9k_hw_4k_get_eeprom(struct 
    350350                return pModal->antdiv_ctl1; 
    351351        case EEP_TXGAIN_TYPE: 
    352352                return pBase->txGainType; 
     353        case EEP_ANTENNA_GAIN_2G: 
     354                return pModal->antennaGainCh[0]; 
    353355        default: 
    354356                return 0; 
    355357        } 
    static void ath9k_hw_set_4k_power_per_ra 
    462464                                                 struct ath9k_channel *chan, 
    463465                                                 int16_t *ratesArray, 
    464466                                                 u16 cfgCtl, 
    465                                                  u16 AntennaReduction, 
    466                                                  u16 twiceMaxRegulatoryPower, 
     467                                                 u16 antenna_reduction, 
    467468                                                 u16 powerLimit) 
    468469{ 
    469470#define CMP_TEST_GRP \ 
    static void ath9k_hw_set_4k_power_per_ra 
    472473        || (((cfgCtl & ~CTL_MODE_M) | (pCtlMode[ctlMode] & CTL_MODE_M)) == \ 
    473474            ((pEepData->ctlIndex[i] & CTL_MODE_M) | SD_NO_CTL)) 
    474475 
    475         struct ath_regulatory *regulatory = ath9k_hw_regulatory(ah); 
    476476        int i; 
    477         int16_t twiceLargestAntenna; 
    478477        u16 twiceMinEdgePower; 
    479478        u16 twiceMaxEdgePower = MAX_RATE_POWER; 
    480         u16 scaledPower = 0, minCtlPower, maxRegAllowedPower; 
     479        u16 scaledPower = 0, minCtlPower; 
    481480        u16 numCtlModes; 
    482481        const u16 *pCtlMode; 
    483482        u16 ctlMode, freq; 
    484483        struct chan_centers centers; 
    485484        struct cal_ctl_data_4k *rep; 
    486485        struct ar5416_eeprom_4k *pEepData = &ah->eeprom.map4k; 
    487         static const u16 tpScaleReductionTable[5] = 
    488                 { 0, 3, 6, 9, MAX_RATE_POWER }; 
    489486        struct cal_target_power_leg targetPowerOfdm, targetPowerCck = { 
    490487                0, { 0, 0, 0, 0} 
    491488        }; 
    static void ath9k_hw_set_4k_power_per_ra 
    503500 
    504501        ath9k_hw_get_channel_centers(ah, chan, &centers); 
    505502 
    506         twiceLargestAntenna = pEepData->modalHeader.antennaGainCh[0]; 
    507         twiceLargestAntenna = (int16_t)min(AntennaReduction - 
    508                                            twiceLargestAntenna, 0); 
    509  
    510         maxRegAllowedPower = twiceMaxRegulatoryPower + twiceLargestAntenna; 
    511         if (regulatory->tp_scale != ATH9K_TP_SCALE_MAX) { 
    512                 maxRegAllowedPower -= 
    513                         (tpScaleReductionTable[(regulatory->tp_scale)] * 2); 
    514         } 
    515  
    516         scaledPower = min(powerLimit, maxRegAllowedPower); 
    517         scaledPower = max((u16)0, scaledPower); 
    518  
     503        scaledPower = powerLimit - antenna_reduction; 
    519504        numCtlModes = ARRAY_SIZE(ctlModesFor11g) - SUB_NUM_CTL_MODES_AT_2G_40; 
    520505        pCtlMode = ctlModesFor11g; 
    521506 
    static void ath9k_hw_4k_set_txpower(stru 
    671656                                    struct ath9k_channel *chan, 
    672657                                    u16 cfgCtl, 
    673658                                    u8 twiceAntennaReduction, 
    674                                     u8 twiceMaxRegulatoryPower, 
    675659                                    u8 powerLimit, bool test) 
    676660{ 
    677661        struct ath_regulatory *regulatory = ath9k_hw_regulatory(ah); 
    static void ath9k_hw_4k_set_txpower(stru 
    691675        ath9k_hw_set_4k_power_per_rate_table(ah, chan, 
    692676                                             &ratesArray[0], cfgCtl, 
    693677                                             twiceAntennaReduction, 
    694                                              twiceMaxRegulatoryPower, 
    695678                                             powerLimit); 
    696679 
    697680        ath9k_hw_set_4k_power_cal_table(ah, chan); 
  • drivers/net/wireless/ath/ath9k/eeprom_9287.c

    a b static u32 ath9k_hw_ar9287_get_eeprom(st 
    336336                        return pBase->tempSensSlopePalOn; 
    337337                else 
    338338                        return 0; 
     339        case EEP_ANTENNA_GAIN_2G: 
     340                return max_t(u8, pModal->antennaGainCh[0], 
     341                                 pModal->antennaGainCh[1]); 
    339342        default: 
    340343                return 0; 
    341344        } 
    static void ath9k_hw_set_ar9287_power_pe 
    554557                                                     struct ath9k_channel *chan, 
    555558                                                     int16_t *ratesArray, 
    556559                                                     u16 cfgCtl, 
    557                                                      u16 AntennaReduction, 
    558                                                      u16 twiceMaxRegulatoryPower, 
     560                                                     u16 antenna_reduction, 
    559561                                                     u16 powerLimit) 
    560562{ 
    561563#define CMP_CTL \ 
    static void ath9k_hw_set_ar9287_power_pe 
    569571#define REDUCE_SCALED_POWER_BY_TWO_CHAIN     6 
    570572#define REDUCE_SCALED_POWER_BY_THREE_CHAIN   10 
    571573 
    572         struct ath_regulatory *regulatory = ath9k_hw_regulatory(ah); 
    573574        u16 twiceMaxEdgePower = MAX_RATE_POWER; 
    574         static const u16 tpScaleReductionTable[5] = 
    575                 { 0, 3, 6, 9, MAX_RATE_POWER }; 
    576575        int i; 
    577         int16_t twiceLargestAntenna; 
    578576        struct cal_ctl_data_ar9287 *rep; 
    579577        struct cal_target_power_leg targetPowerOfdm = {0, {0, 0, 0, 0} }, 
    580578                                    targetPowerCck = {0, {0, 0, 0, 0} }; 
    static void ath9k_hw_set_ar9287_power_pe 
    582580                                    targetPowerCckExt = {0, {0, 0, 0, 0} }; 
    583581        struct cal_target_power_ht targetPowerHt20, 
    584582                                    targetPowerHt40 = {0, {0, 0, 0, 0} }; 
    585         u16 scaledPower = 0, minCtlPower, maxRegAllowedPower; 
     583        u16 scaledPower = 0, minCtlPower; 
    586584        static const u16 ctlModesFor11g[] = { 
    587585                CTL_11B, CTL_11G, CTL_2GHT20, 
    588586                CTL_11B_EXT, CTL_11G_EXT, CTL_2GHT40 
    static void ath9k_hw_set_ar9287_power_pe 
    597595        tx_chainmask = ah->txchainmask; 
    598596 
    599597        ath9k_hw_get_channel_centers(ah, chan, &centers); 
    600  
    601         /* Compute TxPower reduction due to Antenna Gain */ 
    602         twiceLargestAntenna = max(pEepData->modalHeader.antennaGainCh[0], 
    603                                   pEepData->modalHeader.antennaGainCh[1]); 
    604         twiceLargestAntenna = (int16_t)min((AntennaReduction) - 
    605                                            twiceLargestAntenna, 0); 
    606  
    607         /* 
    608          * scaledPower is the minimum of the user input power level 
    609          * and the regulatory allowed power level. 
    610          */ 
    611         maxRegAllowedPower = twiceMaxRegulatoryPower + twiceLargestAntenna; 
    612  
    613         if (regulatory->tp_scale != ATH9K_TP_SCALE_MAX) 
    614                 maxRegAllowedPower -= 
    615                         (tpScaleReductionTable[(regulatory->tp_scale)] * 2); 
    616  
    617         scaledPower = min(powerLimit, maxRegAllowedPower); 
     598        scaledPower = powerLimit - antenna_reduction; 
    618599 
    619600        /* 
    620601         * Reduce scaled Power by number of chains active 
    static void ath9k_hw_set_ar9287_power_pe 
    815796static void ath9k_hw_ar9287_set_txpower(struct ath_hw *ah, 
    816797                                        struct ath9k_channel *chan, u16 cfgCtl, 
    817798                                        u8 twiceAntennaReduction, 
    818                                         u8 twiceMaxRegulatoryPower, 
    819799                                        u8 powerLimit, bool test) 
    820800{ 
    821801        struct ath_regulatory *regulatory = ath9k_hw_regulatory(ah); 
    static void ath9k_hw_ar9287_set_txpower( 
    834814        ath9k_hw_set_ar9287_power_per_rate_table(ah, chan, 
    835815                                                 &ratesArray[0], cfgCtl, 
    836816                                                 twiceAntennaReduction, 
    837                                                  twiceMaxRegulatoryPower, 
    838817                                                 powerLimit); 
    839818 
    840819        ath9k_hw_set_ar9287_power_cal_table(ah, chan); 
  • drivers/net/wireless/ath/ath9k/eeprom_def.c

    a b static u32 ath9k_hw_def_get_eeprom(struc 
    400400        struct ar5416_eeprom_def *eep = &ah->eeprom.def; 
    401401        struct modal_eep_header *pModal = eep->modalHeader; 
    402402        struct base_eep_header *pBase = &eep->baseEepHeader; 
     403        int band = 0; 
    403404 
    404405        switch (param) { 
    405406        case EEP_NFTHRESH_5: 
    static u32 ath9k_hw_def_get_eeprom(struc 
    467468                        return pBase->pwr_table_offset; 
    468469                else 
    469470                        return AR5416_PWR_TABLE_OFFSET_DB; 
     471        case EEP_ANTENNA_GAIN_2G: 
     472                band = 1; 
     473                /* fall through */ 
     474        case EEP_ANTENNA_GAIN_5G: 
     475                return max_t(u8, max_t(u8, 
     476                        pModal[band].antennaGainCh[0], 
     477                        pModal[band].antennaGainCh[1]), 
     478                        pModal[band].antennaGainCh[2]); 
    470479        default: 
    471480                return 0; 
    472481        } 
    static void ath9k_hw_set_def_power_per_r 
    986995                                                  struct ath9k_channel *chan, 
    987996                                                  int16_t *ratesArray, 
    988997                                                  u16 cfgCtl, 
    989                                                   u16 AntennaReduction, 
    990                                                   u16 twiceMaxRegulatoryPower, 
     998                                                  u16 antenna_reduction, 
    991999                                                  u16 powerLimit) 
    9921000{ 
    9931001#define REDUCE_SCALED_POWER_BY_TWO_CHAIN     6  /* 10*log10(2)*2 */ 
    9941002#define REDUCE_SCALED_POWER_BY_THREE_CHAIN   9 /* 10*log10(3)*2 */ 
    9951003 
    996         struct ath_regulatory *regulatory = ath9k_hw_regulatory(ah); 
    9971004        struct ar5416_eeprom_def *pEepData = &ah->eeprom.def; 
    9981005        u16 twiceMaxEdgePower = MAX_RATE_POWER; 
    999         static const u16 tpScaleReductionTable[5] = 
    1000                 { 0, 3, 6, 9, MAX_RATE_POWER }; 
    1001  
    10021006        int i; 
    1003         int16_t twiceLargestAntenna; 
    10041007        struct cal_ctl_data *rep; 
    10051008        struct cal_target_power_leg targetPowerOfdm, targetPowerCck = { 
    10061009                0, { 0, 0, 0, 0} 
    static void ath9k_hw_set_def_power_per_r 
    10121015        struct cal_target_power_ht targetPowerHt20, targetPowerHt40 = { 
    10131016                0, {0, 0, 0, 0} 
    10141017        }; 
    1015         u16 scaledPower = 0, minCtlPower, maxRegAllowedPower; 
     1018        u16 scaledPower = 0, minCtlPower; 
    10161019        static const u16 ctlModesFor11a[] = { 
    10171020                CTL_11A, CTL_5GHT20, CTL_11A_EXT, CTL_5GHT40 
    10181021        }; 
    static void ath9k_hw_set_def_power_per_r 
    10311034 
    10321035        ath9k_hw_get_channel_centers(ah, chan, &centers); 
    10331036 
    1034         twiceLargestAntenna = max( 
    1035                 pEepData->modalHeader 
    1036                         [IS_CHAN_2GHZ(chan)].antennaGainCh[0], 
    1037                 pEepData->modalHeader 
    1038                         [IS_CHAN_2GHZ(chan)].antennaGainCh[1]); 
    1039  
    1040         twiceLargestAntenna = max((u8)twiceLargestAntenna, 
    1041                                   pEepData->modalHeader 
    1042                                   [IS_CHAN_2GHZ(chan)].antennaGainCh[2]); 
    1043  
    1044         twiceLargestAntenna = (int16_t)min(AntennaReduction - 
    1045                                            twiceLargestAntenna, 0); 
    1046  
    1047         maxRegAllowedPower = twiceMaxRegulatoryPower + twiceLargestAntenna; 
    1048  
    1049         if (regulatory->tp_scale != ATH9K_TP_SCALE_MAX) { 
    1050                 maxRegAllowedPower -= 
    1051                         (tpScaleReductionTable[(regulatory->tp_scale)] * 2); 
    1052         } 
    1053  
    1054         scaledPower = min(powerLimit, maxRegAllowedPower); 
     1037        scaledPower = powerLimit - antenna_reduction; 
    10551038 
    10561039        switch (ar5416_get_ntxchains(tx_chainmask)) { 
    10571040        case 1: 
    static void ath9k_hw_def_set_txpower(str 
    12561239                                    struct ath9k_channel *chan, 
    12571240                                    u16 cfgCtl, 
    12581241                                    u8 twiceAntennaReduction, 
    1259                                     u8 twiceMaxRegulatoryPower, 
    12601242                                    u8 powerLimit, bool test) 
    12611243{ 
    12621244#define RT_AR_DELTA(x) (ratesArray[x] - cck_ofdm_delta) 
    static void ath9k_hw_def_set_txpower(str 
    12781260        ath9k_hw_set_def_power_per_rate_table(ah, chan, 
    12791261                                               &ratesArray[0], cfgCtl, 
    12801262                                               twiceAntennaReduction, 
    1281                                                twiceMaxRegulatoryPower, 
    12821263                                               powerLimit); 
    12831264 
    12841265        ath9k_hw_set_def_power_cal_table(ah, chan); 
  • drivers/net/wireless/ath/ath9k/ar5008_phy.c

    a b static void ar5008_hw_set_channel_regs(s 
    763763static int ar5008_hw_process_ini(struct ath_hw *ah, 
    764764                                 struct ath9k_channel *chan) 
    765765{ 
    766         struct ath_regulatory *regulatory = ath9k_hw_regulatory(ah); 
    767766        struct ath_common *common = ath9k_hw_common(ah); 
    768767        int i, regWrites = 0; 
    769         struct ieee80211_channel *channel = chan->chan; 
    770768        u32 modesIndex, freqIndex; 
    771769 
    772770        switch (chan->chanmode) { 
    static int ar5008_hw_process_ini(struct  
    903901        ar5008_hw_set_channel_regs(ah, chan); 
    904902        ar5008_hw_init_chain_masks(ah); 
    905903        ath9k_olc_init(ah); 
    906  
    907         /* Set TX power */ 
    908         ah->eep_ops->set_txpower(ah, chan, 
    909                                  ath9k_regd_get_ctl(regulatory, chan), 
    910                                  channel->max_antenna_gain * 2, 
    911                                  channel->max_power * 2, 
    912                                  min((u32) MAX_RATE_POWER, 
    913                                  (u32) regulatory->power_limit), false); 
     904        ath9k_hw_apply_txpower(ah, chan); 
    914905 
    915906        /* Write analog registers */ 
    916907        if (!ath9k_hw_set_rf_regs(ah, chan, freqIndex)) { 
  • drivers/net/wireless/ath/ath9k/ar9003_paprd.c

    a b  
    1919 
    2020void ar9003_paprd_enable(struct ath_hw *ah, bool val) 
    2121{ 
    22         struct ath_regulatory *regulatory = ath9k_hw_regulatory(ah); 
    2322        struct ath9k_channel *chan = ah->curchan; 
    2423        struct ar9300_eeprom *eep = &ah->eeprom.ar9300_eep; 
    2524 
    void ar9003_paprd_enable(struct ath_hw * 
    5453 
    5554        if (val) { 
    5655                ah->paprd_table_write_done = true; 
    57  
    58                 ah->eep_ops->set_txpower(ah, chan, 
    59                                 ath9k_regd_get_ctl(regulatory, chan), 
    60                                 chan->chan->max_antenna_gain * 2, 
    61                                 chan->chan->max_power * 2, 
    62                                 min((u32) MAX_RATE_POWER, 
    63                                 (u32) regulatory->power_limit), false); 
     56                ath9k_hw_apply_txpower(ah, chan); 
    6457        } 
    6558 
    6659        REG_RMW_FIELD(ah, AR_PHY_PAPRD_CTRL0_B0, 
  • drivers/net/wireless/ath/ath9k/ar9003_phy.c

    a b static void ar9003_hw_prog_ini(struct at 
    628628static int ar9003_hw_process_ini(struct ath_hw *ah, 
    629629                                 struct ath9k_channel *chan) 
    630630{ 
    631         struct ath_regulatory *regulatory = ath9k_hw_regulatory(ah); 
    632631        unsigned int regWrites = 0, i; 
    633         struct ieee80211_channel *channel = chan->chan; 
    634632        u32 modesIndex; 
    635633 
    636634        switch (chan->chanmode) { 
    static int ar9003_hw_process_ini(struct  
    683681        ar9003_hw_override_ini(ah); 
    684682        ar9003_hw_set_channel_regs(ah, chan); 
    685683        ar9003_hw_set_chain_masks(ah, ah->rxchainmask, ah->txchainmask); 
    686  
    687         /* Set TX power */ 
    688         ah->eep_ops->set_txpower(ah, chan, 
    689                                  ath9k_regd_get_ctl(regulatory, chan), 
    690                                  channel->max_antenna_gain * 2, 
    691                                  channel->max_power * 2, 
    692                                  min((u32) MAX_RATE_POWER, 
    693                                  (u32) regulatory->power_limit), false); 
     684        ath9k_hw_apply_txpower(ah, chan); 
    694685 
    695686        return 0; 
    696687} 
  • drivers/net/wireless/ath/ath9k/common.c

    a b EXPORT_SYMBOL(ath9k_cmn_count_streams); 
    161161void ath9k_cmn_update_txpow(struct ath_hw *ah, u16 cur_txpow, 
    162162                            u16 new_txpow, u16 *txpower) 
    163163{ 
    164         if (cur_txpow != new_txpow) { 
     164        struct ath_regulatory *reg = ath9k_hw_regulatory(ah); 
     165 
     166        if (reg->power_limit != new_txpow) { 
    165167                ath9k_hw_set_txpowerlimit(ah, new_txpow, false); 
    166168                /* read back in case value is clamped */ 
    167                 *txpower = ath9k_hw_regulatory(ah)->power_limit; 
     169                *txpower = reg->max_power_level; 
    168170        } 
    169171} 
    170172EXPORT_SYMBOL(ath9k_cmn_update_txpow); 
  • drivers/net/wireless/ath/ath9k/eeprom.h

    a b enum eeprom_param { 
    253253        EEP_PAPRD, 
    254254        EEP_MODAL_VER, 
    255255        EEP_ANT_DIV_CTL1, 
    256         EEP_CHAIN_MASK_REDUCE 
     256        EEP_CHAIN_MASK_REDUCE, 
     257        EEP_ANTENNA_GAIN_2G, 
     258        EEP_ANTENNA_GAIN_5G 
    257259}; 
    258260 
    259261enum ar5416_rates { 
    struct eeprom_ops { 
    657659        void (*set_addac)(struct ath_hw *hw, struct ath9k_channel *chan); 
    658660        void (*set_txpower)(struct ath_hw *hw, struct ath9k_channel *chan, 
    659661                           u16 cfgCtl, u8 twiceAntennaReduction, 
    660                            u8 twiceMaxRegulatoryPower, u8 powerLimit, 
    661                            bool test); 
     662                           u8 powerLimit, bool test); 
    662663        u16 (*get_spur_channel)(struct ath_hw *ah, u16 i, bool is2GHz); 
    663664}; 
    664665 
  • drivers/net/wireless/ath/ath9k/init.c

    a b static void ath9k_init_band_txpower(stru 
    626626        struct ieee80211_supported_band *sband; 
    627627        struct ieee80211_channel *chan; 
    628628        struct ath_hw *ah = sc->sc_ah; 
    629         struct ath_regulatory *reg = ath9k_hw_regulatory(ah); 
    630629        int i; 
    631630 
    632631        sband = &sc->sbands[band]; 
    static void ath9k_init_band_txpower(stru 
    635634                ah->curchan = &ah->channels[chan->hw_value]; 
    636635                ath9k_cmn_update_ichannel(ah->curchan, chan, NL80211_CHAN_HT20); 
    637636                ath9k_hw_set_txpowerlimit(ah, MAX_RATE_POWER, true); 
    638                 chan->max_power = reg->max_power_level / 2; 
    639637        } 
    640638} 
    641639 
Note: See TracBrowser for help on using the repository browser.