Merge tag 'pm+acpi-3.10-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm

Pull power management and ACPI updates from Rafael J Wysocki:

 - ARM big.LITTLE cpufreq driver from Viresh Kumar.

 - exynos5440 cpufreq driver from Amit Daniel Kachhap.

 - cpufreq core cleanup and code consolidation from Viresh Kumar and
   Stratos Karafotis.

 - cpufreq scalability improvement from Nathan Zimmer.

 - AMD "frequency sensitivity feedback" powersave bias for the ondemand
   cpufreq governor from Jacob Shin.

 - cpuidle code consolidation and cleanups from Daniel Lezcano.

 - ARM OMAP cpuidle fixes from Santosh Shilimkar and Daniel Lezcano.

 - ACPICA fixes and other improvements from Bob Moore, Jung-uk Kim, Lv
   Zheng, Yinghai Lu, Tang Chen, Colin Ian King, and Linn Crosetto.

 - ACPI core updates related to hotplug from Toshi Kani, Paul Bolle,
   Yasuaki Ishimatsu, and Rafael J Wysocki.

 - Intel Lynxpoint LPSS (Low-Power Subsystem) support improvements from
   Rafael J Wysocki and Andy Shevchenko.

* tag 'pm+acpi-3.10-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm: (192 commits)
  cpufreq: Revert incorrect commit 5800043
  cpufreq: MAINTAINERS: Add co-maintainer
  cpuidle: add maintainer entry
  ACPI / thermal: do not always return THERMAL_TREND_RAISING for active trip points
  ARM: s3c64xx: cpuidle: use init/exit common routine
  cpufreq: pxa2xx: initialize variables
  ACPI: video: correct acpi_video_bus_add error processing
  SH: cpuidle: use init/exit common routine
  ARM: S5pv210: compiling issue, ARM_S5PV210_CPUFREQ needs CONFIG_CPU_FREQ_TABLE=y
  ACPI: Fix wrong parameter passed to memblock_reserve
  cpuidle: fix comment format
  pnp: use %*phC to dump small buffers
  isapnp: remove debug leftovers
  ARM: imx: cpuidle: use init/exit common routine
  ARM: davinci: cpuidle: use init/exit common routine
  ARM: kirkwood: cpuidle: use init/exit common routine
  ARM: calxeda: cpuidle: use init/exit common routine
  ARM: tegra: cpuidle: use init/exit common routine for tegra3
  ARM: tegra: cpuidle: use init/exit common routine for tegra2
  ARM: OMAP4: cpuidle: use init/exit common routine
  ...

1 files changed, 220 insertions, 0 deletions

diff --git a/drivers/cpufreq/integrator-cpufreq.c b/drivers/cpufreq/integrator-cpufreq.c
new file mode 100644
index 000000000000..f7c99df0880b
--- /dev/null
+++ b/drivers/cpufreq/integrator-cpufreq.c
@@ -0,0 +1,220 @@
+/*
+ *  Copyright (C) 2001-2002 Deep Blue Solutions Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * CPU support functions
+ */
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/cpufreq.h>
+#include <linux/sched.h>
+#include <linux/smp.h>
+#include <linux/init.h>
+#include <linux/io.h>
+
+#include <mach/hardware.h>
+#include <mach/platform.h>
+#include <asm/mach-types.h>
+#include <asm/hardware/icst.h>
+
+static struct cpufreq_driver integrator_driver;
+
+#define CM_ID   __io_address(INTEGRATOR_HDR_ID)
+#define CM_OSC  __io_address(INTEGRATOR_HDR_OSC)
+#define CM_STAT __io_address(INTEGRATOR_HDR_STAT)
+#define CM_LOCK __io_address(INTEGRATOR_HDR_LOCK)
+
+static const struct icst_params lclk_params = {
+        .ref            = 24000000,
+        .vco_max        = ICST525_VCO_MAX_5V,
+        .vco_min        = ICST525_VCO_MIN,
+        .vd_min         = 8,
+        .vd_max         = 132,
+        .rd_min         = 24,
+        .rd_max         = 24,
+        .s2div          = icst525_s2div,
+        .idx2s          = icst525_idx2s,
+};
+
+static const struct icst_params cclk_params = {
+        .ref            = 24000000,
+        .vco_max        = ICST525_VCO_MAX_5V,
+        .vco_min        = ICST525_VCO_MIN,
+        .vd_min         = 12,
+        .vd_max         = 160,
+        .rd_min         = 24,
+        .rd_max         = 24,
+        .s2div          = icst525_s2div,
+        .idx2s          = icst525_idx2s,
+};
+
+/*
+ * Validate the speed policy.
+ */
+static int integrator_verify_policy(struct cpufreq_policy *policy)
+{
+        struct icst_vco vco;
+
+        cpufreq_verify_within_limits(policy, 
+                                     policy->cpuinfo.min_freq, 
+                                     policy->cpuinfo.max_freq);
+
+        vco = icst_hz_to_vco(&cclk_params, policy->max * 1000);
+        policy->max = icst_hz(&cclk_params, vco) / 1000;
+
+        vco = icst_hz_to_vco(&cclk_params, policy->min * 1000);
+        policy->min = icst_hz(&cclk_params, vco) / 1000;
+
+        cpufreq_verify_within_limits(policy, 
+                                     policy->cpuinfo.min_freq, 
+                                     policy->cpuinfo.max_freq);
+
+        return 0;
+}
+
+
+static int integrator_set_target(struct cpufreq_policy *policy,
+                                 unsigned int target_freq,
+                                 unsigned int relation)
+{
+        cpumask_t cpus_allowed;
+        int cpu = policy->cpu;
+        struct icst_vco vco;
+        struct cpufreq_freqs freqs;
+        u_int cm_osc;
+
+        /*
+         * Save this threads cpus_allowed mask.
+         */
+        cpus_allowed = current->cpus_allowed;
+
+        /*
+         * Bind to the specified CPU.  When this call returns,
+         * we should be running on the right CPU.
+         */
+        set_cpus_allowed(current, cpumask_of_cpu(cpu));
+        BUG_ON(cpu != smp_processor_id());
+
+        /* get current setting */
+        cm_osc = __raw_readl(CM_OSC);
+
+        if (machine_is_integrator()) {
+                vco.s = (cm_osc >> 8) & 7;
+        } else if (machine_is_cintegrator()) {
+                vco.s = 1;
+        }
+        vco.v = cm_osc & 255;
+        vco.r = 22;
+        freqs.old = icst_hz(&cclk_params, vco) / 1000;
+
+        /* icst_hz_to_vco rounds down -- so we need the next
+         * larger freq in case of CPUFREQ_RELATION_L.
+         */
+        if (relation == CPUFREQ_RELATION_L)
+                target_freq += 999;
+        if (target_freq > policy->max)
+                target_freq = policy->max;
+        vco = icst_hz_to_vco(&cclk_params, target_freq * 1000);
+        freqs.new = icst_hz(&cclk_params, vco) / 1000;
+
+        if (freqs.old == freqs.new) {
+                set_cpus_allowed(current, cpus_allowed);
+                return 0;
+        }
+
+        cpufreq_notify_transition(policy, &freqs, CPUFREQ_PRECHANGE);
+
+        cm_osc = __raw_readl(CM_OSC);
+
+        if (machine_is_integrator()) {
+                cm_osc &= 0xfffff800;
+                cm_osc |= vco.s << 8;
+        } else if (machine_is_cintegrator()) {
+                cm_osc &= 0xffffff00;
+        }
+        cm_osc |= vco.v;
+
+        __raw_writel(0xa05f, CM_LOCK);
+        __raw_writel(cm_osc, CM_OSC);
+        __raw_writel(0, CM_LOCK);
+
+        /*
+         * Restore the CPUs allowed mask.
+         */
+        set_cpus_allowed(current, cpus_allowed);
+
+        cpufreq_notify_transition(policy, &freqs, CPUFREQ_POSTCHANGE);
+
+        return 0;
+}
+
+static unsigned int integrator_get(unsigned int cpu)
+{
+        cpumask_t cpus_allowed;
+        unsigned int current_freq;
+        u_int cm_osc;
+        struct icst_vco vco;
+
+        cpus_allowed = current->cpus_allowed;
+
+        set_cpus_allowed(current, cpumask_of_cpu(cpu));
+        BUG_ON(cpu != smp_processor_id());
+
+        /* detect memory etc. */
+        cm_osc = __raw_readl(CM_OSC);
+
+        if (machine_is_integrator()) {
+                vco.s = (cm_osc >> 8) & 7;
+        } else {
+                vco.s = 1;
+        }
+        vco.v = cm_osc & 255;
+        vco.r = 22;
+
+        current_freq = icst_hz(&cclk_params, vco) / 1000; /* current freq */
+
+        set_cpus_allowed(current, cpus_allowed);
+
+        return current_freq;
+}
+
+static int integrator_cpufreq_init(struct cpufreq_policy *policy)
+{
+
+        /* set default policy and cpuinfo */
+        policy->cpuinfo.max_freq = 160000;
+        policy->cpuinfo.min_freq = 12000;
+        policy->cpuinfo.transition_latency = 1000000; /* 1 ms, assumed */
+        policy->cur = policy->min = policy->max = integrator_get(policy->cpu);
+
+        return 0;
+}
+
+static struct cpufreq_driver integrator_driver = {
+        .verify         = integrator_verify_policy,
+        .target         = integrator_set_target,
+        .get            = integrator_get,
+        .init           = integrator_cpufreq_init,
+        .name           = "integrator",
+};
+
+static int __init integrator_cpu_init(void)
+{
+        return cpufreq_register_driver(&integrator_driver);
+}
+
+static void __exit integrator_cpu_exit(void)
+{
+        cpufreq_unregister_driver(&integrator_driver);
+}
+
+MODULE_AUTHOR ("Russell M. King");
+MODULE_DESCRIPTION ("cpufreq driver for ARM Integrator CPUs");
+MODULE_LICENSE ("GPL");
+
+module_init(integrator_cpu_init);
+module_exit(integrator_cpu_exit);