Merge master.kernel.org:/pub/scm/linux/kernel/git/davej/cpufreq

* master.kernel.org:/pub/scm/linux/kernel/git/davej/cpufreq:
  [CPUFREQ] Longhaul - Redo Longhaul ver. 2
  [CPUFREQ] EPS - Correct 2nd brand test
  [CPUFREQ] Longhaul - Separate frequency and voltage transition
  [CPUFREQ] Longhaul - Models of Nehemiah
  [CPUFREQ] Whitespace fixup
  [CPUFREQ] Longhaul - Simplier minmult
  [CPUFREQ] CPU_FREQ_TABLE shouldn't be a def_tristate
  [CPUFREQ] ondemand governor use new cpufreq rwsem locking in work callback
  [CPUFREQ] ondemand governor restructure the work callback
  [CPUFREQ] Rewrite lock in cpufreq to eliminate cpufreq/hotplug related issues
  [CPUFREQ] Remove hotplug cpu crap
  [CPUFREQ] Enhanced PowerSaver driver
  [CPUFREQ] Longhaul - Add VT8235 support
  [CPUFREQ] Longhaul - Fix guess_fsb function
  [CPUFREQ] Longhaul - Remove duplicate tables
  [CPUFREQ] Longhaul - Introduce Nehemiah C
  [CPUFREQ] fix cpuinfo_cur_freq for CPU_HW_PSTATE
  [CPUFREQ] Longhaul - Remove "ignore_latency" option

6 files changed, 576 insertions, 286 deletions

diff --git a/arch/i386/kernel/cpu/cpufreq/Kconfig b/arch/i386/kernel/cpu/cpufreq/Kconfig
index 5299c5bf4454..6c52182ca323 100644
--- a/arch/i386/kernel/cpu/cpufreq/Kconfig
+++ b/arch/i386/kernel/cpu/cpufreq/Kconfig
@@ -217,6 +217,15 @@ config X86_LONGHAUL
 
           If in doubt, say N.
 
+config X86_E_POWERSAVER
+        tristate "VIA C7 Enhanced PowerSaver (EXPERIMENTAL)"
+        select CPU_FREQ_TABLE
+        depends on EXPERIMENTAL
+        help
+          This adds the CPUFreq driver for VIA C7 processors.
+
+          If in doubt, say N.
+
 comment "shared options"
 
 config X86_ACPI_CPUFREQ_PROC_INTF
diff --git a/arch/i386/kernel/cpu/cpufreq/Makefile b/arch/i386/kernel/cpu/cpufreq/Makefile
index 8de3abe322a9..560f7760dae5 100644
--- a/arch/i386/kernel/cpu/cpufreq/Makefile
+++ b/arch/i386/kernel/cpu/cpufreq/Makefile
@@ -2,6 +2,7 @@ obj-$(CONFIG_X86_POWERNOW_K6)		+= powernow-k6.o
 obj-$(CONFIG_X86_POWERNOW_K7)           += powernow-k7.o
 obj-$(CONFIG_X86_POWERNOW_K8)           += powernow-k8.o
 obj-$(CONFIG_X86_LONGHAUL)              += longhaul.o
+obj-$(CONFIG_X86_E_POWERSAVER)          += e_powersaver.o
 obj-$(CONFIG_ELAN_CPUFREQ)              += elanfreq.o
 obj-$(CONFIG_SC520_CPUFREQ)             += sc520_freq.o
 obj-$(CONFIG_X86_LONGRUN)               += longrun.o  
diff --git a/arch/i386/kernel/cpu/cpufreq/e_powersaver.c b/arch/i386/kernel/cpu/cpufreq/e_powersaver.c
new file mode 100644
index 000000000000..f43d98e11cc7
--- /dev/null
+++ b/arch/i386/kernel/cpu/cpufreq/e_powersaver.c
@@ -0,0 +1,334 @@
+/*
+ *  Based on documentation provided by Dave Jones. Thanks!
+ *
+ *  Licensed under the terms of the GNU GPL License version 2.
+ *
+ *  BIG FAT DISCLAIMER: Work in progress code. Possibly *dangerous*
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/cpufreq.h>
+#include <linux/ioport.h>
+#include <linux/slab.h>
+
+#include <asm/msr.h>
+#include <asm/tsc.h>
+#include <asm/timex.h>
+#include <asm/io.h>
+#include <asm/delay.h>
+
+#define EPS_BRAND_C7M   0
+#define EPS_BRAND_C7    1
+#define EPS_BRAND_EDEN  2
+#define EPS_BRAND_C3    3
+
+struct eps_cpu_data {
+        u32 fsb;
+        struct cpufreq_frequency_table freq_table[];
+};
+
+static struct eps_cpu_data *eps_cpu[NR_CPUS];
+
+
+static unsigned int eps_get(unsigned int cpu)
+{
+        struct eps_cpu_data *centaur;
+        u32 lo, hi;
+
+        if (cpu)
+                return 0;
+        centaur = eps_cpu[cpu];
+        if (centaur == NULL)
+                return 0;
+
+        /* Return current frequency */
+        rdmsr(MSR_IA32_PERF_STATUS, lo, hi);
+        return centaur->fsb * ((lo >> 8) & 0xff);
+}
+
+static int eps_set_state(struct eps_cpu_data *centaur,
+                         unsigned int cpu,
+                         u32 dest_state)
+{
+        struct cpufreq_freqs freqs;
+        u32 lo, hi;
+        int err = 0;
+        int i;
+
+        freqs.old = eps_get(cpu);
+        freqs.new = centaur->fsb * ((dest_state >> 8) & 0xff);
+        freqs.cpu = cpu;
+        cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
+
+        /* Wait while CPU is busy */
+        rdmsr(MSR_IA32_PERF_STATUS, lo, hi);
+        i = 0;
+        while (lo & ((1 << 16) | (1 << 17))) {
+                udelay(16);
+                rdmsr(MSR_IA32_PERF_STATUS, lo, hi);
+                i++;
+                if (unlikely(i > 64)) {
+                        err = -ENODEV;
+                        goto postchange;
+                }
+        }
+        /* Set new multiplier and voltage */
+        wrmsr(MSR_IA32_PERF_CTL, dest_state & 0xffff, 0);
+        /* Wait until transition end */
+        i = 0;
+        do {
+                udelay(16);
+                rdmsr(MSR_IA32_PERF_STATUS, lo, hi);
+                i++;
+                if (unlikely(i > 64)) {
+                        err = -ENODEV;
+                        goto postchange;
+                }
+        } while (lo & ((1 << 16) | (1 << 17)));
+
+        /* Return current frequency */
+postchange:
+        rdmsr(MSR_IA32_PERF_STATUS, lo, hi);
+        freqs.new = centaur->fsb * ((lo >> 8) & 0xff);
+
+        cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
+        return err;
+}
+
+static int eps_target(struct cpufreq_policy *policy,
+                               unsigned int target_freq,
+                               unsigned int relation)
+{
+        struct eps_cpu_data *centaur;
+        unsigned int newstate = 0;
+        unsigned int cpu = policy->cpu;
+        unsigned int dest_state;
+        int ret;
+
+        if (unlikely(eps_cpu[cpu] == NULL))
+                return -ENODEV;
+        centaur = eps_cpu[cpu];
+
+        if (unlikely(cpufreq_frequency_table_target(policy,
+                        &eps_cpu[cpu]->freq_table[0],
+                        target_freq,
+                        relation,
+                        &newstate))) {
+                return -EINVAL;
+        }
+
+        /* Make frequency transition */
+        dest_state = centaur->freq_table[newstate].index & 0xffff;
+        ret = eps_set_state(centaur, cpu, dest_state);
+        if (ret)
+                printk(KERN_ERR "eps: Timeout!\n");
+        return ret;
+}
+
+static int eps_verify(struct cpufreq_policy *policy)
+{
+        return cpufreq_frequency_table_verify(policy,
+                        &eps_cpu[policy->cpu]->freq_table[0]);
+}
+
+static int eps_cpu_init(struct cpufreq_policy *policy)
+{
+        unsigned int i;
+        u32 lo, hi;
+        u64 val;
+        u8 current_multiplier, current_voltage;
+        u8 max_multiplier, max_voltage;
+        u8 min_multiplier, min_voltage;
+        u8 brand;
+        u32 fsb;
+        struct eps_cpu_data *centaur;
+        struct cpufreq_frequency_table *f_table;
+        int k, step, voltage;
+        int ret;
+        int states;
+
+        if (policy->cpu != 0)
+                return -ENODEV;
+
+        /* Check brand */
+        printk("eps: Detected VIA ");
+        rdmsr(0x1153, lo, hi);
+        brand = (((lo >> 2) ^ lo) >> 18) & 3;
+        switch(brand) {
+        case EPS_BRAND_C7M:
+                printk("C7-M\n");
+                break;
+        case EPS_BRAND_C7:
+                printk("C7\n");
+                break;
+        case EPS_BRAND_EDEN:
+                printk("Eden\n");
+                break;
+        case EPS_BRAND_C3:
+                printk("C3\n");
+                return -ENODEV;
+                break;
+        }
+        /* Enable Enhanced PowerSaver */
+        rdmsrl(MSR_IA32_MISC_ENABLE, val);
+        if (!(val & 1 << 16)) {
+                val |= 1 << 16;
+                wrmsrl(MSR_IA32_MISC_ENABLE, val);
+                /* Can be locked at 0 */
+                rdmsrl(MSR_IA32_MISC_ENABLE, val);
+                if (!(val & 1 << 16)) {
+                        printk("eps: Can't enable Enhanced PowerSaver\n");
+                        return -ENODEV;
+                }
+        }
+
+        /* Print voltage and multiplier */
+        rdmsr(MSR_IA32_PERF_STATUS, lo, hi);
+        current_voltage = lo & 0xff;
+        printk("eps: Current voltage = %dmV\n", current_voltage * 16 + 700);
+        current_multiplier = (lo >> 8) & 0xff;
+        printk("eps: Current multiplier = %d\n", current_multiplier);
+
+        /* Print limits */
+        max_voltage = hi & 0xff;
+        printk("eps: Highest voltage = %dmV\n", max_voltage * 16 + 700);
+        max_multiplier = (hi >> 8) & 0xff;
+        printk("eps: Highest multiplier = %d\n", max_multiplier);
+        min_voltage = (hi >> 16) & 0xff;
+        printk("eps: Lowest voltage = %dmV\n", min_voltage * 16 + 700);
+        min_multiplier = (hi >> 24) & 0xff;
+        printk("eps: Lowest multiplier = %d\n", min_multiplier);
+
+        /* Sanity checks */
+        if (current_multiplier == 0 || max_multiplier == 0
+            || min_multiplier == 0)
+                return -EINVAL;
+        if (current_multiplier > max_multiplier
+            || max_multiplier <= min_multiplier)
+                return -EINVAL;
+        if (current_voltage > 0x1c || max_voltage > 0x1c)
+                return -EINVAL;
+        if (max_voltage < min_voltage)
+                return -EINVAL;
+
+        /* Calc FSB speed */
+        fsb = cpu_khz / current_multiplier;
+        /* Calc number of p-states supported */
+        if (brand == EPS_BRAND_C7M)
+                states = max_multiplier - min_multiplier + 1;
+        else
+                states = 2;
+
+        /* Allocate private data and frequency table for current cpu */
+        centaur = kzalloc(sizeof(struct eps_cpu_data)
+                    + (states + 1) * sizeof(struct cpufreq_frequency_table),
+                    GFP_KERNEL);
+        if (!centaur)
+                return -ENOMEM;
+        eps_cpu[0] = centaur;
+
+        /* Copy basic values */
+        centaur->fsb = fsb;
+
+        /* Fill frequency and MSR value table */
+        f_table = &centaur->freq_table[0];
+        if (brand != EPS_BRAND_C7M) {
+                f_table[0].frequency = fsb * min_multiplier;
+                f_table[0].index = (min_multiplier << 8) | min_voltage;
+                f_table[1].frequency = fsb * max_multiplier;
+                f_table[1].index = (max_multiplier << 8) | max_voltage;
+                f_table[2].frequency = CPUFREQ_TABLE_END;
+        } else {
+                k = 0;
+                step = ((max_voltage - min_voltage) * 256)
+                        / (max_multiplier - min_multiplier);
+                for (i = min_multiplier; i <= max_multiplier; i++) {
+                        voltage = (k * step) / 256 + min_voltage;
+                        f_table[k].frequency = fsb * i;
+                        f_table[k].index = (i << 8) | voltage;
+                        k++;
+                }
+                f_table[k].frequency = CPUFREQ_TABLE_END;
+        }
+
+        policy->governor = CPUFREQ_DEFAULT_GOVERNOR;
+        policy->cpuinfo.transition_latency = 140000; /* 844mV -> 700mV in ns */
+        policy->cur = fsb * current_multiplier;
+
+        ret = cpufreq_frequency_table_cpuinfo(policy, &centaur->freq_table[0]);
+        if (ret) {
+                kfree(centaur);
+                return ret;
+        }
+
+        cpufreq_frequency_table_get_attr(&centaur->freq_table[0], policy->cpu);
+        return 0;
+}
+
+static int eps_cpu_exit(struct cpufreq_policy *policy)
+{
+        unsigned int cpu = policy->cpu;
+        struct eps_cpu_data *centaur;
+        u32 lo, hi;
+
+        if (eps_cpu[cpu] == NULL)
+                return -ENODEV;
+        centaur = eps_cpu[cpu];
+
+        /* Get max frequency */
+        rdmsr(MSR_IA32_PERF_STATUS, lo, hi);
+        /* Set max frequency */
+        eps_set_state(centaur, cpu, hi & 0xffff);
+        /* Bye */
+        cpufreq_frequency_table_put_attr(policy->cpu);
+        kfree(eps_cpu[cpu]);
+        eps_cpu[cpu] = NULL;
+        return 0;
+}
+
+static struct freq_attr* eps_attr[] = {
+        &cpufreq_freq_attr_scaling_available_freqs,
+        NULL,
+};
+
+static struct cpufreq_driver eps_driver = {
+        .verify         = eps_verify,
+        .target         = eps_target,
+        .init           = eps_cpu_init,
+        .exit           = eps_cpu_exit,
+        .get            = eps_get,
+        .name           = "e_powersaver",
+        .owner          = THIS_MODULE,
+        .attr           = eps_attr,
+};
+
+static int __init eps_init(void)
+{
+        struct cpuinfo_x86 *c = cpu_data;
+
+        /* This driver will work only on Centaur C7 processors with
+         * Enhanced SpeedStep/PowerSaver registers */
+        if (c->x86_vendor != X86_VENDOR_CENTAUR
+            || c->x86 != 6 || c->x86_model != 10)
+                return -ENODEV;
+        if (!cpu_has(c, X86_FEATURE_EST))
+                return -ENODEV;
+
+        if (cpufreq_register_driver(&eps_driver))
+                return -EINVAL;
+        return 0;
+}
+
+static void __exit eps_exit(void)
+{
+        cpufreq_unregister_driver(&eps_driver);
+}
+
+MODULE_AUTHOR("Rafa³ Bilski <rafalbilski@interia.pl>");
+MODULE_DESCRIPTION("Enhanced PowerSaver driver for VIA C7 CPU's.");
+MODULE_LICENSE("GPL");
+
+module_init(eps_init);
+module_exit(eps_exit);
diff --git a/arch/i386/kernel/cpu/cpufreq/longhaul.c b/arch/i386/kernel/cpu/cpufreq/longhaul.c
index a3db9332d652..b59878a0d9b3 100644
--- a/arch/i386/kernel/cpu/cpufreq/longhaul.c
+++ b/arch/i386/kernel/cpu/cpufreq/longhaul.c
@@ -8,12 +8,11 @@
  *  VIA have currently 3 different versions of Longhaul.
  *  Version 1 (Longhaul) uses the BCR2 MSR at 0x1147.
  *   It is present only in Samuel 1 (C5A), Samuel 2 (C5B) stepping 0.
- *  Version 2 of longhaul is the same as v1, but adds voltage scaling.
- *   Present in Samuel 2 (steppings 1-7 only) (C5B), and Ezra (C5C)
- *   voltage scaling support has currently been disabled in this driver
- *   until we have code that gets it right.
+ *  Version 2 of longhaul is backward compatible with v1, but adds
+ *   LONGHAUL MSR for purpose of both frequency and voltage scaling.
+ *   Present in Samuel 2 (steppings 1-7 only) (C5B), and Ezra (C5C).
  *  Version 3 of longhaul got renamed to Powersaver and redesigned
- *   to use the POWERSAVER MSR at 0x110a.
+ *   to use only the POWERSAVER MSR at 0x110a.
  *   It is present in Ezra-T (C5M), Nehemiah (C5X) and above.
  *   It's pretty much the same feature wise to longhaul v2, though
  *   there is provision for scaling FSB too, but this doesn't work
@@ -51,10 +50,12 @@
 #define CPU_EZRA        3
 #define CPU_EZRA_T      4
 #define CPU_NEHEMIAH    5
+#define CPU_NEHEMIAH_C  6
 
 /* Flags */
 #define USE_ACPI_C3             (1 << 1)
 #define USE_NORTHBRIDGE         (1 << 2)
+#define USE_VT8235              (1 << 3)
 
 static int cpu_model;
 static unsigned int numscales=16;
@@ -63,7 +64,8 @@ static unsigned int fsb;
 static struct mV_pos *vrm_mV_table;
 static unsigned char *mV_vrm_table;
 struct f_msr {
-        unsigned char vrm;
+        u8 vrm;
+        u8 pos;
 };
 static struct f_msr f_msr_table[32];
 
@@ -73,10 +75,10 @@ static int can_scale_voltage;
 static struct acpi_processor *pr = NULL;
 static struct acpi_processor_cx *cx = NULL;
 static u8 longhaul_flags;
+static u8 longhaul_pos;
 
 /* Module parameters */
 static int scale_voltage;
-static int ignore_latency;
 
 #define dprintk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_DRIVER, "longhaul", msg)
 
@@ -164,26 +166,47 @@ static void do_longhaul1(unsigned int clock_ratio_index)
 static void do_powersaver(int cx_address, unsigned int clock_ratio_index)
 {
         union msr_longhaul longhaul;
+        u8 dest_pos;
         u32 t;
 
+        dest_pos = f_msr_table[clock_ratio_index].pos;
+
         rdmsrl(MSR_VIA_LONGHAUL, longhaul.val);
+        /* Setup new frequency */
         longhaul.bits.RevisionKey = longhaul.bits.RevisionID;
         longhaul.bits.SoftBusRatio = clock_ratio_index & 0xf;
         longhaul.bits.SoftBusRatio4 = (clock_ratio_index & 0x10) >> 4;
-        longhaul.bits.EnableSoftBusRatio = 1;
-
-        if (can_scale_voltage) {
+        /* Setup new voltage */
+        if (can_scale_voltage)
                 longhaul.bits.SoftVID = f_msr_table[clock_ratio_index].vrm;
+        /* Sync to timer tick */
+        safe_halt();
+        /* Raise voltage if necessary */
+        if (can_scale_voltage && longhaul_pos < dest_pos) {
                 longhaul.bits.EnableSoftVID = 1;
+                wrmsrl(MSR_VIA_LONGHAUL, longhaul.val);
+                /* Change voltage */
+                if (!cx_address) {
+                        ACPI_FLUSH_CPU_CACHE();
+                        halt();
+                } else {
+                        ACPI_FLUSH_CPU_CACHE();
+                        /* Invoke C3 */
+                        inb(cx_address);
+                        /* Dummy op - must do something useless after P_LVL3
+                         * read */
+                        t = inl(acpi_gbl_FADT.xpm_timer_block.address);
+                }
+                longhaul.bits.EnableSoftVID = 0;
+                wrmsrl(MSR_VIA_LONGHAUL, longhaul.val);
+                longhaul_pos = dest_pos;
         }
 
-        /* Sync to timer tick */
-        safe_halt();
         /* Change frequency on next halt or sleep */
+        longhaul.bits.EnableSoftBusRatio = 1;
         wrmsrl(MSR_VIA_LONGHAUL, longhaul.val);
         if (!cx_address) {
                 ACPI_FLUSH_CPU_CACHE();
-                /* Invoke C1 */
                 halt();
         } else {
                 ACPI_FLUSH_CPU_CACHE();
@@ -193,12 +216,29 @@ static void do_powersaver(int cx_address, unsigned int clock_ratio_index)
                 t = inl(acpi_gbl_FADT.xpm_timer_block.address);
         }
         /* Disable bus ratio bit */
-        local_irq_disable();
-        longhaul.bits.RevisionKey = longhaul.bits.RevisionID;
         longhaul.bits.EnableSoftBusRatio = 0;
-        longhaul.bits.EnableSoftBSEL = 0;
-        longhaul.bits.EnableSoftVID = 0;
         wrmsrl(MSR_VIA_LONGHAUL, longhaul.val);
+
+        /* Reduce voltage if necessary */
+        if (can_scale_voltage && longhaul_pos > dest_pos) {
+                longhaul.bits.EnableSoftVID = 1;
+                wrmsrl(MSR_VIA_LONGHAUL, longhaul.val);
+                /* Change voltage */
+                if (!cx_address) {
+                        ACPI_FLUSH_CPU_CACHE();
+                        halt();
+                } else {
+                        ACPI_FLUSH_CPU_CACHE();
+                        /* Invoke C3 */
+                        inb(cx_address);
+                        /* Dummy op - must do something useless after P_LVL3
+                         * read */
+                        t = inl(acpi_gbl_FADT.xpm_timer_block.address);
+                }
+                longhaul.bits.EnableSoftVID = 0;
+                wrmsrl(MSR_VIA_LONGHAUL, longhaul.val);
+                longhaul_pos = dest_pos;
+        }
 }
 
 /**
@@ -257,26 +297,19 @@ static void longhaul_setstate(unsigned int clock_ratio_index)
         /*
          * Longhaul v1. (Samuel[C5A] and Samuel2 stepping 0[C5B])
          * Software controlled multipliers only.
-         *
-         * *NB* Until we get voltage scaling working v1 & v2 are the same code.
-         * Longhaul v2 appears in Samuel2 Steppings 1->7 [C5b] and Ezra [C5C]
          */
         case TYPE_LONGHAUL_V1:
-        case TYPE_LONGHAUL_V2:
                 do_longhaul1(clock_ratio_index);
                 break;
 
         /*
+         * Longhaul v2 appears in Samuel2 Steppings 1->7 [C5B] and Ezra [C5C]
+         *
          * Longhaul v3 (aka Powersaver). (Ezra-T [C5M] & Nehemiah [C5N])
-         * We can scale voltage with this too, but that's currently
-         * disabled until we come up with a decent 'match freq to voltage'
-         * algorithm.
-         * When we add voltage scaling, we will also need to do the
-         * voltage/freq setting in order depending on the direction
-         * of scaling (like we do in powernow-k7.c)
          * Nehemiah can do FSB scaling too, but this has never been proven
          * to work in practice.
          */
+        case TYPE_LONGHAUL_V2:
         case TYPE_POWERSAVER:
                 if (longhaul_flags & USE_ACPI_C3) {
                         /* Don't allow wakeup */
@@ -301,6 +334,7 @@ static void longhaul_setstate(unsigned int clock_ratio_index)
         local_irq_restore(flags);
         preempt_enable();
 
+        freqs.new = calc_speed(longhaul_get_cpu_mult());
         cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
 }
 
@@ -315,31 +349,19 @@ static void longhaul_setstate(unsigned int clock_ratio_index)
 
 #define ROUNDING        0xf
 
-static int _guess(int guess, int mult)
-{
-        int target;
-
-        target = ((mult/10)*guess);
-        if (mult%10 != 0)
-                target += (guess/2);
-        target += ROUNDING/2;
-        target &= ~ROUNDING;
-        return target;
-}
-
-
 static int guess_fsb(int mult)
 {
-        int speed = (cpu_khz/1000);
+        int speed = cpu_khz / 1000;
         int i;
-        int speeds[] = { 66, 100, 133, 200 };
-
-        speed += ROUNDING/2;
-        speed &= ~ROUNDING;
-
-        for (i=0; i<4; i++) {
-                if (_guess(speeds[i], mult) == speed)
-                        return speeds[i];
+        int speeds[] = { 666, 1000, 1333, 2000 };
+        int f_max, f_min;
+
+        for (i = 0; i < 4; i++) {
+                f_max = ((speeds[i] * mult) + 50) / 100;
+                f_max += (ROUNDING / 2);
+                f_min = f_max - ROUNDING;
+                if ((speed <= f_max) && (speed >= f_min))
+                        return speeds[i] / 10;
         }
         return 0;
 }
@@ -347,67 +369,40 @@ static int guess_fsb(int mult)
 
 static int __init longhaul_get_ranges(void)
 {
-        unsigned long invalue;
-        unsigned int ezra_t_multipliers[32]= {
-                        90,  30,  40, 100,  55,  35,  45,  95,
-                        50,  70,  80,  60, 120,  75,  85,  65,
-                        -1, 110, 120,  -1, 135, 115, 125, 105,
-                        130, 150, 160, 140,  -1, 155,  -1, 145 };
         unsigned int j, k = 0;
-        union msr_longhaul longhaul;
-        int mult = 0;
+        int mult;
 
-        switch (longhaul_version) {
-        case TYPE_LONGHAUL_V1:
-        case TYPE_LONGHAUL_V2:
-                /* Ugh, Longhaul v1 didn't have the min/max MSRs.
-                   Assume min=3.0x & max = whatever we booted at. */
+        /* Get current frequency */
+        mult = longhaul_get_cpu_mult();
+        if (mult == -1) {
+                printk(KERN_INFO PFX "Invalid (reserved) multiplier!\n");
+                return -EINVAL;
+        }
+        fsb = guess_fsb(mult);
+        if (fsb == 0) {
+                printk(KERN_INFO PFX "Invalid (reserved) FSB!\n");
+                return -EINVAL;
+        }
+        /* Get max multiplier - as we always did.
+         * Longhaul MSR is usefull only when voltage scaling is enabled.
+         * C3 is booting at max anyway. */
+        maxmult = mult;
+        /* Get min multiplier */
+        switch (cpu_model) {
+        case CPU_NEHEMIAH:
+                minmult = 50;
+                break;
+        case CPU_NEHEMIAH_C:
+                minmult = 40;
+                break;
+        default:
                 minmult = 30;
-                maxmult = mult = longhaul_get_cpu_mult();
                 break;
-
-        case TYPE_POWERSAVER:
-                /* Ezra-T */
-                if (cpu_model==CPU_EZRA_T) {
-                        minmult = 30;
-                        rdmsrl (MSR_VIA_LONGHAUL, longhaul.val);
-                        invalue = longhaul.bits.MaxMHzBR;
-                        if (longhaul.bits.MaxMHzBR4)
-                                invalue += 16;
-                        maxmult = mult = ezra_t_multipliers[invalue];
-                        break;
-                }
-
-                /* Nehemiah */
-                if (cpu_model==CPU_NEHEMIAH) {
-                        rdmsrl (MSR_VIA_LONGHAUL, longhaul.val);
-
-                        /*
-                         * TODO: This code works, but raises a lot of questions.
-                         * - Some Nehemiah's seem to have broken Min/MaxMHzBR's.
-                         *   We get around this by using a hardcoded multiplier of 4.0x
-                         *   for the minimimum speed, and the speed we booted up at for the max.
-                         *   This is done in longhaul_get_cpu_mult() by reading the EBLCR register.
-                         * - According to some VIA documentation EBLCR is only
-                         *   in pre-Nehemiah C3s. How this still works is a mystery.
-                         *   We're possibly using something undocumented and unsupported,
-                         *   But it works, so we don't grumble.
-                         */
-                        minmult=40;
-                        maxmult = mult = longhaul_get_cpu_mult();
-                        break;
-                }
         }
-        fsb = guess_fsb(mult);
 
         dprintk ("MinMult:%d.%dx MaxMult:%d.%dx\n",
                  minmult/10, minmult%10, maxmult/10, maxmult%10);
 
-        if (fsb == 0) {
-                printk (KERN_INFO PFX "Invalid (reserved) FSB!\n");
-                return -EINVAL;
-        }
-
         highest_speed = calc_speed(maxmult);
         lowest_speed = calc_speed(minmult);
         dprintk ("FSB:%dMHz  Lowest speed: %s   Highest speed:%s\n", fsb,
@@ -455,6 +450,7 @@ static void __init longhaul_setup_voltagescaling(void)
         union msr_longhaul longhaul;
         struct mV_pos minvid, maxvid;
         unsigned int j, speed, pos, kHz_step, numvscales;
+        int min_vid_speed;
 
         rdmsrl(MSR_VIA_LONGHAUL, longhaul.val);
         if (!(longhaul.bits.RevisionID & 1)) {
@@ -468,14 +464,14 @@ static void __init longhaul_setup_voltagescaling(void)
                 mV_vrm_table = &mV_vrm85[0];
         } else {
                 printk (KERN_INFO PFX "Mobile VRM\n");
+                if (cpu_model < CPU_NEHEMIAH)
+                        return;
                 vrm_mV_table = &mobilevrm_mV[0];
                 mV_vrm_table = &mV_mobilevrm[0];
         }
 
         minvid = vrm_mV_table[longhaul.bits.MinimumVID];
         maxvid = vrm_mV_table[longhaul.bits.MaximumVID];
-        numvscales = maxvid.pos - minvid.pos + 1;
-        kHz_step = (highest_speed - lowest_speed) / numvscales;
 
         if (minvid.mV == 0 || maxvid.mV == 0 || minvid.mV > maxvid.mV) {
                 printk (KERN_INFO PFX "Bogus values Min:%d.%03d Max:%d.%03d. "
@@ -491,20 +487,59 @@ static void __init longhaul_setup_voltagescaling(void)
                 return;
         }
 
-        printk(KERN_INFO PFX "Max VID=%d.%03d  Min VID=%d.%03d, %d possible voltage scales\n",
+        /* How many voltage steps */
+        numvscales = maxvid.pos - minvid.pos + 1;
+        printk(KERN_INFO PFX
+                "Max VID=%d.%03d  "
+                "Min VID=%d.%03d, "
+                "%d possible voltage scales\n",
                 maxvid.mV/1000, maxvid.mV%1000,
                 minvid.mV/1000, minvid.mV%1000,
                 numvscales);
 
+        /* Calculate max frequency at min voltage */
+        j = longhaul.bits.MinMHzBR;
+        if (longhaul.bits.MinMHzBR4)
+                j += 16;
+        min_vid_speed = eblcr_table[j];
+        if (min_vid_speed == -1)
+                return;
+        switch (longhaul.bits.MinMHzFSB) {
+        case 0:
+                min_vid_speed *= 13333;
+                break;
+        case 1:
+                min_vid_speed *= 10000;
+                break;
+        case 3:
+                min_vid_speed *= 6666;
+                break;
+        default:
+                return;
+                break;
+        }
+        if (min_vid_speed >= highest_speed)
+                return;
+        /* Calculate kHz for one voltage step */
+        kHz_step = (highest_speed - min_vid_speed) / numvscales;
+
+
         j = 0;
         while (longhaul_table[j].frequency != CPUFREQ_TABLE_END) {
                 speed = longhaul_table[j].frequency;
-                pos = (speed - lowest_speed) / kHz_step + minvid.pos;
+                if (speed > min_vid_speed)
+                        pos = (speed - min_vid_speed) / kHz_step + minvid.pos;
+                else
+                        pos = minvid.pos;
                 f_msr_table[longhaul_table[j].index].vrm = mV_vrm_table[pos];
+                f_msr_table[longhaul_table[j].index].pos = pos;
                 j++;
         }
 
+        longhaul_pos = maxvid.pos;
         can_scale_voltage = 1;
+        printk(KERN_INFO PFX "Voltage scaling enabled. "
+                "Use of \"conservative\" governor is highly recommended.\n");
 }
 
 
@@ -573,20 +608,51 @@ static int enable_arbiter_disable(void)
         if (dev != NULL) {
                 /* Enable access to port 0x22 */
                 pci_read_config_byte(dev, reg, &pci_cmd);
-                if ( !(pci_cmd & 1<<7) ) {
+                if (!(pci_cmd & 1<<7)) {
                         pci_cmd |= 1<<7;
                         pci_write_config_byte(dev, reg, pci_cmd);
+                        pci_read_config_byte(dev, reg, &pci_cmd);
+                        if (!(pci_cmd & 1<<7)) {
+                                printk(KERN_ERR PFX
+                                        "Can't enable access to port 0x22.\n");
+                                return 0;
+                        }
                 }
                 return 1;
         }
         return 0;
 }
 
+static int longhaul_setup_vt8235(void)
+{
+        struct pci_dev *dev;
+        u8 pci_cmd;
+
+        /* Find VT8235 southbridge */
+        dev = pci_find_device(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8235, NULL);
+        if (dev != NULL) {
+                /* Set transition time to max */
+                pci_read_config_byte(dev, 0xec, &pci_cmd);
+                pci_cmd &= ~(1 << 2);
+                pci_write_config_byte(dev, 0xec, pci_cmd);
+                pci_read_config_byte(dev, 0xe4, &pci_cmd);
+                pci_cmd &= ~(1 << 7);
+                pci_write_config_byte(dev, 0xe4, pci_cmd);
+                pci_read_config_byte(dev, 0xe5, &pci_cmd);
+                pci_cmd |= 1 << 7;
+                pci_write_config_byte(dev, 0xe5, pci_cmd);
+                return 1;
+        }
+        return 0;
+}
+
 static int __init longhaul_cpu_init(struct cpufreq_policy *policy)
 {
         struct cpuinfo_x86 *c = cpu_data;
         char *cpuname=NULL;
         int ret;
+        u32 lo, hi;
+        int vt8235_present;
 
         /* Check what we have on this motherboard */
         switch (c->x86_model) {
@@ -599,16 +665,20 @@ static int __init longhaul_cpu_init(struct cpufreq_policy *policy)
                 break;
 
         case 7:
-                longhaul_version = TYPE_LONGHAUL_V1;
                 switch (c->x86_mask) {
                 case 0:
+                        longhaul_version = TYPE_LONGHAUL_V1;
                         cpu_model = CPU_SAMUEL2;
                         cpuname = "C3 'Samuel 2' [C5B]";
-                        /* Note, this is not a typo, early Samuel2's had Samuel1 ratios. */
-                        memcpy (clock_ratio, samuel1_clock_ratio, sizeof(samuel1_clock_ratio));
-                        memcpy (eblcr_table, samuel2_eblcr, sizeof(samuel2_eblcr));
+                        /* Note, this is not a typo, early Samuel2's had
+                         * Samuel1 ratios. */
+                        memcpy(clock_ratio, samuel1_clock_ratio,
+                                sizeof(samuel1_clock_ratio));
+                        memcpy(eblcr_table, samuel2_eblcr,
+                                sizeof(samuel2_eblcr));
                         break;
                 case 1 ... 15:
+                        longhaul_version = TYPE_LONGHAUL_V2;
                         if (c->x86_mask < 8) {
                                 cpu_model = CPU_SAMUEL2;
                                 cpuname = "C3 'Samuel 2' [C5B]";
@@ -616,8 +686,10 @@ static int __init longhaul_cpu_init(struct cpufreq_policy *policy)
                                 cpu_model = CPU_EZRA;
                                 cpuname = "C3 'Ezra' [C5C]";
                         }
-                        memcpy (clock_ratio, ezra_clock_ratio, sizeof(ezra_clock_ratio));
-                        memcpy (eblcr_table, ezra_eblcr, sizeof(ezra_eblcr));
+                        memcpy(clock_ratio, ezra_clock_ratio,
+                                sizeof(ezra_clock_ratio));
+                        memcpy(eblcr_table, ezra_eblcr,
+                                sizeof(ezra_eblcr));
                         break;
                 }
                 break;
@@ -632,24 +704,24 @@ static int __init longhaul_cpu_init(struct cpufreq_policy *policy)
                 break;
 
         case 9:
-                cpu_model = CPU_NEHEMIAH;
                 longhaul_version = TYPE_POWERSAVER;
-                numscales=32;
+                numscales = 32;
+                memcpy(clock_ratio,
+                       nehemiah_clock_ratio,
+                       sizeof(nehemiah_clock_ratio));
+                memcpy(eblcr_table, nehemiah_eblcr, sizeof(nehemiah_eblcr));
                 switch (c->x86_mask) {
                 case 0 ... 1:
-                        cpuname = "C3 'Nehemiah A' [C5N]";
-                        memcpy (clock_ratio, nehemiah_a_clock_ratio, sizeof(nehemiah_a_clock_ratio));
-                        memcpy (eblcr_table, nehemiah_a_eblcr, sizeof(nehemiah_a_eblcr));
+                        cpu_model = CPU_NEHEMIAH;
+                        cpuname = "C3 'Nehemiah A' [C5XLOE]";
                         break;
                 case 2 ... 4:
-                        cpuname = "C3 'Nehemiah B' [C5N]";
-                        memcpy (clock_ratio, nehemiah_b_clock_ratio, sizeof(nehemiah_b_clock_ratio));
-                        memcpy (eblcr_table, nehemiah_b_eblcr, sizeof(nehemiah_b_eblcr));
+                        cpu_model = CPU_NEHEMIAH;
+                        cpuname = "C3 'Nehemiah B' [C5XLOH]";
                         break;
                 case 5 ... 15:
-                        cpuname = "C3 'Nehemiah C' [C5N]";
-                        memcpy (clock_ratio, nehemiah_c_clock_ratio, sizeof(nehemiah_c_clock_ratio));
-                        memcpy (eblcr_table, nehemiah_c_eblcr, sizeof(nehemiah_c_eblcr));
+                        cpu_model = CPU_NEHEMIAH_C;
+                        cpuname = "C3 'Nehemiah C' [C5P]";
                         break;
                 }
                 break;
@@ -658,6 +730,13 @@ static int __init longhaul_cpu_init(struct cpufreq_policy *policy)
                 cpuname = "Unknown";
                 break;
         }
+        /* Check Longhaul ver. 2 */
+        if (longhaul_version == TYPE_LONGHAUL_V2) {
+                rdmsr(MSR_VIA_LONGHAUL, lo, hi);
+                if (lo == 0 && hi == 0)
+                        /* Looks like MSR isn't present */
+                        longhaul_version = TYPE_LONGHAUL_V1;
+        }
 
         printk (KERN_INFO PFX "VIA %s CPU detected.  ", cpuname);
         switch (longhaul_version) {
@@ -670,15 +749,18 @@ static int __init longhaul_cpu_init(struct cpufreq_policy *policy)
                 break;
         };
 
+        /* Doesn't hurt */
+        vt8235_present = longhaul_setup_vt8235();
+
         /* Find ACPI data for processor */
-        acpi_walk_namespace(ACPI_TYPE_PROCESSOR, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX,
-                            &longhaul_walk_callback, NULL, (void *)&pr);
+        acpi_walk_namespace(ACPI_TYPE_PROCESSOR, ACPI_ROOT_OBJECT,
+                                ACPI_UINT32_MAX, &longhaul_walk_callback,
+                                NULL, (void *)&pr);
 
         /* Check ACPI support for C3 state */
-        if ((pr != NULL) && (longhaul_version == TYPE_POWERSAVER)) {
+        if (pr != NULL && longhaul_version != TYPE_LONGHAUL_V1) {
                 cx = &pr->power.states[ACPI_STATE_C3];
-                if (cx->address > 0 &&
-                   (cx->latency <= 1000 || ignore_latency != 0) ) {
+                if (cx->address > 0 && cx->latency <= 1000) {
                         longhaul_flags |= USE_ACPI_C3;
                         goto print_support_type;
                 }
@@ -688,8 +770,11 @@ static int __init longhaul_cpu_init(struct cpufreq_policy *policy)
                 longhaul_flags |= USE_NORTHBRIDGE;
                 goto print_support_type;
         }
-
-        /* No ACPI C3 or we can't use it */
+        /* Use VT8235 southbridge if present */
+        if (longhaul_version == TYPE_POWERSAVER && vt8235_present) {
+                longhaul_flags |= USE_VT8235;
+                goto print_support_type;
+        }
         /* Check ACPI support for bus master arbiter disable */
         if ((pr == NULL) || !(pr->flags.bm_control)) {
                 printk(KERN_ERR PFX
@@ -698,18 +783,18 @@ static int __init longhaul_cpu_init(struct cpufreq_policy *policy)
         }
 
 print_support_type:
-        if (!(longhaul_flags & USE_NORTHBRIDGE)) {
-                printk (KERN_INFO PFX "Using ACPI support.\n");
-        } else {
+        if (longhaul_flags & USE_NORTHBRIDGE)
                 printk (KERN_INFO PFX "Using northbridge support.\n");
-        }
+        else if (longhaul_flags & USE_VT8235)
+                printk (KERN_INFO PFX "Using VT8235 support.\n");
+        else
+                printk (KERN_INFO PFX "Using ACPI support.\n");
 
         ret = longhaul_get_ranges();
         if (ret != 0)
                 return ret;
 
-        if ((longhaul_version==TYPE_LONGHAUL_V2 || longhaul_version==TYPE_POWERSAVER) &&
-                 (scale_voltage != 0))
+        if ((longhaul_version != TYPE_LONGHAUL_V1) && (scale_voltage != 0))
                 longhaul_setup_voltagescaling();
 
         policy->governor = CPUFREQ_DEFAULT_GOVERNOR;
@@ -797,8 +882,6 @@ static void __exit longhaul_exit(void)
 
 module_param (scale_voltage, int, 0644);
 MODULE_PARM_DESC(scale_voltage, "Scale voltage of processor");
-module_param(ignore_latency, int, 0644);
-MODULE_PARM_DESC(ignore_latency, "Skip ACPI C3 latency test");
 
 MODULE_AUTHOR ("Dave Jones <davej@codemonkey.org.uk>");
 MODULE_DESCRIPTION ("Longhaul driver for VIA Cyrix processors.");
diff --git a/arch/i386/kernel/cpu/cpufreq/longhaul.h b/arch/i386/kernel/cpu/cpufreq/longhaul.h
index bc4682aad69b..bb0a04b1d1ab 100644
--- a/arch/i386/kernel/cpu/cpufreq/longhaul.h
+++ b/arch/i386/kernel/cpu/cpufreq/longhaul.h
@@ -235,84 +235,14 @@ static int __initdata ezrat_eblcr[32] = {
 /*
  * VIA C3 Nehemiah */
 
-static int __initdata nehemiah_a_clock_ratio[32] = {
+static int __initdata  nehemiah_clock_ratio[32] = {
         100, /* 0000 -> 10.0x */
         160, /* 0001 -> 16.0x */
-        -1,  /* 0010 ->  RESERVED */
-        90,  /* 0011 ->  9.0x */
-        95,  /* 0100 ->  9.5x */
-        -1,  /* 0101 ->  RESERVED */
-        -1,  /* 0110 ->  RESERVED */
-        55,  /* 0111 ->  5.5x */
-        60,  /* 1000 ->  6.0x */
-        70,  /* 1001 ->  7.0x */
-        80,  /* 1010 ->  8.0x */
-        50,  /* 1011 ->  5.0x */
-        65,  /* 1100 ->  6.5x */
-        75,  /* 1101 ->  7.5x */
-        85,  /* 1110 ->  8.5x */
-        120, /* 1111 -> 12.0x */
-        100, /* 0000 -> 10.0x */
-        -1,  /* 0001 -> RESERVED */
-        120, /* 0010 -> 12.0x */
-        90,  /* 0011 ->  9.0x */
-        105, /* 0100 -> 10.5x */
-        115, /* 0101 -> 11.5x */
-        125, /* 0110 -> 12.5x */
-        135, /* 0111 -> 13.5x */
-        140, /* 1000 -> 14.0x */
-        150, /* 1001 -> 15.0x */
-        160, /* 1010 -> 16.0x */
-        130, /* 1011 -> 13.0x */
-        145, /* 1100 -> 14.5x */
-        155, /* 1101 -> 15.5x */
-        -1,  /* 1110 -> RESERVED (13.0x) */
-        120, /* 1111 -> 12.0x */
-};
-
-static int __initdata  nehemiah_b_clock_ratio[32] = {
-        100, /* 0000 -> 10.0x */
-        160, /* 0001 -> 16.0x */
-        -1,  /* 0010 ->  RESERVED */
-        90,  /* 0011 ->  9.0x */
-        95,  /* 0100 ->  9.5x */
-        -1,  /* 0101 ->  RESERVED */
-        -1,  /* 0110 ->  RESERVED */
-        55,  /* 0111 ->  5.5x */
-        60,  /* 1000 ->  6.0x */
-        70,  /* 1001 ->  7.0x */
-        80,  /* 1010 ->  8.0x */
-        50,  /* 1011 ->  5.0x */
-        65,  /* 1100 ->  6.5x */
-        75,  /* 1101 ->  7.5x */
-        85,  /* 1110 ->  8.5x */
-        120, /* 1111 -> 12.0x */
-        100, /* 0000 -> 10.0x */
-        110, /* 0001 -> 11.0x */
-        120, /* 0010 -> 12.0x */
-        90,  /* 0011 ->  9.0x */
-        105, /* 0100 -> 10.5x */
-        115, /* 0101 -> 11.5x */
-        125, /* 0110 -> 12.5x */
-        135, /* 0111 -> 13.5x */
-        140, /* 1000 -> 14.0x */
-        150, /* 1001 -> 15.0x */
-        160, /* 1010 -> 16.0x */
-        130, /* 1011 -> 13.0x */
-        145, /* 1100 -> 14.5x */
-        155, /* 1101 -> 15.5x */
-        -1,  /* 1110 -> RESERVED (13.0x) */
-        120, /* 1111 -> 12.0x */
-};
-
-static int __initdata  nehemiah_c_clock_ratio[32] = {
-        100, /* 0000 -> 10.0x */
-        160, /* 0001 -> 16.0x */
-        40,  /* 0010 ->  RESERVED */
+        40,  /* 0010 ->  4.0x */
         90,  /* 0011 ->  9.0x */
         95,  /* 0100 ->  9.5x */
         -1,  /* 0101 ->  RESERVED */
-        45,  /* 0110 ->  RESERVED */
+        45,  /* 0110 ->  4.5x */
         55,  /* 0111 ->  5.5x */
         60,  /* 1000 ->  6.0x */
         70,  /* 1001 ->  7.0x */
@@ -340,84 +270,14 @@ static int __initdata  nehemiah_c_clock_ratio[32] = {
         120, /* 1111 -> 12.0x */
 };
 
-static int __initdata nehemiah_a_eblcr[32] = {
-        50,  /* 0000 ->  5.0x */
-        160, /* 0001 -> 16.0x */
-        -1,  /* 0010 ->  RESERVED */
-        100, /* 0011 -> 10.0x */
-        55,  /* 0100 ->  5.5x */
-        -1,  /* 0101 ->  RESERVED */
-        -1,  /* 0110 ->  RESERVED */
-        95,  /* 0111 ->  9.5x */
-        90,  /* 1000 ->  9.0x */
-        70,  /* 1001 ->  7.0x */
-        80,  /* 1010 ->  8.0x */
-        60,  /* 1011 ->  6.0x */
-        120, /* 1100 -> 12.0x */
-        75,  /* 1101 ->  7.5x */
-        85,  /* 1110 ->  8.5x */
-        65,  /* 1111 ->  6.5x */
-        90,  /* 0000 ->  9.0x */
-        -1,  /* 0001 -> RESERVED */
-        120, /* 0010 -> 12.0x */
-        100, /* 0011 -> 10.0x */
-        135, /* 0100 -> 13.5x */
-        115, /* 0101 -> 11.5x */
-        125, /* 0110 -> 12.5x */
-        105, /* 0111 -> 10.5x */
-        130, /* 1000 -> 13.0x */
-        150, /* 1001 -> 15.0x */
-        160, /* 1010 -> 16.0x */
-        140, /* 1011 -> 14.0x */
-        120, /* 1100 -> 12.0x */
-        155, /* 1101 -> 15.5x */
-        -1,  /* 1110 -> RESERVED (13.0x) */
-        145 /* 1111 -> 14.5x */
-   /* end of table  */
-};
-static int __initdata nehemiah_b_eblcr[32] = {
-        50,  /* 0000 ->  5.0x */
-        160, /* 0001 -> 16.0x */
-        -1,  /* 0010 ->  RESERVED */
-        100, /* 0011 -> 10.0x */
-        55,  /* 0100 ->  5.5x */
-        -1,  /* 0101 ->  RESERVED */
-        -1,  /* 0110 ->  RESERVED */
-        95,  /* 0111 ->  9.5x */
-        90,  /* 1000 ->  9.0x */
-        70,  /* 1001 ->  7.0x */
-        80,  /* 1010 ->  8.0x */
-        60,  /* 1011 ->  6.0x */
-        120, /* 1100 -> 12.0x */
-        75,  /* 1101 ->  7.5x */
-        85,  /* 1110 ->  8.5x */
-        65,  /* 1111 ->  6.5x */
-        90,  /* 0000 ->  9.0x */
-        110, /* 0001 -> 11.0x */
-        120, /* 0010 -> 12.0x */
-        100, /* 0011 -> 10.0x */
-        135, /* 0100 -> 13.5x */
-        115, /* 0101 -> 11.5x */
-        125, /* 0110 -> 12.5x */
-        105, /* 0111 -> 10.5x */
-        130, /* 1000 -> 13.0x */
-        150, /* 1001 -> 15.0x */
-        160, /* 1010 -> 16.0x */
-        140, /* 1011 -> 14.0x */
-        120, /* 1100 -> 12.0x */
-        155, /* 1101 -> 15.5x */
-        -1,  /* 1110 -> RESERVED (13.0x) */
-        145 /* 1111 -> 14.5x */
-           /* end of table  */
-};
-static int __initdata nehemiah_c_eblcr[32] = {
+static int __initdata nehemiah_eblcr[32] = {
         50,  /* 0000 ->  5.0x */
         160, /* 0001 -> 16.0x */
-        40,  /* 0010 ->  RESERVED */
+        40,  /* 0010 ->  4.0x */
         100, /* 0011 -> 10.0x */
         55,  /* 0100 ->  5.5x */
         -1,  /* 0101 ->  RESERVED */
-        45,  /* 0110 ->  RESERVED */
+        45,  /* 0110 ->  4.5x */
         95,  /* 0111 ->  9.5x */
         90,  /* 1000 ->  9.0x */
         70,  /* 1001 ->  7.0x */
@@ -443,7 +303,6 @@ static int __initdata nehemiah_c_eblcr[32] = {
         155, /* 1101 -> 15.5x */
         -1,  /* 1110 -> RESERVED (13.0x) */
         145 /* 1111 -> 14.5x */
-          /* end of table  */
 };
 
 /*
diff --git a/arch/i386/kernel/cpu/cpufreq/powernow-k8.c b/arch/i386/kernel/cpu/cpufreq/powernow-k8.c
index 2d6491672559..fe3b67005ebb 100644
--- a/arch/i386/kernel/cpu/cpufreq/powernow-k8.c
+++ b/arch/i386/kernel/cpu/cpufreq/powernow-k8.c
@@ -1289,7 +1289,11 @@ static unsigned int powernowk8_get (unsigned int cpu)
         if (query_current_values_with_pending_wait(data))
                 goto out;
 
-        khz = find_khz_freq_from_fid(data->currfid);
+        if (cpu_family == CPU_HW_PSTATE)
+                khz = find_khz_freq_from_fiddid(data->currfid, data->currdid);
+        else
+                khz = find_khz_freq_from_fid(data->currfid);
+
 
 out:
         set_cpus_allowed(current, oldmask);