58 files changed, 927 insertions, 562 deletions

diff --git a/Documentation/cpu-freq/core.txt b/Documentation/cpu-freq/core.txt
index 29b3f9ffc66c..ce0666e51036 100644
--- a/Documentation/cpu-freq/core.txt
+++ b/Documentation/cpu-freq/core.txt
@@ -24,7 +24,7 @@ Contents:
 1. General Information
 =======================
 
-The CPUFreq core code is located in linux/kernel/cpufreq.c. This
+The CPUFreq core code is located in drivers/cpufreq/cpufreq.c. This
 cpufreq code offers a standardized interface for the CPUFreq
 architecture drivers (those pieces of code that do actual
 frequency transitions), as well as to "notifiers". These are device
diff --git a/Documentation/feature-removal-schedule.txt b/Documentation/feature-removal-schedule.txt
index 031029e89fd9..64ce44da5936 100644
--- a/Documentation/feature-removal-schedule.txt
+++ b/Documentation/feature-removal-schedule.txt
@@ -259,3 +259,25 @@ Why:	The new layer 3 independant connection tracking replaces the old
 Who:    Patrick McHardy <kaber@trash.net>
 
 ---------------------------
+
+What:   ACPI hooks (X86_SPEEDSTEP_CENTRINO_ACPI) in speedstep-centrino driver
+When:   December 2006
+Why:    Speedstep-centrino driver with ACPI hooks and acpi-cpufreq driver are
+        functionally very much similar. They talk to ACPI in same way. Only
+        difference between them is the way they do frequency transitions.
+        One uses MSRs and the other one uses IO ports. Functionaliy of
+        speedstep_centrino with ACPI hooks is now merged into acpi-cpufreq.
+        That means one common driver will support all Intel Enhanced Speedstep
+        capable CPUs. That means less confusion over name of
+        speedstep-centrino driver (with that driver supposed to be used on
+        non-centrino platforms). That means less duplication of code and
+        less maintenance effort and no possibility of these two drivers
+        going out of sync.
+        Current users of speedstep_centrino with ACPI hooks are requested to
+        switch over to acpi-cpufreq driver. speedstep-centrino will continue
+        to work using older non-ACPI static table based scheme even after this
+        date.
+
+Who:    Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
+
+---------------------------
diff --git a/Documentation/kbuild/kconfig-language.txt b/Documentation/kbuild/kconfig-language.txt
index 125093c3ef76..536d5bfbdb8d 100644
--- a/Documentation/kbuild/kconfig-language.txt
+++ b/Documentation/kbuild/kconfig-language.txt
@@ -29,7 +29,7 @@ them. A single configuration option is defined like this:
 
 config MODVERSIONS
         bool "Set version information on all module symbols"
-        depends MODULES
+        depends on MODULES
         help
           Usually, modules have to be recompiled whenever you switch to a new
           kernel.  ...
@@ -163,7 +163,7 @@ The position of a menu entry in the tree is determined in two ways. First
 it can be specified explicitly:
 
 menu "Network device support"
-        depends NET
+        depends on NET
 
 config NETDEVICES
         ...
@@ -188,10 +188,10 @@ config MODULES
 
 config MODVERSIONS
         bool "Set version information on all module symbols"
-        depends MODULES
+        depends on MODULES
 
 comment "module support disabled"
-        depends !MODULES
+        depends on !MODULES
 
 MODVERSIONS directly depends on MODULES, this means it's only visible if
 MODULES is different from 'n'. The comment on the other hand is always
diff --git a/MAINTAINERS b/MAINTAINERS
index b2024938adcf..8a0bfeca55c9 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -740,7 +740,7 @@ P:	Dave Jones
 M:      davej@codemonkey.org.uk
 L:      cpufreq@lists.linux.org.uk
 W:      http://www.codemonkey.org.uk/projects/cpufreq/
-T:      git kernel.org/pub/scm/linux/kernel/davej/cpufreq.git
+T:      git kernel.org/pub/scm/linux/kernel/git/davej/cpufreq.git
 S:      Maintained
 
 CPUID/MSR DRIVER
@@ -1504,8 +1504,10 @@ T:	git kernel.org:/pub/scm/linux/kernel/git/dtor/input.git
 S:      Maintained
 
 INOTIFY
-P:      John McCutchan and Robert Love
-M:      ttb@tentacle.dhs.org and rml@novell.com
+P:      John McCutchan
+M:      ttb@tentacle.dhs.org
+P:      Robert Love
+M:      rml@novell.com
 L:      linux-kernel@vger.kernel.org
 S:      Maintained
 
diff --git a/Makefile b/Makefile
index 73e825b39a08..4eabaa8afbff 100644
--- a/Makefile
+++ b/Makefile
@@ -1100,9 +1100,9 @@ boards := $(notdir $(boards))
 
 help:
         @echo  'Cleaning targets:'
-        @echo  '  clean           - remove most generated files but keep the config and'
+        @echo  '  clean           - Remove most generated files but keep the config and'
         @echo  '                    enough build support to build external modules'
-        @echo  '  mrproper        - remove all generated files + config + various backup files'
+        @echo  '  mrproper        - Remove all generated files + config + various backup files'
         @echo  '  distclean       - mrproper + remove editor backup and patch files'
         @echo  ''
         @echo  'Configuration targets:'
diff --git a/arch/arm/mach-pxa/Kconfig b/arch/arm/mach-pxa/Kconfig
index 9e3d0bdcba07..5c0a10041cd1 100644
--- a/arch/arm/mach-pxa/Kconfig
+++ b/arch/arm/mach-pxa/Kconfig
@@ -75,28 +75,28 @@ endmenu
 
 config MACH_POODLE
         bool "Enable Sharp SL-5600 (Poodle) Support"
-        depends PXA_SHARPSL_25x
+        depends on PXA_SHARPSL_25x
         select SHARP_LOCOMO
         select PXA_SSP
 
 config MACH_CORGI
         bool "Enable Sharp SL-C700 (Corgi) Support"
-        depends PXA_SHARPSL_25x
+        depends on PXA_SHARPSL_25x
         select PXA_SHARP_C7xx
 
 config MACH_SHEPHERD
         bool "Enable Sharp SL-C750 (Shepherd) Support"
-        depends PXA_SHARPSL_25x
+        depends on PXA_SHARPSL_25x
         select PXA_SHARP_C7xx
 
 config MACH_HUSKY
         bool "Enable Sharp SL-C760 (Husky) Support"
-        depends PXA_SHARPSL_25x
+        depends on PXA_SHARPSL_25x
         select PXA_SHARP_C7xx
 
 config MACH_AKITA
         bool "Enable Sharp SL-1000 (Akita) Support"
-        depends PXA_SHARPSL_27x
+        depends on PXA_SHARPSL_27x
         select PXA_SHARP_Cxx00
         select MACH_SPITZ
         select I2C
@@ -104,17 +104,17 @@ config MACH_AKITA
 
 config MACH_SPITZ
         bool "Enable Sharp Zaurus SL-3000 (Spitz) Support"
-        depends PXA_SHARPSL_27x
+        depends on PXA_SHARPSL_27x
         select PXA_SHARP_Cxx00
 
 config MACH_BORZOI
         bool "Enable Sharp Zaurus SL-3100 (Borzoi) Support"
-        depends PXA_SHARPSL_27x
+        depends on PXA_SHARPSL_27x
         select PXA_SHARP_Cxx00
 
 config MACH_TOSA
         bool "Enable Sharp SL-6000x (Tosa) Support"
-        depends PXA_SHARPSL_25x
+        depends on PXA_SHARPSL_25x
 
 config PXA25x
         bool
diff --git a/arch/arm/plat-omap/Kconfig b/arch/arm/plat-omap/Kconfig
index ec752e16d618..f2dc363de66b 100644
--- a/arch/arm/plat-omap/Kconfig
+++ b/arch/arm/plat-omap/Kconfig
@@ -113,7 +113,7 @@ endchoice
 
 config OMAP_SERIAL_WAKE
         bool "Enable wake-up events for serial ports"
-        depends OMAP_MUX
+        depends on OMAP_MUX
         default y
         help
           Select this option if you want to have your system wake up
diff --git a/arch/i386/kernel/cpu/cpufreq/Kconfig b/arch/i386/kernel/cpu/cpufreq/Kconfig
index ccc1edff5c97..5299c5bf4454 100644
--- a/arch/i386/kernel/cpu/cpufreq/Kconfig
+++ b/arch/i386/kernel/cpu/cpufreq/Kconfig
@@ -17,6 +17,7 @@ config X86_ACPI_CPUFREQ
         help
           This driver adds a CPUFreq driver which utilizes the ACPI
           Processor Performance States.
+          This driver also supports Intel Enhanced Speedstep.
 
           For details, take a look at <file:Documentation/cpu-freq/>.
 
@@ -121,11 +122,14 @@ config X86_SPEEDSTEP_CENTRINO
           If in doubt, say N.
 
 config X86_SPEEDSTEP_CENTRINO_ACPI
-        bool "Use ACPI tables to decode valid frequency/voltage pairs"
+        bool "Use ACPI tables to decode valid frequency/voltage (deprecated)"
         depends on X86_SPEEDSTEP_CENTRINO && ACPI_PROCESSOR
         depends on !(X86_SPEEDSTEP_CENTRINO = y && ACPI_PROCESSOR = m)
         default y
         help
+          This is deprecated and this functionality is now merged into
+          acpi_cpufreq (X86_ACPI_CPUFREQ). Use that driver instead of
+          speedstep_centrino.
           Use primarily the information provided in the BIOS ACPI tables
           to determine valid CPU frequency and voltage pairings. It is
           required for the driver to work on non-Banias CPUs.
diff --git a/arch/i386/kernel/cpu/cpufreq/Makefile b/arch/i386/kernel/cpu/cpufreq/Makefile
index 2e894f1c8910..8de3abe322a9 100644
--- a/arch/i386/kernel/cpu/cpufreq/Makefile
+++ b/arch/i386/kernel/cpu/cpufreq/Makefile
@@ -7,9 +7,9 @@ obj-$(CONFIG_SC520_CPUFREQ)		+= sc520_freq.o
 obj-$(CONFIG_X86_LONGRUN)               += longrun.o  
 obj-$(CONFIG_X86_GX_SUSPMOD)            += gx-suspmod.o
 obj-$(CONFIG_X86_SPEEDSTEP_ICH)         += speedstep-ich.o
-obj-$(CONFIG_X86_SPEEDSTEP_CENTRINO)    += speedstep-centrino.o
 obj-$(CONFIG_X86_SPEEDSTEP_LIB)         += speedstep-lib.o
 obj-$(CONFIG_X86_SPEEDSTEP_SMI)         += speedstep-smi.o
 obj-$(CONFIG_X86_ACPI_CPUFREQ)          += acpi-cpufreq.o
+obj-$(CONFIG_X86_SPEEDSTEP_CENTRINO)    += speedstep-centrino.o
 obj-$(CONFIG_X86_P4_CLOCKMOD)           += p4-clockmod.o
 obj-$(CONFIG_X86_CPUFREQ_NFORCE2)       += cpufreq-nforce2.o
diff --git a/arch/i386/kernel/cpu/cpufreq/acpi-cpufreq.c b/arch/i386/kernel/cpu/cpufreq/acpi-cpufreq.c
index 57c880bf0bd6..18f4715c655d 100644
--- a/arch/i386/kernel/cpu/cpufreq/acpi-cpufreq.c
+++ b/arch/i386/kernel/cpu/cpufreq/acpi-cpufreq.c
@@ -1,9 +1,10 @@
 /*
- * acpi-cpufreq.c - ACPI Processor P-States Driver ($Revision: 1.3 $)
+ * acpi-cpufreq.c - ACPI Processor P-States Driver ($Revision: 1.4 $)
  *
  *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
  *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
  *  Copyright (C) 2002 - 2004 Dominik Brodowski <linux@brodo.de>
+ *  Copyright (C) 2006       Denis Sadykov <denis.m.sadykov@intel.com>
  *
  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  *
@@ -27,202 +28,387 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/init.h>
+#include <linux/smp.h>
+#include <linux/sched.h>
 #include <linux/cpufreq.h>
-#include <linux/proc_fs.h>
-#include <linux/seq_file.h>
 #include <linux/compiler.h>
-#include <linux/sched.h>        /* current */
 #include <linux/dmi.h>
-#include <asm/io.h>
-#include <asm/delay.h>
-#include <asm/uaccess.h>
 
 #include <linux/acpi.h>
 #include <acpi/processor.h>
 
+#include <asm/io.h>
+#include <asm/msr.h>
+#include <asm/processor.h>
+#include <asm/cpufeature.h>
+#include <asm/delay.h>
+#include <asm/uaccess.h>
+
 #define dprintk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_DRIVER, "acpi-cpufreq", msg)
 
 MODULE_AUTHOR("Paul Diefenbaugh, Dominik Brodowski");
 MODULE_DESCRIPTION("ACPI Processor P-States Driver");
 MODULE_LICENSE("GPL");
 
+enum {
+        UNDEFINED_CAPABLE = 0,
+        SYSTEM_INTEL_MSR_CAPABLE,
+        SYSTEM_IO_CAPABLE,
+};
+
+#define INTEL_MSR_RANGE         (0xffff)
+#define CPUID_6_ECX_APERFMPERF_CAPABILITY       (0x1)
 
-struct cpufreq_acpi_io {
-        struct acpi_processor_performance       *acpi_data;
-        struct cpufreq_frequency_table          *freq_table;
-        unsigned int                            resume;
+struct acpi_cpufreq_data {
+        struct acpi_processor_performance *acpi_data;
+        struct cpufreq_frequency_table *freq_table;
+        unsigned int max_freq;
+        unsigned int resume;
+        unsigned int cpu_feature;
 };
 
-static struct cpufreq_acpi_io   *acpi_io_data[NR_CPUS];
-static struct acpi_processor_performance        *acpi_perf_data[NR_CPUS];
+static struct acpi_cpufreq_data *drv_data[NR_CPUS];
+static struct acpi_processor_performance *acpi_perf_data[NR_CPUS];
 
 static struct cpufreq_driver acpi_cpufreq_driver;
 
 static unsigned int acpi_pstate_strict;
 
-static int
-acpi_processor_write_port(
-        u16     port,
-        u8      bit_width,
-        u32     value)
+static int check_est_cpu(unsigned int cpuid)
+{
+        struct cpuinfo_x86 *cpu = &cpu_data[cpuid];
+
+        if (cpu->x86_vendor != X86_VENDOR_INTEL ||
+            !cpu_has(cpu, X86_FEATURE_EST))
+                return 0;
+
+        return 1;
+}
+
+static unsigned extract_io(u32 value, struct acpi_cpufreq_data *data)
+{
+        struct acpi_processor_performance *perf;
+        int i;
+
+        perf = data->acpi_data;
+
+        for (i=0; i<perf->state_count; i++) {
+                if (value == perf->states[i].status)
+                        return data->freq_table[i].frequency;
+        }
+        return 0;
+}
+
+static unsigned extract_msr(u32 msr, struct acpi_cpufreq_data *data)
 {
-        if (bit_width <= 8) {
+        int i;
+        struct acpi_processor_performance *perf;
+
+        msr &= INTEL_MSR_RANGE;
+        perf = data->acpi_data;
+
+        for (i=0; data->freq_table[i].frequency != CPUFREQ_TABLE_END; i++) {
+                if (msr == perf->states[data->freq_table[i].index].status)
+                        return data->freq_table[i].frequency;
+        }
+        return data->freq_table[0].frequency;
+}
+
+static unsigned extract_freq(u32 val, struct acpi_cpufreq_data *data)
+{
+        switch (data->cpu_feature) {
+        case SYSTEM_INTEL_MSR_CAPABLE:
+                return extract_msr(val, data);
+        case SYSTEM_IO_CAPABLE:
+                return extract_io(val, data);
+        default:
+                return 0;
+        }
+}
+
+static void wrport(u16 port, u8 bit_width, u32 value)
+{
+        if (bit_width <= 8)
                 outb(value, port);
-        } else if (bit_width <= 16) {
+        else if (bit_width <= 16)
                 outw(value, port);
-        } else if (bit_width <= 32) {
+        else if (bit_width <= 32)
                 outl(value, port);
-        } else {
-                return -ENODEV;
-        }
-        return 0;
 }
 
-static int
-acpi_processor_read_port(
-        u16     port,
-        u8      bit_width,
-        u32     *ret)
+static void rdport(u16 port, u8 bit_width, u32 * ret)
 {
         *ret = 0;
-        if (bit_width <= 8) {
+        if (bit_width <= 8)
                 *ret = inb(port);
-        } else if (bit_width <= 16) {
+        else if (bit_width <= 16)
                 *ret = inw(port);
-        } else if (bit_width <= 32) {
+        else if (bit_width <= 32)
                 *ret = inl(port);
-        } else {
-                return -ENODEV;
+}
+
+struct msr_addr {
+        u32 reg;
+};
+
+struct io_addr {
+        u16 port;
+        u8 bit_width;
+};
+
+typedef union {
+        struct msr_addr msr;
+        struct io_addr io;
+} drv_addr_union;
+
+struct drv_cmd {
+        unsigned int type;
+        cpumask_t mask;
+        drv_addr_union addr;
+        u32 val;
+};
+
+static void do_drv_read(struct drv_cmd *cmd)
+{
+        u32 h;
+
+        switch (cmd->type) {
+        case SYSTEM_INTEL_MSR_CAPABLE:
+                rdmsr(cmd->addr.msr.reg, cmd->val, h);
+                break;
+        case SYSTEM_IO_CAPABLE:
+                rdport(cmd->addr.io.port, cmd->addr.io.bit_width, &cmd->val);
+                break;
+        default:
+                break;
         }
-        return 0;
 }
 
-static int
-acpi_processor_set_performance (
-        struct cpufreq_acpi_io  *data,
-        unsigned int            cpu,
-        int                     state)
+static void do_drv_write(struct drv_cmd *cmd)
 {
-        u16                     port = 0;
-        u8                      bit_width = 0;
-        int                     i = 0;
-        int                     ret = 0;
-        u32                     value = 0;
-        int                     retval;
-        struct acpi_processor_performance       *perf;
-
-        dprintk("acpi_processor_set_performance\n");
-
-        retval = 0;
-        perf = data->acpi_data; 
-        if (state == perf->state) {
-                if (unlikely(data->resume)) {
-                        dprintk("Called after resume, resetting to P%d\n", state);
-                        data->resume = 0;
-                } else {
-                        dprintk("Already at target state (P%d)\n", state);
-                        return (retval);
-                }
+        u32 h = 0;
+
+        switch (cmd->type) {
+        case SYSTEM_INTEL_MSR_CAPABLE:
+                wrmsr(cmd->addr.msr.reg, cmd->val, h);
+                break;
+        case SYSTEM_IO_CAPABLE:
+                wrport(cmd->addr.io.port, cmd->addr.io.bit_width, cmd->val);
+                break;
+        default:
+                break;
         }
+}
 
-        dprintk("Transitioning from P%d to P%d\n", perf->state, state);
+static void drv_read(struct drv_cmd *cmd)
+{
+        cpumask_t saved_mask = current->cpus_allowed;
+        cmd->val = 0;
 
-        /*
-         * First we write the target state's 'control' value to the
-         * control_register.
-         */
+        set_cpus_allowed(current, cmd->mask);
+        do_drv_read(cmd);
+        set_cpus_allowed(current, saved_mask);
+}
+
+static void drv_write(struct drv_cmd *cmd)
+{
+        cpumask_t saved_mask = current->cpus_allowed;
+        unsigned int i;
+
+        for_each_cpu_mask(i, cmd->mask) {
+                set_cpus_allowed(current, cpumask_of_cpu(i));
+                do_drv_write(cmd);
+        }
+
+        set_cpus_allowed(current, saved_mask);
+        return;
+}
+
+static u32 get_cur_val(cpumask_t mask)
+{
+        struct acpi_processor_performance *perf;
+        struct drv_cmd cmd;
+
+        if (unlikely(cpus_empty(mask)))
+                return 0;
+
+        switch (drv_data[first_cpu(mask)]->cpu_feature) {
+        case SYSTEM_INTEL_MSR_CAPABLE:
+                cmd.type = SYSTEM_INTEL_MSR_CAPABLE;
+                cmd.addr.msr.reg = MSR_IA32_PERF_STATUS;
+                break;
+        case SYSTEM_IO_CAPABLE:
+                cmd.type = SYSTEM_IO_CAPABLE;
+                perf = drv_data[first_cpu(mask)]->acpi_data;
+                cmd.addr.io.port = perf->control_register.address;
+                cmd.addr.io.bit_width = perf->control_register.bit_width;
+                break;
+        default:
+                return 0;
+        }
+
+        cmd.mask = mask;
 
-        port = perf->control_register.address;
-        bit_width = perf->control_register.bit_width;
-        value = (u32) perf->states[state].control;
+        drv_read(&cmd);
 
-        dprintk("Writing 0x%08x to port 0x%04x\n", value, port);
+        dprintk("get_cur_val = %u\n", cmd.val);
 
-        ret = acpi_processor_write_port(port, bit_width, value);
-        if (ret) {
-                dprintk("Invalid port width 0x%04x\n", bit_width);
-                return (ret);
+        return cmd.val;
+}
+
+/*
+ * Return the measured active (C0) frequency on this CPU since last call
+ * to this function.
+ * Input: cpu number
+ * Return: Average CPU frequency in terms of max frequency (zero on error)
+ *
+ * We use IA32_MPERF and IA32_APERF MSRs to get the measured performance
+ * over a period of time, while CPU is in C0 state.
+ * IA32_MPERF counts at the rate of max advertised frequency
+ * IA32_APERF counts at the rate of actual CPU frequency
+ * Only IA32_APERF/IA32_MPERF ratio is architecturally defined and
+ * no meaning should be associated with absolute values of these MSRs.
+ */
+static unsigned int get_measured_perf(unsigned int cpu)
+{
+        union {
+                struct {
+                        u32 lo;
+                        u32 hi;
+                } split;
+                u64 whole;
+        } aperf_cur, mperf_cur;
+
+        cpumask_t saved_mask;
+        unsigned int perf_percent;
+        unsigned int retval;
+
+        saved_mask = current->cpus_allowed;
+        set_cpus_allowed(current, cpumask_of_cpu(cpu));
+        if (get_cpu() != cpu) {
+                /* We were not able to run on requested processor */
+                put_cpu();
+                return 0;
         }
 
+        rdmsr(MSR_IA32_APERF, aperf_cur.split.lo, aperf_cur.split.hi);
+        rdmsr(MSR_IA32_MPERF, mperf_cur.split.lo, mperf_cur.split.hi);
+
+        wrmsr(MSR_IA32_APERF, 0,0);
+        wrmsr(MSR_IA32_MPERF, 0,0);
+
+#ifdef __i386__
         /*
-         * Assume the write went through when acpi_pstate_strict is not used.
-         * As read status_register is an expensive operation and there 
-         * are no specific error cases where an IO port write will fail.
+         * We dont want to do 64 bit divide with 32 bit kernel
+         * Get an approximate value. Return failure in case we cannot get
+         * an approximate value.
          */
-        if (acpi_pstate_strict) {
-                /* Then we read the 'status_register' and compare the value 
-                 * with the target state's 'status' to make sure the 
-                 * transition was successful.
-                 * Note that we'll poll for up to 1ms (100 cycles of 10us) 
-                 * before giving up.
-                 */
-
-                port = perf->status_register.address;
-                bit_width = perf->status_register.bit_width;
-
-                dprintk("Looking for 0x%08x from port 0x%04x\n",
-                        (u32) perf->states[state].status, port);
-
-                for (i = 0; i < 100; i++) {
-                        ret = acpi_processor_read_port(port, bit_width, &value);
-                        if (ret) {      
-                                dprintk("Invalid port width 0x%04x\n", bit_width);
-                                return (ret);
-                        }
-                        if (value == (u32) perf->states[state].status)
-                                break;
-                        udelay(10);
-                }
-        } else {
-                value = (u32) perf->states[state].status;
+        if (unlikely(aperf_cur.split.hi || mperf_cur.split.hi)) {
+                int shift_count;
+                u32 h;
+
+                h = max_t(u32, aperf_cur.split.hi, mperf_cur.split.hi);
+                shift_count = fls(h);
+
+                aperf_cur.whole >>= shift_count;
+                mperf_cur.whole >>= shift_count;
+        }
+
+        if (((unsigned long)(-1) / 100) < aperf_cur.split.lo) {
+                int shift_count = 7;
+                aperf_cur.split.lo >>= shift_count;
+                mperf_cur.split.lo >>= shift_count;
+        }
+
+        if (aperf_cur.split.lo && mperf_cur.split.lo)
+                perf_percent = (aperf_cur.split.lo * 100) / mperf_cur.split.lo;
+        else
+                perf_percent = 0;
+
+#else
+        if (unlikely(((unsigned long)(-1) / 100) < aperf_cur.whole)) {
+                int shift_count = 7;
+                aperf_cur.whole >>= shift_count;
+                mperf_cur.whole >>= shift_count;
         }
 
-        if (unlikely(value != (u32) perf->states[state].status)) {
-                printk(KERN_WARNING "acpi-cpufreq: Transition failed\n");
-                retval = -ENODEV;
-                return (retval);
+        if (aperf_cur.whole && mperf_cur.whole)
+                perf_percent = (aperf_cur.whole * 100) / mperf_cur.whole;
+        else
+                perf_percent = 0;
+
+#endif
+
+        retval = drv_data[cpu]->max_freq * perf_percent / 100;
+
+        put_cpu();
+        set_cpus_allowed(current, saved_mask);
+
+        dprintk("cpu %d: performance percent %d\n", cpu, perf_percent);
+        return retval;
+}
+
+static unsigned int get_cur_freq_on_cpu(unsigned int cpu)
+{
+        struct acpi_cpufreq_data *data = drv_data[cpu];
+        unsigned int freq;
+
+        dprintk("get_cur_freq_on_cpu (%d)\n", cpu);
+
+        if (unlikely(data == NULL ||
+                     data->acpi_data == NULL || data->freq_table == NULL)) {
+                return 0;
         }
 
-        dprintk("Transition successful after %d microseconds\n", i * 10);
+        freq = extract_freq(get_cur_val(cpumask_of_cpu(cpu)), data);
+        dprintk("cur freq = %u\n", freq);
 
-        perf->state = state;
-        return (retval);
+        return freq;
 }
 
+static unsigned int check_freqs(cpumask_t mask, unsigned int freq,
+                                struct acpi_cpufreq_data *data)
+{
+        unsigned int cur_freq;
+        unsigned int i;
+
+        for (i=0; i<100; i++) {
+                cur_freq = extract_freq(get_cur_val(mask), data);
+                if (cur_freq == freq)
+                        return 1;
+                udelay(10);
+        }
+        return 0;
+}
 
-static int
-acpi_cpufreq_target (
-        struct cpufreq_policy   *policy,
-        unsigned int target_freq,
-        unsigned int relation)
+static int acpi_cpufreq_target(struct cpufreq_policy *policy,
+                               unsigned int target_freq, unsigned int relation)
 {
-        struct cpufreq_acpi_io *data = acpi_io_data[policy->cpu];
+        struct acpi_cpufreq_data *data = drv_data[policy->cpu];
         struct acpi_processor_performance *perf;
         struct cpufreq_freqs freqs;
         cpumask_t online_policy_cpus;
-        cpumask_t saved_mask;
-        cpumask_t set_mask;
-        cpumask_t covered_cpus;
-        unsigned int cur_state = 0;
+        struct drv_cmd cmd;
+        unsigned int msr;
         unsigned int next_state = 0;
-        unsigned int result = 0;
-        unsigned int j;
-        unsigned int tmp;
+        unsigned int next_perf_state = 0;
+        unsigned int i;
+        int result = 0;
 
-        dprintk("acpi_cpufreq_setpolicy\n");
+        dprintk("acpi_cpufreq_target %d (%d)\n", target_freq, policy->cpu);
 
-        result = cpufreq_frequency_table_target(policy,
-                        data->freq_table,
-                        target_freq,
-                        relation,
-                        &next_state);
-        if (unlikely(result))
-                return (result);
+        if (unlikely(data == NULL ||
+             data->acpi_data == NULL || data->freq_table == NULL)) {
+                return -ENODEV;
+        }
 
         perf = data->acpi_data;
-        cur_state = perf->state;
-        freqs.old = data->freq_table[cur_state].frequency;
-        freqs.new = data->freq_table[next_state].frequency;
+        result = cpufreq_frequency_table_target(policy,
+                                                data->freq_table,
+                                                target_freq,
+                                                relation, &next_state);
+        if (unlikely(result))
+                return -ENODEV;
 
 #ifdef CONFIG_HOTPLUG_CPU
         /* cpufreq holds the hotplug lock, so we are safe from here on */
@@ -231,106 +417,84 @@ acpi_cpufreq_target (
         online_policy_cpus = policy->cpus;
 #endif
 
-        for_each_cpu_mask(j, online_policy_cpus) {
-                freqs.cpu = j;
-                cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
+        next_perf_state = data->freq_table[next_state].index;
+        if (perf->state == next_perf_state) {
+                if (unlikely(data->resume)) {
+                        dprintk("Called after resume, resetting to P%d\n",
+                                next_perf_state);
+                        data->resume = 0;
+                } else {
+                        dprintk("Already at target state (P%d)\n",
+                                next_perf_state);
+                        return 0;
+                }
         }
 
-        /*
-         * We need to call driver->target() on all or any CPU in
-         * policy->cpus, depending on policy->shared_type.
-         */
-        saved_mask = current->cpus_allowed;
-        cpus_clear(covered_cpus);
-        for_each_cpu_mask(j, online_policy_cpus) {
-                /*
-                 * Support for SMP systems.
-                 * Make sure we are running on CPU that wants to change freq
-                 */
-                cpus_clear(set_mask);
-                if (policy->shared_type == CPUFREQ_SHARED_TYPE_ANY)
-                        cpus_or(set_mask, set_mask, online_policy_cpus);
-                else
-                        cpu_set(j, set_mask);
-
-                set_cpus_allowed(current, set_mask);
-                if (unlikely(!cpu_isset(smp_processor_id(), set_mask))) {
-                        dprintk("couldn't limit to CPUs in this domain\n");
-                        result = -EAGAIN;
-                        break;
-                }
+        switch (data->cpu_feature) {
+        case SYSTEM_INTEL_MSR_CAPABLE:
+                cmd.type = SYSTEM_INTEL_MSR_CAPABLE;
+                cmd.addr.msr.reg = MSR_IA32_PERF_CTL;
+                msr =
+                    (u32) perf->states[next_perf_state].
+                    control & INTEL_MSR_RANGE;
+                cmd.val = (cmd.val & ~INTEL_MSR_RANGE) | msr;
+                break;
+        case SYSTEM_IO_CAPABLE:
+                cmd.type = SYSTEM_IO_CAPABLE;
+                cmd.addr.io.port = perf->control_register.address;
+                cmd.addr.io.bit_width = perf->control_register.bit_width;
+                cmd.val = (u32) perf->states[next_perf_state].control;
+                break;
+        default:
+                return -ENODEV;
+        }
 
-                result = acpi_processor_set_performance (data, j, next_state);
-                if (result) {
-                        result = -EAGAIN;
-                        break;
-                }
+        cpus_clear(cmd.mask);
 
-                if (policy->shared_type == CPUFREQ_SHARED_TYPE_ANY)
-                        break;
- 
-                cpu_set(j, covered_cpus);
-        }
+        if (policy->shared_type != CPUFREQ_SHARED_TYPE_ANY)
+                cmd.mask = online_policy_cpus;
+        else
+                cpu_set(policy->cpu, cmd.mask);
 
-        for_each_cpu_mask(j, online_policy_cpus) {
-                freqs.cpu = j;
-                cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
+        freqs.old = data->freq_table[perf->state].frequency;
+        freqs.new = data->freq_table[next_perf_state].frequency;
+        for_each_cpu_mask(i, cmd.mask) {
+                freqs.cpu = i;
+                cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
         }
 
-        if (unlikely(result)) {
-                /*
-                 * We have failed halfway through the frequency change.
-                 * We have sent callbacks to online_policy_cpus and
-                 * acpi_processor_set_performance() has been called on 
-                 * coverd_cpus. Best effort undo..
-                 */
-
-                if (!cpus_empty(covered_cpus)) {
-                        for_each_cpu_mask(j, covered_cpus) {
-                                policy->cpu = j;
-                                acpi_processor_set_performance (data, 
-                                                j, 
-                                                cur_state);
-                        }
-                }
+        drv_write(&cmd);
 
-                tmp = freqs.new;
-                freqs.new = freqs.old;
-                freqs.old = tmp;
-                for_each_cpu_mask(j, online_policy_cpus) {
-                        freqs.cpu = j;
-                        cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
-                        cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
+        if (acpi_pstate_strict) {
+                if (!check_freqs(cmd.mask, freqs.new, data)) {
+                        dprintk("acpi_cpufreq_target failed (%d)\n",
+                                policy->cpu);
+                        return -EAGAIN;
                 }
         }
 
-        set_cpus_allowed(current, saved_mask);
-        return (result);
-}
+        for_each_cpu_mask(i, cmd.mask) {
+                freqs.cpu = i;
+                cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
+        }
+        perf->state = next_perf_state;
 
+        return result;
+}
 
-static int
-acpi_cpufreq_verify (
-        struct cpufreq_policy   *policy)
+static int acpi_cpufreq_verify(struct cpufreq_policy *policy)
 {
-        unsigned int result = 0;
-        struct cpufreq_acpi_io *data = acpi_io_data[policy->cpu];
+        struct acpi_cpufreq_data *data = drv_data[policy->cpu];
 
         dprintk("acpi_cpufreq_verify\n");
 
-        result = cpufreq_frequency_table_verify(policy, 
-                        data->freq_table);
-
-        return (result);
+        return cpufreq_frequency_table_verify(policy, data->freq_table);
 }
 
-
 static unsigned long
-acpi_cpufreq_guess_freq (
-        struct cpufreq_acpi_io  *data,
-        unsigned int            cpu)
+acpi_cpufreq_guess_freq(struct acpi_cpufreq_data *data, unsigned int cpu)
 {
-        struct acpi_processor_performance       *perf = data->acpi_data;
+        struct acpi_processor_performance *perf = data->acpi_data;
 
         if (cpu_khz) {
                 /* search the closest match to cpu_khz */
@@ -338,16 +502,16 @@ acpi_cpufreq_guess_freq (
                 unsigned long freq;
                 unsigned long freqn = perf->states[0].core_frequency * 1000;
 
-                for (i = 0; i < (perf->state_count - 1); i++) {
+                for (i=0; i<(perf->state_count-1); i++) {
                         freq = freqn;
                         freqn = perf->states[i+1].core_frequency * 1000;
                         if ((2 * cpu_khz) > (freqn + freq)) {
                                 perf->state = i;
-                                return (freq);
+                                return freq;
                         }
                 }
-                perf->state = perf->state_count - 1;
-                return (freqn);
+                perf->state = perf->state_count-1;
+                return freqn;
         } else {
                 /* assume CPU is at P0... */
                 perf->state = 0;
@@ -355,7 +519,6 @@ acpi_cpufreq_guess_freq (
         }
 }
 
-
 /*
  * acpi_cpufreq_early_init - initialize ACPI P-States library
  *
@@ -364,30 +527,34 @@ acpi_cpufreq_guess_freq (
  * do _PDC and _PSD and find out the processor dependency for the
  * actual init that will happen later...
  */
-static int acpi_cpufreq_early_init_acpi(void)
+static int acpi_cpufreq_early_init(void)
 {
-        struct acpi_processor_performance       *data;
-        unsigned int                            i, j;
+        struct acpi_processor_performance *data;
+        cpumask_t covered;
+        unsigned int i, j;
 
         dprintk("acpi_cpufreq_early_init\n");
 
         for_each_possible_cpu(i) {
-                data = kzalloc(sizeof(struct acpi_processor_performance), 
-                        GFP_KERNEL);
+                data = kzalloc(sizeof(struct acpi_processor_performance),
+                               GFP_KERNEL);
                 if (!data) {
-                        for_each_possible_cpu(j) {
+                        for_each_cpu_mask(j, covered) {
                                 kfree(acpi_perf_data[j]);
                                 acpi_perf_data[j] = NULL;
                         }
-                        return (-ENOMEM);
+                        return -ENOMEM;
                 }
                 acpi_perf_data[i] = data;
+                cpu_set(i, covered);
         }
 
         /* Do initialization in ACPI core */
-        return acpi_processor_preregister_performance(acpi_perf_data);
+        acpi_processor_preregister_performance(acpi_perf_data);
+        return 0;
 }
 
+#ifdef CONFIG_SMP
 /*
  * Some BIOSes do SW_ANY coordination internally, either set it up in hw
  * or do it in BIOS firmware and won't inform about it to OS. If not
@@ -414,39 +581,42 @@ static struct dmi_system_id sw_any_bug_dmi_table[] = {
         },
         { }
 };
+#endif
 
-static int
-acpi_cpufreq_cpu_init (
-        struct cpufreq_policy   *policy)
+static int acpi_cpufreq_cpu_init(struct cpufreq_policy *policy)
 {
-        unsigned int            i;
-        unsigned int            cpu = policy->cpu;
-        struct cpufreq_acpi_io  *data;
-        unsigned int            result = 0;
+        unsigned int i;
+        unsigned int valid_states = 0;
+        unsigned int cpu = policy->cpu;
+        struct acpi_cpufreq_data *data;
+        unsigned int result = 0;
         struct cpuinfo_x86 *c = &cpu_data[policy->cpu];
-        struct acpi_processor_performance       *perf;
+        struct acpi_processor_performance *perf;
 
         dprintk("acpi_cpufreq_cpu_init\n");
 
         if (!acpi_perf_data[cpu])
-                return (-ENODEV);
+                return -ENODEV;
 
-        data = kzalloc(sizeof(struct cpufreq_acpi_io), GFP_KERNEL);
+        data = kzalloc(sizeof(struct acpi_cpufreq_data), GFP_KERNEL);
         if (!data)
-                return (-ENOMEM);
+                return -ENOMEM;
 
         data->acpi_data = acpi_perf_data[cpu];
-        acpi_io_data[cpu] = data;
+        drv_data[cpu] = data;
 
-        result = acpi_processor_register_performance(data->acpi_data, cpu);
+        if (cpu_has(c, X86_FEATURE_CONSTANT_TSC))
+                acpi_cpufreq_driver.flags |= CPUFREQ_CONST_LOOPS;
 
+        result = acpi_processor_register_performance(data->acpi_data, cpu);
         if (result)
                 goto err_free;
 
         perf = data->acpi_data;
         policy->shared_type = perf->shared_type;
+
         /*
-         * Will let policy->cpus know about dependency only when software 
+         * Will let policy->cpus know about dependency only when software
          * coordination is required.
          */
         if (policy->shared_type == CPUFREQ_SHARED_TYPE_ALL ||
@@ -462,10 +632,6 @@ acpi_cpufreq_cpu_init (
         }
 #endif
 
-        if (cpu_has(c, X86_FEATURE_CONSTANT_TSC)) {
-                acpi_cpufreq_driver.flags |= CPUFREQ_CONST_LOOPS;
-        }
-
         /* capability check */
         if (perf->state_count <= 1) {
                 dprintk("No P-States\n");
@@ -473,17 +639,33 @@ acpi_cpufreq_cpu_init (
                 goto err_unreg;
         }
 
-        if ((perf->control_register.space_id != ACPI_ADR_SPACE_SYSTEM_IO) ||
-            (perf->status_register.space_id != ACPI_ADR_SPACE_SYSTEM_IO)) {
-                dprintk("Unsupported address space [%d, %d]\n",
-                        (u32) (perf->control_register.space_id),
-                        (u32) (perf->status_register.space_id));
+        if (perf->control_register.space_id != perf->status_register.space_id) {
+                result = -ENODEV;
+                goto err_unreg;
+        }
+
+        switch (perf->control_register.space_id) {
+        case ACPI_ADR_SPACE_SYSTEM_IO:
+                dprintk("SYSTEM IO addr space\n");
+                data->cpu_feature = SYSTEM_IO_CAPABLE;
+                break;
+        case ACPI_ADR_SPACE_FIXED_HARDWARE:
+                dprintk("HARDWARE addr space\n");
+                if (!check_est_cpu(cpu)) {
+                        result = -ENODEV;
+                        goto err_unreg;
+                }
+                data->cpu_feature = SYSTEM_INTEL_MSR_CAPABLE;
+                break;
+        default:
+                dprintk("Unknown addr space %d\n",
+                        (u32) (perf->control_register.space_id));
                 result = -ENODEV;
                 goto err_unreg;
         }
 
-        /* alloc freq_table */
-        data->freq_table = kmalloc(sizeof(struct cpufreq_frequency_table) * (perf->state_count + 1), GFP_KERNEL);
+        data->freq_table = kmalloc(sizeof(struct cpufreq_frequency_table) *
+                    (perf->state_count+1), GFP_KERNEL);
         if (!data->freq_table) {
                 result = -ENOMEM;
                 goto err_unreg;
@@ -492,129 +674,140 @@ acpi_cpufreq_cpu_init (
         /* detect transition latency */
         policy->cpuinfo.transition_latency = 0;
         for (i=0; i<perf->state_count; i++) {
-                if ((perf->states[i].transition_latency * 1000) > policy->cpuinfo.transition_latency)
-                        policy->cpuinfo.transition_latency = perf->states[i].transition_latency * 1000;
+                if ((perf->states[i].transition_latency * 1000) >
+                    policy->cpuinfo.transition_latency)
+                        policy->cpuinfo.transition_latency =
+                            perf->states[i].transition_latency * 1000;
         }
         policy->governor = CPUFREQ_DEFAULT_GOVERNOR;
 
-        /* The current speed is unknown and not detectable by ACPI...  */
-        policy->cur = acpi_cpufreq_guess_freq(data, policy->cpu);
-
+        data->max_freq = perf->states[0].core_frequency * 1000;
         /* table init */
-        for (i=0; i<=perf->state_count; i++)
-        {
-                data->freq_table[i].index = i;
-                if (i<perf->state_count)
-                        data->freq_table[i].frequency = perf->states[i].core_frequency * 1000;
-                else
-                        data->freq_table[i].frequency = CPUFREQ_TABLE_END;
+        for (i=0; i<perf->state_count; i++) {
+                if (i>0 && perf->states[i].core_frequency ==
+                    perf->states[i-1].core_frequency)
+                        continue;
+
+                data->freq_table[valid_states].index = i;
+                data->freq_table[valid_states].frequency =
+                    perf->states[i].core_frequency * 1000;
+                valid_states++;
         }
+        data->freq_table[valid_states].frequency = CPUFREQ_TABLE_END;
 
         result = cpufreq_frequency_table_cpuinfo(policy, data->freq_table);
-        if (result) {
+        if (result)
                 goto err_freqfree;
+
+        switch (data->cpu_feature) {
+        case ACPI_ADR_SPACE_SYSTEM_IO:
+                /* Current speed is unknown and not detectable by IO port */
+                policy->cur = acpi_cpufreq_guess_freq(data, policy->cpu);
+                break;
+        case ACPI_ADR_SPACE_FIXED_HARDWARE:
+                acpi_cpufreq_driver.get = get_cur_freq_on_cpu;
+                get_cur_freq_on_cpu(cpu);
+                break;
+        default:
+                break;
         }
 
         /* notify BIOS that we exist */
         acpi_processor_notify_smm(THIS_MODULE);
 
-        printk(KERN_INFO "acpi-cpufreq: CPU%u - ACPI performance management activated.\n",
-               cpu);
+        /* Check for APERF/MPERF support in hardware */
+        if (c->x86_vendor == X86_VENDOR_INTEL && c->cpuid_level >= 6) {
+                unsigned int ecx;
+                ecx = cpuid_ecx(6);
+                if (ecx & CPUID_6_ECX_APERFMPERF_CAPABILITY)
+                        acpi_cpufreq_driver.getavg = get_measured_perf;
+        }
+
+        dprintk("CPU%u - ACPI performance management activated.\n", cpu);
         for (i = 0; i < perf->state_count; i++)
                 dprintk("     %cP%d: %d MHz, %d mW, %d uS\n",
-                        (i == perf->state?'*':' '), i,
+                        (i == perf->state ? '*' : ' '), i,
                         (u32) perf->states[i].core_frequency,
                         (u32) perf->states[i].power,
                         (u32) perf->states[i].transition_latency);
 
         cpufreq_frequency_table_get_attr(data->freq_table, policy->cpu);
-        
+
         /*
          * the first call to ->target() should result in us actually
          * writing something to the appropriate registers.
          */
         data->resume = 1;
-        
-        return (result);
 
- err_freqfree:
+        return result;
+
+err_freqfree:
         kfree(data->freq_table);
- err_unreg:
+err_unreg:
         acpi_processor_unregister_performance(perf, cpu);
- err_free:
+err_free:
         kfree(data);
-        acpi_io_data[cpu] = NULL;
+        drv_data[cpu] = NULL;
 
-        return (result);
+        return result;
 }
 
-
-static int
-acpi_cpufreq_cpu_exit (
-        struct cpufreq_policy   *policy)
+static int acpi_cpufreq_cpu_exit(struct cpufreq_policy *policy)
 {
-        struct cpufreq_acpi_io *data = acpi_io_data[policy->cpu];
-
+        struct acpi_cpufreq_data *data = drv_data[policy->cpu];
 
         dprintk("acpi_cpufreq_cpu_exit\n");
 
         if (data) {
                 cpufreq_frequency_table_put_attr(policy->cpu);
-                acpi_io_data[policy->cpu] = NULL;
-                acpi_processor_unregister_performance(data->acpi_data, policy->cpu);
+                drv_data[policy->cpu] = NULL;
+                acpi_processor_unregister_performance(data->acpi_data,
+                                                      policy->cpu);
                 kfree(data);
         }
 
-        return (0);
+        return 0;
 }
 
-static int
-acpi_cpufreq_resume (
-        struct cpufreq_policy   *policy)
+static int acpi_cpufreq_resume(struct cpufreq_policy *policy)
 {
-        struct cpufreq_acpi_io *data = acpi_io_data[policy->cpu];
-
+        struct acpi_cpufreq_data *data = drv_data[policy->cpu];
 
         dprintk("acpi_cpufreq_resume\n");
 
         data->resume = 1;
 
-        return (0);
+        return 0;
 }
 
-
-static struct freq_attr* acpi_cpufreq_attr[] = {
+static struct freq_attr *acpi_cpufreq_attr[] = {
         &cpufreq_freq_attr_scaling_available_freqs,
         NULL,
 };
 
 static struct cpufreq_driver acpi_cpufreq_driver = {
-        .verify = acpi_cpufreq_verify,
-        .target = acpi_cpufreq_target,
-        .init   = acpi_cpufreq_cpu_init,
-        .exit   = acpi_cpufreq_cpu_exit,
-        .resume = acpi_cpufreq_resume,
-        .name   = "acpi-cpufreq",
-        .owner  = THIS_MODULE,
-        .attr   = acpi_cpufreq_attr,
+        .verify = acpi_cpufreq_verify,
+        .target = acpi_cpufreq_target,
+        .init = acpi_cpufreq_cpu_init,
+        .exit = acpi_cpufreq_cpu_exit,
+        .resume = acpi_cpufreq_resume,
+        .name = "acpi-cpufreq",
+        .owner = THIS_MODULE,
+        .attr = acpi_cpufreq_attr,
 };
 
-
-static int __init
-acpi_cpufreq_init (void)
+static int __init acpi_cpufreq_init(void)
 {
         dprintk("acpi_cpufreq_init\n");
 
-        acpi_cpufreq_early_init_acpi();
+        acpi_cpufreq_early_init();
 
         return cpufreq_register_driver(&acpi_cpufreq_driver);
 }
 
-
-static void __exit
-acpi_cpufreq_exit (void)
+static void __exit acpi_cpufreq_exit(void)
 {
-        unsigned int    i;
+        unsigned int i;
         dprintk("acpi_cpufreq_exit\n");
 
         cpufreq_unregister_driver(&acpi_cpufreq_driver);
@@ -627,7 +820,9 @@ acpi_cpufreq_exit (void)
 }
 
 module_param(acpi_pstate_strict, uint, 0644);
-MODULE_PARM_DESC(acpi_pstate_strict, "value 0 or non-zero. non-zero -> strict ACPI checks are performed during frequency changes.");
+MODULE_PARM_DESC(acpi_pstate_strict,
+        "value 0 or non-zero. non-zero -> strict ACPI checks are "
+        "performed during frequency changes.");
 
 late_initcall(acpi_cpufreq_init);
 module_exit(acpi_cpufreq_exit);
diff --git a/arch/i386/kernel/cpu/cpufreq/gx-suspmod.c b/arch/i386/kernel/cpu/cpufreq/gx-suspmod.c
index 92afa3bc84f1..6667e9cceb9f 100644
--- a/arch/i386/kernel/cpu/cpufreq/gx-suspmod.c
+++ b/arch/i386/kernel/cpu/cpufreq/gx-suspmod.c
@@ -447,7 +447,6 @@ static int __init cpufreq_gx_init(void)
         int ret;
         struct gxfreq_params *params;
         struct pci_dev *gx_pci;
-        u32 class_rev;
 
         /* Test if we have the right hardware */
         if ((gx_pci = gx_detect_chipset()) == NULL)
@@ -472,8 +471,7 @@ static int __init cpufreq_gx_init(void)
         pci_read_config_byte(params->cs55x0, PCI_PMER2, &(params->pci_pmer2));
         pci_read_config_byte(params->cs55x0, PCI_MODON, &(params->on_duration));
         pci_read_config_byte(params->cs55x0, PCI_MODOFF, &(params->off_duration));
-        pci_read_config_dword(params->cs55x0, PCI_CLASS_REVISION, &class_rev);
-        params->pci_rev = class_rev && 0xff;
+        pci_read_config_byte(params->cs55x0, PCI_REVISION_ID, &params->pci_rev);
 
         if ((ret = cpufreq_register_driver(&gx_suspmod_driver))) {
                 kfree(params);
diff --git a/arch/i386/kernel/cpu/cpufreq/longhaul.c b/arch/i386/kernel/cpu/cpufreq/longhaul.c
index 7233abe5d695..c548daad3476 100644
--- a/arch/i386/kernel/cpu/cpufreq/longhaul.c
+++ b/arch/i386/kernel/cpu/cpufreq/longhaul.c
@@ -410,7 +410,7 @@ static int __init longhaul_get_ranges(void)
                         maxmult=longhaul_get_cpu_mult();
 
                         /* Starting with the 1.2GHz parts, theres a 200MHz bus. */
-                        if ((cpu_khz/1000) > 1200)
+                        if ((cpu_khz/maxmult) > 13400)
                                 fsb = 200;
                         else
                                 fsb = eblcr_fsb_table_v2[longhaul.bits.MaxMHzFSB];
@@ -583,6 +583,10 @@ static int enable_arbiter_disable(void)
         if (dev == NULL) {
                 reg = 0x76;
                 dev = pci_find_device(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_862X_0, NULL);
+                /* Find CN400 V-Link host bridge */
+                if (dev == NULL)
+                        dev = pci_find_device(PCI_VENDOR_ID_VIA, 0x7259, NULL);
+
         }
         if (dev != NULL) {
                 /* Enable access to port 0x22 */
@@ -734,7 +738,7 @@ print_support_type:
         return 0;
 
 err_acpi:
-        printk(KERN_ERR PFX "No ACPI support. No VT8601 or VT8623 northbridge. Aborting.\n");
+        printk(KERN_ERR PFX "No ACPI support. Unsupported northbridge. Aborting.\n");
         return -ENODEV;
 }
 
diff --git a/arch/i386/kernel/cpu/cpufreq/p4-clockmod.c b/arch/i386/kernel/cpu/cpufreq/p4-clockmod.c
index 304d2eaa4a1b..bec50170b75a 100644
--- a/arch/i386/kernel/cpu/cpufreq/p4-clockmod.c
+++ b/arch/i386/kernel/cpu/cpufreq/p4-clockmod.c
@@ -163,29 +163,27 @@ static int cpufreq_p4_verify(struct cpufreq_policy *policy)
 
 static unsigned int cpufreq_p4_get_frequency(struct cpuinfo_x86 *c)
 {
-        if ((c->x86 == 0x06) && (c->x86_model == 0x09)) {
-                /* Pentium M (Banias) */
-                printk(KERN_WARNING PFX "Warning: Pentium M detected. "
-                       "The speedstep_centrino module offers voltage scaling"
-                       " in addition of frequency scaling. You should use "
-                       "that instead of p4-clockmod, if possible.\n");
-                return speedstep_get_processor_frequency(SPEEDSTEP_PROCESSOR_PM);
-        }
-
-        if ((c->x86 == 0x06) && (c->x86_model == 0x0D)) {
-                /* Pentium M (Dothan) */
-                printk(KERN_WARNING PFX "Warning: Pentium M detected. "
-                       "The speedstep_centrino module offers voltage scaling"
-                       " in addition of frequency scaling. You should use "
-                       "that instead of p4-clockmod, if possible.\n");
-                /* on P-4s, the TSC runs with constant frequency independent whether
-                 * throttling is active or not. */
-                p4clockmod_driver.flags |= CPUFREQ_CONST_LOOPS;
-                return speedstep_get_processor_frequency(SPEEDSTEP_PROCESSOR_PM);
+        if (c->x86 == 0x06) {
+                if (cpu_has(c, X86_FEATURE_EST))
+                        printk(KERN_WARNING PFX "Warning: EST-capable CPU detected. "
+                               "The acpi-cpufreq module offers voltage scaling"
+                               " in addition of frequency scaling. You should use "
+                               "that instead of p4-clockmod, if possible.\n");
+                switch (c->x86_model) {
+                case 0x0E: /* Core */
+                case 0x0F: /* Core Duo */
+                        p4clockmod_driver.flags |= CPUFREQ_CONST_LOOPS;
+                        return speedstep_get_processor_frequency(SPEEDSTEP_PROCESSOR_PCORE);
+                case 0x0D: /* Pentium M (Dothan) */
+                        p4clockmod_driver.flags |= CPUFREQ_CONST_LOOPS;
+                        /* fall through */
+                case 0x09: /* Pentium M (Banias) */
+                        return speedstep_get_processor_frequency(SPEEDSTEP_PROCESSOR_PM);
+                }
         }
 
         if (c->x86 != 0xF) {
-                printk(KERN_WARNING PFX "Unknown p4-clockmod-capable CPU. Please send an e-mail to <linux@brodo.de>\n");
+                printk(KERN_WARNING PFX "Unknown p4-clockmod-capable CPU. Please send an e-mail to <cpufreq@lists.linux.org.uk>\n");
                 return 0;
         }
 
diff --git a/arch/i386/kernel/cpu/cpufreq/sc520_freq.c b/arch/i386/kernel/cpu/cpufreq/sc520_freq.c
index ef457d50f4ac..b8fb4b521c62 100644
--- a/arch/i386/kernel/cpu/cpufreq/sc520_freq.c
+++ b/arch/i386/kernel/cpu/cpufreq/sc520_freq.c
@@ -153,6 +153,7 @@ static struct cpufreq_driver sc520_freq_driver = {
 static int __init sc520_freq_init(void)
 {
         struct cpuinfo_x86 *c = cpu_data;
+        int err;
 
         /* Test if we have the right hardware */
         if(c->x86_vendor != X86_VENDOR_AMD ||
@@ -166,7 +167,11 @@ static int __init sc520_freq_init(void)
                 return -ENOMEM;
         }
 
-        return cpufreq_register_driver(&sc520_freq_driver);
+        err = cpufreq_register_driver(&sc520_freq_driver);
+        if (err)
+                iounmap(cpuctl);
+
+        return err;
 }
 
 
diff --git a/arch/i386/kernel/cpu/cpufreq/speedstep-centrino.c b/arch/i386/kernel/cpu/cpufreq/speedstep-centrino.c
index e8993baf3d14..5113e9231634 100644
--- a/arch/i386/kernel/cpu/cpufreq/speedstep-centrino.c
+++ b/arch/i386/kernel/cpu/cpufreq/speedstep-centrino.c
@@ -36,6 +36,7 @@
 
 #define dprintk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_DRIVER, "speedstep-centrino", msg)
 
+#define INTEL_MSR_RANGE (0xffff)
 
 struct cpu_id
 {
@@ -379,6 +380,7 @@ static int centrino_cpu_early_init_acpi(void)
 }
 
 
+#ifdef CONFIG_SMP
 /*
  * Some BIOSes do SW_ANY coordination internally, either set it up in hw
  * or do it in BIOS firmware and won't inform about it to OS. If not
@@ -392,7 +394,6 @@ static int sw_any_bug_found(struct dmi_system_id *d)
         return 0;
 }
 
-
 static struct dmi_system_id sw_any_bug_dmi_table[] = {
         {
                 .callback = sw_any_bug_found,
@@ -405,7 +406,7 @@ static struct dmi_system_id sw_any_bug_dmi_table[] = {
         },
         { }
 };
-
+#endif
 
 /*
  * centrino_cpu_init_acpi - register with ACPI P-States library
@@ -463,8 +464,9 @@ static int centrino_cpu_init_acpi(struct cpufreq_policy *policy)
         }
 
         for (i=0; i<p->state_count; i++) {
-                if (p->states[i].control != p->states[i].status) {
-                        dprintk("Different control (%llu) and status values (%llu)\n",
+                if ((p->states[i].control & INTEL_MSR_RANGE) !=
+                    (p->states[i].status & INTEL_MSR_RANGE)) {
+                        dprintk("Different MSR bits in control (%llu) and status (%llu)\n",
                                 p->states[i].control, p->states[i].status);
                         result = -EINVAL;
                         goto err_unreg;
@@ -500,7 +502,7 @@ static int centrino_cpu_init_acpi(struct cpufreq_policy *policy)
         }
 
         for (i=0; i<p->state_count; i++) {
-                centrino_model[cpu]->op_points[i].index = p->states[i].control;
+                centrino_model[cpu]->op_points[i].index = p->states[i].control & INTEL_MSR_RANGE;
                 centrino_model[cpu]->op_points[i].frequency = p->states[i].core_frequency * 1000;
                 dprintk("adding state %i with frequency %u and control value %04x\n", 
                         i, centrino_model[cpu]->op_points[i].frequency, centrino_model[cpu]->op_points[i].index);
@@ -531,6 +533,9 @@ static int centrino_cpu_init_acpi(struct cpufreq_policy *policy)
 
         /* notify BIOS that we exist */
         acpi_processor_notify_smm(THIS_MODULE);
+        printk("speedstep-centrino with X86_SPEEDSTEP_CENTRINO_ACPI"
+                        "config is deprecated.\n "
+                        "Use X86_ACPI_CPUFREQ (acpi-cpufreq instead.\n" );
 
         return 0;
 
diff --git a/arch/i386/kernel/cpu/cpufreq/speedstep-lib.c b/arch/i386/kernel/cpu/cpufreq/speedstep-lib.c
index 4f46cac155c4..d59277c00911 100644
--- a/arch/i386/kernel/cpu/cpufreq/speedstep-lib.c
+++ b/arch/i386/kernel/cpu/cpufreq/speedstep-lib.c
@@ -123,6 +123,36 @@ static unsigned int pentiumM_get_frequency(void)
         return (msr_tmp * 100 * 1000);
 }
 
+static unsigned int pentium_core_get_frequency(void)
+{
+        u32 fsb = 0;
+        u32 msr_lo, msr_tmp;
+
+        rdmsr(MSR_FSB_FREQ, msr_lo, msr_tmp);
+        /* see table B-2 of 25366920.pdf */
+        switch (msr_lo & 0x07) {
+        case 5:
+                fsb = 100000;
+                break;
+        case 1:
+                fsb = 133333;
+                break;
+        case 3:
+                fsb = 166667;
+                break;
+        default:
+                printk(KERN_ERR "PCORE - MSR_FSB_FREQ undefined value");
+        }
+
+        rdmsr(MSR_IA32_EBL_CR_POWERON, msr_lo, msr_tmp);
+        dprintk("PCORE - MSR_IA32_EBL_CR_POWERON: 0x%x 0x%x\n", msr_lo, msr_tmp);
+
+        msr_tmp = (msr_lo >> 22) & 0x1f;
+        dprintk("bits 22-26 are 0x%x, speed is %u\n", msr_tmp, (msr_tmp * fsb));
+
+        return (msr_tmp * fsb);
+}
+
 
 static unsigned int pentium4_get_frequency(void)
 {
@@ -174,6 +204,8 @@ static unsigned int pentium4_get_frequency(void)
 unsigned int speedstep_get_processor_frequency(unsigned int processor)
 {
         switch (processor) {
+        case SPEEDSTEP_PROCESSOR_PCORE:
+                return pentium_core_get_frequency();
         case SPEEDSTEP_PROCESSOR_PM:
                 return pentiumM_get_frequency();
         case SPEEDSTEP_PROCESSOR_P4D:
diff --git a/arch/i386/kernel/cpu/cpufreq/speedstep-lib.h b/arch/i386/kernel/cpu/cpufreq/speedstep-lib.h
index b735429c50b4..b11bcc608cac 100644
--- a/arch/i386/kernel/cpu/cpufreq/speedstep-lib.h
+++ b/arch/i386/kernel/cpu/cpufreq/speedstep-lib.h
@@ -22,6 +22,7 @@
  * the speedstep_get_processor_frequency() call. */
 #define SPEEDSTEP_PROCESSOR_PM                  0xFFFFFF03  /* Pentium M  */
 #define SPEEDSTEP_PROCESSOR_P4D                 0xFFFFFF04  /* desktop P4  */
+#define SPEEDSTEP_PROCESSOR_PCORE               0xFFFFFF05  /* Core */
 
 /* speedstep states -- only two of them */
 
diff --git a/arch/i386/kernel/cpu/cpufreq/speedstep-smi.c b/arch/i386/kernel/cpu/cpufreq/speedstep-smi.c
index c28333d53646..ff0d89806114 100644
--- a/arch/i386/kernel/cpu/cpufreq/speedstep-smi.c
+++ b/arch/i386/kernel/cpu/cpufreq/speedstep-smi.c
@@ -360,9 +360,6 @@ static int __init speedstep_init(void)
         case SPEEDSTEP_PROCESSOR_PIII_C:
         case SPEEDSTEP_PROCESSOR_PIII_C_EARLY:
                 break;
-        case SPEEDSTEP_PROCESSOR_P4M:
-                printk(KERN_INFO "speedstep-smi: you're trying to use this cpufreq driver on a Pentium 4-based CPU. Most likely it will not work.\n");
-                break;
         default:
                 speedstep_processor = 0;
         }
diff --git a/arch/powerpc/platforms/4xx/Kconfig b/arch/powerpc/platforms/4xx/Kconfig
index ed39d6a3d22a..2f2a13ed7667 100644
--- a/arch/powerpc/platforms/4xx/Kconfig
+++ b/arch/powerpc/platforms/4xx/Kconfig
@@ -179,7 +179,7 @@ config BIOS_FIXUP
 # OAK doesn't exist but wanted to keep this around for any future 403GCX boards
 config 403GCX
         bool
-        depends OAK
+        depends on OAK
         default y
 
 config 405EP
diff --git a/arch/powerpc/platforms/embedded6xx/Kconfig b/arch/powerpc/platforms/embedded6xx/Kconfig
index ddbe398fbd48..b3c2ce4cb7a8 100644
--- a/arch/powerpc/platforms/embedded6xx/Kconfig
+++ b/arch/powerpc/platforms/embedded6xx/Kconfig
@@ -35,7 +35,7 @@ config HDPU
           Select HDPU if configuring a Sky Computers Compute Blade.
 
 config HDPU_FEATURES
-        depends HDPU
+        depends on HDPU
         tristate "HDPU-Features"
         help
           Select to enable HDPU enhanced features.
diff --git a/arch/ppc/Kconfig b/arch/ppc/Kconfig
index 692b5ba53209..8eb82efe05a1 100644
--- a/arch/ppc/Kconfig
+++ b/arch/ppc/Kconfig
@@ -624,7 +624,7 @@ config HDPU
           Select HDPU if configuring a Sky Computers Compute Blade.
 
 config HDPU_FEATURES
-        depends HDPU
+        depends on HDPU
         tristate "HDPU-Features"
         help
           Select to enable HDPU enhanced features.
@@ -735,7 +735,7 @@ config LITE5200
 
 config LITE5200B
         bool "Freescale LITE5200B"
-        depends LITE5200
+        depends on LITE5200
         help
           Support for the LITE5200B dev board for the MPC5200 from Freescale.
           This is the new board with 2 PCI slots.
diff --git a/arch/ppc/platforms/4xx/Kconfig b/arch/ppc/platforms/4xx/Kconfig
index 293bd489e7d9..6980de420e92 100644
--- a/arch/ppc/platforms/4xx/Kconfig
+++ b/arch/ppc/platforms/4xx/Kconfig
@@ -189,7 +189,7 @@ config BIOS_FIXUP
 # OAK doesn't exist but wanted to keep this around for any future 403GCX boards
 config 403GCX
         bool
-        depends OAK
+        depends on OAK
         default y
 
 config 405EP
diff --git a/arch/um/drivers/net_kern.c b/arch/um/drivers/net_kern.c
index 286bc0b3207f..b2e9762e13c5 100644
--- a/arch/um/drivers/net_kern.c
+++ b/arch/um/drivers/net_kern.c
@@ -334,13 +334,12 @@ static int eth_configure(int n, void *init, char *mac,
         size = transport->private_size + sizeof(struct uml_net_private) + 
                 sizeof(((struct uml_net_private *) 0)->user);
 
-        device = kmalloc(sizeof(*device), GFP_KERNEL);
+        device = kzalloc(sizeof(*device), GFP_KERNEL);
         if (device == NULL) {
                 printk(KERN_ERR "eth_configure failed to allocate uml_net\n");
                 return(1);
         }
 
-        memset(device, 0, sizeof(*device));
         INIT_LIST_HEAD(&device->list);
         device->index = n;
 
diff --git a/arch/v850/Kconfig b/arch/v850/Kconfig
index bcf825875d17..f0d4d72e560f 100644
--- a/arch/v850/Kconfig
+++ b/arch/v850/Kconfig
@@ -105,17 +105,17 @@ menu "Processor type and features"
    # currently support
    config V850E_MA1
           bool
-          depends RTE_CB_MA1
+          depends on RTE_CB_MA1
           default y
    # Similarly for the RTE-V850E/NB85E-CB - V850E/TEG
    config V850E_TEG
           bool
-          depends RTE_CB_NB85E
+          depends on RTE_CB_NB85E
           default y
    # ... and the RTE-V850E/ME2-CB - V850E/ME2
    config V850E_ME2
           bool
-          depends RTE_CB_ME2
+          depends on RTE_CB_ME2
           default y
 
 
@@ -123,7 +123,7 @@ menu "Processor type and features"
 
    config V850E2_SIM85E2
           bool
-          depends V850E2_SIM85E2C || V850E2_SIM85E2S
+          depends on V850E2_SIM85E2C || V850E2_SIM85E2S
           default y
 
 
@@ -132,7 +132,7 @@ menu "Processor type and features"
    # V850E2 processors
    config V850E2
           bool
-          depends V850E2_SIM85E2 || V850E2_FPGA85E2C || V850E2_ANNA
+          depends on V850E2_SIM85E2 || V850E2_FPGA85E2C || V850E2_ANNA
           default y
 
 
@@ -141,7 +141,7 @@ menu "Processor type and features"
    # Boards in the RTE-x-CB series
    config RTE_CB
           bool
-          depends RTE_CB_MA1 || RTE_CB_NB85E || RTE_CB_ME2
+          depends on RTE_CB_MA1 || RTE_CB_NB85E || RTE_CB_ME2
           default y
 
    config RTE_CB_MULTI
@@ -149,28 +149,28 @@ menu "Processor type and features"
           # RTE_CB_NB85E can either have multi ROM support or not, but
           # other platforms (currently only RTE_CB_MA1) require it.
           prompt "Multi monitor ROM support" if RTE_CB_NB85E
-          depends RTE_CB_MA1 || RTE_CB_NB85E
+          depends on RTE_CB_MA1 || RTE_CB_NB85E
           default y
 
    config RTE_CB_MULTI_DBTRAP
           bool "Pass illegal insn trap / dbtrap to kernel"
-          depends RTE_CB_MULTI
+          depends on RTE_CB_MULTI
           default n
 
    config RTE_CB_MA1_KSRAM
           bool "Kernel in SRAM (limits size of kernel)"
-          depends RTE_CB_MA1 && RTE_CB_MULTI
+          depends on RTE_CB_MA1 && RTE_CB_MULTI
           default n
 
    config RTE_MB_A_PCI
           bool "Mother-A PCI support"
-          depends RTE_CB
+          depends on RTE_CB
           default y
 
    # The GBUS is used to talk to the RTE-MOTHER-A board
    config RTE_GBUS_INT
           bool
-          depends RTE_MB_A_PCI
+          depends on RTE_MB_A_PCI
           default y
 
    # The only PCI bus we support is on the RTE-MOTHER-A board
@@ -209,7 +209,7 @@ menu "Processor type and features"
 
    config ROM_KERNEL
           bool "Kernel in ROM"
-          depends V850E2_ANNA || V850E_AS85EP1 || RTE_CB_ME2
+          depends on V850E2_ANNA || V850E_AS85EP1 || RTE_CB_ME2
 
    # Some platforms pre-zero memory, in which case the kernel doesn't need to
    config ZERO_BSS
@@ -225,10 +225,10 @@ menu "Processor type and features"
 
    config V850E_HIGHRES_TIMER
           bool "High resolution timer support"
-          depends V850E_TIMER_D
+          depends on V850E_TIMER_D
    config TIME_BOOTUP
           bool "Time bootup"
-          depends V850E_HIGHRES_TIMER
+          depends on V850E_HIGHRES_TIMER
 
    config RESET_GUARD
           bool "Reset Guard"
diff --git a/arch/x86_64/kernel/cpufreq/Kconfig b/arch/x86_64/kernel/cpufreq/Kconfig
index 81f1562e5393..3abcfa3e1ed7 100644
--- a/arch/x86_64/kernel/cpufreq/Kconfig
+++ b/arch/x86_64/kernel/cpufreq/Kconfig
@@ -27,10 +27,13 @@ config X86_POWERNOW_K8_ACPI
         default y
 
 config X86_SPEEDSTEP_CENTRINO
-        tristate "Intel Enhanced SpeedStep"
+        tristate "Intel Enhanced SpeedStep (deprecated)"
         select CPU_FREQ_TABLE
         depends on ACPI_PROCESSOR
         help
+          This is deprecated and this functionality is now merged into
+          acpi_cpufreq (X86_ACPI_CPUFREQ). Use that driver instead of
+          speedstep_centrino.
           This adds the CPUFreq driver for Enhanced SpeedStep enabled
           mobile CPUs.  This means Intel Pentium M (Centrino) CPUs
           or 64bit enabled Intel Xeons.
@@ -50,6 +53,7 @@ config X86_ACPI_CPUFREQ
         help
           This driver adds a CPUFreq driver which utilizes the ACPI
           Processor Performance States.
+          This driver also supports Intel Enhanced Speedstep.
 
           For details, take a look at <file:Documentation/cpu-freq/>.
 
diff --git a/arch/x86_64/kernel/cpufreq/Makefile b/arch/x86_64/kernel/cpufreq/Makefile
index d8b593879224..753ce1dd418e 100644
--- a/arch/x86_64/kernel/cpufreq/Makefile
+++ b/arch/x86_64/kernel/cpufreq/Makefile
@@ -5,8 +5,8 @@
 SRCDIR := ../../../i386/kernel/cpu/cpufreq
 
 obj-$(CONFIG_X86_POWERNOW_K8) += powernow-k8.o
-obj-$(CONFIG_X86_SPEEDSTEP_CENTRINO) += speedstep-centrino.o
 obj-$(CONFIG_X86_ACPI_CPUFREQ) += acpi-cpufreq.o
+obj-$(CONFIG_X86_SPEEDSTEP_CENTRINO) += speedstep-centrino.o
 obj-$(CONFIG_X86_P4_CLOCKMOD) += p4-clockmod.o
 obj-$(CONFIG_X86_SPEEDSTEP_LIB) += speedstep-lib.o
 
diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig
index b10f4d8fdc7f..0a3aee29e067 100644
--- a/drivers/char/Kconfig
+++ b/drivers/char/Kconfig
@@ -867,7 +867,7 @@ config SONYPI
 
 config TANBAC_TB0219
         tristate "TANBAC TB0219 base board support"
-        depends TANBAC_TB022X
+        depends on TANBAC_TB022X
         select GPIO_VR41XX
 
 source "drivers/char/agp/Kconfig"
diff --git a/drivers/char/watchdog/at91rm9200_wdt.c b/drivers/char/watchdog/at91rm9200_wdt.c
index cb86967e2c5f..38bd37372599 100644
--- a/drivers/char/watchdog/at91rm9200_wdt.c
+++ b/drivers/char/watchdog/at91rm9200_wdt.c
@@ -203,9 +203,9 @@ static int __init at91wdt_probe(struct platform_device *pdev)
 {
         int res;
 
-        if (at91wdt_miscdev.dev)
+        if (at91wdt_miscdev.parent)
                 return -EBUSY;
-        at91wdt_miscdev.dev = &pdev->dev;
+        at91wdt_miscdev.parent = &pdev->dev;
 
         res = misc_register(&at91wdt_miscdev);
         if (res)
@@ -221,7 +221,7 @@ static int __exit at91wdt_remove(struct platform_device *pdev)
 
         res = misc_deregister(&at91wdt_miscdev);
         if (!res)
-                at91wdt_miscdev.dev = NULL;
+                at91wdt_miscdev.parent = NULL;
 
         return res;
 }
diff --git a/drivers/char/watchdog/mpcore_wdt.c b/drivers/char/watchdog/mpcore_wdt.c
index 3404a9c67f08..e88947f8fe53 100644
--- a/drivers/char/watchdog/mpcore_wdt.c
+++ b/drivers/char/watchdog/mpcore_wdt.c
@@ -347,7 +347,7 @@ static int __devinit mpcore_wdt_probe(struct platform_device *dev)
                 goto err_free;
         }
 
-        mpcore_wdt_miscdev.dev = &dev->dev;
+        mpcore_wdt_miscdev.parent = &dev->dev;
         ret = misc_register(&mpcore_wdt_miscdev);
         if (ret) {
                 dev_printk(KERN_ERR, _dev, "cannot register miscdev on minor=%d (err=%d)\n",
diff --git a/drivers/char/watchdog/omap_wdt.c b/drivers/char/watchdog/omap_wdt.c
index 5dbd7dc2936f..6c6f97332dbb 100644
--- a/drivers/char/watchdog/omap_wdt.c
+++ b/drivers/char/watchdog/omap_wdt.c
@@ -290,7 +290,7 @@ static int __init omap_wdt_probe(struct platform_device *pdev)
         omap_wdt_disable();
         omap_wdt_adjust_timeout(timer_margin);
 
-        omap_wdt_miscdev.dev = &pdev->dev;
+        omap_wdt_miscdev.parent = &pdev->dev;
         ret = misc_register(&omap_wdt_miscdev);
         if (ret)
                 goto fail;
diff --git a/drivers/char/watchdog/pcwd_usb.c b/drivers/char/watchdog/pcwd_usb.c
index 61138726b501..2da5ac99687c 100644
--- a/drivers/char/watchdog/pcwd_usb.c
+++ b/drivers/char/watchdog/pcwd_usb.c
@@ -42,6 +42,7 @@
 #include <asm/uaccess.h>
 #include <linux/usb.h>
 #include <linux/mutex.h>
+#include <linux/hid.h>          /* For HID_REQ_SET_REPORT & HID_DT_REPORT */
 
 
 #ifdef CONFIG_USB_DEBUG
@@ -109,10 +110,6 @@ MODULE_DEVICE_TABLE (usb, usb_pcwd_table);
 #define CMD_ENABLE_WATCHDOG             0x30    /* Enable / Disable Watchdog */
 #define CMD_DISABLE_WATCHDOG            CMD_ENABLE_WATCHDOG
 
-/* Some defines that I like to be somewhere else like include/linux/usb_hid.h */
-#define HID_REQ_SET_REPORT              0x09
-#define HID_DT_REPORT                   (USB_TYPE_CLASS | 0x02)
-
 /* We can only use 1 card due to the /dev/watchdog restriction */
 static int cards_found;
 
diff --git a/drivers/char/watchdog/rm9k_wdt.c b/drivers/char/watchdog/rm9k_wdt.c
index ec3909371c21..7576a13e86bc 100644
--- a/drivers/char/watchdog/rm9k_wdt.c
+++ b/drivers/char/watchdog/rm9k_wdt.c
@@ -47,7 +47,7 @@
 
 
 /* Function prototypes */
-static irqreturn_t wdt_gpi_irqhdl(int, void *, struct pt_regs *);
+static irqreturn_t wdt_gpi_irqhdl(int, void *);
 static void wdt_gpi_start(void);
 static void wdt_gpi_stop(void);
 static void wdt_gpi_set_timeout(unsigned int);
@@ -94,8 +94,28 @@ module_param(nowayout, bool, 0444);
 MODULE_PARM_DESC(nowayout, "Watchdog cannot be disabled once started");
 
 
+/* Kernel interfaces */
+static struct file_operations fops = {
+        .owner          = THIS_MODULE,
+        .open           = wdt_gpi_open,
+        .release        = wdt_gpi_release,
+        .write          = wdt_gpi_write,
+        .unlocked_ioctl = wdt_gpi_ioctl,
+};
+
+static struct miscdevice miscdev = {
+        .minor          = WATCHDOG_MINOR,
+        .name           = wdt_gpi_name,
+        .fops           = &fops,
+};
+
+static struct notifier_block wdt_gpi_shutdown = {
+        .notifier_call  = wdt_gpi_notify,
+};
+
+
 /* Interrupt handler */
-static irqreturn_t wdt_gpi_irqhdl(int irq, void *ctxt, struct pt_regs *regs)
+static irqreturn_t wdt_gpi_irqhdl(int irq, void *ctxt)
 {
         if (!unlikely(__raw_readl(wd_regs + 0x0008) & 0x1))
                 return IRQ_NONE;
@@ -312,26 +332,6 @@ wdt_gpi_notify(struct notifier_block *this, unsigned long code, void *unused)
 }
 
 
-/* Kernel interfaces */
-static struct file_operations fops = {
-        .owner          = THIS_MODULE,
-        .open           = wdt_gpi_open,
-        .release        = wdt_gpi_release,
-        .write          = wdt_gpi_write,
-        .unlocked_ioctl = wdt_gpi_ioctl,
-};
-
-static struct miscdevice miscdev = {
-        .minor          = WATCHDOG_MINOR,
-        .name           = wdt_gpi_name,
-        .fops           = &fops,
-};
-
-static struct notifier_block wdt_gpi_shutdown = {
-        .notifier_call  = wdt_gpi_notify,
-};
-
-
 /* Init & exit procedures */
 static const struct resource *
 wdt_gpi_get_resource(struct platform_device *pdv, const char *name,
diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c
index 47ab42db122a..9fb2edf36611 100644
--- a/drivers/cpufreq/cpufreq.c
+++ b/drivers/cpufreq/cpufreq.c
@@ -29,7 +29,8 @@
 #include <linux/completion.h>
 #include <linux/mutex.h>
 
-#define dprintk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_CORE, "cpufreq-core", msg)
+#define dprintk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_CORE, \
+                                                "cpufreq-core", msg)
 
 /**
  * The "cpufreq driver" - the arch- or hardware-dependent low
@@ -151,7 +152,8 @@ static void cpufreq_debug_disable_ratelimit(void)
         spin_unlock_irqrestore(&disable_ratelimit_lock, flags);
 }
 
-void cpufreq_debug_printk(unsigned int type, const char *prefix, const char *fmt, ...)
+void cpufreq_debug_printk(unsigned int type, const char *prefix,
+                                                        const char *fmt, ...)
 {
         char s[256];
         va_list args;
@@ -161,7 +163,8 @@ void cpufreq_debug_printk(unsigned int type, const char *prefix, const char *fmt
         WARN_ON(!prefix);
         if (type & debug) {
                 spin_lock_irqsave(&disable_ratelimit_lock, flags);
-                if (!disable_ratelimit && debug_ratelimit && !printk_ratelimit()) {
+                if (!disable_ratelimit && debug_ratelimit
+                                        && !printk_ratelimit()) {
                         spin_unlock_irqrestore(&disable_ratelimit_lock, flags);
                         return;
                 }
@@ -182,10 +185,12 @@ EXPORT_SYMBOL(cpufreq_debug_printk);
 
 
 module_param(debug, uint, 0644);
-MODULE_PARM_DESC(debug, "CPUfreq debugging: add 1 to debug core, 2 to debug drivers, and 4 to debug governors.");
+MODULE_PARM_DESC(debug, "CPUfreq debugging: add 1 to debug core,"
+                        " 2 to debug drivers, and 4 to debug governors.");
 
 module_param(debug_ratelimit, uint, 0644);
-MODULE_PARM_DESC(debug_ratelimit, "CPUfreq debugging: set to 0 to disable ratelimiting.");
+MODULE_PARM_DESC(debug_ratelimit, "CPUfreq debugging:"
+                                        " set to 0 to disable ratelimiting.");
 
 #else /* !CONFIG_CPU_FREQ_DEBUG */
 
@@ -219,17 +224,23 @@ static void adjust_jiffies(unsigned long val, struct cpufreq_freqs *ci)
         if (!l_p_j_ref_freq) {
                 l_p_j_ref = loops_per_jiffy;
                 l_p_j_ref_freq = ci->old;
-                dprintk("saving %lu as reference value for loops_per_jiffy; freq is %u kHz\n", l_p_j_ref, l_p_j_ref_freq);
+                dprintk("saving %lu as reference value for loops_per_jiffy;"
+                        "freq is %u kHz\n", l_p_j_ref, l_p_j_ref_freq);
         }
         if ((val == CPUFREQ_PRECHANGE  && ci->old < ci->new) ||
             (val == CPUFREQ_POSTCHANGE && ci->old > ci->new) ||
             (val == CPUFREQ_RESUMECHANGE || val == CPUFREQ_SUSPENDCHANGE)) {
-                loops_per_jiffy = cpufreq_scale(l_p_j_ref, l_p_j_ref_freq, ci->new);
-                dprintk("scaling loops_per_jiffy to %lu for frequency %u kHz\n", loops_per_jiffy, ci->new);
+                loops_per_jiffy = cpufreq_scale(l_p_j_ref, l_p_j_ref_freq,
+                                                                ci->new);
+                dprintk("scaling loops_per_jiffy to %lu"
+                        "for frequency %u kHz\n", loops_per_jiffy, ci->new);
         }
 }
 #else
-static inline void adjust_jiffies(unsigned long val, struct cpufreq_freqs *ci) { return; }
+static inline void adjust_jiffies(unsigned long val, struct cpufreq_freqs *ci)
+{
+        return;
+}
 #endif
 
 
@@ -316,7 +327,8 @@ static int cpufreq_parse_governor (char *str_governor, unsigned int *policy,
                 if (!strnicmp(str_governor, "performance", CPUFREQ_NAME_LEN)) {
                         *policy = CPUFREQ_POLICY_PERFORMANCE;
                         err = 0;
-                } else if (!strnicmp(str_governor, "powersave", CPUFREQ_NAME_LEN)) {
+                } else if (!strnicmp(str_governor, "powersave",
+                                                CPUFREQ_NAME_LEN)) {
                         *policy = CPUFREQ_POLICY_POWERSAVE;
                         err = 0;
                 }
@@ -328,7 +340,8 @@ static int cpufreq_parse_governor (char *str_governor, unsigned int *policy,
                 t = __find_governor(str_governor);
 
                 if (t == NULL) {
-                        char *name = kasprintf(GFP_KERNEL, "cpufreq_%s", str_governor);
+                        char *name = kasprintf(GFP_KERNEL, "cpufreq_%s",
+                                                                str_governor);
 
                         if (name) {
                                 int ret;
@@ -361,7 +374,8 @@ extern struct sysdev_class cpu_sysdev_class;
 
 
 /**
- * cpufreq_per_cpu_attr_read() / show_##file_name() - print out cpufreq information
+ * cpufreq_per_cpu_attr_read() / show_##file_name() -
+ * print out cpufreq information
  *
  * Write out information from cpufreq_driver->policy[cpu]; object must be
  * "unsigned int".
@@ -380,7 +394,8 @@ show_one(scaling_min_freq, min);
 show_one(scaling_max_freq, max);
 show_one(scaling_cur_freq, cur);
 
-static int __cpufreq_set_policy(struct cpufreq_policy *data, struct cpufreq_policy *policy);
+static int __cpufreq_set_policy(struct cpufreq_policy *data,
+                                struct cpufreq_policy *policy);
 
 /**
  * cpufreq_per_cpu_attr_write() / store_##file_name() - sysfs write access
@@ -416,7 +431,8 @@ store_one(scaling_max_freq,max);
 /**
  * show_cpuinfo_cur_freq - current CPU frequency as detected by hardware
  */
-static ssize_t show_cpuinfo_cur_freq (struct cpufreq_policy * policy, char *buf)
+static ssize_t show_cpuinfo_cur_freq (struct cpufreq_policy * policy,
+                                                        char *buf)
 {
         unsigned int cur_freq = cpufreq_get(policy->cpu);
         if (!cur_freq)
@@ -428,7 +444,8 @@ static ssize_t show_cpuinfo_cur_freq (struct cpufreq_policy * policy, char *buf)
 /**
  * show_scaling_governor - show the current policy for the specified CPU
  */
-static ssize_t show_scaling_governor (struct cpufreq_policy * policy, char *buf)
+static ssize_t show_scaling_governor (struct cpufreq_policy * policy,
+                                                        char *buf)
 {
         if(policy->policy == CPUFREQ_POLICY_POWERSAVE)
                 return sprintf(buf, "powersave\n");
@@ -458,7 +475,8 @@ static ssize_t store_scaling_governor (struct cpufreq_policy * policy,
         if (ret != 1)
                 return -EINVAL;
 
-        if (cpufreq_parse_governor(str_governor, &new_policy.policy, &new_policy.governor))
+        if (cpufreq_parse_governor(str_governor, &new_policy.policy,
+                                                &new_policy.governor))
                 return -EINVAL;
 
         lock_cpu_hotplug();
@@ -474,7 +492,10 @@ static ssize_t store_scaling_governor (struct cpufreq_policy * policy,
 
         unlock_cpu_hotplug();
 
-        return ret ? ret : count;
+        if (ret)
+                return ret;
+        else
+                return count;
 }
 
 /**
@@ -488,7 +509,7 @@ static ssize_t show_scaling_driver (struct cpufreq_policy * policy, char *buf)
 /**
  * show_scaling_available_governors - show the available CPUfreq governors
  */
-static ssize_t show_scaling_available_governors (struct cpufreq_policy * policy,
+static ssize_t show_scaling_available_governors (struct cpufreq_policy *policy,
                                 char *buf)
 {
         ssize_t i = 0;
@@ -574,7 +595,11 @@ static ssize_t show(struct kobject * kobj, struct attribute * attr ,char * buf)
         policy = cpufreq_cpu_get(policy->cpu);
         if (!policy)
                 return -EINVAL;
-        ret = fattr->show ? fattr->show(policy,buf) : -EIO;
+        if (fattr->show)
+                ret = fattr->show(policy, buf);
+        else
+                ret = -EIO;
+
         cpufreq_cpu_put(policy);
         return ret;
 }
@@ -588,7 +613,11 @@ static ssize_t store(struct kobject * kobj, struct attribute * attr,
         policy = cpufreq_cpu_get(policy->cpu);
         if (!policy)
                 return -EINVAL;
-        ret = fattr->store ? fattr->store(policy,buf,count) : -EIO;
+        if (fattr->store)
+                ret = fattr->store(policy, buf, count);
+        else
+                ret = -EIO;
+
         cpufreq_cpu_put(policy);
         return ret;
 }
@@ -913,7 +942,8 @@ static void handle_update(struct work_struct *work)
  *      We adjust to current frequency first, and need to clean up later. So either call
  *      to cpufreq_update_policy() or schedule handle_update()).
  */
-static void cpufreq_out_of_sync(unsigned int cpu, unsigned int old_freq, unsigned int new_freq)
+static void cpufreq_out_of_sync(unsigned int cpu, unsigned int old_freq,
+                                unsigned int new_freq)
 {
         struct cpufreq_freqs freqs;
 
@@ -938,16 +968,16 @@ static void cpufreq_out_of_sync(unsigned int cpu, unsigned int old_freq, unsigne
 unsigned int cpufreq_quick_get(unsigned int cpu)
 {
         struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
-        unsigned int ret = 0;
+        unsigned int ret_freq = 0;
 
         if (policy) {
                 mutex_lock(&policy->lock);
-                ret = policy->cur;
+                ret_freq = policy->cur;
                 mutex_unlock(&policy->lock);
                 cpufreq_cpu_put(policy);
         }
 
-        return (ret);
+        return (ret_freq);
 }
 EXPORT_SYMBOL(cpufreq_quick_get);
 
@@ -961,7 +991,7 @@ EXPORT_SYMBOL(cpufreq_quick_get);
 unsigned int cpufreq_get(unsigned int cpu)
 {
         struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
-        unsigned int ret = 0;
+        unsigned int ret_freq = 0;
 
         if (!policy)
                 return 0;
@@ -971,12 +1001,14 @@ unsigned int cpufreq_get(unsigned int cpu)
 
         mutex_lock(&policy->lock);
 
-        ret = cpufreq_driver->get(cpu);
+        ret_freq = cpufreq_driver->get(cpu);
 
-        if (ret && policy->cur && !(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) {
-                /* verify no discrepancy between actual and saved value exists */
-                if (unlikely(ret != policy->cur)) {
-                        cpufreq_out_of_sync(cpu, policy->cur, ret);
+        if (ret_freq && policy->cur &&
+                !(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) {
+                /* verify no discrepancy between actual and
+                                        saved value exists */
+                if (unlikely(ret_freq != policy->cur)) {
+                        cpufreq_out_of_sync(cpu, policy->cur, ret_freq);
                         schedule_work(&policy->update);
                 }
         }
@@ -986,7 +1018,7 @@ unsigned int cpufreq_get(unsigned int cpu)
 out:
         cpufreq_cpu_put(policy);
 
-        return (ret);
+        return (ret_freq);
 }
 EXPORT_SYMBOL(cpufreq_get);
 
@@ -998,7 +1030,7 @@ EXPORT_SYMBOL(cpufreq_get);
 static int cpufreq_suspend(struct sys_device * sysdev, pm_message_t pmsg)
 {
         int cpu = sysdev->id;
-        unsigned int ret = 0;
+        int ret = 0;
         unsigned int cur_freq = 0;
         struct cpufreq_policy *cpu_policy;
 
@@ -1080,7 +1112,7 @@ out:
 static int cpufreq_resume(struct sys_device * sysdev)
 {
         int cpu = sysdev->id;
-        unsigned int ret = 0;
+        int ret = 0;
         struct cpufreq_policy *cpu_policy;
 
         dprintk("resuming cpu %u\n", cpu);
@@ -1276,22 +1308,45 @@ int cpufreq_driver_target(struct cpufreq_policy *policy,
 }
 EXPORT_SYMBOL_GPL(cpufreq_driver_target);
 
+int cpufreq_driver_getavg(struct cpufreq_policy *policy)
+{
+        int ret = 0;
+
+        policy = cpufreq_cpu_get(policy->cpu);
+        if (!policy)
+                return -EINVAL;
+
+        mutex_lock(&policy->lock);
+
+        if (cpu_online(policy->cpu) && cpufreq_driver->getavg)
+                ret = cpufreq_driver->getavg(policy->cpu);
+
+        mutex_unlock(&policy->lock);
+
+        cpufreq_cpu_put(policy);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(cpufreq_driver_getavg);
+
 /*
  * Locking: Must be called with the lock_cpu_hotplug() lock held
  * when "event" is CPUFREQ_GOV_LIMITS
  */
 
-static int __cpufreq_governor(struct cpufreq_policy *policy, unsigned int event)
+static int __cpufreq_governor(struct cpufreq_policy *policy,
+                                        unsigned int event)
 {
         int ret;
 
         if (!try_module_get(policy->governor->owner))
                 return -EINVAL;
 
-        dprintk("__cpufreq_governor for CPU %u, event %u\n", policy->cpu, event);
+        dprintk("__cpufreq_governor for CPU %u, event %u\n",
+                                                policy->cpu, event);
         ret = policy->governor->governor(policy, event);
 
-        /* we keep one module reference alive for each CPU governed by this CPU */
+        /* we keep one module reference alive for
+                        each CPU governed by this CPU */
         if ((event != CPUFREQ_GOV_START) || ret)
                 module_put(policy->governor->owner);
         if ((event == CPUFREQ_GOV_STOP) && !ret)
@@ -1367,9 +1422,12 @@ EXPORT_SYMBOL(cpufreq_get_policy);
 
 
 /*
+ * data   : current policy.
+ * policy : policy to be set.
  * Locking: Must be called with the lock_cpu_hotplug() lock held
  */
-static int __cpufreq_set_policy(struct cpufreq_policy *data, struct cpufreq_policy *policy)
+static int __cpufreq_set_policy(struct cpufreq_policy *data,
+                                struct cpufreq_policy *policy)
 {
         int ret = 0;
 
@@ -1377,7 +1435,8 @@ static int __cpufreq_set_policy(struct cpufreq_policy *data, struct cpufreq_poli
         dprintk("setting new policy for CPU %u: %u - %u kHz\n", policy->cpu,
                 policy->min, policy->max);
 
-        memcpy(&policy->cpuinfo, &data->cpuinfo, sizeof(struct cpufreq_cpuinfo));
+        memcpy(&policy->cpuinfo, &data->cpuinfo,
+                                sizeof(struct cpufreq_cpuinfo));
 
         if (policy->min > data->min && policy->min > policy->max) {
                 ret = -EINVAL;
@@ -1410,7 +1469,8 @@ static int __cpufreq_set_policy(struct cpufreq_policy *data, struct cpufreq_poli
         data->min = policy->min;
         data->max = policy->max;
 
-        dprintk("new min and max freqs are %u - %u kHz\n", data->min, data->max);
+        dprintk("new min and max freqs are %u - %u kHz\n",
+                                        data->min, data->max);
 
         if (cpufreq_driver->setpolicy) {
                 data->policy = policy->policy;
@@ -1431,10 +1491,12 @@ static int __cpufreq_set_policy(struct cpufreq_policy *data, struct cpufreq_poli
                         data->governor = policy->governor;
                         if (__cpufreq_governor(data, CPUFREQ_GOV_START)) {
                                 /* new governor failed, so re-start old one */
-                                dprintk("starting governor %s failed\n", data->governor->name);
+                                dprintk("starting governor %s failed\n",
+                                                        data->governor->name);
                                 if (old_gov) {
                                         data->governor = old_gov;
-                                        __cpufreq_governor(data, CPUFREQ_GOV_START);
+                                        __cpufreq_governor(data,
+                                                           CPUFREQ_GOV_START);
                                 }
                                 ret = -EINVAL;
                                 goto error_out;
@@ -1524,7 +1586,8 @@ int cpufreq_update_policy(unsigned int cpu)
                         data->cur = policy.cur;
                 } else {
                         if (data->cur != policy.cur)
-                                cpufreq_out_of_sync(cpu, data->cur, policy.cur);
+                                cpufreq_out_of_sync(cpu, data->cur,
+                                                                policy.cur);
                 }
         }
 
@@ -1626,8 +1689,10 @@ int cpufreq_register_driver(struct cpufreq_driver *driver_data)
 
                 /* if all ->init() calls failed, unregister */
                 if (ret) {
-                        dprintk("no CPU initialized for driver %s\n", driver_data->name);
-                        sysdev_driver_unregister(&cpu_sysdev_class, &cpufreq_sysdev_driver);
+                        dprintk("no CPU initialized for driver %s\n",
+                                                        driver_data->name);
+                        sysdev_driver_unregister(&cpu_sysdev_class,
+                                                &cpufreq_sysdev_driver);
 
                         spin_lock_irqsave(&cpufreq_driver_lock, flags);
                         cpufreq_driver = NULL;
diff --git a/drivers/cpufreq/cpufreq_conservative.c b/drivers/cpufreq/cpufreq_conservative.c
index 5ef5ede5b884..eef0270c6f3d 100644
--- a/drivers/cpufreq/cpufreq_conservative.c
+++ b/drivers/cpufreq/cpufreq_conservative.c
@@ -44,15 +44,17 @@
  * latency of the processor. The governor will work on any processor with 
  * transition latency <= 10mS, using appropriate sampling 
  * rate.
- * For CPUs with transition latency > 10mS (mostly drivers with CPUFREQ_ETERNAL)
- * this governor will not work.
+ * For CPUs with transition latency > 10mS (mostly drivers
+ * with CPUFREQ_ETERNAL), this governor will not work.
  * All times here are in uS.
  */
 static unsigned int                             def_sampling_rate;
 #define MIN_SAMPLING_RATE_RATIO                 (2)
 /* for correct statistics, we need at least 10 ticks between each measure */
-#define MIN_STAT_SAMPLING_RATE                  (MIN_SAMPLING_RATE_RATIO * jiffies_to_usecs(10))
-#define MIN_SAMPLING_RATE                       (def_sampling_rate / MIN_SAMPLING_RATE_RATIO)
+#define MIN_STAT_SAMPLING_RATE                  \
+                        (MIN_SAMPLING_RATE_RATIO * jiffies_to_usecs(10))
+#define MIN_SAMPLING_RATE                       \
+                        (def_sampling_rate / MIN_SAMPLING_RATE_RATIO)
 #define MAX_SAMPLING_RATE                       (500 * def_sampling_rate)
 #define DEF_SAMPLING_RATE_LATENCY_MULTIPLIER    (1000)
 #define DEF_SAMPLING_DOWN_FACTOR                (1)
@@ -103,11 +105,16 @@ static struct dbs_tuners dbs_tuners_ins = {
 
 static inline unsigned int get_cpu_idle_time(unsigned int cpu)
 {
-        return  kstat_cpu(cpu).cpustat.idle +
+        unsigned int add_nice = 0, ret;
+
+        if (dbs_tuners_ins.ignore_nice)
+                add_nice = kstat_cpu(cpu).cpustat.nice;
+
+        ret =   kstat_cpu(cpu).cpustat.idle +
                 kstat_cpu(cpu).cpustat.iowait +
-                ( dbs_tuners_ins.ignore_nice ?
-                  kstat_cpu(cpu).cpustat.nice :
-                  0);
+                add_nice;
+
+        return ret;
 }
 
 /************************** sysfs interface ************************/
@@ -452,6 +459,7 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
         unsigned int cpu = policy->cpu;
         struct cpu_dbs_info_s *this_dbs_info;
         unsigned int j;
+        int rc;
 
         this_dbs_info = &per_cpu(cpu_dbs_info, cpu);
 
@@ -468,6 +476,13 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
                         break;
                  
                 mutex_lock(&dbs_mutex);
+
+                rc = sysfs_create_group(&policy->kobj, &dbs_attr_group);
+                if (rc) {
+                        mutex_unlock(&dbs_mutex);
+                        return rc;
+                }
+
                 for_each_cpu_mask(j, policy->cpus) {
                         struct cpu_dbs_info_s *j_dbs_info;
                         j_dbs_info = &per_cpu(cpu_dbs_info, j);
@@ -480,7 +495,7 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
                 this_dbs_info->enable = 1;
                 this_dbs_info->down_skip = 0;
                 this_dbs_info->requested_freq = policy->cur;
-                sysfs_create_group(&policy->kobj, &dbs_attr_group);
+
                 dbs_enable++;
                 /*
                  * Start the timerschedule work, when this governor
diff --git a/drivers/cpufreq/cpufreq_ondemand.c b/drivers/cpufreq/cpufreq_ondemand.c
index e1cc5113c2ae..f697449327c6 100644
--- a/drivers/cpufreq/cpufreq_ondemand.c
+++ b/drivers/cpufreq/cpufreq_ondemand.c
@@ -41,8 +41,10 @@
 static unsigned int def_sampling_rate;
 #define MIN_SAMPLING_RATE_RATIO                 (2)
 /* for correct statistics, we need at least 10 ticks between each measure */
-#define MIN_STAT_SAMPLING_RATE                  (MIN_SAMPLING_RATE_RATIO * jiffies_to_usecs(10))
-#define MIN_SAMPLING_RATE                       (def_sampling_rate / MIN_SAMPLING_RATE_RATIO)
+#define MIN_STAT_SAMPLING_RATE                  \
+                        (MIN_SAMPLING_RATE_RATIO * jiffies_to_usecs(10))
+#define MIN_SAMPLING_RATE                       \
+                        (def_sampling_rate / MIN_SAMPLING_RATE_RATIO)
 #define MAX_SAMPLING_RATE                       (500 * def_sampling_rate)
 #define DEF_SAMPLING_RATE_LATENCY_MULTIPLIER    (1000)
 #define TRANSITION_LATENCY_LIMIT                (10 * 1000)
@@ -206,7 +208,8 @@ static ssize_t store_sampling_rate(struct cpufreq_policy *unused,
         ret = sscanf(buf, "%u", &input);
 
         mutex_lock(&dbs_mutex);
-        if (ret != 1 || input > MAX_SAMPLING_RATE || input < MIN_SAMPLING_RATE) {
+        if (ret != 1 || input > MAX_SAMPLING_RATE
+                     || input < MIN_SAMPLING_RATE) {
                 mutex_unlock(&dbs_mutex);
                 return -EINVAL;
         }
@@ -397,8 +400,15 @@ static void dbs_check_cpu(struct cpu_dbs_info_s *this_dbs_info)
          * policy. To be safe, we focus 10 points under the threshold.
          */
         if (load < (dbs_tuners_ins.up_threshold - 10)) {
-                unsigned int freq_next = (policy->cur * load) /
+                unsigned int freq_next, freq_cur;
+
+                freq_cur = cpufreq_driver_getavg(policy);
+                if (!freq_cur)
+                        freq_cur = policy->cur;
+
+                freq_next = (freq_cur * load) /
                         (dbs_tuners_ins.up_threshold - 10);
+
                 if (!dbs_tuners_ins.powersave_bias) {
                         __cpufreq_driver_target(policy, freq_next,
                                         CPUFREQ_RELATION_L);
@@ -472,6 +482,7 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
         unsigned int cpu = policy->cpu;
         struct cpu_dbs_info_s *this_dbs_info;
         unsigned int j;
+        int rc;
 
         this_dbs_info = &per_cpu(cpu_dbs_info, cpu);
 
@@ -494,12 +505,23 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
                 if (dbs_enable == 1) {
                         kondemand_wq = create_workqueue("kondemand");
                         if (!kondemand_wq) {
-                                printk(KERN_ERR "Creation of kondemand failed\n");
+                                printk(KERN_ERR
+                                         "Creation of kondemand failed\n");
                                 dbs_enable--;
                                 mutex_unlock(&dbs_mutex);
                                 return -ENOSPC;
                         }
                 }
+
+                rc = sysfs_create_group(&policy->kobj, &dbs_attr_group);
+                if (rc) {
+                        if (dbs_enable == 1)
+                                destroy_workqueue(kondemand_wq);
+                        dbs_enable--;
+                        mutex_unlock(&dbs_mutex);
+                        return rc;
+                }
+
                 for_each_cpu_mask(j, policy->cpus) {
                         struct cpu_dbs_info_s *j_dbs_info;
                         j_dbs_info = &per_cpu(cpu_dbs_info, j);
@@ -509,7 +531,6 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
                         j_dbs_info->prev_cpu_wall = get_jiffies_64();
                 }
                 this_dbs_info->enable = 1;
-                sysfs_create_group(&policy->kobj, &dbs_attr_group);
                 /*
                  * Start the timerschedule work, when this governor
                  * is used for first time
diff --git a/drivers/cpufreq/cpufreq_performance.c b/drivers/cpufreq/cpufreq_performance.c
index de91e3371ef8..e8e1451ef1c1 100644
--- a/drivers/cpufreq/cpufreq_performance.c
+++ b/drivers/cpufreq/cpufreq_performance.c
@@ -15,7 +15,8 @@
 #include <linux/cpufreq.h>
 #include <linux/init.h>
 
-#define dprintk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_GOVERNOR, "performance", msg)
+#define dprintk(msg...) \
+        cpufreq_debug_printk(CPUFREQ_DEBUG_GOVERNOR, "performance", msg)
 
 
 static int cpufreq_governor_performance(struct cpufreq_policy *policy,
@@ -24,8 +25,10 @@ static int cpufreq_governor_performance(struct cpufreq_policy *policy,
         switch (event) {
         case CPUFREQ_GOV_START:
         case CPUFREQ_GOV_LIMITS:
-                dprintk("setting to %u kHz because of event %u\n", policy->max, event);
-                __cpufreq_driver_target(policy, policy->max, CPUFREQ_RELATION_H);
+                dprintk("setting to %u kHz because of event %u\n",
+                                                policy->max, event);
+                __cpufreq_driver_target(policy, policy->max,
+                                                CPUFREQ_RELATION_H);
                 break;
         default:
                 break;
diff --git a/drivers/cpufreq/cpufreq_powersave.c b/drivers/cpufreq/cpufreq_powersave.c
index 0a2596044e65..13fe06b94b0a 100644
--- a/drivers/cpufreq/cpufreq_powersave.c
+++ b/drivers/cpufreq/cpufreq_powersave.c
@@ -15,7 +15,8 @@
 #include <linux/cpufreq.h>
 #include <linux/init.h>
 
-#define dprintk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_GOVERNOR, "powersave", msg)
+#define dprintk(msg...) \
+        cpufreq_debug_printk(CPUFREQ_DEBUG_GOVERNOR, "powersave", msg)
 
 static int cpufreq_governor_powersave(struct cpufreq_policy *policy,
                                         unsigned int event)
@@ -23,8 +24,10 @@ static int cpufreq_governor_powersave(struct cpufreq_policy *policy,
         switch (event) {
         case CPUFREQ_GOV_START:
         case CPUFREQ_GOV_LIMITS:
-                dprintk("setting to %u kHz because of event %u\n", policy->min, event);
-                __cpufreq_driver_target(policy, policy->min, CPUFREQ_RELATION_L);
+                dprintk("setting to %u kHz because of event %u\n",
+                                                        policy->min, event);
+                __cpufreq_driver_target(policy, policy->min,
+                                                CPUFREQ_RELATION_L);
                 break;
         default:
                 break;
diff --git a/drivers/cpufreq/cpufreq_stats.c b/drivers/cpufreq/cpufreq_stats.c
index c2ecc599dc5f..6742b1adf2c8 100644
--- a/drivers/cpufreq/cpufreq_stats.c
+++ b/drivers/cpufreq/cpufreq_stats.c
@@ -351,8 +351,8 @@ __init cpufreq_stats_init(void)
 
         register_hotcpu_notifier(&cpufreq_stat_cpu_notifier);
         for_each_online_cpu(cpu) {
-                cpufreq_stat_cpu_callback(&cpufreq_stat_cpu_notifier, CPU_ONLINE,
-                        (void *)(long)cpu);
+                cpufreq_stat_cpu_callback(&cpufreq_stat_cpu_notifier,
+                                CPU_ONLINE, (void *)(long)cpu);
         }
         return 0;
 }
@@ -368,14 +368,15 @@ __exit cpufreq_stats_exit(void)
         unregister_hotcpu_notifier(&cpufreq_stat_cpu_notifier);
         lock_cpu_hotplug();
         for_each_online_cpu(cpu) {
-                cpufreq_stat_cpu_callback(&cpufreq_stat_cpu_notifier, CPU_DEAD,
-                        (void *)(long)cpu);
+                cpufreq_stat_cpu_callback(&cpufreq_stat_cpu_notifier,
+                                                CPU_DEAD, (void *)(long)cpu);
         }
         unlock_cpu_hotplug();
 }
 
 MODULE_AUTHOR ("Zou Nan hai <nanhai.zou@intel.com>");
-MODULE_DESCRIPTION ("'cpufreq_stats' - A driver to export cpufreq stats through sysfs filesystem");
+MODULE_DESCRIPTION ("'cpufreq_stats' - A driver to export cpufreq stats"
+                                "through sysfs filesystem");
 MODULE_LICENSE ("GPL");
 
 module_init(cpufreq_stats_init);
diff --git a/drivers/cpufreq/cpufreq_userspace.c b/drivers/cpufreq/cpufreq_userspace.c
index a06c204589cd..2a4eb0bfaf30 100644
--- a/drivers/cpufreq/cpufreq_userspace.c
+++ b/drivers/cpufreq/cpufreq_userspace.c
@@ -131,19 +131,26 @@ static int cpufreq_governor_userspace(struct cpufreq_policy *policy,
                                    unsigned int event)
 {
         unsigned int cpu = policy->cpu;
+        int rc = 0;
+
         switch (event) {
         case CPUFREQ_GOV_START:
                 if (!cpu_online(cpu))
                         return -EINVAL;
                 BUG_ON(!policy->cur);
                 mutex_lock(&userspace_mutex);
+                rc = sysfs_create_file (&policy->kobj,
+                                        &freq_attr_scaling_setspeed.attr);
+                if (rc)
+                        goto start_out;
+
                 cpu_is_managed[cpu] = 1;
                 cpu_min_freq[cpu] = policy->min;
                 cpu_max_freq[cpu] = policy->max;
                 cpu_cur_freq[cpu] = policy->cur;
                 cpu_set_freq[cpu] = policy->cur;
-                sysfs_create_file (&policy->kobj, &freq_attr_scaling_setspeed.attr);
                 dprintk("managing cpu %u started (%u - %u kHz, currently %u kHz)\n", cpu, cpu_min_freq[cpu], cpu_max_freq[cpu], cpu_cur_freq[cpu]);
+start_out:
                 mutex_unlock(&userspace_mutex);
                 break;
         case CPUFREQ_GOV_STOP:
@@ -180,7 +187,7 @@ static int cpufreq_governor_userspace(struct cpufreq_policy *policy,
                 mutex_unlock(&userspace_mutex);
                 break;
         }
-        return 0;
+        return rc;
 }
 
 
diff --git a/drivers/cpufreq/freq_table.c b/drivers/cpufreq/freq_table.c
index 551f4ccf87fd..e7490925fdcf 100644
--- a/drivers/cpufreq/freq_table.c
+++ b/drivers/cpufreq/freq_table.c
@@ -9,7 +9,8 @@
 #include <linux/init.h>
 #include <linux/cpufreq.h>
 
-#define dprintk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_CORE, "freq-table", msg)
+#define dprintk(msg...) \
+        cpufreq_debug_printk(CPUFREQ_DEBUG_CORE, "freq-table", msg)
 
 /*********************************************************************
  *                     FREQUENCY TABLE HELPERS                       *
@@ -29,7 +30,8 @@ int cpufreq_frequency_table_cpuinfo(struct cpufreq_policy *policy,
 
                         continue;
                 }
-                dprintk("table entry %u: %u kHz, %u index\n", i, freq, table[i].index);
+                dprintk("table entry %u: %u kHz, %u index\n",
+                                        i, freq, table[i].index);
                 if (freq < min_freq)
                         min_freq = freq;
                 if (freq > max_freq)
@@ -54,13 +56,14 @@ int cpufreq_frequency_table_verify(struct cpufreq_policy *policy,
         unsigned int i;
         unsigned int count = 0;
 
-        dprintk("request for verification of policy (%u - %u kHz) for cpu %u\n", policy->min, policy->max, policy->cpu);
+        dprintk("request for verification of policy (%u - %u kHz) for cpu %u\n",
+                                        policy->min, policy->max, policy->cpu);
 
         if (!cpu_online(policy->cpu))
                 return -EINVAL;
 
-        cpufreq_verify_within_limits(policy,
-                                     policy->cpuinfo.min_freq, policy->cpuinfo.max_freq);
+        cpufreq_verify_within_limits(policy, policy->cpuinfo.min_freq,
+                                     policy->cpuinfo.max_freq);
 
         for (i=0; (table[i].frequency != CPUFREQ_TABLE_END); i++) {
                 unsigned int freq = table[i].frequency;
@@ -75,10 +78,11 @@ int cpufreq_frequency_table_verify(struct cpufreq_policy *policy,
         if (!count)
                 policy->max = next_larger;
 
-        cpufreq_verify_within_limits(policy,
-                                     policy->cpuinfo.min_freq, policy->cpuinfo.max_freq);
+        cpufreq_verify_within_limits(policy, policy->cpuinfo.min_freq,
+                                     policy->cpuinfo.max_freq);
 
-        dprintk("verification lead to (%u - %u kHz) for cpu %u\n", policy->min, policy->max, policy->cpu);
+        dprintk("verification lead to (%u - %u kHz) for cpu %u\n",
+                                policy->min, policy->max, policy->cpu);
 
         return 0;
 }
@@ -101,7 +105,8 @@ int cpufreq_frequency_table_target(struct cpufreq_policy *policy,
         };
         unsigned int i;
 
-        dprintk("request for target %u kHz (relation: %u) for cpu %u\n", target_freq, relation, policy->cpu);
+        dprintk("request for target %u kHz (relation: %u) for cpu %u\n",
+                                        target_freq, relation, policy->cpu);
 
         switch (relation) {
         case CPUFREQ_RELATION_H:
@@ -192,7 +197,10 @@ static ssize_t show_available_freqs (struct cpufreq_policy *policy, char *buf)
 }
 
 struct freq_attr cpufreq_freq_attr_scaling_available_freqs = {
-        .attr = { .name = "scaling_available_frequencies", .mode = 0444, .owner=THIS_MODULE },
+        .attr = { .name = "scaling_available_frequencies",
+                  .mode = 0444,
+                  .owner=THIS_MODULE
+                },
         .show = show_available_freqs,
 };
 EXPORT_SYMBOL_GPL(cpufreq_freq_attr_scaling_available_freqs);
diff --git a/drivers/ide/Kconfig b/drivers/ide/Kconfig
index e23bc0d62159..3f828052f8d2 100644
--- a/drivers/ide/Kconfig
+++ b/drivers/ide/Kconfig
@@ -796,7 +796,7 @@ endchoice
 config BLK_DEV_IDE_AU1XXX_SEQTS_PER_RQ
        int "Maximum transfer size (KB) per request (up to 128)"
        default "128"
-       depends BLK_DEV_IDE_AU1XXX
+       depends on BLK_DEV_IDE_AU1XXX
 
 config IDE_ARM
         def_bool ARM && (ARCH_A5K || ARCH_CLPS7500 || ARCH_RPC || ARCH_SHARK)
diff --git a/drivers/leds/Kconfig b/drivers/leds/Kconfig
index 176142c61492..7399ba791116 100644
--- a/drivers/leds/Kconfig
+++ b/drivers/leds/Kconfig
@@ -12,7 +12,7 @@ config NEW_LEDS
 
 config LEDS_CLASS
         tristate "LED Class Support"
-        depends NEW_LEDS
+        depends on NEW_LEDS
         help
           This option enables the led sysfs class in /sys/class/leds.  You'll
           need this to do anything useful with LEDs.  If unsure, say N.
@@ -21,28 +21,28 @@ comment "LED drivers"
 
 config LEDS_CORGI
         tristate "LED Support for the Sharp SL-C7x0 series"
-        depends LEDS_CLASS && PXA_SHARP_C7xx
+        depends on LEDS_CLASS && PXA_SHARP_C7xx
         help
           This option enables support for the LEDs on Sharp Zaurus
           SL-C7x0 series (C700, C750, C760, C860).
 
 config LEDS_LOCOMO
         tristate "LED Support for Locomo device"
-        depends LEDS_CLASS && SHARP_LOCOMO
+        depends on LEDS_CLASS && SHARP_LOCOMO
         help
           This option enables support for the LEDs on Sharp Locomo.
           Zaurus models SL-5500 and SL-5600.
 
 config LEDS_SPITZ
         tristate "LED Support for the Sharp SL-Cxx00 series"
-        depends LEDS_CLASS && PXA_SHARP_Cxx00
+        depends on LEDS_CLASS && PXA_SHARP_Cxx00
         help
           This option enables support for the LEDs on Sharp Zaurus
           SL-Cxx00 series (C1000, C3000, C3100).
 
 config LEDS_IXP4XX
         tristate "LED Support for GPIO connected LEDs on IXP4XX processors"
-        depends LEDS_CLASS && ARCH_IXP4XX
+        depends on LEDS_CLASS && ARCH_IXP4XX
         help
           This option enables support for the LEDs connected to GPIO
           outputs of the Intel IXP4XX processors.  To be useful the
@@ -51,7 +51,7 @@ config LEDS_IXP4XX
 
 config LEDS_TOSA
         tristate "LED Support for the Sharp SL-6000 series"
-        depends LEDS_CLASS && PXA_SHARPSL
+        depends on LEDS_CLASS && PXA_SHARPSL
         help
           This option enables support for the LEDs on Sharp Zaurus
           SL-6000 series.
@@ -65,7 +65,7 @@ config LEDS_S3C24XX
 
 config LEDS_AMS_DELTA
         tristate "LED Support for the Amstrad Delta (E3)"
-        depends LEDS_CLASS && MACH_AMS_DELTA
+        depends on LEDS_CLASS && MACH_AMS_DELTA
         help
           This option enables support for the LEDs on Amstrad Delta (E3).
 
@@ -86,7 +86,7 @@ comment "LED Triggers"
 
 config LEDS_TRIGGERS
         bool "LED Trigger support"
-        depends NEW_LEDS
+        depends on NEW_LEDS
         help
           This option enables trigger support for the leds class.
           These triggers allow kernel events to drive the LEDs and can
@@ -94,21 +94,21 @@ config LEDS_TRIGGERS
 
 config LEDS_TRIGGER_TIMER
         tristate "LED Timer Trigger"
-        depends LEDS_TRIGGERS
+        depends on LEDS_TRIGGERS
         help
           This allows LEDs to be controlled by a programmable timer
           via sysfs. If unsure, say Y.
 
 config LEDS_TRIGGER_IDE_DISK
         bool "LED IDE Disk Trigger"
-        depends LEDS_TRIGGERS && BLK_DEV_IDEDISK
+        depends on LEDS_TRIGGERS && BLK_DEV_IDEDISK
         help
           This allows LEDs to be controlled by IDE disk activity.
           If unsure, say Y.
 
 config LEDS_TRIGGER_HEARTBEAT
         tristate "LED Heartbeat Trigger"
-        depends LEDS_TRIGGERS
+        depends on LEDS_TRIGGERS
         help
           This allows LEDs to be controlled by a CPU load average.
           The flash frequency is a hyperbolic function of the 1-minute
diff --git a/drivers/media/video/ov7670.c b/drivers/media/video/ov7670.c
index 89dd18c3c5cc..5ed0adc4ca26 100644
--- a/drivers/media/video/ov7670.c
+++ b/drivers/media/video/ov7670.c
@@ -18,7 +18,7 @@
 #include <linux/i2c.h>
 
 
-MODULE_AUTHOR("Jonathan Corbet <corbet@lwn.net.");
+MODULE_AUTHOR("Jonathan Corbet <corbet@lwn.net>");
 MODULE_DESCRIPTION("A low-level driver for OmniVision ov7670 sensors");
 MODULE_LICENSE("GPL");
 
diff --git a/drivers/net/e100.c b/drivers/net/e100.c
index 03bf164f9e8d..c2ae2a24629b 100644
--- a/drivers/net/e100.c
+++ b/drivers/net/e100.c
@@ -1930,9 +1930,8 @@ static int e100_rx_alloc_list(struct nic *nic)
         nic->rx_to_use = nic->rx_to_clean = NULL;
         nic->ru_running = RU_UNINITIALIZED;
 
-        if(!(nic->rxs = kmalloc(sizeof(struct rx) * count, GFP_ATOMIC)))
+        if(!(nic->rxs = kcalloc(count, sizeof(struct rx), GFP_ATOMIC)))
                 return -ENOMEM;
-        memset(nic->rxs, 0, sizeof(struct rx) * count);
 
         for(rx = nic->rxs, i = 0; i < count; rx++, i++) {
                 rx->next = (i + 1 < count) ? rx + 1 : nic->rxs;
diff --git a/drivers/serial/Kconfig b/drivers/serial/Kconfig
index 0b36dd5cdac2..2978c09860ee 100644
--- a/drivers/serial/Kconfig
+++ b/drivers/serial/Kconfig
@@ -663,7 +663,7 @@ config V850E_UART
 
 config V850E_UARTB
         bool
-        depends V850E_UART && V850E_ME2
+        depends on V850E_UART && V850E_ME2
         default y
 
 config V850E_UART_CONSOLE
@@ -909,7 +909,7 @@ config SERIAL_M32R_PLDSIO
 
 config SERIAL_TXX9
         bool "TMPTX39XX/49XX SIO support"
-        depends HAS_TXX9_SERIAL
+        depends on HAS_TXX9_SERIAL
         select SERIAL_CORE
         default y
 
diff --git a/drivers/serial/icom.c b/drivers/serial/icom.c
index 7d623003e65e..71e6a24d8c28 100644
--- a/drivers/serial/icom.c
+++ b/drivers/serial/icom.c
@@ -1510,7 +1510,7 @@ static int __devinit icom_probe(struct pci_dev *dev,
         }
 
         if ( (retval = pci_request_regions(dev, "icom"))) {
-                 dev_err(&dev->dev, "pci_request_region FAILED\n");
+                 dev_err(&dev->dev, "pci_request_regions FAILED\n");
                  pci_disable_device(dev);
                  return retval;
          }
diff --git a/fs/Kconfig b/fs/Kconfig
index b3b5aa0edff9..276ff3baaafe 100644
--- a/fs/Kconfig
+++ b/fs/Kconfig
@@ -12,9 +12,7 @@ config EXT2_FS
           Ext2 is a standard Linux file system for hard disks.
 
           To compile this file system support as a module, choose M here: the
-          module will be called ext2.  Be aware however that the file system
-          of your root partition (the one containing the directory /) cannot
-          be compiled as a module, and so this could be dangerous.
+          module will be called ext2.
 
           If unsure, say Y.
 
@@ -98,9 +96,7 @@ config EXT3_FS
           (available at <http://sourceforge.net/projects/e2fsprogs/>).
 
           To compile this file system support as a module, choose M here: the
-          module will be called ext3.  Be aware however that the file system
-          of your root partition (the one containing the directory /) cannot
-          be compiled as a module, and so this may be dangerous.
+          module will be called ext3.
 
 config EXT3_FS_XATTR
         bool "Ext3 extended attributes"
@@ -163,9 +159,7 @@ config EXT4DEV_FS
           features will be added to ext4dev gradually.
 
           To compile this file system support as a module, choose M here. The
-          module will be called ext4dev.  Be aware, however, that the filesystem
-          of your root partition (the one containing the directory /) cannot
-          be compiled as a module, and so this could be dangerous.
+          module will be called ext4dev.
 
           If unsure, say N.
 
@@ -1008,7 +1002,7 @@ config TMPFS_POSIX_ACL
 
 config HUGETLBFS
         bool "HugeTLB file system support"
-        depends X86 || IA64 || PPC64 || SPARC64 || SUPERH || BROKEN
+        depends on X86 || IA64 || PPC64 || SPARC64 || SUPERH || BROKEN
         help
           hugetlbfs is a filesystem backing for HugeTLB pages, based on
           ramfs. For architectures that support it, say Y here and read
diff --git a/fs/binfmt_elf_fdpic.c b/fs/binfmt_elf_fdpic.c
index 76f06f6bc2f6..6e6d4568d548 100644
--- a/fs/binfmt_elf_fdpic.c
+++ b/fs/binfmt_elf_fdpic.c
@@ -706,12 +706,11 @@ static int elf_fdpic_map_file(struct elf_fdpic_params *params,
                 return -ELIBBAD;
 
         size = sizeof(*loadmap) + nloads * sizeof(*seg);
-        loadmap = kmalloc(size, GFP_KERNEL);
+        loadmap = kzalloc(size, GFP_KERNEL);
         if (!loadmap)
                 return -ENOMEM;
 
         params->loadmap = loadmap;
-        memset(loadmap, 0, size);
 
         loadmap->version = ELF32_FDPIC_LOADMAP_VERSION;
         loadmap->nsegs = nloads;
diff --git a/include/asm-i386/msr.h b/include/asm-i386/msr.h
index 5679d4993072..609a3899475c 100644
--- a/include/asm-i386/msr.h
+++ b/include/asm-i386/msr.h
@@ -100,6 +100,8 @@ static inline void wrmsrl (unsigned long msr, unsigned long long val)
 
 #define MSR_P6_PERFCTR0         0xc1
 #define MSR_P6_PERFCTR1         0xc2
+#define MSR_FSB_FREQ            0xcd
+
 
 #define MSR_IA32_BBL_CR_CTL             0x119
 
@@ -130,6 +132,9 @@ static inline void wrmsrl (unsigned long msr, unsigned long long val)
 #define MSR_IA32_PERF_STATUS            0x198
 #define MSR_IA32_PERF_CTL               0x199
 
+#define MSR_IA32_MPERF                  0xE7
+#define MSR_IA32_APERF                  0xE8
+
 #define MSR_IA32_THERM_CONTROL          0x19a
 #define MSR_IA32_THERM_INTERRUPT        0x19b
 #define MSR_IA32_THERM_STATUS           0x19c
diff --git a/include/asm-x86_64/msr.h b/include/asm-x86_64/msr.h
index 952783d35c7b..3227bc93d69b 100644
--- a/include/asm-x86_64/msr.h
+++ b/include/asm-x86_64/msr.h
@@ -189,6 +189,7 @@ static inline unsigned int cpuid_edx(unsigned int op)
 
 #define MSR_IA32_PERFCTR0      0xc1
 #define MSR_IA32_PERFCTR1      0xc2
+#define MSR_FSB_FREQ            0xcd
 
 #define MSR_MTRRcap             0x0fe
 #define MSR_IA32_BBL_CR_CTL        0x119
@@ -311,6 +312,9 @@ static inline unsigned int cpuid_edx(unsigned int op)
 #define MSR_IA32_PERF_STATUS            0x198
 #define MSR_IA32_PERF_CTL               0x199
 
+#define MSR_IA32_MPERF                  0xE7
+#define MSR_IA32_APERF                  0xE8
+
 #define MSR_IA32_THERM_CONTROL          0x19a
 #define MSR_IA32_THERM_INTERRUPT        0x19b
 #define MSR_IA32_THERM_STATUS           0x19c
diff --git a/include/linux/compiler.h b/include/linux/compiler.h
index 538423d4a865..aca66984aafd 100644
--- a/include/linux/compiler.h
+++ b/include/linux/compiler.h
@@ -40,7 +40,7 @@ extern void __chk_io_ptr(void __iomem *);
 #error no compiler-gcc.h file for this gcc version
 #elif __GNUC__ == 4
 # include <linux/compiler-gcc4.h>
-#elif __GNUC__ == 3
+#elif __GNUC__ == 3 && __GNUC_MINOR__ >= 2
 # include <linux/compiler-gcc3.h>
 #else
 # error Sorry, your compiler is too old/not recognized.
diff --git a/include/linux/configfs.h b/include/linux/configfs.h
index a7f015027535..fef6f3d0a4a7 100644
--- a/include/linux/configfs.h
+++ b/include/linux/configfs.h
@@ -160,31 +160,6 @@ struct configfs_group_operations {
         void (*drop_item)(struct config_group *group, struct config_item *item);
 };
 
-
-
-/**
- * Use these macros to make defining attributes easier. See include/linux/device.h
- * for examples..
- */
-
-#if 0
-#define __ATTR(_name,_mode,_show,_store) { \
-        .attr = {.ca_name = __stringify(_name), .ca_mode = _mode, .ca_owner = THIS_MODULE },    \
-        .show   = _show,                                        \
-        .store  = _store,                                       \
-}
-
-#define __ATTR_RO(_name) { \
-        .attr   = { .ca_name = __stringify(_name), .ca_mode = 0444, .ca_owner = THIS_MODULE },  \
-        .show   = _name##_show, \
-}
-
-#define __ATTR_NULL { .attr = { .name = NULL } }
-
-#define attr_name(_attr) (_attr).attr.name
-#endif
-
-
 struct configfs_subsystem {
         struct config_group     su_group;
         struct semaphore        su_sem;
diff --git a/include/linux/cpufreq.h b/include/linux/cpufreq.h
index 4ea39fee99c7..7f008f6bfdc3 100644
--- a/include/linux/cpufreq.h
+++ b/include/linux/cpufreq.h
@@ -172,6 +172,8 @@ extern int __cpufreq_driver_target(struct cpufreq_policy *policy,
                                    unsigned int relation);
 
 
+extern int cpufreq_driver_getavg(struct cpufreq_policy *policy);
+
 int cpufreq_register_governor(struct cpufreq_governor *governor);
 void cpufreq_unregister_governor(struct cpufreq_governor *governor);
 
@@ -204,6 +206,7 @@ struct cpufreq_driver {
         unsigned int    (*get)  (unsigned int cpu);
 
         /* optional */
+        unsigned int (*getavg)  (unsigned int cpu);
         int     (*exit)         (struct cpufreq_policy *policy);
         int     (*suspend)      (struct cpufreq_policy *policy, pm_message_t pmsg);
         int     (*resume)       (struct cpufreq_policy *policy);
diff --git a/include/linux/sysctl.h b/include/linux/sysctl.h
index 6d8846e7be6d..81480e613467 100644
--- a/include/linux/sysctl.h
+++ b/include/linux/sysctl.h
@@ -11,7 +11,7 @@
  **  the sysctl() binary interface.  Do *NOT* change the
  **  numbering of any existing values here, and do not change
  **  any numbers within any one set of values.  If you have to
- **  have to redefine an existing interface, use a new number for it.
+ **  redefine an existing interface, use a new number for it.
  **  The kernel will then return -ENOTDIR to any application using
  **  the old binary interface.
  **
diff --git a/init/Kconfig b/init/Kconfig
index 9edf103b3ec3..f000edb3bb7a 100644
--- a/init/Kconfig
+++ b/init/Kconfig
@@ -348,7 +348,7 @@ config SYSCTL_SYSCALL
           If unsure say Y here.
 
 config KALLSYMS
-         bool "Load all symbols for debugging/kksymoops" if EMBEDDED
+         bool "Load all symbols for debugging/ksymoops" if EMBEDDED
          default y
          help
            Say Y here to let the kernel print out symbolic crash information and
diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug
index 0701ddda1df8..818e4589f718 100644
--- a/lib/Kconfig.debug
+++ b/lib/Kconfig.debug
@@ -437,7 +437,7 @@ config FAIL_PAGE_ALLOC
           Provide fault-injection capability for alloc_pages().
 
 config FAIL_MAKE_REQUEST
-        bool "Fault-injection capabilitiy for disk IO"
+        bool "Fault-injection capability for disk IO"
         depends on FAULT_INJECTION
         help
           Provide fault-injection capability for disk IO.
diff --git a/net/ipv4/ip_fragment.c b/net/ipv4/ip_fragment.c
index 74046efdf875..8ce00d3703da 100644
--- a/net/ipv4/ip_fragment.c
+++ b/net/ipv4/ip_fragment.c
@@ -565,7 +565,7 @@ static void ip_frag_queue(struct ipq *qp, struct sk_buff *skb)
                 } else {
                         struct sk_buff *free_it = next;
 
-                        /* Old fragmnet is completely overridden with
+                        /* Old fragment is completely overridden with
                          * new one drop it.
                          */
                         next = next->next;
diff --git a/sound/aoa/fabrics/Kconfig b/sound/aoa/fabrics/Kconfig
index c3bc7705c86a..50d7021ff677 100644
--- a/sound/aoa/fabrics/Kconfig
+++ b/sound/aoa/fabrics/Kconfig
@@ -1,6 +1,6 @@
 config SND_AOA_FABRIC_LAYOUT
         tristate "layout-id fabric"
-        depends SND_AOA
+        depends on SND_AOA
         select SND_AOA_SOUNDBUS
         select SND_AOA_SOUNDBUS_I2S
         ---help---