linux-omap 2.6.39: add cpufreq support and tweak beagleboard expansionboard patches

make it the default for beagleboard

Signed-off-by: Koen Kooi <koen@dominion.thruhere.net>

8 files changed, 1254 insertions, 0 deletions

diff --git a/recipes-kernel/linux/linux-omap-2.6.39/pm/linux-omap-2.6.39-ti-pm-wip-cpufreq/0044-OMAP-CPUfreq-ensure-driver-initializes-after-cpufreq.patch b/recipes-kernel/linux/linux-omap-2.6.39/pm/linux-omap-2.6.39-ti-pm-wip-cpufreq/0044-OMAP-CPUfreq-ensure-driver-initializes-after-cpufreq.patch
new file mode 100644
index 00000000..a8da2573
--- /dev/null
+++ b/recipes-kernel/linux/linux-omap-2.6.39/pm/linux-omap-2.6.39-ti-pm-wip-cpufreq/0044-OMAP-CPUfreq-ensure-driver-initializes-after-cpufreq.patch
@@ -0,0 +1,27 @@
+From 48ec8ab4a64104f7ecc9dabb9e23e2c3d0d1feee Mon Sep 17 00:00:00 2001
+From: Peter 'p2' De Schrijver <peter.de-schrijver@nokia.com>
+Date: Wed, 11 Aug 2010 17:02:43 -0700
+Subject: [PATCH 44/59] OMAP: CPUfreq: ensure driver initializes after cpufreq framework and governors
+
+Signed-off-by: Peter 'p2' De Schrijver <peter.de-schrijver@nokia.com>
+Signed-off-by: Kevin Hilman <khilman@deeprootsystems.com>
+---
+ arch/arm/plat-omap/cpu-omap.c |    2 +-
+ 1 files changed, 1 insertions(+), 1 deletions(-)
+
+diff --git a/arch/arm/plat-omap/cpu-omap.c b/arch/arm/plat-omap/cpu-omap.c
+index da4f68d..cd09d4b 100644
+--- a/arch/arm/plat-omap/cpu-omap.c
++++ b/arch/arm/plat-omap/cpu-omap.c
+@@ -160,7 +160,7 @@ static int __init omap_cpufreq_init(void)
+        return cpufreq_register_driver(&omap_driver);
+ }
+ 
+-arch_initcall(omap_cpufreq_init);
++late_initcall(omap_cpufreq_init);
+ 
+ /*
+  * if ever we want to remove this, upon cleanup call:
+-- 
+1.6.6.1
+
diff --git a/recipes-kernel/linux/linux-omap-2.6.39/pm/linux-omap-2.6.39-ti-pm-wip-cpufreq/0045-OMAP-CPUfreq-ensure-policy-is-fully-initialized.patch b/recipes-kernel/linux/linux-omap-2.6.39/pm/linux-omap-2.6.39-ti-pm-wip-cpufreq/0045-OMAP-CPUfreq-ensure-policy-is-fully-initialized.patch
new file mode 100644
index 00000000..132aeec6
--- /dev/null
+++ b/recipes-kernel/linux/linux-omap-2.6.39/pm/linux-omap-2.6.39-ti-pm-wip-cpufreq/0045-OMAP-CPUfreq-ensure-policy-is-fully-initialized.patch
@@ -0,0 +1,31 @@
+From 56cee7bf023af728c952f692f4c24822392882a1 Mon Sep 17 00:00:00 2001
+From: Kevin Hilman <khilman@deeprootsystems.com>
+Date: Wed, 11 Aug 2010 17:05:38 -0700
+Subject: [PATCH 45/59] OMAP: CPUfreq: ensure policy is fully initialized
+
+Ensure policy min/max/cur values are initialized when OMAP
+CPUfreq driver starts.
+
+Signed-off-by: Kevin Hilman <khilman@deeprootsystems.com>
+---
+ arch/arm/plat-omap/cpu-omap.c |    4 ++++
+ 1 files changed, 4 insertions(+), 0 deletions(-)
+
+diff --git a/arch/arm/plat-omap/cpu-omap.c b/arch/arm/plat-omap/cpu-omap.c
+index cd09d4b..1b36664 100644
+--- a/arch/arm/plat-omap/cpu-omap.c
++++ b/arch/arm/plat-omap/cpu-omap.c
+@@ -126,6 +126,10 @@ static int __cpuinit omap_cpu_init(struct cpufreq_policy *policy)
+                                                        VERY_HI_RATE) / 1000;
+        }
+ 
++       policy->min = policy->cpuinfo.min_freq;
++       policy->max = policy->cpuinfo.max_freq;
++       policy->cur = omap_getspeed(0);
++
+        /* FIXME: what's the actual transition time? */
+        policy->cpuinfo.transition_latency = 300 * 1000;
+ 
+-- 
+1.6.6.1
+
diff --git a/recipes-kernel/linux/linux-omap-2.6.39/pm/linux-omap-2.6.39-ti-pm-wip-cpufreq/0046-OMAP3-PM-CPUFreq-driver-for-OMAP3.patch b/recipes-kernel/linux/linux-omap-2.6.39/pm/linux-omap-2.6.39-ti-pm-wip-cpufreq/0046-OMAP3-PM-CPUFreq-driver-for-OMAP3.patch
new file mode 100644
index 00000000..371ad292
--- /dev/null
+++ b/recipes-kernel/linux/linux-omap-2.6.39/pm/linux-omap-2.6.39-ti-pm-wip-cpufreq/0046-OMAP3-PM-CPUFreq-driver-for-OMAP3.patch
@@ -0,0 +1,263 @@
+From a5072bdf333b8fb1080aac5d2b986553ea8de0f9 Mon Sep 17 00:00:00 2001
+From: Rajendra Nayak <rnayak@ti.com>
+Date: Mon, 10 Nov 2008 17:00:25 +0530
+Subject: [PATCH 46/59] OMAP3 PM: CPUFreq driver for OMAP3
+
+CPUFreq driver for OMAP3
+
+With additional fixes and cleanups from Tero Kristo:
+- Fix rate calculation bug in omap3_select_table_rate
+- Refreshed DVFS VDD1 control against latest clock fw
+
+Signed-off-by: Tero Kristo <tero.kristo@nokia.com>
+Signed-off-by: Rajendra Nayak <rnayak@ti.com>
+
+OMAP3: PM: CPUFreq: Fix omap_getspeed.
+
+Signed-off-by: Peter 'p2' De Schrijver <peter.de-schrijver@nokia.com>
+
+Make sure omap cpufreq driver initializes after cpufreq framework and governors
+
+Signed-off-by: Peter 'p2' De Schrijver <peter.de-schrijver@nokia.com>
+
+merge: CPUFreq: remove obsolete funcs
+
+OMAP3 clock: Update cpufreq driver
+
+This patch removes all refrences to virtual clock
+nodes in CPUFreq driver.
+
+Signed-off-by: Rajendra Nayak <rnayak@ti.com>
+Signed-off-by: Tero Kristo <tero.kristo@nokia.com>
+Signed-off-by: Jean Pihet <jpihet@mvista.com>
+
+PM: Prevent direct cpufreq scaling during initialization
+
+It is seen that the OMAP specific cpufreq initialization code tries to
+scale the MPU frequency to the highest possible without taking care of
+the voltage level. On power on reset the power IC does not provide the
+necessary voltage for the highest available MPU frequency (that would
+satisfy all Si families). This potentially is an window of opportunity
+for things to go wrong.
+
+Signed-off-by: Romit Dasgupta <romit@ti.com>
+Signed-off-by: Kevin Hilman <khilman@deeprootsystems.com>
+
+OMAP3: PM: enable 600MHz (overdrive) OPP
+
+Signed-off-by: Kevin Hilman <khilman@deeprootsystems.com>
+
+omap3: introduce cpufreq
+
+OMAP OPP layer functions now have dependencies of CONFIG_CPU_FREQ only.
+
+With this patch, omap opp layer now has its compilation flags
+bound to CONFIG_CPU_FREQ. Also its code has been removed from pm34xx.c.
+
+A new file has been created to contain cpu freq code related to
+OMAP3: cpufreq34xx.c
+
+OMAP34xx and OMAP36xx family OPPs are made available
+
+Signed-off-by: Eduardo Valentin <eduardo.valentin@nokia.com>
+Signed-off-by: Paul Walmsley <paul@pwsan.com>
+Signed-off-by: Nishanth Menon <nm@ti.com>
+Signed-off-by: Vishwanath BS <vishwanath.bs@ti.com>
+Signed-off-by: Kevin Hilman <khilman@deeprootsystems.com>
+Signed-off-by: Romit Dasgupta <romit@ti.com>
+Signed-off-by: Rajendra Nayak <rnayak@ti.com>
+
+omap3: cpufreq: allow default opp table init
+
+For board files which choose to override the defaults, the existing
+mechanism will work, for boards that would like to work with defaults,
+allow init_common_hw to call init_opp_table to initialize if not
+already initialized. this will allow all omap boards which have opp
+tables predefined for a silicon to use the same.
+
+Originally reported for overo:
+http://marc.info/?t=127265269400004&r=1&w=2
+
+Signed-off-by: Nishanth Menon <nm@ti.com>
+Reported-by: Peter Tseng <tsenpet09@gmail.com>
+Cc: Cliff Brake <cliff.brake@gmail.com>
+Cc: Kevin Hilman <khilman@deeprootsystems.com>
+
+OMAP2: update OPP data to be device based
+
+Cc: Nishanth Menon <nm@ti.com>
+Signed-off-by: Kevin Hilman <khilman@deeprootsystems.com>
+
+OMAP3: CPUfreq: update to device-based OPP API
+
+Update usage of OPP API to use new device-based API.  This requires
+getting the 'struct device' for the MPU and using that with the OPP
+API.
+
+Signed-off-by: Kevin Hilman <khilman@deeprootsystems.com>
+
+omap3: opp: make independent of cpufreq
+
+Make opp3xx data which is registered with the opp layer
+dependent purely on CONFIG_PM as opp layer and pm.c users
+are CONFIG_PM dependent not cpufreq dependent.
+so we rename the data definition to opp3xxx_data.c (inline with what
+we have for omap2), also move the build definition to be under
+the existing CONFIG_PM build instead of CPUFREQ.
+
+Cc: Eduardo Valentin <eduardo.valentin@nokia.com>
+Cc: Kevin Hilman <khilman@deeprootsystems.com>
+Cc: Paul Walmsley <paul@pwsan.com>
+Cc: Rajendra Nayak <rnayak@ti.com>
+Cc: Sanjeev Premi <premi@ti.com>
+Cc: Thara Gopinath <thara@ti.com>
+Cc: Tony Lindgren <tony@atomide.com>
+
+Signed-off-by: Nishanth Menon <nm@ti.com>
+---
+ arch/arm/mach-omap2/clock.h     |   14 +++++++++++++-
+ arch/arm/mach-omap2/clock34xx.c |    2 ++
+ arch/arm/plat-omap/cpu-omap.c   |   34 +++++++++++++++++++++++++++++++---
+ 3 files changed, 46 insertions(+), 4 deletions(-)
+
+diff --git a/arch/arm/mach-omap2/clock.h b/arch/arm/mach-omap2/clock.h
+index e10ff2b..0a07e50 100644
+--- a/arch/arm/mach-omap2/clock.h
++++ b/arch/arm/mach-omap2/clock.h
+@@ -141,7 +141,9 @@ extern const struct clksel_rate gpt_sys_rates[];
+ extern const struct clksel_rate gfx_l3_rates[];
+ extern const struct clksel_rate dsp_ick_rates[];
+ 
+-#if defined(CONFIG_ARCH_OMAP2) && defined(CONFIG_CPU_FREQ)
++#ifdef CONFIG_CPU_FREQ
++
++#ifdef CONFIG_ARCH_OMAP2
+ extern void omap2_clk_init_cpufreq_table(struct cpufreq_frequency_table **table);
+ extern void omap2_clk_exit_cpufreq_table(struct cpufreq_frequency_table **table);
+ #else
+@@ -149,6 +151,16 @@ extern void omap2_clk_exit_cpufreq_table(struct cpufreq_frequency_table **table)
+ #define omap2_clk_exit_cpufreq_table   0
+ #endif
+ 
++#ifdef CONFIG_ARCH_OMAP3
++extern void omap3_clk_init_cpufreq_table(struct cpufreq_frequency_table **table);
++extern void omap3_clk_exit_cpufreq_table(struct cpufreq_frequency_table **table);
++#else
++#define omap3_clk_init_cpufreq_table   0
++#define omap3_clk_exit_cpufreq_table   0
++#endif
++
++#endif /* CONFIG_CPU_FREQ */
++
+ extern const struct clkops clkops_omap2_iclk_dflt_wait;
+ extern const struct clkops clkops_omap2_iclk_dflt;
+ extern const struct clkops clkops_omap2_iclk_idle_only;
+diff --git a/arch/arm/mach-omap2/clock34xx.c b/arch/arm/mach-omap2/clock34xx.c
+index 1fc96b9..119e135 100644
+--- a/arch/arm/mach-omap2/clock34xx.c
++++ b/arch/arm/mach-omap2/clock34xx.c
+@@ -20,6 +20,8 @@
+ #include <linux/kernel.h>
+ #include <linux/clk.h>
+ #include <linux/io.h>
++#include <linux/err.h>
++#include <linux/cpufreq.h>
+ 
+ #include <plat/clock.h>
+ 
+diff --git a/arch/arm/plat-omap/cpu-omap.c b/arch/arm/plat-omap/cpu-omap.c
+index 1b36664..f0f9430 100644
+--- a/arch/arm/plat-omap/cpu-omap.c
++++ b/arch/arm/plat-omap/cpu-omap.c
+@@ -8,6 +8,10 @@
+  *
+  *  Based on cpu-sa1110.c, Copyright (C) 2001 Russell King
+  *
++ * Copyright (C) 2007-2008 Texas Instruments, Inc.
++ * Updated to support OMAP3
++ * Rajendra Nayak <rnayak@ti.com>
++ *
+  * 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.
+@@ -26,12 +30,19 @@
+ #include <plat/clock.h>
+ #include <asm/system.h>
+ 
++#if defined(CONFIG_ARCH_OMAP3) && !defined(CONFIG_OMAP_PM_NONE)
++#include <plat/omap-pm.h>
++#include <plat/opp.h>
++#endif
++
+ #define VERY_HI_RATE   900000000
+ 
+ static struct cpufreq_frequency_table *freq_table;
+ 
+ #ifdef CONFIG_ARCH_OMAP1
+ #define MPU_CLK                "mpu"
++#elif CONFIG_ARCH_OMAP3
++#define MPU_CLK                "arm_fck"
+ #else
+ #define MPU_CLK                "virt_prcm_set"
+ #endif
+@@ -73,7 +84,13 @@ static int omap_target(struct cpufreq_policy *policy,
+                       unsigned int target_freq,
+                       unsigned int relation)
+ {
++#ifdef CONFIG_ARCH_OMAP1
+        struct cpufreq_freqs freqs;
++#endif
++#if defined(CONFIG_ARCH_OMAP3) && !defined(CONFIG_OMAP_PM_NONE)
++       unsigned long freq;
++       struct device *mpu_dev = omap2_get_mpuss_device();
++#endif
+        int ret = 0;
+ 
+        /* Ensure desired rate is within allowed range.  Some govenors
+@@ -83,13 +100,13 @@ static int omap_target(struct cpufreq_policy *policy,
+        if (target_freq > policy->max)
+                target_freq = policy->max;
+ 
++#ifdef CONFIG_ARCH_OMAP1
+        freqs.old = omap_getspeed(0);
+        freqs.new = clk_round_rate(mpu_clk, target_freq * 1000) / 1000;
+        freqs.cpu = 0;
+ 
+        if (freqs.old == freqs.new)
+                return ret;
+-
+        cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
+ #ifdef CONFIG_CPU_FREQ_DEBUG
+        printk(KERN_DEBUG "cpufreq-omap: transition: %u --> %u\n",
+@@ -97,7 +114,11 @@ static int omap_target(struct cpufreq_policy *policy,
+ #endif
+        ret = clk_set_rate(mpu_clk, freqs.new * 1000);
+        cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
+-
++#elif defined(CONFIG_ARCH_OMAP3) && !defined(CONFIG_OMAP_PM_NONE)
++       freq = target_freq * 1000;
++       if (opp_find_freq_ceil(mpu_dev, &freq))
++               omap_pm_cpu_set_freq(freq);
++#endif
+        return ret;
+ }
+ 
+@@ -114,7 +135,14 @@ static int __cpuinit omap_cpu_init(struct cpufreq_policy *policy)
+ 
+        policy->cur = policy->min = policy->max = omap_getspeed(0);
+ 
+-       clk_init_cpufreq_table(&freq_table);
++       if (!cpu_is_omap34xx()) {
++               clk_init_cpufreq_table(&freq_table);
++       } else {
++               struct device *mpu_dev = omap2_get_mpuss_device();
++
++               opp_init_cpufreq_table(mpu_dev, &freq_table);
++       }
++
+        if (freq_table) {
+                result = cpufreq_frequency_table_cpuinfo(policy, freq_table);
+                if (!result)
+-- 
+1.6.6.1
+
diff --git a/recipes-kernel/linux/linux-omap-2.6.39/pm/linux-omap-2.6.39-ti-pm-wip-cpufreq/0047-OMAP-PM-CPUFREQ-Fix-conditional-compilation.patch b/recipes-kernel/linux/linux-omap-2.6.39/pm/linux-omap-2.6.39-ti-pm-wip-cpufreq/0047-OMAP-PM-CPUFREQ-Fix-conditional-compilation.patch
new file mode 100644
index 00000000..5d7b02ab
--- /dev/null
+++ b/recipes-kernel/linux/linux-omap-2.6.39/pm/linux-omap-2.6.39-ti-pm-wip-cpufreq/0047-OMAP-PM-CPUFREQ-Fix-conditional-compilation.patch
@@ -0,0 +1,32 @@
+From 4b4c71142858947f540b337873caf5c1436b4d73 Mon Sep 17 00:00:00 2001
+From: Silesh C V <silesh@ti.com>
+Date: Wed, 29 Sep 2010 14:52:54 +0530
+Subject: [PATCH 47/59] OMAP: PM: CPUFREQ: Fix conditional compilation
+
+Fix conditional compilation. A conditional expresiion
+should follow "#elif", in this case #elif clause should
+check whether CONFIG_ARCH_OMAP3 is defined or not
+(ie. defined(CONFIG_ARCH_OMAP3)) rather than checking for
+the value of the macro.
+
+Signed-off-by: Silesh C V <silesh@ti.com>
+---
+ arch/arm/plat-omap/cpu-omap.c |    2 +-
+ 1 files changed, 1 insertions(+), 1 deletions(-)
+
+diff --git a/arch/arm/plat-omap/cpu-omap.c b/arch/arm/plat-omap/cpu-omap.c
+index f0f9430..c3ac065 100644
+--- a/arch/arm/plat-omap/cpu-omap.c
++++ b/arch/arm/plat-omap/cpu-omap.c
+@@ -41,7 +41,7 @@ static struct cpufreq_frequency_table *freq_table;
+ 
+ #ifdef CONFIG_ARCH_OMAP1
+ #define MPU_CLK                "mpu"
+-#elif CONFIG_ARCH_OMAP3
++#elif defined(CONFIG_ARCH_OMAP3)
+ #define MPU_CLK                "arm_fck"
+ #else
+ #define MPU_CLK                "virt_prcm_set"
+-- 
+1.6.6.1
+
diff --git a/recipes-kernel/linux/linux-omap-2.6.39/pm/linux-omap-2.6.39-ti-pm-wip-cpufreq/0048-cpufreq-fixup-after-new-OPP-layer-merged.patch b/recipes-kernel/linux/linux-omap-2.6.39/pm/linux-omap-2.6.39-ti-pm-wip-cpufreq/0048-cpufreq-fixup-after-new-OPP-layer-merged.patch
new file mode 100644
index 00000000..4bbaeedf
--- /dev/null
+++ b/recipes-kernel/linux/linux-omap-2.6.39/pm/linux-omap-2.6.39-ti-pm-wip-cpufreq/0048-cpufreq-fixup-after-new-OPP-layer-merged.patch
@@ -0,0 +1,33 @@
+From 6dac35adbd97f167ddbf26fd1bcea66d1e8a6c6f Mon Sep 17 00:00:00 2001
+From: Kevin Hilman <khilman@deeprootsystems.com>
+Date: Tue, 16 Nov 2010 11:48:41 -0800
+Subject: [PATCH 48/59] cpufreq: fixup after new OPP layer merged
+
+---
+ arch/arm/plat-omap/cpu-omap.c |    3 ++-
+ 1 files changed, 2 insertions(+), 1 deletions(-)
+
+diff --git a/arch/arm/plat-omap/cpu-omap.c b/arch/arm/plat-omap/cpu-omap.c
+index c3ac065..9cd2709 100644
+--- a/arch/arm/plat-omap/cpu-omap.c
++++ b/arch/arm/plat-omap/cpu-omap.c
+@@ -25,6 +25,7 @@
+ #include <linux/err.h>
+ #include <linux/clk.h>
+ #include <linux/io.h>
++#include <linux/opp.h>
+ 
+ #include <mach/hardware.h>
+ #include <plat/clock.h>
+@@ -32,7 +33,7 @@
+ 
+ #if defined(CONFIG_ARCH_OMAP3) && !defined(CONFIG_OMAP_PM_NONE)
+ #include <plat/omap-pm.h>
+-#include <plat/opp.h>
++#include <plat/common.h>
+ #endif
+ 
+ #define VERY_HI_RATE   900000000
+-- 
+1.6.6.1
+
diff --git a/recipes-kernel/linux/linux-omap-2.6.39/pm/linux-omap-2.6.39-ti-pm-wip-cpufreq/0049-OMAP-cpufreq-Split-OMAP1-and-OMAP2PLUS-CPUfreq-drive.patch b/recipes-kernel/linux/linux-omap-2.6.39/pm/linux-omap-2.6.39-ti-pm-wip-cpufreq/0049-OMAP-cpufreq-Split-OMAP1-and-OMAP2PLUS-CPUfreq-drive.patch
new file mode 100644
index 00000000..9fedb6c0
--- /dev/null
+++ b/recipes-kernel/linux/linux-omap-2.6.39/pm/linux-omap-2.6.39-ti-pm-wip-cpufreq/0049-OMAP-cpufreq-Split-OMAP1-and-OMAP2PLUS-CPUfreq-drive.patch
@@ -0,0 +1,669 @@
+From 989bfeaacfc9eb39762aefbfb5f25ecbd05892cc Mon Sep 17 00:00:00 2001
+From: Santosh Shilimkar <santosh.shilimkar@ti.com>
+Date: Mon, 14 Mar 2011 17:08:48 +0530
+Subject: [PATCH 49/59] OMAP: cpufreq: Split OMAP1 and OMAP2PLUS CPUfreq drivers.
+
+This patch is an attempt to cleanup the #ifdeferry in the
+omap CPUfreq drivers.
+
+The split betwenn OMAP1 and OMAP2PLUS is logical because
+        - OMAP1 doesn't support opp layer.
+        - OMAP1 build is seperate from omap2plus.
+
+Signed-off-by: Santosh Shilimkar <santosh.shilimkar@ti.com>
+Cc: Kevin Hilman <khilman@ti.com>
+Cc: Vishwanath BS <vishwanath.bs@ti.com>
+---
+ arch/arm/mach-omap1/Makefile            |    3 +
+ arch/arm/mach-omap1/omap1-cpufreq.c     |  176 ++++++++++++++++++++++++++
+ arch/arm/mach-omap2/Makefile            |    3 +
+ arch/arm/mach-omap2/omap2plus-cpufreq.c |  201 ++++++++++++++++++++++++++++++
+ arch/arm/plat-omap/Makefile             |    1 -
+ arch/arm/plat-omap/cpu-omap.c           |  204 -------------------------------
+ 6 files changed, 383 insertions(+), 205 deletions(-)
+ create mode 100644 arch/arm/mach-omap1/omap1-cpufreq.c
+ create mode 100644 arch/arm/mach-omap2/omap2plus-cpufreq.c
+ delete mode 100644 arch/arm/plat-omap/cpu-omap.c
+
+diff --git a/arch/arm/mach-omap1/Makefile b/arch/arm/mach-omap1/Makefile
+index af98117..e5082b0 100644
+--- a/arch/arm/mach-omap1/Makefile
++++ b/arch/arm/mach-omap1/Makefile
+@@ -10,6 +10,9 @@ obj-$(CONFIG_OMAP_MCBSP) += mcbsp.o
+ 
+ obj-$(CONFIG_OMAP_32K_TIMER)   += timer32k.o
+ 
++# CPUFREQ driver
++obj-$(CONFIG_CPU_FREQ) += omap1-cpufreq.o
++
+ # Power Management
+ obj-$(CONFIG_PM) += pm.o sleep.o pm_bus.o
+ 
+diff --git a/arch/arm/mach-omap1/omap1-cpufreq.c b/arch/arm/mach-omap1/omap1-cpufreq.c
+new file mode 100644
+index 0000000..682cdc8
+--- /dev/null
++++ b/arch/arm/mach-omap1/omap1-cpufreq.c
+@@ -0,0 +1,176 @@
++/*
++ *  OMAP1 cpufreq driver
++ *
++ *  CPU frequency scaling for OMAP
++ *
++ *  Copyright (C) 2005 Nokia Corporation
++ *  Written by Tony Lindgren <tony@atomide.com>
++ *
++ *  Based on cpu-sa1110.c, Copyright (C) 2001 Russell King
++ *
++ * Copyright (C) 2007-2008 Texas Instruments, Inc.
++ * Updated to support OMAP3
++ * Rajendra Nayak <rnayak@ti.com>
++ *
++ * 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.
++ */
++#include <linux/types.h>
++#include <linux/kernel.h>
++#include <linux/sched.h>
++#include <linux/cpufreq.h>
++#include <linux/delay.h>
++#include <linux/init.h>
++#include <linux/err.h>
++#include <linux/clk.h>
++#include <linux/io.h>
++#include <linux/opp.h>
++
++#include <asm/system.h>
++
++#include <plat/clock.h>
++#include <plat/omap-pm.h>
++
++#include <mach/hardware.h>
++
++#define VERY_HI_RATE   900000000
++
++static struct cpufreq_frequency_table *freq_table;
++static struct clk *mpu_clk;
++
++static int omap_verify_speed(struct cpufreq_policy *policy)
++{
++       if (freq_table)
++               return cpufreq_frequency_table_verify(policy, freq_table);
++
++       if (policy->cpu)
++               return -EINVAL;
++
++       cpufreq_verify_within_limits(policy, policy->cpuinfo.min_freq,
++                                    policy->cpuinfo.max_freq);
++
++       policy->min = clk_round_rate(mpu_clk, policy->min * 1000) / 1000;
++       policy->max = clk_round_rate(mpu_clk, policy->max * 1000) / 1000;
++       cpufreq_verify_within_limits(policy, policy->cpuinfo.min_freq,
++                                    policy->cpuinfo.max_freq);
++       return 0;
++}
++
++static unsigned int omap_getspeed(unsigned int cpu)
++{
++       unsigned long rate;
++
++       if (cpu)
++               return 0;
++
++       rate = clk_get_rate(mpu_clk) / 1000;
++       return rate;
++}
++
++static int omap_target(struct cpufreq_policy *policy,
++                      unsigned int target_freq,
++                      unsigned int relation)
++{
++       struct cpufreq_freqs freqs;
++       int ret = 0;
++
++       /* Ensure desired rate is within allowed range.  Some govenors
++        * (ondemand) will just pass target_freq=0 to get the minimum. */
++       if (target_freq < policy->min)
++               target_freq = policy->min;
++       if (target_freq > policy->max)
++               target_freq = policy->max;
++
++       freqs.old = omap_getspeed(0);
++       freqs.new = clk_round_rate(mpu_clk, target_freq * 1000) / 1000;
++       freqs.cpu = 0;
++
++       if (freqs.old == freqs.new)
++               return ret;
++
++       cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
++
++#ifdef CONFIG_CPU_FREQ_DEBUG
++       pr_info("cpufreq-omap: transition: %u --> %u\n", freqs.old, freqs.new);
++#endif
++       ret = clk_set_rate(mpu_clk, freqs.new * 1000);
++
++       cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
++
++       return ret;
++}
++
++static int __init omap_cpu_init(struct cpufreq_policy *policy)
++{
++       int result = 0;
++
++       mpu_clk = clk_get(NULL, "mpu");
++       if (IS_ERR(mpu_clk))
++               return PTR_ERR(mpu_clk);
++
++       if (policy->cpu != 0)
++               return -EINVAL;
++
++       policy->cur = policy->min = policy->max = omap_getspeed(0);
++
++       clk_init_cpufreq_table(&freq_table);
++
++       if (freq_table) {
++               result = cpufreq_frequency_table_cpuinfo(policy, freq_table);
++               if (!result)
++                       cpufreq_frequency_table_get_attr(freq_table,
++                                                       policy->cpu);
++       } else {
++               policy->cpuinfo.min_freq = clk_round_rate(mpu_clk, 0) / 1000;
++               policy->cpuinfo.max_freq = clk_round_rate(mpu_clk,
++                                                       VERY_HI_RATE) / 1000;
++       }
++
++       policy->min = policy->cpuinfo.min_freq;
++       policy->max = policy->cpuinfo.max_freq;
++       policy->cur = omap_getspeed(0);
++
++       /* FIXME: what's the actual transition time? */
++       policy->cpuinfo.transition_latency = 300 * 1000;
++
++       return 0;
++}
++
++static int omap_cpu_exit(struct cpufreq_policy *policy)
++{
++       clk_exit_cpufreq_table(&freq_table);
++       clk_put(mpu_clk);
++       return 0;
++}
++
++static struct freq_attr *omap_cpufreq_attr[] = {
++       &cpufreq_freq_attr_scaling_available_freqs,
++       NULL,
++};
++
++static struct cpufreq_driver omap_driver = {
++       .flags          = CPUFREQ_STICKY,
++       .verify         = omap_verify_speed,
++       .target         = omap_target,
++       .get            = omap_getspeed,
++       .init           = omap_cpu_init,
++       .exit           = omap_cpu_exit,
++       .name           = "omap1",
++       .attr           = omap_cpufreq_attr,
++};
++
++static int __init omap_cpufreq_init(void)
++{
++       return cpufreq_register_driver(&omap_driver);
++}
++
++static void __exit omap_cpufreq_exit(void)
++{
++       cpufreq_unregister_driver(&omap_driver);
++}
++
++MODULE_DESCRIPTION("cpufreq driver for OMAP1 SOCs");
++MODULE_LICENSE("GPL");
++module_init(omap_cpufreq_init);
++module_exit(omap_cpufreq_exit);
+diff --git a/arch/arm/mach-omap2/Makefile b/arch/arm/mach-omap2/Makefile
+index 512b152..42924f3 100644
+--- a/arch/arm/mach-omap2/Makefile
++++ b/arch/arm/mach-omap2/Makefile
+@@ -56,6 +56,9 @@ obj-$(CONFIG_ARCH_OMAP3)              += opp3xxx_data.o
+ obj-$(CONFIG_ARCH_OMAP4)               += opp4xxx_data.o
+ endif
+ 
++# CPUFREQ driver
++obj-$(CONFIG_CPU_FREQ)                 += omap2plus-cpufreq.o
++
+ # Power Management
+ ifeq ($(CONFIG_PM),y)
+ obj-$(CONFIG_ARCH_OMAP2)               += pm24xx.o
+diff --git a/arch/arm/mach-omap2/omap2plus-cpufreq.c b/arch/arm/mach-omap2/omap2plus-cpufreq.c
+new file mode 100644
+index 0000000..14f84cc
+--- /dev/null
++++ b/arch/arm/mach-omap2/omap2plus-cpufreq.c
+@@ -0,0 +1,201 @@
++/*
++ *  OMAP2PLUS cpufreq driver
++ *
++ *  CPU frequency scaling for OMAP
++ *
++ *  Copyright (C) 2005 Nokia Corporation
++ *  Written by Tony Lindgren <tony@atomide.com>
++ *
++ *  Based on cpu-sa1110.c, Copyright (C) 2001 Russell King
++ *
++ * Copyright (C) 2007-2008 Texas Instruments, Inc.
++ * Updated to support OMAP3
++ * Rajendra Nayak <rnayak@ti.com>
++ *
++ * 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.
++ */
++#include <linux/types.h>
++#include <linux/kernel.h>
++#include <linux/sched.h>
++#include <linux/cpufreq.h>
++#include <linux/delay.h>
++#include <linux/init.h>
++#include <linux/err.h>
++#include <linux/clk.h>
++#include <linux/io.h>
++#include <linux/opp.h>
++
++#include <asm/system.h>
++#include <asm/smp_plat.h>
++
++#include <plat/clock.h>
++#include <plat/omap-pm.h>
++#include <plat/common.h>
++
++#include <mach/hardware.h>
++
++#define VERY_HI_RATE   900000000
++
++static struct cpufreq_frequency_table *freq_table;
++static struct clk *mpu_clk;
++
++static int omap_verify_speed(struct cpufreq_policy *policy)
++{
++       if (freq_table)
++               return cpufreq_frequency_table_verify(policy, freq_table);
++
++       if (policy->cpu)
++               return -EINVAL;
++
++       cpufreq_verify_within_limits(policy, policy->cpuinfo.min_freq,
++                                    policy->cpuinfo.max_freq);
++
++       policy->min = clk_round_rate(mpu_clk, policy->min * 1000) / 1000;
++       policy->max = clk_round_rate(mpu_clk, policy->max * 1000) / 1000;
++       cpufreq_verify_within_limits(policy, policy->cpuinfo.min_freq,
++                                    policy->cpuinfo.max_freq);
++       return 0;
++}
++
++static unsigned int omap_getspeed(unsigned int cpu)
++{
++       unsigned long rate;
++
++       if (cpu)
++               return 0;
++
++       rate = clk_get_rate(mpu_clk) / 1000;
++       return rate;
++}
++
++static int omap_target(struct cpufreq_policy *policy,
++                      unsigned int target_freq,
++                      unsigned int relation)
++{
++       int ret = 0;
++       struct cpufreq_freqs freqs;
++
++       /* Ensure desired rate is within allowed range.  Some govenors
++        * (ondemand) will just pass target_freq=0 to get the minimum. */
++       if (target_freq < policy->min)
++               target_freq = policy->min;
++       if (target_freq > policy->max)
++               target_freq = policy->max;
++
++       freqs.old = omap_getspeed(0);
++       freqs.new = clk_round_rate(mpu_clk, target_freq * 1000) / 1000;
++       freqs.cpu = 0;
++
++       if (freqs.old == freqs.new)
++               return ret;
++
++       cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
++
++#ifdef CONFIG_CPU_FREQ_DEBUG
++       pr_info("cpufreq-omap: transition: %u --> %u\n", freqs.old, freqs.new);
++#endif
++
++       ret = clk_set_rate(mpu_clk, freqs.new * 1000);
++
++       /*
++        * Generic CPUFREQ driver jiffy update is under !SMP. So jiffies
++        * won't get updated when UP machine cpufreq build with
++        * CONFIG_SMP enabled. Below code is added only to manage that
++        * scenario
++        */
++       if (!is_smp())
++               loops_per_jiffy =
++                        cpufreq_scale(loops_per_jiffy, freqs.old, freqs.new);
++
++       cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
++
++       return ret;
++}
++
++static int __cpuinit omap_cpu_init(struct cpufreq_policy *policy)
++{
++       int result = 0;
++       struct device *mpu_dev;
++
++       if (cpu_is_omap24xx())
++               mpu_clk = clk_get(NULL, "virt_prcm_set");
++       else if (cpu_is_omap34xx())
++               mpu_clk = clk_get(NULL, "dpll1_ck");
++       else if (cpu_is_omap34xx())
++               mpu_clk = clk_get(NULL, "dpll_mpu_ck");
++
++       if (IS_ERR(mpu_clk))
++               return PTR_ERR(mpu_clk);
++
++       if (policy->cpu != 0)
++               return -EINVAL;
++
++       policy->cur = policy->min = policy->max = omap_getspeed(0);
++
++       mpu_dev = omap2_get_mpuss_device();
++       if (!mpu_dev) {
++               pr_warning("%s: unable to get the mpu device\n", __func__);
++               return -EINVAL;
++       }
++       opp_init_cpufreq_table(mpu_dev, &freq_table);
++
++       if (freq_table) {
++               result = cpufreq_frequency_table_cpuinfo(policy, freq_table);
++               if (!result)
++                       cpufreq_frequency_table_get_attr(freq_table,
++                                                       policy->cpu);
++       } else {
++               policy->cpuinfo.min_freq = clk_round_rate(mpu_clk, 0) / 1000;
++               policy->cpuinfo.max_freq = clk_round_rate(mpu_clk,
++                                                       VERY_HI_RATE) / 1000;
++       }
++
++       policy->min = policy->cpuinfo.min_freq;
++       policy->max = policy->cpuinfo.max_freq;
++       policy->cur = omap_getspeed(0);
++
++       /* FIXME: what's the actual transition time? */
++       policy->cpuinfo.transition_latency = 300 * 1000;
++
++       return 0;
++}
++
++static int omap_cpu_exit(struct cpufreq_policy *policy)
++{
++       clk_exit_cpufreq_table(&freq_table);
++       clk_put(mpu_clk);
++       return 0;
++}
++
++static struct freq_attr *omap_cpufreq_attr[] = {
++       &cpufreq_freq_attr_scaling_available_freqs,
++       NULL,
++};
++
++static struct cpufreq_driver omap_driver = {
++       .flags          = CPUFREQ_STICKY,
++       .verify         = omap_verify_speed,
++       .target         = omap_target,
++       .get            = omap_getspeed,
++       .init           = omap_cpu_init,
++       .exit           = omap_cpu_exit,
++       .name           = "omap2plus",
++       .attr           = omap_cpufreq_attr,
++};
++
++static int __init omap_cpufreq_init(void)
++{
++       return cpufreq_register_driver(&omap_driver);
++}
++
++static void __exit omap_cpufreq_exit(void)
++{
++       cpufreq_unregister_driver(&omap_driver);
++}
++
++MODULE_DESCRIPTION("cpufreq driver for OMAP2PLUS SOCs");
++MODULE_LICENSE("GPL");
++module_init(omap_cpufreq_init);
++module_exit(omap_cpufreq_exit);
+diff --git a/arch/arm/plat-omap/Makefile b/arch/arm/plat-omap/Makefile
+index a4a1285..ec7862e 100644
+--- a/arch/arm/plat-omap/Makefile
++++ b/arch/arm/plat-omap/Makefile
+@@ -21,7 +21,6 @@ obj-$(CONFIG_OMAP_MCBSP) += mcbsp.o
+ obj-$(CONFIG_OMAP_IOMMU) += iommu.o iovmm.o
+ obj-$(CONFIG_OMAP_IOMMU_DEBUG) += iommu-debug.o
+ 
+-obj-$(CONFIG_CPU_FREQ) += cpu-omap.o
+ obj-$(CONFIG_OMAP_DM_TIMER) += dmtimer.o
+ obj-$(CONFIG_OMAP_DEBUG_DEVICES) += debug-devices.o
+ obj-$(CONFIG_OMAP_DEBUG_LEDS) += debug-leds.o
+diff --git a/arch/arm/plat-omap/cpu-omap.c b/arch/arm/plat-omap/cpu-omap.c
+deleted file mode 100644
+index 9cd2709..0000000
+--- a/arch/arm/plat-omap/cpu-omap.c
++++ /dev/null
+@@ -1,204 +0,0 @@
+-/*
+- *  linux/arch/arm/plat-omap/cpu-omap.c
+- *
+- *  CPU frequency scaling for OMAP
+- *
+- *  Copyright (C) 2005 Nokia Corporation
+- *  Written by Tony Lindgren <tony@atomide.com>
+- *
+- *  Based on cpu-sa1110.c, Copyright (C) 2001 Russell King
+- *
+- * Copyright (C) 2007-2008 Texas Instruments, Inc.
+- * Updated to support OMAP3
+- * Rajendra Nayak <rnayak@ti.com>
+- *
+- * 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.
+- */
+-#include <linux/types.h>
+-#include <linux/kernel.h>
+-#include <linux/sched.h>
+-#include <linux/cpufreq.h>
+-#include <linux/delay.h>
+-#include <linux/init.h>
+-#include <linux/err.h>
+-#include <linux/clk.h>
+-#include <linux/io.h>
+-#include <linux/opp.h>
+-
+-#include <mach/hardware.h>
+-#include <plat/clock.h>
+-#include <asm/system.h>
+-
+-#if defined(CONFIG_ARCH_OMAP3) && !defined(CONFIG_OMAP_PM_NONE)
+-#include <plat/omap-pm.h>
+-#include <plat/common.h>
+-#endif
+-
+-#define VERY_HI_RATE   900000000
+-
+-static struct cpufreq_frequency_table *freq_table;
+-
+-#ifdef CONFIG_ARCH_OMAP1
+-#define MPU_CLK                "mpu"
+-#elif defined(CONFIG_ARCH_OMAP3)
+-#define MPU_CLK                "arm_fck"
+-#else
+-#define MPU_CLK                "virt_prcm_set"
+-#endif
+-
+-static struct clk *mpu_clk;
+-
+-/* TODO: Add support for SDRAM timing changes */
+-
+-static int omap_verify_speed(struct cpufreq_policy *policy)
+-{
+-       if (freq_table)
+-               return cpufreq_frequency_table_verify(policy, freq_table);
+-
+-       if (policy->cpu)
+-               return -EINVAL;
+-
+-       cpufreq_verify_within_limits(policy, policy->cpuinfo.min_freq,
+-                                    policy->cpuinfo.max_freq);
+-
+-       policy->min = clk_round_rate(mpu_clk, policy->min * 1000) / 1000;
+-       policy->max = clk_round_rate(mpu_clk, policy->max * 1000) / 1000;
+-       cpufreq_verify_within_limits(policy, policy->cpuinfo.min_freq,
+-                                    policy->cpuinfo.max_freq);
+-       return 0;
+-}
+-
+-static unsigned int omap_getspeed(unsigned int cpu)
+-{
+-       unsigned long rate;
+-
+-       if (cpu)
+-               return 0;
+-
+-       rate = clk_get_rate(mpu_clk) / 1000;
+-       return rate;
+-}
+-
+-static int omap_target(struct cpufreq_policy *policy,
+-                      unsigned int target_freq,
+-                      unsigned int relation)
+-{
+-#ifdef CONFIG_ARCH_OMAP1
+-       struct cpufreq_freqs freqs;
+-#endif
+-#if defined(CONFIG_ARCH_OMAP3) && !defined(CONFIG_OMAP_PM_NONE)
+-       unsigned long freq;
+-       struct device *mpu_dev = omap2_get_mpuss_device();
+-#endif
+-       int ret = 0;
+-
+-       /* Ensure desired rate is within allowed range.  Some govenors
+-        * (ondemand) will just pass target_freq=0 to get the minimum. */
+-       if (target_freq < policy->min)
+-               target_freq = policy->min;
+-       if (target_freq > policy->max)
+-               target_freq = policy->max;
+-
+-#ifdef CONFIG_ARCH_OMAP1
+-       freqs.old = omap_getspeed(0);
+-       freqs.new = clk_round_rate(mpu_clk, target_freq * 1000) / 1000;
+-       freqs.cpu = 0;
+-
+-       if (freqs.old == freqs.new)
+-               return ret;
+-       cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
+-#ifdef CONFIG_CPU_FREQ_DEBUG
+-       printk(KERN_DEBUG "cpufreq-omap: transition: %u --> %u\n",
+-              freqs.old, freqs.new);
+-#endif
+-       ret = clk_set_rate(mpu_clk, freqs.new * 1000);
+-       cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
+-#elif defined(CONFIG_ARCH_OMAP3) && !defined(CONFIG_OMAP_PM_NONE)
+-       freq = target_freq * 1000;
+-       if (opp_find_freq_ceil(mpu_dev, &freq))
+-               omap_pm_cpu_set_freq(freq);
+-#endif
+-       return ret;
+-}
+-
+-static int __cpuinit omap_cpu_init(struct cpufreq_policy *policy)
+-{
+-       int result = 0;
+-
+-       mpu_clk = clk_get(NULL, MPU_CLK);
+-       if (IS_ERR(mpu_clk))
+-               return PTR_ERR(mpu_clk);
+-
+-       if (policy->cpu != 0)
+-               return -EINVAL;
+-
+-       policy->cur = policy->min = policy->max = omap_getspeed(0);
+-
+-       if (!cpu_is_omap34xx()) {
+-               clk_init_cpufreq_table(&freq_table);
+-       } else {
+-               struct device *mpu_dev = omap2_get_mpuss_device();
+-
+-               opp_init_cpufreq_table(mpu_dev, &freq_table);
+-       }
+-
+-       if (freq_table) {
+-               result = cpufreq_frequency_table_cpuinfo(policy, freq_table);
+-               if (!result)
+-                       cpufreq_frequency_table_get_attr(freq_table,
+-                                                       policy->cpu);
+-       } else {
+-               policy->cpuinfo.min_freq = clk_round_rate(mpu_clk, 0) / 1000;
+-               policy->cpuinfo.max_freq = clk_round_rate(mpu_clk,
+-                                                       VERY_HI_RATE) / 1000;
+-       }
+-
+-       policy->min = policy->cpuinfo.min_freq;
+-       policy->max = policy->cpuinfo.max_freq;
+-       policy->cur = omap_getspeed(0);
+-
+-       /* FIXME: what's the actual transition time? */
+-       policy->cpuinfo.transition_latency = 300 * 1000;
+-
+-       return 0;
+-}
+-
+-static int omap_cpu_exit(struct cpufreq_policy *policy)
+-{
+-       clk_exit_cpufreq_table(&freq_table);
+-       clk_put(mpu_clk);
+-       return 0;
+-}
+-
+-static struct freq_attr *omap_cpufreq_attr[] = {
+-       &cpufreq_freq_attr_scaling_available_freqs,
+-       NULL,
+-};
+-
+-static struct cpufreq_driver omap_driver = {
+-       .flags          = CPUFREQ_STICKY,
+-       .verify         = omap_verify_speed,
+-       .target         = omap_target,
+-       .get            = omap_getspeed,
+-       .init           = omap_cpu_init,
+-       .exit           = omap_cpu_exit,
+-       .name           = "omap",
+-       .attr           = omap_cpufreq_attr,
+-};
+-
+-static int __init omap_cpufreq_init(void)
+-{
+-       return cpufreq_register_driver(&omap_driver);
+-}
+-
+-late_initcall(omap_cpufreq_init);
+-
+-/*
+- * if ever we want to remove this, upon cleanup call:
+- *
+- * cpufreq_unregister_driver()
+- * cpufreq_frequency_table_put_attr()
+- */
+-
+-- 
+1.6.6.1
+
diff --git a/recipes-kernel/linux/linux-omap-2.6.39/pm/linux-omap-2.6.39-ti-pm-wip-cpufreq/0050-OMAP2PLUS-cpufreq-Add-SMP-support-to-cater-OMAP4430.patch b/recipes-kernel/linux/linux-omap-2.6.39/pm/linux-omap-2.6.39-ti-pm-wip-cpufreq/0050-OMAP2PLUS-cpufreq-Add-SMP-support-to-cater-OMAP4430.patch
new file mode 100644
index 00000000..c9e42893
--- /dev/null
+++ b/recipes-kernel/linux/linux-omap-2.6.39/pm/linux-omap-2.6.39-ti-pm-wip-cpufreq/0050-OMAP2PLUS-cpufreq-Add-SMP-support-to-cater-OMAP4430.patch
@@ -0,0 +1,170 @@
+From d1774fef215a30d5a5db713170f74cc8da82933f Mon Sep 17 00:00:00 2001
+From: Santosh Shilimkar <santosh.shilimkar@ti.com>
+Date: Mon, 14 Mar 2011 17:08:49 +0530
+Subject: [PATCH 50/59] OMAP2PLUS: cpufreq: Add SMP support to cater OMAP4430
+
+On OMAP SMP configuartion, both processors share the voltage
+and clock. So both CPUs needs to be scaled together and hence
+needs software co-ordination.
+
+Signed-off-by: Santosh Shilimkar <santosh.shilimkar@ti.com>
+Cc: Kevin Hilman <khilman@ti.com>
+cc: Vishwanath BS <vishwanath.bs@ti.com>
+---
+ arch/arm/mach-omap2/omap2plus-cpufreq.c |   73 ++++++++++++++++++++++++++-----
+ 1 files changed, 62 insertions(+), 11 deletions(-)
+
+diff --git a/arch/arm/mach-omap2/omap2plus-cpufreq.c b/arch/arm/mach-omap2/omap2plus-cpufreq.c
+index 14f84cc..8d472f6 100644
+--- a/arch/arm/mach-omap2/omap2plus-cpufreq.c
++++ b/arch/arm/mach-omap2/omap2plus-cpufreq.c
+@@ -26,9 +26,11 @@
+ #include <linux/clk.h>
+ #include <linux/io.h>
+ #include <linux/opp.h>
++#include <linux/cpu.h>
+ 
+ #include <asm/system.h>
+ #include <asm/smp_plat.h>
++#include <asm/cpu.h>
+ 
+ #include <plat/clock.h>
+ #include <plat/omap-pm.h>
+@@ -63,7 +65,7 @@ static unsigned int omap_getspeed(unsigned int cpu)
+ {
+        unsigned long rate;
+ 
+-       if (cpu)
++       if (cpu >= NR_CPUS)
+                return 0;
+ 
+        rate = clk_get_rate(mpu_clk) / 1000;
+@@ -74,9 +76,13 @@ static int omap_target(struct cpufreq_policy *policy,
+                       unsigned int target_freq,
+                       unsigned int relation)
+ {
+-       int ret = 0;
++       int i, ret = 0;
+        struct cpufreq_freqs freqs;
+ 
++       /* Changes not allowed until all CPUs are online */
++       if (is_smp() && (num_online_cpus() < NR_CPUS))
++               return ret;
++
+        /* Ensure desired rate is within allowed range.  Some govenors
+         * (ondemand) will just pass target_freq=0 to get the minimum. */
+        if (target_freq < policy->min)
+@@ -84,15 +90,25 @@ static int omap_target(struct cpufreq_policy *policy,
+        if (target_freq > policy->max)
+                target_freq = policy->max;
+ 
+-       freqs.old = omap_getspeed(0);
++       freqs.old = omap_getspeed(policy->cpu);
+        freqs.new = clk_round_rate(mpu_clk, target_freq * 1000) / 1000;
+-       freqs.cpu = 0;
++       freqs.cpu = policy->cpu;
+ 
+        if (freqs.old == freqs.new)
+                return ret;
+ 
+-       cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
++       if (!is_smp()) {
++               cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
++               goto set_freq;
++       }
++
++       /* notifiers */
++       for_each_cpu(i, policy->cpus) {
++               freqs.cpu = i;
++               cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
++       }
+ 
++set_freq:
+ #ifdef CONFIG_CPU_FREQ_DEBUG
+        pr_info("cpufreq-omap: transition: %u --> %u\n", freqs.old, freqs.new);
+ #endif
+@@ -105,12 +121,33 @@ static int omap_target(struct cpufreq_policy *policy,
+         * CONFIG_SMP enabled. Below code is added only to manage that
+         * scenario
+         */
+-       if (!is_smp())
++       freqs.new = omap_getspeed(policy->cpu);
++       if (!is_smp()) {
+                loops_per_jiffy =
+                         cpufreq_scale(loops_per_jiffy, freqs.old, freqs.new);
++               cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
++               goto skip_lpj;
++       }
+ 
+-       cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
++#ifdef CONFIG_SMP
++       /*
++        * Note that loops_per_jiffy is not updated on SMP systems in
++        * cpufreq driver. So, update the per-CPU loops_per_jiffy value
++        * on frequency transition. We need to update all dependent CPUs.
++        */
++       for_each_cpu(i, policy->cpus)
++               per_cpu(cpu_data, i).loops_per_jiffy =
++                       cpufreq_scale(per_cpu(cpu_data, i).loops_per_jiffy,
++                                       freqs.old, freqs.new);
++#endif
+ 
++       /* notifiers */
++       for_each_cpu(i, policy->cpus) {
++               freqs.cpu = i;
++               cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
++       }
++
++skip_lpj:
+        return ret;
+ }
+ 
+@@ -118,6 +155,7 @@ static int __cpuinit omap_cpu_init(struct cpufreq_policy *policy)
+ {
+        int result = 0;
+        struct device *mpu_dev;
++       static cpumask_var_t cpumask;
+ 
+        if (cpu_is_omap24xx())
+                mpu_clk = clk_get(NULL, "virt_prcm_set");
+@@ -129,12 +167,12 @@ static int __cpuinit omap_cpu_init(struct cpufreq_policy *policy)
+        if (IS_ERR(mpu_clk))
+                return PTR_ERR(mpu_clk);
+ 
+-       if (policy->cpu != 0)
++       if (policy->cpu >= NR_CPUS)
+                return -EINVAL;
+ 
+-       policy->cur = policy->min = policy->max = omap_getspeed(0);
+-
++       policy->cur = policy->min = policy->max = omap_getspeed(policy->cpu);
+        mpu_dev = omap2_get_mpuss_device();
++
+        if (!mpu_dev) {
+                pr_warning("%s: unable to get the mpu device\n", __func__);
+                return -EINVAL;
+@@ -154,7 +192,20 @@ static int __cpuinit omap_cpu_init(struct cpufreq_policy *policy)
+ 
+        policy->min = policy->cpuinfo.min_freq;
+        policy->max = policy->cpuinfo.max_freq;
+-       policy->cur = omap_getspeed(0);
++       policy->cur = omap_getspeed(policy->cpu);
++
++       /*
++        * On OMAP SMP configuartion, both processors share the voltage
++        * and clock. So both CPUs needs to be scaled together and hence
++        * needs software co-ordination. Use cpufreq affected_cpus
++        * interface to handle this scenario. Additional is_smp() check
++        * is to keep SMP_ON_UP build working.
++        */
++       if (is_smp()) {
++               policy->shared_type = CPUFREQ_SHARED_TYPE_ANY;
++               cpumask_or(cpumask, cpumask_of(policy->cpu), cpumask);
++               cpumask_copy(policy->cpus, cpumask);
++       }
+ 
+        /* FIXME: what's the actual transition time? */
+        policy->cpuinfo.transition_latency = 300 * 1000;
+-- 
+1.6.6.1
+
diff --git a/recipes-kernel/linux/linux-omap-2.6.39/pm/linux-omap-2.6.39-ti-pm-wip-cpufreq/0051-OMAP2PLUS-cpufreq-Fix-typo-when-attempting-to-set-mp.patch b/recipes-kernel/linux/linux-omap-2.6.39/pm/linux-omap-2.6.39-ti-pm-wip-cpufreq/0051-OMAP2PLUS-cpufreq-Fix-typo-when-attempting-to-set-mp.patch
new file mode 100644
index 00000000..3685af92
--- /dev/null
+++ b/recipes-kernel/linux/linux-omap-2.6.39/pm/linux-omap-2.6.39-ti-pm-wip-cpufreq/0051-OMAP2PLUS-cpufreq-Fix-typo-when-attempting-to-set-mp.patch
@@ -0,0 +1,29 @@
+From b25a843135dc8ba5053befd1d39ac2286a3d9fa4 Mon Sep 17 00:00:00 2001
+From: Jarkko Nikula <jhnikula@gmail.com>
+Date: Thu, 14 Apr 2011 16:21:58 +0300
+Subject: [PATCH 51/59] OMAP2PLUS: cpufreq: Fix typo when attempting to set mpu_clk for OMAP4
+
+Fix this typo as there is no dpll_mpu_ck for OMAP3 and code flow is clearly
+trying to set mpu_clk for OMAP4 for which this dpll_mpu_ck is available.
+
+Signed-off-by: Jarkko Nikula <jhnikula@gmail.com>
+---
+ arch/arm/mach-omap2/omap2plus-cpufreq.c |    2 +-
+ 1 files changed, 1 insertions(+), 1 deletions(-)
+
+diff --git a/arch/arm/mach-omap2/omap2plus-cpufreq.c b/arch/arm/mach-omap2/omap2plus-cpufreq.c
+index 8d472f6..d53ce23 100644
+--- a/arch/arm/mach-omap2/omap2plus-cpufreq.c
++++ b/arch/arm/mach-omap2/omap2plus-cpufreq.c
+@@ -161,7 +161,7 @@ static int __cpuinit omap_cpu_init(struct cpufreq_policy *policy)
+                mpu_clk = clk_get(NULL, "virt_prcm_set");
+        else if (cpu_is_omap34xx())
+                mpu_clk = clk_get(NULL, "dpll1_ck");
+-       else if (cpu_is_omap34xx())
++       else if (cpu_is_omap44xx())
+                mpu_clk = clk_get(NULL, "dpll_mpu_ck");
+ 
+        if (IS_ERR(mpu_clk))
+-- 
+1.6.6.1
+