Merge branch 'linus' into percpu-cpumask-x86-for-linus-2

Conflicts:
	arch/sparc/kernel/time_64.c
	drivers/gpu/drm/drm_proc.c

Manual merge to resolve build warning due to phys_addr_t type change
on x86:

	drivers/gpu/drm/drm_info.c

Signed-off-by: Ingo Molnar <mingo@elte.hu>

12 files changed, 1833 insertions, 388 deletions

diff --git a/drivers/net/wireless/ath5k/ath5k.h b/drivers/net/wireless/ath5k/ath5k.h
index 0dc2c7321c8b..0b616e72fe05 100644
--- a/drivers/net/wireless/ath5k/ath5k.h
+++ b/drivers/net/wireless/ath5k/ath5k.h
@@ -204,9 +204,9 @@
 #define AR5K_TUNE_CWMAX_11B                     1023
 #define AR5K_TUNE_CWMAX_XR                      7
 #define AR5K_TUNE_NOISE_FLOOR                   -72
-#define AR5K_TUNE_MAX_TXPOWER                   60
-#define AR5K_TUNE_DEFAULT_TXPOWER               30
-#define AR5K_TUNE_TPC_TXPOWER                   true
+#define AR5K_TUNE_MAX_TXPOWER                   63
+#define AR5K_TUNE_DEFAULT_TXPOWER               25
+#define AR5K_TUNE_TPC_TXPOWER                   false
 #define AR5K_TUNE_ANT_DIVERSITY                 true
 #define AR5K_TUNE_HWTXTRIES                     4
 
@@ -551,11 +551,11 @@ enum ath5k_pkt_type {
  */
 #define AR5K_TXPOWER_OFDM(_r, _v)       (                       \
         ((0 & 1) << ((_v) + 6)) |                               \
-        (((ah->ah_txpower.txp_rates[(_r)]) & 0x3f) << (_v))     \
+        (((ah->ah_txpower.txp_rates_power_table[(_r)]) & 0x3f) << (_v)) \
 )
 
 #define AR5K_TXPOWER_CCK(_r, _v)        (                       \
-        (ah->ah_txpower.txp_rates[(_r)] & 0x3f) << (_v) \
+        (ah->ah_txpower.txp_rates_power_table[(_r)] & 0x3f) << (_v)     \
 )
 
 /*
@@ -1085,13 +1085,25 @@ struct ath5k_hw {
         struct ath5k_gain       ah_gain;
         u8                      ah_offset[AR5K_MAX_RF_BANKS];
 
+
         struct {
-                u16             txp_pcdac[AR5K_EEPROM_POWER_TABLE_SIZE];
-                u16             txp_rates[AR5K_MAX_RATES];
-                s16             txp_min;
-                s16             txp_max;
+                /* Temporary tables used for interpolation */
+                u8              tmpL[AR5K_EEPROM_N_PD_GAINS]
+                                        [AR5K_EEPROM_POWER_TABLE_SIZE];
+                u8              tmpR[AR5K_EEPROM_N_PD_GAINS]
+                                        [AR5K_EEPROM_POWER_TABLE_SIZE];
+                u8              txp_pd_table[AR5K_EEPROM_POWER_TABLE_SIZE * 2];
+                u16             txp_rates_power_table[AR5K_MAX_RATES];
+                u8              txp_min_idx;
                 bool            txp_tpc;
+                /* Values in 0.25dB units */
+                s16             txp_min_pwr;
+                s16             txp_max_pwr;
+                s16             txp_offset;
                 s16             txp_ofdm;
+                /* Values in dB units */
+                s16             txp_cck_ofdm_pwr_delta;
+                s16             txp_cck_ofdm_gainf_delta;
         } ah_txpower;
 
         struct {
@@ -1161,6 +1173,7 @@ extern void ath5k_hw_update_mib_counters(struct ath5k_hw *ah, struct ieee80211_l
 
 /* EEPROM access functions */
 extern int ath5k_eeprom_init(struct ath5k_hw *ah);
+extern void ath5k_eeprom_detach(struct ath5k_hw *ah);
 extern int ath5k_eeprom_read_mac(struct ath5k_hw *ah, u8 *mac);
 extern bool ath5k_eeprom_is_hb63(struct ath5k_hw *ah);
 
@@ -1256,8 +1269,8 @@ extern void ath5k_hw_set_def_antenna(struct ath5k_hw *ah, unsigned int ant);
 extern unsigned int ath5k_hw_get_def_antenna(struct ath5k_hw *ah);
 extern int ath5k_hw_phy_disable(struct ath5k_hw *ah);
 /* TX power setup */
-extern int ath5k_hw_txpower(struct ath5k_hw *ah, struct ieee80211_channel *channel, unsigned int txpower);
-extern int ath5k_hw_set_txpower_limit(struct ath5k_hw *ah, unsigned int power);
+extern int ath5k_hw_txpower(struct ath5k_hw *ah, struct ieee80211_channel *channel, u8 ee_mode, u8 txpower);
+extern int ath5k_hw_set_txpower_limit(struct ath5k_hw *ah, u8 ee_mode, u8 txpower);
 
 /*
  * Functions used internaly
diff --git a/drivers/net/wireless/ath5k/attach.c b/drivers/net/wireless/ath5k/attach.c
index 656cb9dc833b..70d376c63aac 100644
--- a/drivers/net/wireless/ath5k/attach.c
+++ b/drivers/net/wireless/ath5k/attach.c
@@ -341,6 +341,8 @@ void ath5k_hw_detach(struct ath5k_hw *ah)
         if (ah->ah_rf_banks != NULL)
                 kfree(ah->ah_rf_banks);
 
+        ath5k_eeprom_detach(ah);
+
         /* assume interrupts are down */
         kfree(ah);
 }
diff --git a/drivers/net/wireless/ath5k/base.c b/drivers/net/wireless/ath5k/base.c
index cad3ccf61b00..5d57d774e466 100644
--- a/drivers/net/wireless/ath5k/base.c
+++ b/drivers/net/wireless/ath5k/base.c
@@ -685,13 +685,6 @@ ath5k_pci_resume(struct pci_dev *pdev)
         if (err)
                 return err;
 
-        /*
-         * Suspend/Resume resets the PCI configuration space, so we have to
-         * re-disable the RETRY_TIMEOUT register (0x41) to keep
-         * PCI Tx retries from interfering with C3 CPU state
-         */
-        pci_write_config_byte(pdev, 0x41, 0);
-
         err = request_irq(pdev->irq, ath5k_intr, IRQF_SHARED, "ath", sc);
         if (err) {
                 ATH5K_ERR(sc, "request_irq failed\n");
@@ -1095,9 +1088,18 @@ ath5k_mode_setup(struct ath5k_softc *sc)
 static inline int
 ath5k_hw_to_driver_rix(struct ath5k_softc *sc, int hw_rix)
 {
-        WARN(hw_rix < 0 || hw_rix >= AR5K_MAX_RATES,
-                        "hw_rix out of bounds: %x\n", hw_rix);
-        return sc->rate_idx[sc->curband->band][hw_rix];
+        int rix;
+
+        /* return base rate on errors */
+        if (WARN(hw_rix < 0 || hw_rix >= AR5K_MAX_RATES,
+                        "hw_rix out of bounds: %x\n", hw_rix))
+                return 0;
+
+        rix = sc->rate_idx[sc->curband->band][hw_rix];
+        if (WARN(rix < 0, "invalid hw_rix: %x\n", hw_rix))
+                rix = 0;
+
+        return rix;
 }
 
 /***************\
@@ -1216,6 +1218,9 @@ ath5k_txbuf_setup(struct ath5k_softc *sc, struct ath5k_buf *bf)
 
         pktlen = skb->len;
 
+        /* FIXME: If we are in g mode and rate is a CCK rate
+         * subtract ah->ah_txpower.txp_cck_ofdm_pwr_delta
+         * from tx power (value is in dB units already) */
         if (info->control.hw_key) {
                 keyidx = info->control.hw_key->hw_key_idx;
                 pktlen += info->control.hw_key->icv_len;
@@ -2044,6 +2049,9 @@ ath5k_beacon_setup(struct ath5k_softc *sc, struct ath5k_buf *bf)
                         antenna = sc->bsent & 4 ? 2 : 1;
         }
 
+        /* FIXME: If we are in g mode and rate is a CCK rate
+         * subtract ah->ah_txpower.txp_cck_ofdm_pwr_delta
+         * from tx power (value is in dB units already) */
         ds->ds_data = bf->skbaddr;
         ret = ah->ah_setup_tx_desc(ah, ds, skb->len,
                         ieee80211_get_hdrlen_from_skb(skb),
@@ -2305,7 +2313,7 @@ ath5k_init(struct ath5k_softc *sc)
         sc->curband = &sc->sbands[sc->curchan->band];
         sc->imask = AR5K_INT_RXOK | AR5K_INT_RXERR | AR5K_INT_RXEOL |
                 AR5K_INT_RXORN | AR5K_INT_TXDESC | AR5K_INT_TXEOL |
-                AR5K_INT_FATAL | AR5K_INT_GLOBAL | AR5K_INT_MIB;
+                AR5K_INT_FATAL | AR5K_INT_GLOBAL;
         ret = ath5k_reset(sc, false, false);
         if (ret)
                 goto done;
@@ -2554,7 +2562,7 @@ ath5k_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
                 if (skb_headroom(skb) < padsize) {
                         ATH5K_ERR(sc, "tx hdrlen not %%4: %d not enough"
                                   " headroom to pad %d\n", hdrlen, padsize);
-                        return NETDEV_TX_BUSY;
+                        goto drop_packet;
                 }
                 skb_push(skb, padsize);
                 memmove(skb->data, skb->data+padsize, hdrlen);
@@ -2565,7 +2573,7 @@ ath5k_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
                 ATH5K_ERR(sc, "no further txbuf available, dropping packet\n");
                 spin_unlock_irqrestore(&sc->txbuflock, flags);
                 ieee80211_stop_queue(hw, skb_get_queue_mapping(skb));
-                return NETDEV_TX_BUSY;
+                goto drop_packet;
         }
         bf = list_first_entry(&sc->txbuf, struct ath5k_buf, list);
         list_del(&bf->list);
@@ -2582,10 +2590,12 @@ ath5k_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
                 list_add_tail(&bf->list, &sc->txbuf);
                 sc->txbuf_len++;
                 spin_unlock_irqrestore(&sc->txbuflock, flags);
-                dev_kfree_skb_any(skb);
-                return NETDEV_TX_OK;
+                goto drop_packet;
         }
+        return NETDEV_TX_OK;
 
+drop_packet:
+        dev_kfree_skb_any(skb);
         return NETDEV_TX_OK;
 }
 
@@ -2608,12 +2618,6 @@ ath5k_reset(struct ath5k_softc *sc, bool stop, bool change_channel)
                 goto err;
         }
 
-        /*
-         * This is needed only to setup initial state
-         * but it's best done after a reset.
-         */
-        ath5k_hw_set_txpower_limit(sc->ah, 0);
-
         ret = ath5k_rx_start(sc);
         if (ret) {
                 ATH5K_ERR(sc, "can't start recv logic\n");
diff --git a/drivers/net/wireless/ath5k/base.h b/drivers/net/wireless/ath5k/base.h
index 20e0d14b41ec..822956114cd7 100644
--- a/drivers/net/wireless/ath5k/base.h
+++ b/drivers/net/wireless/ath5k/base.h
@@ -112,7 +112,7 @@ struct ath5k_softc {
         struct ieee80211_supported_band sbands[IEEE80211_NUM_BANDS];
         struct ieee80211_channel channels[ATH_CHAN_MAX];
         struct ieee80211_rate   rates[IEEE80211_NUM_BANDS][AR5K_MAX_RATES];
-        u8                      rate_idx[IEEE80211_NUM_BANDS][AR5K_MAX_RATES];
+        s8                      rate_idx[IEEE80211_NUM_BANDS][AR5K_MAX_RATES];
         enum nl80211_iftype     opmode;
         struct ath5k_hw         *ah;            /* Atheros HW */
 
diff --git a/drivers/net/wireless/ath5k/desc.c b/drivers/net/wireless/ath5k/desc.c
index b40a9287a39a..dc30a2b70a6b 100644
--- a/drivers/net/wireless/ath5k/desc.c
+++ b/drivers/net/wireless/ath5k/desc.c
@@ -194,6 +194,10 @@ static int ath5k_hw_setup_4word_tx_desc(struct ath5k_hw *ah,
                 return -EINVAL;
         }
 
+        tx_power += ah->ah_txpower.txp_offset;
+        if (tx_power > AR5K_TUNE_MAX_TXPOWER)
+                tx_power = AR5K_TUNE_MAX_TXPOWER;
+
         /* Clear descriptor */
         memset(&desc->ud.ds_tx5212, 0, sizeof(struct ath5k_hw_5212_tx_desc));
 
diff --git a/drivers/net/wireless/ath5k/eeprom.c b/drivers/net/wireless/ath5k/eeprom.c
index ac45ca47ca87..c0fb3b09ba45 100644
--- a/drivers/net/wireless/ath5k/eeprom.c
+++ b/drivers/net/wireless/ath5k/eeprom.c
@@ -1,7 +1,7 @@
 /*
  * Copyright (c) 2004-2008 Reyk Floeter <reyk@openbsd.org>
- * Copyright (c) 2006-2008 Nick Kossifidis <mickflemm@gmail.com>
- * Copyright (c) 2008 Felix Fietkau <nbd@openwrt.org>
+ * Copyright (c) 2006-2009 Nick Kossifidis <mickflemm@gmail.com>
+ * Copyright (c) 2008-2009 Felix Fietkau <nbd@openwrt.org>
  *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
@@ -98,11 +98,6 @@ ath5k_eeprom_init_header(struct ath5k_hw *ah)
         int ret;
         u16 val;
 
-        /* Initial TX thermal adjustment values */
-        ee->ee_tx_clip = 4;
-        ee->ee_pwd_84 = ee->ee_pwd_90 = 1;
-        ee->ee_gain_select = 1;
-
         /*
          * Read values from EEPROM and store them in the capability structure
          */
@@ -241,22 +236,22 @@ static int ath5k_eeprom_read_modes(struct ath5k_hw *ah, u32 *offset,
         ee->ee_adc_desired_size[mode]   = (s8)((val >> 8) & 0xff);
         switch(mode) {
         case AR5K_EEPROM_MODE_11A:
-                ee->ee_ob[mode][3]              = (val >> 5) & 0x7;
-                ee->ee_db[mode][3]              = (val >> 2) & 0x7;
-                ee->ee_ob[mode][2]              = (val << 1) & 0x7;
+                ee->ee_ob[mode][3]      = (val >> 5) & 0x7;
+                ee->ee_db[mode][3]      = (val >> 2) & 0x7;
+                ee->ee_ob[mode][2]      = (val << 1) & 0x7;
 
                 AR5K_EEPROM_READ(o++, val);
-                ee->ee_ob[mode][2]              |= (val >> 15) & 0x1;
-                ee->ee_db[mode][2]              = (val >> 12) & 0x7;
-                ee->ee_ob[mode][1]              = (val >> 9) & 0x7;
-                ee->ee_db[mode][1]              = (val >> 6) & 0x7;
-                ee->ee_ob[mode][0]              = (val >> 3) & 0x7;
-                ee->ee_db[mode][0]              = val & 0x7;
+                ee->ee_ob[mode][2]      |= (val >> 15) & 0x1;
+                ee->ee_db[mode][2]      = (val >> 12) & 0x7;
+                ee->ee_ob[mode][1]      = (val >> 9) & 0x7;
+                ee->ee_db[mode][1]      = (val >> 6) & 0x7;
+                ee->ee_ob[mode][0]      = (val >> 3) & 0x7;
+                ee->ee_db[mode][0]      = val & 0x7;
                 break;
         case AR5K_EEPROM_MODE_11G:
         case AR5K_EEPROM_MODE_11B:
-                ee->ee_ob[mode][1]              = (val >> 4) & 0x7;
-                ee->ee_db[mode][1]              = val & 0x7;
+                ee->ee_ob[mode][1]      = (val >> 4) & 0x7;
+                ee->ee_db[mode][1]      = val & 0x7;
                 break;
         }
 
@@ -504,35 +499,6 @@ ath5k_eeprom_init_modes(struct ath5k_hw *ah)
         return 0;
 }
 
-/* Used to match PCDAC steps with power values on RF5111 chips
- * (eeprom versions < 4). For RF5111 we have 10 pre-defined PCDAC
- * steps that match with the power values we read from eeprom. On
- * older eeprom versions (< 3.2) these steps are equaly spaced at
- * 10% of the pcdac curve -until the curve reaches it's maximum-
- * (10 steps from 0 to 100%) but on newer eeprom versions (>= 3.2)
- * these 10 steps are spaced in a different way. This function returns
- * the pcdac steps based on eeprom version and curve min/max so that we
- * can have  pcdac/pwr points.
- */
-static inline void
-ath5k_get_pcdac_intercepts(struct ath5k_hw *ah, u8 min, u8 max, u8 *vp)
-{
-        static const u16 intercepts3[] =
-                { 0, 5, 10, 20, 30, 50, 70, 85, 90, 95, 100 };
-        static const u16 intercepts3_2[] =
-                { 0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 };
-        const u16 *ip;
-        int i;
-
-        if (ah->ah_ee_version >= AR5K_EEPROM_VERSION_3_2)
-                ip = intercepts3_2;
-        else
-                ip = intercepts3;
-
-        for (i = 0; i < ARRAY_SIZE(intercepts3); i++)
-                *vp++ = (ip[i] * max + (100 - ip[i]) * min) / 100;
-}
-
 /* Read the frequency piers for each mode (mostly used on newer eeproms with 0xff
  * frequency mask) */
 static inline int
@@ -546,26 +512,25 @@ ath5k_eeprom_read_freq_list(struct ath5k_hw *ah, int *offset, int max,
         int ret;
         u16 val;
 
+        ee->ee_n_piers[mode] = 0;
         while(i < max) {
                 AR5K_EEPROM_READ(o++, val);
 
-                freq1 = (val >> 8) & 0xff;
-                freq2 = val & 0xff;
-
-                if (freq1) {
-                        pc[i++].freq = ath5k_eeprom_bin2freq(ee,
-                                        freq1, mode);
-                        ee->ee_n_piers[mode]++;
-                }
+                freq1 = val & 0xff;
+                if (!freq1)
+                        break;
 
-                if (freq2) {
-                        pc[i++].freq = ath5k_eeprom_bin2freq(ee,
-                                        freq2, mode);
-                        ee->ee_n_piers[mode]++;
-                }
+                pc[i++].freq = ath5k_eeprom_bin2freq(ee,
+                                freq1, mode);
+                ee->ee_n_piers[mode]++;
 
-                if (!freq1 || !freq2)
+                freq2 = (val >> 8) & 0xff;
+                if (!freq2)
                         break;
+
+                pc[i++].freq = ath5k_eeprom_bin2freq(ee,
+                                freq2, mode);
+                ee->ee_n_piers[mode]++;
         }
 
         /* return new offset */
@@ -652,13 +617,122 @@ ath5k_eeprom_init_11bg_2413(struct ath5k_hw *ah, unsigned int mode, int offset)
         return 0;
 }
 
-/* Read power calibration for RF5111 chips
+/*
+ * Read power calibration for RF5111 chips
+ *
  * For RF5111 we have an XPD -eXternal Power Detector- curve
- * for each calibrated channel. Each curve has PCDAC steps on
- * x axis and power on y axis and looks like a logarithmic
- * function. To recreate the curve and pass the power values
- * on the pcdac table, we read 10 points here and interpolate later.
+ * for each calibrated channel. Each curve has 0,5dB Power steps
+ * on x axis and PCDAC steps (offsets) on y axis and looks like an
+ * exponential function. To recreate the curve we read 11 points
+ * here and interpolate later.
  */
+
+/* Used to match PCDAC steps with power values on RF5111 chips
+ * (eeprom versions < 4). For RF5111 we have 11 pre-defined PCDAC
+ * steps that match with the power values we read from eeprom. On
+ * older eeprom versions (< 3.2) these steps are equaly spaced at
+ * 10% of the pcdac curve -until the curve reaches it's maximum-
+ * (11 steps from 0 to 100%) but on newer eeprom versions (>= 3.2)
+ * these 11 steps are spaced in a different way. This function returns
+ * the pcdac steps based on eeprom version and curve min/max so that we
+ * can have pcdac/pwr points.
+ */
+static inline void
+ath5k_get_pcdac_intercepts(struct ath5k_hw *ah, u8 min, u8 max, u8 *vp)
+{
+        const static u16 intercepts3[] =
+                { 0, 5, 10, 20, 30, 50, 70, 85, 90, 95, 100 };
+        const static u16 intercepts3_2[] =
+                { 0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 };
+        const u16 *ip;
+        int i;
+
+        if (ah->ah_ee_version >= AR5K_EEPROM_VERSION_3_2)
+                ip = intercepts3_2;
+        else
+                ip = intercepts3;
+
+        for (i = 0; i < ARRAY_SIZE(intercepts3); i++)
+                vp[i] = (ip[i] * max + (100 - ip[i]) * min) / 100;
+}
+
+/* Convert RF5111 specific data to generic raw data
+ * used by interpolation code */
+static int
+ath5k_eeprom_convert_pcal_info_5111(struct ath5k_hw *ah, int mode,
+                                struct ath5k_chan_pcal_info *chinfo)
+{
+        struct ath5k_eeprom_info *ee = &ah->ah_capabilities.cap_eeprom;
+        struct ath5k_chan_pcal_info_rf5111 *pcinfo;
+        struct ath5k_pdgain_info *pd;
+        u8 pier, point, idx;
+        u8 *pdgain_idx = ee->ee_pdc_to_idx[mode];
+
+        /* Fill raw data for each calibration pier */
+        for (pier = 0; pier < ee->ee_n_piers[mode]; pier++) {
+
+                pcinfo = &chinfo[pier].rf5111_info;
+
+                /* Allocate pd_curves for this cal pier */
+                chinfo[pier].pd_curves =
+                        kcalloc(AR5K_EEPROM_N_PD_CURVES,
+                                sizeof(struct ath5k_pdgain_info),
+                                GFP_KERNEL);
+
+                if (!chinfo[pier].pd_curves)
+                        return -ENOMEM;
+
+                /* Only one curve for RF5111
+                 * find out which one and place
+                 * in in pd_curves.
+                 * Note: ee_x_gain is reversed here */
+                for (idx = 0; idx < AR5K_EEPROM_N_PD_CURVES; idx++) {
+
+                        if (!((ee->ee_x_gain[mode] >> idx) & 0x1)) {
+                                pdgain_idx[0] = idx;
+                                break;
+                        }
+                }
+
+                ee->ee_pd_gains[mode] = 1;
+
+                pd = &chinfo[pier].pd_curves[idx];
+
+                pd->pd_points = AR5K_EEPROM_N_PWR_POINTS_5111;
+
+                /* Allocate pd points for this curve */
+                pd->pd_step = kcalloc(AR5K_EEPROM_N_PWR_POINTS_5111,
+                                        sizeof(u8), GFP_KERNEL);
+                if (!pd->pd_step)
+                        return -ENOMEM;
+
+                pd->pd_pwr = kcalloc(AR5K_EEPROM_N_PWR_POINTS_5111,
+                                        sizeof(s16), GFP_KERNEL);
+                if (!pd->pd_pwr)
+                        return -ENOMEM;
+
+                /* Fill raw dataset
+                 * (convert power to 0.25dB units
+                 * for RF5112 combatibility) */
+                for (point = 0; point < pd->pd_points; point++) {
+
+                        /* Absolute values */
+                        pd->pd_pwr[point] = 2 * pcinfo->pwr[point];
+
+                        /* Already sorted */
+                        pd->pd_step[point] = pcinfo->pcdac[point];
+                }
+
+                /* Set min/max pwr */
+                chinfo[pier].min_pwr = pd->pd_pwr[0];
+                chinfo[pier].max_pwr = pd->pd_pwr[10];
+
+        }
+
+        return 0;
+}
+
+/* Parse EEPROM data */
 static int
 ath5k_eeprom_read_pcal_info_5111(struct ath5k_hw *ah, int mode)
 {
@@ -747,30 +821,165 @@ ath5k_eeprom_read_pcal_info_5111(struct ath5k_hw *ah, int mode)
                         cdata->pcdac_max, cdata->pcdac);
         }
 
-        return 0;
+        return ath5k_eeprom_convert_pcal_info_5111(ah, mode, pcal);
 }
 
-/* Read power calibration for RF5112 chips
+
+/*
+ * Read power calibration for RF5112 chips
+ *
  * For RF5112 we have 4 XPD -eXternal Power Detector- curves
  * for each calibrated channel on 0, -6, -12 and -18dbm but we only
- * use the higher (3) and the lower (0) curves. Each curve has PCDAC
- * steps on x axis and power on y axis and looks like a linear
- * function. To recreate the curve and pass the power values
- * on the pcdac table, we read 4 points for xpd 0 and 3 points
- * for xpd 3 here and interpolate later.
+ * use the higher (3) and the lower (0) curves. Each curve has 0.5dB
+ * power steps on x axis and PCDAC steps on y axis and looks like a
+ * linear function. To recreate the curve and pass the power values
+ * on hw, we read 4 points for xpd 0 (lower gain -> max power)
+ * and 3 points for xpd 3 (higher gain -> lower power) here and
+ * interpolate later.
  *
  * Note: Many vendors just use xpd 0 so xpd 3 is zeroed.
  */
+
+/* Convert RF5112 specific data to generic raw data
+ * used by interpolation code */
+static int
+ath5k_eeprom_convert_pcal_info_5112(struct ath5k_hw *ah, int mode,
+                                struct ath5k_chan_pcal_info *chinfo)
+{
+        struct ath5k_eeprom_info *ee = &ah->ah_capabilities.cap_eeprom;
+        struct ath5k_chan_pcal_info_rf5112 *pcinfo;
+        u8 *pdgain_idx = ee->ee_pdc_to_idx[mode];
+        unsigned int pier, pdg, point;
+
+        /* Fill raw data for each calibration pier */
+        for (pier = 0; pier < ee->ee_n_piers[mode]; pier++) {
+
+                pcinfo = &chinfo[pier].rf5112_info;
+
+                /* Allocate pd_curves for this cal pier */
+                chinfo[pier].pd_curves =
+                                kcalloc(AR5K_EEPROM_N_PD_CURVES,
+                                        sizeof(struct ath5k_pdgain_info),
+                                        GFP_KERNEL);
+
+                if (!chinfo[pier].pd_curves)
+                        return -ENOMEM;
+
+                /* Fill pd_curves */
+                for (pdg = 0; pdg < ee->ee_pd_gains[mode]; pdg++) {
+
+                        u8 idx = pdgain_idx[pdg];
+                        struct ath5k_pdgain_info *pd =
+                                        &chinfo[pier].pd_curves[idx];
+
+                        /* Lowest gain curve (max power) */
+                        if (pdg == 0) {
+                                /* One more point for better accuracy */
+                                pd->pd_points = AR5K_EEPROM_N_XPD0_POINTS;
+
+                                /* Allocate pd points for this curve */
+                                pd->pd_step = kcalloc(pd->pd_points,
+                                                sizeof(u8), GFP_KERNEL);
+
+                                if (!pd->pd_step)
+                                        return -ENOMEM;
+
+                                pd->pd_pwr = kcalloc(pd->pd_points,
+                                                sizeof(s16), GFP_KERNEL);
+
+                                if (!pd->pd_pwr)
+                                        return -ENOMEM;
+
+
+                                /* Fill raw dataset
+                                 * (all power levels are in 0.25dB units) */
+                                pd->pd_step[0] = pcinfo->pcdac_x0[0];
+                                pd->pd_pwr[0] = pcinfo->pwr_x0[0];
+
+                                for (point = 1; point < pd->pd_points;
+                                point++) {
+                                        /* Absolute values */
+                                        pd->pd_pwr[point] =
+                                                pcinfo->pwr_x0[point];
+
+                                        /* Deltas */
+                                        pd->pd_step[point] =
+                                                pd->pd_step[point - 1] +
+                                                pcinfo->pcdac_x0[point];
+                                }
+
+                                /* Set min power for this frequency */
+                                chinfo[pier].min_pwr = pd->pd_pwr[0];
+
+                        /* Highest gain curve (min power) */
+                        } else if (pdg == 1) {
+
+                                pd->pd_points = AR5K_EEPROM_N_XPD3_POINTS;
+
+                                /* Allocate pd points for this curve */
+                                pd->pd_step = kcalloc(pd->pd_points,
+                                                sizeof(u8), GFP_KERNEL);
+
+                                if (!pd->pd_step)
+                                        return -ENOMEM;
+
+                                pd->pd_pwr = kcalloc(pd->pd_points,
+                                                sizeof(s16), GFP_KERNEL);
+
+                                if (!pd->pd_pwr)
+                                        return -ENOMEM;
+
+                                /* Fill raw dataset
+                                 * (all power levels are in 0.25dB units) */
+                                for (point = 0; point < pd->pd_points;
+                                point++) {
+                                        /* Absolute values */
+                                        pd->pd_pwr[point] =
+                                                pcinfo->pwr_x3[point];
+
+                                        /* Fixed points */
+                                        pd->pd_step[point] =
+                                                pcinfo->pcdac_x3[point];
+                                }
+
+                                /* Since we have a higher gain curve
+                                 * override min power */
+                                chinfo[pier].min_pwr = pd->pd_pwr[0];
+                        }
+                }
+        }
+
+        return 0;
+}
+
+/* Parse EEPROM data */
 static int
 ath5k_eeprom_read_pcal_info_5112(struct ath5k_hw *ah, int mode)
 {
         struct ath5k_eeprom_info *ee = &ah->ah_capabilities.cap_eeprom;
         struct ath5k_chan_pcal_info_rf5112 *chan_pcal_info;
         struct ath5k_chan_pcal_info *gen_chan_info;
+        u8 *pdgain_idx = ee->ee_pdc_to_idx[mode];
         u32 offset;
-        unsigned int i, c;
+        u8 i, c;
         u16 val;
         int ret;
+        u8 pd_gains = 0;
+
+        /* Count how many curves we have and
+         * identify them (which one of the 4
+         * available curves we have on each count).
+         * Curves are stored from lower (x0) to
+         * higher (x3) gain */
+        for (i = 0; i < AR5K_EEPROM_N_PD_CURVES; i++) {
+                /* ee_x_gain[mode] is x gain mask */
+                if ((ee->ee_x_gain[mode] >> i) & 0x1)
+                        pdgain_idx[pd_gains++] = i;
+        }
+        ee->ee_pd_gains[mode] = pd_gains;
+
+        if (pd_gains == 0 || pd_gains > 2)
+                return -EINVAL;
 
         switch (mode) {
         case AR5K_EEPROM_MODE_11A:
@@ -808,13 +1017,13 @@ ath5k_eeprom_read_pcal_info_5112(struct ath5k_hw *ah, int mode)
         for (i = 0; i < ee->ee_n_piers[mode]; i++) {
                 chan_pcal_info = &gen_chan_info[i].rf5112_info;
 
-                /* Power values in dBm * 4
+                /* Power values in quarter dB
                  * for the lower xpd gain curve
                  * (0 dBm -> higher output power) */
                 for (c = 0; c < AR5K_EEPROM_N_XPD0_POINTS; c++) {
                         AR5K_EEPROM_READ(offset++, val);
-                        chan_pcal_info->pwr_x0[c] = (val & 0xff);
-                        chan_pcal_info->pwr_x0[++c] = ((val >> 8) & 0xff);
+                        chan_pcal_info->pwr_x0[c] = (s8) (val & 0xff);
+                        chan_pcal_info->pwr_x0[++c] = (s8) ((val >> 8) & 0xff);
                 }
 
                 /* PCDAC steps
@@ -825,12 +1034,12 @@ ath5k_eeprom_read_pcal_info_5112(struct ath5k_hw *ah, int mode)
                 chan_pcal_info->pcdac_x0[2] = ((val >> 5) & 0x1f);
                 chan_pcal_info->pcdac_x0[3] = ((val >> 10) & 0x1f);
 
-                /* Power values in dBm * 4
+                /* Power values in quarter dB
                  * for the higher xpd gain curve
                  * (18 dBm -> lower output power) */
                 AR5K_EEPROM_READ(offset++, val);
-                chan_pcal_info->pwr_x3[0] = (val & 0xff);
-                chan_pcal_info->pwr_x3[1] = ((val >> 8) & 0xff);
+                chan_pcal_info->pwr_x3[0] = (s8) (val & 0xff);
+                chan_pcal_info->pwr_x3[1] = (s8) ((val >> 8) & 0xff);
 
                 AR5K_EEPROM_READ(offset++, val);
                 chan_pcal_info->pwr_x3[2] = (val & 0xff);
@@ -843,24 +1052,36 @@ ath5k_eeprom_read_pcal_info_5112(struct ath5k_hw *ah, int mode)
                 chan_pcal_info->pcdac_x3[2] = 63;
 
                 if (ee->ee_version >= AR5K_EEPROM_VERSION_4_3) {
-                        chan_pcal_info->pcdac_x0[0] = ((val >> 8) & 0xff);
+                        chan_pcal_info->pcdac_x0[0] = ((val >> 8) & 0x3f);
 
                         /* Last xpd0 power level is also channel maximum */
                         gen_chan_info[i].max_pwr = chan_pcal_info->pwr_x0[3];
                 } else {
                         chan_pcal_info->pcdac_x0[0] = 1;
-                        gen_chan_info[i].max_pwr = ((val >> 8) & 0xff);
+                        gen_chan_info[i].max_pwr = (s8) ((val >> 8) & 0xff);
                 }
 
-                /* Recreate pcdac_x0 table for this channel using pcdac steps */
-                chan_pcal_info->pcdac_x0[1] += chan_pcal_info->pcdac_x0[0];
-                chan_pcal_info->pcdac_x0[2] += chan_pcal_info->pcdac_x0[1];
-                chan_pcal_info->pcdac_x0[3] += chan_pcal_info->pcdac_x0[2];
         }
 
-        return 0;
+        return ath5k_eeprom_convert_pcal_info_5112(ah, mode, gen_chan_info);
 }
 
+
+/*
+ * Read power calibration for RF2413 chips
+ *
+ * For RF2413 we have a Power to PDDAC table (Power Detector)
+ * instead of a PCDAC and 4 pd gain curves for each calibrated channel.
+ * Each curve has power on x axis in 0.5 db steps and PDDADC steps on y
+ * axis and looks like an exponential function like the RF5111 curve.
+ *
+ * To recreate the curves we read here the points and interpolate
+ * later. Note that in most cases only 2 (higher and lower) curves are
+ * used (like RF5112) but vendors have the oportunity to include all
+ * 4 curves on eeprom. The final curve (higher power) has an extra
+ * point for better accuracy like RF5112.
+ */
+
 /* For RF2413 power calibration data doesn't start on a fixed location and
  * if a mode is not supported, it's section is missing -not zeroed-.
  * So we need to calculate the starting offset for each section by using
@@ -890,13 +1111,15 @@ ath5k_cal_data_offset_2413(struct ath5k_eeprom_info *ee, int mode)
         switch(mode) {
         case AR5K_EEPROM_MODE_11G:
                 if (AR5K_EEPROM_HDR_11B(ee->ee_header))
-                        offset += ath5k_pdgains_size_2413(ee, AR5K_EEPROM_MODE_11B) +
-                                                        AR5K_EEPROM_N_2GHZ_CHAN_2413 / 2;
+                        offset += ath5k_pdgains_size_2413(ee,
+                                        AR5K_EEPROM_MODE_11B) +
+                                        AR5K_EEPROM_N_2GHZ_CHAN_2413 / 2;
                 /* fall through */
         case AR5K_EEPROM_MODE_11B:
                 if (AR5K_EEPROM_HDR_11A(ee->ee_header))
-                        offset += ath5k_pdgains_size_2413(ee, AR5K_EEPROM_MODE_11A) +
-                                                        AR5K_EEPROM_N_5GHZ_CHAN / 2;
+                        offset += ath5k_pdgains_size_2413(ee,
+                                        AR5K_EEPROM_MODE_11A) +
+                                        AR5K_EEPROM_N_5GHZ_CHAN / 2;
                 /* fall through */
         case AR5K_EEPROM_MODE_11A:
                 break;
@@ -907,37 +1130,118 @@ ath5k_cal_data_offset_2413(struct ath5k_eeprom_info *ee, int mode)
         return offset;
 }
 
-/* Read power calibration for RF2413 chips
- * For RF2413 we have a PDDAC table (Power Detector) instead
- * of a PCDAC and 4 pd gain curves for each calibrated channel.
- * Each curve has PDDAC steps on x axis and power on y axis and
- * looks like an exponential function. To recreate the curves
- * we read here the points and interpolate later. Note that
- * in most cases only higher and lower curves are used (like
- * RF5112) but vendors have the oportunity to include all 4
- * curves on eeprom. The final curve (higher power) has an extra
- * point for better accuracy like RF5112.
- */
+/* Convert RF2413 specific data to generic raw data
+ * used by interpolation code */
+static int
+ath5k_eeprom_convert_pcal_info_2413(struct ath5k_hw *ah, int mode,
+                                struct ath5k_chan_pcal_info *chinfo)
+{
+        struct ath5k_eeprom_info *ee = &ah->ah_capabilities.cap_eeprom;
+        struct ath5k_chan_pcal_info_rf2413 *pcinfo;
+        u8 *pdgain_idx = ee->ee_pdc_to_idx[mode];
+        unsigned int pier, pdg, point;
+
+        /* Fill raw data for each calibration pier */
+        for (pier = 0; pier < ee->ee_n_piers[mode]; pier++) {
+
+                pcinfo = &chinfo[pier].rf2413_info;
+
+                /* Allocate pd_curves for this cal pier */
+                chinfo[pier].pd_curves =
+                                kcalloc(AR5K_EEPROM_N_PD_CURVES,
+                                        sizeof(struct ath5k_pdgain_info),
+                                        GFP_KERNEL);
+
+                if (!chinfo[pier].pd_curves)
+                        return -ENOMEM;
+
+                /* Fill pd_curves */
+                for (pdg = 0; pdg < ee->ee_pd_gains[mode]; pdg++) {
+
+                        u8 idx = pdgain_idx[pdg];
+                        struct ath5k_pdgain_info *pd =
+                                        &chinfo[pier].pd_curves[idx];
+
+                        /* One more point for the highest power
+                         * curve (lowest gain) */
+                        if (pdg == ee->ee_pd_gains[mode] - 1)
+                                pd->pd_points = AR5K_EEPROM_N_PD_POINTS;
+                        else
+                                pd->pd_points = AR5K_EEPROM_N_PD_POINTS - 1;
+
+                        /* Allocate pd points for this curve */
+                        pd->pd_step = kcalloc(pd->pd_points,
+                                        sizeof(u8), GFP_KERNEL);
+
+                        if (!pd->pd_step)
+                                return -ENOMEM;
+
+                        pd->pd_pwr = kcalloc(pd->pd_points,
+                                        sizeof(s16), GFP_KERNEL);
+
+                        if (!pd->pd_pwr)
+                                return -ENOMEM;
+
+                        /* Fill raw dataset
+                         * convert all pwr levels to
+                         * quarter dB for RF5112 combatibility */
+                        pd->pd_step[0] = pcinfo->pddac_i[pdg];
+                        pd->pd_pwr[0] = 4 * pcinfo->pwr_i[pdg];
+
+                        for (point = 1; point < pd->pd_points; point++) {
+
+                                pd->pd_pwr[point] = pd->pd_pwr[point - 1] +
+                                        2 * pcinfo->pwr[pdg][point - 1];
+
+                                pd->pd_step[point] = pd->pd_step[point - 1] +
+                                                pcinfo->pddac[pdg][point - 1];
+
+                        }
+
+                        /* Highest gain curve -> min power */
+                        if (pdg == 0)
+                                chinfo[pier].min_pwr = pd->pd_pwr[0];
+
+                        /* Lowest gain curve -> max power */
+                        if (pdg == ee->ee_pd_gains[mode] - 1)
+                                chinfo[pier].max_pwr =
+                                        pd->pd_pwr[pd->pd_points - 1];
+                }
+        }
+
+        return 0;
+}
+
+/* Parse EEPROM data */
 static int
 ath5k_eeprom_read_pcal_info_2413(struct ath5k_hw *ah, int mode)
 {
         struct ath5k_eeprom_info *ee = &ah->ah_capabilities.cap_eeprom;
-        struct ath5k_chan_pcal_info_rf2413 *chan_pcal_info;
-        struct ath5k_chan_pcal_info *gen_chan_info;
-        unsigned int i, c;
+        struct ath5k_chan_pcal_info_rf2413 *pcinfo;
+        struct ath5k_chan_pcal_info *chinfo;
+        u8 *pdgain_idx = ee->ee_pdc_to_idx[mode];
         u32 offset;
-        int ret;
+        int idx, i, ret;
         u16 val;
         u8 pd_gains = 0;
 
-        if (ee->ee_x_gain[mode] & 0x1) pd_gains++;
-        if ((ee->ee_x_gain[mode] >> 1) & 0x1) pd_gains++;
-        if ((ee->ee_x_gain[mode] >> 2) & 0x1) pd_gains++;
-        if ((ee->ee_x_gain[mode] >> 3) & 0x1) pd_gains++;
+        /* Count how many curves we have and
+         * identify them (which one of the 4
+         * available curves we have on each count).
+         * Curves are stored from higher to
+         * lower gain so we go backwards */
+        for (idx = AR5K_EEPROM_N_PD_CURVES - 1; idx >= 0; idx--) {
+                /* ee_x_gain[mode] is x gain mask */
+                if ((ee->ee_x_gain[mode] >> idx) & 0x1)
+                        pdgain_idx[pd_gains++] = idx;
+
+        }
         ee->ee_pd_gains[mode] = pd_gains;
 
+        if (pd_gains == 0)
+                return -EINVAL;
+
         offset = ath5k_cal_data_offset_2413(ee, mode);
-        ee->ee_n_piers[mode] = 0;
         switch (mode) {
         case AR5K_EEPROM_MODE_11A:
                 if (!AR5K_EEPROM_HDR_11A(ee->ee_header))
@@ -945,7 +1249,7 @@ ath5k_eeprom_read_pcal_info_2413(struct ath5k_hw *ah, int mode)
 
                 ath5k_eeprom_init_11a_pcal_freq(ah, offset);
                 offset += AR5K_EEPROM_N_5GHZ_CHAN / 2;
-                gen_chan_info = ee->ee_pwr_cal_a;
+                chinfo = ee->ee_pwr_cal_a;
                 break;
         case AR5K_EEPROM_MODE_11B:
                 if (!AR5K_EEPROM_HDR_11B(ee->ee_header))
@@ -953,7 +1257,7 @@ ath5k_eeprom_read_pcal_info_2413(struct ath5k_hw *ah, int mode)
 
                 ath5k_eeprom_init_11bg_2413(ah, mode, offset);
                 offset += AR5K_EEPROM_N_2GHZ_CHAN_2413 / 2;
-                gen_chan_info = ee->ee_pwr_cal_b;
+                chinfo = ee->ee_pwr_cal_b;
                 break;
         case AR5K_EEPROM_MODE_11G:
                 if (!AR5K_EEPROM_HDR_11G(ee->ee_header))
@@ -961,41 +1265,35 @@ ath5k_eeprom_read_pcal_info_2413(struct ath5k_hw *ah, int mode)
 
                 ath5k_eeprom_init_11bg_2413(ah, mode, offset);
                 offset += AR5K_EEPROM_N_2GHZ_CHAN_2413 / 2;
-                gen_chan_info = ee->ee_pwr_cal_g;
+                chinfo = ee->ee_pwr_cal_g;
                 break;
         default:
                 return -EINVAL;
         }
 
-        if (pd_gains == 0)
-                return 0;
-
         for (i = 0; i < ee->ee_n_piers[mode]; i++) {
-                chan_pcal_info = &gen_chan_info[i].rf2413_info;
+                pcinfo = &chinfo[i].rf2413_info;
 
                 /*
                  * Read pwr_i, pddac_i and the first
                  * 2 pd points (pwr, pddac)
                  */
                 AR5K_EEPROM_READ(offset++, val);
-                chan_pcal_info->pwr_i[0] = val & 0x1f;
-                chan_pcal_info->pddac_i[0] = (val >> 5) & 0x7f;
-                chan_pcal_info->pwr[0][0] =
-                                        (val >> 12) & 0xf;
+                pcinfo->pwr_i[0] = val & 0x1f;
+                pcinfo->pddac_i[0] = (val >> 5) & 0x7f;
+                pcinfo->pwr[0][0] = (val >> 12) & 0xf;
 
                 AR5K_EEPROM_READ(offset++, val);
-                chan_pcal_info->pddac[0][0] = val & 0x3f;
-                chan_pcal_info->pwr[0][1] = (val >> 6) & 0xf;
-                chan_pcal_info->pddac[0][1] =
-                                        (val >> 10) & 0x3f;
+                pcinfo->pddac[0][0] = val & 0x3f;
+                pcinfo->pwr[0][1] = (val >> 6) & 0xf;
+                pcinfo->pddac[0][1] = (val >> 10) & 0x3f;
 
                 AR5K_EEPROM_READ(offset++, val);
-                chan_pcal_info->pwr[0][2] = val & 0xf;
-                chan_pcal_info->pddac[0][2] =
-                                        (val >> 4) & 0x3f;
+                pcinfo->pwr[0][2] = val & 0xf;
+                pcinfo->pddac[0][2] = (val >> 4) & 0x3f;
 
-                chan_pcal_info->pwr[0][3] = 0;
-                chan_pcal_info->pddac[0][3] = 0;
+                pcinfo->pwr[0][3] = 0;
+                pcinfo->pddac[0][3] = 0;
 
                 if (pd_gains > 1) {
                         /*
@@ -1003,44 +1301,36 @@ ath5k_eeprom_read_pcal_info_2413(struct ath5k_hw *ah, int mode)
                          * so it only has 2 pd points.
                          * Continue wih pd gain 1.
                          */
-                        chan_pcal_info->pwr_i[1] = (val >> 10) & 0x1f;
+                        pcinfo->pwr_i[1] = (val >> 10) & 0x1f;
 
-                        chan_pcal_info->pddac_i[1] = (val >> 15) & 0x1;
+                        pcinfo->pddac_i[1] = (val >> 15) & 0x1;
                         AR5K_EEPROM_READ(offset++, val);
-                        chan_pcal_info->pddac_i[1] |= (val & 0x3F) << 1;
+                        pcinfo->pddac_i[1] |= (val & 0x3F) << 1;
 
-                        chan_pcal_info->pwr[1][0] = (val >> 6) & 0xf;
-                        chan_pcal_info->pddac[1][0] =
-                                                (val >> 10) & 0x3f;
+                        pcinfo->pwr[1][0] = (val >> 6) & 0xf;
+                        pcinfo->pddac[1][0] = (val >> 10) & 0x3f;
 
                         AR5K_EEPROM_READ(offset++, val);
-                        chan_pcal_info->pwr[1][1] = val & 0xf;
-                        chan_pcal_info->pddac[1][1] =
-                                                (val >> 4) & 0x3f;
-                        chan_pcal_info->pwr[1][2] =
-                                                (val >> 10) & 0xf;
-
-                        chan_pcal_info->pddac[1][2] =
-                                                (val >> 14) & 0x3;
+                        pcinfo->pwr[1][1] = val & 0xf;
+                        pcinfo->pddac[1][1] = (val >> 4) & 0x3f;
+                        pcinfo->pwr[1][2] = (val >> 10) & 0xf;
+
+                        pcinfo->pddac[1][2] = (val >> 14) & 0x3;
                         AR5K_EEPROM_READ(offset++, val);
-                        chan_pcal_info->pddac[1][2] |=
-                                                (val & 0xF) << 2;
+                        pcinfo->pddac[1][2] |= (val & 0xF) << 2;
 
-                        chan_pcal_info->pwr[1][3] = 0;
-                        chan_pcal_info->pddac[1][3] = 0;
+                        pcinfo->pwr[1][3] = 0;
+                        pcinfo->pddac[1][3] = 0;
                 } else if (pd_gains == 1) {
                         /*
                          * Pd gain 0 is the last one so
                          * read the extra point.
                          */
-                        chan_pcal_info->pwr[0][3] =
-                                                (val >> 10) & 0xf;
+                        pcinfo->pwr[0][3] = (val >> 10) & 0xf;
 
-                        chan_pcal_info->pddac[0][3] =
-                                                (val >> 14) & 0x3;
+                        pcinfo->pddac[0][3] = (val >> 14) & 0x3;
                         AR5K_EEPROM_READ(offset++, val);
-                        chan_pcal_info->pddac[0][3] |=
-                                                (val & 0xF) << 2;
+                        pcinfo->pddac[0][3] |= (val & 0xF) << 2;
                 }
 
                 /*
@@ -1048,105 +1338,65 @@ ath5k_eeprom_read_pcal_info_2413(struct ath5k_hw *ah, int mode)
                  * as above.
                  */
                 if (pd_gains > 2) {
-                        chan_pcal_info->pwr_i[2] = (val >> 4) & 0x1f;
-                        chan_pcal_info->pddac_i[2] = (val >> 9) & 0x7f;
+                        pcinfo->pwr_i[2] = (val >> 4) & 0x1f;
+                        pcinfo->pddac_i[2] = (val >> 9) & 0x7f;
 
                         AR5K_EEPROM_READ(offset++, val);
-                        chan_pcal_info->pwr[2][0] =
-                                                (val >> 0) & 0xf;
-                        chan_pcal_info->pddac[2][0] =
-                                                (val >> 4) & 0x3f;
-                        chan_pcal_info->pwr[2][1] =
-                                                (val >> 10) & 0xf;
-
-                        chan_pcal_info->pddac[2][1] =
-                                                (val >> 14) & 0x3;
+                        pcinfo->pwr[2][0] = (val >> 0) & 0xf;
+                        pcinfo->pddac[2][0] = (val >> 4) & 0x3f;
+                        pcinfo->pwr[2][1] = (val >> 10) & 0xf;
+
+                        pcinfo->pddac[2][1] = (val >> 14) & 0x3;
                         AR5K_EEPROM_READ(offset++, val);
-                        chan_pcal_info->pddac[2][1] |=
-                                                (val & 0xF) << 2;
+                        pcinfo->pddac[2][1] |= (val & 0xF) << 2;
 
-                        chan_pcal_info->pwr[2][2] =
-                                                (val >> 4) & 0xf;
-                        chan_pcal_info->pddac[2][2] =
-                                                (val >> 8) & 0x3f;
+                        pcinfo->pwr[2][2] = (val >> 4) & 0xf;
+                        pcinfo->pddac[2][2] = (val >> 8) & 0x3f;
 
-                        chan_pcal_info->pwr[2][3] = 0;
-                        chan_pcal_info->pddac[2][3] = 0;
+                        pcinfo->pwr[2][3] = 0;
+                        pcinfo->pddac[2][3] = 0;
                 } else if (pd_gains == 2) {
-                        chan_pcal_info->pwr[1][3] =
-                                                (val >> 4) & 0xf;
-                        chan_pcal_info->pddac[1][3] =
-                                                (val >> 8) & 0x3f;
+                        pcinfo->pwr[1][3] = (val >> 4) & 0xf;
+                        pcinfo->pddac[1][3] = (val >> 8) & 0x3f;
                 }
 
                 if (pd_gains > 3) {
-                        chan_pcal_info->pwr_i[3] = (val >> 14) & 0x3;
+                        pcinfo->pwr_i[3] = (val >> 14) & 0x3;
                         AR5K_EEPROM_READ(offset++, val);
-                        chan_pcal_info->pwr_i[3] |= ((val >> 0) & 0x7) << 2;
+                        pcinfo->pwr_i[3] |= ((val >> 0) & 0x7) << 2;
 
-                        chan_pcal_info->pddac_i[3] = (val >> 3) & 0x7f;
-                        chan_pcal_info->pwr[3][0] =
-                                                (val >> 10) & 0xf;
-                        chan_pcal_info->pddac[3][0] =
-                                                (val >> 14) & 0x3;
+                        pcinfo->pddac_i[3] = (val >> 3) & 0x7f;
+                        pcinfo->pwr[3][0] = (val >> 10) & 0xf;
+                        pcinfo->pddac[3][0] = (val >> 14) & 0x3;
 
                         AR5K_EEPROM_READ(offset++, val);
-                        chan_pcal_info->pddac[3][0] |=
-                                                (val & 0xF) << 2;
-                        chan_pcal_info->pwr[3][1] =
-                                                (val >> 4) & 0xf;
-                        chan_pcal_info->pddac[3][1] =
-                                                (val >> 8) & 0x3f;
-
-                        chan_pcal_info->pwr[3][2] =
-                                                (val >> 14) & 0x3;
+                        pcinfo->pddac[3][0] |= (val & 0xF) << 2;
+                        pcinfo->pwr[3][1] = (val >> 4) & 0xf;
+                        pcinfo->pddac[3][1] = (val >> 8) & 0x3f;
+
+                        pcinfo->pwr[3][2] = (val >> 14) & 0x3;
                         AR5K_EEPROM_READ(offset++, val);
-                        chan_pcal_info->pwr[3][2] |=
-                                                ((val >> 0) & 0x3) << 2;
+                        pcinfo->pwr[3][2] |= ((val >> 0) & 0x3) << 2;
 
-                        chan_pcal_info->pddac[3][2] =
-                                                (val >> 2) & 0x3f;
-                        chan_pcal_info->pwr[3][3] =
-                                                (val >> 8) & 0xf;
+                        pcinfo->pddac[3][2] = (val >> 2) & 0x3f;
+                        pcinfo->pwr[3][3] = (val >> 8) & 0xf;
 
-                        chan_pcal_info->pddac[3][3] =
-                                                (val >> 12) & 0xF;
+                        pcinfo->pddac[3][3] = (val >> 12) & 0xF;
                         AR5K_EEPROM_READ(offset++, val);
-                        chan_pcal_info->pddac[3][3] |=
-                                                ((val >> 0) & 0x3) << 4;
+                        pcinfo->pddac[3][3] |= ((val >> 0) & 0x3) << 4;
                 } else if (pd_gains == 3) {
-                        chan_pcal_info->pwr[2][3] =
-                                                (val >> 14) & 0x3;
+                        pcinfo->pwr[2][3] = (val >> 14) & 0x3;
                         AR5K_EEPROM_READ(offset++, val);
-                        chan_pcal_info->pwr[2][3] |=
-                                                ((val >> 0) & 0x3) << 2;
-
-                        chan_pcal_info->pddac[2][3] =
-                                                (val >> 2) & 0x3f;
-                }
+                        pcinfo->pwr[2][3] |= ((val >> 0) & 0x3) << 2;
 
-                for (c = 0; c < pd_gains; c++) {
-                        /* Recreate pwr table for this channel using pwr steps */
-                        chan_pcal_info->pwr[c][0] += chan_pcal_info->pwr_i[c] * 2;
-                        chan_pcal_info->pwr[c][1] += chan_pcal_info->pwr[c][0];
-                        chan_pcal_info->pwr[c][2] += chan_pcal_info->pwr[c][1];
-                        chan_pcal_info->pwr[c][3] += chan_pcal_info->pwr[c][2];
-                        if (chan_pcal_info->pwr[c][3] == chan_pcal_info->pwr[c][2])
-                                chan_pcal_info->pwr[c][3] = 0;
-
-                        /* Recreate pddac table for this channel using pddac steps */
-                        chan_pcal_info->pddac[c][0] += chan_pcal_info->pddac_i[c];
-                        chan_pcal_info->pddac[c][1] += chan_pcal_info->pddac[c][0];
-                        chan_pcal_info->pddac[c][2] += chan_pcal_info->pddac[c][1];
-                        chan_pcal_info->pddac[c][3] += chan_pcal_info->pddac[c][2];
-                        if (chan_pcal_info->pddac[c][3] == chan_pcal_info->pddac[c][2])
-                                chan_pcal_info->pddac[c][3] = 0;
+                        pcinfo->pddac[2][3] = (val >> 2) & 0x3f;
                 }
         }
 
-        return 0;
+        return ath5k_eeprom_convert_pcal_info_2413(ah, mode, chinfo);
 }
 
+
 /*
  * Read per rate target power (this is the maximum tx power
  * supported by the card). This info is used when setting
@@ -1154,11 +1404,12 @@ ath5k_eeprom_read_pcal_info_2413(struct ath5k_hw *ah, int mode)
  *
  * This also works for v5 EEPROMs.
  */
-static int ath5k_eeprom_read_target_rate_pwr_info(struct ath5k_hw *ah, unsigned int mode)
+static int
+ath5k_eeprom_read_target_rate_pwr_info(struct ath5k_hw *ah, unsigned int mode)
 {
         struct ath5k_eeprom_info *ee = &ah->ah_capabilities.cap_eeprom;
         struct ath5k_rate_pcal_info *rate_pcal_info;
-        u16 *rate_target_pwr_num;
+        u8 *rate_target_pwr_num;
         u32 offset;
         u16 val;
         int ret, i;
@@ -1264,7 +1515,9 @@ ath5k_eeprom_read_pcal_info(struct ath5k_hw *ah)
         else
                 read_pcal = ath5k_eeprom_read_pcal_info_5111;
 
-        for (mode = AR5K_EEPROM_MODE_11A; mode <= AR5K_EEPROM_MODE_11G; mode++) {
+
+        for (mode = AR5K_EEPROM_MODE_11A; mode <= AR5K_EEPROM_MODE_11G;
+        mode++) {
                 err = read_pcal(ah, mode);
                 if (err)
                         return err;
@@ -1277,6 +1530,62 @@ ath5k_eeprom_read_pcal_info(struct ath5k_hw *ah)
         return 0;
 }
 
+static int
+ath5k_eeprom_free_pcal_info(struct ath5k_hw *ah, int mode)
+{
+        struct ath5k_eeprom_info *ee = &ah->ah_capabilities.cap_eeprom;
+        struct ath5k_chan_pcal_info *chinfo;
+        u8 pier, pdg;
+
+        switch (mode) {
+        case AR5K_EEPROM_MODE_11A:
+                if (!AR5K_EEPROM_HDR_11A(ee->ee_header))
+                        return 0;
+                chinfo = ee->ee_pwr_cal_a;
+                break;
+        case AR5K_EEPROM_MODE_11B:
+                if (!AR5K_EEPROM_HDR_11B(ee->ee_header))
+                        return 0;
+                chinfo = ee->ee_pwr_cal_b;
+                break;
+        case AR5K_EEPROM_MODE_11G:
+                if (!AR5K_EEPROM_HDR_11G(ee->ee_header))
+                        return 0;
+                chinfo = ee->ee_pwr_cal_g;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        for (pier = 0; pier < ee->ee_n_piers[mode]; pier++) {
+                if (!chinfo[pier].pd_curves)
+                        continue;
+
+                for (pdg = 0; pdg < ee->ee_pd_gains[mode]; pdg++) {
+                        struct ath5k_pdgain_info *pd =
+                                        &chinfo[pier].pd_curves[pdg];
+
+                        if (pd != NULL) {
+                                kfree(pd->pd_step);
+                                kfree(pd->pd_pwr);
+                        }
+                }
+
+                kfree(chinfo[pier].pd_curves);
+        }
+
+        return 0;
+}
+
+void
+ath5k_eeprom_detach(struct ath5k_hw *ah)
+{
+        u8 mode;
+
+        for (mode = AR5K_EEPROM_MODE_11A; mode <= AR5K_EEPROM_MODE_11G; mode++)
+                ath5k_eeprom_free_pcal_info(ah, mode);
+}
+
 /* Read conformance test limits used for regulatory control */
 static int
 ath5k_eeprom_read_ctl_info(struct ath5k_hw *ah)
@@ -1457,3 +1766,4 @@ bool ath5k_eeprom_is_hb63(struct ath5k_hw *ah)
         else
                 return false;
 }
+
diff --git a/drivers/net/wireless/ath5k/eeprom.h b/drivers/net/wireless/ath5k/eeprom.h
index 1deebc0257d4..b0c0606dea0b 100644
--- a/drivers/net/wireless/ath5k/eeprom.h
+++ b/drivers/net/wireless/ath5k/eeprom.h
@@ -173,6 +173,7 @@
 #define AR5K_EEPROM_N_5GHZ_CHAN         10
 #define AR5K_EEPROM_N_2GHZ_CHAN         3
 #define AR5K_EEPROM_N_2GHZ_CHAN_2413    4
+#define AR5K_EEPROM_N_2GHZ_CHAN_MAX     4
 #define AR5K_EEPROM_MAX_CHAN            10
 #define AR5K_EEPROM_N_PWR_POINTS_5111   11
 #define AR5K_EEPROM_N_PCDAC             11
@@ -193,7 +194,7 @@
 #define AR5K_EEPROM_SCALE_OC_DELTA(_x)  (((_x) * 2) / 10)
 #define AR5K_EEPROM_N_CTLS(_v)          AR5K_EEPROM_OFF(_v, 16, 32)
 #define AR5K_EEPROM_MAX_CTLS            32
-#define AR5K_EEPROM_N_XPD_PER_CHANNEL   4
+#define AR5K_EEPROM_N_PD_CURVES         4
 #define AR5K_EEPROM_N_XPD0_POINTS       4
 #define AR5K_EEPROM_N_XPD3_POINTS       3
 #define AR5K_EEPROM_N_PD_GAINS          4
@@ -232,7 +233,7 @@ enum ath5k_ctl_mode {
         AR5K_CTL_11B = 1,
         AR5K_CTL_11G = 2,
         AR5K_CTL_TURBO = 3,
-        AR5K_CTL_108G = 4,
+        AR5K_CTL_TURBOG = 4,
         AR5K_CTL_2GHT20 = 5,
         AR5K_CTL_5GHT20 = 6,
         AR5K_CTL_2GHT40 = 7,
@@ -240,65 +241,114 @@ enum ath5k_ctl_mode {
         AR5K_CTL_MODE_M = 15,
 };
 
+/* Default CTL ids for the 3 main reg domains.
+ * Atheros only uses these by default but vendors
+ * can have up to 32 different CTLs for different
+ * scenarios. Note that theese values are ORed with
+ * the mode id (above) so we can have up to 24 CTL
+ * datasets out of these 3 main regdomains. That leaves
+ * 8 ids that can be used by vendors and since 0x20 is
+ * missing from HAL sources i guess this is the set of
+ * custom CTLs vendors can use. */
+#define AR5K_CTL_FCC    0x10
+#define AR5K_CTL_CUSTOM 0x20
+#define AR5K_CTL_ETSI   0x30
+#define AR5K_CTL_MKK    0x40
+
+/* Indicates a CTL with only mode set and
+ * no reg domain mapping, such CTLs are used
+ * for world roaming domains or simply when
+ * a reg domain is not set */
+#define AR5K_CTL_NO_REGDOMAIN   0xf0
+
+/* Indicates an empty (invalid) CTL */
+#define AR5K_CTL_NO_CTL         0xff
+
 /* Per channel calibration data, used for power table setup */
 struct ath5k_chan_pcal_info_rf5111 {
         /* Power levels in half dbm units
          * for one power curve. */
-        u8              pwr[AR5K_EEPROM_N_PWR_POINTS_5111];
+        u8 pwr[AR5K_EEPROM_N_PWR_POINTS_5111];
         /* PCDAC table steps
          * for the above values */
-        u8              pcdac[AR5K_EEPROM_N_PWR_POINTS_5111];
+        u8 pcdac[AR5K_EEPROM_N_PWR_POINTS_5111];
         /* Starting PCDAC step */
-        u8              pcdac_min;
+        u8 pcdac_min;
         /* Final PCDAC step */
-        u8              pcdac_max;
+        u8 pcdac_max;
 };
 
 struct ath5k_chan_pcal_info_rf5112 {
         /* Power levels in quarter dBm units
          * for lower (0) and higher (3)
-         * level curves */
-        s8              pwr_x0[AR5K_EEPROM_N_XPD0_POINTS];
-        s8              pwr_x3[AR5K_EEPROM_N_XPD3_POINTS];
+         * level curves in 0.25dB units */
+        s8 pwr_x0[AR5K_EEPROM_N_XPD0_POINTS];
+        s8 pwr_x3[AR5K_EEPROM_N_XPD3_POINTS];
         /* PCDAC table steps
          * for the above values */
-        u8      pcdac_x0[AR5K_EEPROM_N_XPD0_POINTS];
-        u8      pcdac_x3[AR5K_EEPROM_N_XPD3_POINTS];
+        u8 pcdac_x0[AR5K_EEPROM_N_XPD0_POINTS];
+        u8 pcdac_x3[AR5K_EEPROM_N_XPD3_POINTS];
 };
 
 struct ath5k_chan_pcal_info_rf2413 {
         /* Starting pwr/pddac values */
-        s8              pwr_i[AR5K_EEPROM_N_PD_GAINS];
-        u8      pddac_i[AR5K_EEPROM_N_PD_GAINS];
-        /* (pwr,pddac) points */
-        s8              pwr[AR5K_EEPROM_N_PD_GAINS]
-                                [AR5K_EEPROM_N_PD_POINTS];
-        u8      pddac[AR5K_EEPROM_N_PD_GAINS]
-                                [AR5K_EEPROM_N_PD_POINTS];
+        s8 pwr_i[AR5K_EEPROM_N_PD_GAINS];
+        u8 pddac_i[AR5K_EEPROM_N_PD_GAINS];
+        /* (pwr,pddac) points
+         * power levels in 0.5dB units */
+        s8 pwr[AR5K_EEPROM_N_PD_GAINS]
+                [AR5K_EEPROM_N_PD_POINTS];
+        u8 pddac[AR5K_EEPROM_N_PD_GAINS]
+                [AR5K_EEPROM_N_PD_POINTS];
+};
+
+enum ath5k_powertable_type {
+        AR5K_PWRTABLE_PWR_TO_PCDAC = 0,
+        AR5K_PWRTABLE_LINEAR_PCDAC = 1,
+        AR5K_PWRTABLE_PWR_TO_PDADC = 2,
+};
+
+struct ath5k_pdgain_info {
+        u8 pd_points;
+        u8 *pd_step;
+        /* Power values are in
+         * 0.25dB units */
+        s16 *pd_pwr;
 };
 
 struct ath5k_chan_pcal_info {
         /* Frequency */
         u16     freq;
-        /* Max available power */
-        s8              max_pwr;
+        /* Tx power boundaries */
+        s16     max_pwr;
+        s16     min_pwr;
         union {
                 struct ath5k_chan_pcal_info_rf5111 rf5111_info;
                 struct ath5k_chan_pcal_info_rf5112 rf5112_info;
                 struct ath5k_chan_pcal_info_rf2413 rf2413_info;
         };
+        /* Raw values used by phy code
+         * Curves are stored in order from lower
+         * gain to higher gain (max txpower -> min txpower) */
+        struct ath5k_pdgain_info *pd_curves;
 };
 
-/* Per rate calibration data for each mode, used for power table setup */
+/* Per rate calibration data for each mode,
+ * used for rate power table setup.
+ * Note: Values in 0.5dB units */
 struct ath5k_rate_pcal_info {
         u16     freq; /* Frequency */
-        /* Power level for 6-24Mbit/s rates */
+        /* Power level for 6-24Mbit/s rates or
+         * 1Mb rate */
         u16     target_power_6to24;
-        /* Power level for 36Mbit rate */
+        /* Power level for 36Mbit rate or
+         * 2Mb rate */
         u16     target_power_36;
-        /* Power level for 48Mbit rate */
+        /* Power level for 48Mbit rate or
+         * 5.5Mbit rate */
         u16     target_power_48;
-        /* Power level for 54Mbit rate */
+        /* Power level for 54Mbit rate or
+         * 11Mbit rate */
         u16     target_power_54;
 };
 
@@ -330,12 +380,6 @@ struct ath5k_eeprom_info {
         u16     ee_cck_ofdm_power_delta;
         u16     ee_scaled_cck_delta;
 
-        /* Used for tx thermal adjustment (eeprom_init, rfregs) */
-        u16     ee_tx_clip;
-        u16     ee_pwd_84;
-        u16     ee_pwd_90;
-        u16     ee_gain_select;
-
         /* RF Calibration settings (reset, rfregs) */
         u16     ee_i_cal[AR5K_EEPROM_N_MODES];
         u16     ee_q_cal[AR5K_EEPROM_N_MODES];
@@ -363,23 +407,25 @@ struct ath5k_eeprom_info {
         /* Power calibration data */
         u16     ee_false_detect[AR5K_EEPROM_N_MODES];
 
-        /* Number of pd gain curves per mode (RF2413) */
-        u8 ee_pd_gains[AR5K_EEPROM_N_MODES];
+        /* Number of pd gain curves per mode */
+        u8      ee_pd_gains[AR5K_EEPROM_N_MODES];
+        /* Back mapping pdcurve number -> pdcurve index in pd->pd_curves */
+        u8      ee_pdc_to_idx[AR5K_EEPROM_N_MODES][AR5K_EEPROM_N_PD_GAINS];
 
-        u8 ee_n_piers[AR5K_EEPROM_N_MODES];
+        u8      ee_n_piers[AR5K_EEPROM_N_MODES];
         struct ath5k_chan_pcal_info     ee_pwr_cal_a[AR5K_EEPROM_N_5GHZ_CHAN];
-        struct ath5k_chan_pcal_info     ee_pwr_cal_b[AR5K_EEPROM_N_2GHZ_CHAN];
-        struct ath5k_chan_pcal_info     ee_pwr_cal_g[AR5K_EEPROM_N_2GHZ_CHAN];
+        struct ath5k_chan_pcal_info     ee_pwr_cal_b[AR5K_EEPROM_N_2GHZ_CHAN_MAX];
+        struct ath5k_chan_pcal_info     ee_pwr_cal_g[AR5K_EEPROM_N_2GHZ_CHAN_MAX];
 
         /* Per rate target power levels */
-        u16     ee_rate_target_pwr_num[AR5K_EEPROM_N_MODES];
+        u8      ee_rate_target_pwr_num[AR5K_EEPROM_N_MODES];
         struct ath5k_rate_pcal_info     ee_rate_tpwr_a[AR5K_EEPROM_N_5GHZ_CHAN];
-        struct ath5k_rate_pcal_info     ee_rate_tpwr_b[AR5K_EEPROM_N_2GHZ_CHAN];
-        struct ath5k_rate_pcal_info     ee_rate_tpwr_g[AR5K_EEPROM_N_2GHZ_CHAN];
+        struct ath5k_rate_pcal_info     ee_rate_tpwr_b[AR5K_EEPROM_N_2GHZ_CHAN_MAX];
+        struct ath5k_rate_pcal_info     ee_rate_tpwr_g[AR5K_EEPROM_N_2GHZ_CHAN_MAX];
 
         /* Conformance test limits (Unused) */
-        u16     ee_ctls;
-        u16     ee_ctl[AR5K_EEPROM_MAX_CTLS];
+        u8      ee_ctls;
+        u8      ee_ctl[AR5K_EEPROM_MAX_CTLS];
         struct ath5k_edge_power ee_ctl_pwr[AR5K_EEPROM_N_EDGES * AR5K_EEPROM_MAX_CTLS];
 
         /* Noise Floor Calibration settings */
diff --git a/drivers/net/wireless/ath5k/initvals.c b/drivers/net/wireless/ath5k/initvals.c
index 44886434187b..61fb621ed20d 100644
--- a/drivers/net/wireless/ath5k/initvals.c
+++ b/drivers/net/wireless/ath5k/initvals.c
@@ -1510,8 +1510,8 @@ int ath5k_hw_write_initvals(struct ath5k_hw *ah, u8 mode, bool change_channel)
                                         rf2425_ini_mode_end, mode);
 
                         ath5k_hw_ini_registers(ah,
-                                        ARRAY_SIZE(rf2413_ini_common_end),
-                                        rf2413_ini_common_end, change_channel);
+                                        ARRAY_SIZE(rf2425_ini_common_end),
+                                        rf2425_ini_common_end, change_channel);
 
                         ath5k_hw_ini_registers(ah,
                                         ARRAY_SIZE(rf5112_ini_bbgain),
diff --git a/drivers/net/wireless/ath5k/led.c b/drivers/net/wireless/ath5k/led.c
index 0686e12738b3..19555fb79c9b 100644
--- a/drivers/net/wireless/ath5k/led.c
+++ b/drivers/net/wireless/ath5k/led.c
@@ -65,6 +65,8 @@ static const struct pci_device_id ath5k_led_devices[] = {
         { ATH_SDEVICE(PCI_VENDOR_ID_AMBIT, 0x0422), ATH_LED(1, 1) },
         /* E-machines E510 (tuliom@gmail.com) */
         { ATH_SDEVICE(PCI_VENDOR_ID_AMBIT, 0x0428), ATH_LED(3, 0) },
+        /* Acer Extensa 5620z (nekoreeve@gmail.com) */
+        { ATH_SDEVICE(PCI_VENDOR_ID_QMI, 0x0105), ATH_LED(3, 0) },
         { }
 };
 
diff --git a/drivers/net/wireless/ath5k/phy.c b/drivers/net/wireless/ath5k/phy.c
index 81f5bebc48b1..9e2faae5ae94 100644
--- a/drivers/net/wireless/ath5k/phy.c
+++ b/drivers/net/wireless/ath5k/phy.c
@@ -4,6 +4,7 @@
  * Copyright (c) 2004-2007 Reyk Floeter <reyk@openbsd.org>
  * Copyright (c) 2006-2009 Nick Kossifidis <mickflemm@gmail.com>
  * Copyright (c) 2007-2008 Jiri Slaby <jirislaby@gmail.com>
+ * Copyright (c) 2008-2009 Felix Fietkau <nbd@openwrt.org>
  *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
@@ -183,7 +184,9 @@ static void ath5k_hw_request_rfgain_probe(struct ath5k_hw *ah)
         if (ah->ah_gain.g_state != AR5K_RFGAIN_ACTIVE)
                 return;
 
-        ath5k_hw_reg_write(ah, AR5K_REG_SM(ah->ah_txpower.txp_max,
+        /* Send the packet with 2dB below max power as
+         * patent doc suggest */
+        ath5k_hw_reg_write(ah, AR5K_REG_SM(ah->ah_txpower.txp_max_pwr - 4,
                         AR5K_PHY_PAPD_PROBE_TXPOWER) |
                         AR5K_PHY_PAPD_PROBE_TX_NEXT, AR5K_PHY_PAPD_PROBE);
 
@@ -1433,93 +1436,1120 @@ unsigned int ath5k_hw_get_def_antenna(struct ath5k_hw *ah)
         return false; /*XXX: What do we return for 5210 ?*/
 }
 
+
+/****************\
+* TX power setup *
+\****************/
+
+/*
+ * Helper functions
+ */
+
+/*
+ * Do linear interpolation between two given (x, y) points
+ */
+static s16
+ath5k_get_interpolated_value(s16 target, s16 x_left, s16 x_right,
+                                        s16 y_left, s16 y_right)
+{
+        s16 ratio, result;
+
+        /* Avoid divide by zero and skip interpolation
+         * if we have the same point */
+        if ((x_left == x_right) || (y_left == y_right))
+                return y_left;
+
+        /*
+         * Since we use ints and not fps, we need to scale up in
+         * order to get a sane ratio value (or else we 'll eg. get
+         * always 1 instead of 1.25, 1.75 etc). We scale up by 100
+         * to have some accuracy both for 0.5 and 0.25 steps.
+         */
+        ratio = ((100 * y_right - 100 * y_left)/(x_right - x_left));
+
+        /* Now scale down to be in range */
+        result = y_left + (ratio * (target - x_left) / 100);
+
+        return result;
+}
+
+/*
+ * Find vertical boundary (min pwr) for the linear PCDAC curve.
+ *
+ * Since we have the top of the curve and we draw the line below
+ * until we reach 1 (1 pcdac step) we need to know which point
+ * (x value) that is so that we don't go below y axis and have negative
+ * pcdac values when creating the curve, or fill the table with zeroes.
+ */
+static s16
+ath5k_get_linear_pcdac_min(const u8 *stepL, const u8 *stepR,
+                                const s16 *pwrL, const s16 *pwrR)
+{
+        s8 tmp;
+        s16 min_pwrL, min_pwrR;
+        s16 pwr_i = pwrL[0];
+
+        do {
+                pwr_i--;
+                tmp = (s8) ath5k_get_interpolated_value(pwr_i,
+                                                pwrL[0], pwrL[1],
+                                                stepL[0], stepL[1]);
+
+        } while (tmp > 1);
+
+        min_pwrL = pwr_i;
+
+        pwr_i = pwrR[0];
+        do {
+                pwr_i--;
+                tmp = (s8) ath5k_get_interpolated_value(pwr_i,
+                                                pwrR[0], pwrR[1],
+                                                stepR[0], stepR[1]);
+
+        } while (tmp > 1);
+
+        min_pwrR = pwr_i;
+
+        /* Keep the right boundary so that it works for both curves */
+        return max(min_pwrL, min_pwrR);
+}
+
+/*
+ * Interpolate (pwr,vpd) points to create a Power to PDADC or a
+ * Power to PCDAC curve.
+ *
+ * Each curve has power on x axis (in 0.5dB units) and PCDAC/PDADC
+ * steps (offsets) on y axis. Power can go up to 31.5dB and max
+ * PCDAC/PDADC step for each curve is 64 but we can write more than
+ * one curves on hw so we can go up to 128 (which is the max step we
+ * can write on the final table).
+ *
+ * We write y values (PCDAC/PDADC steps) on hw.
+ */
+static void
+ath5k_create_power_curve(s16 pmin, s16 pmax,
+                        const s16 *pwr, const u8 *vpd,
+                        u8 num_points,
+                        u8 *vpd_table, u8 type)
+{
+        u8 idx[2] = { 0, 1 };
+        s16 pwr_i = 2*pmin;
+        int i;
+
+        if (num_points < 2)
+                return;
+
+        /* We want the whole line, so adjust boundaries
+         * to cover the entire power range. Note that
+         * power values are already 0.25dB so no need
+         * to multiply pwr_i by 2 */
+        if (type == AR5K_PWRTABLE_LINEAR_PCDAC) {
+                pwr_i = pmin;
+                pmin = 0;
+                pmax = 63;
+        }
+
+        /* Find surrounding turning points (TPs)
+         * and interpolate between them */
+        for (i = 0; (i <= (u16) (pmax - pmin)) &&
+        (i < AR5K_EEPROM_POWER_TABLE_SIZE); i++) {
+
+                /* We passed the right TP, move to the next set of TPs
+                 * if we pass the last TP, extrapolate above using the last
+                 * two TPs for ratio */
+                if ((pwr_i > pwr[idx[1]]) && (idx[1] < num_points - 1)) {
+                        idx[0]++;
+                        idx[1]++;
+                }
+
+                vpd_table[i] = (u8) ath5k_get_interpolated_value(pwr_i,
+                                                pwr[idx[0]], pwr[idx[1]],
+                                                vpd[idx[0]], vpd[idx[1]]);
+
+                /* Increase by 0.5dB
+                 * (0.25 dB units) */
+                pwr_i += 2;
+        }
+}
+
+/*
+ * Get the surrounding per-channel power calibration piers
+ * for a given frequency so that we can interpolate between
+ * them and come up with an apropriate dataset for our current
+ * channel.
+ */
+static void
+ath5k_get_chan_pcal_surrounding_piers(struct ath5k_hw *ah,
+                        struct ieee80211_channel *channel,
+                        struct ath5k_chan_pcal_info **pcinfo_l,
+                        struct ath5k_chan_pcal_info **pcinfo_r)
+{
+        struct ath5k_eeprom_info *ee = &ah->ah_capabilities.cap_eeprom;
+        struct ath5k_chan_pcal_info *pcinfo;
+        u8 idx_l, idx_r;
+        u8 mode, max, i;
+        u32 target = channel->center_freq;
+
+        idx_l = 0;
+        idx_r = 0;
+
+        if (!(channel->hw_value & CHANNEL_OFDM)) {
+                pcinfo = ee->ee_pwr_cal_b;
+                mode = AR5K_EEPROM_MODE_11B;
+        } else if (channel->hw_value & CHANNEL_2GHZ) {
+                pcinfo = ee->ee_pwr_cal_g;
+                mode = AR5K_EEPROM_MODE_11G;
+        } else {
+                pcinfo = ee->ee_pwr_cal_a;
+                mode = AR5K_EEPROM_MODE_11A;
+        }
+        max = ee->ee_n_piers[mode] - 1;
+
+        /* Frequency is below our calibrated
+         * range. Use the lowest power curve
+         * we have */
+        if (target < pcinfo[0].freq) {
+                idx_l = idx_r = 0;
+                goto done;
+        }
+
+        /* Frequency is above our calibrated
+         * range. Use the highest power curve
+         * we have */
+        if (target > pcinfo[max].freq) {
+                idx_l = idx_r = max;
+                goto done;
+        }
+
+        /* Frequency is inside our calibrated
+         * channel range. Pick the surrounding
+         * calibration piers so that we can
+         * interpolate */
+        for (i = 0; i <= max; i++) {
+
+                /* Frequency matches one of our calibration
+                 * piers, no need to interpolate, just use
+                 * that calibration pier */
+                if (pcinfo[i].freq == target) {
+                        idx_l = idx_r = i;
+                        goto done;
+                }
+
+                /* We found a calibration pier that's above
+                 * frequency, use this pier and the previous
+                 * one to interpolate */
+                if (target < pcinfo[i].freq) {
+                        idx_r = i;
+                        idx_l = idx_r - 1;
+                        goto done;
+                }
+        }
+
+done:
+        *pcinfo_l = &pcinfo[idx_l];
+        *pcinfo_r = &pcinfo[idx_r];
+
+        return;
+}
+
+/*
+ * Get the surrounding per-rate power calibration data
+ * for a given frequency and interpolate between power
+ * values to set max target power supported by hw for
+ * each rate.
+ */
+static void
+ath5k_get_rate_pcal_data(struct ath5k_hw *ah,
+                        struct ieee80211_channel *channel,
+                        struct ath5k_rate_pcal_info *rates)
+{
+        struct ath5k_eeprom_info *ee = &ah->ah_capabilities.cap_eeprom;
+        struct ath5k_rate_pcal_info *rpinfo;
+        u8 idx_l, idx_r;
+        u8 mode, max, i;
+        u32 target = channel->center_freq;
+
+        idx_l = 0;
+        idx_r = 0;
+
+        if (!(channel->hw_value & CHANNEL_OFDM)) {
+                rpinfo = ee->ee_rate_tpwr_b;
+                mode = AR5K_EEPROM_MODE_11B;
+        } else if (channel->hw_value & CHANNEL_2GHZ) {
+                rpinfo = ee->ee_rate_tpwr_g;
+                mode = AR5K_EEPROM_MODE_11G;
+        } else {
+                rpinfo = ee->ee_rate_tpwr_a;
+                mode = AR5K_EEPROM_MODE_11A;
+        }
+        max = ee->ee_rate_target_pwr_num[mode] - 1;
+
+        /* Get the surrounding calibration
+         * piers - same as above */
+        if (target < rpinfo[0].freq) {
+                idx_l = idx_r = 0;
+                goto done;
+        }
+
+        if (target > rpinfo[max].freq) {
+                idx_l = idx_r = max;
+                goto done;
+        }
+
+        for (i = 0; i <= max; i++) {
+
+                if (rpinfo[i].freq == target) {
+                        idx_l = idx_r = i;
+                        goto done;
+                }
+
+                if (target < rpinfo[i].freq) {
+                        idx_r = i;
+                        idx_l = idx_r - 1;
+                        goto done;
+                }
+        }
+
+done:
+        /* Now interpolate power value, based on the frequency */
+        rates->freq = target;
+
+        rates->target_power_6to24 =
+                ath5k_get_interpolated_value(target, rpinfo[idx_l].freq,
+                                        rpinfo[idx_r].freq,
+                                        rpinfo[idx_l].target_power_6to24,
+                                        rpinfo[idx_r].target_power_6to24);
+
+        rates->target_power_36 =
+                ath5k_get_interpolated_value(target, rpinfo[idx_l].freq,
+                                        rpinfo[idx_r].freq,
+                                        rpinfo[idx_l].target_power_36,
+                                        rpinfo[idx_r].target_power_36);
+
+        rates->target_power_48 =
+                ath5k_get_interpolated_value(target, rpinfo[idx_l].freq,
+                                        rpinfo[idx_r].freq,
+                                        rpinfo[idx_l].target_power_48,
+                                        rpinfo[idx_r].target_power_48);
+
+        rates->target_power_54 =
+                ath5k_get_interpolated_value(target, rpinfo[idx_l].freq,
+                                        rpinfo[idx_r].freq,
+                                        rpinfo[idx_l].target_power_54,
+                                        rpinfo[idx_r].target_power_54);
+}
+
+/*
+ * Get the max edge power for this channel if
+ * we have such data from EEPROM's Conformance Test
+ * Limits (CTL), and limit max power if needed.
+ *
+ * FIXME: Only works for world regulatory domains
+ */
+static void
+ath5k_get_max_ctl_power(struct ath5k_hw *ah,
+                        struct ieee80211_channel *channel)
+{
+        struct ath5k_eeprom_info *ee = &ah->ah_capabilities.cap_eeprom;
+        struct ath5k_edge_power *rep = ee->ee_ctl_pwr;
+        u8 *ctl_val = ee->ee_ctl;
+        s16 max_chan_pwr = ah->ah_txpower.txp_max_pwr / 4;
+        s16 edge_pwr = 0;
+        u8 rep_idx;
+        u8 i, ctl_mode;
+        u8 ctl_idx = 0xFF;
+        u32 target = channel->center_freq;
+
+        /* Find out a CTL for our mode that's not mapped
+         * on a specific reg domain.
+         *
+         * TODO: Map our current reg domain to one of the 3 available
+         * reg domain ids so that we can support more CTLs. */
+        switch (channel->hw_value & CHANNEL_MODES) {
+        case CHANNEL_A:
+                ctl_mode = AR5K_CTL_11A | AR5K_CTL_NO_REGDOMAIN;
+                break;
+        case CHANNEL_G:
+                ctl_mode = AR5K_CTL_11G | AR5K_CTL_NO_REGDOMAIN;
+                break;
+        case CHANNEL_B:
+                ctl_mode = AR5K_CTL_11B | AR5K_CTL_NO_REGDOMAIN;
+                break;
+        case CHANNEL_T:
+                ctl_mode = AR5K_CTL_TURBO | AR5K_CTL_NO_REGDOMAIN;
+                break;
+        case CHANNEL_TG:
+                ctl_mode = AR5K_CTL_TURBOG | AR5K_CTL_NO_REGDOMAIN;
+                break;
+        case CHANNEL_XR:
+                /* Fall through */
+        default:
+                return;
+        }
+
+        for (i = 0; i < ee->ee_ctls; i++) {
+                if (ctl_val[i] == ctl_mode) {
+                        ctl_idx = i;
+                        break;
+                }
+        }
+
+        /* If we have a CTL dataset available grab it and find the
+         * edge power for our frequency */
+        if (ctl_idx == 0xFF)
+                return;
+
+        /* Edge powers are sorted by frequency from lower
+         * to higher. Each CTL corresponds to 8 edge power
+         * measurements. */
+        rep_idx = ctl_idx * AR5K_EEPROM_N_EDGES;
+
+        /* Don't do boundaries check because we
+         * might have more that one bands defined
+         * for this mode */
+
+        /* Get the edge power that's closer to our
+         * frequency */
+        for (i = 0; i < AR5K_EEPROM_N_EDGES; i++) {
+                rep_idx += i;
+                if (target <= rep[rep_idx].freq)
+                        edge_pwr = (s16) rep[rep_idx].edge;
+        }
+
+        if (edge_pwr)
+                ah->ah_txpower.txp_max_pwr = 4*min(edge_pwr, max_chan_pwr);
+}
+
+
+/*
+ * Power to PCDAC table functions
+ */
+
 /*
- * TX power setup
+ * Fill Power to PCDAC table on RF5111
+ *
+ * No further processing is needed for RF5111, the only thing we have to
+ * do is fill the values below and above calibration range since eeprom data
+ * may not cover the entire PCDAC table.
  */
+static void
+ath5k_fill_pwr_to_pcdac_table(struct ath5k_hw *ah, s16* table_min,
+                                                        s16 *table_max)
+{
+        u8      *pcdac_out = ah->ah_txpower.txp_pd_table;
+        u8      *pcdac_tmp = ah->ah_txpower.tmpL[0];
+        u8      pcdac_0, pcdac_n, pcdac_i, pwr_idx, i;
+        s16     min_pwr, max_pwr;
+
+        /* Get table boundaries */
+        min_pwr = table_min[0];
+        pcdac_0 = pcdac_tmp[0];
+
+        max_pwr = table_max[0];
+        pcdac_n = pcdac_tmp[table_max[0] - table_min[0]];
+
+        /* Extrapolate below minimum using pcdac_0 */
+        pcdac_i = 0;
+        for (i = 0; i < min_pwr; i++)
+                pcdac_out[pcdac_i++] = pcdac_0;
+
+        /* Copy values from pcdac_tmp */
+        pwr_idx = min_pwr;
+        for (i = 0 ; pwr_idx <= max_pwr &&
+        pcdac_i < AR5K_EEPROM_POWER_TABLE_SIZE; i++) {
+                pcdac_out[pcdac_i++] = pcdac_tmp[i];
+                pwr_idx++;
+        }
+
+        /* Extrapolate above maximum */
+        while (pcdac_i < AR5K_EEPROM_POWER_TABLE_SIZE)
+                pcdac_out[pcdac_i++] = pcdac_n;
+
+}
 
 /*
- * Initialize the tx power table (not fully implemented)
+ * Combine available XPD Curves and fill Linear Power to PCDAC table
+ * on RF5112
+ *
+ * RFX112 can have up to 2 curves (one for low txpower range and one for
+ * higher txpower range). We need to put them both on pcdac_out and place
+ * them in the correct location. In case we only have one curve available
+ * just fit it on pcdac_out (it's supposed to cover the entire range of
+ * available pwr levels since it's always the higher power curve). Extrapolate
+ * below and above final table if needed.
  */
-static void ath5k_txpower_table(struct ath5k_hw *ah,
-                struct ieee80211_channel *channel, s16 max_power)
+static void
+ath5k_combine_linear_pcdac_curves(struct ath5k_hw *ah, s16* table_min,
+                                                s16 *table_max, u8 pdcurves)
 {
-        unsigned int i, min, max, n;
-        u16 txpower, *rates;
-
-        rates = ah->ah_txpower.txp_rates;
-
-        txpower = AR5K_TUNE_DEFAULT_TXPOWER * 2;
-        if (max_power > txpower)
-                txpower = max_power > AR5K_TUNE_MAX_TXPOWER ?
-                    AR5K_TUNE_MAX_TXPOWER : max_power;
-
-        for (i = 0; i < AR5K_MAX_RATES; i++)
-                rates[i] = txpower;
-
-        /* XXX setup target powers by rate */
-
-        ah->ah_txpower.txp_min = rates[7];
-        ah->ah_txpower.txp_max = rates[0];
-        ah->ah_txpower.txp_ofdm = rates[0];
-
-        /* Calculate the power table */
-        n = ARRAY_SIZE(ah->ah_txpower.txp_pcdac);
-        min = AR5K_EEPROM_PCDAC_START;
-        max = AR5K_EEPROM_PCDAC_STOP;
-        for (i = 0; i < n; i += AR5K_EEPROM_PCDAC_STEP)
-                ah->ah_txpower.txp_pcdac[i] =
-#ifdef notyet
-                min + ((i * (max - min)) / n);
-#else
-                min;
+        u8      *pcdac_out = ah->ah_txpower.txp_pd_table;
+        u8      *pcdac_low_pwr;
+        u8      *pcdac_high_pwr;
+        u8      *pcdac_tmp;
+        u8      pwr;
+        s16     max_pwr_idx;
+        s16     min_pwr_idx;
+        s16     mid_pwr_idx = 0;
+        /* Edge flag turs on the 7nth bit on the PCDAC
+         * to delcare the higher power curve (force values
+         * to be greater than 64). If we only have one curve
+         * we don't need to set this, if we have 2 curves and
+         * fill the table backwards this can also be used to
+         * switch from higher power curve to lower power curve */
+        u8      edge_flag;
+        int     i;
+
+        /* When we have only one curve available
+         * that's the higher power curve. If we have
+         * two curves the first is the high power curve
+         * and the next is the low power curve. */
+        if (pdcurves > 1) {
+                pcdac_low_pwr = ah->ah_txpower.tmpL[1];
+                pcdac_high_pwr = ah->ah_txpower.tmpL[0];
+                mid_pwr_idx = table_max[1] - table_min[1] - 1;
+                max_pwr_idx = (table_max[0] - table_min[0]) / 2;
+
+                /* If table size goes beyond 31.5dB, keep the
+                 * upper 31.5dB range when setting tx power.
+                 * Note: 126 = 31.5 dB in quarter dB steps */
+                if (table_max[0] - table_min[1] > 126)
+                        min_pwr_idx = table_max[0] - 126;
+                else
+                        min_pwr_idx = table_min[1];
+
+                /* Since we fill table backwards
+                 * start from high power curve */
+                pcdac_tmp = pcdac_high_pwr;
+
+                edge_flag = 0x40;
+#if 0
+                /* If both min and max power limits are in lower
+                 * power curve's range, only use the low power curve.
+                 * TODO: min/max levels are related to target
+                 * power values requested from driver/user
+                 * XXX: Is this really needed ? */
+                if (min_pwr < table_max[1] &&
+                max_pwr < table_max[1]) {
+                        edge_flag = 0;
+                        pcdac_tmp = pcdac_low_pwr;
+                        max_pwr_idx = (table_max[1] - table_min[1])/2;
+                }
 #endif
+        } else {
+                pcdac_low_pwr = ah->ah_txpower.tmpL[1]; /* Zeroed */
+                pcdac_high_pwr = ah->ah_txpower.tmpL[0];
+                min_pwr_idx = table_min[0];
+                max_pwr_idx = (table_max[0] - table_min[0]) / 2;
+                pcdac_tmp = pcdac_high_pwr;
+                edge_flag = 0;
+        }
+
+        /* This is used when setting tx power*/
+        ah->ah_txpower.txp_min_idx = min_pwr_idx/2;
+
+        /* Fill Power to PCDAC table backwards */
+        pwr = max_pwr_idx;
+        for (i = 63; i >= 0; i--) {
+                /* Entering lower power range, reset
+                 * edge flag and set pcdac_tmp to lower
+                 * power curve.*/
+                if (edge_flag == 0x40 &&
+                (2*pwr <= (table_max[1] - table_min[0]) || pwr == 0)) {
+                        edge_flag = 0x00;
+                        pcdac_tmp = pcdac_low_pwr;
+                        pwr = mid_pwr_idx/2;
+                }
+
+                /* Don't go below 1, extrapolate below if we have
+                 * already swithced to the lower power curve -or
+                 * we only have one curve and edge_flag is zero
+                 * anyway */
+                if (pcdac_tmp[pwr] < 1 && (edge_flag == 0x00)) {
+                        while (i >= 0) {
+                                pcdac_out[i] = pcdac_out[i + 1];
+                                i--;
+                        }
+                        break;
+                }
+
+                pcdac_out[i] = pcdac_tmp[pwr] | edge_flag;
+
+                /* Extrapolate above if pcdac is greater than
+                 * 126 -this can happen because we OR pcdac_out
+                 * value with edge_flag on high power curve */
+                if (pcdac_out[i] > 126)
+                        pcdac_out[i] = 126;
+
+                /* Decrease by a 0.5dB step */
+                pwr--;
+        }
 }
 
+/* Write PCDAC values on hw */
+static void
+ath5k_setup_pcdac_table(struct ath5k_hw *ah)
+{
+        u8      *pcdac_out = ah->ah_txpower.txp_pd_table;
+        int     i;
+
+        /*
+         * Write TX power values
+         */
+        for (i = 0; i < (AR5K_EEPROM_POWER_TABLE_SIZE / 2); i++) {
+                ath5k_hw_reg_write(ah,
+                        (((pcdac_out[2*i + 0] << 8 | 0xff) & 0xffff) << 0) |
+                        (((pcdac_out[2*i + 1] << 8 | 0xff) & 0xffff) << 16),
+                        AR5K_PHY_PCDAC_TXPOWER(i));
+        }
+}
+
+
 /*
- * Set transmition power
+ * Power to PDADC table functions
  */
-int /*O.K. - txpower_table is unimplemented so this doesn't work*/
-ath5k_hw_txpower(struct ath5k_hw *ah, struct ieee80211_channel *channel,
-                unsigned int txpower)
+
+/*
+ * Set the gain boundaries and create final Power to PDADC table
+ *
+ * We can have up to 4 pd curves, we need to do a simmilar process
+ * as we do for RF5112. This time we don't have an edge_flag but we
+ * set the gain boundaries on a separate register.
+ */
+static void
+ath5k_combine_pwr_to_pdadc_curves(struct ath5k_hw *ah,
+                        s16 *pwr_min, s16 *pwr_max, u8 pdcurves)
 {
-        bool tpc = ah->ah_txpower.txp_tpc;
-        unsigned int i;
+        u8 gain_boundaries[AR5K_EEPROM_N_PD_GAINS];
+        u8 *pdadc_out = ah->ah_txpower.txp_pd_table;
+        u8 *pdadc_tmp;
+        s16 pdadc_0;
+        u8 pdadc_i, pdadc_n, pwr_step, pdg, max_idx, table_size;
+        u8 pd_gain_overlap;
+
+        /* Note: Register value is initialized on initvals
+         * there is no feedback from hw.
+         * XXX: What about pd_gain_overlap from EEPROM ? */
+        pd_gain_overlap = (u8) ath5k_hw_reg_read(ah, AR5K_PHY_TPC_RG5) &
+                AR5K_PHY_TPC_RG5_PD_GAIN_OVERLAP;
+
+        /* Create final PDADC table */
+        for (pdg = 0, pdadc_i = 0; pdg < pdcurves; pdg++) {
+                pdadc_tmp = ah->ah_txpower.tmpL[pdg];
+
+                if (pdg == pdcurves - 1)
+                        /* 2 dB boundary stretch for last
+                         * (higher power) curve */
+                        gain_boundaries[pdg] = pwr_max[pdg] + 4;
+                else
+                        /* Set gain boundary in the middle
+                         * between this curve and the next one */
+                        gain_boundaries[pdg] =
+                                (pwr_max[pdg] + pwr_min[pdg + 1]) / 2;
+
+                /* Sanity check in case our 2 db stretch got out of
+                 * range. */
+                if (gain_boundaries[pdg] > AR5K_TUNE_MAX_TXPOWER)
+                        gain_boundaries[pdg] = AR5K_TUNE_MAX_TXPOWER;
+
+                /* For the first curve (lower power)
+                 * start from 0 dB */
+                if (pdg == 0)
+                        pdadc_0 = 0;
+                else
+                        /* For the other curves use the gain overlap */
+                        pdadc_0 = (gain_boundaries[pdg - 1] - pwr_min[pdg]) -
+                                                        pd_gain_overlap;
 
-        ATH5K_TRACE(ah->ah_sc);
-        if (txpower > AR5K_TUNE_MAX_TXPOWER) {
-                ATH5K_ERR(ah->ah_sc, "invalid tx power: %u\n", txpower);
-                return -EINVAL;
+                /* Force each power step to be at least 0.5 dB */
+                if ((pdadc_tmp[1] - pdadc_tmp[0]) > 1)
+                        pwr_step = pdadc_tmp[1] - pdadc_tmp[0];
+                else
+                        pwr_step = 1;
+
+                /* If pdadc_0 is negative, we need to extrapolate
+                 * below this pdgain by a number of pwr_steps */
+                while ((pdadc_0 < 0) && (pdadc_i < 128)) {
+                        s16 tmp = pdadc_tmp[0] + pdadc_0 * pwr_step;
+                        pdadc_out[pdadc_i++] = (tmp < 0) ? 0 : (u8) tmp;
+                        pdadc_0++;
+                }
+
+                /* Set last pwr level, using gain boundaries */
+                pdadc_n = gain_boundaries[pdg] + pd_gain_overlap - pwr_min[pdg];
+                /* Limit it to be inside pwr range */
+                table_size = pwr_max[pdg] - pwr_min[pdg];
+                max_idx = (pdadc_n < table_size) ? pdadc_n : table_size;
+
+                /* Fill pdadc_out table */
+                while (pdadc_0 < max_idx)
+                        pdadc_out[pdadc_i++] = pdadc_tmp[pdadc_0++];
+
+                /* Need to extrapolate above this pdgain? */
+                if (pdadc_n <= max_idx)
+                        continue;
+
+                /* Force each power step to be at least 0.5 dB */
+                if ((pdadc_tmp[table_size - 1] - pdadc_tmp[table_size - 2]) > 1)
+                        pwr_step = pdadc_tmp[table_size - 1] -
+                                                pdadc_tmp[table_size - 2];
+                else
+                        pwr_step = 1;
+
+                /* Extrapolate above */
+                while ((pdadc_0 < (s16) pdadc_n) &&
+                (pdadc_i < AR5K_EEPROM_POWER_TABLE_SIZE * 2)) {
+                        s16 tmp = pdadc_tmp[table_size - 1] +
+                                        (pdadc_0 - max_idx) * pwr_step;
+                        pdadc_out[pdadc_i++] = (tmp > 127) ? 127 : (u8) tmp;
+                        pdadc_0++;
+                }
         }
 
+        while (pdg < AR5K_EEPROM_N_PD_GAINS) {
+                gain_boundaries[pdg] = gain_boundaries[pdg - 1];
+                pdg++;
+        }
+
+        while (pdadc_i < AR5K_EEPROM_POWER_TABLE_SIZE * 2) {
+                pdadc_out[pdadc_i] = pdadc_out[pdadc_i - 1];
+                pdadc_i++;
+        }
+
+        /* Set gain boundaries */
+        ath5k_hw_reg_write(ah,
+                AR5K_REG_SM(pd_gain_overlap,
+                        AR5K_PHY_TPC_RG5_PD_GAIN_OVERLAP) |
+                AR5K_REG_SM(gain_boundaries[0],
+                        AR5K_PHY_TPC_RG5_PD_GAIN_BOUNDARY_1) |
+                AR5K_REG_SM(gain_boundaries[1],
+                        AR5K_PHY_TPC_RG5_PD_GAIN_BOUNDARY_2) |
+                AR5K_REG_SM(gain_boundaries[2],
+                        AR5K_PHY_TPC_RG5_PD_GAIN_BOUNDARY_3) |
+                AR5K_REG_SM(gain_boundaries[3],
+                        AR5K_PHY_TPC_RG5_PD_GAIN_BOUNDARY_4),
+                AR5K_PHY_TPC_RG5);
+
+        /* Used for setting rate power table */
+        ah->ah_txpower.txp_min_idx = pwr_min[0];
+
+}
+
+/* Write PDADC values on hw */
+static void
+ath5k_setup_pwr_to_pdadc_table(struct ath5k_hw *ah,
+                        u8 pdcurves, u8 *pdg_to_idx)
+{
+        u8 *pdadc_out = ah->ah_txpower.txp_pd_table;
+        u32 reg;
+        u8 i;
+
+        /* Select the right pdgain curves */
+
+        /* Clear current settings */
+        reg = ath5k_hw_reg_read(ah, AR5K_PHY_TPC_RG1);
+        reg &= ~(AR5K_PHY_TPC_RG1_PDGAIN_1 |
+                AR5K_PHY_TPC_RG1_PDGAIN_2 |
+                AR5K_PHY_TPC_RG1_PDGAIN_3 |
+                AR5K_PHY_TPC_RG1_NUM_PD_GAIN);
+
         /*
-         * RF2413 for some reason can't
-         * transmit anything if we call
-         * this funtion, so we skip it
-         * until we fix txpower.
+         * Use pd_gains curve from eeprom
          *
-         * XXX: Assume same for RF2425
-         * to be safe.
+         * This overrides the default setting from initvals
+         * in case some vendors (e.g. Zcomax) don't use the default
+         * curves. If we don't honor their settings we 'll get a
+         * 5dB (1 * gain overlap ?) drop.
          */
-        if ((ah->ah_radio == AR5K_RF2413) || (ah->ah_radio == AR5K_RF2425))
-                return 0;
+        reg |= AR5K_REG_SM(pdcurves, AR5K_PHY_TPC_RG1_NUM_PD_GAIN);
 
-        /* Reset TX power values */
-        memset(&ah->ah_txpower, 0, sizeof(ah->ah_txpower));
-        ah->ah_txpower.txp_tpc = tpc;
-
-        /* Initialize TX power table */
-        ath5k_txpower_table(ah, channel, txpower);
+        switch (pdcurves) {
+        case 3:
+                reg |= AR5K_REG_SM(pdg_to_idx[2], AR5K_PHY_TPC_RG1_PDGAIN_3);
+                /* Fall through */
+        case 2:
+                reg |= AR5K_REG_SM(pdg_to_idx[1], AR5K_PHY_TPC_RG1_PDGAIN_2);
+                /* Fall through */
+        case 1:
+                reg |= AR5K_REG_SM(pdg_to_idx[0], AR5K_PHY_TPC_RG1_PDGAIN_1);
+                break;
+        }
+        ath5k_hw_reg_write(ah, reg, AR5K_PHY_TPC_RG1);
 
         /*
          * Write TX power values
          */
         for (i = 0; i < (AR5K_EEPROM_POWER_TABLE_SIZE / 2); i++) {
                 ath5k_hw_reg_write(ah,
-                        ((((ah->ah_txpower.txp_pcdac[(i << 1) + 1] << 8) | 0xff) & 0xffff) << 16) |
-                        (((ah->ah_txpower.txp_pcdac[(i << 1)    ] << 8) | 0xff) & 0xffff),
-                        AR5K_PHY_PCDAC_TXPOWER(i));
+                        ((pdadc_out[4*i + 0] & 0xff) << 0) |
+                        ((pdadc_out[4*i + 1] & 0xff) << 8) |
+                        ((pdadc_out[4*i + 2] & 0xff) << 16) |
+                        ((pdadc_out[4*i + 3] & 0xff) << 24),
+                        AR5K_PHY_PDADC_TXPOWER(i));
+        }
+}
+
+
+/*
+ * Common code for PCDAC/PDADC tables
+ */
+
+/*
+ * This is the main function that uses all of the above
+ * to set PCDAC/PDADC table on hw for the current channel.
+ * This table is used for tx power calibration on the basband,
+ * without it we get weird tx power levels and in some cases
+ * distorted spectral mask
+ */
+static int
+ath5k_setup_channel_powertable(struct ath5k_hw *ah,
+                        struct ieee80211_channel *channel,
+                        u8 ee_mode, u8 type)
+{
+        struct ath5k_pdgain_info *pdg_L, *pdg_R;
+        struct ath5k_chan_pcal_info *pcinfo_L;
+        struct ath5k_chan_pcal_info *pcinfo_R;
+        struct ath5k_eeprom_info *ee = &ah->ah_capabilities.cap_eeprom;
+        u8 *pdg_curve_to_idx = ee->ee_pdc_to_idx[ee_mode];
+        s16 table_min[AR5K_EEPROM_N_PD_GAINS];
+        s16 table_max[AR5K_EEPROM_N_PD_GAINS];
+        u8 *tmpL;
+        u8 *tmpR;
+        u32 target = channel->center_freq;
+        int pdg, i;
+
+        /* Get surounding freq piers for this channel */
+        ath5k_get_chan_pcal_surrounding_piers(ah, channel,
+                                                &pcinfo_L,
+                                                &pcinfo_R);
+
+        /* Loop over pd gain curves on
+         * surounding freq piers by index */
+        for (pdg = 0; pdg < ee->ee_pd_gains[ee_mode]; pdg++) {
+
+                /* Fill curves in reverse order
+                 * from lower power (max gain)
+                 * to higher power. Use curve -> idx
+                 * backmaping we did on eeprom init */
+                u8 idx = pdg_curve_to_idx[pdg];
+
+                /* Grab the needed curves by index */
+                pdg_L = &pcinfo_L->pd_curves[idx];
+                pdg_R = &pcinfo_R->pd_curves[idx];
+
+                /* Initialize the temp tables */
+                tmpL = ah->ah_txpower.tmpL[pdg];
+                tmpR = ah->ah_txpower.tmpR[pdg];
+
+                /* Set curve's x boundaries and create
+                 * curves so that they cover the same
+                 * range (if we don't do that one table
+                 * will have values on some range and the
+                 * other one won't have any so interpolation
+                 * will fail) */
+                table_min[pdg] = min(pdg_L->pd_pwr[0],
+                                        pdg_R->pd_pwr[0]) / 2;
+
+                table_max[pdg] = max(pdg_L->pd_pwr[pdg_L->pd_points - 1],
+                                pdg_R->pd_pwr[pdg_R->pd_points - 1]) / 2;
+
+                /* Now create the curves on surrounding channels
+                 * and interpolate if needed to get the final
+                 * curve for this gain on this channel */
+                switch (type) {
+                case AR5K_PWRTABLE_LINEAR_PCDAC:
+                        /* Override min/max so that we don't loose
+                         * accuracy (don't divide by 2) */
+                        table_min[pdg] = min(pdg_L->pd_pwr[0],
+                                                pdg_R->pd_pwr[0]);
+
+                        table_max[pdg] =
+                                max(pdg_L->pd_pwr[pdg_L->pd_points - 1],
+                                        pdg_R->pd_pwr[pdg_R->pd_points - 1]);
+
+                        /* Override minimum so that we don't get
+                         * out of bounds while extrapolating
+                         * below. Don't do this when we have 2
+                         * curves and we are on the high power curve
+                         * because table_min is ok in this case */
+                        if (!(ee->ee_pd_gains[ee_mode] > 1 && pdg == 0)) {
+
+                                table_min[pdg] =
+                                        ath5k_get_linear_pcdac_min(pdg_L->pd_step,
+                                                                pdg_R->pd_step,
+                                                                pdg_L->pd_pwr,
+                                                                pdg_R->pd_pwr);
+
+                                /* Don't go too low because we will
+                                 * miss the upper part of the curve.
+                                 * Note: 126 = 31.5dB (max power supported)
+                                 * in 0.25dB units */
+                                if (table_max[pdg] - table_min[pdg] > 126)
+                                        table_min[pdg] = table_max[pdg] - 126;
+                        }
+
+                        /* Fall through */
+                case AR5K_PWRTABLE_PWR_TO_PCDAC:
+                case AR5K_PWRTABLE_PWR_TO_PDADC:
+
+                        ath5k_create_power_curve(table_min[pdg],
+                                                table_max[pdg],
+                                                pdg_L->pd_pwr,
+                                                pdg_L->pd_step,
+                                                pdg_L->pd_points, tmpL, type);
+
+                        /* We are in a calibration
+                         * pier, no need to interpolate
+                         * between freq piers */
+                        if (pcinfo_L == pcinfo_R)
+                                continue;
+
+                        ath5k_create_power_curve(table_min[pdg],
+                                                table_max[pdg],
+                                                pdg_R->pd_pwr,
+                                                pdg_R->pd_step,
+                                                pdg_R->pd_points, tmpR, type);
+                        break;
+                default:
+                        return -EINVAL;
+                }
+
+                /* Interpolate between curves
+                 * of surounding freq piers to
+                 * get the final curve for this
+                 * pd gain. Re-use tmpL for interpolation
+                 * output */
+                for (i = 0; (i < (u16) (table_max[pdg] - table_min[pdg])) &&
+                (i < AR5K_EEPROM_POWER_TABLE_SIZE); i++) {
+                        tmpL[i] = (u8) ath5k_get_interpolated_value(target,
+                                                        (s16) pcinfo_L->freq,
+                                                        (s16) pcinfo_R->freq,
+                                                        (s16) tmpL[i],
+                                                        (s16) tmpR[i]);
+                }
         }
 
+        /* Now we have a set of curves for this
+         * channel on tmpL (x range is table_max - table_min
+         * and y values are tmpL[pdg][]) sorted in the same
+         * order as EEPROM (because we've used the backmaping).
+         * So for RF5112 it's from higher power to lower power
+         * and for RF2413 it's from lower power to higher power.
+         * For RF5111 we only have one curve. */
+
+        /* Fill min and max power levels for this
+         * channel by interpolating the values on
+         * surounding channels to complete the dataset */
+        ah->ah_txpower.txp_min_pwr = ath5k_get_interpolated_value(target,
+                                        (s16) pcinfo_L->freq,
+                                        (s16) pcinfo_R->freq,
+                                        pcinfo_L->min_pwr, pcinfo_R->min_pwr);
+
+        ah->ah_txpower.txp_max_pwr = ath5k_get_interpolated_value(target,
+                                        (s16) pcinfo_L->freq,
+                                        (s16) pcinfo_R->freq,
+                                        pcinfo_L->max_pwr, pcinfo_R->max_pwr);
+
+        /* We are ready to go, fill PCDAC/PDADC
+         * table and write settings on hardware */
+        switch (type) {
+        case AR5K_PWRTABLE_LINEAR_PCDAC:
+                /* For RF5112 we can have one or two curves
+                 * and each curve covers a certain power lvl
+                 * range so we need to do some more processing */
+                ath5k_combine_linear_pcdac_curves(ah, table_min, table_max,
+                                                ee->ee_pd_gains[ee_mode]);
+
+                /* Set txp.offset so that we can
+                 * match max power value with max
+                 * table index */
+                ah->ah_txpower.txp_offset = 64 - (table_max[0] / 2);
+
+                /* Write settings on hw */
+                ath5k_setup_pcdac_table(ah);
+                break;
+        case AR5K_PWRTABLE_PWR_TO_PCDAC:
+                /* We are done for RF5111 since it has only
+                 * one curve, just fit the curve on the table */
+                ath5k_fill_pwr_to_pcdac_table(ah, table_min, table_max);
+
+                /* No rate powertable adjustment for RF5111 */
+                ah->ah_txpower.txp_min_idx = 0;
+                ah->ah_txpower.txp_offset = 0;
+
+                /* Write settings on hw */
+                ath5k_setup_pcdac_table(ah);
+                break;
+        case AR5K_PWRTABLE_PWR_TO_PDADC:
+                /* Set PDADC boundaries and fill
+                 * final PDADC table */
+                ath5k_combine_pwr_to_pdadc_curves(ah, table_min, table_max,
+                                                ee->ee_pd_gains[ee_mode]);
+
+                /* Write settings on hw */
+                ath5k_setup_pwr_to_pdadc_table(ah, pdg, pdg_curve_to_idx);
+
+                /* Set txp.offset, note that table_min
+                 * can be negative */
+                ah->ah_txpower.txp_offset = table_min[0];
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+
+/*
+ * Per-rate tx power setting
+ *
+ * This is the code that sets the desired tx power (below
+ * maximum) on hw for each rate (we also have TPC that sets
+ * power per packet). We do that by providing an index on the
+ * PCDAC/PDADC table we set up.
+ */
+
+/*
+ * Set rate power table
+ *
+ * For now we only limit txpower based on maximum tx power
+ * supported by hw (what's inside rate_info). We need to limit
+ * this even more, based on regulatory domain etc.
+ *
+ * Rate power table contains indices to PCDAC/PDADC table (0.5dB steps)
+ * and is indexed as follows:
+ * rates[0] - rates[7] -> OFDM rates
+ * rates[8] - rates[14] -> CCK rates
+ * rates[15] -> XR rates (they all have the same power)
+ */
+static void
+ath5k_setup_rate_powertable(struct ath5k_hw *ah, u16 max_pwr,
+                        struct ath5k_rate_pcal_info *rate_info,
+                        u8 ee_mode)
+{
+        unsigned int i;
+        u16 *rates;
+
+        /* max_pwr is power level we got from driver/user in 0.5dB
+         * units, switch to 0.25dB units so we can compare */
+        max_pwr *= 2;
+        max_pwr = min(max_pwr, (u16) ah->ah_txpower.txp_max_pwr) / 2;
+
+        /* apply rate limits */
+        rates = ah->ah_txpower.txp_rates_power_table;
+
+        /* OFDM rates 6 to 24Mb/s */
+        for (i = 0; i < 5; i++)
+                rates[i] = min(max_pwr, rate_info->target_power_6to24);
+
+        /* Rest OFDM rates */
+        rates[5] = min(rates[0], rate_info->target_power_36);
+        rates[6] = min(rates[0], rate_info->target_power_48);
+        rates[7] = min(rates[0], rate_info->target_power_54);
+
+        /* CCK rates */
+        /* 1L */
+        rates[8] = min(rates[0], rate_info->target_power_6to24);
+        /* 2L */
+        rates[9] = min(rates[0], rate_info->target_power_36);
+        /* 2S */
+        rates[10] = min(rates[0], rate_info->target_power_36);
+        /* 5L */
+        rates[11] = min(rates[0], rate_info->target_power_48);
+        /* 5S */
+        rates[12] = min(rates[0], rate_info->target_power_48);
+        /* 11L */
+        rates[13] = min(rates[0], rate_info->target_power_54);
+        /* 11S */
+        rates[14] = min(rates[0], rate_info->target_power_54);
+
+        /* XR rates */
+        rates[15] = min(rates[0], rate_info->target_power_6to24);
+
+        /* CCK rates have different peak to average ratio
+         * so we have to tweak their power so that gainf
+         * correction works ok. For this we use OFDM to
+         * CCK delta from eeprom */
+        if ((ee_mode == AR5K_EEPROM_MODE_11G) &&
+        (ah->ah_phy_revision < AR5K_SREV_PHY_5212A))
+                for (i = 8; i <= 15; i++)
+                        rates[i] -= ah->ah_txpower.txp_cck_ofdm_gainf_delta;
+
+        ah->ah_txpower.txp_min_pwr = rates[7];
+        ah->ah_txpower.txp_max_pwr = rates[0];
+        ah->ah_txpower.txp_ofdm = rates[7];
+}
+
+
+/*
+ * Set transmition power
+ */
+int
+ath5k_hw_txpower(struct ath5k_hw *ah, struct ieee80211_channel *channel,
+                u8 ee_mode, u8 txpower)
+{
+        struct ath5k_rate_pcal_info rate_info;
+        u8 type;
+        int ret;
+
+        ATH5K_TRACE(ah->ah_sc);
+        if (txpower > AR5K_TUNE_MAX_TXPOWER) {
+                ATH5K_ERR(ah->ah_sc, "invalid tx power: %u\n", txpower);
+                return -EINVAL;
+        }
+        if (txpower == 0)
+                txpower = AR5K_TUNE_DEFAULT_TXPOWER;
+
+        /* Reset TX power values */
+        memset(&ah->ah_txpower, 0, sizeof(ah->ah_txpower));
+        ah->ah_txpower.txp_tpc = AR5K_TUNE_TPC_TXPOWER;
+        ah->ah_txpower.txp_min_pwr = 0;
+        ah->ah_txpower.txp_max_pwr = AR5K_TUNE_MAX_TXPOWER;
+
+        /* Initialize TX power table */
+        switch (ah->ah_radio) {
+        case AR5K_RF5111:
+                type = AR5K_PWRTABLE_PWR_TO_PCDAC;
+                break;
+        case AR5K_RF5112:
+                type = AR5K_PWRTABLE_LINEAR_PCDAC;
+                break;
+        case AR5K_RF2413:
+        case AR5K_RF5413:
+        case AR5K_RF2316:
+        case AR5K_RF2317:
+        case AR5K_RF2425:
+                type = AR5K_PWRTABLE_PWR_TO_PDADC;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        /* FIXME: Only on channel/mode change */
+        ret = ath5k_setup_channel_powertable(ah, channel, ee_mode, type);
+        if (ret)
+                return ret;
+
+        /* Limit max power if we have a CTL available */
+        ath5k_get_max_ctl_power(ah, channel);
+
+        /* FIXME: Tx power limit for this regdomain
+         * XXX: Mac80211/CRDA will do that anyway ? */
+
+        /* FIXME: Antenna reduction stuff */
+
+        /* FIXME: Limit power on turbo modes */
+
+        /* FIXME: TPC scale reduction */
+
+        /* Get surounding channels for per-rate power table
+         * calibration */
+        ath5k_get_rate_pcal_data(ah, channel, &rate_info);
+
+        /* Setup rate power table */
+        ath5k_setup_rate_powertable(ah, txpower, &rate_info, ee_mode);
+
+        /* Write rate power table on hw */
         ath5k_hw_reg_write(ah, AR5K_TXPOWER_OFDM(3, 24) |
                 AR5K_TXPOWER_OFDM(2, 16) | AR5K_TXPOWER_OFDM(1, 8) |
                 AR5K_TXPOWER_OFDM(0, 0), AR5K_PHY_TXPOWER_RATE1);
@@ -1536,26 +2566,34 @@ ath5k_hw_txpower(struct ath5k_hw *ah, struct ieee80211_channel *channel,
                 AR5K_TXPOWER_CCK(13, 16) | AR5K_TXPOWER_CCK(12, 8) |
                 AR5K_TXPOWER_CCK(11, 0), AR5K_PHY_TXPOWER_RATE4);
 
-        if (ah->ah_txpower.txp_tpc)
+        /* FIXME: TPC support */
+        if (ah->ah_txpower.txp_tpc) {
                 ath5k_hw_reg_write(ah, AR5K_PHY_TXPOWER_RATE_MAX_TPC_ENABLE |
                         AR5K_TUNE_MAX_TXPOWER, AR5K_PHY_TXPOWER_RATE_MAX);
-        else
+
+                ath5k_hw_reg_write(ah,
+                        AR5K_REG_MS(AR5K_TUNE_MAX_TXPOWER, AR5K_TPC_ACK) |
+                        AR5K_REG_MS(AR5K_TUNE_MAX_TXPOWER, AR5K_TPC_CTS) |
+                        AR5K_REG_MS(AR5K_TUNE_MAX_TXPOWER, AR5K_TPC_CHIRP),
+                        AR5K_TPC);
+        } else {
                 ath5k_hw_reg_write(ah, AR5K_PHY_TXPOWER_RATE_MAX |
                         AR5K_TUNE_MAX_TXPOWER, AR5K_PHY_TXPOWER_RATE_MAX);
+        }
 
         return 0;
 }
 
-int ath5k_hw_set_txpower_limit(struct ath5k_hw *ah, unsigned int power)
+int ath5k_hw_set_txpower_limit(struct ath5k_hw *ah, u8 mode, u8 txpower)
 {
         /*Just a try M.F.*/
         struct ieee80211_channel *channel = &ah->ah_current_channel;
 
         ATH5K_TRACE(ah->ah_sc);
         ATH5K_DBG(ah->ah_sc, ATH5K_DEBUG_TXPOWER,
-                "changing txpower to %d\n", power);
+                "changing txpower to %d\n", txpower);
 
-        return ath5k_hw_txpower(ah, channel, power);
+        return ath5k_hw_txpower(ah, channel, mode, txpower);
 }
 
 #undef _ATH5K_PHY
diff --git a/drivers/net/wireless/ath5k/reg.h b/drivers/net/wireless/ath5k/reg.h
index 2dc008e10226..7070d1543cdc 100644
--- a/drivers/net/wireless/ath5k/reg.h
+++ b/drivers/net/wireless/ath5k/reg.h
@@ -1554,6 +1554,19 @@
 /*===5212 Specific PCU registers===*/
 
 /*
+ * Transmit power control register
+ */
+#define AR5K_TPC                        0x80e8
+#define AR5K_TPC_ACK                    0x0000003f      /* ack frames */
+#define AR5K_TPC_ACK_S                  0
+#define AR5K_TPC_CTS                    0x00003f00      /* cts frames */
+#define AR5K_TPC_CTS_S                  8
+#define AR5K_TPC_CHIRP                  0x003f0000      /* chirp frames */
+#define AR5K_TPC_CHIRP_S                16
+#define AR5K_TPC_DOPPLER                0x0f000000      /* doppler chirp span */
+#define AR5K_TPC_DOPPLER_S              24
+
+/*
  * XR (eXtended Range) mode register
  */
 #define AR5K_XRMODE                     0x80c0                  /* Register Address */
@@ -2550,6 +2563,12 @@
 #define AR5K_PHY_TPC_RG1                0xa258
 #define AR5K_PHY_TPC_RG1_NUM_PD_GAIN    0x0000c000
 #define AR5K_PHY_TPC_RG1_NUM_PD_GAIN_S  14
+#define AR5K_PHY_TPC_RG1_PDGAIN_1       0x00030000
+#define AR5K_PHY_TPC_RG1_PDGAIN_1_S     16
+#define AR5K_PHY_TPC_RG1_PDGAIN_2       0x000c0000
+#define AR5K_PHY_TPC_RG1_PDGAIN_2_S     18
+#define AR5K_PHY_TPC_RG1_PDGAIN_3       0x00300000
+#define AR5K_PHY_TPC_RG1_PDGAIN_3_S     20
 
 #define AR5K_PHY_TPC_RG5                        0xa26C
 #define AR5K_PHY_TPC_RG5_PD_GAIN_OVERLAP        0x0000000F
diff --git a/drivers/net/wireless/ath5k/reset.c b/drivers/net/wireless/ath5k/reset.c
index 685dc213edae..7a17d31b2fd9 100644
--- a/drivers/net/wireless/ath5k/reset.c
+++ b/drivers/net/wireless/ath5k/reset.c
@@ -664,29 +664,35 @@ static void ath5k_hw_commit_eeprom_settings(struct ath5k_hw *ah,
                 struct ieee80211_channel *channel, u8 *ant, u8 ee_mode)
 {
         struct ath5k_eeprom_info *ee = &ah->ah_capabilities.cap_eeprom;
+        s16 cck_ofdm_pwr_delta;
 
-        /* Set CCK to OFDM power delta */
-        if (ah->ah_phy_revision >= AR5K_SREV_PHY_5212A) {
-                int16_t cck_ofdm_pwr_delta;
-
-                /* Adjust power delta for channel 14 */
-                if (channel->center_freq == 2484)
-                        cck_ofdm_pwr_delta =
-                                ((ee->ee_cck_ofdm_power_delta -
-                                ee->ee_scaled_cck_delta) * 2) / 10;
-                else
-                        cck_ofdm_pwr_delta =
-                                (ee->ee_cck_ofdm_power_delta * 2) / 10;
+        /* Adjust power delta for channel 14 */
+        if (channel->center_freq == 2484)
+                cck_ofdm_pwr_delta =
+                        ((ee->ee_cck_ofdm_power_delta -
+                        ee->ee_scaled_cck_delta) * 2) / 10;
+        else
+                cck_ofdm_pwr_delta =
+                        (ee->ee_cck_ofdm_power_delta * 2) / 10;
 
+        /* Set CCK to OFDM power delta on tx power
+         * adjustment register */
+        if (ah->ah_phy_revision >= AR5K_SREV_PHY_5212A) {
                 if (channel->hw_value == CHANNEL_G)
                         ath5k_hw_reg_write(ah,
-                        AR5K_REG_SM((ee->ee_cck_ofdm_power_delta * -1),
+                        AR5K_REG_SM((ee->ee_cck_ofdm_gain_delta * -1),
                                 AR5K_PHY_TX_PWR_ADJ_CCK_GAIN_DELTA) |
                         AR5K_REG_SM((cck_ofdm_pwr_delta * -1),
                                 AR5K_PHY_TX_PWR_ADJ_CCK_PCDAC_INDEX),
                                 AR5K_PHY_TX_PWR_ADJ);
                 else
                         ath5k_hw_reg_write(ah, 0, AR5K_PHY_TX_PWR_ADJ);
+        } else {
+                /* For older revs we scale power on sw during tx power
+                 * setup */
+                ah->ah_txpower.txp_cck_ofdm_pwr_delta = cck_ofdm_pwr_delta;
+                ah->ah_txpower.txp_cck_ofdm_gainf_delta =
+                                                ee->ee_cck_ofdm_gain_delta;
         }
 
         /* Set antenna idle switch table */
@@ -994,7 +1000,8 @@ int ath5k_hw_reset(struct ath5k_hw *ah, enum nl80211_iftype op_mode,
                 /*
                  * Set TX power (FIXME)
                  */
-                ret = ath5k_hw_txpower(ah, channel, AR5K_TUNE_DEFAULT_TXPOWER);
+                ret = ath5k_hw_txpower(ah, channel, ee_mode,
+                                        AR5K_TUNE_DEFAULT_TXPOWER);
                 if (ret)
                         return ret;