This layer provides Energy Aware Scheduling (EAS) patcheseel_5.1.0 eel_5.0.3 eel_5.0.2 eel/5.1.0 eel/5.0.3 eel/5.0.2 5.1.0 5.0.3 5.0.2 eel

For the moment only for Renesas R-Car Gen3 SoC's. Can be expanded for other SoC's by setting the machine feature biglittle and provide the relevant EAS patches. Bug-AGL: SPEC-813 Change-Id: I2b5e69c515c33e57be19b30466fe208d7b8ac1a5 Signed-off-by: Frode Isaksen <fisaksen@baylibre.com>
author: Frode Isaksen <fisaksen@baylibre.com> 2017-12-19 11:15:35 +0000
committer: Jan-Simon Moeller <jsmoeller@linuxfoundation.org> 2018-02-07 11:47:29 +0000
commit: c4a6287185179732dfc1e903c195ff90c19f1065 (patch)
tree: d35f5010dbd952e40f5c178322026445b55757c1
parent: 109dea1d5c5a38807b098b588584636ae636a302 (diff)
101 files changed, 10932 insertions, 0 deletions
diff --git a/meta-eas/README.md b/meta-eas/README.md
new file mode 100644
index 0000000..87494c4
--- /dev/null
+++ b/meta-eas/README.md
@@ -0,0 +1,74 @@
+# EAS patches for linux-reneas layer
+
+This README file contains information on the contents of the
+meta-eas layer.
+
+Please see the corresponding sections below for details.
+
+### Dependencies
+-------------------------
+
+This layer depends on:
+
+  * URI: https://gerrit.automotivelinux.org/gerrit/AGL/meta-renesas-rcar-gen3<br>
+  layers: `meta-rcar-gen3`<br>
+  tag: `master`
+
+The machine feature `biglittle` must be set in order for these patches
+to be applied.
+If support in needed for another SoC, please add the machine feature
+`biglittle` and provide the relevant EAS patches for the linux kernel.
+
+### Patches
+-----------
+
+Please submit any patches against the meta-baylibre-agl-eas layer to the
+the maintainers:
+
+* Michael Turquette <mturquette@baylibre.com>
+* Frode Isaksen <fisaksen@baylibre.com>
+* Jerome Brunet <jbrunet@baylibre.com>
+
+## I. Description and provided packages:
+
+The layer provides Energy Aware Scheduling (EAS) patches for the linux-reneases kernel. 
+This package is an experimental utility to improve scheduling efficiency on big/LITTLE architecture.
+
++ Patched packages :
+	- linux-renesas: Add configuration flags and patches required for EAS.
+
+## II. Adding the meta-baylibre-agl-eas layer to your AGL build
+
+1. Download meta-agl-extra at `$AGL_TOP`
+2. Add `eas` to the feature of your AGL build<br>
+```shell
+source meta-agl/scripts/aglsetup.sh -m $MACHINE -b <your-other-features> eas
+```
+
+With this `meta-eas` will be added to your `conf/bblayers.conf`.
+
+## III. Background information:
+
+Several techniques for saving energy through various scheduler
+modifications have been proposed in the past, however most of the
+techniques have not been universally beneficial for all use-cases and
+platforms. For example, consolidating tasks on fewer cpus is an
+effective way to save energy on some platforms, while it might make
+things worse on others.
+
+This proposal, which is inspired by the Ksummit workshop discussions in
+2013 [1], takes a different approach by using a (relatively) simple
+platform energy cost model to guide scheduling decisions. By providing
+the model with platform specific costing data the model can provide a
+estimate of the energy implications of scheduling decisions. So instead
+of blindly applying scheduling techniques that may or may not work for
+the current use-case, the scheduler can make informed energy-aware
+decisions. We believe this approach provides a methodology that can be
+adapted to any platform, including heterogeneous systems such as ARM
+big.LITTLE. The model considers cpus only, i.e. no peripherals, GPU or
+memory. Model data includes power consumption at each P-state and
+C-state.
+
+## IV. Further reading:
+
+https://developer.arm.com/open-source/energy-aware-scheduling
diff --git a/meta-eas/conf/layer.conf b/meta-eas/conf/layer.conf
new file mode 100644
index 0000000..de9f43b
--- /dev/null
+++ b/meta-eas/conf/layer.conf
@@ -0,0 +1,10 @@
+# We have a conf and classes directory, add to BBPATH
+BBPATH .= ":${LAYERDIR}"
+
+# We have recipes-* directories, add to BBFILES
+BBFILES += "${LAYERDIR}/recipes-*/*/*.bb \
+	${LAYERDIR}/recipes-*/*/*.bbappend"
+
+BBFILE_COLLECTIONS += "eas"
+BBFILE_PATTERN_eas = "^${LAYERDIR}/"
+BBFILE_PRIORITY_eas = "6"
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0001-arm64-dts-r8a7795-Update-cpu-capacity-dmips-mhz.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0001-arm64-dts-r8a7795-Update-cpu-capacity-dmips-mhz.patch
new file mode 100644
index 0000000..11f927d
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0001-arm64-dts-r8a7795-Update-cpu-capacity-dmips-mhz.patch
@@ -0,0 +1,59 @@
+From 59c433df0378f573a9928a8c94573fdf570138a6 Mon Sep 17 00:00:00 2001
+From: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+Date: Wed, 15 Nov 2017 11:28:32 +0900
+Subject: [PATCH 1/4] arm64: dts: r8a7795: Update cpu capacity-dmips-mhz
+
+Since the cpu_capacity for CA53 was set smaller than expected, the
+behavior of scheduler may not be suitable a little. This patch fixes
+the reasonable value to fit current implementation. This value should
+be updated again when the turbo mode and big little architecture will
+support with cpu capacity features.
+
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ arch/arm64/boot/dts/renesas/r8a7795.dtsi | 8 ++++----
+ 1 file changed, 4 insertions(+), 4 deletions(-)
+
+diff --git a/arch/arm64/boot/dts/renesas/r8a7795.dtsi b/arch/arm64/boot/dts/renesas/r8a7795.dtsi
+index eff01d6..4e44a94 100644
+--- a/arch/arm64/boot/dts/renesas/r8a7795.dtsi
++++ b/arch/arm64/boot/dts/renesas/r8a7795.dtsi
+@@ -165,7 +165,7 @@
+ 			dynamic-power-coefficient = <277>;
+ 			clocks =<&cpg CPG_CORE R8A7795_CLK_Z2>;
+ 			operating-points-v2 = <&cluster1_opp_tb0>;
+-			capacity-dmips-mhz = <379>;
++			capacity-dmips-mhz = <540>;
+ 		};
+ 
+ 		a53_1: cpu@101 {
+@@ -175,7 +175,7 @@
+ 			next-level-cache = <&L2_CA53>;
+ 			enable-method = "psci";
+ 			operating-points-v2 = <&cluster1_opp_tb0>;
+-			capacity-dmips-mhz = <379>;
++			capacity-dmips-mhz = <540>;
+ 		};
+ 
+ 		a53_2: cpu@102 {
+@@ -185,7 +185,7 @@
+ 			next-level-cache = <&L2_CA53>;
+ 			enable-method = "psci";
+ 			operating-points-v2 = <&cluster1_opp_tb0>;
+-			capacity-dmips-mhz = <379>;
++			capacity-dmips-mhz = <540>;
+ 		};
+ 
+ 		a53_3: cpu@103 {
+@@ -195,7 +195,7 @@
+ 			next-level-cache = <&L2_CA53>;
+ 			enable-method = "psci";
+ 			operating-points-v2 = <&cluster1_opp_tb0>;
+-			capacity-dmips-mhz = <379>;
++			capacity-dmips-mhz = <540>;
+ 		};
+ 
+ 		L2_CA57: cache-controller@0 {
+-- 
+2.7.4
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0001-sched-fair-Kill-the-unused-sched_shares_window_ns-tu.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0001-sched-fair-Kill-the-unused-sched_shares_window_ns-tu.patch
new file mode 100644
index 0000000..5477ade
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0001-sched-fair-Kill-the-unused-sched_shares_window_ns-tu.patch
@@ -0,0 +1,80 @@
+From d1f3667faa908a76aeb6e54f38b1e1d4b2a3ce2b Mon Sep 17 00:00:00 2001
+From: Matt Fleming <matt@codeblueprint.co.uk>
+Date: Wed, 19 Oct 2016 15:10:59 +0100
+Subject: [PATCH 01/92] sched/fair: Kill the unused 'sched_shares_window_ns'
+ tunable
+
+The last user of this tunable was removed in 2012 in commit:
+
+  82958366cfea ("sched: Replace update_shares weight distribution with per-entity computation")
+
+Delete it since its very existence confuses people.
+
+Signed-off-by: Matt Fleming <matt@codeblueprint.co.uk>
+Cc: Dietmar Eggemann <dietmar.eggemann@arm.com>
+Cc: Linus Torvalds <torvalds@linux-foundation.org>
+Cc: Mike Galbraith <umgwanakikbuti@gmail.com>
+Cc: Paul Turner <pjt@google.com>
+Cc: Peter Zijlstra <peterz@infradead.org>
+Cc: Thomas Gleixner <tglx@linutronix.de>
+Link: http://lkml.kernel.org/r/20161019141059.26408-1-matt@codeblueprint.co.uk
+Signed-off-by: Ingo Molnar <mingo@kernel.org>
+(cherry picked from commit 3c3fcb45d524feb5d14a14f332e3eec7f2aff8f3)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ include/linux/sched/sysctl.h | 1 -
+ kernel/sched/fair.c          | 7 -------
+ kernel/sysctl.c              | 7 -------
+ 3 files changed, 15 deletions(-)
+
+diff --git a/include/linux/sched/sysctl.h b/include/linux/sched/sysctl.h
+index 22db1e6..4411453 100644
+--- a/include/linux/sched/sysctl.h
++++ b/include/linux/sched/sysctl.h
+@@ -36,7 +36,6 @@ enum sched_tunable_scaling {
+ extern unsigned int sysctl_sched_migration_cost;
+ extern unsigned int sysctl_sched_nr_migrate;
+ extern unsigned int sysctl_sched_time_avg;
+-extern unsigned int sysctl_sched_shares_window;
+ 
+ int sched_proc_update_handler(struct ctl_table *table, int write,
+ 		void __user *buffer, size_t *length,
+diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
+index c242944..3cf446c 100644
+--- a/kernel/sched/fair.c
++++ b/kernel/sched/fair.c
+@@ -93,13 +93,6 @@ enum sched_tunable_scaling sysctl_sched_tunable_scaling
+ 
+ const_debug unsigned int sysctl_sched_migration_cost = 500000UL;
+ 
+-/*
+- * The exponential sliding  window over which load is averaged for shares
+- * distribution.
+- * (default: 10msec)
+- */
+-unsigned int __read_mostly sysctl_sched_shares_window = 10000000UL;
+-
+ #ifdef CONFIG_CFS_BANDWIDTH
+ /*
+  * Amount of runtime to allocate from global (tg) to local (per-cfs_rq) pool
+diff --git a/kernel/sysctl.c b/kernel/sysctl.c
+index 706309f..739fb17 100644
+--- a/kernel/sysctl.c
++++ b/kernel/sysctl.c
+@@ -347,13 +347,6 @@ static int sysrq_sysctl_handler(struct ctl_table *table, int write,
+ 		.mode		= 0644,
+ 		.proc_handler	= proc_dointvec,
+ 	},
+-	{
+-		.procname	= "sched_shares_window_ns",
+-		.data		= &sysctl_sched_shares_window,
+-		.maxlen		= sizeof(unsigned int),
+-		.mode		= 0644,
+-		.proc_handler	= proc_dointvec,
+-	},
+ #ifdef CONFIG_SCHEDSTATS
+ 	{
+ 		.procname	= "sched_schedstats",
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0002-arm64-dts-r8a7796-Update-cpu-capacity-dmips-mhz.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0002-arm64-dts-r8a7796-Update-cpu-capacity-dmips-mhz.patch
new file mode 100644
index 0000000..391ee27
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0002-arm64-dts-r8a7796-Update-cpu-capacity-dmips-mhz.patch
@@ -0,0 +1,59 @@
+From a88ec6504f72d17ca2a0ae4da2e895462df7e23e Mon Sep 17 00:00:00 2001
+From: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+Date: Wed, 15 Nov 2017 11:33:36 +0900
+Subject: [PATCH 2/4] arm64: dts: r8a7796: Update cpu capacity-dmips-mhz
+
+Since the cpu_capacity for CA53 was set smaller than expected, the
+behavior of scheduler may not be suitable a little. This patch fixes
+the reasonable value to fit current implementation. This value should
+be updated again when the turbo mode and big little architecture will
+support with cpu capacity features.
+
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ arch/arm64/boot/dts/renesas/r8a7796.dtsi | 8 ++++----
+ 1 file changed, 4 insertions(+), 4 deletions(-)
+
+diff --git a/arch/arm64/boot/dts/renesas/r8a7796.dtsi b/arch/arm64/boot/dts/renesas/r8a7796.dtsi
+index da26f88..e35adbf 100644
+--- a/arch/arm64/boot/dts/renesas/r8a7796.dtsi
++++ b/arch/arm64/boot/dts/renesas/r8a7796.dtsi
+@@ -126,7 +126,7 @@
+ 			dynamic-power-coefficient = <277>;
+ 			clocks =<&cpg CPG_CORE R8A7796_CLK_Z2>;
+ 			operating-points-v2 = <&cluster1_opp_tb0>;
+-			capacity-dmips-mhz = <362>;
++			capacity-dmips-mhz = <543>;
+ 		};
+ 
+ 		a53_1: cpu@101 {
+@@ -136,7 +136,7 @@
+ 			next-level-cache = <&L2_CA53>;
+ 			enable-method = "psci";
+ 			operating-points-v2 = <&cluster1_opp_tb0>;
+-			capacity-dmips-mhz = <362>;
++			capacity-dmips-mhz = <543>;
+ 		};
+ 
+ 		a53_2: cpu@102 {
+@@ -146,7 +146,7 @@
+ 			next-level-cache = <&L2_CA53>;
+ 			enable-method = "psci";
+ 			operating-points-v2 = <&cluster1_opp_tb0>;
+-			capacity-dmips-mhz = <362>;
++			capacity-dmips-mhz = <543>;
+ 		};
+ 
+ 		a53_3: cpu@103 {
+@@ -156,7 +156,7 @@
+ 			next-level-cache = <&L2_CA53>;
+ 			enable-method = "psci";
+ 			operating-points-v2 = <&cluster1_opp_tb0>;
+-			capacity-dmips-mhz = <362>;
++			capacity-dmips-mhz = <543>;
+ 		};
+ 
+ 		L2_CA57: cache-controller@0 {
+-- 
+2.7.4
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0002-sched-fair-Compute-task-cpu-utilization-at-wake-up-c.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0002-sched-fair-Compute-task-cpu-utilization-at-wake-up-c.patch
new file mode 100644
index 0000000..fccc8f3
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0002-sched-fair-Compute-task-cpu-utilization-at-wake-up-c.patch
@@ -0,0 +1,123 @@
+From cb6859b76310842444b2123afc2a7dea03279b72 Mon Sep 17 00:00:00 2001
+From: Morten Rasmussen <morten.rasmussen@arm.com>
+Date: Fri, 14 Oct 2016 14:41:07 +0100
+Subject: [PATCH 02/92] sched/fair: Compute task/cpu utilization at wake-up
+ correctly
+
+At task wake-up load-tracking isn't updated until the task is enqueued.
+The task's own view of its utilization contribution may therefore not be
+aligned with its contribution to the cfs_rq load-tracking which may have
+been updated in the meantime. Basically, the task's own utilization
+hasn't yet accounted for the sleep decay, while the cfs_rq may have
+(partially). Estimating the cfs_rq utilization in case the task is
+migrated at wake-up as task_rq(p)->cfs.avg.util_avg - p->se.avg.util_avg
+is therefore incorrect as the two load-tracking signals aren't time
+synchronized (different last update).
+
+To solve this problem, this patch synchronizes the task utilization with
+its previous rq before the task utilization is used in the wake-up path.
+Currently the update/synchronization is done _after_ the task has been
+placed by select_task_rq_fair(). The synchronization is done without
+having to take the rq lock using the existing mechanism used in
+remove_entity_load_avg().
+
+Signed-off-by: Morten Rasmussen <morten.rasmussen@arm.com>
+Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
+Cc: Linus Torvalds <torvalds@linux-foundation.org>
+Cc: Peter Zijlstra <peterz@infradead.org>
+Cc: Thomas Gleixner <tglx@linutronix.de>
+Cc: dietmar.eggemann@arm.com
+Cc: freedom.tan@mediatek.com
+Cc: keita.kobayashi.ym@renesas.com
+Cc: mgalbraith@suse.de
+Cc: sgurrappadi@nvidia.com
+Cc: vincent.guittot@linaro.org
+Cc: yuyang.du@intel.com
+Link: http://lkml.kernel.org/r/1476452472-24740-2-git-send-email-morten.rasmussen@arm.com
+Signed-off-by: Ingo Molnar <mingo@kernel.org>
+(cherry picked from commit 104cb16d9eb684f071d5bf3aa87c0d01af259b7c)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ kernel/sched/fair.c | 39 +++++++++++++++++++++++++++++++++++----
+ 1 file changed, 35 insertions(+), 4 deletions(-)
+
+diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
+index 3cf446c..b05d691 100644
+--- a/kernel/sched/fair.c
++++ b/kernel/sched/fair.c
+@@ -3199,13 +3199,25 @@ static inline u64 cfs_rq_last_update_time(struct cfs_rq *cfs_rq)
+ #endif
+ 
+ /*
++ * Synchronize entity load avg of dequeued entity without locking
++ * the previous rq.
++ */
++void sync_entity_load_avg(struct sched_entity *se)
++{
++	struct cfs_rq *cfs_rq = cfs_rq_of(se);
++	u64 last_update_time;
++
++	last_update_time = cfs_rq_last_update_time(cfs_rq);
++	__update_load_avg(last_update_time, cpu_of(rq_of(cfs_rq)), &se->avg, 0, 0, NULL);
++}
++
++/*
+  * Task first catches up with cfs_rq, and then subtract
+  * itself from the cfs_rq (task must be off the queue now).
+  */
+ void remove_entity_load_avg(struct sched_entity *se)
+ {
+ 	struct cfs_rq *cfs_rq = cfs_rq_of(se);
+-	u64 last_update_time;
+ 
+ 	/*
+ 	 * tasks cannot exit without having gone through wake_up_new_task() ->
+@@ -3217,9 +3229,7 @@ void remove_entity_load_avg(struct sched_entity *se)
+ 	 * calls this.
+ 	 */
+ 
+-	last_update_time = cfs_rq_last_update_time(cfs_rq);
+-
+-	__update_load_avg(last_update_time, cpu_of(rq_of(cfs_rq)), &se->avg, 0, 0, NULL);
++	sync_entity_load_avg(se);
+ 	atomic_long_add(se->avg.load_avg, &cfs_rq->removed_load_avg);
+ 	atomic_long_add(se->avg.util_avg, &cfs_rq->removed_util_avg);
+ }
+@@ -5583,6 +5593,24 @@ static inline int task_util(struct task_struct *p)
+ }
+ 
+ /*
++ * cpu_util_wake: Compute cpu utilization with any contributions from
++ * the waking task p removed.
++ */
++static int cpu_util_wake(int cpu, struct task_struct *p)
++{
++	unsigned long util, capacity;
++
++	/* Task has no contribution or is new */
++	if (cpu != task_cpu(p) || !p->se.avg.last_update_time)
++		return cpu_util(cpu);
++
++	capacity = capacity_orig_of(cpu);
++	util = max_t(long, cpu_rq(cpu)->cfs.avg.util_avg - task_util(p), 0);
++
++	return (util >= capacity) ? capacity : util;
++}
++
++/*
+  * Disable WAKE_AFFINE in the case where task @p doesn't fit in the
+  * capacity of either the waking CPU @cpu or the previous CPU @prev_cpu.
+  *
+@@ -5600,6 +5628,9 @@ static int wake_cap(struct task_struct *p, int cpu, int prev_cpu)
+ 	if (max_cap - min_cap < max_cap >> 3)
+ 		return 0;
+ 
++	/* Bring task utilization in sync with prev_cpu */
++	sync_entity_load_avg(&p->se);
++
+ 	return min_cap * 1024 < task_util(p) * capacity_margin;
+ }
+ 
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0003-arm64-dts-r8a7795-es1-Update-cpu-capacity-dmips-mhz.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0003-arm64-dts-r8a7795-es1-Update-cpu-capacity-dmips-mhz.patch
new file mode 100644
index 0000000..d779509
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0003-arm64-dts-r8a7795-es1-Update-cpu-capacity-dmips-mhz.patch
@@ -0,0 +1,59 @@
+From 30b845df13f693baadc3c35b8719adb0a13a2a4a Mon Sep 17 00:00:00 2001
+From: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+Date: Wed, 15 Nov 2017 11:36:37 +0900
+Subject: [PATCH 3/4] arm64: dts: r8a7795-es1: Update cpu capacity-dmips-mhz
+
+Since the cpu_capacity for CA53 was set smaller than expected, the
+behavior of scheduler may not be suitable a little. This patch fixes
+the reasonable value to fit current implementation. This value should
+be updated again when the turbo mode and big little architecture will
+support with cpu capacity features.
+
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ arch/arm64/boot/dts/renesas/r8a7795-es1.dtsi | 8 ++++----
+ 1 file changed, 4 insertions(+), 4 deletions(-)
+
+diff --git a/arch/arm64/boot/dts/renesas/r8a7795-es1.dtsi b/arch/arm64/boot/dts/renesas/r8a7795-es1.dtsi
+index c2b5b8d..b8a1542 100644
+--- a/arch/arm64/boot/dts/renesas/r8a7795-es1.dtsi
++++ b/arch/arm64/boot/dts/renesas/r8a7795-es1.dtsi
+@@ -170,7 +170,7 @@
+ 			dynamic-power-coefficient = <277>;
+ 			clocks =<&cpg CPG_CORE R8A7795_CLK_Z2>;
+ 			operating-points-v2 = <&cluster1_opp_tb0>;
+-			capacity-dmips-mhz = <379>;
++			capacity-dmips-mhz = <540>;
+ 		};
+ 
+ 		a53_1: cpu@101 {
+@@ -180,7 +180,7 @@
+ 			next-level-cache = <&L2_CA53>;
+ 			enable-method = "psci";
+ 			operating-points-v2 = <&cluster1_opp_tb0>;
+-			capacity-dmips-mhz = <379>;
++			capacity-dmips-mhz = <540>;
+ 		};
+ 
+ 		a53_2: cpu@102 {
+@@ -190,7 +190,7 @@
+ 			next-level-cache = <&L2_CA53>;
+ 			enable-method = "psci";
+ 			operating-points-v2 = <&cluster1_opp_tb0>;
+-			capacity-dmips-mhz = <379>;
++			capacity-dmips-mhz = <540>;
+ 		};
+ 
+ 		a53_3: cpu@103 {
+@@ -200,7 +200,7 @@
+ 			next-level-cache = <&L2_CA53>;
+ 			enable-method = "psci";
+ 			operating-points-v2 = <&cluster1_opp_tb0>;
+-			capacity-dmips-mhz = <379>;
++			capacity-dmips-mhz = <540>;
+ 		};
+ 
+ 		L2_CA57: cache-controller@0 {
+-- 
+2.7.4
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0003-sched-fair-Consider-spare-capacity-in-find_idlest_gr.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0003-sched-fair-Consider-spare-capacity-in-find_idlest_gr.patch
new file mode 100644
index 0000000..674ebb9
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0003-sched-fair-Consider-spare-capacity-in-find_idlest_gr.patch
@@ -0,0 +1,140 @@
+From 575af3de702dae80c40bf510aaf7755374accb88 Mon Sep 17 00:00:00 2001
+From: Morten Rasmussen <morten.rasmussen@arm.com>
+Date: Fri, 14 Oct 2016 14:41:08 +0100
+Subject: [PATCH 03/92] sched/fair: Consider spare capacity in
+ find_idlest_group()
+
+In low-utilization scenarios comparing relative loads in
+find_idlest_group() doesn't always lead to the most optimum choice.
+Systems with groups containing different numbers of cpus and/or cpus of
+different compute capacity are significantly better off when considering
+spare capacity rather than relative load in those scenarios.
+
+In addition to existing load based search an alternative spare capacity
+based candidate sched_group is found and selected instead if sufficient
+spare capacity exists. If not, existing behaviour is preserved.
+
+Signed-off-by: Morten Rasmussen <morten.rasmussen@arm.com>
+Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
+Cc: Linus Torvalds <torvalds@linux-foundation.org>
+Cc: Peter Zijlstra <peterz@infradead.org>
+Cc: Thomas Gleixner <tglx@linutronix.de>
+Cc: dietmar.eggemann@arm.com
+Cc: freedom.tan@mediatek.com
+Cc: keita.kobayashi.ym@renesas.com
+Cc: mgalbraith@suse.de
+Cc: sgurrappadi@nvidia.com
+Cc: vincent.guittot@linaro.org
+Cc: yuyang.du@intel.com
+Link: http://lkml.kernel.org/r/1476452472-24740-3-git-send-email-morten.rasmussen@arm.com
+Signed-off-by: Ingo Molnar <mingo@kernel.org>
+(cherry picked from commit 6a0b19c0f39a7a7b7fb77d3867a733136ff059a3)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ kernel/sched/fair.c | 50 +++++++++++++++++++++++++++++++++++++++++++++-----
+ 1 file changed, 45 insertions(+), 5 deletions(-)
+
+diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
+index b05d691..1ad3706 100644
+--- a/kernel/sched/fair.c
++++ b/kernel/sched/fair.c
+@@ -5202,6 +5202,14 @@ static int wake_affine(struct sched_domain *sd, struct task_struct *p,
+ 	return 1;
+ }
+ 
++static inline int task_util(struct task_struct *p);
++static int cpu_util_wake(int cpu, struct task_struct *p);
++
++static unsigned long capacity_spare_wake(int cpu, struct task_struct *p)
++{
++	return capacity_orig_of(cpu) - cpu_util_wake(cpu, p);
++}
++
+ /*
+  * find_idlest_group finds and returns the least busy CPU group within the
+  * domain.
+@@ -5211,7 +5219,9 @@ static int wake_affine(struct sched_domain *sd, struct task_struct *p,
+ 		  int this_cpu, int sd_flag)
+ {
+ 	struct sched_group *idlest = NULL, *group = sd->groups;
++	struct sched_group *most_spare_sg = NULL;
+ 	unsigned long min_load = ULONG_MAX, this_load = 0;
++	unsigned long most_spare = 0, this_spare = 0;
+ 	int load_idx = sd->forkexec_idx;
+ 	int imbalance = 100 + (sd->imbalance_pct-100)/2;
+ 
+@@ -5219,7 +5229,7 @@ static int wake_affine(struct sched_domain *sd, struct task_struct *p,
+ 		load_idx = sd->wake_idx;
+ 
+ 	do {
+-		unsigned long load, avg_load;
++		unsigned long load, avg_load, spare_cap, max_spare_cap;
+ 		int local_group;
+ 		int i;
+ 
+@@ -5231,8 +5241,12 @@ static int wake_affine(struct sched_domain *sd, struct task_struct *p,
+ 		local_group = cpumask_test_cpu(this_cpu,
+ 					       sched_group_cpus(group));
+ 
+-		/* Tally up the load of all CPUs in the group */
++		/*
++		 * Tally up the load of all CPUs in the group and find
++		 * the group containing the CPU with most spare capacity.
++		 */
+ 		avg_load = 0;
++		max_spare_cap = 0;
+ 
+ 		for_each_cpu(i, sched_group_cpus(group)) {
+ 			/* Bias balancing toward cpus of our domain */
+@@ -5242,6 +5256,11 @@ static int wake_affine(struct sched_domain *sd, struct task_struct *p,
+ 				load = target_load(i, load_idx);
+ 
+ 			avg_load += load;
++
++			spare_cap = capacity_spare_wake(i, p);
++
++			if (spare_cap > max_spare_cap)
++				max_spare_cap = spare_cap;
+ 		}
+ 
+ 		/* Adjust by relative CPU capacity of the group */
+@@ -5249,12 +5268,33 @@ static int wake_affine(struct sched_domain *sd, struct task_struct *p,
+ 
+ 		if (local_group) {
+ 			this_load = avg_load;
+-		} else if (avg_load < min_load) {
+-			min_load = avg_load;
+-			idlest = group;
++			this_spare = max_spare_cap;
++		} else {
++			if (avg_load < min_load) {
++				min_load = avg_load;
++				idlest = group;
++			}
++
++			if (most_spare < max_spare_cap) {
++				most_spare = max_spare_cap;
++				most_spare_sg = group;
++			}
+ 		}
+ 	} while (group = group->next, group != sd->groups);
+ 
++	/*
++	 * The cross-over point between using spare capacity or least load
++	 * is too conservative for high utilization tasks on partially
++	 * utilized systems if we require spare_capacity > task_util(p),
++	 * so we allow for some task stuffing by using
++	 * spare_capacity > task_util(p)/2.
++	 */
++	if (this_spare > task_util(p) / 2 &&
++	    imbalance*this_spare > 100*most_spare)
++		return NULL;
++	else if (most_spare > task_util(p) / 2)
++		return most_spare_sg;
++
+ 	if (!idlest || 100*this_load < imbalance*min_load)
+ 		return NULL;
+ 	return idlest;
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0004-arm64-Update-the-energy-model-on-CA53-for-R-Car-Gen3.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0004-arm64-Update-the-energy-model-on-CA53-for-R-Car-Gen3.patch
new file mode 100644
index 0000000..39e8d07
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0004-arm64-Update-the-energy-model-on-CA53-for-R-Car-Gen3.patch
@@ -0,0 +1,59 @@
+From b3e079ba90ed7ee0e618a441844f3274c6e49e3b Mon Sep 17 00:00:00 2001
+From: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+Date: Wed, 15 Nov 2017 12:34:48 +0900
+Subject: [PATCH 4/4] arm64: Update the energy model on CA53 for R-Car Gen3
+
+Since the cpu_capacity for CA53 was set smaller than expected, the
+behavior of scheduler may not be suitable a little. This patch fixes
+the reasonable value to fit current implementation. This value should
+be updated again when the turbo mode will support with cpu capacity
+features.
+
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ arch/arm64/kernel/energy_model.h | 8 ++++----
+ 1 file changed, 4 insertions(+), 4 deletions(-)
+
+diff --git a/arch/arm64/kernel/energy_model.h b/arch/arm64/kernel/energy_model.h
+index c2aae4f..f261080 100644
+--- a/arch/arm64/kernel/energy_model.h
++++ b/arch/arm64/kernel/energy_model.h
+@@ -189,7 +189,7 @@ static struct idle_state idle_states_cluster_h3_a57[] = {
+ 
+ static struct capacity_state cap_states_cluster_h3_a53[] = {
+ 	/* Power per cluster */
+-	{ .cap =  379, .power = 16, }, /* 1200 MHz */
++	{ .cap =  432, .power = 16, }, /* 1200 MHz */
+ };
+ 
+ static struct capacity_state cap_states_cluster_h3_a57[] = {
+@@ -231,7 +231,7 @@ static struct idle_state idle_states_core_h3_a57[] = {
+ 
+ static struct capacity_state cap_states_core_h3_a53[] = {
+ 	/* Power per cpu */
+-	{ .cap =  379, .power = 131, }, /* 1200 MHz */
++	{ .cap =  432, .power = 131, }, /* 1200 MHz */
+ };
+ 
+ static struct capacity_state cap_states_core_h3_a57[] = {
+@@ -273,7 +273,7 @@ static struct idle_state idle_states_cluster_m3_a57[] = {
+ 
+ static struct capacity_state cap_states_cluster_m3_a53[] = {
+ 	/* Power per cluster */
+-	{ .cap =  362, .power = 33, }, /* 1200 MHz */
++	{ .cap =  434, .power = 33, }, /* 1200 MHz */
+ };
+ 
+ static struct capacity_state cap_states_cluster_m3_a57[] = {
+@@ -316,7 +316,7 @@ static struct idle_state idle_states_core_m3_a57[] = {
+ 
+ static struct capacity_state cap_states_core_m3_a53[] = {
+ 	/* Power per cpu */
+-	{ .cap =  362, .power = 131, }, /* 1200 MHz */
++	{ .cap =  434, .power = 131, }, /* 1200 MHz */
+ };
+ 
+ static struct capacity_state cap_states_core_m3_a57[] = {
+-- 
+2.7.4
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0004-sched-fair-Add-per-CPU-min-capacity-to-sched_group_c.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0004-sched-fair-Add-per-CPU-min-capacity-to-sched_group_c.patch
new file mode 100644
index 0000000..7932e0b
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0004-sched-fair-Add-per-CPU-min-capacity-to-sched_group_c.patch
@@ -0,0 +1,143 @@
+From 9a434b62bbd9621f05318569949b59d37a0f59ce Mon Sep 17 00:00:00 2001
+From: Morten Rasmussen <morten.rasmussen@arm.com>
+Date: Fri, 14 Oct 2016 14:41:09 +0100
+Subject: [PATCH 04/92] sched/fair: Add per-CPU min capacity to
+ sched_group_capacity
+
+struct sched_group_capacity currently represents the compute capacity
+sum of all CPUs in the sched_group.
+
+Unless it is divided by the group_weight to get the average capacity
+per CPU, it hides differences in CPU capacity for mixed capacity systems
+(e.g. high RT/IRQ utilization or ARM big.LITTLE).
+
+But even the average may not be sufficient if the group covers CPUs of
+different capacities.
+
+Instead, by extending struct sched_group_capacity to indicate min per-CPU
+capacity in the group a suitable group for a given task utilization can
+more easily be found such that CPUs with reduced capacity can be avoided
+for tasks with high utilization (not implemented by this patch).
+
+Signed-off-by: Morten Rasmussen <morten.rasmussen@arm.com>
+Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
+Cc: Linus Torvalds <torvalds@linux-foundation.org>
+Cc: Peter Zijlstra <peterz@infradead.org>
+Cc: Thomas Gleixner <tglx@linutronix.de>
+Cc: dietmar.eggemann@arm.com
+Cc: freedom.tan@mediatek.com
+Cc: keita.kobayashi.ym@renesas.com
+Cc: mgalbraith@suse.de
+Cc: sgurrappadi@nvidia.com
+Cc: vincent.guittot@linaro.org
+Cc: yuyang.du@intel.com
+Link: http://lkml.kernel.org/r/1476452472-24740-4-git-send-email-morten.rasmussen@arm.com
+Signed-off-by: Ingo Molnar <mingo@kernel.org>
+(cherry picked from commit bf475ce0a3dd75b5d1df6c6c14ae25168caa15ac)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ kernel/sched/core.c  |  3 ++-
+ kernel/sched/fair.c  | 17 ++++++++++++-----
+ kernel/sched/sched.h |  3 ++-
+ 3 files changed, 16 insertions(+), 7 deletions(-)
+
+diff --git a/kernel/sched/core.c b/kernel/sched/core.c
+index 154fd68..e891e12 100644
+--- a/kernel/sched/core.c
++++ b/kernel/sched/core.c
+@@ -5707,7 +5707,7 @@ static int sched_domain_debug_one(struct sched_domain *sd, int cpu, int level,
+ 		printk(KERN_CONT " %*pbl",
+ 		       cpumask_pr_args(sched_group_cpus(group)));
+ 		if (group->sgc->capacity != SCHED_CAPACITY_SCALE) {
+-			printk(KERN_CONT " (cpu_capacity = %d)",
++			printk(KERN_CONT " (cpu_capacity = %lu)",
+ 				group->sgc->capacity);
+ 		}
+ 
+@@ -6184,6 +6184,7 @@ int group_balance_cpu(struct sched_group *sg)
+ 		 * die on a /0 trap.
+ 		 */
+ 		sg->sgc->capacity = SCHED_CAPACITY_SCALE * cpumask_weight(sg_span);
++		sg->sgc->min_capacity = SCHED_CAPACITY_SCALE;
+ 
+ 		/*
+ 		 * Make sure the first group of this domain contains the
+diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
+index 1ad3706..faf8f18 100644
+--- a/kernel/sched/fair.c
++++ b/kernel/sched/fair.c
+@@ -6909,13 +6909,14 @@ static void update_cpu_capacity(struct sched_domain *sd, int cpu)
+ 
+ 	cpu_rq(cpu)->cpu_capacity = capacity;
+ 	sdg->sgc->capacity = capacity;
++	sdg->sgc->min_capacity = capacity;
+ }
+ 
+ void update_group_capacity(struct sched_domain *sd, int cpu)
+ {
+ 	struct sched_domain *child = sd->child;
+ 	struct sched_group *group, *sdg = sd->groups;
+-	unsigned long capacity;
++	unsigned long capacity, min_capacity;
+ 	unsigned long interval;
+ 
+ 	interval = msecs_to_jiffies(sd->balance_interval);
+@@ -6928,6 +6929,7 @@ void update_group_capacity(struct sched_domain *sd, int cpu)
+ 	}
+ 
+ 	capacity = 0;
++	min_capacity = ULONG_MAX;
+ 
+ 	if (child->flags & SD_OVERLAP) {
+ 		/*
+@@ -6952,11 +6954,12 @@ void update_group_capacity(struct sched_domain *sd, int cpu)
+ 			 */
+ 			if (unlikely(!rq->sd)) {
+ 				capacity += capacity_of(cpu);
+-				continue;
++			} else {
++				sgc = rq->sd->groups->sgc;
++				capacity += sgc->capacity;
+ 			}
+ 
+-			sgc = rq->sd->groups->sgc;
+-			capacity += sgc->capacity;
++			min_capacity = min(capacity, min_capacity);
+ 		}
+ 	} else  {
+ 		/*
+@@ -6966,12 +6969,16 @@ void update_group_capacity(struct sched_domain *sd, int cpu)
+ 
+ 		group = child->groups;
+ 		do {
+-			capacity += group->sgc->capacity;
++			struct sched_group_capacity *sgc = group->sgc;
++
++			capacity += sgc->capacity;
++			min_capacity = min(sgc->min_capacity, min_capacity);
+ 			group = group->next;
+ 		} while (group != child->groups);
+ 	}
+ 
+ 	sdg->sgc->capacity = capacity;
++	sdg->sgc->min_capacity = min_capacity;
+ }
+ 
+ /*
+diff --git a/kernel/sched/sched.h b/kernel/sched/sched.h
+index 055f935..345c1cc 100644
+--- a/kernel/sched/sched.h
++++ b/kernel/sched/sched.h
+@@ -892,7 +892,8 @@ struct sched_group_capacity {
+ 	 * CPU capacity of this group, SCHED_CAPACITY_SCALE being max capacity
+ 	 * for a single CPU.
+ 	 */
+-	unsigned int capacity;
++	unsigned long capacity;
++	unsigned long min_capacity; /* Min per-CPU capacity in group */
+ 	unsigned long next_update;
+ 	int imbalance; /* XXX unrelated to capacity but shared group state */
+ 
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0005-sched-fair-Avoid-pulling-tasks-from-non-overloaded-h.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0005-sched-fair-Avoid-pulling-tasks-from-non-overloaded-h.patch
new file mode 100644
index 0000000..d4bd2bd
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0005-sched-fair-Avoid-pulling-tasks-from-non-overloaded-h.patch
@@ -0,0 +1,81 @@
+From 3a86f1d4b2d288f765534c1763ed698029376098 Mon Sep 17 00:00:00 2001
+From: Morten Rasmussen <morten.rasmussen@arm.com>
+Date: Fri, 14 Oct 2016 14:41:10 +0100
+Subject: [PATCH 05/92] sched/fair: Avoid pulling tasks from non-overloaded
+ higher capacity groups
+
+For asymmetric CPU capacity systems it is counter-productive for
+throughput if low capacity CPUs are pulling tasks from non-overloaded
+CPUs with higher capacity. The assumption is that higher CPU capacity is
+preferred over running alone in a group with lower CPU capacity.
+
+This patch rejects higher CPU capacity groups with one or less task per
+CPU as potential busiest group which could otherwise lead to a series of
+failing load-balancing attempts leading to a force-migration.
+
+Signed-off-by: Morten Rasmussen <morten.rasmussen@arm.com>
+Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
+Cc: Linus Torvalds <torvalds@linux-foundation.org>
+Cc: Peter Zijlstra <peterz@infradead.org>
+Cc: Thomas Gleixner <tglx@linutronix.de>
+Cc: dietmar.eggemann@arm.com
+Cc: freedom.tan@mediatek.com
+Cc: keita.kobayashi.ym@renesas.com
+Cc: mgalbraith@suse.de
+Cc: sgurrappadi@nvidia.com
+Cc: vincent.guittot@linaro.org
+Cc: yuyang.du@intel.com
+Link: http://lkml.kernel.org/r/1476452472-24740-5-git-send-email-morten.rasmussen@arm.com
+Signed-off-by: Ingo Molnar <mingo@kernel.org>
+(cherry picked from commit 9e0994c0a1c1f82c705f1f66388e1bcffcee8bb9)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ kernel/sched/fair.c | 25 +++++++++++++++++++++++++
+ 1 file changed, 25 insertions(+)
+
+diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
+index faf8f18..ee39bfd 100644
+--- a/kernel/sched/fair.c
++++ b/kernel/sched/fair.c
+@@ -7073,6 +7073,17 @@ static inline int sg_imbalanced(struct sched_group *group)
+ 	return false;
+ }
+ 
++/*
++ * group_smaller_cpu_capacity: Returns true if sched_group sg has smaller
++ * per-CPU capacity than sched_group ref.
++ */
++static inline bool
++group_smaller_cpu_capacity(struct sched_group *sg, struct sched_group *ref)
++{
++	return sg->sgc->min_capacity * capacity_margin <
++						ref->sgc->min_capacity * 1024;
++}
++
+ static inline enum
+ group_type group_classify(struct sched_group *group,
+ 			  struct sg_lb_stats *sgs)
+@@ -7176,6 +7187,20 @@ static bool update_sd_pick_busiest(struct lb_env *env,
+ 	if (sgs->avg_load <= busiest->avg_load)
+ 		return false;
+ 
++	if (!(env->sd->flags & SD_ASYM_CPUCAPACITY))
++		goto asym_packing;
++
++	/*
++	 * Candidate sg has no more than one task per CPU and
++	 * has higher per-CPU capacity. Migrating tasks to less
++	 * capable CPUs may harm throughput. Maximize throughput,
++	 * power/energy consequences are not considered.
++	 */
++	if (sgs->sum_nr_running <= sgs->group_weight &&
++	    group_smaller_cpu_capacity(sds->local, sg))
++		return false;
++
++asym_packing:
+ 	/* This is the busiest node in its class. */
+ 	if (!(env->sd->flags & SD_ASYM_PACKING))
+ 		return true;
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0006-sched-fair-Fix-incorrect-comment-for-capacity_margin.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0006-sched-fair-Fix-incorrect-comment-for-capacity_margin.patch
new file mode 100644
index 0000000..f8619de
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0006-sched-fair-Fix-incorrect-comment-for-capacity_margin.patch
@@ -0,0 +1,47 @@
+From 05c05d839fb3a94d5e07822d06cf0ae8bb8b564d Mon Sep 17 00:00:00 2001
+From: Morten Rasmussen <morten.rasmussen@arm.com>
+Date: Fri, 14 Oct 2016 14:41:12 +0100
+Subject: [PATCH 06/92] sched/fair: Fix incorrect comment for capacity_margin
+
+The comment for capacity_margin introduced in:
+
+  3273163c6775 ("sched/fair: Let asymmetric CPU configurations balance at wake-up")
+
+... got its usage the wrong way round - fix it.
+
+Signed-off-by: Morten Rasmussen <morten.rasmussen@arm.com>
+Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
+Cc: Linus Torvalds <torvalds@linux-foundation.org>
+Cc: Peter Zijlstra <peterz@infradead.org>
+Cc: Thomas Gleixner <tglx@linutronix.de>
+Cc: dietmar.eggemann@arm.com
+Cc: freedom.tan@mediatek.com
+Cc: keita.kobayashi.ym@renesas.com
+Cc: mgalbraith@suse.de
+Cc: sgurrappadi@nvidia.com
+Cc: vincent.guittot@linaro.org
+Cc: yuyang.du@intel.com
+Link: http://lkml.kernel.org/r/1476452472-24740-7-git-send-email-morten.rasmussen@arm.com
+Signed-off-by: Ingo Molnar <mingo@kernel.org>
+(cherry picked from commit 893c5d2279041afeb593f1fa8edd9d02edf5b7cb)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ kernel/sched/fair.c | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
+index ee39bfd..5e6c00a 100644
+--- a/kernel/sched/fair.c
++++ b/kernel/sched/fair.c
+@@ -109,7 +109,7 @@ enum sched_tunable_scaling sysctl_sched_tunable_scaling
+ 
+ /*
+  * The margin used when comparing utilization with CPU capacity:
+- * util * 1024 < capacity * margin
++ * util * margin < capacity * 1024
+  */
+ unsigned int capacity_margin = 1280; /* ~20% */
+ 
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0007-sched-fair-Factorize-attach-detach-entity.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0007-sched-fair-Factorize-attach-detach-entity.patch
new file mode 100644
index 0000000..0773c2c
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0007-sched-fair-Factorize-attach-detach-entity.patch
@@ -0,0 +1,142 @@
+From 3fa8e908c327f136ecfa353f7034b19c6b23f852 Mon Sep 17 00:00:00 2001
+From: Vincent Guittot <vincent.guittot@linaro.org>
+Date: Tue, 8 Nov 2016 10:53:42 +0100
+Subject: [PATCH 07/92] sched/fair: Factorize attach/detach entity
+
+Factorize post_init_entity_util_avg() and part of attach_task_cfs_rq()
+in one function attach_entity_cfs_rq().
+
+Create symmetric detach_entity_cfs_rq() function.
+
+Signed-off-by: Vincent Guittot <vincent.guittot@linaro.org>
+Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
+Acked-by: Dietmar Eggemann <dietmar.eggemann@arm.com>
+Cc: Linus Torvalds <torvalds@linux-foundation.org>
+Cc: Morten.Rasmussen@arm.com
+Cc: Peter Zijlstra <peterz@infradead.org>
+Cc: Thomas Gleixner <tglx@linutronix.de>
+Cc: bsegall@google.com
+Cc: kernellwp@gmail.com
+Cc: pjt@google.com
+Cc: yuyang.du@intel.com
+Link: http://lkml.kernel.org/r/1478598827-32372-2-git-send-email-vincent.guittot@linaro.org
+Signed-off-by: Ingo Molnar <mingo@kernel.org>
+(cherry picked from commit df217913e72ec7e603d8b68cc4c70646cf7000db)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ kernel/sched/fair.c | 53 +++++++++++++++++++++++++++++++----------------------
+ 1 file changed, 31 insertions(+), 22 deletions(-)
+
+diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
+index 5e6c00a..0731aff 100644
+--- a/kernel/sched/fair.c
++++ b/kernel/sched/fair.c
+@@ -701,9 +701,7 @@ void init_entity_runnable_average(struct sched_entity *se)
+ }
+ 
+ static inline u64 cfs_rq_clock_task(struct cfs_rq *cfs_rq);
+-static int update_cfs_rq_load_avg(u64 now, struct cfs_rq *cfs_rq, bool update_freq);
+-static void update_tg_load_avg(struct cfs_rq *cfs_rq, int force);
+-static void attach_entity_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se);
++static void attach_entity_cfs_rq(struct sched_entity *se);
+ 
+ /*
+  * With new tasks being created, their initial util_avgs are extrapolated
+@@ -735,7 +733,6 @@ void post_init_entity_util_avg(struct sched_entity *se)
+ 	struct cfs_rq *cfs_rq = cfs_rq_of(se);
+ 	struct sched_avg *sa = &se->avg;
+ 	long cap = (long)(SCHED_CAPACITY_SCALE - cfs_rq->avg.util_avg) / 2;
+-	u64 now = cfs_rq_clock_task(cfs_rq);
+ 
+ 	if (cap > 0) {
+ 		if (cfs_rq->avg.util_avg != 0) {
+@@ -763,14 +760,12 @@ void post_init_entity_util_avg(struct sched_entity *se)
+ 			 * such that the next switched_to_fair() has the
+ 			 * expected state.
+ 			 */
+-			se->avg.last_update_time = now;
++			se->avg.last_update_time = cfs_rq_clock_task(cfs_rq);
+ 			return;
+ 		}
+ 	}
+ 
+-	update_cfs_rq_load_avg(now, cfs_rq, false);
+-	attach_entity_load_avg(cfs_rq, se);
+-	update_tg_load_avg(cfs_rq, false);
++	attach_entity_cfs_rq(se);
+ }
+ 
+ #else /* !CONFIG_SMP */
+@@ -8783,30 +8778,19 @@ static inline bool vruntime_normalized(struct task_struct *p)
+ 	return false;
+ }
+ 
+-static void detach_task_cfs_rq(struct task_struct *p)
++static void detach_entity_cfs_rq(struct sched_entity *se)
+ {
+-	struct sched_entity *se = &p->se;
+ 	struct cfs_rq *cfs_rq = cfs_rq_of(se);
+ 	u64 now = cfs_rq_clock_task(cfs_rq);
+ 
+-	if (!vruntime_normalized(p)) {
+-		/*
+-		 * Fix up our vruntime so that the current sleep doesn't
+-		 * cause 'unlimited' sleep bonus.
+-		 */
+-		place_entity(cfs_rq, se, 0);
+-		se->vruntime -= cfs_rq->min_vruntime;
+-	}
+-
+ 	/* Catch up with the cfs_rq and remove our load when we leave */
+ 	update_cfs_rq_load_avg(now, cfs_rq, false);
+ 	detach_entity_load_avg(cfs_rq, se);
+ 	update_tg_load_avg(cfs_rq, false);
+ }
+ 
+-static void attach_task_cfs_rq(struct task_struct *p)
++static void attach_entity_cfs_rq(struct sched_entity *se)
+ {
+-	struct sched_entity *se = &p->se;
+ 	struct cfs_rq *cfs_rq = cfs_rq_of(se);
+ 	u64 now = cfs_rq_clock_task(cfs_rq);
+ 
+@@ -8818,10 +8802,35 @@ static void attach_task_cfs_rq(struct task_struct *p)
+ 	se->depth = se->parent ? se->parent->depth + 1 : 0;
+ #endif
+ 
+-	/* Synchronize task with its cfs_rq */
++	/* Synchronize entity with its cfs_rq */
+ 	update_cfs_rq_load_avg(now, cfs_rq, false);
+ 	attach_entity_load_avg(cfs_rq, se);
+ 	update_tg_load_avg(cfs_rq, false);
++}
++
++static void detach_task_cfs_rq(struct task_struct *p)
++{
++	struct sched_entity *se = &p->se;
++	struct cfs_rq *cfs_rq = cfs_rq_of(se);
++
++	if (!vruntime_normalized(p)) {
++		/*
++		 * Fix up our vruntime so that the current sleep doesn't
++		 * cause 'unlimited' sleep bonus.
++		 */
++		place_entity(cfs_rq, se, 0);
++		se->vruntime -= cfs_rq->min_vruntime;
++	}
++
++	detach_entity_cfs_rq(se);
++}
++
++static void attach_task_cfs_rq(struct task_struct *p)
++{
++	struct sched_entity *se = &p->se;
++	struct cfs_rq *cfs_rq = cfs_rq_of(se);
++
++	attach_entity_cfs_rq(se);
+ 
+ 	if (!vruntime_normalized(p))
+ 		se->vruntime += cfs_rq->min_vruntime;
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0008-sched-fair-Fix-hierarchical-order-in-rq-leaf_cfs_rq_.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0008-sched-fair-Fix-hierarchical-order-in-rq-leaf_cfs_rq_.patch
new file mode 100644
index 0000000..323a48f
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0008-sched-fair-Fix-hierarchical-order-in-rq-leaf_cfs_rq_.patch
@@ -0,0 +1,171 @@
+From b351fc19a07fde281957aeb737cd32392c7bf5ba Mon Sep 17 00:00:00 2001
+From: Vincent Guittot <vincent.guittot@linaro.org>
+Date: Tue, 8 Nov 2016 10:53:43 +0100
+Subject: [PATCH 08/92] sched/fair: Fix hierarchical order in
+ rq->leaf_cfs_rq_list
+
+Fix the insertion of cfs_rq in rq->leaf_cfs_rq_list to ensure that a
+child will always be called before its parent.
+
+The hierarchical order in shares update list has been introduced by
+commit:
+
+  67e86250f8ea ("sched: Introduce hierarchal order on shares update list")
+
+With the current implementation a child can be still put after its
+parent.
+
+Lets take the example of:
+
+       root
+        \
+         b
+         /\
+         c d*
+           |
+           e*
+
+with root -> b -> c already enqueued but not d -> e so the
+leaf_cfs_rq_list looks like: head -> c -> b -> root -> tail
+
+The branch d -> e will be added the first time that they are enqueued,
+starting with e then d.
+
+When e is added, its parents is not already on the list so e is put at
+the tail : head -> c -> b -> root -> e -> tail
+
+Then, d is added at the head because its parent is already on the
+list: head -> d -> c -> b -> root -> e -> tail
+
+e is not placed at the right position and will be called the last
+whereas it should be called at the beginning.
+
+Because it follows the bottom-up enqueue sequence, we are sure that we
+will finished to add either a cfs_rq without parent or a cfs_rq with a
+parent that is already on the list. We can use this event to detect
+when we have finished to add a new branch. For the others, whose
+parents are not already added, we have to ensure that they will be
+added after their children that have just been inserted the steps
+before, and after any potential parents that are already in the list.
+The easiest way is to put the cfs_rq just after the last inserted one
+and to keep track of it untl the branch is fully added.
+
+Signed-off-by: Vincent Guittot <vincent.guittot@linaro.org>
+Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
+Acked-by: Dietmar Eggemann <dietmar.eggemann@arm.com>
+Cc: Linus Torvalds <torvalds@linux-foundation.org>
+Cc: Morten.Rasmussen@arm.com
+Cc: Peter Zijlstra <peterz@infradead.org>
+Cc: Thomas Gleixner <tglx@linutronix.de>
+Cc: bsegall@google.com
+Cc: kernellwp@gmail.com
+Cc: pjt@google.com
+Cc: yuyang.du@intel.com
+Link: http://lkml.kernel.org/r/1478598827-32372-3-git-send-email-vincent.guittot@linaro.org
+Signed-off-by: Ingo Molnar <mingo@kernel.org>
+(cherry picked from commit 9c2791f936ef5fd04a118b5c284f2c9a95f4a647)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ kernel/sched/core.c  |  1 +
+ kernel/sched/fair.c  | 54 +++++++++++++++++++++++++++++++++++++++++++++-------
+ kernel/sched/sched.h |  1 +
+ 3 files changed, 49 insertions(+), 7 deletions(-)
+
+diff --git a/kernel/sched/core.c b/kernel/sched/core.c
+index e891e12..391d6c9 100644
+--- a/kernel/sched/core.c
++++ b/kernel/sched/core.c
+@@ -7603,6 +7603,7 @@ void __init sched_init(void)
+ #ifdef CONFIG_FAIR_GROUP_SCHED
+ 		root_task_group.shares = ROOT_TASK_GROUP_LOAD;
+ 		INIT_LIST_HEAD(&rq->leaf_cfs_rq_list);
++		rq->tmp_alone_branch = &rq->leaf_cfs_rq_list;
+ 		/*
+ 		 * How much cpu bandwidth does root_task_group get?
+ 		 *
+diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
+index 0731aff..4a67026 100644
+--- a/kernel/sched/fair.c
++++ b/kernel/sched/fair.c
+@@ -283,19 +283,59 @@ static inline struct cfs_rq *group_cfs_rq(struct sched_entity *grp)
+ static inline void list_add_leaf_cfs_rq(struct cfs_rq *cfs_rq)
+ {
+ 	if (!cfs_rq->on_list) {
++		struct rq *rq = rq_of(cfs_rq);
++		int cpu = cpu_of(rq);
+ 		/*
+ 		 * Ensure we either appear before our parent (if already
+ 		 * enqueued) or force our parent to appear after us when it is
+-		 * enqueued.  The fact that we always enqueue bottom-up
+-		 * reduces this to two cases.
++		 * enqueued. The fact that we always enqueue bottom-up
++		 * reduces this to two cases and a special case for the root
++		 * cfs_rq. Furthermore, it also means that we will always reset
++		 * tmp_alone_branch either when the branch is connected
++		 * to a tree or when we reach the beg of the tree
+ 		 */
+ 		if (cfs_rq->tg->parent &&
+-		    cfs_rq->tg->parent->cfs_rq[cpu_of(rq_of(cfs_rq))]->on_list) {
+-			list_add_rcu(&cfs_rq->leaf_cfs_rq_list,
+-				&rq_of(cfs_rq)->leaf_cfs_rq_list);
+-		} else {
++		    cfs_rq->tg->parent->cfs_rq[cpu]->on_list) {
++			/*
++			 * If parent is already on the list, we add the child
++			 * just before. Thanks to circular linked property of
++			 * the list, this means to put the child at the tail
++			 * of the list that starts by parent.
++			 */
++			list_add_tail_rcu(&cfs_rq->leaf_cfs_rq_list,
++				&(cfs_rq->tg->parent->cfs_rq[cpu]->leaf_cfs_rq_list));
++			/*
++			 * The branch is now connected to its tree so we can
++			 * reset tmp_alone_branch to the beginning of the
++			 * list.
++			 */
++			rq->tmp_alone_branch = &rq->leaf_cfs_rq_list;
++		} else if (!cfs_rq->tg->parent) {
++			/*
++			 * cfs rq without parent should be put
++			 * at the tail of the list.
++			 */
+ 			list_add_tail_rcu(&cfs_rq->leaf_cfs_rq_list,
+-				&rq_of(cfs_rq)->leaf_cfs_rq_list);
++				&rq->leaf_cfs_rq_list);
++			/*
++			 * We have reach the beg of a tree so we can reset
++			 * tmp_alone_branch to the beginning of the list.
++			 */
++			rq->tmp_alone_branch = &rq->leaf_cfs_rq_list;
++		} else {
++			/*
++			 * The parent has not already been added so we want to
++			 * make sure that it will be put after us.
++			 * tmp_alone_branch points to the beg of the branch
++			 * where we will add parent.
++			 */
++			list_add_rcu(&cfs_rq->leaf_cfs_rq_list,
++				rq->tmp_alone_branch);
++			/*
++			 * update tmp_alone_branch to points to the new beg
++			 * of the branch
++			 */
++			rq->tmp_alone_branch = &cfs_rq->leaf_cfs_rq_list;
+ 		}
+ 
+ 		cfs_rq->on_list = 1;
+diff --git a/kernel/sched/sched.h b/kernel/sched/sched.h
+index 345c1cc..36f30e0 100644
+--- a/kernel/sched/sched.h
++++ b/kernel/sched/sched.h
+@@ -623,6 +623,7 @@ struct rq {
+ #ifdef CONFIG_FAIR_GROUP_SCHED
+ 	/* list of leaf cfs_rq on this cpu: */
+ 	struct list_head leaf_cfs_rq_list;
++	struct list_head *tmp_alone_branch;
+ #endif /* CONFIG_FAIR_GROUP_SCHED */
+ 
+ 	/*
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0009-sched-fair-Factorize-PELT-update.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0009-sched-fair-Factorize-PELT-update.patch
new file mode 100644
index 0000000..b5c051c
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0009-sched-fair-Factorize-PELT-update.patch
@@ -0,0 +1,242 @@
+From 5fce03ae44059401dcf219ca80a53850fed51932 Mon Sep 17 00:00:00 2001
+From: Vincent Guittot <vincent.guittot@linaro.org>
+Date: Tue, 8 Nov 2016 10:53:44 +0100
+Subject: [PATCH 09/92] sched/fair: Factorize PELT update
+
+Every time we modify load/utilization of sched_entity, we start to
+sync it with its cfs_rq. This update is done in different ways:
+
+ - when attaching/detaching a sched_entity, we update cfs_rq and then
+   we sync the entity with the cfs_rq.
+
+ - when enqueueing/dequeuing the sched_entity, we update both
+   sched_entity and cfs_rq metrics to now.
+
+Use update_load_avg() everytime we have to update and sync cfs_rq and
+sched_entity before changing the state of a sched_enity.
+
+Signed-off-by: Vincent Guittot <vincent.guittot@linaro.org>
+Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
+Acked-by: Dietmar Eggemann <dietmar.eggemann@arm.com>
+Cc: Linus Torvalds <torvalds@linux-foundation.org>
+Cc: Morten.Rasmussen@arm.com
+Cc: Peter Zijlstra <peterz@infradead.org>
+Cc: Thomas Gleixner <tglx@linutronix.de>
+Cc: bsegall@google.com
+Cc: kernellwp@gmail.com
+Cc: pjt@google.com
+Cc: yuyang.du@intel.com
+Link: http://lkml.kernel.org/r/1478598827-32372-4-git-send-email-vincent.guittot@linaro.org
+Signed-off-by: Ingo Molnar <mingo@kernel.org>
+(cherry picked from commit d31b1a66cbe0931733583ad9d9e8c6cfd710907d)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ kernel/sched/fair.c | 76 ++++++++++++++++++-----------------------------------
+ 1 file changed, 25 insertions(+), 51 deletions(-)
+
+diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
+index 4a67026..d707ad0 100644
+--- a/kernel/sched/fair.c
++++ b/kernel/sched/fair.c
+@@ -3092,8 +3092,14 @@ static inline void cfs_rq_util_change(struct cfs_rq *cfs_rq)
+ 	return decayed || removed_load;
+ }
+ 
++/*
++ * Optional action to be done while updating the load average
++ */
++#define UPDATE_TG	0x1
++#define SKIP_AGE_LOAD	0x2
++
+ /* Update task and its cfs_rq load average */
+-static inline void update_load_avg(struct sched_entity *se, int update_tg)
++static inline void update_load_avg(struct sched_entity *se, int flags)
+ {
+ 	struct cfs_rq *cfs_rq = cfs_rq_of(se);
+ 	u64 now = cfs_rq_clock_task(cfs_rq);
+@@ -3104,11 +3110,13 @@ static inline void update_load_avg(struct sched_entity *se, int update_tg)
+ 	 * Track task load average for carrying it to new CPU after migrated, and
+ 	 * track group sched_entity load average for task_h_load calc in migration
+ 	 */
+-	__update_load_avg(now, cpu, &se->avg,
++	if (se->avg.last_update_time && !(flags & SKIP_AGE_LOAD)) {
++		__update_load_avg(now, cpu, &se->avg,
+ 			  se->on_rq * scale_load_down(se->load.weight),
+ 			  cfs_rq->curr == se, NULL);
++	}
+ 
+-	if (update_cfs_rq_load_avg(now, cfs_rq, true) && update_tg)
++	if (update_cfs_rq_load_avg(now, cfs_rq, true) && (flags & UPDATE_TG))
+ 		update_tg_load_avg(cfs_rq, 0);
+ }
+ 
+@@ -3122,26 +3130,6 @@ static inline void update_load_avg(struct sched_entity *se, int update_tg)
+  */
+ static void attach_entity_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se)
+ {
+-	if (!sched_feat(ATTACH_AGE_LOAD))
+-		goto skip_aging;
+-
+-	/*
+-	 * If we got migrated (either between CPUs or between cgroups) we'll
+-	 * have aged the average right before clearing @last_update_time.
+-	 *
+-	 * Or we're fresh through post_init_entity_util_avg().
+-	 */
+-	if (se->avg.last_update_time) {
+-		__update_load_avg(cfs_rq->avg.last_update_time, cpu_of(rq_of(cfs_rq)),
+-				  &se->avg, 0, 0, NULL);
+-
+-		/*
+-		 * XXX: we could have just aged the entire load away if we've been
+-		 * absent from the fair class for too long.
+-		 */
+-	}
+-
+-skip_aging:
+ 	se->avg.last_update_time = cfs_rq->avg.last_update_time;
+ 	cfs_rq->avg.load_avg += se->avg.load_avg;
+ 	cfs_rq->avg.load_sum += se->avg.load_sum;
+@@ -3161,9 +3149,6 @@ static void attach_entity_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *s
+  */
+ static void detach_entity_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se)
+ {
+-	__update_load_avg(cfs_rq->avg.last_update_time, cpu_of(rq_of(cfs_rq)),
+-			  &se->avg, se->on_rq * scale_load_down(se->load.weight),
+-			  cfs_rq->curr == se, NULL);
+ 
+ 	sub_positive(&cfs_rq->avg.load_avg, se->avg.load_avg);
+ 	sub_positive(&cfs_rq->avg.load_sum, se->avg.load_sum);
+@@ -3178,34 +3163,20 @@ static void detach_entity_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *s
+ enqueue_entity_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se)
+ {
+ 	struct sched_avg *sa = &se->avg;
+-	u64 now = cfs_rq_clock_task(cfs_rq);
+-	int migrated, decayed;
+-
+-	migrated = !sa->last_update_time;
+-	if (!migrated) {
+-		__update_load_avg(now, cpu_of(rq_of(cfs_rq)), sa,
+-			se->on_rq * scale_load_down(se->load.weight),
+-			cfs_rq->curr == se, NULL);
+-	}
+-
+-	decayed = update_cfs_rq_load_avg(now, cfs_rq, !migrated);
+ 
+ 	cfs_rq->runnable_load_avg += sa->load_avg;
+ 	cfs_rq->runnable_load_sum += sa->load_sum;
+ 
+-	if (migrated)
++	if (!sa->last_update_time) {
+ 		attach_entity_load_avg(cfs_rq, se);
+-
+-	if (decayed || migrated)
+ 		update_tg_load_avg(cfs_rq, 0);
++	}
+ }
+ 
+ /* Remove the runnable load generated by se from cfs_rq's runnable load average */
+ static inline void
+ dequeue_entity_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se)
+ {
+-	update_load_avg(se, 1);
+-
+ 	cfs_rq->runnable_load_avg =
+ 		max_t(long, cfs_rq->runnable_load_avg - se->avg.load_avg, 0);
+ 	cfs_rq->runnable_load_sum =
+@@ -3289,7 +3260,10 @@ static inline unsigned long cfs_rq_load_avg(struct cfs_rq *cfs_rq)
+ 	return 0;
+ }
+ 
+-static inline void update_load_avg(struct sched_entity *se, int not_used)
++#define UPDATE_TG	0x0
++#define SKIP_AGE_LOAD	0x0
++
++static inline void update_load_avg(struct sched_entity *se, int not_used1)
+ {
+ 	cpufreq_update_util(rq_of(cfs_rq_of(se)), 0);
+ }
+@@ -3434,6 +3408,7 @@ static inline void check_schedstat_required(void)
+ 	if (renorm && !curr)
+ 		se->vruntime += cfs_rq->min_vruntime;
+ 
++	update_load_avg(se, UPDATE_TG);
+ 	enqueue_entity_load_avg(cfs_rq, se);
+ 	account_entity_enqueue(cfs_rq, se);
+ 	update_cfs_shares(cfs_rq);
+@@ -3508,6 +3483,7 @@ static void clear_buddies(struct cfs_rq *cfs_rq, struct sched_entity *se)
+ 	 * Update run-time statistics of the 'current'.
+ 	 */
+ 	update_curr(cfs_rq);
++	update_load_avg(se, UPDATE_TG);
+ 	dequeue_entity_load_avg(cfs_rq, se);
+ 
+ 	update_stats_dequeue(cfs_rq, se, flags);
+@@ -3595,7 +3571,7 @@ static void clear_buddies(struct cfs_rq *cfs_rq, struct sched_entity *se)
+ 		 */
+ 		update_stats_wait_end(cfs_rq, se);
+ 		__dequeue_entity(cfs_rq, se);
+-		update_load_avg(se, 1);
++		update_load_avg(se, UPDATE_TG);
+ 	}
+ 
+ 	update_stats_curr_start(cfs_rq, se);
+@@ -3713,7 +3689,7 @@ static void put_prev_entity(struct cfs_rq *cfs_rq, struct sched_entity *prev)
+ 	/*
+ 	 * Ensure that runnable average is periodically updated.
+ 	 */
+-	update_load_avg(curr, 1);
++	update_load_avg(curr, UPDATE_TG);
+ 	update_cfs_shares(cfs_rq);
+ 
+ #ifdef CONFIG_SCHED_HRTICK
+@@ -4610,7 +4586,7 @@ static inline void hrtick_update(struct rq *rq)
+ 		if (cfs_rq_throttled(cfs_rq))
+ 			break;
+ 
+-		update_load_avg(se, 1);
++		update_load_avg(se, UPDATE_TG);
+ 		update_cfs_shares(cfs_rq);
+ 	}
+ 
+@@ -4669,7 +4645,7 @@ static void dequeue_task_fair(struct rq *rq, struct task_struct *p, int flags)
+ 		if (cfs_rq_throttled(cfs_rq))
+ 			break;
+ 
+-		update_load_avg(se, 1);
++		update_load_avg(se, UPDATE_TG);
+ 		update_cfs_shares(cfs_rq);
+ 	}
+ 
+@@ -8821,10 +8797,9 @@ static inline bool vruntime_normalized(struct task_struct *p)
+ static void detach_entity_cfs_rq(struct sched_entity *se)
+ {
+ 	struct cfs_rq *cfs_rq = cfs_rq_of(se);
+-	u64 now = cfs_rq_clock_task(cfs_rq);
+ 
+ 	/* Catch up with the cfs_rq and remove our load when we leave */
+-	update_cfs_rq_load_avg(now, cfs_rq, false);
++	update_load_avg(se, 0);
+ 	detach_entity_load_avg(cfs_rq, se);
+ 	update_tg_load_avg(cfs_rq, false);
+ }
+@@ -8832,7 +8807,6 @@ static void detach_entity_cfs_rq(struct sched_entity *se)
+ static void attach_entity_cfs_rq(struct sched_entity *se)
+ {
+ 	struct cfs_rq *cfs_rq = cfs_rq_of(se);
+-	u64 now = cfs_rq_clock_task(cfs_rq);
+ 
+ #ifdef CONFIG_FAIR_GROUP_SCHED
+ 	/*
+@@ -8843,7 +8817,7 @@ static void attach_entity_cfs_rq(struct sched_entity *se)
+ #endif
+ 
+ 	/* Synchronize entity with its cfs_rq */
+-	update_cfs_rq_load_avg(now, cfs_rq, false);
++	update_load_avg(se, sched_feat(ATTACH_AGE_LOAD) ? 0 : SKIP_AGE_LOAD);
+ 	attach_entity_load_avg(cfs_rq, se);
+ 	update_tg_load_avg(cfs_rq, false);
+ }
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0010-sched-fair-Propagate-load-during-synchronous-attach-.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0010-sched-fair-Propagate-load-during-synchronous-attach-.patch
new file mode 100644
index 0000000..13bcd06
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0010-sched-fair-Propagate-load-during-synchronous-attach-.patch
@@ -0,0 +1,319 @@
+From bf9dc711b0003a71003b9da414efa25ebae3e5f7 Mon Sep 17 00:00:00 2001
+From: Vincent Guittot <vincent.guittot@linaro.org>
+Date: Tue, 8 Nov 2016 10:53:45 +0100
+Subject: [PATCH 10/92] sched/fair: Propagate load during synchronous
+ attach/detach
+
+When a task moves from/to a cfs_rq, we set a flag which is then used to
+propagate the change at parent level (sched_entity and cfs_rq) during
+next update. If the cfs_rq is throttled, the flag will stay pending until
+the cfs_rq is unthrottled.
+
+For propagating the utilization, we copy the utilization of group cfs_rq to
+the sched_entity.
+
+For propagating the load, we have to take into account the load of the
+whole task group in order to evaluate the load of the sched_entity.
+Similarly to what was done before the rewrite of PELT, we add a correction
+factor in case the task group's load is greater than its share so it will
+contribute the same load of a task of equal weight.
+
+Signed-off-by: Vincent Guittot <vincent.guittot@linaro.org>
+Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
+Acked-by: Dietmar Eggemann <dietmar.eggemann@arm.com>
+Cc: Linus Torvalds <torvalds@linux-foundation.org>
+Cc: Morten.Rasmussen@arm.com
+Cc: Peter Zijlstra <peterz@infradead.org>
+Cc: Thomas Gleixner <tglx@linutronix.de>
+Cc: bsegall@google.com
+Cc: kernellwp@gmail.com
+Cc: pjt@google.com
+Cc: yuyang.du@intel.com
+Link: http://lkml.kernel.org/r/1478598827-32372-5-git-send-email-vincent.guittot@linaro.org
+Signed-off-by: Ingo Molnar <mingo@kernel.org>
+(cherry picked from commit 09a43ace1f986b003c118fdf6ddf1fd685692d49)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ kernel/sched/fair.c  | 188 ++++++++++++++++++++++++++++++++++++++++++++++++++-
+ kernel/sched/sched.h |   1 +
+ 2 files changed, 188 insertions(+), 1 deletion(-)
+
+diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
+index d707ad0..8cf26fd 100644
+--- a/kernel/sched/fair.c
++++ b/kernel/sched/fair.c
+@@ -2918,6 +2918,26 @@ static u32 __compute_runnable_contrib(u64 n)
+ 	return decayed;
+ }
+ 
++/*
++ * Signed add and clamp on underflow.
++ *
++ * Explicitly do a load-store to ensure the intermediate value never hits
++ * memory. This allows lockless observations without ever seeing the negative
++ * values.
++ */
++#define add_positive(_ptr, _val) do {                           \
++	typeof(_ptr) ptr = (_ptr);                              \
++	typeof(_val) val = (_val);                              \
++	typeof(*ptr) res, var = READ_ONCE(*ptr);                \
++								\
++	res = var + val;                                        \
++								\
++	if (val < 0 && res > var)                               \
++		res = 0;                                        \
++								\
++	WRITE_ONCE(*ptr, res);                                  \
++} while (0)
++
+ #ifdef CONFIG_FAIR_GROUP_SCHED
+ /**
+  * update_tg_load_avg - update the tg's load avg
+@@ -2997,8 +3017,138 @@ void set_task_rq_fair(struct sched_entity *se,
+ 		se->avg.last_update_time = n_last_update_time;
+ 	}
+ }
++
++/* Take into account change of utilization of a child task group */
++static inline void
++update_tg_cfs_util(struct cfs_rq *cfs_rq, struct sched_entity *se)
++{
++	struct cfs_rq *gcfs_rq = group_cfs_rq(se);
++	long delta = gcfs_rq->avg.util_avg - se->avg.util_avg;
++
++	/* Nothing to update */
++	if (!delta)
++		return;
++
++	/* Set new sched_entity's utilization */
++	se->avg.util_avg = gcfs_rq->avg.util_avg;
++	se->avg.util_sum = se->avg.util_avg * LOAD_AVG_MAX;
++
++	/* Update parent cfs_rq utilization */
++	add_positive(&cfs_rq->avg.util_avg, delta);
++	cfs_rq->avg.util_sum = cfs_rq->avg.util_avg * LOAD_AVG_MAX;
++}
++
++/* Take into account change of load of a child task group */
++static inline void
++update_tg_cfs_load(struct cfs_rq *cfs_rq, struct sched_entity *se)
++{
++	struct cfs_rq *gcfs_rq = group_cfs_rq(se);
++	long delta, load = gcfs_rq->avg.load_avg;
++
++	/*
++	 * If the load of group cfs_rq is null, the load of the
++	 * sched_entity will also be null so we can skip the formula
++	 */
++	if (load) {
++		long tg_load;
++
++		/* Get tg's load and ensure tg_load > 0 */
++		tg_load = atomic_long_read(&gcfs_rq->tg->load_avg) + 1;
++
++		/* Ensure tg_load >= load and updated with current load*/
++		tg_load -= gcfs_rq->tg_load_avg_contrib;
++		tg_load += load;
++
++		/*
++		 * We need to compute a correction term in the case that the
++		 * task group is consuming more CPU than a task of equal
++		 * weight. A task with a weight equals to tg->shares will have
++		 * a load less or equal to scale_load_down(tg->shares).
++		 * Similarly, the sched_entities that represent the task group
++		 * at parent level, can't have a load higher than
++		 * scale_load_down(tg->shares). And the Sum of sched_entities'
++		 * load must be <= scale_load_down(tg->shares).
++		 */
++		if (tg_load > scale_load_down(gcfs_rq->tg->shares)) {
++			/* scale gcfs_rq's load into tg's shares*/
++			load *= scale_load_down(gcfs_rq->tg->shares);
++			load /= tg_load;
++		}
++	}
++
++	delta = load - se->avg.load_avg;
++
++	/* Nothing to update */
++	if (!delta)
++		return;
++
++	/* Set new sched_entity's load */
++	se->avg.load_avg = load;
++	se->avg.load_sum = se->avg.load_avg * LOAD_AVG_MAX;
++
++	/* Update parent cfs_rq load */
++	add_positive(&cfs_rq->avg.load_avg, delta);
++	cfs_rq->avg.load_sum = cfs_rq->avg.load_avg * LOAD_AVG_MAX;
++
++	/*
++	 * If the sched_entity is already enqueued, we also have to update the
++	 * runnable load avg.
++	 */
++	if (se->on_rq) {
++		/* Update parent cfs_rq runnable_load_avg */
++		add_positive(&cfs_rq->runnable_load_avg, delta);
++		cfs_rq->runnable_load_sum = cfs_rq->runnable_load_avg * LOAD_AVG_MAX;
++	}
++}
++
++static inline void set_tg_cfs_propagate(struct cfs_rq *cfs_rq)
++{
++	cfs_rq->propagate_avg = 1;
++}
++
++static inline int test_and_clear_tg_cfs_propagate(struct sched_entity *se)
++{
++	struct cfs_rq *cfs_rq = group_cfs_rq(se);
++
++	if (!cfs_rq->propagate_avg)
++		return 0;
++
++	cfs_rq->propagate_avg = 0;
++	return 1;
++}
++
++/* Update task and its cfs_rq load average */
++static inline int propagate_entity_load_avg(struct sched_entity *se)
++{
++	struct cfs_rq *cfs_rq;
++
++	if (entity_is_task(se))
++		return 0;
++
++	if (!test_and_clear_tg_cfs_propagate(se))
++		return 0;
++
++	cfs_rq = cfs_rq_of(se);
++
++	set_tg_cfs_propagate(cfs_rq);
++
++	update_tg_cfs_util(cfs_rq, se);
++	update_tg_cfs_load(cfs_rq, se);
++
++	return 1;
++}
++
+ #else /* CONFIG_FAIR_GROUP_SCHED */
++
+ static inline void update_tg_load_avg(struct cfs_rq *cfs_rq, int force) {}
++
++static inline int propagate_entity_load_avg(struct sched_entity *se)
++{
++	return 0;
++}
++
++static inline void set_tg_cfs_propagate(struct cfs_rq *cfs_rq) {}
++
+ #endif /* CONFIG_FAIR_GROUP_SCHED */
+ 
+ static inline void cfs_rq_util_change(struct cfs_rq *cfs_rq)
+@@ -3105,6 +3255,7 @@ static inline void update_load_avg(struct sched_entity *se, int flags)
+ 	u64 now = cfs_rq_clock_task(cfs_rq);
+ 	struct rq *rq = rq_of(cfs_rq);
+ 	int cpu = cpu_of(rq);
++	int decayed;
+ 
+ 	/*
+ 	 * Track task load average for carrying it to new CPU after migrated, and
+@@ -3116,7 +3267,10 @@ static inline void update_load_avg(struct sched_entity *se, int flags)
+ 			  cfs_rq->curr == se, NULL);
+ 	}
+ 
+-	if (update_cfs_rq_load_avg(now, cfs_rq, true) && (flags & UPDATE_TG))
++	decayed  = update_cfs_rq_load_avg(now, cfs_rq, true);
++	decayed |= propagate_entity_load_avg(se);
++
++	if (decayed && (flags & UPDATE_TG))
+ 		update_tg_load_avg(cfs_rq, 0);
+ }
+ 
+@@ -3135,6 +3289,7 @@ static void attach_entity_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *s
+ 	cfs_rq->avg.load_sum += se->avg.load_sum;
+ 	cfs_rq->avg.util_avg += se->avg.util_avg;
+ 	cfs_rq->avg.util_sum += se->avg.util_sum;
++	set_tg_cfs_propagate(cfs_rq);
+ 
+ 	cfs_rq_util_change(cfs_rq);
+ }
+@@ -3154,6 +3309,7 @@ static void detach_entity_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *s
+ 	sub_positive(&cfs_rq->avg.load_sum, se->avg.load_sum);
+ 	sub_positive(&cfs_rq->avg.util_avg, se->avg.util_avg);
+ 	sub_positive(&cfs_rq->avg.util_sum, se->avg.util_sum);
++	set_tg_cfs_propagate(cfs_rq);
+ 
+ 	cfs_rq_util_change(cfs_rq);
+ }
+@@ -8794,6 +8950,31 @@ static inline bool vruntime_normalized(struct task_struct *p)
+ 	return false;
+ }
+ 
++#ifdef CONFIG_FAIR_GROUP_SCHED
++/*
++ * Propagate the changes of the sched_entity across the tg tree to make it
++ * visible to the root
++ */
++static void propagate_entity_cfs_rq(struct sched_entity *se)
++{
++	struct cfs_rq *cfs_rq;
++
++	/* Start to propagate at parent */
++	se = se->parent;
++
++	for_each_sched_entity(se) {
++		cfs_rq = cfs_rq_of(se);
++
++		if (cfs_rq_throttled(cfs_rq))
++			break;
++
++		update_load_avg(se, UPDATE_TG);
++	}
++}
++#else
++static void propagate_entity_cfs_rq(struct sched_entity *se) { }
++#endif
++
+ static void detach_entity_cfs_rq(struct sched_entity *se)
+ {
+ 	struct cfs_rq *cfs_rq = cfs_rq_of(se);
+@@ -8802,6 +8983,7 @@ static void detach_entity_cfs_rq(struct sched_entity *se)
+ 	update_load_avg(se, 0);
+ 	detach_entity_load_avg(cfs_rq, se);
+ 	update_tg_load_avg(cfs_rq, false);
++	propagate_entity_cfs_rq(se);
+ }
+ 
+ static void attach_entity_cfs_rq(struct sched_entity *se)
+@@ -8820,6 +9002,7 @@ static void attach_entity_cfs_rq(struct sched_entity *se)
+ 	update_load_avg(se, sched_feat(ATTACH_AGE_LOAD) ? 0 : SKIP_AGE_LOAD);
+ 	attach_entity_load_avg(cfs_rq, se);
+ 	update_tg_load_avg(cfs_rq, false);
++	propagate_entity_cfs_rq(se);
+ }
+ 
+ static void detach_task_cfs_rq(struct task_struct *p)
+@@ -8898,6 +9081,9 @@ void init_cfs_rq(struct cfs_rq *cfs_rq)
+ 	cfs_rq->min_vruntime_copy = cfs_rq->min_vruntime;
+ #endif
+ #ifdef CONFIG_SMP
++#ifdef CONFIG_FAIR_GROUP_SCHED
++	cfs_rq->propagate_avg = 0;
++#endif
+ 	atomic_long_set(&cfs_rq->removed_load_avg, 0);
+ 	atomic_long_set(&cfs_rq->removed_util_avg, 0);
+ #endif
+diff --git a/kernel/sched/sched.h b/kernel/sched/sched.h
+index 36f30e0..d7e3931 100644
+--- a/kernel/sched/sched.h
++++ b/kernel/sched/sched.h
+@@ -404,6 +404,7 @@ struct cfs_rq {
+ 	unsigned long runnable_load_avg;
+ #ifdef CONFIG_FAIR_GROUP_SCHED
+ 	unsigned long tg_load_avg_contrib;
++	unsigned long propagate_avg;
+ #endif
+ 	atomic_long_t removed_load_avg, removed_util_avg;
+ #ifndef CONFIG_64BIT
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0011-sched-fair-Propagate-asynchrous-detach.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0011-sched-fair-Propagate-asynchrous-detach.patch
new file mode 100644
index 0000000..3d7412a
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0011-sched-fair-Propagate-asynchrous-detach.patch
@@ -0,0 +1,72 @@
+From 02927c812e8cd4ebd635e567ccd935d9e87075b8 Mon Sep 17 00:00:00 2001
+From: Vincent Guittot <vincent.guittot@linaro.org>
+Date: Tue, 8 Nov 2016 10:53:46 +0100
+Subject: [PATCH 11/92] sched/fair: Propagate asynchrous detach
+
+A task can be asynchronously detached from cfs_rq when migrating
+between CPUs. The load of the migrated task is then removed from
+source cfs_rq during its next update. We use this event to set
+propagation flag.
+
+During the load balance, we take advantage of the update of blocked
+load to propagate any pending changes.
+
+The propagation relies on patch:
+
+  "sched: Fix hierarchical order in rq->leaf_cfs_rq_list"
+
+... which orders children and parents, to ensure that it's done in one pass.
+
+Signed-off-by: Vincent Guittot <vincent.guittot@linaro.org>
+Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
+Acked-by: Dietmar Eggemann <dietmar.eggemann@arm.com>
+Cc: Linus Torvalds <torvalds@linux-foundation.org>
+Cc: Morten.Rasmussen@arm.com
+Cc: Peter Zijlstra <peterz@infradead.org>
+Cc: Thomas Gleixner <tglx@linutronix.de>
+Cc: bsegall@google.com
+Cc: kernellwp@gmail.com
+Cc: pjt@google.com
+Cc: yuyang.du@intel.com
+Link: http://lkml.kernel.org/r/1478598827-32372-6-git-send-email-vincent.guittot@linaro.org
+Signed-off-by: Ingo Molnar <mingo@kernel.org>
+(cherry picked from commit 4e5160766fcc9f41bbd38bac11f92dce993644aa)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ kernel/sched/fair.c | 6 ++++++
+ 1 file changed, 6 insertions(+)
+
+diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
+index 8cf26fd..090a9bb 100644
+--- a/kernel/sched/fair.c
++++ b/kernel/sched/fair.c
+@@ -3219,6 +3219,7 @@ static inline void cfs_rq_util_change(struct cfs_rq *cfs_rq)
+ 		sub_positive(&sa->load_avg, r);
+ 		sub_positive(&sa->load_sum, r * LOAD_AVG_MAX);
+ 		removed_load = 1;
++		set_tg_cfs_propagate(cfs_rq);
+ 	}
+ 
+ 	if (atomic_long_read(&cfs_rq->removed_util_avg)) {
+@@ -3226,6 +3227,7 @@ static inline void cfs_rq_util_change(struct cfs_rq *cfs_rq)
+ 		sub_positive(&sa->util_avg, r);
+ 		sub_positive(&sa->util_sum, r * LOAD_AVG_MAX);
+ 		removed_util = 1;
++		set_tg_cfs_propagate(cfs_rq);
+ 	}
+ 
+ 	decayed = __update_load_avg(now, cpu_of(rq_of(cfs_rq)), sa,
+@@ -6872,6 +6874,10 @@ static void update_blocked_averages(int cpu)
+ 
+ 		if (update_cfs_rq_load_avg(cfs_rq_clock_task(cfs_rq), cfs_rq, true))
+ 			update_tg_load_avg(cfs_rq, 0);
++
++		/* Propagate pending load changes to the parent */
++		if (cfs_rq->tg->se[cpu])
++			update_load_avg(cfs_rq->tg->se[cpu], 0);
+ 	}
+ 	raw_spin_unlock_irqrestore(&rq->lock, flags);
+ }
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0012-sched-fair-Fix-task-group-initialization.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0012-sched-fair-Fix-task-group-initialization.patch
new file mode 100644
index 0000000..e8703ba
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0012-sched-fair-Fix-task-group-initialization.patch
@@ -0,0 +1,43 @@
+From c71758c426fd1c0e04b6f870b57c0434cb73246a Mon Sep 17 00:00:00 2001
+From: Vincent Guittot <vincent.guittot@linaro.org>
+Date: Tue, 8 Nov 2016 10:53:47 +0100
+Subject: [PATCH 12/92] sched/fair: Fix task group initialization
+
+The moves of tasks are now propagated down to root and the utilization
+of cfs_rq reflects reality so it doesn't need to be estimated at init.
+
+Signed-off-by: Vincent Guittot <vincent.guittot@linaro.org>
+Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
+Acked-by: Dietmar Eggemann <dietmar.eggemann@arm.com>
+Cc: Linus Torvalds <torvalds@linux-foundation.org>
+Cc: Morten.Rasmussen@arm.com
+Cc: Peter Zijlstra <peterz@infradead.org>
+Cc: Thomas Gleixner <tglx@linutronix.de>
+Cc: bsegall@google.com
+Cc: kernellwp@gmail.com
+Cc: pjt@google.com
+Cc: yuyang.du@intel.com
+Link: http://lkml.kernel.org/r/1478598827-32372-7-git-send-email-vincent.guittot@linaro.org
+Signed-off-by: Ingo Molnar <mingo@kernel.org>
+(cherry picked from commit d03266910a533d874c01ef2ca8dc73009f2925fa)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ kernel/sched/fair.c | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
+index 090a9bb..02605f2 100644
+--- a/kernel/sched/fair.c
++++ b/kernel/sched/fair.c
+@@ -9198,7 +9198,7 @@ void online_fair_sched_group(struct task_group *tg)
+ 		se = tg->se[i];
+ 
+ 		raw_spin_lock_irq(&rq->lock);
+-		post_init_entity_util_avg(se);
++		attach_entity_cfs_rq(se);
+ 		sync_throttle(tg, i);
+ 		raw_spin_unlock_irq(&rq->lock);
+ 	}
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0013-sched-dl-Fix-comment-in-pick_next_task_dl.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0013-sched-dl-Fix-comment-in-pick_next_task_dl.patch
new file mode 100644
index 0000000..6458474
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0013-sched-dl-Fix-comment-in-pick_next_task_dl.patch
@@ -0,0 +1,38 @@
+From a1ca4aea32f8ec66617aca32decdab5f0dd51182 Mon Sep 17 00:00:00 2001
+From: "T.Zhou" <t1zhou@163.com>
+Date: Wed, 23 Nov 2016 08:48:32 +0800
+Subject: [PATCH 13/92] sched/dl: Fix comment in pick_next_task_dl()
+
+Fix cut & paste oversight:
+
+  s/pull_rt_task/pull_dl_task
+
+Signed-off-by: T.Zhou <t1zhou@163.com>
+Cc: Linus Torvalds <torvalds@linux-foundation.org>
+Cc: Peter Zijlstra <peterz@infradead.org>
+Cc: Thomas Gleixner <tglx@linutronix.de>
+Cc: juri.lelli@gmail.com
+Link: http://lkml.kernel.org/r/20161123004832.GA2983@geo
+Signed-off-by: Ingo Molnar <mingo@kernel.org>
+(cherry picked from commit 176cedc4ed143745708999155c11b5717cdebb35)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ kernel/sched/deadline.c | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/kernel/sched/deadline.c b/kernel/sched/deadline.c
+index 37e2449..0e4ad2a 100644
+--- a/kernel/sched/deadline.c
++++ b/kernel/sched/deadline.c
+@@ -1137,7 +1137,7 @@ struct task_struct *
+ 		pull_dl_task(rq);
+ 		lockdep_repin_lock(&rq->lock, cookie);
+ 		/*
+-		 * pull_rt_task() can drop (and re-acquire) rq->lock; this
++		 * pull_dl_task() can drop (and re-acquire) rq->lock; this
+ 		 * means a stop task can slip in, in which case we need to
+ 		 * re-start task selection.
+ 		 */
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0014-sched-fair-Clean-up-the-tunable-parameter-definition.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0014-sched-fair-Clean-up-the-tunable-parameter-definition.patch
new file mode 100644
index 0000000..df0388a
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0014-sched-fair-Clean-up-the-tunable-parameter-definition.patch
@@ -0,0 +1,141 @@
+From 05871df5280460c20d17434132329bebb27a2cfa Mon Sep 17 00:00:00 2001
+From: Ingo Molnar <mingo@kernel.org>
+Date: Wed, 23 Nov 2016 07:37:00 +0100
+Subject: [PATCH 14/92] sched/fair: Clean up the tunable parameter definitions
+
+No change in functionality:
+
+ - align the default values vertically to make them easier to scan
+ - standardize the 'default:' lines
+ - fix minor whitespace typos
+
+Acked-by: Peter Zijlstra (Intel) <peterz@infradead.org>
+Cc: Linus Torvalds <torvalds@linux-foundation.org>
+Cc: Mike Galbraith <efault@gmx.de>
+Cc: Thomas Gleixner <tglx@linutronix.de>
+Cc: linux-kernel@vger.kernel.org
+Signed-off-by: Ingo Molnar <mingo@kernel.org>
+(cherry picked from commit 2b4d5b2582deffb77b3b4b48a59cd36e9e1e14d9)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ kernel/sched/fair.c | 50 ++++++++++++++++++++++++++++----------------------
+ 1 file changed, 28 insertions(+), 22 deletions(-)
+
+diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
+index 02605f2..aa47589 100644
+--- a/kernel/sched/fair.c
++++ b/kernel/sched/fair.c
+@@ -37,7 +37,6 @@
+ 
+ /*
+  * Targeted preemption latency for CPU-bound tasks:
+- * (default: 6ms * (1 + ilog(ncpus)), units: nanoseconds)
+  *
+  * NOTE: this latency value is not the same as the concept of
+  * 'timeslice length' - timeslices in CFS are of variable length
+@@ -46,31 +45,35 @@
+  *
+  * (to see the precise effective timeslice length of your workload,
+  *  run vmstat and monitor the context-switches (cs) field)
++ *
++ * (default: 6ms * (1 + ilog(ncpus)), units: nanoseconds)
+  */
+-unsigned int sysctl_sched_latency = 6000000ULL;
+-unsigned int normalized_sysctl_sched_latency = 6000000ULL;
++unsigned int sysctl_sched_latency			= 6000000ULL;
++unsigned int normalized_sysctl_sched_latency		= 6000000ULL;
+ 
+ /*
+  * The initial- and re-scaling of tunables is configurable
+- * (default SCHED_TUNABLESCALING_LOG = *(1+ilog(ncpus))
+  *
+  * Options are:
+- * SCHED_TUNABLESCALING_NONE - unscaled, always *1
+- * SCHED_TUNABLESCALING_LOG - scaled logarithmical, *1+ilog(ncpus)
+- * SCHED_TUNABLESCALING_LINEAR - scaled linear, *ncpus
++ *
++ *   SCHED_TUNABLESCALING_NONE - unscaled, always *1
++ *   SCHED_TUNABLESCALING_LOG - scaled logarithmical, *1+ilog(ncpus)
++ *   SCHED_TUNABLESCALING_LINEAR - scaled linear, *ncpus
++ *
++ * (default SCHED_TUNABLESCALING_LOG = *(1+ilog(ncpus))
+  */
+-enum sched_tunable_scaling sysctl_sched_tunable_scaling
+-	= SCHED_TUNABLESCALING_LOG;
++enum sched_tunable_scaling sysctl_sched_tunable_scaling = SCHED_TUNABLESCALING_LOG;
+ 
+ /*
+  * Minimal preemption granularity for CPU-bound tasks:
++ *
+  * (default: 0.75 msec * (1 + ilog(ncpus)), units: nanoseconds)
+  */
+-unsigned int sysctl_sched_min_granularity = 750000ULL;
+-unsigned int normalized_sysctl_sched_min_granularity = 750000ULL;
++unsigned int sysctl_sched_min_granularity		= 750000ULL;
++unsigned int normalized_sysctl_sched_min_granularity	= 750000ULL;
+ 
+ /*
+- * is kept at sysctl_sched_latency / sysctl_sched_min_granularity
++ * This value is kept at sysctl_sched_latency/sysctl_sched_min_granularity
+  */
+ static unsigned int sched_nr_latency = 8;
+ 
+@@ -82,16 +85,17 @@ enum sched_tunable_scaling sysctl_sched_tunable_scaling
+ 
+ /*
+  * SCHED_OTHER wake-up granularity.
+- * (default: 1 msec * (1 + ilog(ncpus)), units: nanoseconds)
+  *
+  * This option delays the preemption effects of decoupled workloads
+  * and reduces their over-scheduling. Synchronous workloads will still
+  * have immediate wakeup/sleep latencies.
++ *
++ * (default: 1 msec * (1 + ilog(ncpus)), units: nanoseconds)
+  */
+-unsigned int sysctl_sched_wakeup_granularity = 1000000UL;
+-unsigned int normalized_sysctl_sched_wakeup_granularity = 1000000UL;
++unsigned int sysctl_sched_wakeup_granularity		= 1000000UL;
++unsigned int normalized_sysctl_sched_wakeup_granularity	= 1000000UL;
+ 
+-const_debug unsigned int sysctl_sched_migration_cost = 500000UL;
++const_debug unsigned int sysctl_sched_migration_cost	= 500000UL;
+ 
+ #ifdef CONFIG_CFS_BANDWIDTH
+ /*
+@@ -102,16 +106,18 @@ enum sched_tunable_scaling sysctl_sched_tunable_scaling
+  * to consumption or the quota being specified to be smaller than the slice)
+  * we will always only issue the remaining available time.
+  *
+- * default: 5 msec, units: microseconds
+-  */
+-unsigned int sysctl_sched_cfs_bandwidth_slice = 5000UL;
++ * (default: 5 msec, units: microseconds)
++ */
++unsigned int sysctl_sched_cfs_bandwidth_slice		= 5000UL;
+ #endif
+ 
+ /*
+  * The margin used when comparing utilization with CPU capacity:
+  * util * margin < capacity * 1024
++ *
++ * (default: ~20%)
+  */
+-unsigned int capacity_margin = 1280; /* ~20% */
++unsigned int capacity_margin				= 1280;
+ 
+ static inline void update_load_add(struct load_weight *lw, unsigned long inc)
+ {
+@@ -7174,8 +7180,8 @@ void update_group_capacity(struct sched_domain *sd, int cpu)
+  * cpumask covering 1 cpu of the first group and 3 cpus of the second group.
+  * Something like:
+  *
+- * 	{ 0 1 2 3 } { 4 5 6 7 }
+- * 	        *     * * *
++ *	{ 0 1 2 3 } { 4 5 6 7 }
++ *	        *     * * *
+  *
+  * If we were to balance group-wise we'd place two tasks in the first group and
+  * two tasks in the second group. Clearly this is undesired as it will overload
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0015-sched-Extend-scheduler-s-asym-packing.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0015-sched-Extend-scheduler-s-asym-packing.patch
new file mode 100644
index 0000000..6d2b9de
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0015-sched-Extend-scheduler-s-asym-packing.patch
@@ -0,0 +1,208 @@
+From e467f39a4c96c4a6f96be66a9224807fe9b7346e Mon Sep 17 00:00:00 2001
+From: Tim Chen <tim.c.chen@linux.intel.com>
+Date: Tue, 22 Nov 2016 12:23:53 -0800
+Subject: [PATCH 15/92] sched: Extend scheduler's asym packing
+
+We generalize the scheduler's asym packing to provide an ordering
+of the cpu beyond just the cpu number.  This allows the use of the
+ASYM_PACKING scheduler machinery to move loads to preferred CPU in a
+sched domain. The preference is defined with the cpu priority
+given by arch_asym_cpu_priority(cpu).
+
+We also record the most preferred cpu in a sched group when
+we build the cpu's capacity for fast lookup of preferred cpu
+during load balancing.
+
+Co-developed-by: Peter Zijlstra (Intel) <peterz@infradead.org>
+Signed-off-by: Tim Chen <tim.c.chen@linux.intel.com>
+Acked-by: Peter Zijlstra (Intel) <peterz@infradead.org>
+Cc: linux-pm@vger.kernel.org
+Cc: jolsa@redhat.com
+Cc: rjw@rjwysocki.net
+Cc: linux-acpi@vger.kernel.org
+Cc: Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>
+Cc: bp@suse.de
+Link: http://lkml.kernel.org/r/0e73ae12737dfaafa46c07066cc7c5d3f1675e46.1479844244.git.tim.c.chen@linux.intel.com
+Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
+
+(cherry picked from commit afe06efdf07c12fd9370d5cce5383398cedf6c90)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ include/linux/sched.h |  2 ++
+ kernel/sched/core.c   | 15 +++++++++++++++
+ kernel/sched/fair.c   | 53 ++++++++++++++++++++++++++++++++++-----------------
+ kernel/sched/sched.h  |  6 ++++++
+ 4 files changed, 59 insertions(+), 17 deletions(-)
+
+diff --git a/include/linux/sched.h b/include/linux/sched.h
+index e9c009d..2e3c2a1 100644
+--- a/include/linux/sched.h
++++ b/include/linux/sched.h
+@@ -1057,6 +1057,8 @@ static inline int cpu_numa_flags(void)
+ }
+ #endif
+ 
++extern int arch_asym_cpu_priority(int cpu);
++
+ struct sched_domain_attr {
+ 	int relax_domain_level;
+ };
+diff --git a/kernel/sched/core.c b/kernel/sched/core.c
+index 391d6c9..209d2ea 100644
+--- a/kernel/sched/core.c
++++ b/kernel/sched/core.c
+@@ -6302,7 +6302,22 @@ static void init_sched_groups_capacity(int cpu, struct sched_domain *sd)
+ 	WARN_ON(!sg);
+ 
+ 	do {
++		int cpu, max_cpu = -1;
++
+ 		sg->group_weight = cpumask_weight(sched_group_cpus(sg));
++
++		if (!(sd->flags & SD_ASYM_PACKING))
++			goto next;
++
++		for_each_cpu(cpu, sched_group_cpus(sg)) {
++			if (max_cpu < 0)
++				max_cpu = cpu;
++			else if (sched_asym_prefer(cpu, max_cpu))
++				max_cpu = cpu;
++		}
++		sg->asym_prefer_cpu = max_cpu;
++
++next:
+ 		sg = sg->next;
+ 	} while (sg != sd->groups);
+ 
+diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
+index aa47589..18d9e75 100644
+--- a/kernel/sched/fair.c
++++ b/kernel/sched/fair.c
+@@ -97,6 +97,16 @@
+ 
+ const_debug unsigned int sysctl_sched_migration_cost	= 500000UL;
+ 
++#ifdef CONFIG_SMP
++/*
++ * For asym packing, by default the lower numbered cpu has higher priority.
++ */
++int __weak arch_asym_cpu_priority(int cpu)
++{
++	return -cpu;
++}
++#endif
++
+ #ifdef CONFIG_CFS_BANDWIDTH
+ /*
+  * Amount of runtime to allocate from global (tg) to local (per-cfs_rq) pool
+@@ -7388,16 +7398,18 @@ static bool update_sd_pick_busiest(struct lb_env *env,
+ 	if (env->idle == CPU_NOT_IDLE)
+ 		return true;
+ 	/*
+-	 * ASYM_PACKING needs to move all the work to the lowest
+-	 * numbered CPUs in the group, therefore mark all groups
+-	 * higher than ourself as busy.
++	 * ASYM_PACKING needs to move all the work to the highest
++	 * prority CPUs in the group, therefore mark all groups
++	 * of lower priority than ourself as busy.
+ 	 */
+-	if (sgs->sum_nr_running && env->dst_cpu < group_first_cpu(sg)) {
++	if (sgs->sum_nr_running &&
++	    sched_asym_prefer(env->dst_cpu, sg->asym_prefer_cpu)) {
+ 		if (!sds->busiest)
+ 			return true;
+ 
+-		/* Prefer to move from highest possible cpu's work */
+-		if (group_first_cpu(sds->busiest) < group_first_cpu(sg))
++		/* Prefer to move from lowest priority cpu's work */
++		if (sched_asym_prefer(sds->busiest->asym_prefer_cpu,
++				      sg->asym_prefer_cpu))
+ 			return true;
+ 	}
+ 
+@@ -7549,8 +7561,8 @@ static int check_asym_packing(struct lb_env *env, struct sd_lb_stats *sds)
+ 	if (!sds->busiest)
+ 		return 0;
+ 
+-	busiest_cpu = group_first_cpu(sds->busiest);
+-	if (env->dst_cpu > busiest_cpu)
++	busiest_cpu = sds->busiest->asym_prefer_cpu;
++	if (sched_asym_prefer(busiest_cpu, env->dst_cpu))
+ 		return 0;
+ 
+ 	env->imbalance = DIV_ROUND_CLOSEST(
+@@ -7888,10 +7900,11 @@ static int need_active_balance(struct lb_env *env)
+ 
+ 		/*
+ 		 * ASYM_PACKING needs to force migrate tasks from busy but
+-		 * higher numbered CPUs in order to pack all tasks in the
+-		 * lowest numbered CPUs.
++		 * lower priority CPUs in order to pack all tasks in the
++		 * highest priority CPUs.
+ 		 */
+-		if ((sd->flags & SD_ASYM_PACKING) && env->src_cpu > env->dst_cpu)
++		if ((sd->flags & SD_ASYM_PACKING) &&
++		    sched_asym_prefer(env->dst_cpu, env->src_cpu))
+ 			return 1;
+ 	}
+ 
+@@ -8740,7 +8753,7 @@ static inline bool nohz_kick_needed(struct rq *rq)
+ 	unsigned long now = jiffies;
+ 	struct sched_domain_shared *sds;
+ 	struct sched_domain *sd;
+-	int nr_busy, cpu = rq->cpu;
++	int nr_busy, i, cpu = rq->cpu;
+ 	bool kick = false;
+ 
+ 	if (unlikely(rq->idle_balance))
+@@ -8791,12 +8804,18 @@ static inline bool nohz_kick_needed(struct rq *rq)
+ 	}
+ 
+ 	sd = rcu_dereference(per_cpu(sd_asym, cpu));
+-	if (sd && (cpumask_first_and(nohz.idle_cpus_mask,
+-				  sched_domain_span(sd)) < cpu)) {
+-		kick = true;
+-		goto unlock;
+-	}
++	if (sd) {
++		for_each_cpu(i, sched_domain_span(sd)) {
++			if (i == cpu ||
++			    !cpumask_test_cpu(i, nohz.idle_cpus_mask))
++				continue;
+ 
++			if (sched_asym_prefer(i, cpu)) {
++				kick = true;
++				goto unlock;
++			}
++		}
++	}
+ unlock:
+ 	rcu_read_unlock();
+ 	return kick;
+diff --git a/kernel/sched/sched.h b/kernel/sched/sched.h
+index d7e3931..7b34c78 100644
+--- a/kernel/sched/sched.h
++++ b/kernel/sched/sched.h
+@@ -540,6 +540,11 @@ struct dl_rq {
+ 
+ #ifdef CONFIG_SMP
+ 
++static inline bool sched_asym_prefer(int a, int b)
++{
++	return arch_asym_cpu_priority(a) > arch_asym_cpu_priority(b);
++}
++
+ /*
+  * We add the notion of a root-domain which will be used to define per-domain
+  * variables. Each exclusive cpuset essentially defines an island domain by
+@@ -908,6 +913,7 @@ struct sched_group {
+ 
+ 	unsigned int group_weight;
+ 	struct sched_group_capacity *sgc;
++	int asym_prefer_cpu;		/* cpu of highest priority in group */
+ 
+ 	/*
+ 	 * The CPUs this group covers.
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0016-cpufreq-schedutil-Avoid-indented-labels.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0016-cpufreq-schedutil-Avoid-indented-labels.patch
new file mode 100644
index 0000000..a086850
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0016-cpufreq-schedutil-Avoid-indented-labels.patch
@@ -0,0 +1,44 @@
+From b56fd2c55df1136d076d89c88bb4db6877a58fea Mon Sep 17 00:00:00 2001
+From: Viresh Kumar <viresh.kumar@linaro.org>
+Date: Tue, 15 Nov 2016 13:53:20 +0530
+Subject: [PATCH 16/92] cpufreq: schedutil: Avoid indented labels
+
+Switch to the more common practice of writing labels.
+
+Suggested-by: Peter Zijlstra <peterz@infradead.org>
+Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
+Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
+(cherry picked from commit 8e2ddb03643eb9d0bc4926946d7ce0d308eef0a5)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ kernel/sched/cpufreq_schedutil.c | 6 +++---
+ 1 file changed, 3 insertions(+), 3 deletions(-)
+
+diff --git a/kernel/sched/cpufreq_schedutil.c b/kernel/sched/cpufreq_schedutil.c
+index 69e0689..8c4e165 100644
+--- a/kernel/sched/cpufreq_schedutil.c
++++ b/kernel/sched/cpufreq_schedutil.c
+@@ -454,17 +454,17 @@ static int sugov_init(struct cpufreq_policy *policy)
+ 	if (ret)
+ 		goto fail;
+ 
+- out:
++out:
+ 	mutex_unlock(&global_tunables_lock);
+ 
+ 	cpufreq_enable_fast_switch(policy);
+ 	return 0;
+ 
+- fail:
++fail:
+ 	policy->governor_data = NULL;
+ 	sugov_tunables_free(tunables);
+ 
+- free_sg_policy:
++free_sg_policy:
+ 	mutex_unlock(&global_tunables_lock);
+ 
+ 	sugov_policy_free(sg_policy);
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0017-cpufreq-schedutil-enable-fast-switch-earlier.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0017-cpufreq-schedutil-enable-fast-switch-earlier.patch
new file mode 100644
index 0000000..487c01e
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0017-cpufreq-schedutil-enable-fast-switch-earlier.patch
@@ -0,0 +1,79 @@
+From 9286a34be80e891aebc0193be28931a9f194b23d Mon Sep 17 00:00:00 2001
+From: Viresh Kumar <viresh.kumar@linaro.org>
+Date: Tue, 15 Nov 2016 13:53:21 +0530
+Subject: [PATCH 17/92] cpufreq: schedutil: enable fast switch earlier
+
+The fast_switch_enabled flag will be used by both sugov_policy_alloc()
+and sugov_policy_free() with a later patch.
+
+Prepare for that by moving the calls to enable and disable it to the
+beginning of sugov_init() and end of sugov_exit().
+
+Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
+Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
+(cherry picked from commit 4a71ce4348bb61740d411822357061f8bf870f4c)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ kernel/sched/cpufreq_schedutil.c | 17 +++++++++++------
+ 1 file changed, 11 insertions(+), 6 deletions(-)
+
+diff --git a/kernel/sched/cpufreq_schedutil.c b/kernel/sched/cpufreq_schedutil.c
+index 8c4e165..68f21bb 100644
+--- a/kernel/sched/cpufreq_schedutil.c
++++ b/kernel/sched/cpufreq_schedutil.c
+@@ -416,9 +416,13 @@ static int sugov_init(struct cpufreq_policy *policy)
+ 	if (policy->governor_data)
+ 		return -EBUSY;
+ 
++	cpufreq_enable_fast_switch(policy);
++
+ 	sg_policy = sugov_policy_alloc(policy);
+-	if (!sg_policy)
+-		return -ENOMEM;
++	if (!sg_policy) {
++		ret = -ENOMEM;
++		goto disable_fast_switch;
++	}
+ 
+ 	mutex_lock(&global_tunables_lock);
+ 
+@@ -456,8 +460,6 @@ static int sugov_init(struct cpufreq_policy *policy)
+ 
+ out:
+ 	mutex_unlock(&global_tunables_lock);
+-
+-	cpufreq_enable_fast_switch(policy);
+ 	return 0;
+ 
+ fail:
+@@ -468,6 +470,10 @@ static int sugov_init(struct cpufreq_policy *policy)
+ 	mutex_unlock(&global_tunables_lock);
+ 
+ 	sugov_policy_free(sg_policy);
++
++disable_fast_switch:
++	cpufreq_disable_fast_switch(policy);
++
+ 	pr_err("initialization failed (error %d)\n", ret);
+ 	return ret;
+ }
+@@ -478,8 +484,6 @@ static void sugov_exit(struct cpufreq_policy *policy)
+ 	struct sugov_tunables *tunables = sg_policy->tunables;
+ 	unsigned int count;
+ 
+-	cpufreq_disable_fast_switch(policy);
+-
+ 	mutex_lock(&global_tunables_lock);
+ 
+ 	count = gov_attr_set_put(&tunables->attr_set, &sg_policy->tunables_hook);
+@@ -490,6 +494,7 @@ static void sugov_exit(struct cpufreq_policy *policy)
+ 	mutex_unlock(&global_tunables_lock);
+ 
+ 	sugov_policy_free(sg_policy);
++	cpufreq_disable_fast_switch(policy);
+ }
+ 
+ static int sugov_start(struct cpufreq_policy *policy)
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0018-cpufreq-schedutil-move-slow-path-from-workqueue-to-S.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0018-cpufreq-schedutil-move-slow-path-from-workqueue-to-S.patch
new file mode 100644
index 0000000..244cf82
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0018-cpufreq-schedutil-move-slow-path-from-workqueue-to-S.patch
@@ -0,0 +1,228 @@
+From 389b1838b500ecc431c2421ee399b8f737e88cf5 Mon Sep 17 00:00:00 2001
+From: Viresh Kumar <viresh.kumar@linaro.org>
+Date: Tue, 15 Nov 2016 13:53:22 +0530
+Subject: [PATCH 18/92] cpufreq: schedutil: move slow path from workqueue to
+ SCHED_FIFO task
+
+If slow path frequency changes are conducted in a SCHED_OTHER context
+then they may be delayed for some amount of time, including
+indefinitely, when real time or deadline activity is taking place.
+
+Move the slow path to a real time kernel thread. In the future the
+thread should be made SCHED_DEADLINE. The RT priority is arbitrarily set
+to 50 for now.
+
+Hackbench results on ARM Exynos, dual core A15 platform for 10
+iterations:
+
+$ hackbench -s 100 -l 100 -g 10 -f 20
+
+Before			After
+---------------------------------
+1.808			1.603
+1.847			1.251
+2.229			1.590
+1.952			1.600
+1.947			1.257
+1.925			1.627
+2.694			1.620
+1.258			1.621
+1.919			1.632
+1.250			1.240
+
+Average:
+
+1.8829			1.5041
+
+Based on initial work by Steve Muckle.
+
+Signed-off-by: Steve Muckle <smuckle.linux@gmail.com>
+Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
+Acked-by: Peter Zijlstra (Intel) <peterz@infradead.org>
+Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
+(cherry picked from commit 02a7b1ee3baa15a98b541d8cfd156bbe1a091c20)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ kernel/sched/cpufreq_schedutil.c | 85 ++++++++++++++++++++++++++++++++++++----
+ 1 file changed, 78 insertions(+), 7 deletions(-)
+
+diff --git a/kernel/sched/cpufreq_schedutil.c b/kernel/sched/cpufreq_schedutil.c
+index 68f21bb..f165ba0 100644
+--- a/kernel/sched/cpufreq_schedutil.c
++++ b/kernel/sched/cpufreq_schedutil.c
+@@ -12,11 +12,14 @@
+ #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+ 
+ #include <linux/cpufreq.h>
++#include <linux/kthread.h>
+ #include <linux/slab.h>
+ #include <trace/events/power.h>
+ 
+ #include "sched.h"
+ 
++#define SUGOV_KTHREAD_PRIORITY	50
++
+ struct sugov_tunables {
+ 	struct gov_attr_set attr_set;
+ 	unsigned int rate_limit_us;
+@@ -35,8 +38,10 @@ struct sugov_policy {
+ 
+ 	/* The next fields are only needed if fast switch cannot be used. */
+ 	struct irq_work irq_work;
+-	struct work_struct work;
++	struct kthread_work work;
+ 	struct mutex work_lock;
++	struct kthread_worker worker;
++	struct task_struct *thread;
+ 	bool work_in_progress;
+ 
+ 	bool need_freq_update;
+@@ -291,7 +296,7 @@ static void sugov_update_shared(struct update_util_data *hook, u64 time,
+ 	raw_spin_unlock(&sg_policy->update_lock);
+ }
+ 
+-static void sugov_work(struct work_struct *work)
++static void sugov_work(struct kthread_work *work)
+ {
+ 	struct sugov_policy *sg_policy = container_of(work, struct sugov_policy, work);
+ 
+@@ -308,7 +313,21 @@ static void sugov_irq_work(struct irq_work *irq_work)
+ 	struct sugov_policy *sg_policy;
+ 
+ 	sg_policy = container_of(irq_work, struct sugov_policy, irq_work);
+-	schedule_work_on(smp_processor_id(), &sg_policy->work);
++
++	/*
++	 * For Real Time and Deadline tasks, schedutil governor shoots the
++	 * frequency to maximum. And special care must be taken to ensure that
++	 * this kthread doesn't result in that.
++	 *
++	 * This is (mostly) guaranteed by the work_in_progress flag. The flag is
++	 * updated only at the end of the sugov_work() and before that schedutil
++	 * rejects all other frequency scaling requests.
++	 *
++	 * Though there is a very rare case where the RT thread yields right
++	 * after the work_in_progress flag is cleared. The effects of that are
++	 * neglected for now.
++	 */
++	kthread_queue_work(&sg_policy->worker, &sg_policy->work);
+ }
+ 
+ /************************** sysfs interface ************************/
+@@ -372,7 +391,6 @@ static struct sugov_policy *sugov_policy_alloc(struct cpufreq_policy *policy)
+ 
+ 	sg_policy->policy = policy;
+ 	init_irq_work(&sg_policy->irq_work, sugov_irq_work);
+-	INIT_WORK(&sg_policy->work, sugov_work);
+ 	mutex_init(&sg_policy->work_lock);
+ 	raw_spin_lock_init(&sg_policy->update_lock);
+ 	return sg_policy;
+@@ -384,6 +402,51 @@ static void sugov_policy_free(struct sugov_policy *sg_policy)
+ 	kfree(sg_policy);
+ }
+ 
++static int sugov_kthread_create(struct sugov_policy *sg_policy)
++{
++	struct task_struct *thread;
++	struct sched_param param = { .sched_priority = MAX_USER_RT_PRIO / 2 };
++	struct cpufreq_policy *policy = sg_policy->policy;
++	int ret;
++
++	/* kthread only required for slow path */
++	if (policy->fast_switch_enabled)
++		return 0;
++
++	kthread_init_work(&sg_policy->work, sugov_work);
++	kthread_init_worker(&sg_policy->worker);
++	thread = kthread_create(kthread_worker_fn, &sg_policy->worker,
++				"sugov:%d",
++				cpumask_first(policy->related_cpus));
++	if (IS_ERR(thread)) {
++		pr_err("failed to create sugov thread: %ld\n", PTR_ERR(thread));
++		return PTR_ERR(thread);
++	}
++
++	ret = sched_setscheduler_nocheck(thread, SCHED_FIFO, &param);
++	if (ret) {
++		kthread_stop(thread);
++		pr_warn("%s: failed to set SCHED_FIFO\n", __func__);
++		return ret;
++	}
++
++	sg_policy->thread = thread;
++	kthread_bind_mask(thread, policy->related_cpus);
++	wake_up_process(thread);
++
++	return 0;
++}
++
++static void sugov_kthread_stop(struct sugov_policy *sg_policy)
++{
++	/* kthread only required for slow path */
++	if (sg_policy->policy->fast_switch_enabled)
++		return;
++
++	kthread_flush_worker(&sg_policy->worker);
++	kthread_stop(sg_policy->thread);
++}
++
+ static struct sugov_tunables *sugov_tunables_alloc(struct sugov_policy *sg_policy)
+ {
+ 	struct sugov_tunables *tunables;
+@@ -424,12 +487,16 @@ static int sugov_init(struct cpufreq_policy *policy)
+ 		goto disable_fast_switch;
+ 	}
+ 
++	ret = sugov_kthread_create(sg_policy);
++	if (ret)
++		goto free_sg_policy;
++
+ 	mutex_lock(&global_tunables_lock);
+ 
+ 	if (global_tunables) {
+ 		if (WARN_ON(have_governor_per_policy())) {
+ 			ret = -EINVAL;
+-			goto free_sg_policy;
++			goto stop_kthread;
+ 		}
+ 		policy->governor_data = sg_policy;
+ 		sg_policy->tunables = global_tunables;
+@@ -441,7 +508,7 @@ static int sugov_init(struct cpufreq_policy *policy)
+ 	tunables = sugov_tunables_alloc(sg_policy);
+ 	if (!tunables) {
+ 		ret = -ENOMEM;
+-		goto free_sg_policy;
++		goto stop_kthread;
+ 	}
+ 
+ 	tunables->rate_limit_us = LATENCY_MULTIPLIER;
+@@ -466,6 +533,9 @@ static int sugov_init(struct cpufreq_policy *policy)
+ 	policy->governor_data = NULL;
+ 	sugov_tunables_free(tunables);
+ 
++stop_kthread:
++	sugov_kthread_stop(sg_policy);
++
+ free_sg_policy:
+ 	mutex_unlock(&global_tunables_lock);
+ 
+@@ -493,6 +563,7 @@ static void sugov_exit(struct cpufreq_policy *policy)
+ 
+ 	mutex_unlock(&global_tunables_lock);
+ 
++	sugov_kthread_stop(sg_policy);
+ 	sugov_policy_free(sg_policy);
+ 	cpufreq_disable_fast_switch(policy);
+ }
+@@ -541,7 +612,7 @@ static void sugov_stop(struct cpufreq_policy *policy)
+ 	synchronize_sched();
+ 
+ 	irq_work_sync(&sg_policy->irq_work);
+-	cancel_work_sync(&sg_policy->work);
++	kthread_cancel_work_sync(&sg_policy->work);
+ }
+ 
+ static void sugov_limits(struct cpufreq_policy *policy)
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0019-cpufreq-schedutil-irq-work-and-mutex-are-only-used-i.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0019-cpufreq-schedutil-irq-work-and-mutex-are-only-used-i.patch
new file mode 100644
index 0000000..94c768a
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0019-cpufreq-schedutil-irq-work-and-mutex-are-only-used-i.patch
@@ -0,0 +1,71 @@
+From fad60e6f1b0de5e37cb4e0ae8a4a769ef821950f Mon Sep 17 00:00:00 2001
+From: Viresh Kumar <viresh.kumar@linaro.org>
+Date: Tue, 15 Nov 2016 13:53:23 +0530
+Subject: [PATCH 19/92] cpufreq: schedutil: irq-work and mutex are only used in
+ slow path
+
+Execute the irq-work specific initialization/exit code only when the
+fast path isn't available.
+
+Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
+Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
+(cherry picked from commit 21ef57297b15a49b0c4dd4e7135c1a08e9a29a1c)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ kernel/sched/cpufreq_schedutil.c | 13 ++++++++-----
+ 1 file changed, 8 insertions(+), 5 deletions(-)
+
+diff --git a/kernel/sched/cpufreq_schedutil.c b/kernel/sched/cpufreq_schedutil.c
+index f165ba0..42a220e 100644
+--- a/kernel/sched/cpufreq_schedutil.c
++++ b/kernel/sched/cpufreq_schedutil.c
+@@ -390,15 +390,12 @@ static struct sugov_policy *sugov_policy_alloc(struct cpufreq_policy *policy)
+ 		return NULL;
+ 
+ 	sg_policy->policy = policy;
+-	init_irq_work(&sg_policy->irq_work, sugov_irq_work);
+-	mutex_init(&sg_policy->work_lock);
+ 	raw_spin_lock_init(&sg_policy->update_lock);
+ 	return sg_policy;
+ }
+ 
+ static void sugov_policy_free(struct sugov_policy *sg_policy)
+ {
+-	mutex_destroy(&sg_policy->work_lock);
+ 	kfree(sg_policy);
+ }
+ 
+@@ -432,6 +429,9 @@ static int sugov_kthread_create(struct sugov_policy *sg_policy)
+ 
+ 	sg_policy->thread = thread;
+ 	kthread_bind_mask(thread, policy->related_cpus);
++	init_irq_work(&sg_policy->irq_work, sugov_irq_work);
++	mutex_init(&sg_policy->work_lock);
++
+ 	wake_up_process(thread);
+ 
+ 	return 0;
+@@ -445,6 +445,7 @@ static void sugov_kthread_stop(struct sugov_policy *sg_policy)
+ 
+ 	kthread_flush_worker(&sg_policy->worker);
+ 	kthread_stop(sg_policy->thread);
++	mutex_destroy(&sg_policy->work_lock);
+ }
+ 
+ static struct sugov_tunables *sugov_tunables_alloc(struct sugov_policy *sg_policy)
+@@ -611,8 +612,10 @@ static void sugov_stop(struct cpufreq_policy *policy)
+ 
+ 	synchronize_sched();
+ 
+-	irq_work_sync(&sg_policy->irq_work);
+-	kthread_cancel_work_sync(&sg_policy->work);
++	if (!policy->fast_switch_enabled) {
++		irq_work_sync(&sg_policy->irq_work);
++		kthread_cancel_work_sync(&sg_policy->work);
++	}
+ }
+ 
+ static void sugov_limits(struct cpufreq_policy *policy)
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0020-x86-topology-Define-x86-s-arch_update_cpu_topology.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0020-x86-topology-Define-x86-s-arch_update_cpu_topology.patch
new file mode 100644
index 0000000..338ea13
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0020-x86-topology-Define-x86-s-arch_update_cpu_topology.patch
@@ -0,0 +1,67 @@
+From 32b4c21d163c96ff9fa1829c7a4f325aca0655a7 Mon Sep 17 00:00:00 2001
+From: Tim Chen <tim.c.chen@linux.intel.com>
+Date: Tue, 22 Nov 2016 12:23:54 -0800
+Subject: [PATCH 20/92] x86/topology: Define x86's arch_update_cpu_topology
+
+The scheduler calls arch_update_cpu_topology() to check whether the
+scheduler domains have to be rebuilt.
+
+So far x86 has no requirement for this, but the upcoming ITMT support
+makes this necessary.
+
+Request the rebuild when the x86 internal update flag is set.
+
+Suggested-by: Morten Rasmussen <morten.rasmussen@arm.com>
+Signed-off-by: Tim Chen <tim.c.chen@linux.intel.com>
+Cc: linux-pm@vger.kernel.org
+Cc: peterz@infradead.org
+Cc: jolsa@redhat.com
+Cc: rjw@rjwysocki.net
+Cc: linux-acpi@vger.kernel.org
+Cc: Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>
+Cc: bp@suse.de
+Link: http://lkml.kernel.org/r/bfbf5591276ec60b2af2da798adc1060df1e2a5f.1479844244.git.tim.c.chen@linux.intel.com
+Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
+
+(cherry picked from commit 7d25127cef44924f1013d119ba385095ca4b4a83)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ arch/x86/include/asm/topology.h |  1 +
+ arch/x86/kernel/smpboot.c       | 11 +++++++++++
+ 2 files changed, 12 insertions(+)
+
+diff --git a/arch/x86/include/asm/topology.h b/arch/x86/include/asm/topology.h
+index cf75871..a5ca88a 100644
+--- a/arch/x86/include/asm/topology.h
++++ b/arch/x86/include/asm/topology.h
+@@ -146,4 +146,5 @@ static inline void arch_fix_phys_package_id(int num, u32 slot)
+ int x86_pci_root_bus_node(int bus);
+ void x86_pci_root_bus_resources(int bus, struct list_head *resources);
+ 
++extern bool x86_topology_update;
+ #endif /* _ASM_X86_TOPOLOGY_H */
+diff --git a/arch/x86/kernel/smpboot.c b/arch/x86/kernel/smpboot.c
+index 42f5eb7..ac61ee7 100644
+--- a/arch/x86/kernel/smpboot.c
++++ b/arch/x86/kernel/smpboot.c
+@@ -109,6 +109,17 @@
+ /* Maximum number of SMT threads on any online core */
+ int __max_smt_threads __read_mostly;
+ 
++/* Flag to indicate if a complete sched domain rebuild is required */
++bool x86_topology_update;
++
++int arch_update_cpu_topology(void)
++{
++	int retval = x86_topology_update;
++
++	x86_topology_update = false;
++	return retval;
++}
++
+ static inline void smpboot_setup_warm_reset_vector(unsigned long start_eip)
+ {
+ 	unsigned long flags;
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0021-sched-Prevent-unnecessary-active-balance-of-single-t.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0021-sched-Prevent-unnecessary-active-balance-of-single-t.patch
new file mode 100644
index 0000000..64ad147
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0021-sched-Prevent-unnecessary-active-balance-of-single-t.patch
@@ -0,0 +1,63 @@
+From 67c41183d153dca79ae8073ce6f056b66ba384f2 Mon Sep 17 00:00:00 2001
+From: Morten Rasmussen <morten.rasmussen@arm.com>
+Date: Thu, 2 Jul 2015 17:16:34 +0100
+Subject: [PATCH 21/92] sched: Prevent unnecessary active balance of single
+ task in sched group
+
+Scenarios with the busiest group having just one task and the local
+being idle on topologies with sched groups with different numbers of
+cpus manage to dodge all load-balance bailout conditions resulting the
+nr_balance_failed counter to be incremented. This eventually causes a
+pointless active migration of the task. This patch prevents this by not
+incrementing the counter when the busiest group only has one task.
+ASYM_PACKING migrations and migrations due to reduced capacity should
+still take place as these are explicitly captured by
+need_active_balance().
+
+A better solution would be to not attempt the load-balance in the first
+place, but that requires significant changes to the order of bailout
+conditions and statistics gathering.
+
+cc: Ingo Molnar <mingo@redhat.com>
+cc: Peter Zijlstra <peterz@infradead.org>
+Signed-off-by: Morten Rasmussen <morten.rasmussen@arm.com>
+(cherry picked from commit b1a7e8eae736c483b9ffed01b4dd35747f448232)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ kernel/sched/fair.c | 6 +++++-
+ 1 file changed, 5 insertions(+), 1 deletion(-)
+
+diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
+index 18d9e75..341fccd 100644
+--- a/kernel/sched/fair.c
++++ b/kernel/sched/fair.c
+@@ -6509,6 +6509,7 @@ struct lb_env {
+ 	int			new_dst_cpu;
+ 	enum cpu_idle_type	idle;
+ 	long			imbalance;
++	unsigned int		src_grp_nr_running;
+ 	/* The set of CPUs under consideration for load-balancing */
+ 	struct cpumask		*cpus;
+ 
+@@ -7517,6 +7518,8 @@ static inline void update_sd_lb_stats(struct lb_env *env, struct sd_lb_stats *sd
+ 	if (env->sd->flags & SD_NUMA)
+ 		env->fbq_type = fbq_classify_group(&sds->busiest_stat);
+ 
++	env->src_grp_nr_running = sds->busiest_stat.sum_nr_running;
++
+ 	if (!env->sd->parent) {
+ 		/* update overload indicator if we are at root domain */
+ 		if (env->dst_rq->rd->overload != overload)
+@@ -8133,7 +8136,8 @@ static int load_balance(int this_cpu, struct rq *this_rq,
+ 		 * excessive cache_hot migrations and active balances.
+ 		 */
+ 		if (idle != CPU_NEWLY_IDLE)
+-			sd->nr_balance_failed++;
++			if (env.src_grp_nr_running > 1)
++				sd->nr_balance_failed++;
+ 
+ 		if (need_active_balance(&env)) {
+ 			raw_spin_lock_irqsave(&busiest->lock, flags);
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0022-sched-Enable-idle-balance-to-pull-single-task-toward.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0022-sched-Enable-idle-balance-to-pull-single-task-toward.patch
new file mode 100644
index 0000000..d8d1877
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0022-sched-Enable-idle-balance-to-pull-single-task-toward.patch
@@ -0,0 +1,55 @@
+From 23326036926c9495301467238107ab942286aa54 Mon Sep 17 00:00:00 2001
+From: Dietmar Eggemann <dietmar.eggemann@arm.com>
+Date: Mon, 26 Jan 2015 19:47:28 +0000
+Subject: [PATCH 22/92] sched: Enable idle balance to pull single task towards
+ cpu with higher capacity
+
+We do not want to miss out on the ability to pull a single remaining
+task from a potential source cpu towards an idle destination cpu. Add an
+extra criteria to need_active_balance() to kick off active load balance
+if the source cpu is over-utilized and has lower capacity than the
+destination cpu.
+
+cc: Ingo Molnar <mingo@redhat.com>
+cc: Peter Zijlstra <peterz@infradead.org>
+Signed-off-by: Morten Rasmussen <morten.rasmussen@arm.com>
+Signed-off-by: Dietmar Eggemann <dietmar.eggemann@arm.com>
+(cherry picked from commit 006d246f483211175d75b8a2b90000c36c486b7d)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ kernel/sched/fair.c | 12 ++++++++++++
+ 1 file changed, 12 insertions(+)
+
+diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
+index 341fccd..cb283ca 100644
+--- a/kernel/sched/fair.c
++++ b/kernel/sched/fair.c
+@@ -5859,6 +5859,11 @@ static int wake_cap(struct task_struct *p, int cpu, int prev_cpu)
+ 	return min_cap * 1024 < task_util(p) * capacity_margin;
+ }
+ 
++static bool cpu_overutilized(int cpu)
++{
++	return (capacity_of(cpu) * 1024) < (cpu_util(cpu) * capacity_margin);
++}
++
+ /*
+  * select_task_rq_fair: Select target runqueue for the waking task in domains
+  * that have the 'sd_flag' flag set. In practice, this is SD_BALANCE_WAKE,
+@@ -7924,6 +7929,13 @@ static int need_active_balance(struct lb_env *env)
+ 			return 1;
+ 	}
+ 
++	if ((capacity_of(env->src_cpu) < capacity_of(env->dst_cpu)) &&
++				env->src_rq->cfs.h_nr_running == 1 &&
++				cpu_overutilized(env->src_cpu) &&
++				!cpu_overutilized(env->dst_cpu)) {
++			return 1;
++	}
++
+ 	return unlikely(sd->nr_balance_failed > sd->cache_nice_tries+2);
+ }
+ 
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0023-Documentation-arm-define-DT-cpu-capacity-dmips-mhz-b.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0023-Documentation-arm-define-DT-cpu-capacity-dmips-mhz-b.patch
new file mode 100644
index 0000000..771327c
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0023-Documentation-arm-define-DT-cpu-capacity-dmips-mhz-b.patch
@@ -0,0 +1,309 @@
+From 908654b226b9b67b12a5c07434cd1854d9a848e8 Mon Sep 17 00:00:00 2001
+From: Juri Lelli <juri.lelli@arm.com>
+Date: Thu, 15 Oct 2015 14:49:00 +0100
+Subject: [PATCH 23/92] Documentation: arm: define DT cpu capacity-dmips-mhz
+ bindings
+
+ARM systems may be configured to have cpus with different power/performance
+characteristics within the same chip. In this case, additional information
+has to be made available to the kernel (the scheduler in particular) for it
+to be aware of such differences and take decisions accordingly.
+
+Therefore, this patch aims at standardizing cpu capacities device tree
+bindings for ARM platforms. Bindings define cpu capacity-dmips-mhz
+parameter, to allow operating systems to retrieve such information from
+the device tree and initialize related kernel structures, paving the way
+for common code in the kernel to deal with heterogeneity.
+
+Cc: Rob Herring <robh+dt@kernel.org>
+Cc: Pawel Moll <pawel.moll@arm.com>
+Cc: Mark Rutland <mark.rutland@arm.com>
+Cc: Ian Campbell <ijc+devicetree@hellion.org.uk>
+Cc: Kumar Gala <galak@codeaurora.org>
+Cc: Maxime Ripard <maxime.ripard@free-electrons.com>
+Cc: Olof Johansson <olof@lixom.net>
+Cc: Gregory CLEMENT <gregory.clement@free-electrons.com>
+Cc: Paul Walmsley <paul@pwsan.com>
+Cc: Linus Walleij <linus.walleij@linaro.org>
+Cc: Chen-Yu Tsai <wens@csie.org>
+Cc: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
+Cc: devicetree@vger.kernel.org
+Acked-by: Rob Herring <robh@kernel.org>
+Acked-by: Vincent Guittot <vincent.guittot@linaro.org>
+Signed-off-by: Juri Lelli <juri.lelli@arm.com>
+---
+ .../devicetree/bindings/arm/cpu-capacity.txt       | 236 +++++++++++++++++++++
+ Documentation/devicetree/bindings/arm/cpus.txt     |  10 +
+ 2 files changed, 246 insertions(+)
+ create mode 100644 Documentation/devicetree/bindings/arm/cpu-capacity.txt
+
+diff --git a/Documentation/devicetree/bindings/arm/cpu-capacity.txt b/Documentation/devicetree/bindings/arm/cpu-capacity.txt
+new file mode 100644
+index 0000000..7809fbe
+--- /dev/null
++++ b/Documentation/devicetree/bindings/arm/cpu-capacity.txt
+@@ -0,0 +1,236 @@
++==========================================
++ARM CPUs capacity bindings
++==========================================
++
++==========================================
++1 - Introduction
++==========================================
++
++ARM systems may be configured to have cpus with different power/performance
++characteristics within the same chip. In this case, additional information has
++to be made available to the kernel for it to be aware of such differences and
++take decisions accordingly.
++
++==========================================
++2 - CPU capacity definition
++==========================================
++
++CPU capacity is a number that provides the scheduler information about CPUs
++heterogeneity. Such heterogeneity can come from micro-architectural differences
++(e.g., ARM big.LITTLE systems) or maximum frequency at which CPUs can run
++(e.g., SMP systems with multiple frequency domains). Heterogeneity in this
++context is about differing performance characteristics; this binding tries to
++capture a first-order approximation of the relative performance of CPUs.
++
++CPU capacities are obtained by running a suitable benchmark. This binding makes
++no guarantees on the validity or suitability of any particular benchmark, the
++final capacity should, however, be:
++
++* A "single-threaded" or CPU affine benchmark
++* Divided by the running frequency of the CPU executing the benchmark
++* Not subject to dynamic frequency scaling of the CPU
++
++For the time being we however advise usage of the Dhrystone benchmark. What
++above thus becomes:
++
++CPU capacities are obtained by running the Dhrystone benchmark on each CPU at
++max frequency (with caches enabled). The obtained DMIPS score is then divided
++by the frequency (in MHz) at which the benchmark has been run, so that
++DMIPS/MHz are obtained.  Such values are then normalized w.r.t. the highest
++score obtained in the system.
++
++==========================================
++3 - capacity-dmips-mhz
++==========================================
++
++capacity-dmips-mhz is an optional cpu node [1] property: u32 value
++representing CPU capacity expressed in normalized DMIPS/MHz. At boot time, the
++maximum frequency available to the cpu is then used to calculate the capacity
++value internally used by the kernel.
++
++capacity-dmips-mhz property is all-or-nothing: if it is specified for a cpu
++node, it has to be specified for every other cpu nodes, or the system will
++fall back to the default capacity value for every CPU. If cpufreq is not
++available, final capacities are calculated by directly using capacity-dmips-
++mhz values (normalized w.r.t. the highest value found while parsing the DT).
++
++===========================================
++4 - Examples
++===========================================
++
++Example 1 (ARM 64-bit, 6-cpu system, two clusters):
++capacities-dmips-mhz are scaled w.r.t. 1024 (cpu@0 and cpu@1)
++supposing cluster0@max-freq=1100 and custer1@max-freq=850,
++final capacities are 1024 for cluster0 and 446 for cluster1
++
++cpus {
++	#address-cells = <2>;
++	#size-cells = <0>;
++
++	cpu-map {
++		cluster0 {
++			core0 {
++				cpu = <&A57_0>;
++			};
++			core1 {
++				cpu = <&A57_1>;
++			};
++		};
++
++		cluster1 {
++			core0 {
++				cpu = <&A53_0>;
++			};
++			core1 {
++				cpu = <&A53_1>;
++			};
++			core2 {
++				cpu = <&A53_2>;
++			};
++			core3 {
++				cpu = <&A53_3>;
++			};
++		};
++	};
++
++	idle-states {
++		entry-method = "arm,psci";
++
++		CPU_SLEEP_0: cpu-sleep-0 {
++			compatible = "arm,idle-state";
++			arm,psci-suspend-param = <0x0010000>;
++			local-timer-stop;
++			entry-latency-us = <100>;
++			exit-latency-us = <250>;
++			min-residency-us = <150>;
++		};
++
++		CLUSTER_SLEEP_0: cluster-sleep-0 {
++			compatible = "arm,idle-state";
++			arm,psci-suspend-param = <0x1010000>;
++			local-timer-stop;
++			entry-latency-us = <800>;
++			exit-latency-us = <700>;
++			min-residency-us = <2500>;
++		};
++	};
++
++	A57_0: cpu@0 {
++		compatible = "arm,cortex-a57","arm,armv8";
++		reg = <0x0 0x0>;
++		device_type = "cpu";
++		enable-method = "psci";
++		next-level-cache = <&A57_L2>;
++		clocks = <&scpi_dvfs 0>;
++		cpu-idle-states = <&CPU_SLEEP_0 &CLUSTER_SLEEP_0>;
++		capacity-dmips-mhz = <1024>;
++	};
++
++	A57_1: cpu@1 {
++		compatible = "arm,cortex-a57","arm,armv8";
++		reg = <0x0 0x1>;
++		device_type = "cpu";
++		enable-method = "psci";
++		next-level-cache = <&A57_L2>;
++		clocks = <&scpi_dvfs 0>;
++		cpu-idle-states = <&CPU_SLEEP_0 &CLUSTER_SLEEP_0>;
++		capacity-dmips-mhz = <1024>;
++	};
++
++	A53_0: cpu@100 {
++		compatible = "arm,cortex-a53","arm,armv8";
++		reg = <0x0 0x100>;
++		device_type = "cpu";
++		enable-method = "psci";
++		next-level-cache = <&A53_L2>;
++		clocks = <&scpi_dvfs 1>;
++		cpu-idle-states = <&CPU_SLEEP_0 &CLUSTER_SLEEP_0>;
++		capacity-dmips-mhz = <578>;
++	};
++
++	A53_1: cpu@101 {
++		compatible = "arm,cortex-a53","arm,armv8";
++		reg = <0x0 0x101>;
++		device_type = "cpu";
++		enable-method = "psci";
++		next-level-cache = <&A53_L2>;
++		clocks = <&scpi_dvfs 1>;
++		cpu-idle-states = <&CPU_SLEEP_0 &CLUSTER_SLEEP_0>;
++		capacity-dmips-mhz = <578>;
++	};
++
++	A53_2: cpu@102 {
++		compatible = "arm,cortex-a53","arm,armv8";
++		reg = <0x0 0x102>;
++		device_type = "cpu";
++		enable-method = "psci";
++		next-level-cache = <&A53_L2>;
++		clocks = <&scpi_dvfs 1>;
++		cpu-idle-states = <&CPU_SLEEP_0 &CLUSTER_SLEEP_0>;
++		capacity-dmips-mhz = <578>;
++	};
++
++	A53_3: cpu@103 {
++		compatible = "arm,cortex-a53","arm,armv8";
++		reg = <0x0 0x103>;
++		device_type = "cpu";
++		enable-method = "psci";
++		next-level-cache = <&A53_L2>;
++		clocks = <&scpi_dvfs 1>;
++		cpu-idle-states = <&CPU_SLEEP_0 &CLUSTER_SLEEP_0>;
++		capacity-dmips-mhz = <578>;
++	};
++
++	A57_L2: l2-cache0 {
++		compatible = "cache";
++	};
++
++	A53_L2: l2-cache1 {
++		compatible = "cache";
++	};
++};
++
++Example 2 (ARM 32-bit, 4-cpu system, two clusters,
++	   cpus 0,1@1GHz, cpus 2,3@500MHz):
++capacities-dmips-mhz are scaled w.r.t. 2 (cpu@0 and cpu@1), this means that first
++cpu@0 and cpu@1 are twice fast than cpu@2 and cpu@3 (at the same frequency)
++
++cpus {
++	#address-cells = <1>;
++	#size-cells = <0>;
++
++	cpu0: cpu@0 {
++		device_type = "cpu";
++		compatible = "arm,cortex-a15";
++		reg = <0>;
++		capacity-dmips-mhz = <2>;
++	};
++
++	cpu1: cpu@1 {
++		device_type = "cpu";
++		compatible = "arm,cortex-a15";
++		reg = <1>;
++		capacity-dmips-mhz = <2>;
++	};
++
++	cpu2: cpu@2 {
++		device_type = "cpu";
++		compatible = "arm,cortex-a15";
++		reg = <0x100>;
++		capacity-dmips-mhz = <1>;
++	};
++
++	cpu3: cpu@3 {
++		device_type = "cpu";
++		compatible = "arm,cortex-a15";
++		reg = <0x101>;
++		capacity-dmips-mhz = <1>;
++	};
++};
++
++===========================================
++5 - References
++===========================================
++
++[1] ARM Linux Kernel documentation - CPUs bindings
++    Documentation/devicetree/bindings/arm/cpus.txt
+diff --git a/Documentation/devicetree/bindings/arm/cpus.txt b/Documentation/devicetree/bindings/arm/cpus.txt
+index e6782d5..c1dcf4c 100644
+--- a/Documentation/devicetree/bindings/arm/cpus.txt
++++ b/Documentation/devicetree/bindings/arm/cpus.txt
+@@ -241,6 +241,14 @@ nodes to be present and contain the properties described below.
+ 			# List of phandles to idle state nodes supported
+ 			  by this cpu [3].
+ 
++	- capacity-dmips-mhz
++		Usage: Optional
++		Value type: <u32>
++		Definition:
++			# u32 value representing CPU capacity [3] in
++			  DMIPS/MHz, relative to highest capacity-dmips-mhz
++			  in the system.
++
+ 	- rockchip,pmu
+ 		Usage: optional for systems that have an "enable-method"
+ 		       property value of "rockchip,rk3066-smp"
+@@ -464,3 +472,5 @@ cpus {
+ [2] arm/msm/qcom,kpss-acc.txt
+ [3] ARM Linux kernel documentation - idle states bindings
+     Documentation/devicetree/bindings/arm/idle-states.txt
++[3] ARM Linux kernel documentation - cpu capacity bindings
++    Documentation/devicetree/bindings/arm/cpu-capacity.txt
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0024-arm-parse-cpu-capacity-dmips-mhz-from-DT.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0024-arm-parse-cpu-capacity-dmips-mhz-from-DT.patch
new file mode 100644
index 0000000..0a841b6
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0024-arm-parse-cpu-capacity-dmips-mhz-from-DT.patch
@@ -0,0 +1,210 @@
+From c9441760c1171936fc561e364111866457fde987 Mon Sep 17 00:00:00 2001
+From: Juri Lelli <juri.lelli@arm.com>
+Date: Wed, 11 Nov 2015 16:21:27 +0000
+Subject: [PATCH 24/92] arm: parse cpu capacity-dmips-mhz from DT
+
+With the introduction of cpu capacity-dmips-mhz bindings, CPU capacities
+can now be calculated from values extracted from DT and information
+coming from cpufreq. Add parsing of DT information at boot time, and
+complement it with cpufreq information. We keep code that can produce
+same information, based on different DT properties and hard-coded
+values, as fall-back for backward compatibility.
+
+Caveat: the information provided by this patch will start to be used in
+the future. We need to #define arch_scale_cpu_capacity to something
+provided in arch, so that scheduler's default implementation (which gets
+used if arch_scale_cpu_capacity is not defined) is overwritten.
+
+Cc: Russell King <linux@arm.linux.org.uk>
+Signed-off-by: Juri Lelli <juri.lelli@arm.com>
+---
+ arch/arm/kernel/topology.c | 145 ++++++++++++++++++++++++++++++++++++++++++++-
+ 1 file changed, 144 insertions(+), 1 deletion(-)
+
+diff --git a/arch/arm/kernel/topology.c b/arch/arm/kernel/topology.c
+index ec279d1..b22868a 100644
+--- a/arch/arm/kernel/topology.c
++++ b/arch/arm/kernel/topology.c
+@@ -78,6 +78,134 @@ struct cpu_efficiency {
+ #define cpu_capacity(cpu)	__cpu_capacity[cpu]
+ 
+ static unsigned long middle_capacity = 1;
++static bool cap_from_dt = true;
++static u32 *raw_capacity;
++static bool cap_parsing_failed;
++static u32 capacity_scale;
++
++static int __init parse_cpu_capacity(struct device_node *cpu_node, int cpu)
++{
++	int ret = 1;
++	u32 cpu_capacity;
++
++	if (cap_parsing_failed)
++		return !ret;
++
++	ret = of_property_read_u32(cpu_node,
++				   "capacity-dmips-mhz",
++				   &cpu_capacity);
++	if (!ret) {
++		if (!raw_capacity) {
++			raw_capacity = kcalloc(num_possible_cpus(),
++					       sizeof(*raw_capacity),
++					       GFP_KERNEL);
++			if (!raw_capacity) {
++				pr_err("cpu_capacity: failed to allocate memory for raw capacities\n");
++				cap_parsing_failed = true;
++				return !ret;
++			}
++		}
++		capacity_scale = max(cpu_capacity, capacity_scale);
++		raw_capacity[cpu] = cpu_capacity;
++		pr_debug("cpu_capacity: %s cpu_capacity=%u (raw)\n",
++			cpu_node->full_name, raw_capacity[cpu]);
++	} else {
++		if (raw_capacity) {
++			pr_err("cpu_capacity: missing %s raw capacity\n",
++				cpu_node->full_name);
++			pr_err("cpu_capacity: partial information: fallback to 1024 for all CPUs\n");
++		}
++		cap_parsing_failed = true;
++		kfree(raw_capacity);
++	}
++
++	return !ret;
++}
++
++static void normalize_cpu_capacity(void)
++{
++	u64 capacity;
++	int cpu;
++
++	if (!raw_capacity || cap_parsing_failed)
++		return;
++
++	pr_debug("cpu_capacity: capacity_scale=%u\n", capacity_scale);
++	for_each_possible_cpu(cpu) {
++		capacity = (raw_capacity[cpu] << SCHED_CAPACITY_SHIFT)
++			/ capacity_scale;
++		set_capacity_scale(cpu, capacity);
++		pr_debug("cpu_capacity: CPU%d cpu_capacity=%lu\n",
++			cpu, arch_scale_cpu_capacity(NULL, cpu));
++	}
++}
++
++#ifdef CONFIG_CPU_FREQ
++static cpumask_var_t cpus_to_visit;
++static bool cap_parsing_done;
++
++static int
++init_cpu_capacity_callback(struct notifier_block *nb,
++			   unsigned long val,
++			   void *data)
++{
++	struct cpufreq_policy *policy = data;
++	int cpu;
++
++	if (cap_parsing_failed || cap_parsing_done)
++		return 0;
++
++	switch (val) {
++	case CPUFREQ_NOTIFY:
++		pr_debug("cpu_capacity: init cpu capacity for CPUs [%*pbl] (to_visit=%*pbl)\n",
++				cpumask_pr_args(policy->related_cpus),
++				cpumask_pr_args(cpus_to_visit));
++		cpumask_andnot(cpus_to_visit,
++			       cpus_to_visit,
++			       policy->related_cpus);
++		for_each_cpu(cpu, policy->related_cpus) {
++			raw_capacity[cpu] = arch_scale_cpu_capacity(NULL, cpu) *
++					    policy->cpuinfo.max_freq / 1000UL;
++			capacity_scale = max(raw_capacity[cpu], capacity_scale);
++		}
++		if (cpumask_empty(cpus_to_visit)) {
++			normalize_cpu_capacity();
++			kfree(raw_capacity);
++			pr_debug("cpu_capacity: parsing done\n");
++			cap_parsing_done = true;
++		}
++	}
++	return 0;
++}
++
++static struct notifier_block init_cpu_capacity_notifier = {
++	.notifier_call = init_cpu_capacity_callback,
++};
++
++static int __init register_cpufreq_notifier(void)
++{
++	if (cap_parsing_failed)
++		return -EINVAL;
++
++	if (!alloc_cpumask_var(&cpus_to_visit, GFP_KERNEL)) {
++		pr_err("cpu_capacity: failed to allocate memory for cpus_to_visit\n");
++		return -ENOMEM;
++	}
++	cpumask_copy(cpus_to_visit, cpu_possible_mask);
++
++	return cpufreq_register_notifier(&init_cpu_capacity_notifier,
++					 CPUFREQ_POLICY_NOTIFIER);
++}
++core_initcall(register_cpufreq_notifier);
++#else
++static int __init free_raw_capacity(void)
++{
++	kfree(raw_capacity);
++
++	return 0;
++}
++core_initcall(free_raw_capacity);
++#endif
+ 
+ /*
+  * Iterate all CPUs' descriptor in DT and compute the efficiency
+@@ -99,6 +227,12 @@ static void __init parse_dt_topology(void)
+ 	__cpu_capacity = kcalloc(nr_cpu_ids, sizeof(*__cpu_capacity),
+ 				 GFP_NOWAIT);
+ 
++	cn = of_find_node_by_path("/cpus");
++	if (!cn) {
++		pr_err("No CPU information found in DT\n");
++		return;
++	}
++
+ 	for_each_possible_cpu(cpu) {
+ 		const u32 *rate;
+ 		int len;
+@@ -110,6 +244,13 @@ static void __init parse_dt_topology(void)
+ 			continue;
+ 		}
+ 
++		if (parse_cpu_capacity(cn, cpu)) {
++			of_node_put(cn);
++			continue;
++		}
++
++		cap_from_dt = false;
++
+ 		for (cpu_eff = table_efficiency; cpu_eff->compatible; cpu_eff++)
+ 			if (of_device_is_compatible(cn, cpu_eff->compatible))
+ 				break;
+@@ -151,6 +292,8 @@ static void __init parse_dt_topology(void)
+ 		middle_capacity = ((max_capacity / 3)
+ 				>> (SCHED_CAPACITY_SHIFT-1)) + 1;
+ 
++	if (cap_from_dt && !cap_parsing_failed)
++		normalize_cpu_capacity();
+ }
+ 
+ /*
+@@ -160,7 +303,7 @@ static void __init parse_dt_topology(void)
+  */
+ static void update_cpu_capacity(unsigned int cpu)
+ {
+-	if (!cpu_capacity(cpu))
++	if (!cpu_capacity(cpu) || cap_from_dt)
+ 		return;
+ 
+ 	set_capacity_scale(cpu, cpu_capacity(cpu) / middle_capacity);
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0025-fixup-arm-parse-cpu-capacity-dmips-mhz-from-DT.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0025-fixup-arm-parse-cpu-capacity-dmips-mhz-from-DT.patch
new file mode 100644
index 0000000..84dea53
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0025-fixup-arm-parse-cpu-capacity-dmips-mhz-from-DT.patch
@@ -0,0 +1,49 @@
+From 2b32578a1c36deaddcbb61dc6a10a17356a0499f Mon Sep 17 00:00:00 2001
+From: Juri Lelli <juri.lelli@arm.com>
+Date: Wed, 31 Aug 2016 18:04:46 +0100
+Subject: [PATCH 25/92] fixup! arm: parse cpu capacity-dmips-mhz from DT
+
+(cherry picked from commit 55df048a3a8e4940c78f2a24e6e1766af18a7577)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ arch/arm/kernel/topology.c | 10 ++++++++++
+ 1 file changed, 10 insertions(+)
+
+diff --git a/arch/arm/kernel/topology.c b/arch/arm/kernel/topology.c
+index b22868a..a26e787 100644
+--- a/arch/arm/kernel/topology.c
++++ b/arch/arm/kernel/topology.c
+@@ -143,6 +143,8 @@ static void normalize_cpu_capacity(void)
+ #ifdef CONFIG_CPU_FREQ
+ static cpumask_var_t cpus_to_visit;
+ static bool cap_parsing_done;
++static void parsing_done_workfn(struct work_struct *work);
++static DECLARE_WORK(parsing_done_work, parsing_done_workfn);
+ 
+ static int
+ init_cpu_capacity_callback(struct notifier_block *nb,
+@@ -173,6 +175,7 @@ static void normalize_cpu_capacity(void)
+ 			kfree(raw_capacity);
+ 			pr_debug("cpu_capacity: parsing done\n");
+ 			cap_parsing_done = true;
++			schedule_work(&parsing_done_work);
+ 		}
+ 	}
+ 	return 0;
+@@ -197,6 +200,13 @@ static int __init register_cpufreq_notifier(void)
+ 					 CPUFREQ_POLICY_NOTIFIER);
+ }
+ core_initcall(register_cpufreq_notifier);
++
++static void parsing_done_workfn(struct work_struct *work)
++{
++	cpufreq_unregister_notifier(&init_cpu_capacity_notifier,
++					 CPUFREQ_POLICY_NOTIFIER);
++}
++
+ #else
+ static int __init free_raw_capacity(void)
+ {
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0026-arm-dts-add-TC2-cpu-capacity-dmips-mhz-information.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0026-arm-dts-add-TC2-cpu-capacity-dmips-mhz-information.patch
new file mode 100644
index 0000000..bab5175
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0026-arm-dts-add-TC2-cpu-capacity-dmips-mhz-information.patch
@@ -0,0 +1,70 @@
+From dbe8ad50cfc3117c8b7384f31be43a747911d368 Mon Sep 17 00:00:00 2001
+From: Juri Lelli <juri.lelli@arm.com>
+Date: Tue, 13 Oct 2015 14:56:51 +0100
+Subject: [PATCH 26/92] arm, dts: add TC2 cpu capacity-dmips-mhz information
+
+Add TC2 cpu capacity information.
+
+Cc: Liviu Dudau <liviu.dudau@arm.com>
+Cc: Sudeep Holla <sudeep.holla@arm.com>
+Cc: Lorenzo Pieralisi <lorenzo.pieralisi@arm.com>
+Cc: Rob Herring <robh+dt@kernel.org>
+Cc: Pawel Moll <pawel.moll@arm.com>
+Cc: Mark Rutland <mark.rutland@arm.com>
+Cc: Ian Campbell <ijc+devicetree@hellion.org.uk>
+Cc: Kumar Gala <galak@codeaurora.org>
+Cc: Russell King <linux@arm.linux.org.uk>
+Cc: devicetree@vger.kernel.org
+Acked-by: Sudeep Holla <sudeep.holla@arm.com>
+Signed-off-by: Juri Lelli <juri.lelli@arm.com>
+---
+ arch/arm/boot/dts/vexpress-v2p-ca15_a7.dts | 5 +++++
+ 1 file changed, 5 insertions(+)
+
+diff --git a/arch/arm/boot/dts/vexpress-v2p-ca15_a7.dts b/arch/arm/boot/dts/vexpress-v2p-ca15_a7.dts
+index 0205c97..45d08cc 100644
+--- a/arch/arm/boot/dts/vexpress-v2p-ca15_a7.dts
++++ b/arch/arm/boot/dts/vexpress-v2p-ca15_a7.dts
+@@ -39,6 +39,7 @@
+ 			reg = <0>;
+ 			cci-control-port = <&cci_control1>;
+ 			cpu-idle-states = <&CLUSTER_SLEEP_BIG>;
++			capacity-dmips-mhz = <1024>;
+ 		};
+ 
+ 		cpu1: cpu@1 {
+@@ -47,6 +48,7 @@
+ 			reg = <1>;
+ 			cci-control-port = <&cci_control1>;
+ 			cpu-idle-states = <&CLUSTER_SLEEP_BIG>;
++			capacity-dmips-mhz = <1024>;
+ 		};
+ 
+ 		cpu2: cpu@2 {
+@@ -55,6 +57,7 @@
+ 			reg = <0x100>;
+ 			cci-control-port = <&cci_control2>;
+ 			cpu-idle-states = <&CLUSTER_SLEEP_LITTLE>;
++			capacity-dmips-mhz = <516>;
+ 		};
+ 
+ 		cpu3: cpu@3 {
+@@ -63,6 +66,7 @@
+ 			reg = <0x101>;
+ 			cci-control-port = <&cci_control2>;
+ 			cpu-idle-states = <&CLUSTER_SLEEP_LITTLE>;
++			capacity-dmips-mhz = <516>;
+ 		};
+ 
+ 		cpu4: cpu@4 {
+@@ -71,6 +75,7 @@
+ 			reg = <0x102>;
+ 			cci-control-port = <&cci_control2>;
+ 			cpu-idle-states = <&CLUSTER_SLEEP_LITTLE>;
++			capacity-dmips-mhz = <516>;
+ 		};
+ 
+ 		idle-states {
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0027-arm64-parse-cpu-capacity-dmips-mhz-from-DT.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0027-arm64-parse-cpu-capacity-dmips-mhz-from-DT.patch
new file mode 100644
index 0000000..0b35caf
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0027-arm64-parse-cpu-capacity-dmips-mhz-from-DT.patch
@@ -0,0 +1,212 @@
+From f7b42d6b9a5d61382b11dfa52484bd86f41fc32e Mon Sep 17 00:00:00 2001
+From: Juri Lelli <juri.lelli@arm.com>
+Date: Thu, 19 Nov 2015 16:18:38 +0000
+Subject: [PATCH 27/92] arm64: parse cpu capacity-dmips-mhz from DT
+
+With the introduction of cpu capacity-dmips-mhz bindings, CPU capacities
+can now be calculated from values extracted from DT and information
+coming from cpufreq. Add parsing of DT information at boot time, and
+complement it with cpufreq information. Also, store such information
+using per CPU variables, as we do for arm.
+
+Caveat: the information provided by this patch will start to be used in
+the future. We need to #define arch_scale_cpu_capacity to something
+provided in arch, so that scheduler's default implementation (which gets
+used if arch_scale_cpu_capacity is not defined) is overwritten.
+
+Cc: Catalin Marinas <catalin.marinas@arm.com>
+Cc: Will Deacon <will.deacon@arm.com>
+Cc: Mark Brown <broonie@kernel.org>
+Cc: Sudeep Holla <sudeep.holla@arm.com>
+Signed-off-by: Juri Lelli <juri.lelli@arm.com>
+---
+ arch/arm64/kernel/topology.c | 149 ++++++++++++++++++++++++++++++++++++++++++-
+ 1 file changed, 148 insertions(+), 1 deletion(-)
+
+diff --git a/arch/arm64/kernel/topology.c b/arch/arm64/kernel/topology.c
+index 694f6de..c1277c19 100644
+--- a/arch/arm64/kernel/topology.c
++++ b/arch/arm64/kernel/topology.c
+@@ -19,10 +19,152 @@
+ #include <linux/nodemask.h>
+ #include <linux/of.h>
+ #include <linux/sched.h>
++#include <linux/slab.h>
++#include <linux/cpufreq.h>
+ 
+ #include <asm/cputype.h>
+ #include <asm/topology.h>
+ 
++static DEFINE_PER_CPU(unsigned long, cpu_scale) = SCHED_CAPACITY_SCALE;
++
++unsigned long arch_scale_cpu_capacity(struct sched_domain *sd, int cpu)
++{
++	return per_cpu(cpu_scale, cpu);
++}
++
++static void set_capacity_scale(unsigned int cpu, unsigned long capacity)
++{
++	per_cpu(cpu_scale, cpu) = capacity;
++}
++
++static u32 capacity_scale;
++static u32 *raw_capacity;
++static bool cap_parsing_failed;
++
++static void __init parse_cpu_capacity(struct device_node *cpu_node, int cpu)
++{
++	int ret;
++	u32 cpu_capacity;
++
++	if (cap_parsing_failed)
++		return;
++
++	ret = of_property_read_u32(cpu_node,
++				   "capacity-dmips-mhz",
++				   &cpu_capacity);
++	if (!ret) {
++		if (!raw_capacity) {
++			raw_capacity = kcalloc(num_possible_cpus(),
++					       sizeof(*raw_capacity),
++					       GFP_KERNEL);
++			if (!raw_capacity) {
++				pr_err("cpu_capacity: failed to allocate memory for raw capacities\n");
++				cap_parsing_failed = true;
++				return;
++			}
++		}
++		capacity_scale = max(cpu_capacity, capacity_scale);
++		raw_capacity[cpu] = cpu_capacity;
++		pr_debug("cpu_capacity: %s cpu_capacity=%u (raw)\n",
++			cpu_node->full_name, raw_capacity[cpu]);
++	} else {
++		if (raw_capacity) {
++			pr_err("cpu_capacity: missing %s raw capacity\n",
++				cpu_node->full_name);
++			pr_err("cpu_capacity: partial information: fallback to 1024 for all CPUs\n");
++		}
++		cap_parsing_failed = true;
++		kfree(raw_capacity);
++	}
++}
++
++static void normalize_cpu_capacity(void)
++{
++	u64 capacity;
++	int cpu;
++
++	if (!raw_capacity || cap_parsing_failed)
++		return;
++
++	pr_debug("cpu_capacity: capacity_scale=%u\n", capacity_scale);
++	for_each_possible_cpu(cpu) {
++		pr_debug("cpu_capacity: cpu=%d raw_capacity=%u\n",
++			 cpu, raw_capacity[cpu]);
++		capacity = (raw_capacity[cpu] << SCHED_CAPACITY_SHIFT)
++			/ capacity_scale;
++		set_capacity_scale(cpu, capacity);
++		pr_debug("cpu_capacity: CPU%d cpu_capacity=%lu\n",
++			cpu, arch_scale_cpu_capacity(NULL, cpu));
++	}
++}
++
++#ifdef CONFIG_CPU_FREQ
++static cpumask_var_t cpus_to_visit;
++static bool cap_parsing_done;
++
++static int
++init_cpu_capacity_callback(struct notifier_block *nb,
++			   unsigned long val,
++			   void *data)
++{
++	struct cpufreq_policy *policy = data;
++	int cpu;
++
++	if (cap_parsing_failed || cap_parsing_done)
++		return 0;
++
++	switch (val) {
++	case CPUFREQ_NOTIFY:
++		pr_debug("cpu_capacity: init cpu capacity for CPUs [%*pbl] (to_visit=%*pbl)\n",
++				cpumask_pr_args(policy->related_cpus),
++				cpumask_pr_args(cpus_to_visit));
++		cpumask_andnot(cpus_to_visit,
++			       cpus_to_visit,
++			       policy->related_cpus);
++		for_each_cpu(cpu, policy->related_cpus) {
++			raw_capacity[cpu] = arch_scale_cpu_capacity(NULL, cpu) *
++					    policy->cpuinfo.max_freq / 1000UL;
++			capacity_scale = max(raw_capacity[cpu], capacity_scale);
++		}
++		if (cpumask_empty(cpus_to_visit)) {
++			normalize_cpu_capacity();
++			kfree(raw_capacity);
++			pr_debug("cpu_capacity: parsing done\n");
++			cap_parsing_done = true;
++		}
++	}
++	return 0;
++}
++
++static struct notifier_block init_cpu_capacity_notifier = {
++	.notifier_call = init_cpu_capacity_callback,
++};
++
++static int __init register_cpufreq_notifier(void)
++{
++	if (cap_parsing_failed)
++		return -EINVAL;
++
++	if (!alloc_cpumask_var(&cpus_to_visit, GFP_KERNEL)) {
++		pr_err("cpu_capacity: failed to allocate memory for cpus_to_visit\n");
++		return -ENOMEM;
++	}
++	cpumask_copy(cpus_to_visit, cpu_possible_mask);
++
++	return cpufreq_register_notifier(&init_cpu_capacity_notifier,
++					 CPUFREQ_POLICY_NOTIFIER);
++}
++core_initcall(register_cpufreq_notifier);
++#else
++static int __init free_raw_capacity(void)
++{
++	kfree(raw_capacity);
++
++	return 0;
++}
++core_initcall(free_raw_capacity);
++#endif
++
+ static int __init get_cpu_for_node(struct device_node *node)
+ {
+ 	struct device_node *cpu_node;
+@@ -34,6 +176,7 @@ static int __init get_cpu_for_node(struct device_node *node)
+ 
+ 	for_each_possible_cpu(cpu) {
+ 		if (of_get_cpu_node(cpu, NULL) == cpu_node) {
++			parse_cpu_capacity(cpu_node, cpu);
+ 			of_node_put(cpu_node);
+ 			return cpu;
+ 		}
+@@ -178,13 +321,17 @@ static int __init parse_dt_topology(void)
+ 	 * cluster with restricted subnodes.
+ 	 */
+ 	map = of_get_child_by_name(cn, "cpu-map");
+-	if (!map)
++	if (!map) {
++		cap_parsing_failed = true;
+ 		goto out;
++	}
+ 
+ 	ret = parse_cluster(map, 0);
+ 	if (ret != 0)
+ 		goto out_map;
+ 
++	normalize_cpu_capacity();
++
+ 	/*
+ 	 * Check that all cores are in the topology; the SMP code will
+ 	 * only mark cores described in the DT as possible.
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0028-fixup-arm64-parse-cpu-capacity-dmips-mhz-from-DT.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0028-fixup-arm64-parse-cpu-capacity-dmips-mhz-from-DT.patch
new file mode 100644
index 0000000..2cf8c09
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0028-fixup-arm64-parse-cpu-capacity-dmips-mhz-from-DT.patch
@@ -0,0 +1,49 @@
+From 7096f8cbba75b5a6a9ba440cae5c16092b16e492 Mon Sep 17 00:00:00 2001
+From: Juri Lelli <juri.lelli@arm.com>
+Date: Wed, 31 Aug 2016 18:05:12 +0100
+Subject: [PATCH 28/92] fixup! arm64: parse cpu capacity-dmips-mhz from DT
+
+(cherry picked from commit 2aa41d080e07f93dc979a23bf4e40f91e3643fb0)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ arch/arm64/kernel/topology.c | 10 ++++++++++
+ 1 file changed, 10 insertions(+)
+
+diff --git a/arch/arm64/kernel/topology.c b/arch/arm64/kernel/topology.c
+index c1277c19..b75b0ba 100644
+--- a/arch/arm64/kernel/topology.c
++++ b/arch/arm64/kernel/topology.c
+@@ -101,6 +101,8 @@ static void normalize_cpu_capacity(void)
+ #ifdef CONFIG_CPU_FREQ
+ static cpumask_var_t cpus_to_visit;
+ static bool cap_parsing_done;
++static void parsing_done_workfn(struct work_struct *work);
++static DECLARE_WORK(parsing_done_work, parsing_done_workfn);
+ 
+ static int
+ init_cpu_capacity_callback(struct notifier_block *nb,
+@@ -131,6 +133,7 @@ static void normalize_cpu_capacity(void)
+ 			kfree(raw_capacity);
+ 			pr_debug("cpu_capacity: parsing done\n");
+ 			cap_parsing_done = true;
++			schedule_work(&parsing_done_work);
+ 		}
+ 	}
+ 	return 0;
+@@ -155,6 +158,13 @@ static int __init register_cpufreq_notifier(void)
+ 					 CPUFREQ_POLICY_NOTIFIER);
+ }
+ core_initcall(register_cpufreq_notifier);
++
++static void parsing_done_workfn(struct work_struct *work)
++{
++	cpufreq_unregister_notifier(&init_cpu_capacity_notifier,
++					 CPUFREQ_POLICY_NOTIFIER);
++}
++
+ #else
+ static int __init free_raw_capacity(void)
+ {
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0029-arm64-dts-add-Juno-cpu-capacity-dmips-mhz-informatio.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0029-arm64-dts-add-Juno-cpu-capacity-dmips-mhz-informatio.patch
new file mode 100644
index 0000000..ced0790
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0029-arm64-dts-add-Juno-cpu-capacity-dmips-mhz-informatio.patch
@@ -0,0 +1,82 @@
+From 32b76aa4d389f58f621e704a4c67e6da9ee21df9 Mon Sep 17 00:00:00 2001
+From: Juri Lelli <juri.lelli@arm.com>
+Date: Wed, 11 Nov 2015 18:13:19 +0000
+Subject: [PATCH 29/92] arm64, dts: add Juno cpu capacity-dmips-mhz information
+
+Add Juno cpu capacity-dmips-mhz information.
+
+Cc: Rob Herring <robh+dt@kernel.org>
+Cc: Pawel Moll <pawel.moll@arm.com>
+Cc: Mark Rutland <mark.rutland@arm.com>
+Cc: Ian Campbell <ijc+devicetree@hellion.org.uk>
+Cc: Kumar Gala <galak@codeaurora.org>
+Cc: Catalin Marinas <catalin.marinas@arm.com>
+Cc: Will Deacon <will.deacon@arm.com>
+Cc: Liviu Dudau <Liviu.Dudau@arm.com>
+Cc: Sudeep Holla <sudeep.holla@arm.com>
+Cc: Arnd Bergmann <arnd@arndb.de>
+Cc: Jon Medhurst <tixy@linaro.org>
+Cc: Olof Johansson <olof@lixom.net>
+Cc: Robin Murphy <robin.murphy@arm.com>
+Cc: devicetree@vger.kernel.org
+Acked-by: Sudeep Holla <sudeep.holla@arm.com>
+Signed-off-by: Juri Lelli <juri.lelli@arm.com>
+---
+ arch/arm64/boot/dts/arm/juno.dts | 6 ++++++
+ 1 file changed, 6 insertions(+)
+
+diff --git a/arch/arm64/boot/dts/arm/juno.dts b/arch/arm64/boot/dts/arm/juno.dts
+index 6e154d9..ac5ceb7 100644
+--- a/arch/arm64/boot/dts/arm/juno.dts
++++ b/arch/arm64/boot/dts/arm/juno.dts
+@@ -90,6 +90,7 @@
+ 			next-level-cache = <&A57_L2>;
+ 			clocks = <&scpi_dvfs 0>;
+ 			cpu-idle-states = <&CPU_SLEEP_0 &CLUSTER_SLEEP_0>;
++			capacity-dmips-mhz = <1024>;
+ 		};
+ 
+ 		A57_1: cpu@1 {
+@@ -100,6 +101,7 @@
+ 			next-level-cache = <&A57_L2>;
+ 			clocks = <&scpi_dvfs 0>;
+ 			cpu-idle-states = <&CPU_SLEEP_0 &CLUSTER_SLEEP_0>;
++			capacity-dmips-mhz = <1024>;
+ 		};
+ 
+ 		A53_0: cpu@100 {
+@@ -110,6 +112,7 @@
+ 			next-level-cache = <&A53_L2>;
+ 			clocks = <&scpi_dvfs 1>;
+ 			cpu-idle-states = <&CPU_SLEEP_0 &CLUSTER_SLEEP_0>;
++			capacity-dmips-mhz = <578>;
+ 		};
+ 
+ 		A53_1: cpu@101 {
+@@ -120,6 +123,7 @@
+ 			next-level-cache = <&A53_L2>;
+ 			clocks = <&scpi_dvfs 1>;
+ 			cpu-idle-states = <&CPU_SLEEP_0 &CLUSTER_SLEEP_0>;
++			capacity-dmips-mhz = <578>;
+ 		};
+ 
+ 		A53_2: cpu@102 {
+@@ -130,6 +134,7 @@
+ 			next-level-cache = <&A53_L2>;
+ 			clocks = <&scpi_dvfs 1>;
+ 			cpu-idle-states = <&CPU_SLEEP_0 &CLUSTER_SLEEP_0>;
++			capacity-dmips-mhz = <578>;
+ 		};
+ 
+ 		A53_3: cpu@103 {
+@@ -140,6 +145,7 @@
+ 			next-level-cache = <&A53_L2>;
+ 			clocks = <&scpi_dvfs 1>;
+ 			cpu-idle-states = <&CPU_SLEEP_0 &CLUSTER_SLEEP_0>;
++			capacity-dmips-mhz = <578>;
+ 		};
+ 
+ 		A57_L2: l2-cache0 {
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0030-arm64-dts-add-Juno-r2-cpu-capacity-dmips-mhz-informa.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0030-arm64-dts-add-Juno-r2-cpu-capacity-dmips-mhz-informa.patch
new file mode 100644
index 0000000..79bd1a6
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0030-arm64-dts-add-Juno-r2-cpu-capacity-dmips-mhz-informa.patch
@@ -0,0 +1,83 @@
+From 893313890fb7c18ba7e63626924f32deea273bec Mon Sep 17 00:00:00 2001
+From: Juri Lelli <juri.lelli@arm.com>
+Date: Tue, 22 Mar 2016 15:45:16 +0000
+Subject: [PATCH 30/92] arm64, dts: add Juno r2 cpu capacity-dmips-mhz
+ information
+
+Add Juno r2 cpu capacity-dmips-mhz information.
+
+Cc: Rob Herring <robh+dt@kernel.org>
+Cc: Pawel Moll <pawel.moll@arm.com>
+Cc: Mark Rutland <mark.rutland@arm.com>
+Cc: Ian Campbell <ijc+devicetree@hellion.org.uk>
+Cc: Kumar Gala <galak@codeaurora.org>
+Cc: Catalin Marinas <catalin.marinas@arm.com>
+Cc: Will Deacon <will.deacon@arm.com>
+Cc: Liviu Dudau <Liviu.Dudau@arm.com>
+Cc: Sudeep Holla <sudeep.holla@arm.com>
+Cc: Arnd Bergmann <arnd@arndb.de>
+Cc: Jon Medhurst <tixy@linaro.org>
+Cc: Olof Johansson <olof@lixom.net>
+Cc: Robin Murphy <robin.murphy@arm.com>
+Cc: devicetree@vger.kernel.org
+Acked-by: Sudeep Holla <sudeep.holla@arm.com>
+Signed-off-by: Juri Lelli <juri.lelli@arm.com>
+---
+ arch/arm64/boot/dts/arm/juno-r2.dts | 6 ++++++
+ 1 file changed, 6 insertions(+)
+
+diff --git a/arch/arm64/boot/dts/arm/juno-r2.dts b/arch/arm64/boot/dts/arm/juno-r2.dts
+index 26aaa6a..28f40ec 100644
+--- a/arch/arm64/boot/dts/arm/juno-r2.dts
++++ b/arch/arm64/boot/dts/arm/juno-r2.dts
+@@ -90,6 +90,7 @@
+ 			next-level-cache = <&A72_L2>;
+ 			clocks = <&scpi_dvfs 0>;
+ 			cpu-idle-states = <&CPU_SLEEP_0 &CLUSTER_SLEEP_0>;
++			capacity-dmips-mhz = <1024>;
+ 		};
+ 
+ 		A72_1: cpu@1 {
+@@ -100,6 +101,7 @@
+ 			next-level-cache = <&A72_L2>;
+ 			clocks = <&scpi_dvfs 0>;
+ 			cpu-idle-states = <&CPU_SLEEP_0 &CLUSTER_SLEEP_0>;
++			capacity-dmips-mhz = <1024>;
+ 		};
+ 
+ 		A53_0: cpu@100 {
+@@ -110,6 +112,7 @@
+ 			next-level-cache = <&A53_L2>;
+ 			clocks = <&scpi_dvfs 1>;
+ 			cpu-idle-states = <&CPU_SLEEP_0 &CLUSTER_SLEEP_0>;
++			capacity-dmips-mhz = <485>;
+ 		};
+ 
+ 		A53_1: cpu@101 {
+@@ -120,6 +123,7 @@
+ 			next-level-cache = <&A53_L2>;
+ 			clocks = <&scpi_dvfs 1>;
+ 			cpu-idle-states = <&CPU_SLEEP_0 &CLUSTER_SLEEP_0>;
++			capacity-dmips-mhz = <485>;
+ 		};
+ 
+ 		A53_2: cpu@102 {
+@@ -130,6 +134,7 @@
+ 			next-level-cache = <&A53_L2>;
+ 			clocks = <&scpi_dvfs 1>;
+ 			cpu-idle-states = <&CPU_SLEEP_0 &CLUSTER_SLEEP_0>;
++			capacity-dmips-mhz = <485>;
+ 		};
+ 
+ 		A53_3: cpu@103 {
+@@ -140,6 +145,7 @@
+ 			next-level-cache = <&A53_L2>;
+ 			clocks = <&scpi_dvfs 1>;
+ 			cpu-idle-states = <&CPU_SLEEP_0 &CLUSTER_SLEEP_0>;
++			capacity-dmips-mhz = <485>;
+ 		};
+ 
+ 		A72_L2: l2-cache0 {
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0031-arm-add-sysfs-cpu_capacity-attribute.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0031-arm-add-sysfs-cpu_capacity-attribute.patch
new file mode 100644
index 0000000..03c46e3
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0031-arm-add-sysfs-cpu_capacity-attribute.patch
@@ -0,0 +1,127 @@
+From cecbf11db6cfccccc7019e2aeec37ead5d8b8a03 Mon Sep 17 00:00:00 2001
+From: Juri Lelli <juri.lelli@arm.com>
+Date: Thu, 15 Oct 2015 13:53:37 +0100
+Subject: [PATCH 31/92] arm: add sysfs cpu_capacity attribute
+
+Add a sysfs cpu_capacity attribute with which it is possible to read and
+write (thus over-writing default values) CPUs capacity. This might be
+useful in situations where values needs changing after boot.
+
+The new attribute shows up as:
+
+ /sys/devices/system/cpu/cpu*/cpu_capacity
+
+Cc: Russell King <linux@arm.linux.org.uk>
+Signed-off-by: Juri Lelli <juri.lelli@arm.com>
+---
+ arch/arm/kernel/topology.c | 73 ++++++++++++++++++++++++++++++++++++++++++++++
+ 1 file changed, 73 insertions(+)
+
+diff --git a/arch/arm/kernel/topology.c b/arch/arm/kernel/topology.c
+index a26e787..e79ac85 100644
+--- a/arch/arm/kernel/topology.c
++++ b/arch/arm/kernel/topology.c
+@@ -41,6 +41,7 @@
+  * updated during this sequence.
+  */
+ static DEFINE_PER_CPU(unsigned long, cpu_scale) = SCHED_CAPACITY_SCALE;
++static DEFINE_MUTEX(cpu_scale_mutex);
+ 
+ unsigned long arch_scale_cpu_capacity(struct sched_domain *sd, int cpu)
+ {
+@@ -52,6 +53,76 @@ static void set_capacity_scale(unsigned int cpu, unsigned long capacity)
+ 	per_cpu(cpu_scale, cpu) = capacity;
+ }
+ 
++#ifdef CONFIG_PROC_SYSCTL
++#include <asm/cpu.h>
++#include <linux/string.h>
++static ssize_t show_cpu_capacity(struct device *dev,
++				 struct device_attribute *attr,
++				 char *buf)
++{
++	struct cpu *cpu = container_of(dev, struct cpu, dev);
++	ssize_t rc;
++	int cpunum = cpu->dev.id;
++	unsigned long capacity = arch_scale_cpu_capacity(NULL, cpunum);
++
++	rc = sprintf(buf, "%lu\n", capacity);
++
++	return rc;
++}
++
++static ssize_t store_cpu_capacity(struct device *dev,
++				  struct device_attribute *attr,
++				  const char *buf,
++				  size_t count)
++{
++	struct cpu *cpu = container_of(dev, struct cpu, dev);
++	int this_cpu = cpu->dev.id, i;
++	unsigned long new_capacity;
++	ssize_t ret;
++
++	if (count) {
++		char *p = (char *) buf;
++
++		ret = kstrtoul(p, 0, &new_capacity);
++		if (ret)
++			return ret;
++		if (new_capacity > SCHED_CAPACITY_SCALE)
++			return -EINVAL;
++
++		mutex_lock(&cpu_scale_mutex);
++		for_each_cpu(i, &cpu_topology[this_cpu].core_sibling)
++			set_capacity_scale(i, new_capacity);
++		mutex_unlock(&cpu_scale_mutex);
++	}
++
++	return count;
++}
++
++static DEVICE_ATTR(cpu_capacity,
++		   0644,
++		   show_cpu_capacity,
++		   store_cpu_capacity);
++
++static int register_cpu_capacity_sysctl(void)
++{
++	int i;
++	struct device *cpu;
++
++	for_each_possible_cpu(i) {
++		cpu = get_cpu_device(i);
++		if (!cpu) {
++			pr_err("%s: too early to get CPU%d device!\n",
++			       __func__, i);
++			continue;
++		}
++		device_create_file(cpu, &dev_attr_cpu_capacity);
++	}
++
++	return 0;
++}
++late_initcall(register_cpu_capacity_sysctl);
++#endif
++
+ #ifdef CONFIG_OF
+ struct cpu_efficiency {
+ 	const char *compatible;
+@@ -131,6 +202,7 @@ static void normalize_cpu_capacity(void)
+ 		return;
+ 
+ 	pr_debug("cpu_capacity: capacity_scale=%u\n", capacity_scale);
++	mutex_lock(&cpu_scale_mutex);
+ 	for_each_possible_cpu(cpu) {
+ 		capacity = (raw_capacity[cpu] << SCHED_CAPACITY_SHIFT)
+ 			/ capacity_scale;
+@@ -138,6 +210,7 @@ static void normalize_cpu_capacity(void)
+ 		pr_debug("cpu_capacity: CPU%d cpu_capacity=%lu\n",
+ 			cpu, arch_scale_cpu_capacity(NULL, cpu));
+ 	}
++	mutex_unlock(&cpu_scale_mutex);
+ }
+ 
+ #ifdef CONFIG_CPU_FREQ
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0032-arm64-add-sysfs-cpu_capacity-attribute.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0032-arm64-add-sysfs-cpu_capacity-attribute.patch
new file mode 100644
index 0000000..83f9e38
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0032-arm64-add-sysfs-cpu_capacity-attribute.patch
@@ -0,0 +1,130 @@
+From 4454a804e1015b7699441e42d36dd8be8b0ee897 Mon Sep 17 00:00:00 2001
+From: Juri Lelli <juri.lelli@arm.com>
+Date: Wed, 14 Oct 2015 12:02:05 +0100
+Subject: [PATCH 32/92] arm64: add sysfs cpu_capacity attribute
+
+Add a sysfs cpu_capacity attribute with which it is possible to read and
+write (thus over-writing default values) CPUs capacity. This might be
+useful in situations where values needs changing after boot.
+
+The new attribute shows up as:
+
+ /sys/devices/system/cpu/cpu*/cpu_capacity
+
+Cc: Catalin Marinas <catalin.marinas@arm.com>
+Cc: Will Deacon <will.deacon@arm.com>
+Cc: Mark Brown <broonie@kernel.org>
+Cc: Sudeep Holla <sudeep.holla@arm.com>
+Signed-off-by: Juri Lelli <juri.lelli@arm.com>
+---
+ arch/arm64/kernel/topology.c | 73 ++++++++++++++++++++++++++++++++++++++++++++
+ 1 file changed, 73 insertions(+)
+
+diff --git a/arch/arm64/kernel/topology.c b/arch/arm64/kernel/topology.c
+index b75b0ba..cff34cc 100644
+--- a/arch/arm64/kernel/topology.c
++++ b/arch/arm64/kernel/topology.c
+@@ -26,6 +26,7 @@
+ #include <asm/topology.h>
+ 
+ static DEFINE_PER_CPU(unsigned long, cpu_scale) = SCHED_CAPACITY_SCALE;
++static DEFINE_MUTEX(cpu_scale_mutex);
+ 
+ unsigned long arch_scale_cpu_capacity(struct sched_domain *sd, int cpu)
+ {
+@@ -37,6 +38,76 @@ static void set_capacity_scale(unsigned int cpu, unsigned long capacity)
+ 	per_cpu(cpu_scale, cpu) = capacity;
+ }
+ 
++#ifdef CONFIG_PROC_SYSCTL
++#include <asm/cpu.h>
++#include <linux/string.h>
++static ssize_t show_cpu_capacity(struct device *dev,
++				 struct device_attribute *attr,
++				 char *buf)
++{
++	struct cpu *cpu = container_of(dev, struct cpu, dev);
++	ssize_t rc;
++	int cpunum = cpu->dev.id;
++	unsigned long capacity = arch_scale_cpu_capacity(NULL, cpunum);
++
++	rc = sprintf(buf, "%lu\n", capacity);
++
++	return rc;
++}
++
++static ssize_t store_cpu_capacity(struct device *dev,
++				  struct device_attribute *attr,
++				  const char *buf,
++				  size_t count)
++{
++	struct cpu *cpu = container_of(dev, struct cpu, dev);
++	int this_cpu = cpu->dev.id, i;
++	unsigned long new_capacity;
++	ssize_t ret;
++
++	if (count) {
++		char *p = (char *) buf;
++
++		ret = kstrtoul(p, 0, &new_capacity);
++		if (ret)
++			return ret;
++		if (new_capacity > SCHED_CAPACITY_SCALE)
++			return -EINVAL;
++
++		mutex_lock(&cpu_scale_mutex);
++		for_each_cpu(i, &cpu_topology[this_cpu].core_sibling)
++			set_capacity_scale(i, new_capacity);
++		mutex_unlock(&cpu_scale_mutex);
++	}
++
++	return count;
++}
++
++static DEVICE_ATTR(cpu_capacity,
++		   0644,
++		   show_cpu_capacity,
++		   store_cpu_capacity);
++
++static int register_cpu_capacity_sysctl(void)
++{
++	int i;
++	struct device *cpu;
++
++	for_each_possible_cpu(i) {
++		cpu = get_cpu_device(i);
++		if (!cpu) {
++			pr_err("%s: too early to get CPU%d device!\n",
++			       __func__, i);
++			continue;
++		}
++		device_create_file(cpu, &dev_attr_cpu_capacity);
++	}
++
++	return 0;
++}
++late_initcall(register_cpu_capacity_sysctl);
++#endif
++
+ static u32 capacity_scale;
+ static u32 *raw_capacity;
+ static bool cap_parsing_failed;
+@@ -87,6 +158,7 @@ static void normalize_cpu_capacity(void)
+ 		return;
+ 
+ 	pr_debug("cpu_capacity: capacity_scale=%u\n", capacity_scale);
++	mutex_lock(&cpu_scale_mutex);
+ 	for_each_possible_cpu(cpu) {
+ 		pr_debug("cpu_capacity: cpu=%d raw_capacity=%u\n",
+ 			 cpu, raw_capacity[cpu]);
+@@ -96,6 +168,7 @@ static void normalize_cpu_capacity(void)
+ 		pr_debug("cpu_capacity: CPU%d cpu_capacity=%lu\n",
+ 			cpu, arch_scale_cpu_capacity(NULL, cpu));
+ 	}
++	mutex_unlock(&cpu_scale_mutex);
+ }
+ 
+ #ifdef CONFIG_CPU_FREQ
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0033-fixup-arm-include-linux-cpufreq.h.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0033-fixup-arm-include-linux-cpufreq.h.patch
new file mode 100644
index 0000000..adce4b1
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0033-fixup-arm-include-linux-cpufreq.h.patch
@@ -0,0 +1,27 @@
+From 98f9117448e3de1af4886892b3bf011aedebc4e8 Mon Sep 17 00:00:00 2001
+From: Dietmar Eggemann <dietmar.eggemann@arm.com>
+Date: Mon, 21 Nov 2016 12:24:49 +0000
+Subject: [PATCH 33/92] fixup! arm: #include <linux/cpufreq.h>
+
+Signed-off-by: Dietmar Eggemann <dietmar.eggemann@arm.com>
+(cherry picked from commit 9744ccb31b7c454f7355ca2f8545a23b8cb76b15)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ arch/arm/kernel/topology.c | 1 +
+ 1 file changed, 1 insertion(+)
+
+diff --git a/arch/arm/kernel/topology.c b/arch/arm/kernel/topology.c
+index e79ac85..46167bf 100644
+--- a/arch/arm/kernel/topology.c
++++ b/arch/arm/kernel/topology.c
+@@ -21,6 +21,7 @@
+ #include <linux/of.h>
+ #include <linux/sched.h>
+ #include <linux/slab.h>
++#include <linux/cpufreq.h>
+ 
+ #include <asm/cputype.h>
+ #include <asm/topology.h>
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0034-arm-Re-wire-cpu-invariant-load-tracking-support-up-t.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0034-arm-Re-wire-cpu-invariant-load-tracking-support-up-t.patch
new file mode 100644
index 0000000..3cc8cff
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0034-arm-Re-wire-cpu-invariant-load-tracking-support-up-t.patch
@@ -0,0 +1,55 @@
+From a7770736a651a5e7ee12b2df95982ff7d76a6c5a Mon Sep 17 00:00:00 2001
+From: Morten Rasmussen <morten.rasmussen@arm.com>
+Date: Tue, 14 Apr 2015 16:25:31 +0100
+Subject: [PATCH 34/92] arm: Re-wire cpu-invariant load-tracking support up to
+ the scheduler
+
+Since commit 8cd5601c5060 ("sched/fair: Convert arch_scale_cpu_capacity()
+from weak function to #define") the wiring has to be done by associating
+arch_scale_cpu_capacity with the actual implementation provided by the
+arch.
+
+Define arch_scale_freq_capacity to use the arch-specific function
+scale_cpu_capacity().
+
+cc: Russell King <linux@arm.linux.org.uk>
+Signed-off-by: Morten Rasmussen <morten.rasmussen@arm.com>
+Signed-off-by: Dietmar Eggemann <dietmar.eggemann@arm.com>
+(cherry picked from commit 496fddb12c6eeb54a2caa3413c0a591dc2762ab6)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ arch/arm/include/asm/topology.h | 4 ++++
+ arch/arm/kernel/topology.c      | 2 +-
+ 2 files changed, 5 insertions(+), 1 deletion(-)
+
+diff --git a/arch/arm/include/asm/topology.h b/arch/arm/include/asm/topology.h
+index 370f7a7..942a863 100644
+--- a/arch/arm/include/asm/topology.h
++++ b/arch/arm/include/asm/topology.h
+@@ -24,6 +24,10 @@ struct cputopo_arm {
+ void store_cpu_topology(unsigned int cpuid);
+ const struct cpumask *cpu_coregroup_mask(int cpu);
+ 
++struct sched_domain;
++#define arch_scale_cpu_capacity scale_cpu_capacity
++extern unsigned long scale_cpu_capacity(struct sched_domain *sd, int cpu);
++
+ #else
+ 
+ static inline void init_cpu_topology(void) { }
+diff --git a/arch/arm/kernel/topology.c b/arch/arm/kernel/topology.c
+index 46167bf..f0957f3 100644
+--- a/arch/arm/kernel/topology.c
++++ b/arch/arm/kernel/topology.c
+@@ -44,7 +44,7 @@
+ static DEFINE_PER_CPU(unsigned long, cpu_scale) = SCHED_CAPACITY_SCALE;
+ static DEFINE_MUTEX(cpu_scale_mutex);
+ 
+-unsigned long arch_scale_cpu_capacity(struct sched_domain *sd, int cpu)
++unsigned long scale_cpu_capacity(struct sched_domain *sd, int cpu)
+ {
+ 	return per_cpu(cpu_scale, cpu);
+ }
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0035-arm-Make-cpufreq-policy-notifier-usable-for-frequenc.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0035-arm-Make-cpufreq-policy-notifier-usable-for-frequenc.patch
new file mode 100644
index 0000000..7a004f0
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0035-arm-Make-cpufreq-policy-notifier-usable-for-frequenc.patch
@@ -0,0 +1,83 @@
+From e869e7130e9fcb8b44fd20b11ba4eee166f3f958 Mon Sep 17 00:00:00 2001
+From: Dietmar Eggemann <dietmar.eggemann@arm.com>
+Date: Mon, 21 Nov 2016 16:42:17 +0000
+Subject: [PATCH 35/92] arm: Make cpufreq policy notifier usable for
+ frequency-invariant load-tracking support
+
+The maximum supported frequency of a cpu (policy->cpuinfo.max_freq) has
+to be retrieved for frequency-invariant load-tracking.
+
+This can be achieved by coding this functionality into the existing
+cpufreq policy notifier (init_cpu_capacity_notifier) which is currently
+only used for setting up dt-based cpu capacities (cpu node property
+capacity-dmips-mhz).
+
+But frequency-invariant load-tracking has to work whether cpu capacity
+dt-parsing succeeded or not.
+
+Change init_cpu_capacity_notifier in such a way that even if the parsing
+of the cpu capacity information failed the notifier is called for each
+cpufreq policy to be able to set the maximum supported frequency.
+
+The continue statement in init_cpu_capacity_callback() makes sure that we
+don't go on calculating cap_scale in case the capacity parsing failed. The
+whole implementation makes only sense as soon the code to set the per-cpu
+variable max_freq is introduced by the following patch ("arm:
+Frequency-invariant load-tracking support").
+
+Cc: Russell King <linux@arm.linux.org.uk>
+Signed-off-by: Dietmar Eggemann <dietmar.eggemann@arm.com>
+(cherry picked from commit e47eb4cac39817612543425e7d64cd30a6baf684)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ arch/arm/kernel/topology.c | 15 ++++++++-------
+ 1 file changed, 8 insertions(+), 7 deletions(-)
+
+diff --git a/arch/arm/kernel/topology.c b/arch/arm/kernel/topology.c
+index f0957f3..b030d01 100644
+--- a/arch/arm/kernel/topology.c
++++ b/arch/arm/kernel/topology.c
+@@ -228,7 +228,7 @@ static void normalize_cpu_capacity(void)
+ 	struct cpufreq_policy *policy = data;
+ 	int cpu;
+ 
+-	if (cap_parsing_failed || cap_parsing_done)
++	if (cap_parsing_done)
+ 		return 0;
+ 
+ 	switch (val) {
+@@ -240,14 +240,18 @@ static void normalize_cpu_capacity(void)
+ 			       cpus_to_visit,
+ 			       policy->related_cpus);
+ 		for_each_cpu(cpu, policy->related_cpus) {
++			if (cap_parsing_failed)
++				continue;
+ 			raw_capacity[cpu] = arch_scale_cpu_capacity(NULL, cpu) *
+ 					    policy->cpuinfo.max_freq / 1000UL;
+ 			capacity_scale = max(raw_capacity[cpu], capacity_scale);
+ 		}
+ 		if (cpumask_empty(cpus_to_visit)) {
+-			normalize_cpu_capacity();
+-			kfree(raw_capacity);
+-			pr_debug("cpu_capacity: parsing done\n");
++			if (!cap_parsing_failed) {
++				normalize_cpu_capacity();
++				kfree(raw_capacity);
++			}
++			pr_debug("cpu_capacity: parsing done");
+ 			cap_parsing_done = true;
+ 			schedule_work(&parsing_done_work);
+ 		}
+@@ -261,9 +265,6 @@ static void normalize_cpu_capacity(void)
+ 
+ static int __init register_cpufreq_notifier(void)
+ {
+-	if (cap_parsing_failed)
+-		return -EINVAL;
+-
+ 	if (!alloc_cpumask_var(&cpus_to_visit, GFP_KERNEL)) {
+ 		pr_err("cpu_capacity: failed to allocate memory for cpus_to_visit\n");
+ 		return -ENOMEM;
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0036-arm-Frequency-invariant-load-tracking-support.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0036-arm-Frequency-invariant-load-tracking-support.patch
new file mode 100644
index 0000000..5c8419e
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0036-arm-Frequency-invariant-load-tracking-support.patch
@@ -0,0 +1,134 @@
+From f2b29716bba30b235f4c3a4292bb0ca0465e0031 Mon Sep 17 00:00:00 2001
+From: Dietmar Eggemann <dietmar.eggemann@arm.com>
+Date: Wed, 16 Nov 2016 19:46:35 +0000
+Subject: [PATCH 36/92] arm: Frequency-invariant load-tracking support
+
+Implements arch-specific function scale_freq_capacity() which provides
+the following frequency scaling factor:
+
+  current_freq(cpu) << SCHED_CAPACITY_SHIFT / max_supported_freq(cpu)
+
+The debug output in init_cpu_capacity_callback() has been changed to be
+able to distinguish whether cpu capacity and max frequency or only max
+frequency has been parsed. The latter case happens on systems where there
+is no or broken cpu capacity binding (cpu node property
+capacity-dmips-mhz) information.
+
+One possible consumer of this is the Per-Entity Load Tracking (PELT)
+mechanism of the scheduler's CFS class.
+
+The actual wiring up to the scheduler isn't provided by this patch.
+
+Cc: Russell King <linux@arm.linux.org.uk>
+Signed-off-by: Dietmar Eggemann <dietmar.eggemann@arm.com>
+(cherry picked from commit fd3bdcb6e9f895ba22de4295e29de4f4e1ed3e77)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ arch/arm/kernel/topology.c | 57 +++++++++++++++++++++++++++++++++++++++++-----
+ 1 file changed, 51 insertions(+), 6 deletions(-)
+
+diff --git a/arch/arm/kernel/topology.c b/arch/arm/kernel/topology.c
+index b030d01..e521b07 100644
+--- a/arch/arm/kernel/topology.c
++++ b/arch/arm/kernel/topology.c
+@@ -219,6 +219,8 @@ static void normalize_cpu_capacity(void)
+ static bool cap_parsing_done;
+ static void parsing_done_workfn(struct work_struct *work);
+ static DECLARE_WORK(parsing_done_work, parsing_done_workfn);
++static DEFINE_PER_CPU(unsigned long, freq_scale) = SCHED_CAPACITY_SCALE;
++static DEFINE_PER_CPU(unsigned long, max_freq);
+ 
+ static int
+ init_cpu_capacity_callback(struct notifier_block *nb,
+@@ -233,13 +235,14 @@ static void normalize_cpu_capacity(void)
+ 
+ 	switch (val) {
+ 	case CPUFREQ_NOTIFY:
+-		pr_debug("cpu_capacity: init cpu capacity for CPUs [%*pbl] (to_visit=%*pbl)\n",
+-				cpumask_pr_args(policy->related_cpus),
+-				cpumask_pr_args(cpus_to_visit));
++		pr_debug("cpu_capacity: calling %s for CPUs [%*pbl] (to_visit=%*pbl)\n",
++			 __func__, cpumask_pr_args(policy->related_cpus),
++			 cpumask_pr_args(cpus_to_visit));
+ 		cpumask_andnot(cpus_to_visit,
+ 			       cpus_to_visit,
+ 			       policy->related_cpus);
+ 		for_each_cpu(cpu, policy->related_cpus) {
++			per_cpu(max_freq, cpu) = policy->cpuinfo.max_freq;
+ 			if (cap_parsing_failed)
+ 				continue;
+ 			raw_capacity[cpu] = arch_scale_cpu_capacity(NULL, cpu) *
+@@ -250,8 +253,10 @@ static void normalize_cpu_capacity(void)
+ 			if (!cap_parsing_failed) {
+ 				normalize_cpu_capacity();
+ 				kfree(raw_capacity);
++				pr_debug("cpu_capacity: parsing done");
++			} else {
++				pr_debug("cpu_capacity: max frequency parsing done");
+ 			}
+-			pr_debug("cpu_capacity: parsing done");
+ 			cap_parsing_done = true;
+ 			schedule_work(&parsing_done_work);
+ 		}
+@@ -263,16 +268,56 @@ static void normalize_cpu_capacity(void)
+ 	.notifier_call = init_cpu_capacity_callback,
+ };
+ 
++unsigned long scale_freq_capacity(struct sched_domain *sd, int cpu)
++{
++	return per_cpu(freq_scale, cpu);
++}
++
++static void set_freq_scale(unsigned int cpu, unsigned long freq)
++{
++	unsigned long max = per_cpu(max_freq, cpu);
++
++	if (!max)
++		return;
++
++	per_cpu(freq_scale, cpu) = (freq << SCHED_CAPACITY_SHIFT) / max;
++}
++
++static int
++set_freq_scale_callback(struct notifier_block *nb,
++			unsigned long val,
++			void *data)
++{
++	struct cpufreq_freqs *freq = data;
++
++	switch (val) {
++	case CPUFREQ_PRECHANGE:
++		set_freq_scale(freq->cpu, freq->new);
++	}
++	return 0;
++}
++
++static struct notifier_block set_freq_scale_notifier = {
++	.notifier_call = set_freq_scale_callback,
++};
+ static int __init register_cpufreq_notifier(void)
+ {
++	int ret;
++
+ 	if (!alloc_cpumask_var(&cpus_to_visit, GFP_KERNEL)) {
+ 		pr_err("cpu_capacity: failed to allocate memory for cpus_to_visit\n");
+ 		return -ENOMEM;
+ 	}
+ 	cpumask_copy(cpus_to_visit, cpu_possible_mask);
+ 
+-	return cpufreq_register_notifier(&init_cpu_capacity_notifier,
+-					 CPUFREQ_POLICY_NOTIFIER);
++	ret = cpufreq_register_notifier(&init_cpu_capacity_notifier,
++					CPUFREQ_POLICY_NOTIFIER);
++
++	if (ret)
++		return ret;
++
++	return cpufreq_register_notifier(&set_freq_scale_notifier,
++					 CPUFREQ_TRANSITION_NOTIFIER);
+ }
+ core_initcall(register_cpufreq_notifier);
+ 
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0037-arm-Wire-frequency-invariant-load-tracking-support-u.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0037-arm-Wire-frequency-invariant-load-tracking-support-u.patch
new file mode 100644
index 0000000..5ddb5aa
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0037-arm-Wire-frequency-invariant-load-tracking-support-u.patch
@@ -0,0 +1,38 @@
+From d3d5aa80cf65f112c759fdd04ec6725361afa6a5 Mon Sep 17 00:00:00 2001
+From: Dietmar Eggemann <dietmar.eggemann@arm.com>
+Date: Fri, 18 Nov 2016 12:30:31 +0000
+Subject: [PATCH 37/92] arm: Wire frequency-invariant load-tracking support up
+ to the scheduler
+
+Define arch_scale_freq_capacity to use the arch-specific function
+scale_freq_capacity().
+
+Cc: Russell King <linux@arm.linux.org.uk>
+Signed-off-by: Dietmar Eggemann <dietmar.eggemann@arm.com>
+(cherry picked from commit 7049774f92be687318845bf633f314676285792f)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ arch/arm/include/asm/topology.h | 7 +++++++
+ 1 file changed, 7 insertions(+)
+
+diff --git a/arch/arm/include/asm/topology.h b/arch/arm/include/asm/topology.h
+index 942a863..981e9c2 100644
+--- a/arch/arm/include/asm/topology.h
++++ b/arch/arm/include/asm/topology.h
+@@ -28,6 +28,13 @@ struct cputopo_arm {
+ #define arch_scale_cpu_capacity scale_cpu_capacity
+ extern unsigned long scale_cpu_capacity(struct sched_domain *sd, int cpu);
+ 
++#ifdef CONFIG_CPU_FREQ
++
++#define arch_scale_freq_capacity scale_freq_capacity
++extern unsigned long scale_freq_capacity(struct sched_domain *sd, int cpu);
++
++#endif /* CONFIG_CPU_FREQ */
++
+ #else
+ 
+ static inline void init_cpu_topology(void) { }
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0038-arm64-Wire-cpu-invariant-load-tracking-support-up-to.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0038-arm64-Wire-cpu-invariant-load-tracking-support-up-to.patch
new file mode 100644
index 0000000..7d3f07a
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0038-arm64-Wire-cpu-invariant-load-tracking-support-up-to.patch
@@ -0,0 +1,51 @@
+From abdcda318be2337a46f118ffda2d377c95c12408 Mon Sep 17 00:00:00 2001
+From: Juri Lelli <juri.lelli@arm.com>
+Date: Fri, 20 Nov 2015 11:47:48 +0000
+Subject: [PATCH 38/92] arm64: Wire cpu-invariant load-tracking support up to
+ the scheduler
+
+Define arch_scale_cpu_capacity to use the arch-specific function
+scale_cpu_capacity().
+
+Cc: Catalin Marinas <catalin.marinas@arm.com>
+Cc: Will Deacon <will.deacon@arm.com>
+Signed-off-by: Juri Lelli <juri.lelli@arm.com>
+Signed-off-by: Dietmar Eggemann <dietmar.eggemann@arm.com>
+(cherry picked from commit 94ad9dbcfe547eeed8115fab9f114be0d0487bd8)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ arch/arm64/include/asm/topology.h | 4 ++++
+ arch/arm64/kernel/topology.c      | 2 +-
+ 2 files changed, 5 insertions(+), 1 deletion(-)
+
+diff --git a/arch/arm64/include/asm/topology.h b/arch/arm64/include/asm/topology.h
+index 8b57339..5d576eb 100644
+--- a/arch/arm64/include/asm/topology.h
++++ b/arch/arm64/include/asm/topology.h
+@@ -32,6 +32,10 @@ struct cpu_topology {
+ 
+ #endif /* CONFIG_NUMA */
+ 
++struct sched_domain;
++#define arch_scale_cpu_capacity scale_cpu_capacity
++extern unsigned long scale_cpu_capacity(struct sched_domain *sd, int cpu);
++
+ #include <asm-generic/topology.h>
+ 
+ #endif /* _ASM_ARM_TOPOLOGY_H */
+diff --git a/arch/arm64/kernel/topology.c b/arch/arm64/kernel/topology.c
+index cff34cc..91de9dd 100644
+--- a/arch/arm64/kernel/topology.c
++++ b/arch/arm64/kernel/topology.c
+@@ -28,7 +28,7 @@
+ static DEFINE_PER_CPU(unsigned long, cpu_scale) = SCHED_CAPACITY_SCALE;
+ static DEFINE_MUTEX(cpu_scale_mutex);
+ 
+-unsigned long arch_scale_cpu_capacity(struct sched_domain *sd, int cpu)
++unsigned long scale_cpu_capacity(struct sched_domain *sd, int cpu)
+ {
+ 	return per_cpu(cpu_scale, cpu);
+ }
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0039-arm64-Make-cpufreq-policy-notifier-usable-for-freque.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0039-arm64-Make-cpufreq-policy-notifier-usable-for-freque.patch
new file mode 100644
index 0000000..83670ea
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0039-arm64-Make-cpufreq-policy-notifier-usable-for-freque.patch
@@ -0,0 +1,82 @@
+From c352f232654c79fbe6f7ae46ddffc2f7c267519c Mon Sep 17 00:00:00 2001
+From: Dietmar Eggemann <dietmar.eggemann@arm.com>
+Date: Mon, 21 Nov 2016 16:38:09 +0000
+Subject: [PATCH 39/92] arm64: Make cpufreq policy notifier usable for
+ frequency-invariant load-tracking support
+
+The maximum supported frequency of a cpu (policy->cpuinfo.max_freq) has
+to be retrieved for frequency-invariant load-tracking.
+
+This can be achieved by coding this functionality into the existing
+cpufreq policy notifier (init_cpu_capacity_notifier) which is currently
+only used for setting up dt-based cpu capacities (cpu node property
+(capacity-dmips-mhz).
+
+But frequency-invariant load-tracking has to work whether cpu capacity
+dt-parsing succeeded or not.
+
+Change init_cpu_capacity_notifier in such a way that even if the parsing
+of the cpu capacity information failed the notifier is called for each
+cpufreq policy to be able to set the maximum supported frequency.
+
+The continue statement in init_cpu_capacity_callback() makes sure that we
+don't go on calculating cap_scale in case the capacity parsing failed. The
+whole implementation makes only sense as soon the code to set the per-cpu
+variable max_freq is introduced by the following patch
+("arm64: Frequency-invariant load-tracking support").
+
+Cc: Catalin Marinas <catalin.marinas@arm.com>
+Cc: Will Deacon <will.deacon@arm.com>
+Signed-off-by: Dietmar Eggemann <dietmar.eggemann@arm.com>
+(cherry picked from commit c4e6eb1f2e7ada58bd538af2243809416c6538aa)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ arch/arm64/kernel/topology.c | 13 +++++++------
+ 1 file changed, 7 insertions(+), 6 deletions(-)
+
+diff --git a/arch/arm64/kernel/topology.c b/arch/arm64/kernel/topology.c
+index 91de9dd..3d27df1 100644
+--- a/arch/arm64/kernel/topology.c
++++ b/arch/arm64/kernel/topology.c
+@@ -185,7 +185,7 @@ static void normalize_cpu_capacity(void)
+ 	struct cpufreq_policy *policy = data;
+ 	int cpu;
+ 
+-	if (cap_parsing_failed || cap_parsing_done)
++	if (cap_parsing_done)
+ 		return 0;
+ 
+ 	switch (val) {
+@@ -197,13 +197,17 @@ static void normalize_cpu_capacity(void)
+ 			       cpus_to_visit,
+ 			       policy->related_cpus);
+ 		for_each_cpu(cpu, policy->related_cpus) {
++			if (cap_parsing_failed)
++				continue;
+ 			raw_capacity[cpu] = arch_scale_cpu_capacity(NULL, cpu) *
+ 					    policy->cpuinfo.max_freq / 1000UL;
+ 			capacity_scale = max(raw_capacity[cpu], capacity_scale);
+ 		}
+ 		if (cpumask_empty(cpus_to_visit)) {
+-			normalize_cpu_capacity();
+-			kfree(raw_capacity);
++			if (!cap_parsing_failed) {
++				normalize_cpu_capacity();
++				kfree(raw_capacity);
++			}
+ 			pr_debug("cpu_capacity: parsing done\n");
+ 			cap_parsing_done = true;
+ 			schedule_work(&parsing_done_work);
+@@ -218,9 +222,6 @@ static void normalize_cpu_capacity(void)
+ 
+ static int __init register_cpufreq_notifier(void)
+ {
+-	if (cap_parsing_failed)
+-		return -EINVAL;
+-
+ 	if (!alloc_cpumask_var(&cpus_to_visit, GFP_KERNEL)) {
+ 		pr_err("cpu_capacity: failed to allocate memory for cpus_to_visit\n");
+ 		return -ENOMEM;
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0040-arm64-Frequency-invariant-load-tracking-support.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0040-arm64-Frequency-invariant-load-tracking-support.patch
new file mode 100644
index 0000000..7651c1f
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0040-arm64-Frequency-invariant-load-tracking-support.patch
@@ -0,0 +1,136 @@
+From 34e84963e8c1a9a808e1027a268db205da11174f Mon Sep 17 00:00:00 2001
+From: Dietmar Eggemann <dietmar.eggemann@arm.com>
+Date: Wed, 16 Nov 2016 10:43:37 +0000
+Subject: [PATCH 40/92] arm64: Frequency-invariant load-tracking support
+
+Implements arch-specific function scale_freq_capacity() which provides the
+following frequency scaling factor:
+
+  current_freq(cpu) << SCHED_CAPACITY_SHIFT / max_supported_freq(cpu)
+
+The debug output in init_cpu_capacity_callback() has been changed to be
+able to distinguish whether cpu capacity and max frequency or only max
+frequency has been parsed. The latter case happens on systems where there
+is no or broken cpu capacity binding (cpu node property
+capacity-dmips-mhz) information.
+
+One possible consumer of this is the Per-Entity Load Tracking (PELT)
+mechanism of the scheduler's CFS class.
+
+The actual wiring up to the scheduler isn't provided by this patch.
+
+Cc: Catalin Marinas <catalin.marinas@arm.com>
+Cc: Will Deacon <will.deacon@arm.com>
+Signed-off-by: Dietmar Eggemann <dietmar.eggemann@arm.com>
+(cherry picked from commit b13969222bdf073b5220e990e5bb923b458b5c48)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ arch/arm64/kernel/topology.c | 58 +++++++++++++++++++++++++++++++++++++++-----
+ 1 file changed, 52 insertions(+), 6 deletions(-)
+
+diff --git a/arch/arm64/kernel/topology.c b/arch/arm64/kernel/topology.c
+index 3d27df1..280319b 100644
+--- a/arch/arm64/kernel/topology.c
++++ b/arch/arm64/kernel/topology.c
+@@ -176,6 +176,8 @@ static void normalize_cpu_capacity(void)
+ static bool cap_parsing_done;
+ static void parsing_done_workfn(struct work_struct *work);
+ static DECLARE_WORK(parsing_done_work, parsing_done_workfn);
++static DEFINE_PER_CPU(unsigned long, freq_scale) = SCHED_CAPACITY_SCALE;
++static DEFINE_PER_CPU(unsigned long, max_freq);
+ 
+ static int
+ init_cpu_capacity_callback(struct notifier_block *nb,
+@@ -190,13 +192,14 @@ static void normalize_cpu_capacity(void)
+ 
+ 	switch (val) {
+ 	case CPUFREQ_NOTIFY:
+-		pr_debug("cpu_capacity: init cpu capacity for CPUs [%*pbl] (to_visit=%*pbl)\n",
+-				cpumask_pr_args(policy->related_cpus),
+-				cpumask_pr_args(cpus_to_visit));
++		pr_debug("cpu_capacity: calling %s for CPUs [%*pbl] (to_visit=[%*pbl])\n",
++			 __func__, cpumask_pr_args(policy->related_cpus),
++			 cpumask_pr_args(cpus_to_visit));
+ 		cpumask_andnot(cpus_to_visit,
+ 			       cpus_to_visit,
+ 			       policy->related_cpus);
+ 		for_each_cpu(cpu, policy->related_cpus) {
++			per_cpu(max_freq, cpu) = policy->cpuinfo.max_freq;
+ 			if (cap_parsing_failed)
+ 				continue;
+ 			raw_capacity[cpu] = arch_scale_cpu_capacity(NULL, cpu) *
+@@ -207,8 +210,10 @@ static void normalize_cpu_capacity(void)
+ 			if (!cap_parsing_failed) {
+ 				normalize_cpu_capacity();
+ 				kfree(raw_capacity);
++				pr_debug("cpu_capacity: parsing done\n");
++			} else {
++				pr_debug("cpu_capacity: max frequency parsing done\n");
+ 			}
+-			pr_debug("cpu_capacity: parsing done\n");
+ 			cap_parsing_done = true;
+ 			schedule_work(&parsing_done_work);
+ 		}
+@@ -220,16 +225,57 @@ static void normalize_cpu_capacity(void)
+ 	.notifier_call = init_cpu_capacity_callback,
+ };
+ 
++unsigned long scale_freq_capacity(struct sched_domain *sd, int cpu)
++{
++	return per_cpu(freq_scale, cpu);
++}
++
++static void set_freq_scale(unsigned int cpu, unsigned long freq)
++{
++	unsigned long max = per_cpu(max_freq, cpu);
++
++	if (!max)
++		return;
++
++	per_cpu(freq_scale, cpu) = (freq << SCHED_CAPACITY_SHIFT) / max;
++}
++
++static int
++set_freq_scale_callback(struct notifier_block *nb,
++			unsigned long val,
++			void *data)
++{
++	struct cpufreq_freqs *freq = data;
++
++	switch (val) {
++	case CPUFREQ_PRECHANGE:
++		set_freq_scale(freq->cpu, freq->new);
++	}
++	return 0;
++}
++
++static struct notifier_block set_freq_scale_notifier = {
++	.notifier_call = set_freq_scale_callback,
++};
++
+ static int __init register_cpufreq_notifier(void)
+ {
++	int ret;
++
+ 	if (!alloc_cpumask_var(&cpus_to_visit, GFP_KERNEL)) {
+ 		pr_err("cpu_capacity: failed to allocate memory for cpus_to_visit\n");
+ 		return -ENOMEM;
+ 	}
+ 	cpumask_copy(cpus_to_visit, cpu_possible_mask);
+ 
+-	return cpufreq_register_notifier(&init_cpu_capacity_notifier,
+-					 CPUFREQ_POLICY_NOTIFIER);
++	ret = cpufreq_register_notifier(&init_cpu_capacity_notifier,
++					CPUFREQ_POLICY_NOTIFIER);
++
++	if (ret)
++		return ret;
++
++	return cpufreq_register_notifier(&set_freq_scale_notifier,
++					 CPUFREQ_TRANSITION_NOTIFIER);
+ }
+ core_initcall(register_cpufreq_notifier);
+ 
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0041-arm64-Wire-frequency-invariant-load-tracking-support.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0041-arm64-Wire-frequency-invariant-load-tracking-support.patch
new file mode 100644
index 0000000..ef066fd
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0041-arm64-Wire-frequency-invariant-load-tracking-support.patch
@@ -0,0 +1,39 @@
+From 527149044bd9ad829a841ad770dbad688d01f2cc Mon Sep 17 00:00:00 2001
+From: Dietmar Eggemann <dietmar.eggemann@arm.com>
+Date: Fri, 25 Sep 2015 17:15:11 +0100
+Subject: [PATCH 41/92] arm64: Wire frequency-invariant load-tracking support
+ up to the scheduler
+
+Define arch_scale_freq_capacity to use the arch-specific function
+scale_freq_capacity().
+
+Cc: Catalin Marinas <catalin.marinas@arm.com>
+Cc: Will Deacon <will.deacon@arm.com>
+Signed-off-by: Dietmar Eggemann <dietmar.eggemann@arm.com>
+(cherry picked from commit 3cf6bce5357e08c7876df57c923aa27bf864c00a)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ arch/arm64/include/asm/topology.h | 7 +++++++
+ 1 file changed, 7 insertions(+)
+
+diff --git a/arch/arm64/include/asm/topology.h b/arch/arm64/include/asm/topology.h
+index 5d576eb..0f2c4dc 100644
+--- a/arch/arm64/include/asm/topology.h
++++ b/arch/arm64/include/asm/topology.h
+@@ -36,6 +36,13 @@ struct cpu_topology {
+ #define arch_scale_cpu_capacity scale_cpu_capacity
+ extern unsigned long scale_cpu_capacity(struct sched_domain *sd, int cpu);
+ 
++#ifdef CONFIG_CPU_FREQ
++
++#define arch_scale_freq_capacity scale_freq_capacity
++extern unsigned long scale_freq_capacity(struct sched_domain *sd, int cpu);
++
++#endif /* CONFIG_CPU_FREQ */
++
+ #include <asm-generic/topology.h>
+ 
+ #endif /* _ASM_ARM_TOPOLOGY_H */
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0042-arm-Set-SD_ASYM_CPUCAPACITY-for-big.LITTLE-platforms.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0042-arm-Set-SD_ASYM_CPUCAPACITY-for-big.LITTLE-platforms.patch
new file mode 100644
index 0000000..9225712
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0042-arm-Set-SD_ASYM_CPUCAPACITY-for-big.LITTLE-platforms.patch
@@ -0,0 +1,80 @@
+From 68c09523de80d3510269aa418c5c3814c4aae56b Mon Sep 17 00:00:00 2001
+From: Morten Rasmussen <morten.rasmussen@arm.com>
+Date: Fri, 17 Jun 2016 15:03:34 +0100
+Subject: [PATCH 42/92] arm: Set SD_ASYM_CPUCAPACITY for big.LITTLE platforms
+
+Set the SD_ASYM_CPUCAPACITY flag for DIE level sched_domains
+on big.LITTLE systems.
+
+cc: Russell King <linux@arm.linux.org.uk>
+
+Signed-off-by: Morten Rasmussen <morten.rasmussen@arm.com>
+(cherry picked from commit 2954ca1a61107ff029d1668dadae88c5e43035e5)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ arch/arm/kernel/topology.c | 16 +++++++++++++++-
+ 1 file changed, 15 insertions(+), 1 deletion(-)
+
+diff --git a/arch/arm/kernel/topology.c b/arch/arm/kernel/topology.c
+index e521b07..69fb4b6 100644
+--- a/arch/arm/kernel/topology.c
++++ b/arch/arm/kernel/topology.c
+@@ -154,6 +154,7 @@ struct cpu_efficiency {
+ static u32 *raw_capacity;
+ static bool cap_parsing_failed;
+ static u32 capacity_scale;
++static bool asym_cpucap;
+ 
+ static int __init parse_cpu_capacity(struct device_node *cpu_node, int cpu)
+ {
+@@ -210,6 +211,8 @@ static void normalize_cpu_capacity(void)
+ 		set_capacity_scale(cpu, capacity);
+ 		pr_debug("cpu_capacity: CPU%d cpu_capacity=%lu\n",
+ 			cpu, arch_scale_cpu_capacity(NULL, cpu));
++		if (capacity < capacity_scale)
++			asym_cpucap = true;
+ 	}
+ 	mutex_unlock(&cpu_scale_mutex);
+ }
+@@ -422,6 +425,9 @@ static void __init parse_dt_topology(void)
+ 		middle_capacity = ((max_capacity / 3)
+ 				>> (SCHED_CAPACITY_SHIFT-1)) + 1;
+ 
++	if (max_capacity && max_capacity != min_capacity)
++		asym_cpucap = true;
++
+ 	if (cap_from_dt && !cap_parsing_failed)
+ 		normalize_cpu_capacity();
+ }
+@@ -438,6 +444,9 @@ static void update_cpu_capacity(unsigned int cpu)
+ 
+ 	set_capacity_scale(cpu, cpu_capacity(cpu) / middle_capacity);
+ 
++	if (scale_cpu_capacity(NULL, cpu) < SCHED_CAPACITY_SCALE)
++		asym_cpucap = true;
++
+ 	pr_info("CPU%u: update cpu_capacity %lu\n",
+ 		cpu, arch_scale_cpu_capacity(NULL, cpu));
+ }
+@@ -553,12 +562,17 @@ static inline int cpu_corepower_flags(void)
+ 	return SD_SHARE_PKG_RESOURCES  | SD_SHARE_POWERDOMAIN;
+ }
+ 
++static inline int arm_cpu_cpu_flags(void)
++{
++	return asym_cpucap ? SD_ASYM_CPUCAPACITY : 0;
++}
++
+ static struct sched_domain_topology_level arm_topology[] = {
+ #ifdef CONFIG_SCHED_MC
+ 	{ cpu_corepower_mask, cpu_corepower_flags, SD_INIT_NAME(GMC) },
+ 	{ cpu_coregroup_mask, cpu_core_flags, SD_INIT_NAME(MC) },
+ #endif
+-	{ cpu_cpu_mask, SD_INIT_NAME(DIE) },
++	{ cpu_cpu_mask, arm_cpu_cpu_flags, SD_INIT_NAME(DIE) },
+ 	{ NULL, },
+ };
+ 
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0043-arm-Update-SD_ASYM_CPUCAPACITY-topology-flag-when-cp.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0043-arm-Update-SD_ASYM_CPUCAPACITY-topology-flag-when-cp.patch
new file mode 100644
index 0000000..6781716
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0043-arm-Update-SD_ASYM_CPUCAPACITY-topology-flag-when-cp.patch
@@ -0,0 +1,151 @@
+From 82ae3c283c44fb74536b33dfeb3f23e228af869f Mon Sep 17 00:00:00 2001
+From: Morten Rasmussen <morten.rasmussen@arm.com>
+Date: Wed, 22 Jun 2016 10:58:17 +0100
+Subject: [PATCH 43/92] arm: Update SD_ASYM_CPUCAPACITY topology flag when cpu
+ capacity is changed
+
+When cpu capacity information is provided through DT or sysfs we might
+not know if the system has asymmetric cpu capacities when the system
+topology information is initially passed to the scheduler. We therefore
+have to enforce a rebuild of the sched_domain hierarchy if we later
+discover that the flag was initially set wrong.
+
+It is mainly an issue for systems with same type of cores (dmips/mhz)
+but different max frequencies, and asymmetric cpu capacity systems where
+cpu capacity is not provided by DT but set through sysfs later.
+
+cc: Russell King <linux@armlinux.org.uk>
+
+Signed-off-by: Morten Rasmussen <morten.rasmussen@arm.com>
+(cherry picked from commit d02bb26e525bcbeb3c91345c4ee2a1fe1ca11e48)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ arch/arm/kernel/topology.c | 39 +++++++++++++++++++++++++++++++++++++--
+ 1 file changed, 37 insertions(+), 2 deletions(-)
+
+diff --git a/arch/arm/kernel/topology.c b/arch/arm/kernel/topology.c
+index 69fb4b6..4d94639 100644
+--- a/arch/arm/kernel/topology.c
++++ b/arch/arm/kernel/topology.c
+@@ -22,6 +22,7 @@
+ #include <linux/sched.h>
+ #include <linux/slab.h>
+ #include <linux/cpufreq.h>
++#include <linux/cpuset.h>
+ 
+ #include <asm/cputype.h>
+ #include <asm/topology.h>
+@@ -43,6 +44,8 @@
+  */
+ static DEFINE_PER_CPU(unsigned long, cpu_scale) = SCHED_CAPACITY_SCALE;
+ static DEFINE_MUTEX(cpu_scale_mutex);
++static bool asym_cpucap;
++static bool update_flags;
+ 
+ unsigned long scale_cpu_capacity(struct sched_domain *sd, int cpu)
+ {
+@@ -54,6 +57,14 @@ static void set_capacity_scale(unsigned int cpu, unsigned long capacity)
+ 	per_cpu(cpu_scale, cpu) = capacity;
+ }
+ 
++static void update_sched_flags(void)
++{
++	update_flags = true;
++	rebuild_sched_domains();
++	update_flags = false;
++	pr_debug("cpu_capacity: Rebuilt sched_domain hierarchy.\n");
++}
++
+ #ifdef CONFIG_PROC_SYSCTL
+ #include <asm/cpu.h>
+ #include <linux/string.h>
+@@ -83,6 +94,7 @@ static ssize_t store_cpu_capacity(struct device *dev,
+ 
+ 	if (count) {
+ 		char *p = (char *) buf;
++		bool asym = false;
+ 
+ 		ret = kstrtoul(p, 0, &new_capacity);
+ 		if (ret)
+@@ -93,6 +105,17 @@ static ssize_t store_cpu_capacity(struct device *dev,
+ 		mutex_lock(&cpu_scale_mutex);
+ 		for_each_cpu(i, &cpu_topology[this_cpu].core_sibling)
+ 			set_capacity_scale(i, new_capacity);
++
++		for_each_possible_cpu(i) {
++			if (per_cpu(cpu_scale, i) != new_capacity)
++				asym = true;
++		}
++
++		if (asym != asym_cpucap) {
++			asym_cpucap = asym;
++			update_sched_flags();
++		}
++
+ 		mutex_unlock(&cpu_scale_mutex);
+ 	}
+ 
+@@ -154,7 +177,6 @@ struct cpu_efficiency {
+ static u32 *raw_capacity;
+ static bool cap_parsing_failed;
+ static u32 capacity_scale;
+-static bool asym_cpucap;
+ 
+ static int __init parse_cpu_capacity(struct device_node *cpu_node, int cpu)
+ {
+@@ -199,6 +221,7 @@ static void normalize_cpu_capacity(void)
+ {
+ 	u64 capacity;
+ 	int cpu;
++	bool asym = false;
+ 
+ 	if (!raw_capacity || cap_parsing_failed)
+ 		return;
+@@ -212,9 +235,12 @@ static void normalize_cpu_capacity(void)
+ 		pr_debug("cpu_capacity: CPU%d cpu_capacity=%lu\n",
+ 			cpu, arch_scale_cpu_capacity(NULL, cpu));
+ 		if (capacity < capacity_scale)
+-			asym_cpucap = true;
++			asym = true;
+ 	}
+ 	mutex_unlock(&cpu_scale_mutex);
++
++	if (asym != asym_cpucap)
++		asym_cpucap = asym;
+ }
+ 
+ #ifdef CONFIG_CPU_FREQ
+@@ -232,6 +258,7 @@ static void normalize_cpu_capacity(void)
+ {
+ 	struct cpufreq_policy *policy = data;
+ 	int cpu;
++	bool asym;
+ 
+ 	if (cap_parsing_done)
+ 		return 0;
+@@ -254,7 +281,10 @@ static void normalize_cpu_capacity(void)
+ 		}
+ 		if (cpumask_empty(cpus_to_visit)) {
+ 			if (!cap_parsing_failed) {
++				asym = asym_cpucap;
+ 				normalize_cpu_capacity();
++				if (asym != asym_cpucap)
++					update_sched_flags();
+ 				kfree(raw_capacity);
+ 				pr_debug("cpu_capacity: parsing done");
+ 			} else {
+@@ -502,6 +532,11 @@ static void update_siblings_masks(unsigned int cpuid)
+ 	smp_wmb();
+ }
+ 
++int arch_update_cpu_topology(void)
++{
++	return update_flags ? 1 : 0;
++}
++
+ /*
+  * store_cpu_topology is called at boot when only one cpu is running
+  * and with the mutex cpu_hotplug.lock locked, when several cpus have booted,
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0044-arm64-Set-SD_ASYM_CPUCAPACITY-topology-flag-for-asym.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0044-arm64-Set-SD_ASYM_CPUCAPACITY-topology-flag-for-asym.patch
new file mode 100644
index 0000000..819a5cf
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0044-arm64-Set-SD_ASYM_CPUCAPACITY-topology-flag-for-asym.patch
@@ -0,0 +1,165 @@
+From bacbde41338ca493a4557fb33faf4ea4ab788bb5 Mon Sep 17 00:00:00 2001
+From: Morten Rasmussen <morten.rasmussen@arm.com>
+Date: Wed, 22 Jun 2016 14:51:17 +0100
+Subject: [PATCH 44/92] arm64: Set SD_ASYM_CPUCAPACITY topology flag for
+ asymmetric cpu capacity systems
+
+In addition to adjusting the cpu capacities asymmetric cpu capacity
+systems also have to set the SD_ASYM_CPUCAPACITY topology flag to inform
+the scheduler to look harder when load balancing. This patch sets the
+topology flag on DIE level for such systems based on the cpu capacities
+provided through DT or sysfs.
+
+cc: Catalin Marinas <catalin.marinas@arm.com>
+cc: Will Deacon <will.deacon@arm.com>
+
+Signed-off-by: Morten Rasmussen <morten.rasmussen@arm.com>
+(cherry picked from commit 8a8992543ec08e26f8a8ab3cdb4bb556283ce9ea)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ arch/arm64/kernel/topology.c | 52 ++++++++++++++++++++++++++++++++++++++++++++
+ 1 file changed, 52 insertions(+)
+
+diff --git a/arch/arm64/kernel/topology.c b/arch/arm64/kernel/topology.c
+index 280319b..eb2ad75 100644
+--- a/arch/arm64/kernel/topology.c
++++ b/arch/arm64/kernel/topology.c
+@@ -21,12 +21,15 @@
+ #include <linux/sched.h>
+ #include <linux/slab.h>
+ #include <linux/cpufreq.h>
++#include <linux/cpuset.h>
+ 
+ #include <asm/cputype.h>
+ #include <asm/topology.h>
+ 
+ static DEFINE_PER_CPU(unsigned long, cpu_scale) = SCHED_CAPACITY_SCALE;
+ static DEFINE_MUTEX(cpu_scale_mutex);
++static bool asym_cpucap;
++static bool update_flags;
+ 
+ unsigned long scale_cpu_capacity(struct sched_domain *sd, int cpu)
+ {
+@@ -38,6 +41,14 @@ static void set_capacity_scale(unsigned int cpu, unsigned long capacity)
+ 	per_cpu(cpu_scale, cpu) = capacity;
+ }
+ 
++static void update_sched_flags(void)
++{
++	update_flags = true;
++	rebuild_sched_domains();
++	update_flags = false;
++	pr_debug("cpu_capacity: Rebuilt sched_domain hierarchy.\n");
++}
++
+ #ifdef CONFIG_PROC_SYSCTL
+ #include <asm/cpu.h>
+ #include <linux/string.h>
+@@ -67,6 +78,7 @@ static ssize_t store_cpu_capacity(struct device *dev,
+ 
+ 	if (count) {
+ 		char *p = (char *) buf;
++		bool asym = false;
+ 
+ 		ret = kstrtoul(p, 0, &new_capacity);
+ 		if (ret)
+@@ -77,6 +89,16 @@ static ssize_t store_cpu_capacity(struct device *dev,
+ 		mutex_lock(&cpu_scale_mutex);
+ 		for_each_cpu(i, &cpu_topology[this_cpu].core_sibling)
+ 			set_capacity_scale(i, new_capacity);
++
++		for_each_possible_cpu(i) {
++			if (per_cpu(cpu_scale, i) != new_capacity)
++				asym = true;
++		}
++
++		if (asym != asym_cpucap) {
++			asym_cpucap = asym;
++			update_sched_flags();
++		}
+ 		mutex_unlock(&cpu_scale_mutex);
+ 	}
+ 
+@@ -153,6 +175,7 @@ static void normalize_cpu_capacity(void)
+ {
+ 	u64 capacity;
+ 	int cpu;
++	bool asym = false;
+ 
+ 	if (!raw_capacity || cap_parsing_failed)
+ 		return;
+@@ -167,8 +190,13 @@ static void normalize_cpu_capacity(void)
+ 		set_capacity_scale(cpu, capacity);
+ 		pr_debug("cpu_capacity: CPU%d cpu_capacity=%lu\n",
+ 			cpu, arch_scale_cpu_capacity(NULL, cpu));
++		if (capacity < capacity_scale)
++			asym = true;
+ 	}
+ 	mutex_unlock(&cpu_scale_mutex);
++
++	if (asym != asym_cpucap)
++		asym_cpucap = asym;
+ }
+ 
+ #ifdef CONFIG_CPU_FREQ
+@@ -186,6 +214,7 @@ static void normalize_cpu_capacity(void)
+ {
+ 	struct cpufreq_policy *policy = data;
+ 	int cpu;
++	bool asym;
+ 
+ 	if (cap_parsing_done)
+ 		return 0;
+@@ -208,7 +237,10 @@ static void normalize_cpu_capacity(void)
+ 		}
+ 		if (cpumask_empty(cpus_to_visit)) {
+ 			if (!cap_parsing_failed) {
++				asym = asym_cpucap;
+ 				normalize_cpu_capacity();
++				if (asym != asym_cpucap)
++					update_sched_flags();
+ 				kfree(raw_capacity);
+ 				pr_debug("cpu_capacity: parsing done\n");
+ 			} else {
+@@ -488,6 +520,11 @@ const struct cpumask *cpu_coregroup_mask(int cpu)
+ 	return &cpu_topology[cpu].core_sibling;
+ }
+ 
++static int cpu_cpu_flags(void)
++{
++	return asym_cpucap ? SD_ASYM_CPUCAPACITY : 0;
++}
++
+ static void update_siblings_masks(unsigned int cpuid)
+ {
+ 	struct cpu_topology *cpu_topo, *cpuid_topo = &cpu_topology[cpuid];
+@@ -569,6 +606,19 @@ static void __init reset_cpu_topology(void)
+ 	}
+ }
+ 
++static struct sched_domain_topology_level arm64_topology[] = {
++#ifdef CONFIG_SCHED_MC
++	{ cpu_coregroup_mask, cpu_core_flags, SD_INIT_NAME(MC) },
++#endif
++	{ cpu_cpu_mask, cpu_cpu_flags, SD_INIT_NAME(DIE) },
++	{ NULL, }
++};
++
++int arch_update_cpu_topology(void)
++{
++	return update_flags ? 1 : 0;
++}
++
+ void __init init_cpu_topology(void)
+ {
+ 	reset_cpu_topology();
+@@ -579,4 +629,6 @@ void __init init_cpu_topology(void)
+ 	 */
+ 	if (of_have_populated_dt() && parse_dt_topology())
+ 		reset_cpu_topology();
++	else
++		set_sched_topology(arm64_topology);
+ }
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0045-sched-Documentation-for-scheduler-energy-cost-model.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0045-sched-Documentation-for-scheduler-energy-cost-model.patch
new file mode 100644
index 0000000..273f0e8
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0045-sched-Documentation-for-scheduler-energy-cost-model.patch
@@ -0,0 +1,389 @@
+From ffa86114448cb4f15e3774072964960c5c4d6b5e Mon Sep 17 00:00:00 2001
+From: Morten Rasmussen <morten.rasmussen@arm.com>
+Date: Tue, 13 Jan 2015 13:43:28 +0000
+Subject: [PATCH 45/92] sched: Documentation for scheduler energy cost model
+
+This documentation patch provides an overview of the experimental
+scheduler energy costing model, associated data structures, and a
+reference recipe on how platforms can be characterized to derive energy
+models.
+
+Signed-off-by: Morten Rasmussen <morten.rasmussen@arm.com>
+(cherry picked from commit 8de9277814e36b07759c65bce220c82584f80aa3)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ Documentation/scheduler/sched-energy.txt | 362 +++++++++++++++++++++++++++++++
+ 1 file changed, 362 insertions(+)
+ create mode 100644 Documentation/scheduler/sched-energy.txt
+
+diff --git a/Documentation/scheduler/sched-energy.txt b/Documentation/scheduler/sched-energy.txt
+new file mode 100644
+index 0000000..dab2f90
+--- /dev/null
++++ b/Documentation/scheduler/sched-energy.txt
+@@ -0,0 +1,362 @@
++Energy cost model for energy-aware scheduling (EXPERIMENTAL)
++
++Introduction
++=============
++
++The basic energy model uses platform energy data stored in sched_group_energy
++data structures attached to the sched_groups in the sched_domain hierarchy. The
++energy cost model offers two functions that can be used to guide scheduling
++decisions:
++
++1.	static unsigned int sched_group_energy(struct energy_env *eenv)
++2.	static int energy_diff(struct energy_env *eenv)
++
++sched_group_energy() estimates the energy consumed by all cpus in a specific
++sched_group including any shared resources owned exclusively by this group of
++cpus. Resources shared with other cpus are excluded (e.g. later level caches).
++
++energy_diff() estimates the total energy impact of a utilization change. That
++is, adding, removing, or migrating utilization (tasks).
++
++Both functions use a struct energy_env to specify the scenario to be evaluated:
++
++	struct energy_env {
++		struct sched_group      *sg_top;
++		struct sched_group      *sg_cap;
++		int                     cap_idx;
++		int                     util_delta;
++		int                     src_cpu;
++		int                     dst_cpu;
++		int                     energy;
++	};
++
++sg_top: sched_group to be evaluated. Not used by energy_diff().
++
++sg_cap: sched_group covering the cpus in the same frequency domain. Set by
++sched_group_energy().
++
++cap_idx: Capacity state to be used for energy calculations. Set by
++find_new_capacity().
++
++util_delta: Amount of utilization to be added, removed, or migrated.
++
++src_cpu: Source cpu from where 'util_delta' utilization is removed. Should be
++-1 if no source (e.g. task wake-up).
++
++dst_cpu: Destination cpu where 'util_delta' utilization is added. Should be -1
++if utilization is removed (e.g. terminating tasks).
++
++energy: Result of sched_group_energy().
++
++The metric used to represent utilization is the actual per-entity running time
++averaged over time using a geometric series. Very similar to the existing
++per-entity load-tracking, but _not_ scaled by task priority and capped by the
++capacity of the cpu. The latter property does mean that utilization may
++underestimate the compute requirements for task on fully/over utilized cpus.
++The greatest potential for energy savings without affecting performance too much
++is scenarios where the system isn't fully utilized. If the system is deemed
++fully utilized load-balancing should be done with task load (includes task
++priority) instead in the interest of fairness and performance.
++
++
++Background and Terminology
++===========================
++
++To make it clear from the start:
++
++energy = [joule] (resource like a battery on powered devices)
++power = energy/time = [joule/second] = [watt]
++
++The goal of energy-aware scheduling is to minimize energy, while still getting
++the job done. That is, we want to maximize:
++
++	performance [inst/s]
++	--------------------
++	    power [W]
++
++which is equivalent to minimizing:
++
++	energy [J]
++	-----------
++	instruction
++
++while still getting 'good' performance. It is essentially an alternative
++optimization objective to the current performance-only objective for the
++scheduler. This alternative considers two objectives: energy-efficiency and
++performance. Hence, there needs to be a user controllable knob to switch the
++objective. Since it is early days, this is currently a sched_feature
++(ENERGY_AWARE).
++
++The idea behind introducing an energy cost model is to allow the scheduler to
++evaluate the implications of its decisions rather than applying energy-saving
++techniques blindly that may only have positive effects on some platforms. At
++the same time, the energy cost model must be as simple as possible to minimize
++the scheduler latency impact.
++
++Platform topology
++------------------
++
++The system topology (cpus, caches, and NUMA information, not peripherals) is
++represented in the scheduler by the sched_domain hierarchy which has
++sched_groups attached at each level that covers one or more cpus (see
++sched-domains.txt for more details). To add energy awareness to the scheduler
++we need to consider power and frequency domains.
++
++Power domain:
++
++A power domain is a part of the system that can be powered on/off
++independently. Power domains are typically organized in a hierarchy where you
++may be able to power down just a cpu or a group of cpus along with any
++associated resources (e.g.  shared caches). Powering up a cpu means that all
++power domains it is a part of in the hierarchy must be powered up. Hence, it is
++more expensive to power up the first cpu that belongs to a higher level power
++domain than powering up additional cpus in the same high level domain. Two
++level power domain hierarchy example:
++
++		Power source
++		         +-------------------------------+----...
++per group PD		 G                               G
++		         |           +----------+        |
++		    +--------+-------| Shared   |  (other groups)
++per-cpu PD	    G        G       | resource |
++		    |        |       +----------+
++		+-------+ +-------+
++		| CPU 0 | | CPU 1 |
++		+-------+ +-------+
++
++Frequency domain:
++
++Frequency domains (P-states) typically cover the same group of cpus as one of
++the power domain levels. That is, there might be several smaller power domains
++sharing the same frequency (P-state) or there might be a power domain spanning
++multiple frequency domains.
++
++From a scheduling point of view there is no need to know the actual frequencies
++[Hz]. All the scheduler cares about is the compute capacity available at the
++current state (P-state) the cpu is in and any other available states. For that
++reason, and to also factor in any cpu micro-architecture differences, compute
++capacity scaling states are called 'capacity states' in this document. For SMP
++systems this is equivalent to P-states. For mixed micro-architecture systems
++(like ARM big.LITTLE) it is P-states scaled according to the micro-architecture
++performance relative to the other cpus in the system.
++
++Energy modelling:
++------------------
++
++Due to the hierarchical nature of the power domains, the most obvious way to
++model energy costs is therefore to associate power and energy costs with
++domains (groups of cpus). Energy costs of shared resources are associated with
++the group of cpus that share the resources, only the cost of powering the
++cpu itself and any private resources (e.g. private L1 caches) is associated
++with the per-cpu groups (lowest level).
++
++For example, for an SMP system with per-cpu power domains and a cluster level
++(group of cpus) power domain we get the overall energy costs to be:
++
++	energy = energy_cluster + n * energy_cpu
++
++where 'n' is the number of cpus powered up and energy_cluster is the cost paid
++as soon as any cpu in the cluster is powered up.
++
++The power and frequency domains can naturally be mapped onto the existing
++sched_domain hierarchy and sched_groups by adding the necessary data to the
++existing data structures.
++
++The energy model considers energy consumption from two contributors (shown in
++the illustration below):
++
++1. Busy energy: Energy consumed while a cpu and the higher level groups that it
++belongs to are busy running tasks. Busy energy is associated with the state of
++the cpu, not an event. The time the cpu spends in this state varies. Thus, the
++most obvious platform parameter for this contribution is busy power
++(energy/time).
++
++2. Idle energy: Energy consumed while a cpu and higher level groups that it
++belongs to are idle (in a C-state). Like busy energy, idle energy is associated
++with the state of the cpu. Thus, the platform parameter for this contribution
++is idle power (energy/time).
++
++Energy consumed during transitions from an idle-state (C-state) to a busy state
++(P-state) or going the other way is ignored by the model to simplify the energy
++model calculations.
++
++
++	Power
++	^
++	|            busy->idle             idle->busy
++	|            transition             transition
++	|
++	|                _                      __
++	|               / \                    /  \__________________
++	|______________/   \                  /
++	|                   \                /
++	|  Busy              \    Idle      /        Busy
++	|  low P-state        \____________/         high P-state
++	|
++	+------------------------------------------------------------> time
++
++Busy    |--------------|                          |-----------------|
++
++Wakeup                 |------|            |------|
++
++Idle                          |------------|
++
++
++The basic algorithm
++====================
++
++The basic idea is to determine the total energy impact when utilization is
++added or removed by estimating the impact at each level in the sched_domain
++hierarchy starting from the bottom (sched_group contains just a single cpu).
++The energy cost comes from busy time (sched_group is awake because one or more
++cpus are busy) and idle time (in an idle-state). Energy model numbers account
++for energy costs associated with all cpus in the sched_group as a group.
++
++	for_each_domain(cpu, sd) {
++		sg = sched_group_of(cpu)
++		energy_before = curr_util(sg) * busy_power(sg)
++				+ (1-curr_util(sg)) * idle_power(sg)
++		energy_after = new_util(sg) * busy_power(sg)
++				+ (1-new_util(sg)) * idle_power(sg)
++		energy_diff += energy_before - energy_after
++
++	}
++
++	return energy_diff
++
++{curr, new}_util: The cpu utilization at the lowest level and the overall
++non-idle time for the entire group for higher levels. Utilization is in the
++range 0.0 to 1.0 in the pseudo-code.
++
++busy_power: The power consumption of the sched_group.
++
++idle_power: The power consumption of the sched_group when idle.
++
++Note: It is a fundamental assumption that the utilization is (roughly) scale
++invariant. Task utilization tracking factors in any frequency scaling and
++performance scaling differences due to difference cpu microarchitectures such
++that task utilization can be used across the entire system.
++
++
++Platform energy data
++=====================
++
++struct sched_group_energy can be attached to sched_groups in the sched_domain
++hierarchy and has the following members:
++
++cap_states:
++	List of struct capacity_state representing the supported capacity states
++	(P-states). struct capacity_state has two members: cap and power, which
++	represents the compute capacity and the busy_power of the state. The
++	list must be ordered by capacity low->high.
++
++nr_cap_states:
++	Number of capacity states in cap_states list.
++
++idle_states:
++	List of struct idle_state containing idle_state power cost for each
++	idle-state supported by the system orderd by shallowest state first.
++	All states must be included at all level in the hierarchy, i.e. a
++	sched_group spanning just a single cpu must also include coupled
++	idle-states (cluster states). In addition to the cpuidle idle-states,
++	the list must also contain an entry for the idling using the arch
++	default idle (arch_idle_cpu()). Despite this state may not be a true
++	hardware idle-state it is considered the shallowest idle-state in the
++	energy model and must be the first entry. cpus may enter this state
++	(possibly 'active idling') if cpuidle decides not enter a cpuidle
++	idle-state. Default idle may not be used when cpuidle is enabled.
++	In this case, it should just be a copy of the first cpuidle idle-state.
++
++nr_idle_states:
++	Number of idle states in idle_states list.
++
++There are no unit requirements for the energy cost data. Data can be normalized
++with any reference, however, the normalization must be consistent across all
++energy cost data. That is, one bogo-joule/watt must be the same quantity for
++data, but we don't care what it is.
++
++A recipe for platform characterization
++=======================================
++
++Obtaining the actual model data for a particular platform requires some way of
++measuring power/energy. There isn't a tool to help with this (yet). This
++section provides a recipe for use as reference. It covers the steps used to
++characterize the ARM TC2 development platform. This sort of measurements is
++expected to be done anyway when tuning cpuidle and cpufreq for a given
++platform.
++
++The energy model needs two types of data (struct sched_group_energy holds
++these) for each sched_group where energy costs should be taken into account:
++
++1. Capacity state information
++
++A list containing the compute capacity and power consumption when fully
++utilized attributed to the group as a whole for each available capacity state.
++At the lowest level (group contains just a single cpu) this is the power of the
++cpu alone without including power consumed by resources shared with other cpus.
++It basically needs to fit the basic modelling approach described in "Background
++and Terminology" section:
++
++	energy_system = energy_shared + n * energy_cpu
++
++for a system containing 'n' busy cpus. Only 'energy_cpu' should be included at
++the lowest level. 'energy_shared' is included at the next level which
++represents the group of cpus among which the resources are shared.
++
++This model is, of course, a simplification of reality. Thus, power/energy
++attributions might not always exactly represent how the hardware is designed.
++Also, busy power is likely to depend on the workload. It is therefore
++recommended to use a representative mix of workloads when characterizing the
++capacity states.
++
++If the group has no capacity scaling support, the list will contain a single
++state where power is the busy power attributed to the group. The capacity
++should be set to a default value (1024).
++
++When frequency domains include multiple power domains, the group representing
++the frequency domain and all child groups share capacity states. This must be
++indicated by setting the SD_SHARE_CAP_STATES sched_domain flag. All groups at
++all levels that share the capacity state must have the list of capacity states
++with the power set to the contribution of the individual group.
++
++2. Idle power information
++
++Stored in the idle_states list. The power number is the group idle power
++consumption in each idle state as well when the group is idle but has not
++entered an idle-state ('active idle' as mentioned earlier). Due to the way the
++energy model is defined, the idle power of the deepest group idle state can
++alternatively be accounted for in the parent group busy power. In that case the
++group idle state power values are offset such that the idle power of the
++deepest state is zero. It is less intuitive, but it is easier to measure as
++idle power consumed by the group and the busy/idle power of the parent group
++cannot be distinguished without per group measurement points.
++
++Measuring capacity states and idle power:
++
++The capacity states' capacity and power can be estimated by running a benchmark
++workload at each available capacity state. By restricting the benchmark to run
++on subsets of cpus it is possible to extrapolate the power consumption of
++shared resources.
++
++ARM TC2 has two clusters of two and three cpus respectively. Each cluster has a
++shared L2 cache. TC2 has on-chip energy counters per cluster. Running a
++benchmark workload on just one cpu in a cluster means that power is consumed in
++the cluster (higher level group) and a single cpu (lowest level group). Adding
++another benchmark task to another cpu increases the power consumption by the
++amount consumed by the additional cpu. Hence, it is possible to extrapolate the
++cluster busy power.
++
++For platforms that don't have energy counters or equivalent instrumentation
++built-in, it may be possible to use an external DAQ to acquire similar data.
++
++If the benchmark includes some performance score (for example sysbench cpu
++benchmark), this can be used to record the compute capacity.
++
++Measuring idle power requires insight into the idle state implementation on the
++particular platform. Specifically, if the platform has coupled idle-states (or
++package states). To measure non-coupled per-cpu idle-states it is necessary to
++keep one cpu busy to keep any shared resources alive to isolate the idle power
++of the cpu from idle/busy power of the shared resources. The cpu can be tricked
++into different per-cpu idle states by disabling the other states. Based on
++various combinations of measurements with specific cpus busy and disabling
++idle-states it is possible to extrapolate the idle-state power.
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0046-sched-Make-energy-awareness-a-sched-feature.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0046-sched-Make-energy-awareness-a-sched-feature.patch
new file mode 100644
index 0000000..9b9929b
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0046-sched-Make-energy-awareness-a-sched-feature.patch
@@ -0,0 +1,57 @@
+From ac91525a35e79b82a09fb1ed75ee547802f3bed1 Mon Sep 17 00:00:00 2001
+From: Morten Rasmussen <morten.rasmussen@arm.com>
+Date: Tue, 13 Jan 2015 13:45:51 +0000
+Subject: [PATCH 46/92] sched: Make energy awareness a sched feature
+
+This patch introduces the ENERGY_AWARE sched feature, which is
+implemented using jump labels when SCHED_DEBUG is defined. It is
+statically set false when SCHED_DEBUG is not defined. Hence this doesn't
+allow energy awareness to be enabled without SCHED_DEBUG. This
+sched_feature knob will be replaced later with a more appropriate
+control knob when things have matured a bit.
+
+ENERGY_AWARE is based on per-entity load-tracking hence FAIR_GROUP_SCHED
+must be enable. This dependency isn't checked at compile time yet.
+
+cc: Ingo Molnar <mingo@redhat.com>
+cc: Peter Zijlstra <peterz@infradead.org>
+Signed-off-by: Morten Rasmussen <morten.rasmussen@arm.com>
+(cherry picked from commit e3b80d193dad157c720ec29496104126dbfc67ce)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ kernel/sched/fair.c     | 5 +++++
+ kernel/sched/features.h | 5 +++++
+ 2 files changed, 10 insertions(+)
+
+diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
+index cb283ca..fa393d9 100644
+--- a/kernel/sched/fair.c
++++ b/kernel/sched/fair.c
+@@ -5291,6 +5291,11 @@ static void record_wakee(struct task_struct *p)
+ 	}
+ }
+ 
++static inline bool energy_aware(void)
++{
++	return sched_feat(ENERGY_AWARE);
++}
++
+ /*
+  * Detect M:N waker/wakee relationships via a switching-frequency heuristic.
+  *
+diff --git a/kernel/sched/features.h b/kernel/sched/features.h
+index 69631fa..b634151 100644
+--- a/kernel/sched/features.h
++++ b/kernel/sched/features.h
+@@ -69,3 +69,8 @@
+ SCHED_FEAT(LB_MIN, false)
+ SCHED_FEAT(ATTACH_AGE_LOAD, true)
+ 
++/*
++ * Energy aware scheduling. Use platform energy model to guide scheduling
++ * decisions optimizing for energy efficiency.
++ */
++SCHED_FEAT(ENERGY_AWARE, false)
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0047-sched-Introduce-energy-data-structures.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0047-sched-Introduce-energy-data-structures.patch
new file mode 100644
index 0000000..5590b2f
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0047-sched-Introduce-energy-data-structures.patch
@@ -0,0 +1,107 @@
+From 5e91e54c76b1a29dff30f8c5bfb7741569b3a6f8 Mon Sep 17 00:00:00 2001
+From: Dietmar Eggemann <dietmar.eggemann@arm.com>
+Date: Fri, 14 Nov 2014 16:08:45 +0000
+Subject: [PATCH 47/92] sched: Introduce energy data structures
+
+The struct sched_group_energy represents the per sched_group related
+data which is needed for energy aware scheduling. It contains:
+
+  (1) number of elements of the idle state array
+  (2) pointer to the idle state array which comprises 'power consumption'
+      for each idle state
+  (3) number of elements of the capacity state array
+  (4) pointer to the capacity state array which comprises 'compute
+      capacity and power consumption' tuples for each capacity state
+
+The struct sched_group obtains a pointer to a struct sched_group_energy.
+
+The function pointer sched_domain_energy_f is introduced into struct
+sched_domain_topology_level which will allow the arch to pass a particular
+struct sched_group_energy from the topology shim layer into the scheduler
+core.
+
+The function pointer sched_domain_energy_f has an 'int cpu' parameter
+since the folding of two adjacent sd levels via sd degenerate doesn't work
+for all sd levels. I.e. it is not possible for example to use this feature
+to provide per-cpu energy in sd level DIE on ARM's TC2 platform.
+
+It was discussed that the folding of sd levels approach is preferable
+over the cpu parameter approach, simply because the user (the arch
+specifying the sd topology table) can introduce less errors. But since
+it is not working, the 'int cpu' parameter is the only way out. It's
+possible to use the folding of sd levels approach for
+sched_domain_flags_f and the cpu parameter approach for the
+sched_domain_energy_f at the same time though. With the use of the
+'int cpu' parameter, an extra check function has to be provided to make
+sure that all cpus spanned by a sched group are provisioned with the same
+energy data.
+
+cc: Ingo Molnar <mingo@redhat.com>
+cc: Peter Zijlstra <peterz@infradead.org>
+Signed-off-by: Dietmar Eggemann <dietmar.eggemann@arm.com>
+(cherry picked from commit 0bab805ddc2bbf1dae5baf44f2812392789846c7)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ include/linux/sched.h | 19 +++++++++++++++++++
+ kernel/sched/sched.h  |  1 +
+ 2 files changed, 20 insertions(+)
+
+diff --git a/include/linux/sched.h b/include/linux/sched.h
+index 2e3c2a1..0522149 100644
+--- a/include/linux/sched.h
++++ b/include/linux/sched.h
+@@ -1069,6 +1069,22 @@ struct sched_domain_attr {
+ 
+ extern int sched_domain_level_max;
+ 
++struct capacity_state {
++	unsigned long cap;	/* compute capacity */
++	unsigned long power;	/* power consumption at this compute capacity */
++};
++
++struct idle_state {
++	unsigned long power;	 /* power consumption in this idle state */
++};
++
++struct sched_group_energy {
++	unsigned int nr_idle_states;	/* number of idle states */
++	struct idle_state *idle_states;	/* ptr to idle state array */
++	unsigned int nr_cap_states;	/* number of capacity states */
++	struct capacity_state *cap_states; /* ptr to capacity state array */
++};
++
+ struct sched_group;
+ 
+ struct sched_domain_shared {
+@@ -1176,6 +1192,8 @@ extern void partition_sched_domains(int ndoms_new, cpumask_var_t doms_new[],
+ 
+ typedef const struct cpumask *(*sched_domain_mask_f)(int cpu);
+ typedef int (*sched_domain_flags_f)(void);
++typedef
++const struct sched_group_energy * const(*sched_domain_energy_f)(int cpu);
+ 
+ #define SDTL_OVERLAP	0x01
+ 
+@@ -1189,6 +1207,7 @@ struct sd_data {
+ struct sched_domain_topology_level {
+ 	sched_domain_mask_f mask;
+ 	sched_domain_flags_f sd_flags;
++	sched_domain_energy_f energy;
+ 	int		    flags;
+ 	int		    numa_level;
+ 	struct sd_data      data;
+diff --git a/kernel/sched/sched.h b/kernel/sched/sched.h
+index 7b34c78..46787bd 100644
+--- a/kernel/sched/sched.h
++++ b/kernel/sched/sched.h
+@@ -914,6 +914,7 @@ struct sched_group {
+ 	unsigned int group_weight;
+ 	struct sched_group_capacity *sgc;
+ 	int asym_prefer_cpu;		/* cpu of highest priority in group */
++	const struct sched_group_energy const *sge;
+ 
+ 	/*
+ 	 * The CPUs this group covers.
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0048-sched-Initialize-energy-data-structures.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0048-sched-Initialize-energy-data-structures.patch
new file mode 100644
index 0000000..1107577
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0048-sched-Initialize-energy-data-structures.patch
@@ -0,0 +1,126 @@
+From cd9cfc061f16a3664fc374802e6c014602b0c94f Mon Sep 17 00:00:00 2001
+From: Dietmar Eggemann <dietmar.eggemann@arm.com>
+Date: Fri, 14 Nov 2014 16:20:20 +0000
+Subject: [PATCH 48/92] sched: Initialize energy data structures
+
+The sched_group_energy (sge) pointer of the first sched_group (sg) in
+the sched_domain (sd) is initialized to point to the appropriate (in
+terms of sd level and cpu) sge data defined in the arch and so to the
+correct part of the Energy Model (EM).
+
+Energy-aware scheduling allows that a system has only EM data up to a
+certain sd level (so called highest energy aware balancing sd level).
+A check in init_sched_energy() enforces that all sd's below this sd
+level contain EM data.
+
+The 'int cpu' parameter of sched_domain_energy_f requires that
+check_sched_energy_data() makes sure that all cpus spanned by a sg
+are provisioned with the same EM data.
+
+This patch has also been tested with feature FORCE_SD_OVERLAP enabled.
+
+cc: Ingo Molnar <mingo@redhat.com>
+cc: Peter Zijlstra <peterz@infradead.org>
+Signed-off-by: Dietmar Eggemann <dietmar.eggemann@arm.com>
+(cherry picked from commit 054c7ad511ad9e2b54e48d4e01d34be97fff104c)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ kernel/sched/core.c | 72 ++++++++++++++++++++++++++++++++++++++++++++++++++++-
+ 1 file changed, 71 insertions(+), 1 deletion(-)
+
+diff --git a/kernel/sched/core.c b/kernel/sched/core.c
+index 209d2ea..083b318 100644
+--- a/kernel/sched/core.c
++++ b/kernel/sched/core.c
+@@ -6327,6 +6327,73 @@ static void init_sched_groups_capacity(int cpu, struct sched_domain *sd)
+ 	update_group_capacity(sd, cpu);
+ }
+ 
++#define energy_eff(e, n) \
++    ((e->cap_states[n].cap << SCHED_CAPACITY_SHIFT)/e->cap_states[n].power)
++
++static void init_sched_groups_energy(int cpu, struct sched_domain *sd,
++				     sched_domain_energy_f fn)
++{
++	struct sched_group *sg = sd->groups;
++	const struct sched_group_energy *sge;
++	int i;
++
++	if (!(fn && fn(cpu)))
++		return;
++
++	if (cpu != group_balance_cpu(sg))
++		return;
++
++	if (sd->flags & SD_OVERLAP) {
++		pr_err("BUG: EAS does not support overlapping sd spans\n");
++#ifdef CONFIG_SCHED_DEBUG
++		pr_err("     the %s domain has SD_OVERLAP set\n", sd->name);
++#endif
++		return;
++	}
++
++	if (sd->child && !sd->child->groups->sge) {
++		pr_err("BUG: EAS setup borken for CPU%d\n", cpu);
++#ifdef CONFIG_SCHED_DEBUG
++		pr_err("     energy data on %s but not on %s domain\n",
++			sd->name, sd->child->name);
++#endif
++		return;
++	}
++
++	sge = fn(cpu);
++
++	/*
++	 * Check that the per-cpu provided sd energy data is consistent for all
++	 * cpus within the mask.
++	 */
++	if (cpumask_weight(sched_group_cpus(sg)) > 1) {
++		struct cpumask mask;
++
++		cpumask_xor(&mask, sched_group_cpus(sg), get_cpu_mask(cpu));
++
++		for_each_cpu(i, &mask)
++			BUG_ON(sge != fn(i));
++	}
++
++	/* Check that energy efficiency (capacity/power) is monotonically
++	 * decreasing in the capacity state vector with higher indexes
++	 */
++	for (i = 0; i < (sge->nr_cap_states - 1); i++) {
++		if (energy_eff(sge, i) > energy_eff(sge, i+1))
++			continue;
++#ifdef CONFIG_SCHED_DEBUG
++		pr_warn("WARN: cpu=%d, domain=%s: incr. energy eff %lu[%d]->%lu[%d]\n",
++			cpu, sd->name, energy_eff(sge, i), i,
++			energy_eff(sge, i+1), i+1);
++#else
++		pr_warn("WARN: cpu=%d: incr. energy eff %lu[%d]->%lu[%d]\n",
++			cpu, energy_eff(sge, i), i, energy_eff(sge, i+1), i+1);
++#endif
++	}
++
++	sd->groups->sge = fn(cpu);
++}
++
+ /*
+  * Initializers for schedule domains
+  * Non-inlined to reduce accumulated stack pressure in build_sched_domains()
+@@ -7052,10 +7119,13 @@ static int build_sched_domains(const struct cpumask *cpu_map,
+ 
+ 	/* Calculate CPU capacity for physical packages and nodes */
+ 	for (i = nr_cpumask_bits-1; i >= 0; i--) {
++		struct sched_domain_topology_level *tl = sched_domain_topology;
++
+ 		if (!cpumask_test_cpu(i, cpu_map))
+ 			continue;
+ 
+-		for (sd = *per_cpu_ptr(d.sd, i); sd; sd = sd->parent) {
++		for (sd = *per_cpu_ptr(d.sd, i); sd; sd = sd->parent, tl++) {
++			init_sched_groups_energy(i, sd, tl->energy);
+ 			claim_allocations(i, sd);
+ 			init_sched_groups_capacity(i, sd);
+ 		}
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0049-sched-EAS-cpu-hotplug-interoperability.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0049-sched-EAS-cpu-hotplug-interoperability.patch
new file mode 100644
index 0000000..447e302
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0049-sched-EAS-cpu-hotplug-interoperability.patch
@@ -0,0 +1,204 @@
+From 3477712d21ac713611aa74f9f5a6ff4b1e49a930 Mon Sep 17 00:00:00 2001
+From: Dietmar Eggemann <dietmar.eggemann@arm.com>
+Date: Thu, 30 Jul 2015 16:53:30 +0100
+Subject: [PATCH 49/92] sched: EAS & cpu hotplug interoperability
+
+For Energy-Aware Scheduling (EAS) to work properly, even in the case that
+cpus are hot-plugged out, the energy model (EM) data on all energy-aware
+sched domains has to be present for all online cpus.
+
+Mainline sd hierarchy setup code will remove sd's which are not useful for
+task scheduling e.g. in the following situations:
+
+1. Only one cpu remains in one cluster of a two cluster system.
+
+   This remaining cpu only has DIE and no MC sd.
+
+2. A complete cluster in a two-cluster system is hot-plugged out.
+
+   The cpus of the remaining cluster only have MC and no DIE sd.
+
+To make sure that all online cpus keep all their energy-aware sd's,
+the sd degenerate functionality has been changed to not free sd's if
+their first sg contains EM data in case:
+
+1. There is only one cpu left in the sd.
+
+2. There have to be at least 2 sg's if certain sd flags are set.
+
+Instead of freeing such an sd it now clears only its SD_LOAD_BALANCE
+flag.
+
+This will make sure that the EAS functionality will always see all
+energy-aware sd's for all online cpus.
+
+It will introduce a (small ?) performance degradation since the
+hot-path macro for_each_domain() has to deal with sd's not
+contributing to task-scheduling at all now. There is the handling
+of newidle decay values before the SD_LOAD_BALANCE check in
+rebalance_domains().
+But generally, code to make sure that task scheduling is not invoked
+on these sd's is in place (if (!(sd->flags & SD_LOAD_BALANCE))
+already.
+
+This patch has been tested on a single (a7) cluster TC2 system. I.e. we
+could abandon the SYS sd level patch and use this patch to solve all
+problems related to sd topology setups and runtime changes.
+
+This patch should not be squashed.
+
+Test (w/ CONFIG_SCHED_DEBUG):
+
+JUNO:
+
+$ cat /proc/cpuinfo | grep "^CPU part"
+CPU part        : 0xd03
+CPU part        : 0xd07
+CPU part        : 0xd07
+CPU part        : 0xd03
+CPU part        : 0xd03
+CPU part        : 0xd03
+
+$ cat /proc/sys/kernel/sched_domain/cpu*/domain*/{name,flags}
+
+MC
+DIE
+MC
+DIE
+MC
+DIE
+MC
+DIE
+MC
+DIE
+MC
+DIE
+33583 - 0x832f
+4143  - 0x102f
+33583
+4143
+33583
+4143
+33583
+4143
+33583
+4143
+33583
+4143
+
+Hotplug-out A57 cluster
+
+$ echo 0 > /sys/devices/system/cpu/cpu1/online
+$ echo 0 > /sys/devices/system/cpu/cpu2/online
+
+$ cat /proc/sys/kernel/sched_domain/cpu*/domain*/{name,flags}
+
+MC
+DIE
+MC
+DIE
+MC
+DIE
+MC
+DIE
+33583
+4142  - 0x102e <-- !SD_LOAD_BALANCE
+33583
+4142
+33583
+4142
+33583
+4142
+
+Signed-off-by: Dietmar Eggemann <dietmar.eggemann@arm.com>
+(cherry picked from commit a5ebdd0fe5357fe125d9603d766adc69e7607981)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ kernel/sched/core.c | 17 ++++++++++-------
+ kernel/sched/fair.c |  7 +++++--
+ 2 files changed, 15 insertions(+), 9 deletions(-)
+
+diff --git a/kernel/sched/core.c b/kernel/sched/core.c
+index 083b318..f31ea62 100644
+--- a/kernel/sched/core.c
++++ b/kernel/sched/core.c
+@@ -5663,9 +5663,6 @@ static int sched_domain_debug_one(struct sched_domain *sd, int cpu, int level,
+ 
+ 	if (!(sd->flags & SD_LOAD_BALANCE)) {
+ 		printk("does not load-balance\n");
+-		if (sd->parent)
+-			printk(KERN_ERR "ERROR: !SD_LOAD_BALANCE domain"
+-					" has parent");
+ 		return -1;
+ 	}
+ 
+@@ -5760,8 +5757,12 @@ static inline bool sched_debug(void)
+ 
+ static int sd_degenerate(struct sched_domain *sd)
+ {
+-	if (cpumask_weight(sched_domain_span(sd)) == 1)
+-		return 1;
++	if (cpumask_weight(sched_domain_span(sd)) == 1) {
++		if (sd->groups->sge)
++			sd->flags &= ~SD_LOAD_BALANCE;
++		else
++			return 1;
++	}
+ 
+ 	/* Following flags need at least 2 groups */
+ 	if (sd->flags & (SD_LOAD_BALANCE |
+@@ -5805,6 +5806,10 @@ static int sd_degenerate(struct sched_domain *sd)
+ 				SD_SHARE_PKG_RESOURCES |
+ 				SD_PREFER_SIBLING |
+ 				SD_SHARE_POWERDOMAIN);
++		if (parent->groups->sge) {
++			parent->flags &= ~SD_LOAD_BALANCE;
++			return 0;
++		}
+ 		if (nr_node_ids == 1)
+ 			pflags &= ~SD_SERIALIZE;
+ 	}
+@@ -7098,8 +7103,6 @@ static int build_sched_domains(const struct cpumask *cpu_map,
+ 				*per_cpu_ptr(d.sd, i) = sd;
+ 			if (tl->flags & SDTL_OVERLAP || sched_feat(FORCE_SD_OVERLAP))
+ 				sd->flags |= SD_OVERLAP;
+-			if (cpumask_equal(cpu_map, sched_domain_span(sd)))
+-				break;
+ 		}
+ 	}
+ 
+diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
+index fa393d9..c7d9bbf 100644
+--- a/kernel/sched/fair.c
++++ b/kernel/sched/fair.c
+@@ -7457,6 +7457,9 @@ static inline enum fbq_type fbq_classify_rq(struct rq *rq)
+ }
+ #endif /* CONFIG_NUMA_BALANCING */
+ 
++#define lb_sd_parent(sd) \
++        (sd->parent && sd->parent->groups != sd->parent->groups->next)
++
+ /**
+  * update_sd_lb_stats - Update sched_domain's statistics for load balancing.
+  * @env: The load balancing environment.
+@@ -7530,7 +7533,7 @@ static inline void update_sd_lb_stats(struct lb_env *env, struct sd_lb_stats *sd
+ 
+ 	env->src_grp_nr_running = sds->busiest_stat.sum_nr_running;
+ 
+-	if (!env->sd->parent) {
++	if (!lb_sd_parent(env->sd)) {
+ 		/* update overload indicator if we are at root domain */
+ 		if (env->dst_rq->rd->overload != overload)
+ 			env->dst_rq->rd->overload = overload;
+@@ -7989,7 +7992,7 @@ static int load_balance(int this_cpu, struct rq *this_rq,
+ 			int *continue_balancing)
+ {
+ 	int ld_moved, cur_ld_moved, active_balance = 0;
+-	struct sched_domain *sd_parent = sd->parent;
++	struct sched_domain *sd_parent = lb_sd_parent(sd) ? sd->parent : NULL;
+ 	struct sched_group *group;
+ 	struct rq *busiest;
+ 	unsigned long flags;
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0050-sched-Introduce-SD_SHARE_CAP_STATES-sched_domain-fla.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0050-sched-Introduce-SD_SHARE_CAP_STATES-sched_domain-fla.patch
new file mode 100644
index 0000000..a55cd11
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0050-sched-Introduce-SD_SHARE_CAP_STATES-sched_domain-fla.patch
@@ -0,0 +1,83 @@
+From 1e2c379e10555b3efa8b7f8e4552b9ddae237491 Mon Sep 17 00:00:00 2001
+From: Morten Rasmussen <morten.rasmussen@arm.com>
+Date: Tue, 13 Jan 2015 13:50:46 +0000
+Subject: [PATCH 50/92] sched: Introduce SD_SHARE_CAP_STATES sched_domain flag
+
+cpufreq is currently keeping it a secret which cpus are sharing
+clock source. The scheduler needs to know about clock domains as well
+to become more energy aware. The SD_SHARE_CAP_STATES domain flag
+indicates whether cpus belonging to the sched_domain share capacity
+states (P-states).
+
+There is no connection with cpufreq (yet). The flag must be set by
+the arch specific topology code.
+
+cc: Russell King <linux@arm.linux.org.uk>
+cc: Ingo Molnar <mingo@redhat.com>
+cc: Peter Zijlstra <peterz@infradead.org>
+
+Signed-off-by: Morten Rasmussen <morten.rasmussen@arm.com>
+(cherry picked from commit d5cfb54bc10768bf25da557c1cd7c91df6ae6296)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ include/linux/sched.h |  1 +
+ kernel/sched/core.c   | 10 +++++++---
+ 2 files changed, 8 insertions(+), 3 deletions(-)
+
+diff --git a/include/linux/sched.h b/include/linux/sched.h
+index 0522149..fad382a 100644
+--- a/include/linux/sched.h
++++ b/include/linux/sched.h
+@@ -1035,6 +1035,7 @@ extern void wake_q_add(struct wake_q_head *head,
+ #define SD_PREFER_SIBLING	0x1000	/* Prefer to place tasks in a sibling domain */
+ #define SD_OVERLAP		0x2000	/* sched_domains of this level overlap */
+ #define SD_NUMA			0x4000	/* cross-node balancing */
++#define SD_SHARE_CAP_STATES	0x8000  /* Domain members share capacity state */
+ 
+ #ifdef CONFIG_SCHED_SMT
+ static inline int cpu_smt_flags(void)
+diff --git a/kernel/sched/core.c b/kernel/sched/core.c
+index f31ea62..b450329 100644
+--- a/kernel/sched/core.c
++++ b/kernel/sched/core.c
+@@ -5772,7 +5772,8 @@ static int sd_degenerate(struct sched_domain *sd)
+ 			 SD_SHARE_CPUCAPACITY |
+ 			 SD_ASYM_CPUCAPACITY |
+ 			 SD_SHARE_PKG_RESOURCES |
+-			 SD_SHARE_POWERDOMAIN)) {
++			 SD_SHARE_POWERDOMAIN |
++			 SD_SHARE_CAP_STATES)) {
+ 		if (sd->groups != sd->groups->next)
+ 			return 0;
+ 	}
+@@ -5805,7 +5806,8 @@ static int sd_degenerate(struct sched_domain *sd)
+ 				SD_SHARE_CPUCAPACITY |
+ 				SD_SHARE_PKG_RESOURCES |
+ 				SD_PREFER_SIBLING |
+-				SD_SHARE_POWERDOMAIN);
++				SD_SHARE_POWERDOMAIN |
++				SD_SHARE_CAP_STATES);
+ 		if (parent->groups->sge) {
+ 			parent->flags &= ~SD_LOAD_BALANCE;
+ 			return 0;
+@@ -6515,6 +6517,7 @@ static void claim_allocations(int cpu, struct sched_domain *sd)
+  *   SD_NUMA                - describes NUMA topologies
+  *   SD_SHARE_POWERDOMAIN   - describes shared power domain
+  *   SD_ASYM_CPUCAPACITY    - describes mixed capacity topologies
++ *   SD_SHARE_CAP_STATES    - describes shared capacity states
+  *
+  * Odd one out, which beside describing the topology has a quirk also
+  * prescribes the desired behaviour that goes along with it:
+@@ -6527,7 +6530,8 @@ static void claim_allocations(int cpu, struct sched_domain *sd)
+ 	 SD_NUMA |			\
+ 	 SD_ASYM_PACKING |		\
+ 	 SD_ASYM_CPUCAPACITY |		\
+-	 SD_SHARE_POWERDOMAIN)
++	 SD_SHARE_POWERDOMAIN |		\
++	 SD_SHARE_CAP_STATES)
+ 
+ static struct sched_domain *
+ sd_init(struct sched_domain_topology_level *tl,
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0051-sched-Relocated-cpu_util-and-change-return-type.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0051-sched-Relocated-cpu_util-and-change-return-type.patch
new file mode 100644
index 0000000..dab8b97
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0051-sched-Relocated-cpu_util-and-change-return-type.patch
@@ -0,0 +1,109 @@
+From 88ce1ba602ccc9479feb7837f2c7bc074379561c Mon Sep 17 00:00:00 2001
+From: Morten Rasmussen <morten.rasmussen@arm.com>
+Date: Thu, 11 Dec 2014 15:25:29 +0000
+Subject: [PATCH 51/92] sched: Relocated cpu_util() and change return type
+
+Move cpu_util() to an earlier position in fair.c and change return
+type to unsigned long as negative usage doesn't make much sense. All
+other load and capacity related functions use unsigned long including
+the caller of cpu_util().
+
+cc: Ingo Molnar <mingo@redhat.com>
+cc: Peter Zijlstra <peterz@infradead.org>
+
+Signed-off-by: Morten Rasmussen <morten.rasmussen@arm.com>
+(cherry picked from commit c5aa28c6e0792ee8a994d3e401fc619694d01f5f)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ kernel/sched/fair.c | 68 ++++++++++++++++++++++++++---------------------------
+ 1 file changed, 34 insertions(+), 34 deletions(-)
+
+diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
+index c7d9bbf..0085d4f 100644
+--- a/kernel/sched/fair.c
++++ b/kernel/sched/fair.c
+@@ -5274,6 +5274,40 @@ static long effective_load(struct task_group *tg, int cpu, long wl, long wg)
+ 
+ #endif
+ 
++/*
++ * cpu_util returns the amount of capacity of a CPU that is used by CFS
++ * tasks. The unit of the return value must be the one of capacity so we can
++ * compare the utilization with the capacity of the CPU that is available for
++ * CFS task (ie cpu_capacity).
++ *
++ * cfs_rq.avg.util_avg is the sum of running time of runnable tasks plus the
++ * recent utilization of currently non-runnable tasks on a CPU. It represents
++ * the amount of utilization of a CPU in the range [0..capacity_orig] where
++ * capacity_orig is the cpu_capacity available at the highest frequency
++ * (arch_scale_freq_capacity()).
++ * The utilization of a CPU converges towards a sum equal to or less than the
++ * current capacity (capacity_curr <= capacity_orig) of the CPU because it is
++ * the running time on this CPU scaled by capacity_curr.
++ *
++ * Nevertheless, cfs_rq.avg.util_avg can be higher than capacity_curr or even
++ * higher than capacity_orig because of unfortunate rounding in
++ * cfs.avg.util_avg or just after migrating tasks and new task wakeups until
++ * the average stabilizes with the new running time. We need to check that the
++ * utilization stays within the range of [0..capacity_orig] and cap it if
++ * necessary. Without utilization capping, a group could be seen as overloaded
++ * (CPU0 utilization at 121% + CPU1 utilization at 80%) whereas CPU1 has 20% of
++ * available capacity. We allow utilization to overshoot capacity_curr (but not
++ * capacity_orig) as it useful for predicting the capacity required after task
++ * migrations (scheduler-driven DVFS).
++ */
++static unsigned long cpu_util(int cpu)
++{
++	unsigned long util = cpu_rq(cpu)->cfs.avg.util_avg;
++	unsigned long capacity = capacity_orig_of(cpu);
++
++	return (util >= capacity) ? capacity : util;
++}
++
+ static void record_wakee(struct task_struct *p)
+ {
+ 	/*
+@@ -5783,40 +5817,6 @@ static int select_idle_sibling(struct task_struct *p, int prev, int target)
+ 	return target;
+ }
+ 
+-/*
+- * cpu_util returns the amount of capacity of a CPU that is used by CFS
+- * tasks. The unit of the return value must be the one of capacity so we can
+- * compare the utilization with the capacity of the CPU that is available for
+- * CFS task (ie cpu_capacity).
+- *
+- * cfs_rq.avg.util_avg is the sum of running time of runnable tasks plus the
+- * recent utilization of currently non-runnable tasks on a CPU. It represents
+- * the amount of utilization of a CPU in the range [0..capacity_orig] where
+- * capacity_orig is the cpu_capacity available at the highest frequency
+- * (arch_scale_freq_capacity()).
+- * The utilization of a CPU converges towards a sum equal to or less than the
+- * current capacity (capacity_curr <= capacity_orig) of the CPU because it is
+- * the running time on this CPU scaled by capacity_curr.
+- *
+- * Nevertheless, cfs_rq.avg.util_avg can be higher than capacity_curr or even
+- * higher than capacity_orig because of unfortunate rounding in
+- * cfs.avg.util_avg or just after migrating tasks and new task wakeups until
+- * the average stabilizes with the new running time. We need to check that the
+- * utilization stays within the range of [0..capacity_orig] and cap it if
+- * necessary. Without utilization capping, a group could be seen as overloaded
+- * (CPU0 utilization at 121% + CPU1 utilization at 80%) whereas CPU1 has 20% of
+- * available capacity. We allow utilization to overshoot capacity_curr (but not
+- * capacity_orig) as it useful for predicting the capacity required after task
+- * migrations (scheduler-driven DVFS).
+- */
+-static int cpu_util(int cpu)
+-{
+-	unsigned long util = cpu_rq(cpu)->cfs.avg.util_avg;
+-	unsigned long capacity = capacity_orig_of(cpu);
+-
+-	return (util >= capacity) ? capacity : util;
+-}
+-
+ static inline int task_util(struct task_struct *p)
+ {
+ 	return p->se.avg.util_avg;
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0052-sched-Highest-energy-aware-balancing-sched_domain-le.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0052-sched-Highest-energy-aware-balancing-sched_domain-le.patch
new file mode 100644
index 0000000..546ac07
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0052-sched-Highest-energy-aware-balancing-sched_domain-le.patch
@@ -0,0 +1,76 @@
+From a90c8ec93f298cccfbc4db29a8513675002da326 Mon Sep 17 00:00:00 2001
+From: Morten Rasmussen <morten.rasmussen@arm.com>
+Date: Fri, 2 Jan 2015 17:08:52 +0000
+Subject: [PATCH 52/92] sched: Highest energy aware balancing sched_domain
+ level pointer
+
+Add another member to the family of per-cpu sched_domain shortcut
+pointers. This one, sd_ea, points to the highest level at which energy
+model is provided. At this level and all levels below all sched_groups
+have energy model data attached.
+
+Partial energy model information is possible but restricted to providing
+energy model data for lower level sched_domains (sd_ea and below) and
+leaving load-balancing on levels above to non-energy-aware
+load-balancing. For example, it is possible to apply energy-aware
+scheduling within each socket on a multi-socket system and let normal
+scheduling handle load-balancing between sockets.
+
+cc: Ingo Molnar <mingo@redhat.com>
+cc: Peter Zijlstra <peterz@infradead.org>
+Signed-off-by: Morten Rasmussen <morten.rasmussen@arm.com>
+(cherry picked from commit c4eb7a2b0a1908a377fb063ecae89d7bacd6aa78)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ kernel/sched/core.c  | 10 ++++++++++
+ kernel/sched/sched.h |  1 +
+ 2 files changed, 11 insertions(+)
+
+diff --git a/kernel/sched/core.c b/kernel/sched/core.c
+index b450329..f2642d4 100644
+--- a/kernel/sched/core.c
++++ b/kernel/sched/core.c
+@@ -6001,11 +6001,13 @@ static void destroy_sched_domains(struct sched_domain *sd)
+ DEFINE_PER_CPU(struct sched_domain_shared *, sd_llc_shared);
+ DEFINE_PER_CPU(struct sched_domain *, sd_numa);
+ DEFINE_PER_CPU(struct sched_domain *, sd_asym);
++DEFINE_PER_CPU(struct sched_domain *, sd_ea);
+ 
+ static void update_top_cache_domain(int cpu)
+ {
+ 	struct sched_domain_shared *sds = NULL;
+ 	struct sched_domain *sd;
++	struct sched_domain *ea_sd = NULL;
+ 	int id = cpu;
+ 	int size = 1;
+ 
+@@ -6026,6 +6028,14 @@ static void update_top_cache_domain(int cpu)
+ 
+ 	sd = highest_flag_domain(cpu, SD_ASYM_PACKING);
+ 	rcu_assign_pointer(per_cpu(sd_asym, cpu), sd);
++
++	for_each_domain(cpu, sd) {
++		if (sd->groups->sge)
++			ea_sd = sd;
++		else
++			break;
++	}
++	rcu_assign_pointer(per_cpu(sd_ea, cpu), ea_sd);
+ }
+ 
+ /*
+diff --git a/kernel/sched/sched.h b/kernel/sched/sched.h
+index 46787bd..22b7cfd 100644
+--- a/kernel/sched/sched.h
++++ b/kernel/sched/sched.h
+@@ -892,6 +892,7 @@ static inline struct sched_domain *lowest_flag_domain(int cpu, int flag)
+ DECLARE_PER_CPU(struct sched_domain_shared *, sd_llc_shared);
+ DECLARE_PER_CPU(struct sched_domain *, sd_numa);
+ DECLARE_PER_CPU(struct sched_domain *, sd_asym);
++DECLARE_PER_CPU(struct sched_domain *, sd_ea);
+ 
+ struct sched_group_capacity {
+ 	atomic_t ref;
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0053-sched-Calculate-energy-consumption-of-sched_group.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0053-sched-Calculate-energy-consumption-of-sched_group.patch
new file mode 100644
index 0000000..2f82044
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0053-sched-Calculate-energy-consumption-of-sched_group.patch
@@ -0,0 +1,229 @@
+From 1e9ffadc70a89ede023b79139debe4f6a17c5c7f Mon Sep 17 00:00:00 2001
+From: Morten Rasmussen <morten.rasmussen@arm.com>
+Date: Thu, 18 Dec 2014 14:47:18 +0000
+Subject: [PATCH 53/92] sched: Calculate energy consumption of sched_group
+
+For energy-aware load-balancing decisions it is necessary to know the
+energy consumption estimates of groups of cpus. This patch introduces a
+basic function, sched_group_energy(), which estimates the energy
+consumption of the cpus in the group and any resources shared by the
+members of the group.
+
+NOTE: The function has five levels of identation and breaks the 80
+character limit. Refactoring is necessary.
+
+cc: Ingo Molnar <mingo@redhat.com>
+cc: Peter Zijlstra <peterz@infradead.org>
+Signed-off-by: Morten Rasmussen <morten.rasmussen@arm.com>
+(cherry picked from commit 1e09b216da57376d8321459eda52699cef8f7e1a)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ kernel/sched/core.c  |   4 ++
+ kernel/sched/fair.c  | 156 +++++++++++++++++++++++++++++++++++++++++++++++++++
+ kernel/sched/sched.h |   1 +
+ 3 files changed, 161 insertions(+)
+
+diff --git a/kernel/sched/core.c b/kernel/sched/core.c
+index f2642d4..431c7e0 100644
+--- a/kernel/sched/core.c
++++ b/kernel/sched/core.c
+@@ -6002,6 +6002,7 @@ static void destroy_sched_domains(struct sched_domain *sd)
+ DEFINE_PER_CPU(struct sched_domain *, sd_numa);
+ DEFINE_PER_CPU(struct sched_domain *, sd_asym);
+ DEFINE_PER_CPU(struct sched_domain *, sd_ea);
++DEFINE_PER_CPU(struct sched_domain *, sd_scs);
+ 
+ static void update_top_cache_domain(int cpu)
+ {
+@@ -6036,6 +6037,9 @@ static void update_top_cache_domain(int cpu)
+ 			break;
+ 	}
+ 	rcu_assign_pointer(per_cpu(sd_ea, cpu), ea_sd);
++
++	sd = highest_flag_domain(cpu, SD_SHARE_CAP_STATES);
++	rcu_assign_pointer(per_cpu(sd_scs, cpu), sd);
+ }
+ 
+ /*
+diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
+index 0085d4f..1b8dca7 100644
+--- a/kernel/sched/fair.c
++++ b/kernel/sched/fair.c
+@@ -5331,6 +5331,162 @@ static inline bool energy_aware(void)
+ }
+ 
+ /*
++ * cpu_norm_util() returns the cpu util relative to a specific capacity,
++ * i.e. it's busy ratio, in the range [0..SCHED_CAPACITY_SCALE] which is useful
++ * for energy calculations. Using the scale-invariant util returned by
++ * cpu_util() and approximating scale-invariant util by:
++ *
++ *   util ~ (curr_freq/max_freq)*1024 * capacity_orig/1024 * running_time/time
++ *
++ * the normalized util can be found using the specific capacity.
++ *
++ *   capacity = capacity_orig * curr_freq/max_freq
++ *
++ *   norm_util = running_time/time ~ util/capacity
++ */
++static unsigned long cpu_norm_util(int cpu, unsigned long capacity)
++{
++	int util = cpu_util(cpu);
++
++	if (util >= capacity)
++		return SCHED_CAPACITY_SCALE;
++
++	return (util << SCHED_CAPACITY_SHIFT)/capacity;
++}
++
++static unsigned long group_max_util(struct sched_group *sg)
++{
++	int i;
++	unsigned long max_util = 0;
++
++	for_each_cpu(i, sched_group_cpus(sg))
++		max_util = max(max_util, cpu_util(i));
++
++	return max_util;
++}
++
++/*
++ * group_norm_util() returns the approximated group util relative to it's
++ * current capacity (busy ratio) in the range [0..SCHED_CAPACITY_SCALE] for use
++ * in energy calculations. Since task executions may or may not overlap in time
++ * in the group the true normalized util is between max(cpu_norm_util(i)) and
++ * sum(cpu_norm_util(i)) when iterating over all cpus in the group, i. The
++ * latter is used as the estimate as it leads to a more pessimistic energy
++ * estimate (more busy).
++ */
++static unsigned long group_norm_util(struct sched_group *sg, int cap_idx)
++{
++	int i;
++	unsigned long util_sum = 0;
++	unsigned long capacity = sg->sge->cap_states[cap_idx].cap;
++
++	for_each_cpu(i, sched_group_cpus(sg))
++		util_sum += cpu_norm_util(i, capacity);
++
++	if (util_sum > SCHED_CAPACITY_SCALE)
++		return SCHED_CAPACITY_SCALE;
++	return util_sum;
++}
++
++static int find_new_capacity(struct sched_group *sg,
++	const struct sched_group_energy const *sge)
++{
++	int idx;
++	unsigned long util = group_max_util(sg);
++
++	for (idx = 0; idx < sge->nr_cap_states; idx++) {
++		if (sge->cap_states[idx].cap >= util)
++			return idx;
++	}
++
++	return idx;
++}
++
++/*
++ * sched_group_energy(): Computes the absolute energy consumption of cpus
++ * belonging to the sched_group including shared resources shared only by
++ * members of the group. Iterates over all cpus in the hierarchy below the
++ * sched_group starting from the bottom working it's way up before going to
++ * the next cpu until all cpus are covered at all levels. The current
++ * implementation is likely to gather the same util statistics multiple times.
++ * This can probably be done in a faster but more complex way.
++ * Note: sched_group_energy() may fail when racing with sched_domain updates.
++ */
++static int sched_group_energy(struct sched_group *sg_top)
++{
++	struct sched_domain *sd;
++	int cpu, total_energy = 0;
++	struct cpumask visit_cpus;
++	struct sched_group *sg;
++
++	WARN_ON(!sg_top->sge);
++
++	cpumask_copy(&visit_cpus, sched_group_cpus(sg_top));
++
++	while (!cpumask_empty(&visit_cpus)) {
++		struct sched_group *sg_shared_cap = NULL;
++
++		cpu = cpumask_first(&visit_cpus);
++
++		/*
++		 * Is the group utilization affected by cpus outside this
++		 * sched_group?
++		 */
++		sd = rcu_dereference(per_cpu(sd_scs, cpu));
++
++		if (!sd)
++			/*
++			 * We most probably raced with hotplug; returning a
++			 * wrong energy estimation is better than entering an
++			 * infinite loop.
++			 */
++			return -EINVAL;
++
++		if (sd->parent)
++			sg_shared_cap = sd->parent->groups;
++
++		for_each_domain(cpu, sd) {
++			sg = sd->groups;
++
++			/* Has this sched_domain already been visited? */
++			if (sd->child && group_first_cpu(sg) != cpu)
++				break;
++
++			do {
++				struct sched_group *sg_cap_util;
++				unsigned long group_util;
++				int sg_busy_energy, sg_idle_energy, cap_idx;
++
++				if (sg_shared_cap && sg_shared_cap->group_weight >= sg->group_weight)
++					sg_cap_util = sg_shared_cap;
++				else
++					sg_cap_util = sg;
++
++				cap_idx = find_new_capacity(sg_cap_util, sg->sge);
++				group_util = group_norm_util(sg, cap_idx);
++				sg_busy_energy = (group_util * sg->sge->cap_states[cap_idx].power)
++										>> SCHED_CAPACITY_SHIFT;
++				sg_idle_energy = ((SCHED_CAPACITY_SCALE-group_util) * sg->sge->idle_states[0].power)
++										>> SCHED_CAPACITY_SHIFT;
++
++				total_energy += sg_busy_energy + sg_idle_energy;
++
++				if (!sd->child)
++					cpumask_xor(&visit_cpus, &visit_cpus, sched_group_cpus(sg));
++
++				if (cpumask_equal(sched_group_cpus(sg), sched_group_cpus(sg_top)))
++					goto next_cpu;
++
++			} while (sg = sg->next, sg != sd->groups);
++		}
++next_cpu:
++		continue;
++	}
++
++	return total_energy;
++}
++
++/*
+  * Detect M:N waker/wakee relationships via a switching-frequency heuristic.
+  *
+  * A waker of many should wake a different task than the one last awakened
+diff --git a/kernel/sched/sched.h b/kernel/sched/sched.h
+index 22b7cfd..75dcd85 100644
+--- a/kernel/sched/sched.h
++++ b/kernel/sched/sched.h
+@@ -893,6 +893,7 @@ static inline struct sched_domain *lowest_flag_domain(int cpu, int flag)
+ DECLARE_PER_CPU(struct sched_domain *, sd_numa);
+ DECLARE_PER_CPU(struct sched_domain *, sd_asym);
+ DECLARE_PER_CPU(struct sched_domain *, sd_ea);
++DECLARE_PER_CPU(struct sched_domain *, sd_scs);
+ 
+ struct sched_group_capacity {
+ 	atomic_t ref;
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0054-sched-Extend-sched_group_energy-to-test-load-balanci.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0054-sched-Extend-sched_group_energy-to-test-load-balanci.patch
new file mode 100644
index 0000000..5617b5f
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0054-sched-Extend-sched_group_energy-to-test-load-balanci.patch
@@ -0,0 +1,218 @@
+From f613a647e9c9dc9981b5fe277304fea79aaacfbb Mon Sep 17 00:00:00 2001
+From: Morten Rasmussen <morten.rasmussen@arm.com>
+Date: Fri, 2 Jan 2015 14:21:56 +0000
+Subject: [PATCH 54/92] sched: Extend sched_group_energy to test load-balancing
+ decisions
+
+Extended sched_group_energy() to support energy prediction with usage
+(tasks) added/removed from a specific cpu or migrated between a pair of
+cpus. Useful for load-balancing decision making.
+
+cc: Ingo Molnar <mingo@redhat.com>
+cc: Peter Zijlstra <peterz@infradead.org>
+Signed-off-by: Morten Rasmussen <morten.rasmussen@arm.com>
+(cherry picked from commit 2ab0ed691531c9d04e07c80a91b38970b08c9477)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ kernel/sched/fair.c | 90 +++++++++++++++++++++++++++++++++++++----------------
+ 1 file changed, 63 insertions(+), 27 deletions(-)
+
+diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
+index 1b8dca7..dcc73d8 100644
+--- a/kernel/sched/fair.c
++++ b/kernel/sched/fair.c
+@@ -5300,12 +5300,21 @@ static long effective_load(struct task_group *tg, int cpu, long wl, long wg)
+  * capacity_orig) as it useful for predicting the capacity required after task
+  * migrations (scheduler-driven DVFS).
+  */
+-static unsigned long cpu_util(int cpu)
++static unsigned long __cpu_util(int cpu, int delta)
+ {
+ 	unsigned long util = cpu_rq(cpu)->cfs.avg.util_avg;
+ 	unsigned long capacity = capacity_orig_of(cpu);
+ 
+-	return (util >= capacity) ? capacity : util;
++	delta += util;
++	if (delta < 0)
++		return 0;
++
++	return (delta >= capacity) ? capacity : delta;
++}
++
++static unsigned long cpu_util(int cpu)
++{
++	return __cpu_util(cpu, 0);
+ }
+ 
+ static void record_wakee(struct task_struct *p)
+@@ -5330,8 +5339,18 @@ static inline bool energy_aware(void)
+ 	return sched_feat(ENERGY_AWARE);
+ }
+ 
++struct energy_env {
++	struct sched_group	*sg_top;
++	struct sched_group	*sg_cap;
++	int			cap_idx;
++	int			util_delta;
++	int			src_cpu;
++	int			dst_cpu;
++	int			energy;
++};
++
+ /*
+- * cpu_norm_util() returns the cpu util relative to a specific capacity,
++ * __cpu_norm_util() returns the cpu util relative to a specific capacity,
+  * i.e. it's busy ratio, in the range [0..SCHED_CAPACITY_SCALE] which is useful
+  * for energy calculations. Using the scale-invariant util returned by
+  * cpu_util() and approximating scale-invariant util by:
+@@ -5344,9 +5363,9 @@ static inline bool energy_aware(void)
+  *
+  *   norm_util = running_time/time ~ util/capacity
+  */
+-static unsigned long cpu_norm_util(int cpu, unsigned long capacity)
++static unsigned long __cpu_norm_util(int cpu, unsigned long capacity, int delta)
+ {
+-	int util = cpu_util(cpu);
++	int util = __cpu_util(cpu, delta);
+ 
+ 	if (util >= capacity)
+ 		return SCHED_CAPACITY_SCALE;
+@@ -5354,13 +5373,25 @@ static unsigned long cpu_norm_util(int cpu, unsigned long capacity)
+ 	return (util << SCHED_CAPACITY_SHIFT)/capacity;
+ }
+ 
+-static unsigned long group_max_util(struct sched_group *sg)
++static int calc_util_delta(struct energy_env *eenv, int cpu)
+ {
+-	int i;
++	if (cpu == eenv->src_cpu)
++		return -eenv->util_delta;
++	if (cpu == eenv->dst_cpu)
++		return eenv->util_delta;
++	return 0;
++}
++
++static
++unsigned long group_max_util(struct energy_env *eenv)
++{
++	int i, delta;
+ 	unsigned long max_util = 0;
+ 
+-	for_each_cpu(i, sched_group_cpus(sg))
+-		max_util = max(max_util, cpu_util(i));
++	for_each_cpu(i, sched_group_cpus(eenv->sg_cap)) {
++		delta = calc_util_delta(eenv, i);
++		max_util = max(max_util, __cpu_util(i, delta));
++	}
+ 
+ 	return max_util;
+ }
+@@ -5374,31 +5405,36 @@ static unsigned long group_max_util(struct sched_group *sg)
+  * latter is used as the estimate as it leads to a more pessimistic energy
+  * estimate (more busy).
+  */
+-static unsigned long group_norm_util(struct sched_group *sg, int cap_idx)
++static unsigned
++long group_norm_util(struct energy_env *eenv, struct sched_group *sg)
+ {
+-	int i;
++	int i, delta;
+ 	unsigned long util_sum = 0;
+-	unsigned long capacity = sg->sge->cap_states[cap_idx].cap;
++	unsigned long capacity = sg->sge->cap_states[eenv->cap_idx].cap;
+ 
+-	for_each_cpu(i, sched_group_cpus(sg))
+-		util_sum += cpu_norm_util(i, capacity);
++	for_each_cpu(i, sched_group_cpus(sg)) {
++		delta = calc_util_delta(eenv, i);
++		util_sum += __cpu_norm_util(i, capacity, delta);
++	}
+ 
+ 	if (util_sum > SCHED_CAPACITY_SCALE)
+ 		return SCHED_CAPACITY_SCALE;
+ 	return util_sum;
+ }
+ 
+-static int find_new_capacity(struct sched_group *sg,
++static int find_new_capacity(struct energy_env *eenv,
+ 	const struct sched_group_energy const *sge)
+ {
+ 	int idx;
+-	unsigned long util = group_max_util(sg);
++	unsigned long util = group_max_util(eenv);
+ 
+ 	for (idx = 0; idx < sge->nr_cap_states; idx++) {
+ 		if (sge->cap_states[idx].cap >= util)
+-			return idx;
++			break;
+ 	}
+ 
++	eenv->cap_idx = idx;
++
+ 	return idx;
+ }
+ 
+@@ -5412,16 +5448,16 @@ static int find_new_capacity(struct sched_group *sg,
+  * This can probably be done in a faster but more complex way.
+  * Note: sched_group_energy() may fail when racing with sched_domain updates.
+  */
+-static int sched_group_energy(struct sched_group *sg_top)
++static int sched_group_energy(struct energy_env *eenv)
+ {
+ 	struct sched_domain *sd;
+ 	int cpu, total_energy = 0;
+ 	struct cpumask visit_cpus;
+ 	struct sched_group *sg;
+ 
+-	WARN_ON(!sg_top->sge);
++	WARN_ON(!eenv->sg_top->sge);
+ 
+-	cpumask_copy(&visit_cpus, sched_group_cpus(sg_top));
++	cpumask_copy(&visit_cpus, sched_group_cpus(eenv->sg_top));
+ 
+ 	while (!cpumask_empty(&visit_cpus)) {
+ 		struct sched_group *sg_shared_cap = NULL;
+@@ -5453,17 +5489,16 @@ static int sched_group_energy(struct sched_group *sg_top)
+ 				break;
+ 
+ 			do {
+-				struct sched_group *sg_cap_util;
+ 				unsigned long group_util;
+ 				int sg_busy_energy, sg_idle_energy, cap_idx;
+ 
+ 				if (sg_shared_cap && sg_shared_cap->group_weight >= sg->group_weight)
+-					sg_cap_util = sg_shared_cap;
++					eenv->sg_cap = sg_shared_cap;
+ 				else
+-					sg_cap_util = sg;
++					eenv->sg_cap = sg;
+ 
+-				cap_idx = find_new_capacity(sg_cap_util, sg->sge);
+-				group_util = group_norm_util(sg, cap_idx);
++				cap_idx = find_new_capacity(eenv, sg->sge);
++				group_util = group_norm_util(eenv, sg);
+ 				sg_busy_energy = (group_util * sg->sge->cap_states[cap_idx].power)
+ 										>> SCHED_CAPACITY_SHIFT;
+ 				sg_idle_energy = ((SCHED_CAPACITY_SCALE-group_util) * sg->sge->idle_states[0].power)
+@@ -5474,7 +5509,7 @@ static int sched_group_energy(struct sched_group *sg_top)
+ 				if (!sd->child)
+ 					cpumask_xor(&visit_cpus, &visit_cpus, sched_group_cpus(sg));
+ 
+-				if (cpumask_equal(sched_group_cpus(sg), sched_group_cpus(sg_top)))
++				if (cpumask_equal(sched_group_cpus(sg), sched_group_cpus(eenv->sg_top)))
+ 					goto next_cpu;
+ 
+ 			} while (sg = sg->next, sg != sd->groups);
+@@ -5483,7 +5518,8 @@ static int sched_group_energy(struct sched_group *sg_top)
+ 		continue;
+ 	}
+ 
+-	return total_energy;
++	eenv->energy = total_energy;
++	return 0;
+ }
+ 
+ /*
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0055-sched-Estimate-energy-impact-of-scheduling-decisions.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0055-sched-Estimate-energy-impact-of-scheduling-decisions.patch
new file mode 100644
index 0000000..f6fc44d
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0055-sched-Estimate-energy-impact-of-scheduling-decisions.patch
@@ -0,0 +1,84 @@
+From 9994534fcf8c013f6dfbb017055a3be2c8f48a0f Mon Sep 17 00:00:00 2001
+From: Morten Rasmussen <morten.rasmussen@arm.com>
+Date: Tue, 6 Jan 2015 17:34:05 +0000
+Subject: [PATCH 55/92] sched: Estimate energy impact of scheduling decisions
+
+Adds a generic energy-aware helper function, energy_diff(), that
+calculates energy impact of adding, removing, and migrating utilization
+in the system.
+
+cc: Ingo Molnar <mingo@redhat.com>
+cc: Peter Zijlstra <peterz@infradead.org>
+Signed-off-by: Morten Rasmussen <morten.rasmussen@arm.com>
+(cherry picked from commit 6f19a2b0b118f6551e22cf21c1230040a3c4f8a1)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ kernel/sched/fair.c | 52 ++++++++++++++++++++++++++++++++++++++++++++++++++++
+ 1 file changed, 52 insertions(+)
+
+diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
+index dcc73d8..dc1fca0 100644
+--- a/kernel/sched/fair.c
++++ b/kernel/sched/fair.c
+@@ -5522,6 +5522,58 @@ static int sched_group_energy(struct energy_env *eenv)
+ 	return 0;
+ }
+ 
++static inline bool cpu_in_sg(struct sched_group *sg, int cpu)
++{
++	return cpu != -1 && cpumask_test_cpu(cpu, sched_group_cpus(sg));
++}
++
++/*
++ * energy_diff(): Estimate the energy impact of changing the utilization
++ * distribution. eenv specifies the change: utilisation amount, source, and
++ * destination cpu. Source or destination cpu may be -1 in which case the
++ * utilization is removed from or added to the system (e.g. task wake-up). If
++ * both are specified, the utilization is migrated.
++ */
++static int energy_diff(struct energy_env *eenv)
++{
++	struct sched_domain *sd;
++	struct sched_group *sg;
++	int sd_cpu = -1, energy_before = 0, energy_after = 0;
++
++	struct energy_env eenv_before = {
++		.util_delta	= 0,
++		.src_cpu	= eenv->src_cpu,
++		.dst_cpu	= eenv->dst_cpu,
++	};
++
++	if (eenv->src_cpu == eenv->dst_cpu)
++		return 0;
++
++	sd_cpu = (eenv->src_cpu != -1) ? eenv->src_cpu : eenv->dst_cpu;
++	sd = rcu_dereference(per_cpu(sd_ea, sd_cpu));
++
++	if (!sd)
++		return 0; /* Error */
++
++	sg = sd->groups;
++
++	do {
++		if (cpu_in_sg(sg, eenv->src_cpu) || cpu_in_sg(sg, eenv->dst_cpu)) {
++			eenv_before.sg_top = eenv->sg_top = sg;
++
++			if (sched_group_energy(&eenv_before))
++				return 0; /* Invalid result abort */
++			energy_before += eenv_before.energy;
++
++			if (sched_group_energy(eenv))
++				return 0; /* Invalid result abort */
++			energy_after += eenv->energy;
++		}
++	} while (sg = sg->next, sg != sd->groups);
++
++	return energy_after-energy_before;
++}
++
+ /*
+  * Detect M:N waker/wakee relationships via a switching-frequency heuristic.
+  *
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0056-sched-cpuidle-Track-cpuidle-state-index-in-the-sched.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0056-sched-cpuidle-Track-cpuidle-state-index-in-the-sched.patch
new file mode 100644
index 0000000..db293ea
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0056-sched-cpuidle-Track-cpuidle-state-index-in-the-sched.patch
@@ -0,0 +1,124 @@
+From 1f3a3c308f275c6aeef63c5db216ae869db66dbc Mon Sep 17 00:00:00 2001
+From: Morten Rasmussen <morten.rasmussen@arm.com>
+Date: Tue, 27 Jan 2015 13:48:07 +0000
+Subject: [PATCH 56/92] sched, cpuidle: Track cpuidle state index in the
+ scheduler
+
+The idle-state of each cpu is currently pointed to by rq->idle_state but
+there isn't any information in the struct cpuidle_state that can used to
+look up the idle-state energy model data stored in struct
+sched_group_energy. For this purpose is necessary to store the idle
+state index as well. Ideally, the idle-state data should be unified.
+
+cc: Ingo Molnar <mingo@redhat.com>
+cc: Peter Zijlstra <peterz@infradead.org>
+Signed-off-by: Morten Rasmussen <morten.rasmussen@arm.com>
+(cherry picked from commit b3f2122ee08c05f9290f5d3664446bfb59b54691)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ drivers/cpuidle/cpuidle.c |  4 ++--
+ include/linux/cpuidle.h   |  2 +-
+ kernel/sched/idle.c       |  3 ++-
+ kernel/sched/sched.h      | 21 +++++++++++++++++++++
+ 4 files changed, 26 insertions(+), 4 deletions(-)
+
+diff --git a/drivers/cpuidle/cpuidle.c b/drivers/cpuidle/cpuidle.c
+index c73207a..78ab946 100644
+--- a/drivers/cpuidle/cpuidle.c
++++ b/drivers/cpuidle/cpuidle.c
+@@ -192,7 +192,7 @@ int cpuidle_enter_state(struct cpuidle_device *dev, struct cpuidle_driver *drv,
+ 	}
+ 
+ 	/* Take note of the planned idle state. */
+-	sched_idle_set_state(target_state);
++	sched_idle_set_state(target_state, index);
+ 
+ 	trace_cpu_idle_rcuidle(index, dev->cpu);
+ 	time_start = ns_to_ktime(local_clock());
+@@ -205,7 +205,7 @@ int cpuidle_enter_state(struct cpuidle_device *dev, struct cpuidle_driver *drv,
+ 	trace_cpu_idle_rcuidle(PWR_EVENT_EXIT, dev->cpu);
+ 
+ 	/* The cpu is no longer idle or about to enter idle. */
+-	sched_idle_set_state(NULL);
++	sched_idle_set_state(NULL, -1);
+ 
+ 	if (broadcast) {
+ 		if (WARN_ON_ONCE(!irqs_disabled()))
+diff --git a/include/linux/cpuidle.h b/include/linux/cpuidle.h
+index bb31373..9a8eec9 100644
+--- a/include/linux/cpuidle.h
++++ b/include/linux/cpuidle.h
+@@ -207,7 +207,7 @@ static inline int cpuidle_enter_freeze(struct cpuidle_driver *drv,
+ #endif
+ 
+ /* kernel/sched/idle.c */
+-extern void sched_idle_set_state(struct cpuidle_state *idle_state);
++extern void sched_idle_set_state(struct cpuidle_state *idle_state, int index);
+ extern void default_idle_call(void);
+ 
+ #ifdef CONFIG_ARCH_NEEDS_CPU_IDLE_COUPLED
+diff --git a/kernel/sched/idle.c b/kernel/sched/idle.c
+index 1d8718d..cf75f00 100644
+--- a/kernel/sched/idle.c
++++ b/kernel/sched/idle.c
+@@ -23,9 +23,10 @@
+  * sched_idle_set_state - Record idle state for the current CPU.
+  * @idle_state: State to record.
+  */
+-void sched_idle_set_state(struct cpuidle_state *idle_state)
++void sched_idle_set_state(struct cpuidle_state *idle_state, int index)
+ {
+ 	idle_set_state(this_rq(), idle_state);
++	idle_set_state_idx(this_rq(), index);
+ }
+ 
+ static int __read_mostly cpu_idle_force_poll;
+diff --git a/kernel/sched/sched.h b/kernel/sched/sched.h
+index 75dcd85..b24cefa 100644
+--- a/kernel/sched/sched.h
++++ b/kernel/sched/sched.h
+@@ -726,6 +726,7 @@ struct rq {
+ #ifdef CONFIG_CPU_IDLE
+ 	/* Must be inspected within a rcu lock section */
+ 	struct cpuidle_state *idle_state;
++	int idle_state_idx;
+ #endif
+ };
+ 
+@@ -1335,6 +1336,17 @@ static inline struct cpuidle_state *idle_get_state(struct rq *rq)
+ 	SCHED_WARN_ON(!rcu_read_lock_held());
+ 	return rq->idle_state;
+ }
++
++static inline void idle_set_state_idx(struct rq *rq, int idle_state_idx)
++{
++	rq->idle_state_idx = idle_state_idx;
++}
++
++static inline int idle_get_state_idx(struct rq *rq)
++{
++	WARN_ON(!rcu_read_lock_held());
++	return rq->idle_state_idx;
++}
+ #else
+ static inline void idle_set_state(struct rq *rq,
+ 				  struct cpuidle_state *idle_state)
+@@ -1345,6 +1357,15 @@ static inline struct cpuidle_state *idle_get_state(struct rq *rq)
+ {
+ 	return NULL;
+ }
++
++static inline void idle_set_state_idx(struct rq *rq, int idle_state_idx)
++{
++}
++
++static inline int idle_get_state_idx(struct rq *rq)
++{
++	return -1;
++}
+ #endif
+ 
+ extern void sysrq_sched_debug_show(void);
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0057-sched-Determine-the-current-sched_group-idle-state.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0057-sched-Determine-the-current-sched_group-idle-state.patch
new file mode 100644
index 0000000..e1eec60
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0057-sched-Determine-the-current-sched_group-idle-state.patch
@@ -0,0 +1,76 @@
+From ee2bf33dc8d406cab7a0827d63ad3e41dd41c96e Mon Sep 17 00:00:00 2001
+From: Dietmar Eggemann <dietmar.eggemann@arm.com>
+Date: Tue, 27 Jan 2015 14:04:17 +0000
+Subject: [PATCH 57/92] sched: Determine the current sched_group idle-state
+
+To estimate the energy consumption of a sched_group in
+sched_group_energy() it is necessary to know which idle-state the group
+is in when it is idle. For now, it is assumed that this is the current
+idle-state (though it might be wrong). Based on the individual cpu
+idle-states group_idle_state() finds the group idle-state.
+
+cc: Ingo Molnar <mingo@redhat.com>
+cc: Peter Zijlstra <peterz@infradead.org>
+Signed-off-by: Morten Rasmussen <morten.rasmussen@arm.com>
+Signed-off-by: Dietmar Eggemann <dietmar.eggemann@arm.com>
+(cherry picked from commit 2e5d2cd2670f7564bb38ec3984e3693da3f0470d)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ kernel/sched/fair.c | 25 +++++++++++++++++++++----
+ 1 file changed, 21 insertions(+), 4 deletions(-)
+
+diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
+index dc1fca0..799e2b5 100644
+--- a/kernel/sched/fair.c
++++ b/kernel/sched/fair.c
+@@ -5438,6 +5438,20 @@ static int find_new_capacity(struct energy_env *eenv,
+ 	return idx;
+ }
+ 
++static int group_idle_state(struct sched_group *sg)
++{
++	int i, state = INT_MAX;
++
++	/* Find the shallowest idle state in the sched group. */
++	for_each_cpu(i, sched_group_cpus(sg))
++		state = min(state, idle_get_state_idx(cpu_rq(i)));
++
++	/* Take non-cpuidle idling into account (active idle/arch_cpu_idle()) */
++	state++;
++
++	return state;
++}
++
+ /*
+  * sched_group_energy(): Computes the absolute energy consumption of cpus
+  * belonging to the sched_group including shared resources shared only by
+@@ -5490,7 +5504,8 @@ static int sched_group_energy(struct energy_env *eenv)
+ 
+ 			do {
+ 				unsigned long group_util;
+-				int sg_busy_energy, sg_idle_energy, cap_idx;
++				int sg_busy_energy, sg_idle_energy;
++				int cap_idx, idle_idx;
+ 
+ 				if (sg_shared_cap && sg_shared_cap->group_weight >= sg->group_weight)
+ 					eenv->sg_cap = sg_shared_cap;
+@@ -5498,11 +5513,13 @@ static int sched_group_energy(struct energy_env *eenv)
+ 					eenv->sg_cap = sg;
+ 
+ 				cap_idx = find_new_capacity(eenv, sg->sge);
++				idle_idx = group_idle_state(sg);
+ 				group_util = group_norm_util(eenv, sg);
+ 				sg_busy_energy = (group_util * sg->sge->cap_states[cap_idx].power)
+-										>> SCHED_CAPACITY_SHIFT;
+-				sg_idle_energy = ((SCHED_CAPACITY_SCALE-group_util) * sg->sge->idle_states[0].power)
+-										>> SCHED_CAPACITY_SHIFT;
++								>> SCHED_CAPACITY_SHIFT;
++				sg_idle_energy = ((SCHED_CAPACITY_SCALE-group_util)
++								* sg->sge->idle_states[idle_idx].power)
++								>> SCHED_CAPACITY_SHIFT;
+ 
+ 				total_energy += sg_busy_energy + sg_idle_energy;
+ 
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0058-sched-fair-Add-energy_diff-dead-zone-margin.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0058-sched-fair-Add-energy_diff-dead-zone-margin.patch
new file mode 100644
index 0000000..163fb7c
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0058-sched-fair-Add-energy_diff-dead-zone-margin.patch
@@ -0,0 +1,53 @@
+From 91820aa3145f93421c29834315616f338b4fcca2 Mon Sep 17 00:00:00 2001
+From: Morten Rasmussen <morten.rasmussen@arm.com>
+Date: Wed, 30 Mar 2016 14:20:12 +0100
+Subject: [PATCH 58/92] sched/fair: Add energy_diff dead-zone margin
+
+It is not worth the overhead to migrate tasks for tiny insignificant
+energy savings. To prevent this, an energy margin is introduced in
+energy_diff() which effectively adds a dead-zone that rounds tiny energy
+differences to zero. Since no scale is enforced for energy model data
+the margin can't be absolute. Instead it is defined as +/-1.56% energy
+saving compared to the current total estimated energy consumption.
+
+(cherry picked from commit c36ecf27db72f60934ce2c9ca7e3d97a80926c1c)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ kernel/sched/fair.c | 14 +++++++++++++-
+ 1 file changed, 13 insertions(+), 1 deletion(-)
+
+diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
+index 799e2b5..5e13787 100644
+--- a/kernel/sched/fair.c
++++ b/kernel/sched/fair.c
+@@ -5556,6 +5556,7 @@ static int energy_diff(struct energy_env *eenv)
+ 	struct sched_domain *sd;
+ 	struct sched_group *sg;
+ 	int sd_cpu = -1, energy_before = 0, energy_after = 0;
++	int diff, margin;
+ 
+ 	struct energy_env eenv_before = {
+ 		.util_delta	= 0,
+@@ -5588,7 +5589,18 @@ static int energy_diff(struct energy_env *eenv)
+ 		}
+ 	} while (sg = sg->next, sg != sd->groups);
+ 
+-	return energy_after-energy_before;
++	/*
++	 * Dead-zone margin preventing too many migrations.
++	 */
++
++	margin = energy_before >> 6; /* ~1.56% */
++
++	diff = energy_after-energy_before;
++
++	if (abs(diff) < margin)
++		return 0;
++
++	return diff;
+ }
+ 
+ /*
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0059-sched-Add-over-utilization-tipping-point-indicator.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0059-sched-Add-over-utilization-tipping-point-indicator.patch
new file mode 100644
index 0000000..d2d4d1a
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0059-sched-Add-over-utilization-tipping-point-indicator.patch
@@ -0,0 +1,187 @@
+From 237ff0550a99ada0cffde12845e13e52e69143a1 Mon Sep 17 00:00:00 2001
+From: Morten Rasmussen <morten.rasmussen@arm.com>
+Date: Sat, 9 May 2015 16:49:57 +0100
+Subject: [PATCH 59/92] sched: Add over-utilization/tipping point indicator
+
+Energy-aware scheduling is only meant to be active while the system is
+_not_ over-utilized. That is, there are spare cycles available to shift
+tasks around based on their actual utilization to get a more
+energy-efficient task distribution without depriving any tasks. When
+above the tipping point task placement is done the traditional way based
+on load_avg, spreading the tasks across as many cpus as possible based
+on priority scaled load to preserve smp_nice. Below the tipping point we
+want to use util_avg instead. We need to define a criteria for when we
+make the switch.
+
+The util_avg for each cpu converges towards 100% (1024) regardless of
+how many task additional task we may put on it. If we define
+over-utilized as:
+
+sum_{cpus}(rq.cfs.avg.util_avg) + margin > sum_{cpus}(rq.capacity)
+
+some individual cpus may be over-utilized running multiple tasks even
+when the above condition is false. That should be okay as long as we try
+to spread the tasks out to avoid per-cpu over-utilization as much as
+possible and if all tasks have the _same_ priority. If the latter isn't
+true, we have to consider priority to preserve smp_nice.
+
+For example, we could have n_cpus nice=-10 util_avg=55% tasks and
+n_cpus/2 nice=0 util_avg=60% tasks. Balancing based on util_avg we are
+likely to end up with nice=-10 tasks sharing cpus and nice=0 tasks
+getting their own as we 1.5*n_cpus tasks in total and 55%+55% is less
+over-utilized than 55%+60% for those cpus that have to be shared. The
+system utilization is only 85% of the system capacity, but we are
+breaking smp_nice.
+
+To be sure not to break smp_nice, we have defined over-utilization
+conservatively as when any cpu in the system is fully utilized at it's
+highest frequency instead:
+
+cpu_rq(any).cfs.avg.util_avg + margin > cpu_rq(any).capacity
+
+IOW, as soon as one cpu is (nearly) 100% utilized, we switch to load_avg
+to factor in priority to preserve smp_nice.
+
+With this definition, we can skip periodic load-balance as no cpu has an
+always-running task when the system is not over-utilized. All tasks will
+be periodic and we can balance them at wake-up. This conservative
+condition does however mean that some scenarios that could benefit from
+energy-aware decisions even if one cpu is fully utilized would not get
+those benefits.
+
+For system where some cpus might have reduced capacity on some cpus
+(RT-pressure and/or big.LITTLE), we want periodic load-balance checks as
+soon a just a single cpu is fully utilized as it might one of those with
+reduced capacity and in that case we want to migrate it.
+
+cc: Ingo Molnar <mingo@redhat.com>
+cc: Peter Zijlstra <peterz@infradead.org>
+Signed-off-by: Morten Rasmussen <morten.rasmussen@arm.com>
+(cherry picked from commit e402a7e2f2a45377f32b2925197a747f04ca1668)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ kernel/sched/fair.c  | 31 +++++++++++++++++++++++++------
+ kernel/sched/sched.h |  3 +++
+ 2 files changed, 28 insertions(+), 6 deletions(-)
+
+diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
+index 5e13787..db732bd 100644
+--- a/kernel/sched/fair.c
++++ b/kernel/sched/fair.c
+@@ -4715,6 +4715,8 @@ static inline void hrtick_update(struct rq *rq)
+ }
+ #endif
+ 
++static bool cpu_overutilized(int cpu);
++
+ /*
+  * The enqueue_task method is called before nr_running is
+  * increased. Here we update the fair scheduling stats and
+@@ -4725,6 +4727,7 @@ static inline void hrtick_update(struct rq *rq)
+ {
+ 	struct cfs_rq *cfs_rq;
+ 	struct sched_entity *se = &p->se;
++	int task_new = !(flags & ENQUEUE_WAKEUP);
+ 
+ 	/*
+ 	 * If in_iowait is set, the code below may not trigger any cpufreq
+@@ -4764,9 +4767,12 @@ static inline void hrtick_update(struct rq *rq)
+ 		update_cfs_shares(cfs_rq);
+ 	}
+ 
+-	if (!se)
++	if (!se) {
+ 		add_nr_running(rq, 1);
+-
++		if (!task_new && !rq->rd->overutilized &&
++		    cpu_overutilized(rq->cpu))
++			rq->rd->overutilized = true;
++	}
+ 	hrtick_update(rq);
+ }
+ 
+@@ -7578,11 +7584,12 @@ group_type group_classify(struct sched_group *group,
+  * @local_group: Does group contain this_cpu.
+  * @sgs: variable to hold the statistics for this group.
+  * @overload: Indicate more than one runnable task for any CPU.
++ * @overutilized: Indicate overutilization for any CPU.
+  */
+ static inline void update_sg_lb_stats(struct lb_env *env,
+ 			struct sched_group *group, int load_idx,
+ 			int local_group, struct sg_lb_stats *sgs,
+-			bool *overload)
++			bool *overload, bool *overutilized)
+ {
+ 	unsigned long load;
+ 	int i, nr_running;
+@@ -7616,6 +7623,9 @@ static inline void update_sg_lb_stats(struct lb_env *env,
+ 		 */
+ 		if (!nr_running && idle_cpu(i))
+ 			sgs->idle_cpus++;
++
++		if (cpu_overutilized(i))
++			*overutilized = true;
+ 	}
+ 
+ 	/* Adjust by relative CPU capacity of the group */
+@@ -7744,7 +7754,7 @@ static inline void update_sd_lb_stats(struct lb_env *env, struct sd_lb_stats *sd
+ 	struct sched_group *sg = env->sd->groups;
+ 	struct sg_lb_stats tmp_sgs;
+ 	int load_idx, prefer_sibling = 0;
+-	bool overload = false;
++	bool overload = false, overutilized = false;
+ 
+ 	if (child && child->flags & SD_PREFER_SIBLING)
+ 		prefer_sibling = 1;
+@@ -7766,7 +7776,7 @@ static inline void update_sd_lb_stats(struct lb_env *env, struct sd_lb_stats *sd
+ 		}
+ 
+ 		update_sg_lb_stats(env, sg, load_idx, local_group, sgs,
+-						&overload);
++						&overload, &overutilized);
+ 
+ 		if (local_group)
+ 			goto next_group;
+@@ -7810,8 +7820,14 @@ static inline void update_sd_lb_stats(struct lb_env *env, struct sd_lb_stats *sd
+ 		/* update overload indicator if we are at root domain */
+ 		if (env->dst_rq->rd->overload != overload)
+ 			env->dst_rq->rd->overload = overload;
+-	}
+ 
++		/* Update over-utilization (tipping point, U >= 0) indicator */
++		if (env->dst_rq->rd->overutilized != overutilized)
++			env->dst_rq->rd->overutilized = overutilized;
++	} else {
++		if (!env->dst_rq->rd->overutilized && overutilized)
++			env->dst_rq->rd->overutilized = true;
++	}
+ }
+ 
+ /**
+@@ -9192,6 +9208,9 @@ static void task_tick_fair(struct rq *rq, struct task_struct *curr, int queued)
+ 
+ 	if (static_branch_unlikely(&sched_numa_balancing))
+ 		task_tick_numa(rq, curr);
++
++	if (!rq->rd->overutilized && cpu_overutilized(task_cpu(curr)))
++		rq->rd->overutilized = true;
+ }
+ 
+ /*
+diff --git a/kernel/sched/sched.h b/kernel/sched/sched.h
+index b24cefa..fa98ab3 100644
+--- a/kernel/sched/sched.h
++++ b/kernel/sched/sched.h
+@@ -563,6 +563,9 @@ struct root_domain {
+ 	/* Indicate more than one runnable task for any CPU */
+ 	bool overload;
+ 
++	/* Indicate one or more cpus over-utilized (tipping point) */
++	bool overutilized;
++
+ 	/*
+ 	 * The bit corresponding to a CPU gets set here if such CPU has more
+ 	 * than one runnable -deadline task (as it is below for RT tasks).
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0060-sched-fair-Energy-aware-wake-up-task-placement.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0060-sched-fair-Energy-aware-wake-up-task-placement.patch
new file mode 100644
index 0000000..d85d6fe
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0060-sched-fair-Energy-aware-wake-up-task-placement.patch
@@ -0,0 +1,104 @@
+From b0ba3376b094bcf111551ee7c5e14183fe15da79 Mon Sep 17 00:00:00 2001
+From: Morten Rasmussen <morten.rasmussen@arm.com>
+Date: Wed, 30 Mar 2016 14:29:48 +0100
+Subject: [PATCH 60/92] sched/fair: Energy-aware wake-up task placement
+
+When the systems is not overutilized, place waking tasks on the most
+energy efficient cpu. Previous attempts reduced the search space by
+matching task utilization to cpu capacity before consulting the energy
+model as this is an expensive operation. The search heuristics didn't
+work very well and lacking any better alternatives this patch takes the
+brute-force route and tries all potential targets.
+
+This approach doesn't scale, but it might be sufficient for many
+embedded applications while work is continuing on a heuristic that can
+minimize the necessary computations. The heuristic must be derrived from
+the platform energy model rather than make additional assumptions, such
+lower capacity implies better energy efficiency. PeterZ mentioned in the
+past that we might be able to derrive some simpler deciding functions
+using mathematical (modal?) analysis.
+
+Signed-off-by: Morten Rasmussen <morten.rasmussen@arm.com>
+(cherry picked from commit 8491fd68555c31e596e1888912796184d42138cc)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ kernel/sched/fair.c | 56 +++++++++++++++++++++++++++++++++++++++++++++++++++++
+ 1 file changed, 56 insertions(+)
+
+diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
+index db732bd..58b468c 100644
+--- a/kernel/sched/fair.c
++++ b/kernel/sched/fair.c
+@@ -6148,6 +6148,59 @@ static bool cpu_overutilized(int cpu)
+ 	return (capacity_of(cpu) * 1024) < (cpu_util(cpu) * capacity_margin);
+ }
+ 
++static int select_energy_cpu_brute(struct task_struct *p, int prev_cpu)
++{
++	int i;
++	int min_diff = 0, energy_cpu = prev_cpu, spare_cpu = prev_cpu;
++	unsigned long max_spare = 0;
++	struct sched_domain *sd;
++
++	rcu_read_lock();
++
++	sd = rcu_dereference(per_cpu(sd_ea, prev_cpu));
++
++	if (!sd)
++		return prev_cpu;
++
++	for_each_cpu_and(i, tsk_cpus_allowed(p), sched_domain_span(sd)) {
++		int diff;
++		unsigned long spare;
++
++		struct energy_env eenv = {
++			.util_delta	= task_util(p),
++			.src_cpu	= prev_cpu,
++			.dst_cpu	= i,
++		};
++
++		spare = capacity_spare_wake(i, p);
++
++		if (i == prev_cpu)
++			continue;
++
++		if (spare > max_spare) {
++			max_spare = spare;
++			spare_cpu = i;
++		}
++
++		if (spare * 1024 < capacity_margin * task_util(p))
++			continue;
++
++		diff = energy_diff(&eenv);
++
++		if (diff < min_diff) {
++			min_diff = diff;
++			energy_cpu = i;
++		}
++	}
++
++	rcu_read_unlock();
++
++	if (energy_cpu == prev_cpu && !cpu_overutilized(prev_cpu))
++		return prev_cpu;
++
++	return energy_cpu != prev_cpu ? energy_cpu : spare_cpu;
++}
++
+ /*
+  * select_task_rq_fair: Select target runqueue for the waking task in domains
+  * that have the 'sd_flag' flag set. In practice, this is SD_BALANCE_WAKE,
+@@ -6175,6 +6228,9 @@ static bool cpu_overutilized(int cpu)
+ 			      && cpumask_test_cpu(cpu, tsk_cpus_allowed(p));
+ 	}
+ 
++	if (energy_aware() && !(cpu_rq(prev_cpu)->rd->overutilized))
++		return select_energy_cpu_brute(p, prev_cpu);
++
+ 	rcu_read_lock();
+ 	for_each_domain(cpu, tmp) {
+ 		if (!(tmp->flags & SD_LOAD_BALANCE))
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0061-sched-fair-Fix-select_task_rq_brute-rcu_unlock-when-.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0061-sched-fair-Fix-select_task_rq_brute-rcu_unlock-when-.patch
new file mode 100644
index 0000000..4756f31
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0061-sched-fair-Fix-select_task_rq_brute-rcu_unlock-when-.patch
@@ -0,0 +1,38 @@
+From f4e82adc562197bc0c6411d9db0ad4497bb689a5 Mon Sep 17 00:00:00 2001
+From: Morten Rasmussen <morten.rasmussen@arm.com>
+Date: Thu, 14 Apr 2016 08:39:45 +0100
+Subject: [PATCH 61/92] sched/fair: Fix select_task_rq_brute rcu_unlock when
+ !sd
+
+To be merged with original patch
+
+(cherry picked from commit 149b57aaecf04f0e14a2d0cef807f0c499c6d6ba)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ kernel/sched/fair.c | 3 ++-
+ 1 file changed, 2 insertions(+), 1 deletion(-)
+
+diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
+index 58b468c..3c193f5 100644
+--- a/kernel/sched/fair.c
++++ b/kernel/sched/fair.c
+@@ -6160,7 +6160,7 @@ static int select_energy_cpu_brute(struct task_struct *p, int prev_cpu)
+ 	sd = rcu_dereference(per_cpu(sd_ea, prev_cpu));
+ 
+ 	if (!sd)
+-		return prev_cpu;
++		goto unlock;
+ 
+ 	for_each_cpu_and(i, tsk_cpus_allowed(p), sched_domain_span(sd)) {
+ 		int diff;
+@@ -6193,6 +6193,7 @@ static int select_energy_cpu_brute(struct task_struct *p, int prev_cpu)
+ 		}
+ 	}
+ 
++unlock:
+ 	rcu_read_unlock();
+ 
+ 	if (energy_cpu == prev_cpu && !cpu_overutilized(prev_cpu))
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0062-sched-Consider-a-not-over-utilized-energy-aware-syst.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0062-sched-Consider-a-not-over-utilized-energy-aware-syst.patch
new file mode 100644
index 0000000..70ac245
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0062-sched-Consider-a-not-over-utilized-energy-aware-syst.patch
@@ -0,0 +1,49 @@
+From f02fa9f5a150721451b41d9677f9c5f5710c09a9 Mon Sep 17 00:00:00 2001
+From: Dietmar Eggemann <dietmar.eggemann@arm.com>
+Date: Sun, 10 May 2015 15:17:32 +0100
+Subject: [PATCH 62/92] sched: Consider a not over-utilized energy-aware system
+ as balanced
+
+In case the system operates below the tipping point indicator,
+introduced in ("sched: Add over-utilization/tipping point
+indicator"), bail out in find_busiest_group after the dst and src
+group statistics have been checked.
+
+There is simply no need to move usage around because all involved
+cpus still have spare cycles available.
+
+For an energy-aware system below its tipping point,  we rely on the
+task placement of the wakeup path. This works well for short running
+tasks.
+
+The existence of long running tasks on one of the involved cpus lets
+the system operate over its tipping point. To be able to move such
+a task (whose load can't be used to average the load among the cpus)
+from a src cpu with lower capacity than the dst_cpu, an additional
+rule has to be implemented in need_active_balance.
+
+Signed-off-by: Dietmar Eggemann <dietmar.eggemann@arm.com>
+(cherry picked from commit e604c981fa91a5e5522cd4a5a057880ab54d374c)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ kernel/sched/fair.c | 4 ++++
+ 1 file changed, 4 insertions(+)
+
+diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
+index 3c193f5..360e922 100644
+--- a/kernel/sched/fair.c
++++ b/kernel/sched/fair.c
+@@ -8103,6 +8103,10 @@ static struct sched_group *find_busiest_group(struct lb_env *env)
+ 	 * this level.
+ 	 */
+ 	update_sd_lb_stats(env, &sds);
++
++	if (energy_aware() && !env->dst_rq->rd->overutilized)
++		goto out_balanced;
++
+ 	local = &sds.local_stat;
+ 	busiest = &sds.busiest_stat;
+ 
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0063-sched-Disable-energy-unfriendly-nohz-kicks.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0063-sched-Disable-energy-unfriendly-nohz-kicks.patch
new file mode 100644
index 0000000..8e96e3f
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0063-sched-Disable-energy-unfriendly-nohz-kicks.patch
@@ -0,0 +1,43 @@
+From 64537223eb2a922fd872741df1a82b1bee325f3e Mon Sep 17 00:00:00 2001
+From: Morten Rasmussen <morten.rasmussen@arm.com>
+Date: Tue, 3 Feb 2015 13:54:11 +0000
+Subject: [PATCH 63/92] sched: Disable energy-unfriendly nohz kicks
+
+With energy-aware scheduling enabled nohz_kick_needed() generates many
+nohz idle-balance kicks which lead to nothing when multiple tasks get
+packed on a single cpu to save energy. This causes unnecessary wake-ups
+and hence wastes energy. Make these conditions depend on !energy_aware()
+for now until the energy-aware nohz story gets sorted out.
+
+cc: Ingo Molnar <mingo@redhat.com>
+cc: Peter Zijlstra <peterz@infradead.org>
+Signed-off-by: Morten Rasmussen <morten.rasmussen@arm.com>
+(cherry picked from commit a5268e57a1b257dee1ffa9cd9d670ee747a4ec88)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ kernel/sched/fair.c | 5 +++--
+ 1 file changed, 3 insertions(+), 2 deletions(-)
+
+diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
+index 360e922..bc347af 100644
+--- a/kernel/sched/fair.c
++++ b/kernel/sched/fair.c
+@@ -9150,12 +9150,13 @@ static inline bool nohz_kick_needed(struct rq *rq)
+ 	if (time_before(now, nohz.next_balance))
+ 		return false;
+ 
+-	if (rq->nr_running >= 2)
++	if (rq->nr_running >= 2 &&
++	    (!energy_aware() || cpu_overutilized(cpu)))
+ 		return true;
+ 
+ 	rcu_read_lock();
+ 	sds = rcu_dereference(per_cpu(sd_llc_shared, cpu));
+-	if (sds) {
++	if (sds && !energy_aware()) {
+ 		/*
+ 		 * XXX: write a coherent comment on why we do this.
+ 		 * See also: http://lkml.kernel.org/r/20111202010832.602203411@sbsiddha-desk.sc.intel.com
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0064-arm-Set-SD_SHARE_CAP_STATES-sched_domain-flag-when-a.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0064-arm-Set-SD_SHARE_CAP_STATES-sched_domain-flag-when-a.patch
new file mode 100644
index 0000000..aa3fe22
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0064-arm-Set-SD_SHARE_CAP_STATES-sched_domain-flag-when-a.patch
@@ -0,0 +1,104 @@
+From b1238cc2a12dba910ff1f6af592196a2743bf594 Mon Sep 17 00:00:00 2001
+From: Morten Rasmussen <morten.rasmussen@arm.com>
+Date: Fri, 12 Aug 2016 11:29:04 +0100
+Subject: [PATCH 64/92] arm: Set SD_SHARE_CAP_STATES sched_domain flag when
+ applicable
+
+Energy-aware scheduling relies on the SD_SHARE_CAP_STATES to identify
+sharing the same clock source/frequency domain. The assumption is that a
+sched_domain exists that match the clock/frequency domain, i.e.
+policy->related_cpus in cpufreq terms. The flag is not set for systems
+without frequency scaling or systems with per-cpu frequency scaling.
+
+cc: Russell King <linux@armlinux.org.uk>
+
+Signed-off-by: Morten Rasmussen <morten.rasmussen@arm.com>
+(cherry picked from commit cca07e1a18915b6990c1cf464686bcb24d4d1472)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ arch/arm/kernel/topology.c | 33 ++++++++++++++++++++++++++++++---
+ 1 file changed, 30 insertions(+), 3 deletions(-)
+
+diff --git a/arch/arm/kernel/topology.c b/arch/arm/kernel/topology.c
+index 4d94639..c77f39f 100644
+--- a/arch/arm/kernel/topology.c
++++ b/arch/arm/kernel/topology.c
+@@ -45,6 +45,7 @@
+ static DEFINE_PER_CPU(unsigned long, cpu_scale) = SCHED_CAPACITY_SCALE;
+ static DEFINE_MUTEX(cpu_scale_mutex);
+ static bool asym_cpucap;
++static bool sd_mc_share_cap, sd_die_share_cap;
+ static bool update_flags;
+ 
+ unsigned long scale_cpu_capacity(struct sched_domain *sd, int cpu)
+@@ -268,6 +269,14 @@ static void normalize_cpu_capacity(void)
+ 		pr_debug("cpu_capacity: calling %s for CPUs [%*pbl] (to_visit=%*pbl)\n",
+ 			 __func__, cpumask_pr_args(policy->related_cpus),
+ 			 cpumask_pr_args(cpus_to_visit));
++
++		cpu = cpumask_first(policy->related_cpus);
++
++		if (cpumask_subset(cpu_coregroup_mask(cpu), policy->related_cpus))
++			sd_mc_share_cap = true;
++		else if (cpumask_subset(cpu_cpu_mask(cpu), policy->related_cpus))
++			sd_die_share_cap = true;
++
+ 		cpumask_andnot(cpus_to_visit,
+ 			       cpus_to_visit,
+ 			       policy->related_cpus);
+@@ -279,11 +288,13 @@ static void normalize_cpu_capacity(void)
+ 					    policy->cpuinfo.max_freq / 1000UL;
+ 			capacity_scale = max(raw_capacity[cpu], capacity_scale);
+ 		}
++
+ 		if (cpumask_empty(cpus_to_visit)) {
+ 			if (!cap_parsing_failed) {
+ 				asym = asym_cpucap;
+ 				normalize_cpu_capacity();
+-				if (asym != asym_cpucap)
++				if (asym != asym_cpucap ||
++				    sd_mc_share_cap || sd_die_share_cap)
+ 					update_sched_flags();
+ 				kfree(raw_capacity);
+ 				pr_debug("cpu_capacity: parsing done");
+@@ -477,6 +488,9 @@ static void update_cpu_capacity(unsigned int cpu)
+ 	if (scale_cpu_capacity(NULL, cpu) < SCHED_CAPACITY_SCALE)
+ 		asym_cpucap = true;
+ 
++	if (scale_cpu_capacity(NULL, cpu) < SCHED_CAPACITY_SCALE)
++		asym_cpucap = true;
++
+ 	pr_info("CPU%u: update cpu_capacity %lu\n",
+ 		cpu, arch_scale_cpu_capacity(NULL, cpu));
+ }
+@@ -594,12 +608,25 @@ void store_cpu_topology(unsigned int cpuid)
+ 
+ static inline int cpu_corepower_flags(void)
+ {
+-	return SD_SHARE_PKG_RESOURCES  | SD_SHARE_POWERDOMAIN;
++	int mc_flags = SD_SHARE_PKG_RESOURCES | SD_SHARE_POWERDOMAIN;
++
++	if (sd_mc_share_cap)
++		mc_flags |= SD_SHARE_CAP_STATES;
++
++	return mc_flags;
+ }
+ 
+ static inline int arm_cpu_cpu_flags(void)
+ {
+-	return asym_cpucap ? SD_ASYM_CPUCAPACITY : 0;
++	int die_flags = 0;
++
++	if (asym_cpucap)
++		die_flags |= SD_ASYM_CPUCAPACITY;
++
++	if (sd_die_share_cap)
++		die_flags |= SD_SHARE_CAP_STATES;
++
++	return die_flags;
+ }
+ 
+ static struct sched_domain_topology_level arm_topology[] = {
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0065-arm64-Set-SD_SHARE_CAP_STATES-sched_domain-flag-when.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0065-arm64-Set-SD_SHARE_CAP_STATES-sched_domain-flag-when.patch
new file mode 100644
index 0000000..aac955a
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0065-arm64-Set-SD_SHARE_CAP_STATES-sched_domain-flag-when.patch
@@ -0,0 +1,98 @@
+From 2a8f391ef5bb8d5c68b731743dd1f2b9f1fb0d46 Mon Sep 17 00:00:00 2001
+From: Morten Rasmussen <morten.rasmussen@arm.com>
+Date: Fri, 12 Aug 2016 10:53:13 +0100
+Subject: [PATCH 65/92] arm64: Set SD_SHARE_CAP_STATES sched_domain flag when
+ applicable
+
+Energy-aware scheduling relies on the SD_SHARE_CAP_STATES to identify
+sharing the same clock source/frequency domain. The assumption is that a
+sched_domain exists that match the clock/frequency domain, i.e.
+policy->related_cpus in cpufreq terms. The flag is not set for systems
+without frequency scaling or systems with per-cpu frequency scaling.
+
+cc: Catalin Marinas <catalin.marinas@arm.com>
+cc: Will Deacon <will.deacon@arm.com>
+
+Signed-off-by: Morten Rasmussen <morten.rasmussen@arm.com>
+(cherry picked from commit 2c36006aa6a75c35269d26b08f2e86bad68d72bd)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ arch/arm64/kernel/topology.c | 34 +++++++++++++++++++++++++++++++---
+ 1 file changed, 31 insertions(+), 3 deletions(-)
+
+diff --git a/arch/arm64/kernel/topology.c b/arch/arm64/kernel/topology.c
+index eb2ad75..a8d986e 100644
+--- a/arch/arm64/kernel/topology.c
++++ b/arch/arm64/kernel/topology.c
+@@ -29,6 +29,7 @@
+ static DEFINE_PER_CPU(unsigned long, cpu_scale) = SCHED_CAPACITY_SCALE;
+ static DEFINE_MUTEX(cpu_scale_mutex);
+ static bool asym_cpucap;
++static bool sd_mc_share_cap, sd_die_share_cap;
+ static bool update_flags;
+ 
+ unsigned long scale_cpu_capacity(struct sched_domain *sd, int cpu)
+@@ -224,6 +225,14 @@ static void normalize_cpu_capacity(void)
+ 		pr_debug("cpu_capacity: calling %s for CPUs [%*pbl] (to_visit=[%*pbl])\n",
+ 			 __func__, cpumask_pr_args(policy->related_cpus),
+ 			 cpumask_pr_args(cpus_to_visit));
++
++		cpu = cpumask_first(policy->related_cpus);
++
++		if (cpumask_subset(cpu_coregroup_mask(cpu), policy->related_cpus))
++			sd_mc_share_cap = true;
++		else if (cpumask_subset(cpu_cpu_mask(cpu), policy->related_cpus))
++			sd_die_share_cap = true;
++
+ 		cpumask_andnot(cpus_to_visit,
+ 			       cpus_to_visit,
+ 			       policy->related_cpus);
+@@ -239,7 +248,8 @@ static void normalize_cpu_capacity(void)
+ 			if (!cap_parsing_failed) {
+ 				asym = asym_cpucap;
+ 				normalize_cpu_capacity();
+-				if (asym != asym_cpucap)
++				if (asym != asym_cpucap ||
++				    sd_mc_share_cap || sd_die_share_cap)
+ 					update_sched_flags();
+ 				kfree(raw_capacity);
+ 				pr_debug("cpu_capacity: parsing done\n");
+@@ -522,7 +532,25 @@ const struct cpumask *cpu_coregroup_mask(int cpu)
+ 
+ static int cpu_cpu_flags(void)
+ {
+-	return asym_cpucap ? SD_ASYM_CPUCAPACITY : 0;
++	int die_flags = 0;
++
++	if (asym_cpucap)
++		die_flags |= SD_ASYM_CPUCAPACITY;
++
++	if (sd_die_share_cap)
++		die_flags |= SD_SHARE_CAP_STATES;
++
++	return die_flags;
++}
++
++static int cpu_coregroup_flags(void)
++{
++	int mc_flags = SD_SHARE_PKG_RESOURCES;
++
++	if (sd_mc_share_cap)
++		mc_flags |= SD_SHARE_CAP_STATES;
++
++	return mc_flags;
+ }
+ 
+ static void update_siblings_masks(unsigned int cpuid)
+@@ -608,7 +636,7 @@ static void __init reset_cpu_topology(void)
+ 
+ static struct sched_domain_topology_level arm64_topology[] = {
+ #ifdef CONFIG_SCHED_MC
+-	{ cpu_coregroup_mask, cpu_core_flags, SD_INIT_NAME(MC) },
++	{ cpu_coregroup_mask, cpu_coregroup_flags, SD_INIT_NAME(MC) },
+ #endif
+ 	{ cpu_cpu_mask, cpu_cpu_flags, SD_INIT_NAME(DIE) },
+ 	{ NULL, }
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0066-arm-topology-Define-TC2-energy-and-provide-it-to-the.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0066-arm-topology-Define-TC2-energy-and-provide-it-to-the.patch
new file mode 100644
index 0000000..8f7e877
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0066-arm-topology-Define-TC2-energy-and-provide-it-to-the.patch
@@ -0,0 +1,180 @@
+From 709f084599231a964047d3af46465428b2b2f56a Mon Sep 17 00:00:00 2001
+From: Dietmar Eggemann <dietmar.eggemann@arm.com>
+Date: Fri, 14 Nov 2014 17:16:41 +0000
+Subject: [PATCH 66/92] arm: topology: Define TC2 energy and provide it to the
+ scheduler
+
+This patch is only here to be able to test provisioning of energy related
+data from an arch topology shim layer to the scheduler. Since there is no
+code today which deals with extracting energy related data from the dtb or
+acpi, and process it in the topology shim layer, the content of the
+sched_group_energy structures as well as the idle_state and capacity_state
+arrays are hard-coded here.
+
+This patch defines the sched_group_energy structure as well as the
+idle_state and capacity_state array for the cluster (relates to sched
+groups (sgs) in DIE sched domain level) and for the core (relates to sgs
+in MC sd level) for a Cortex A7 as well as for a Cortex A15.
+It further provides related implementations of the sched_domain_energy_f
+functions (cpu_cluster_energy() and cpu_core_energy()).
+
+To be able to propagate this information from the topology shim layer to
+the scheduler, the elements of the arm_topology[] table have been
+provisioned with the appropriate sched_domain_energy_f functions.
+
+cc: Russell King <linux@arm.linux.org.uk>
+Signed-off-by: Dietmar Eggemann <dietmar.eggemann@arm.com>
+(cherry picked from commit 28ef5dd535285f5edcc4892496925156f453c636)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ arch/arm/kernel/topology.c | 126 +++++++++++++++++++++++++++++++++++++++++++--
+ 1 file changed, 123 insertions(+), 3 deletions(-)
+
+diff --git a/arch/arm/kernel/topology.c b/arch/arm/kernel/topology.c
+index c77f39f..08c4749 100644
+--- a/arch/arm/kernel/topology.c
++++ b/arch/arm/kernel/topology.c
+@@ -606,6 +606,127 @@ void store_cpu_topology(unsigned int cpuid)
+ 		cpu_topology[cpuid].socket_id, mpidr);
+ }
+ 
++/*
++ * ARM TC2 specific energy cost model data. There are no unit requirements for
++ * the data. Data can be normalized to any reference point, but the
++ * normalization must be consistent. That is, one bogo-joule/watt must be the
++ * same quantity for all data, but we don't care what it is.
++ */
++static struct idle_state idle_states_cluster_a7[] = {
++	 { .power = 25 }, /* arch_cpu_idle() (active idle) = WFI */
++	 { .power = 25 }, /* WFI */
++	 { .power = 10 }, /* cluster-sleep-l */
++	};
++
++static struct idle_state idle_states_cluster_a15[] = {
++	 { .power = 70 }, /* arch_cpu_idle() (active idle) = WFI */
++	 { .power = 70 }, /* WFI */
++	 { .power = 25 }, /* cluster-sleep-b */
++	};
++
++static struct capacity_state cap_states_cluster_a7[] = {
++	/* Cluster only power */
++	 { .cap =  150, .power = 2967, }, /*  350 MHz */
++	 { .cap =  172, .power = 2792, }, /*  400 MHz */
++	 { .cap =  215, .power = 2810, }, /*  500 MHz */
++	 { .cap =  258, .power = 2815, }, /*  600 MHz */
++	 { .cap =  301, .power = 2919, }, /*  700 MHz */
++	 { .cap =  344, .power = 2847, }, /*  800 MHz */
++	 { .cap =  387, .power = 3917, }, /*  900 MHz */
++	 { .cap =  430, .power = 4905, }, /* 1000 MHz */
++	};
++
++static struct capacity_state cap_states_cluster_a15[] = {
++	/* Cluster only power */
++	 { .cap =  426, .power =  7920, }, /*  500 MHz */
++	 { .cap =  512, .power =  8165, }, /*  600 MHz */
++	 { .cap =  597, .power =  8172, }, /*  700 MHz */
++	 { .cap =  682, .power =  8195, }, /*  800 MHz */
++	 { .cap =  768, .power =  8265, }, /*  900 MHz */
++	 { .cap =  853, .power =  8446, }, /* 1000 MHz */
++	 { .cap =  938, .power = 11426, }, /* 1100 MHz */
++	 { .cap = 1024, .power = 15200, }, /* 1200 MHz */
++	};
++
++static struct sched_group_energy energy_cluster_a7 = {
++	  .nr_idle_states = ARRAY_SIZE(idle_states_cluster_a7),
++	  .idle_states    = idle_states_cluster_a7,
++	  .nr_cap_states  = ARRAY_SIZE(cap_states_cluster_a7),
++	  .cap_states     = cap_states_cluster_a7,
++};
++
++static struct sched_group_energy energy_cluster_a15 = {
++	  .nr_idle_states = ARRAY_SIZE(idle_states_cluster_a15),
++	  .idle_states    = idle_states_cluster_a15,
++	  .nr_cap_states  = ARRAY_SIZE(cap_states_cluster_a15),
++	  .cap_states     = cap_states_cluster_a15,
++};
++
++static struct idle_state idle_states_core_a7[] = {
++	 { .power = 0 }, /* arch_cpu_idle (active idle) = WFI */
++	 { .power = 0 }, /* WFI */
++	 { .power = 0 }, /* cluster-sleep-l */
++	};
++
++static struct idle_state idle_states_core_a15[] = {
++	 { .power = 0 }, /* arch_cpu_idle (active idle) = WFI */
++	 { .power = 0 }, /* WFI */
++	 { .power = 0 }, /* cluster-sleep-b */
++	};
++
++static struct capacity_state cap_states_core_a7[] = {
++	/* Power per cpu */
++	 { .cap =  150, .power =  187, }, /*  350 MHz */
++	 { .cap =  172, .power =  275, }, /*  400 MHz */
++	 { .cap =  215, .power =  334, }, /*  500 MHz */
++	 { .cap =  258, .power =  407, }, /*  600 MHz */
++	 { .cap =  301, .power =  447, }, /*  700 MHz */
++	 { .cap =  344, .power =  549, }, /*  800 MHz */
++	 { .cap =  387, .power =  761, }, /*  900 MHz */
++	 { .cap =  430, .power = 1024, }, /* 1000 MHz */
++	};
++
++static struct capacity_state cap_states_core_a15[] = {
++	/* Power per cpu */
++	 { .cap =  426, .power = 2021, }, /*  500 MHz */
++	 { .cap =  512, .power = 2312, }, /*  600 MHz */
++	 { .cap =  597, .power = 2756, }, /*  700 MHz */
++	 { .cap =  682, .power = 3125, }, /*  800 MHz */
++	 { .cap =  768, .power = 3524, }, /*  900 MHz */
++	 { .cap =  853, .power = 3846, }, /* 1000 MHz */
++	 { .cap =  938, .power = 5177, }, /* 1100 MHz */
++	 { .cap = 1024, .power = 6997, }, /* 1200 MHz */
++	};
++
++static struct sched_group_energy energy_core_a7 = {
++	  .nr_idle_states = ARRAY_SIZE(idle_states_core_a7),
++	  .idle_states    = idle_states_core_a7,
++	  .nr_cap_states  = ARRAY_SIZE(cap_states_core_a7),
++	  .cap_states     = cap_states_core_a7,
++};
++
++static struct sched_group_energy energy_core_a15 = {
++	  .nr_idle_states = ARRAY_SIZE(idle_states_core_a15),
++	  .idle_states    = idle_states_core_a15,
++	  .nr_cap_states  = ARRAY_SIZE(cap_states_core_a15),
++	  .cap_states     = cap_states_core_a15,
++};
++
++/* sd energy functions */
++static inline
++const struct sched_group_energy * const cpu_cluster_energy(int cpu)
++{
++	return cpu_topology[cpu].socket_id ? &energy_cluster_a7 :
++			&energy_cluster_a15;
++}
++
++static inline
++const struct sched_group_energy * const cpu_core_energy(int cpu)
++{
++	return cpu_topology[cpu].socket_id ? &energy_core_a7 :
++			&energy_core_a15;
++}
++
+ static inline int cpu_corepower_flags(void)
+ {
+ 	int mc_flags = SD_SHARE_PKG_RESOURCES | SD_SHARE_POWERDOMAIN;
+@@ -631,10 +752,9 @@ static inline int arm_cpu_cpu_flags(void)
+ 
+ static struct sched_domain_topology_level arm_topology[] = {
+ #ifdef CONFIG_SCHED_MC
+-	{ cpu_corepower_mask, cpu_corepower_flags, SD_INIT_NAME(GMC) },
+-	{ cpu_coregroup_mask, cpu_core_flags, SD_INIT_NAME(MC) },
++	{ cpu_coregroup_mask, cpu_corepower_flags, cpu_core_energy, SD_INIT_NAME(MC) },
+ #endif
+-	{ cpu_cpu_mask, arm_cpu_cpu_flags, SD_INIT_NAME(DIE) },
++	{ cpu_cpu_mask, arm_cpu_cpu_flags, cpu_cluster_energy, SD_INIT_NAME(DIE) },
+ 	{ NULL, },
+ };
+ 
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0067-arm-Cpu-invariant-scheduler-load-tracking-and-capaci.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0067-arm-Cpu-invariant-scheduler-load-tracking-and-capaci.patch
new file mode 100644
index 0000000..ac96677
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0067-arm-Cpu-invariant-scheduler-load-tracking-and-capaci.patch
@@ -0,0 +1,76 @@
+From facd4083a41b455eacc6ff7b89d5eb4eceb53b39 Mon Sep 17 00:00:00 2001
+From: Dietmar Eggemann <dietmar.eggemann@arm.com>
+Date: Fri, 10 Jul 2015 13:57:19 +0100
+Subject: [PATCH 67/92] arm: Cpu invariant scheduler load-tracking and capacity
+ support
+
+Provides the scheduler with a cpu scaling correction factor for more
+accurate load-tracking and cpu capacity handling.
+
+The Energy Model (EM) (in fact the capacity value of the last element
+of the capacity states vector of the core (MC) level sched_group_energy
+structure) is used instead of the arm arch specific cpu_efficiency and
+dtb property 'clock-frequency' values as the source for this cpu
+scaling factor.
+
+The cpu capacity value depends on the micro-architecture and the
+maximum frequency of the cpu.
+
+The maximum frequency part should not be confused with the frequency
+invariant scheduler load-tracking support which deals with frequency
+related scaling due to DFVS functionality.
+
+Signed-off-by: Juri Lelli <juri.lelli@arm.com>
+Signed-off-by: Dietmar Eggemann <dietmar.eggemann@arm.com>
+(cherry picked from commit e47ea7b6779f5b3b176fb5966c51e638c122656d)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ arch/arm/kernel/topology.c | 18 +++++++++++++++---
+ 1 file changed, 15 insertions(+), 3 deletions(-)
+
+diff --git a/arch/arm/kernel/topology.c b/arch/arm/kernel/topology.c
+index 08c4749..c85e1d0 100644
+--- a/arch/arm/kernel/topology.c
++++ b/arch/arm/kernel/topology.c
+@@ -218,12 +218,17 @@ static int __init parse_cpu_capacity(struct device_node *cpu_node, int cpu)
+ 	return !ret;
+ }
+ 
++static const struct sched_group_energy * const cpu_core_energy(int cpu);
++
+ static void normalize_cpu_capacity(void)
+ {
+ 	u64 capacity;
+ 	int cpu;
+ 	bool asym = false;
+ 
++	if (cpu_core_energy(0))
++		return;
++
+ 	if (!raw_capacity || cap_parsing_failed)
+ 		return;
+ 
+@@ -480,10 +485,17 @@ static void __init parse_dt_topology(void)
+  */
+ static void update_cpu_capacity(unsigned int cpu)
+ {
+-	if (!cpu_capacity(cpu) || cap_from_dt)
+-		return;
++	if (cpu_core_energy(cpu)) {
++		unsigned long capacity;
++		int max_cap_idx = cpu_core_energy(cpu)->nr_cap_states - 1;
++		capacity = cpu_core_energy(cpu)->cap_states[max_cap_idx].cap;
++		set_capacity_scale(cpu, capacity);
++	} else {
++		if (!cpu_capacity(cpu) || cap_from_dt)
++			return;
+ 
+-	set_capacity_scale(cpu, cpu_capacity(cpu) / middle_capacity);
++		set_capacity_scale(cpu, cpu_capacity(cpu) / middle_capacity);
++	}
+ 
+ 	if (scale_cpu_capacity(NULL, cpu) < SCHED_CAPACITY_SCALE)
+ 		asym_cpucap = true;
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0068-arm64-topology-Define-JUNO-energy-and-provide-it-to-.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0068-arm64-topology-Define-JUNO-energy-and-provide-it-to-.patch
new file mode 100644
index 0000000..809e37f
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0068-arm64-topology-Define-JUNO-energy-and-provide-it-to-.patch
@@ -0,0 +1,171 @@
+From 5ef504e0ddfbc6856799fc6c342f36e0e4d18cbd Mon Sep 17 00:00:00 2001
+From: Juri Lelli <juri.lelli@arm.com>
+Date: Tue, 10 Feb 2015 12:05:22 +0000
+Subject: [PATCH 68/92] arm64, topology: Define JUNO energy and provide it to
+ the scheduler
+
+This patch is only here to be able to test provisioning of energy related
+data from an arch topology shim layer to the scheduler. Since there is no
+code today which deals with extracting energy related data from the dtb or
+acpi, and process it in the topology shim layer, the content of the
+sched_group_energy structures as well as the idle_state and capacity_state
+arrays are hard-coded here.
+
+This patch defines the sched_group_energy structure as well as the
+idle_state and capacity_state array for the cluster (relates to sched
+groups (sgs) in DIE sched domain level) and for the core (relates to sgs
+in MC sd level) for a Cortex A53 as well as for a Cortex A57.
+It further provides related implementations of the sched_domain_energy_f
+functions (cpu_cluster_energy() and cpu_core_energy()).
+
+To be able to propagate this information from the topology shim layer to
+the scheduler, the elements of the arm_topology[] table have been
+provisioned with the appropriate sched_domain_energy_f functions.
+
+Signed-off-by: Juri Lelli <juri.lelli@arm.com>
+(cherry picked from commit 037aceb5c5b768295bdda8f111ac9b0c8f97cc79)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ arch/arm64/kernel/topology.c | 118 ++++++++++++++++++++++++++++++++++++++++++-
+ 1 file changed, 116 insertions(+), 2 deletions(-)
+
+diff --git a/arch/arm64/kernel/topology.c b/arch/arm64/kernel/topology.c
+index a8d986e..a75db2b 100644
+--- a/arch/arm64/kernel/topology.c
++++ b/arch/arm64/kernel/topology.c
+@@ -525,6 +525,120 @@ static int __init parse_dt_topology(void)
+ struct cpu_topology cpu_topology[NR_CPUS];
+ EXPORT_SYMBOL_GPL(cpu_topology);
+ 
++/*
++ * ARM JUNO specific energy cost model data. There are no unit requirements for
++ * the data. Data can be normalized to any reference point, but the
++ * normalization must be consistent. That is, one bogo-joule/watt must be the
++ * same quantity for all data, but we don't care what it is.
++ */
++
++static struct idle_state idle_states_cluster_a53[] = {
++	{ .power = 56 }, /* arch_cpu_idle() (active idle) = WFI */
++	{ .power = 56 }, /* WFI */
++	{ .power = 56 }, /* cpu-sleep-0 */
++	{ .power = 17 }, /* cluster-sleep-0 */
++};
++
++static struct idle_state idle_states_cluster_a57[] = {
++	{ .power = 65 }, /* arch_cpu_idle() (active idle) = WFI */
++	{ .power = 65 }, /* WFI */
++	{ .power = 65 }, /* cpu-sleep-0 */
++	{ .power = 24 }, /* cluster-sleep-0 */
++};
++
++static struct capacity_state cap_states_cluster_a53[] = {
++        /* Power per cluster */
++	{ .cap =  235, .power = 26, }, /*  450 MHz */
++	{ .cap =  303, .power = 30, }, /*  575 MHz */
++	{ .cap =  368, .power = 39, }, /*  700 MHz */
++	{ .cap =  406, .power = 47, }, /*  775 MHz */
++	{ .cap =  447, .power = 57, }, /*  850 Mhz */
++};
++
++static struct capacity_state cap_states_cluster_a57[] = {
++        /* Power per cluster */
++	{ .cap =  417, .power = 24, }, /*  450 MHz */
++	{ .cap =  579, .power = 32, }, /*  625 MHz */
++	{ .cap =  744, .power = 43, }, /*  800 MHz */
++	{ .cap =  883, .power = 49, }, /*  950 MHz */
++	{ .cap = 1024, .power = 64, }, /* 1100 MHz */
++};
++
++static struct sched_group_energy energy_cluster_a53 = {
++	.nr_idle_states = ARRAY_SIZE(idle_states_cluster_a53),
++	.idle_states    = idle_states_cluster_a53,
++	.nr_cap_states  = ARRAY_SIZE(cap_states_cluster_a53),
++	.cap_states     = cap_states_cluster_a53,
++};
++
++static struct sched_group_energy energy_cluster_a57 = {
++	.nr_idle_states = ARRAY_SIZE(idle_states_cluster_a57),
++	.idle_states    = idle_states_cluster_a57,
++	.nr_cap_states  = ARRAY_SIZE(cap_states_cluster_a57),
++	.cap_states     = cap_states_cluster_a57,
++};
++
++static struct idle_state idle_states_core_a53[] = {
++	{ .power = 6 }, /* arch_cpu_idle() (active idle) = WFI */
++	{ .power = 6 }, /* WFI */
++	{ .power = 0 }, /* cpu-sleep-0 */
++	{ .power = 0 }, /* cluster-sleep-0 */
++};
++
++static struct idle_state idle_states_core_a57[] = {
++	{ .power = 15 }, /* arch_cpu_idle() (active idle) = WFI */
++	{ .power = 15 }, /* WFI */
++	{ .power = 0  }, /* cpu-sleep-0 */
++	{ .power = 0  }, /* cluster-sleep-0 */
++};
++
++static struct capacity_state cap_states_core_a53[] = {
++        /* Power per cpu */
++	{ .cap =  235, .power =  33, }, /*  450 MHz */
++	{ .cap =  302, .power =  46, }, /*  575 MHz */
++	{ .cap =  368, .power =  61, }, /*  700 MHz */
++	{ .cap =  406, .power =  76, }, /*  775 MHz */
++	{ .cap =  447, .power =  93, }, /*  850 Mhz */
++};
++
++static struct capacity_state cap_states_core_a57[] = {
++        /* Power per cpu */
++	{ .cap =  417, .power = 168, }, /*  450 MHz */
++	{ .cap =  579, .power = 251, }, /*  625 MHz */
++	{ .cap =  744, .power = 359, }, /*  800 MHz */
++	{ .cap =  883, .power = 479, }, /*  950 MHz */
++	{ .cap = 1024, .power = 616, }, /* 1100 MHz */
++};
++
++static struct sched_group_energy energy_core_a53 = {
++	.nr_idle_states = ARRAY_SIZE(idle_states_core_a53),
++	.idle_states    = idle_states_core_a53,
++	.nr_cap_states  = ARRAY_SIZE(cap_states_core_a53),
++	.cap_states     = cap_states_core_a53,
++};
++
++static struct sched_group_energy energy_core_a57 = {
++	  .nr_idle_states = ARRAY_SIZE(idle_states_core_a57),
++	  .idle_states    = idle_states_core_a57,
++	  .nr_cap_states  = ARRAY_SIZE(cap_states_core_a57),
++	  .cap_states     = cap_states_core_a57,
++};
++
++/* sd energy functions */
++static inline
++const struct sched_group_energy * const cpu_cluster_energy(int cpu)
++{
++	return cpu_topology[cpu].cluster_id ? &energy_cluster_a53 :
++			&energy_cluster_a57;
++}
++
++static inline
++const struct sched_group_energy * const cpu_core_energy(int cpu)
++{
++	return cpu_topology[cpu].cluster_id ? &energy_core_a53 :
++			&energy_core_a57;
++}
++
+ const struct cpumask *cpu_coregroup_mask(int cpu)
+ {
+ 	return &cpu_topology[cpu].core_sibling;
+@@ -636,9 +750,9 @@ static void __init reset_cpu_topology(void)
+ 
+ static struct sched_domain_topology_level arm64_topology[] = {
+ #ifdef CONFIG_SCHED_MC
+-	{ cpu_coregroup_mask, cpu_coregroup_flags, SD_INIT_NAME(MC) },
++	{ cpu_coregroup_mask, cpu_coregroup_flags, cpu_core_energy, SD_INIT_NAME(MC) },
+ #endif
+-	{ cpu_cpu_mask, cpu_cpu_flags, SD_INIT_NAME(DIE) },
++	{ cpu_cpu_mask, cpu_cpu_flags, cpu_cluster_energy, SD_INIT_NAME(DIE) },
+ 	{ NULL, }
+ };
+ 
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0069-arm64-Cpu-invariant-scheduler-load-tracking-and-capa.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0069-arm64-Cpu-invariant-scheduler-load-tracking-and-capa.patch
new file mode 100644
index 0000000..50d6766
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0069-arm64-Cpu-invariant-scheduler-load-tracking-and-capa.patch
@@ -0,0 +1,88 @@
+From 4e480c5d43dc3cee5c0b7664d0ee394d1206d994 Mon Sep 17 00:00:00 2001
+From: Juri Lelli <juri.lelli@arm.com>
+Date: Thu, 30 Apr 2015 11:53:48 +0100
+Subject: [PATCH 69/92] arm64: Cpu invariant scheduler load-tracking and
+ capacity support
+
+Provides the scheduler with a cpu scaling correction factor for more
+accurate load-tracking and cpu capacity handling.
+
+The Energy Model (EM) (in fact the capacity value of the last element
+of the capacity states vector of the core (MC) level sched_group_energy
+structure) is used as the source for this cpu scaling factor.
+
+The cpu capacity value depends on the micro-architecture and the
+maximum frequency of the cpu.
+
+The maximum frequency part should not be confused with the frequency
+invariant scheduler load-tracking support which deals with frequency
+related scaling due to DFVS functionality.
+
+Signed-off-by: Juri Lelli <juri.lelli@arm.com>
+Signed-off-by: Dietmar Eggemann <dietmar.eggemann@arm.com>
+(cherry picked from commit ea98c1ac6d9b31033caa1f29ed1b8b707f437ae8)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ arch/arm64/kernel/topology.c | 26 ++++++++++++++++++++++++++
+ 1 file changed, 26 insertions(+)
+
+diff --git a/arch/arm64/kernel/topology.c b/arch/arm64/kernel/topology.c
+index a75db2b..761fcb6 100644
+--- a/arch/arm64/kernel/topology.c
++++ b/arch/arm64/kernel/topology.c
+@@ -172,12 +172,17 @@ static void __init parse_cpu_capacity(struct device_node *cpu_node, int cpu)
+ 	}
+ }
+ 
++static const struct sched_group_energy * const cpu_core_energy(int cpu);
++
+ static void normalize_cpu_capacity(void)
+ {
+ 	u64 capacity;
+ 	int cpu;
+ 	bool asym = false;
+ 
++	if (cpu_core_energy(0))
++		return;
++
+ 	if (!raw_capacity || cap_parsing_failed)
+ 		return;
+ 
+@@ -667,6 +672,26 @@ static int cpu_coregroup_flags(void)
+ 	return mc_flags;
+ }
+ 
++static void update_cpu_capacity(unsigned int cpu)
++{
++	unsigned long capacity;
++	int max_cap_idx;
++
++	if (!cpu_core_energy(cpu))
++		return;
++
++	max_cap_idx = cpu_core_energy(cpu)->nr_cap_states - 1;
++	capacity = cpu_core_energy(cpu)->cap_states[max_cap_idx].cap;
++
++	set_capacity_scale(cpu, capacity);
++
++	if (capacity < SCHED_CAPACITY_SCALE)
++		asym_cpucap = true;
++
++	pr_info("CPU%d: update cpu_capacity %lu\n",
++		cpu, arch_scale_cpu_capacity(NULL, cpu));
++}
++
+ static void update_siblings_masks(unsigned int cpuid)
+ {
+ 	struct cpu_topology *cpu_topo, *cpuid_topo = &cpu_topology[cpuid];
+@@ -728,6 +753,7 @@ void store_cpu_topology(unsigned int cpuid)
+ 
+ topology_populated:
+ 	update_siblings_masks(cpuid);
++	update_cpu_capacity(cpuid);
+ }
+ 
+ static void __init reset_cpu_topology(void)
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0070-arm64-Factor-out-energy-model-from-topology-shim-lay.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0070-arm64-Factor-out-energy-model-from-topology-shim-lay.patch
new file mode 100644
index 0000000..f6ec5be
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0070-arm64-Factor-out-energy-model-from-topology-shim-lay.patch
@@ -0,0 +1,353 @@
+From 19b9b07f001278198a4d3aae6744213beb1a75bd Mon Sep 17 00:00:00 2001
+From: Dietmar Eggemann <dietmar.eggemann@arm.com>
+Date: Mon, 15 Aug 2016 22:38:20 +0100
+Subject: [PATCH 70/92] arm64: Factor out energy model from topology shim layer
+
+To be able to support multiple energy models before we have the
+full-fletched dt solution in arm64 (e.g. for platform Arm Juno and
+Hisilicon Hikey) factor out the static energy model data and the
+appropriate access function into energy_model.h.
+
+The patch uses of_match_node() to match the compatible string with the
+appropriate platform energy model data, i.e. the patch introduces a
+dependency to CONFIG_OF_FLATTREE for propagating the energy model data
+towards the task scheduler.
+
+Signed-off-by: Dietmar Eggemann <dietmar.eggemann@arm.com>
+(cherry picked from commit 6a48e61e481ef4952be07345efb10bc5cd47d22d)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ arch/arm64/kernel/energy_model.h | 177 +++++++++++++++++++++++++++++++++++++++
+ arch/arm64/kernel/topology.c     | 118 +-------------------------
+ 2 files changed, 181 insertions(+), 114 deletions(-)
+ create mode 100644 arch/arm64/kernel/energy_model.h
+
+diff --git a/arch/arm64/kernel/energy_model.h b/arch/arm64/kernel/energy_model.h
+new file mode 100644
+index 0000000..170dd84
+--- /dev/null
++++ b/arch/arm64/kernel/energy_model.h
+@@ -0,0 +1,177 @@
++/*
++ * arch/arm64/kernel/energy_model.h
++ *
++ * Copyright (C) 2016 ARM Ltd.
++ *
++ * This file is subject to the terms and conditions of the GNU General Public
++ * License.  See the file "COPYING" in the main directory of this archive
++ * for more details.
++ */
++
++#include <linux/of_fdt.h>
++
++/*
++ * Energy cost model data. There are no unit requirements for the data.
++ * Data can be normalized to any reference point, but the normalization
++ * must be consistent. That is, one bogo-joule/watt must be the same
++ * quantity for all data, but we don't care what it is.
++ */
++
++/* Juno (r0, r2) */
++
++static struct idle_state idle_states_cluster_juno_a53[] = {
++	{ .power = 56 }, /* arch_cpu_idle() (active idle) = WFI */
++	{ .power = 56 }, /* WFI */
++	{ .power = 56 }, /* cpu-sleep-0 */
++	{ .power = 17 }, /* cluster-sleep-0 */
++};
++
++static struct idle_state idle_states_cluster_juno_a57[] = {
++	{ .power = 65 }, /* arch_cpu_idle() (active idle) = WFI */
++	{ .power = 65 }, /* WFI */
++	{ .power = 65 }, /* cpu-sleep-0 */
++	{ .power = 24 }, /* cluster-sleep-0 */
++};
++
++static struct capacity_state cap_states_cluster_juno_a53[] = {
++	{ .cap =  235, .power = 26, }, /*  450 MHz */
++	{ .cap =  303, .power = 30, }, /*  575 MHz */
++	{ .cap =  368, .power = 39, }, /*  700 MHz */
++	{ .cap =  406, .power = 47, }, /*  775 MHz */
++	{ .cap =  447, .power = 57, }, /*  850 Mhz */
++};
++
++static struct capacity_state cap_states_cluster_juno_a57[] = {
++	{ .cap =  417, .power = 24, }, /*  450 MHz */
++	{ .cap =  579, .power = 32, }, /*  625 MHz */
++	{ .cap =  744, .power = 43, }, /*  800 MHz */
++	{ .cap =  883, .power = 49, }, /*  950 MHz */
++	{ .cap = 1024, .power = 64, }, /* 1100 MHz */
++};
++
++static struct sched_group_energy energy_cluster_juno_a53 = {
++	.nr_idle_states = ARRAY_SIZE(idle_states_cluster_juno_a53),
++	.idle_states    = idle_states_cluster_juno_a53,
++	.nr_cap_states  = ARRAY_SIZE(cap_states_cluster_juno_a53),
++	.cap_states     = cap_states_cluster_juno_a53,
++};
++
++static struct sched_group_energy energy_cluster_juno_a57 = {
++	.nr_idle_states = ARRAY_SIZE(idle_states_cluster_juno_a57),
++	.idle_states    = idle_states_cluster_juno_a57,
++	.nr_cap_states  = ARRAY_SIZE(cap_states_cluster_juno_a57),
++	.cap_states     = cap_states_cluster_juno_a57,
++};
++
++static struct idle_state idle_states_core_juno_a53[] = {
++	{ .power = 6 }, /* arch_cpu_idle() (active idle) = WFI */
++	{ .power = 6 }, /* WFI */
++	{ .power = 0 }, /* cpu-sleep-0 */
++	{ .power = 0 }, /* cluster-sleep-0 */
++};
++
++static struct idle_state idle_states_core_juno_a57[] = {
++	{ .power = 15 }, /* arch_cpu_idle() (active idle) = WFI */
++	{ .power = 15 }, /* WFI */
++	{ .power = 0  }, /* cpu-sleep-0 */
++	{ .power = 0  }, /* cluster-sleep-0 */
++};
++
++static struct capacity_state cap_states_core_juno_a53[] = {
++	{ .cap =  235, .power =  33, }, /*  450 MHz */
++	{ .cap =  302, .power =  46, }, /*  575 MHz */
++	{ .cap =  368, .power =  61, }, /*  700 MHz */
++	{ .cap =  406, .power =  76, }, /*  775 MHz */
++	{ .cap =  447, .power =  93, }, /*  850 Mhz */
++};
++
++static struct capacity_state cap_states_core_juno_a57[] = {
++	{ .cap =  417, .power = 168, }, /*  450 MHz */
++	{ .cap =  579, .power = 251, }, /*  625 MHz */
++	{ .cap =  744, .power = 359, }, /*  800 MHz */
++	{ .cap =  883, .power = 479, }, /*  950 MHz */
++	{ .cap = 1024, .power = 616, }, /* 1100 MHz */
++};
++
++static struct sched_group_energy energy_core_juno_a53 = {
++	.nr_idle_states = ARRAY_SIZE(idle_states_core_juno_a53),
++	.idle_states    = idle_states_core_juno_a53,
++	.nr_cap_states  = ARRAY_SIZE(cap_states_core_juno_a53),
++	.cap_states     = cap_states_core_juno_a53,
++};
++
++static struct sched_group_energy energy_core_juno_a57 = {
++	  .nr_idle_states = ARRAY_SIZE(idle_states_core_juno_a57),
++	  .idle_states    = idle_states_core_juno_a57,
++	  .nr_cap_states  = ARRAY_SIZE(cap_states_core_juno_a57),
++	  .cap_states     = cap_states_core_juno_a57,
++};
++
++/* An energy model contains core and cluster sched group energy for 2
++ * clusters (cluster id 0 and 1). set_energy_model() relies on this
++ * feature. It is enforced by a BUG_ON in energy().
++ */
++
++struct energy_model {
++	struct sched_group_energy *core_energy[2];
++	struct sched_group_energy *cluster_energy[2];
++};
++
++static struct energy_model juno_model = {
++	{ &energy_core_juno_a57, &energy_core_juno_a53, },
++	{ &energy_cluster_juno_a57, &energy_cluster_juno_a53, },
++};
++
++static struct of_device_id model_matches[] = {
++	{ .compatible = "arm,juno", .data = &juno_model },
++	{},
++};
++
++static struct sched_group_energy **core_energy, **cluster_energy;
++
++static void __init set_energy_model(void)
++{
++	const struct of_device_id *match;
++	struct energy_model *em;
++
++	BUG_ON(core_energy || cluster_energy);
++
++	match = of_match_node(model_matches, of_root);
++
++	if (!match)
++		return;
++
++	em = (struct energy_model *) match->data;
++
++	core_energy = em->core_energy;
++	cluster_energy = em->cluster_energy;
++
++	pr_debug("energy model core[0,1]=[%p,%p] cluster=[%p,%p]\n",
++		 em->core_energy[0], em->core_energy[1],
++		 em->cluster_energy[0], em->cluster_energy[1]);
++}
++
++static inline
++struct sched_group_energy *energy(int cpu, struct sched_group_energy **sge)
++{
++	int idx = cpu_topology[cpu].cluster_id;
++
++	BUG_ON(idx != 0 && idx != 1);
++
++	pr_debug("cpu=%d %s%s[%d]=%p\n", cpu, (sge == core_energy) ?
++		 "core" : "cluster", "_energy", idx, sge[idx]);
++
++	return sge[idx];
++}
++
++static inline
++const struct sched_group_energy * const cpu_core_energy(int cpu)
++{
++	return core_energy ? energy(cpu, core_energy) : NULL;
++}
++
++static inline
++const struct sched_group_energy * const cpu_cluster_energy(int cpu)
++{
++	return cluster_energy ? energy(cpu, cluster_energy) : NULL;
++}
+diff --git a/arch/arm64/kernel/topology.c b/arch/arm64/kernel/topology.c
+index 761fcb6..baaab53 100644
+--- a/arch/arm64/kernel/topology.c
++++ b/arch/arm64/kernel/topology.c
+@@ -26,6 +26,8 @@
+ #include <asm/cputype.h>
+ #include <asm/topology.h>
+ 
++#include "energy_model.h"
++
+ static DEFINE_PER_CPU(unsigned long, cpu_scale) = SCHED_CAPACITY_SCALE;
+ static DEFINE_MUTEX(cpu_scale_mutex);
+ static bool asym_cpucap;
+@@ -503,6 +505,8 @@ static int __init parse_dt_topology(void)
+ 		goto out;
+ 	}
+ 
++	set_energy_model();
++
+ 	ret = parse_cluster(map, 0);
+ 	if (ret != 0)
+ 		goto out_map;
+@@ -530,120 +534,6 @@ static int __init parse_dt_topology(void)
+ struct cpu_topology cpu_topology[NR_CPUS];
+ EXPORT_SYMBOL_GPL(cpu_topology);
+ 
+-/*
+- * ARM JUNO specific energy cost model data. There are no unit requirements for
+- * the data. Data can be normalized to any reference point, but the
+- * normalization must be consistent. That is, one bogo-joule/watt must be the
+- * same quantity for all data, but we don't care what it is.
+- */
+-
+-static struct idle_state idle_states_cluster_a53[] = {
+-	{ .power = 56 }, /* arch_cpu_idle() (active idle) = WFI */
+-	{ .power = 56 }, /* WFI */
+-	{ .power = 56 }, /* cpu-sleep-0 */
+-	{ .power = 17 }, /* cluster-sleep-0 */
+-};
+-
+-static struct idle_state idle_states_cluster_a57[] = {
+-	{ .power = 65 }, /* arch_cpu_idle() (active idle) = WFI */
+-	{ .power = 65 }, /* WFI */
+-	{ .power = 65 }, /* cpu-sleep-0 */
+-	{ .power = 24 }, /* cluster-sleep-0 */
+-};
+-
+-static struct capacity_state cap_states_cluster_a53[] = {
+-        /* Power per cluster */
+-	{ .cap =  235, .power = 26, }, /*  450 MHz */
+-	{ .cap =  303, .power = 30, }, /*  575 MHz */
+-	{ .cap =  368, .power = 39, }, /*  700 MHz */
+-	{ .cap =  406, .power = 47, }, /*  775 MHz */
+-	{ .cap =  447, .power = 57, }, /*  850 Mhz */
+-};
+-
+-static struct capacity_state cap_states_cluster_a57[] = {
+-        /* Power per cluster */
+-	{ .cap =  417, .power = 24, }, /*  450 MHz */
+-	{ .cap =  579, .power = 32, }, /*  625 MHz */
+-	{ .cap =  744, .power = 43, }, /*  800 MHz */
+-	{ .cap =  883, .power = 49, }, /*  950 MHz */
+-	{ .cap = 1024, .power = 64, }, /* 1100 MHz */
+-};
+-
+-static struct sched_group_energy energy_cluster_a53 = {
+-	.nr_idle_states = ARRAY_SIZE(idle_states_cluster_a53),
+-	.idle_states    = idle_states_cluster_a53,
+-	.nr_cap_states  = ARRAY_SIZE(cap_states_cluster_a53),
+-	.cap_states     = cap_states_cluster_a53,
+-};
+-
+-static struct sched_group_energy energy_cluster_a57 = {
+-	.nr_idle_states = ARRAY_SIZE(idle_states_cluster_a57),
+-	.idle_states    = idle_states_cluster_a57,
+-	.nr_cap_states  = ARRAY_SIZE(cap_states_cluster_a57),
+-	.cap_states     = cap_states_cluster_a57,
+-};
+-
+-static struct idle_state idle_states_core_a53[] = {
+-	{ .power = 6 }, /* arch_cpu_idle() (active idle) = WFI */
+-	{ .power = 6 }, /* WFI */
+-	{ .power = 0 }, /* cpu-sleep-0 */
+-	{ .power = 0 }, /* cluster-sleep-0 */
+-};
+-
+-static struct idle_state idle_states_core_a57[] = {
+-	{ .power = 15 }, /* arch_cpu_idle() (active idle) = WFI */
+-	{ .power = 15 }, /* WFI */
+-	{ .power = 0  }, /* cpu-sleep-0 */
+-	{ .power = 0  }, /* cluster-sleep-0 */
+-};
+-
+-static struct capacity_state cap_states_core_a53[] = {
+-        /* Power per cpu */
+-	{ .cap =  235, .power =  33, }, /*  450 MHz */
+-	{ .cap =  302, .power =  46, }, /*  575 MHz */
+-	{ .cap =  368, .power =  61, }, /*  700 MHz */
+-	{ .cap =  406, .power =  76, }, /*  775 MHz */
+-	{ .cap =  447, .power =  93, }, /*  850 Mhz */
+-};
+-
+-static struct capacity_state cap_states_core_a57[] = {
+-        /* Power per cpu */
+-	{ .cap =  417, .power = 168, }, /*  450 MHz */
+-	{ .cap =  579, .power = 251, }, /*  625 MHz */
+-	{ .cap =  744, .power = 359, }, /*  800 MHz */
+-	{ .cap =  883, .power = 479, }, /*  950 MHz */
+-	{ .cap = 1024, .power = 616, }, /* 1100 MHz */
+-};
+-
+-static struct sched_group_energy energy_core_a53 = {
+-	.nr_idle_states = ARRAY_SIZE(idle_states_core_a53),
+-	.idle_states    = idle_states_core_a53,
+-	.nr_cap_states  = ARRAY_SIZE(cap_states_core_a53),
+-	.cap_states     = cap_states_core_a53,
+-};
+-
+-static struct sched_group_energy energy_core_a57 = {
+-	  .nr_idle_states = ARRAY_SIZE(idle_states_core_a57),
+-	  .idle_states    = idle_states_core_a57,
+-	  .nr_cap_states  = ARRAY_SIZE(cap_states_core_a57),
+-	  .cap_states     = cap_states_core_a57,
+-};
+-
+-/* sd energy functions */
+-static inline
+-const struct sched_group_energy * const cpu_cluster_energy(int cpu)
+-{
+-	return cpu_topology[cpu].cluster_id ? &energy_cluster_a53 :
+-			&energy_cluster_a57;
+-}
+-
+-static inline
+-const struct sched_group_energy * const cpu_core_energy(int cpu)
+-{
+-	return cpu_topology[cpu].cluster_id ? &energy_core_a53 :
+-			&energy_core_a57;
+-}
+-
+ const struct cpumask *cpu_coregroup_mask(int cpu)
+ {
+ 	return &cpu_topology[cpu].core_sibling;
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0071-arm64-Add-Hikey-energy-model.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0071-arm64-Add-Hikey-energy-model.patch
new file mode 100644
index 0000000..891ca92
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0071-arm64-Add-Hikey-energy-model.patch
@@ -0,0 +1,87 @@
+From 0eeb3c8bc2f3436b44096bd0659050ce301f49ae Mon Sep 17 00:00:00 2001
+From: Dietmar Eggemann <dietmar.eggemann@arm.com>
+Date: Tue, 16 Aug 2016 14:10:38 +0100
+Subject: [PATCH 71/92] arm64: Add Hikey energy model
+
+Signed-off-by: Dietmar Eggemann <dietmar.eggemann@arm.com>
+(cherry picked from commit 75751f967eca10b6cced89831efa39d28699ba37)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ arch/arm64/kernel/energy_model.h | 52 ++++++++++++++++++++++++++++++++++++++++
+ 1 file changed, 52 insertions(+)
+
+diff --git a/arch/arm64/kernel/energy_model.h b/arch/arm64/kernel/energy_model.h
+index 170dd84..a71c78d 100644
+--- a/arch/arm64/kernel/energy_model.h
++++ b/arch/arm64/kernel/energy_model.h
+@@ -107,6 +107,52 @@
+ 	  .cap_states     = cap_states_core_juno_a57,
+ };
+ 
++/* HiKey */
++
++static struct idle_state idle_states_cluster_hikey[] = {
++	{ .power = 107 }, /* arch_cpu_idle() (active idle) = WFI */
++	{ .power = 107 }, /* WFI */
++	{ .power =  47 }, /* cpu-sleep */
++	{ .power =   0 }, /* cluster-sleep */
++};
++
++static struct capacity_state cap_states_cluster_hikey[] = {
++	{ .cap =  178, .power =  16, }, /*  208 MHz */
++	{ .cap =  369, .power =  29, }, /*  432 MHz */
++	{ .cap =  622, .power =  47, }, /*  729 MHz */
++	{ .cap =  819, .power =  75, }, /*  960 MHz */
++	{ .cap = 1024, .power = 112, }, /* 1200 MHz */
++};
++
++static struct sched_group_energy energy_cluster_hikey = {
++	.nr_idle_states = ARRAY_SIZE(idle_states_cluster_hikey),
++	.idle_states    = idle_states_cluster_hikey,
++	.nr_cap_states  = ARRAY_SIZE(cap_states_cluster_hikey),
++	.cap_states     = cap_states_cluster_hikey,
++};
++
++static struct idle_state idle_states_core_hikey[] = {
++	{ .power = 15 }, /* arch_cpu_idle() (active idle) = WFI */
++	{ .power = 15 }, /* WFI */
++	{ .power =  0 }, /* cpu-sleep */
++	{ .power =  0 }, /* cluster-sleep */
++};
++
++static struct capacity_state cap_states_core_hikey[] = {
++	{ .cap =  178, .power =  69, }, /*  208 MHz */
++	{ .cap =  369, .power = 125, }, /*  432 MHz */
++	{ .cap =  622, .power = 224, }, /*  729 MHz */
++	{ .cap =  819, .power = 367, }, /*  960 MHz */
++	{ .cap = 1024, .power = 670, }, /* 1200 MHz */
++};
++
++static struct sched_group_energy energy_core_hikey = {
++	.nr_idle_states = ARRAY_SIZE(idle_states_core_hikey),
++	.idle_states    = idle_states_core_hikey,
++	.nr_cap_states  = ARRAY_SIZE(cap_states_core_hikey),
++	.cap_states     = cap_states_core_hikey,
++};
++
+ /* An energy model contains core and cluster sched group energy for 2
+  * clusters (cluster id 0 and 1). set_energy_model() relies on this
+  * feature. It is enforced by a BUG_ON in energy().
+@@ -122,8 +168,14 @@ struct energy_model {
+ 	{ &energy_cluster_juno_a57, &energy_cluster_juno_a53, },
+ };
+ 
++static struct energy_model hikey_model = {
++	{ &energy_core_hikey, &energy_core_hikey, },
++	{ &energy_cluster_hikey, &energy_cluster_hikey, },
++};
++
+ static struct of_device_id model_matches[] = {
+ 	{ .compatible = "arm,juno", .data = &juno_model },
++	{ .compatible = "hisilicon,hi6220-hikey", .data = &hikey_model },
+ 	{},
+ };
+ 
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0072-arm64-dts-Add-Hikey-cpu-capacity-dmips-mhz-informati.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0072-arm64-dts-Add-Hikey-cpu-capacity-dmips-mhz-informati.patch
new file mode 100644
index 0000000..87a8aec
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0072-arm64-dts-Add-Hikey-cpu-capacity-dmips-mhz-informati.patch
@@ -0,0 +1,93 @@
+From 9634026b856ae824ed7e2b714c81edd180a36ca3 Mon Sep 17 00:00:00 2001
+From: Dietmar Eggemann <dietmar.eggemann@arm.com>
+Date: Sun, 14 Aug 2016 15:44:31 +0100
+Subject: [PATCH 72/92] arm64, dts: Add Hikey cpu capacity-dmips-mhz
+ information
+
+Hikey is an SMP platform, so this property would normally not be necessary.
+
+But since we drive the setting of the EAS specific sched domain flag
+SD_SHARE_CAP_STATES via the init_cpu_capacity_callback() cpufreq notifier
+we have to make sure that cap_parsing_failed is not set to true in
+parse_cpu_capacity() so that init_cpu_capacity_callback() will bail out
+before consuming the CPUFREQ_NOTIFY. The easiest way to achieve this is to
+provide the dts file with this property.
+
+Signed-off-by: Dietmar Eggemann <dietmar.eggemann@arm.com>
+(cherry picked from commit 9cffd417af22705fbdafc3264d90e18b175af62b)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ arch/arm64/boot/dts/hisilicon/hi6220.dtsi | 8 ++++++++
+ 1 file changed, 8 insertions(+)
+
+diff --git a/arch/arm64/boot/dts/hisilicon/hi6220.dtsi b/arch/arm64/boot/dts/hisilicon/hi6220.dtsi
+index 17839db..78af87b 100644
+--- a/arch/arm64/boot/dts/hisilicon/hi6220.dtsi
++++ b/arch/arm64/boot/dts/hisilicon/hi6220.dtsi
+@@ -92,6 +92,7 @@
+ 			#cooling-cells = <2>; /* min followed by max */
+ 			cpu-idle-states = <&CPU_SLEEP &CLUSTER_SLEEP>;
+ 			dynamic-power-coefficient = <311>;
++			capacity-dmips-mhz = <1024>;
+ 		};
+ 
+ 		cpu1: cpu@1 {
+@@ -102,6 +103,7 @@
+ 			next-level-cache = <&CLUSTER0_L2>;
+ 			operating-points-v2 = <&cpu_opp_table>;
+ 			cpu-idle-states = <&CPU_SLEEP &CLUSTER_SLEEP>;
++			capacity-dmips-mhz = <1024>;
+ 		};
+ 
+ 		cpu2: cpu@2 {
+@@ -112,6 +114,7 @@
+ 			next-level-cache = <&CLUSTER0_L2>;
+ 			operating-points-v2 = <&cpu_opp_table>;
+ 			cpu-idle-states = <&CPU_SLEEP &CLUSTER_SLEEP>;
++			capacity-dmips-mhz = <1024>;
+ 		};
+ 
+ 		cpu3: cpu@3 {
+@@ -122,6 +125,7 @@
+ 			next-level-cache = <&CLUSTER0_L2>;
+ 			operating-points-v2 = <&cpu_opp_table>;
+ 			cpu-idle-states = <&CPU_SLEEP &CLUSTER_SLEEP>;
++			capacity-dmips-mhz = <1024>;
+ 		};
+ 
+ 		cpu4: cpu@100 {
+@@ -132,6 +136,7 @@
+ 			next-level-cache = <&CLUSTER1_L2>;
+ 			operating-points-v2 = <&cpu_opp_table>;
+ 			cpu-idle-states = <&CPU_SLEEP &CLUSTER_SLEEP>;
++			capacity-dmips-mhz = <1024>;
+ 		};
+ 
+ 		cpu5: cpu@101 {
+@@ -142,6 +147,7 @@
+ 			next-level-cache = <&CLUSTER1_L2>;
+ 			operating-points-v2 = <&cpu_opp_table>;
+ 			cpu-idle-states = <&CPU_SLEEP &CLUSTER_SLEEP>;
++			capacity-dmips-mhz = <1024>;
+ 		};
+ 
+ 		cpu6: cpu@102 {
+@@ -152,6 +158,7 @@
+ 			next-level-cache = <&CLUSTER1_L2>;
+ 			operating-points-v2 = <&cpu_opp_table>;
+ 			cpu-idle-states = <&CPU_SLEEP &CLUSTER_SLEEP>;
++			capacity-dmips-mhz = <1024>;
+ 		};
+ 
+ 		cpu7: cpu@103 {
+@@ -162,6 +169,7 @@
+ 			next-level-cache = <&CLUSTER1_L2>;
+ 			operating-points-v2 = <&cpu_opp_table>;
+ 			cpu-idle-states = <&CPU_SLEEP &CLUSTER_SLEEP>;
++			capacity-dmips-mhz = <1024>;
+ 		};
+ 
+ 		CLUSTER0_L2: l2-cache0 {
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0073-arm64-Introduce-sys-sd-energy-model-infrastructure.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0073-arm64-Introduce-sys-sd-energy-model-infrastructure.patch
new file mode 100644
index 0000000..700ecc0
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0073-arm64-Introduce-sys-sd-energy-model-infrastructure.patch
@@ -0,0 +1,126 @@
+From dabca795d8793a16cbbce37b0cc187d2a65cd50e Mon Sep 17 00:00:00 2001
+From: Dietmar Eggemann <dietmar.eggemann@arm.com>
+Date: Thu, 18 Aug 2016 12:06:07 +0100
+Subject: [PATCH 73/92] arm64: Introduce sys sd energy model infrastructure
+
+Allow the energy model to contain a system level besides the already
+existing core and cluster level.
+
+This is necessary for platforms with frequency domains spanning all
+cpus to let the EAS algorithm work properly.
+
+The whole idea of this system level has to be rethought once
+the idea of the 'struct sched_domain_shared' gets more momentum:
+
+https://lkml.org/lkml/2016/6/16/209
+
+Signed-off-by: Dietmar Eggemann <dietmar.eggemann@arm.com>
+(cherry picked from commit 83a776c78d6e2885f2821a35c78e465c60726244)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ arch/arm64/kernel/energy_model.h | 28 ++++++++++++++++++++--------
+ arch/arm64/kernel/topology.c     |  1 +
+ 2 files changed, 21 insertions(+), 8 deletions(-)
+
+diff --git a/arch/arm64/kernel/energy_model.h b/arch/arm64/kernel/energy_model.h
+index a71c78d..4a86fa3 100644
+--- a/arch/arm64/kernel/energy_model.h
++++ b/arch/arm64/kernel/energy_model.h
+@@ -153,24 +153,27 @@
+ 	.cap_states     = cap_states_core_hikey,
+ };
+ 
+-/* An energy model contains core and cluster sched group energy for 2
+- * clusters (cluster id 0 and 1). set_energy_model() relies on this
+- * feature. It is enforced by a BUG_ON in energy().
++/* An energy model contains core, cluster and system sched group energy
++ * for 2 clusters (cluster id 0 and 1). set_energy_model() relies on
++ * this feature. It is enforced by a BUG_ON in energy().
+  */
+ 
+ struct energy_model {
+ 	struct sched_group_energy *core_energy[2];
+ 	struct sched_group_energy *cluster_energy[2];
++	struct sched_group_energy *system_energy[2];
+ };
+ 
+ static struct energy_model juno_model = {
+ 	{ &energy_core_juno_a57, &energy_core_juno_a53, },
+ 	{ &energy_cluster_juno_a57, &energy_cluster_juno_a53, },
++	{},
+ };
+ 
+ static struct energy_model hikey_model = {
+ 	{ &energy_core_hikey, &energy_core_hikey, },
+ 	{ &energy_cluster_hikey, &energy_cluster_hikey, },
++	{},
+ };
+ 
+ static struct of_device_id model_matches[] = {
+@@ -179,14 +182,14 @@ struct energy_model {
+ 	{},
+ };
+ 
+-static struct sched_group_energy **core_energy, **cluster_energy;
++struct sched_group_energy **core_energy, **cluster_energy, **system_energy;
+ 
+ static void __init set_energy_model(void)
+ {
+ 	const struct of_device_id *match;
+ 	struct energy_model *em;
+ 
+-	BUG_ON(core_energy || cluster_energy);
++	BUG_ON(core_energy || cluster_energy || system_energy);
+ 
+ 	match = of_match_node(model_matches, of_root);
+ 
+@@ -197,10 +200,12 @@ static void __init set_energy_model(void)
+ 
+ 	core_energy = em->core_energy;
+ 	cluster_energy = em->cluster_energy;
++	system_energy = em->system_energy;
+ 
+-	pr_debug("energy model core[0,1]=[%p,%p] cluster=[%p,%p]\n",
++	pr_debug("energy model core[0,1]=[%p,%p] cluster=[%p,%p] system=[%p,%p]\n",
+ 		 em->core_energy[0], em->core_energy[1],
+-		 em->cluster_energy[0], em->cluster_energy[1]);
++		 em->cluster_energy[0], em->cluster_energy[1],
++		 em->system_energy[0], em->system_energy[1]);
+ }
+ 
+ static inline
+@@ -211,7 +216,8 @@ struct sched_group_energy *energy(int cpu, struct sched_group_energy **sge)
+ 	BUG_ON(idx != 0 && idx != 1);
+ 
+ 	pr_debug("cpu=%d %s%s[%d]=%p\n", cpu, (sge == core_energy) ?
+-		 "core" : "cluster", "_energy", idx, sge[idx]);
++		 "core" : (sge == cluster_energy) ? "cluster" :
++		 "system", "_energy", idx, sge[idx]);
+ 
+ 	return sge[idx];
+ }
+@@ -227,3 +233,9 @@ const struct sched_group_energy * const cpu_cluster_energy(int cpu)
+ {
+ 	return cluster_energy ? energy(cpu, cluster_energy) : NULL;
+ }
++
++static inline
++const struct sched_group_energy * const cpu_system_energy(int cpu)
++{
++	return system_energy ? energy(cpu, system_energy) : NULL;
++}
+diff --git a/arch/arm64/kernel/topology.c b/arch/arm64/kernel/topology.c
+index baaab53..4062786 100644
+--- a/arch/arm64/kernel/topology.c
++++ b/arch/arm64/kernel/topology.c
+@@ -669,6 +669,7 @@ static void __init reset_cpu_topology(void)
+ 	{ cpu_coregroup_mask, cpu_coregroup_flags, cpu_core_energy, SD_INIT_NAME(MC) },
+ #endif
+ 	{ cpu_cpu_mask, cpu_cpu_flags, cpu_cluster_energy, SD_INIT_NAME(DIE) },
++	{ cpu_cpu_mask, NULL, cpu_system_energy, SD_INIT_NAME(SYS) },
+ 	{ NULL, }
+ };
+ 
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0074-arm64-Define-Hi6220-SYS-sd-energy-model.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0074-arm64-Define-Hi6220-SYS-sd-energy-model.patch
new file mode 100644
index 0000000..1afbf14
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0074-arm64-Define-Hi6220-SYS-sd-energy-model.patch
@@ -0,0 +1,69 @@
+From 18204f2d5c286cde5c83e50c153ef678cb08ecf9 Mon Sep 17 00:00:00 2001
+From: Dietmar Eggemann <dietmar.eggemann@arm.com>
+Date: Thu, 18 Aug 2016 14:27:09 +0100
+Subject: [PATCH 74/92] arm64: Define Hi6220 SYS sd energy model
+
+Hi6220 has a single frequency domain spanning the two clusters. It
+needs the SYS sched domain (sd) to let the EAS algorithm work
+properly.
+
+The SD_SHARE_CAP_STATES flag is not set on SYS sd.
+
+This lets sd_ea (highest sd w/ energy model data) point to the SYS
+sd whereas sd_scs (highest sd w/ SD_SHARE_CAP_STATES set) points to
+the DIE sd. This setup allows the code in sched_group_energy() to
+set sg_shared_cap to the single sched group of the SYS sd covering
+all the cpus in the system as they are all part of the single
+frequency domain.
+
+The capacity and idle state vectors only contain entries w/ power
+values equal zero, so there is no system-wide energy contribution.
+
+Signed-off-by: Dietmar Eggemann <dietmar.eggemann@arm.com>
+(cherry picked from commit 364845656d93e1722081038e09c4781fa7cfb961)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ arch/arm64/kernel/energy_model.h | 20 +++++++++++++++++++-
+ 1 file changed, 19 insertions(+), 1 deletion(-)
+
+diff --git a/arch/arm64/kernel/energy_model.h b/arch/arm64/kernel/energy_model.h
+index 4a86fa3..0a7c134 100644
+--- a/arch/arm64/kernel/energy_model.h
++++ b/arch/arm64/kernel/energy_model.h
+@@ -109,6 +109,24 @@
+ 
+ /* HiKey */
+ 
++static struct idle_state idle_states_system_hikey[] = {
++	{ .power = 0 }, /* arch_cpu_idle() (active idle) = WFI */
++	{ .power = 0 }, /* WFI */
++	{ .power = 0 }, /* cpu-sleep */
++	{ .power = 0 }, /* cluster-sleep */
++};
++
++static struct capacity_state cap_states_system_hikey[] = {
++	{ .cap = 1024, .power = 0, },
++};
++
++static struct sched_group_energy energy_system_hikey = {
++	.nr_idle_states = ARRAY_SIZE(idle_states_system_hikey),
++	.idle_states    = idle_states_system_hikey,
++	.nr_cap_states  = ARRAY_SIZE(cap_states_system_hikey),
++	.cap_states     = cap_states_system_hikey,
++};
++
+ static struct idle_state idle_states_cluster_hikey[] = {
+ 	{ .power = 107 }, /* arch_cpu_idle() (active idle) = WFI */
+ 	{ .power = 107 }, /* WFI */
+@@ -173,7 +191,7 @@ struct energy_model {
+ static struct energy_model hikey_model = {
+ 	{ &energy_core_hikey, &energy_core_hikey, },
+ 	{ &energy_cluster_hikey, &energy_cluster_hikey, },
+-	{},
++	{ &energy_system_hikey, &energy_system_hikey, },
+ };
+ 
+ static struct of_device_id model_matches[] = {
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0075-sched-debug-Add-energy-procfs-interface.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0075-sched-debug-Add-energy-procfs-interface.patch
new file mode 100644
index 0000000..7073d2b
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0075-sched-debug-Add-energy-procfs-interface.patch
@@ -0,0 +1,161 @@
+From 066fa940b25dc58b6618b785d82c90cbaa9b54d5 Mon Sep 17 00:00:00 2001
+From: Dietmar Eggemann <dietmar.eggemann@arm.com>
+Date: Fri, 14 Nov 2014 16:25:50 +0000
+Subject: [PATCH 75/92] sched/debug: Add energy procfs interface
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+This patch makes the energy data available via procfs. The related files
+are placed as sub-directory named 'energy' inside the
+/proc/sys/kernel/sched_domain/cpuX/domainY/groupZ directory for those
+cpu/domain/group tuples which have energy information.
+
+The following example depicts the contents of
+/proc/sys/kernel/sched_domain/cpu0/domain0/group[01] for a system which
+has energy information attached to domain level 0.
+
+├── cpu0
+│   ├── domain0
+│   │   ├── busy_factor
+│   │   ├── busy_idx
+│   │   ├── cache_nice_tries
+│   │   ├── flags
+│   │   ├── forkexec_idx
+│   │   ├── group0
+│   │   │   └── energy
+│   │   │       ├── cap_states
+│   │   │       ├── idle_states
+│   │   │       ├── nr_cap_states
+│   │   │       └── nr_idle_states
+│   │   ├── group1
+│   │   │   └── energy
+│   │   │       ├── cap_states
+│   │   │       ├── idle_states
+│   │   │       ├── nr_cap_states
+│   │   │       └── nr_idle_states
+│   │   ├── idle_idx
+│   │   ├── imbalance_pct
+│   │   ├── max_interval
+│   │   ├── max_newidle_lb_cost
+│   │   ├── min_interval
+│   │   ├── name
+│   │   ├── newidle_idx
+│   │   └── wake_idx
+│   └── domain1
+│       ├── busy_factor
+│       ├── busy_idx
+│       ├── cache_nice_tries
+│       ├── flags
+│       ├── forkexec_idx
+│       ├── idle_idx
+│       ├── imbalance_pct
+│       ├── max_interval
+│       ├── max_newidle_lb_cost
+│       ├── min_interval
+│       ├── name
+│       ├── newidle_idx
+│       └── wake_idx
+
+The files 'nr_idle_states' and 'nr_cap_states' contain a scalar value
+whereas 'idle_states' and 'cap_states' contain a vector of power
+consumption at this idle state respectively (compute capacity, power
+consumption) at this capacity state.
+
+Signed-off-by: Dietmar Eggemann <dietmar.eggemann@arm.com>
+(cherry picked from commit 6bc112e3c581d16e3ebb7eb7abd396b7a2048169)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ kernel/sched/debug.c | 67 ++++++++++++++++++++++++++++++++++++++++++++++++++--
+ 1 file changed, 65 insertions(+), 2 deletions(-)
+
+diff --git a/kernel/sched/debug.c b/kernel/sched/debug.c
+index fa178b6..48a621c 100644
+--- a/kernel/sched/debug.c
++++ b/kernel/sched/debug.c
+@@ -261,9 +261,60 @@ static void sd_free_ctl_entry(struct ctl_table **tablep)
+ }
+ 
+ static struct ctl_table *
++sd_alloc_ctl_energy_table(struct sched_group_energy *sge)
++{
++	struct ctl_table *table = sd_alloc_ctl_entry(5);
++
++	if (table == NULL)
++		return NULL;
++
++	set_table_entry(&table[0], "nr_idle_states", &sge->nr_idle_states,
++			sizeof(int), 0644, proc_dointvec_minmax, false);
++	set_table_entry(&table[1], "idle_states", &sge->idle_states[0].power,
++			sge->nr_idle_states*sizeof(struct idle_state), 0644,
++			proc_doulongvec_minmax, false);
++	set_table_entry(&table[2], "nr_cap_states", &sge->nr_cap_states,
++			sizeof(int), 0644, proc_dointvec_minmax, false);
++	set_table_entry(&table[3], "cap_states", &sge->cap_states[0].cap,
++			sge->nr_cap_states*sizeof(struct capacity_state), 0644,
++			proc_doulongvec_minmax, false);
++
++	return table;
++}
++
++static struct ctl_table *
++sd_alloc_ctl_group_table(struct sched_group *sg)
++{
++	struct ctl_table *table = sd_alloc_ctl_entry(2);
++
++	if (table == NULL)
++		return NULL;
++
++	table->procname = kstrdup("energy", GFP_KERNEL);
++	table->mode = 0555;
++	table->child = sd_alloc_ctl_energy_table((struct sched_group_energy *)sg->sge);
++
++	return table;
++}
++
++static struct ctl_table *
+ sd_alloc_ctl_domain_table(struct sched_domain *sd)
+ {
+-	struct ctl_table *table = sd_alloc_ctl_entry(14);
++	struct ctl_table *table;
++	unsigned int nr_entries = 14;
++
++	int i = 0;
++	struct sched_group *sg = sd->groups;
++
++	if (sg->sge) {
++		int nr_sgs = 0;
++
++		do {} while (nr_sgs++, sg = sg->next, sg != sd->groups);
++
++		nr_entries += nr_sgs;
++	}
++
++	table = sd_alloc_ctl_entry(nr_entries);
+ 
+ 	if (table == NULL)
+ 		return NULL;
+@@ -296,7 +347,19 @@ static void sd_free_ctl_entry(struct ctl_table **tablep)
+ 		sizeof(long), 0644, proc_doulongvec_minmax, false);
+ 	set_table_entry(&table[12], "name", sd->name,
+ 		CORENAME_MAX_SIZE, 0444, proc_dostring, false);
+-	/* &table[13] is terminator */
++	sg = sd->groups;
++	if (sg->sge) {
++		char buf[32];
++		struct ctl_table *entry = &table[13];
++
++		do {
++			snprintf(buf, 32, "group%d", i);
++			entry->procname = kstrdup(buf, GFP_KERNEL);
++			entry->mode = 0555;
++			entry->child = sd_alloc_ctl_group_table(sg);
++		} while (entry++, i++, sg = sg->next, sg != sd->groups);
++	}
++	/* &table[nr_entries-1] is terminator */
+ 
+ 	return table;
+ }
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0076-sched-events-Introduce-cfs_rq-PELT-trace-event-sched.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0076-sched-events-Introduce-cfs_rq-PELT-trace-event-sched.patch
new file mode 100644
index 0000000..950e7a9
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0076-sched-events-Introduce-cfs_rq-PELT-trace-event-sched.patch
@@ -0,0 +1,121 @@
+From 1f93576e19b38a0df4203faaf07b656e5f24b6f8 Mon Sep 17 00:00:00 2001
+From: Dietmar Eggemann <dietmar.eggemann@arm.com>
+Date: Mon, 9 Nov 2015 12:07:27 +0000
+Subject: [PATCH 76/92] sched/events: Introduce cfs_rq PELT trace event
+ sched_pelt_cfs_rq()
+
+The trace event is only defined if symmetric multi-processing
+(CONFIG_SMP) is enabled.
+To let this trace event work for configurations with and without group
+scheduling support for SCHED_OTHER (CONFIG_FAIR_GROUP_SCHED) the
+following special handling is necessary for non-existent key=value
+pairs:
+
+id = -1 : In case of !CONFIG_FAIR_GROUP_SCHED the task group css id is
+          set to -1.
+
+Signed-off-by: Dietmar Eggemann <dietmar.eggemann@arm.com>
+(cherry picked from commit 1c61904cbc5998b19dc8c04bb0cfc99f9a8ec9db)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ include/trace/events/sched.h | 51 ++++++++++++++++++++++++++++++++++++++++++++
+ kernel/sched/fair.c          |  7 ++++++
+ 2 files changed, 58 insertions(+)
+
+diff --git a/include/trace/events/sched.h b/include/trace/events/sched.h
+index 9b90c57..c9c3348 100644
+--- a/include/trace/events/sched.h
++++ b/include/trace/events/sched.h
+@@ -562,6 +562,57 @@ static inline long __trace_sched_switch_state(bool preempt, struct task_struct *
+ 
+ 	TP_printk("cpu=%d", __entry->cpu)
+ );
++
++#ifdef CONFIG_SMP
++/*
++ * Tracepoint for cfs_rq Per Entity Load Tracking (PELT).
++ */
++TRACE_EVENT(sched_pelt_cfs_rq,
++
++	TP_PROTO(struct cfs_rq *cfs_rq),
++
++	TP_ARGS(cfs_rq),
++
++	TP_STRUCT__entry(
++		__field( int,		cpu			)
++		__field( int,		id			)
++		__field( unsigned long,	load_avg		)
++		__field( unsigned long,	util_avg		)
++		__field( u64,		load_sum		)
++		__field( u32,		util_sum		)
++		__field( u32,		period_contrib		)
++		__field( u64,		last_update_time	)
++		__field( unsigned long,	runnable_load_avg	)
++		__field( u64,		runnable_load_sum	)
++	),
++
++	TP_fast_assign(
++#ifdef CONFIG_FAIR_GROUP_SCHED
++		__entry->cpu			= cfs_rq->rq->cpu;
++		__entry->id			= cfs_rq->tg->css.id;
++#else
++		__entry->cpu			= (container_of(cfs_rq, struct rq, cfs))->cpu;
++		__entry->id			= -1;
++#endif
++		__entry->load_avg		= cfs_rq->avg.load_avg;
++		__entry->util_avg		= cfs_rq->avg.util_avg;
++		__entry->load_sum		= cfs_rq->avg.load_sum;
++		__entry->util_sum		= cfs_rq->avg.util_sum;
++		__entry->period_contrib		= cfs_rq->avg.period_contrib;
++		__entry->last_update_time	= cfs_rq->avg.last_update_time;
++		__entry->runnable_load_avg	= cfs_rq->runnable_load_avg;
++		__entry->runnable_load_sum	= cfs_rq->runnable_load_sum;
++	),
++
++	TP_printk("cpu=%d tg_css_id=%d load_avg=%lu util_avg=%lu"
++		  " load_sum=%llu util_sum=%u period_contrib=%u last_update_time=%llu"
++		  " runnable_load_avg=%lu runnable_load_sum=%llu",
++		  __entry->cpu, __entry->id, __entry->load_avg,
++		  __entry->util_avg, __entry->load_sum, __entry->util_sum,
++		  __entry->period_contrib, __entry->last_update_time,
++		  __entry->runnable_load_avg, __entry->runnable_load_sum)
++);
++#endif /* CONFIG_SMP */
+ #endif /* _TRACE_SCHED_H */
+ 
+ /* This part must be outside protection */
+diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
+index bc347af..03b4666 100644
+--- a/kernel/sched/fair.c
++++ b/kernel/sched/fair.c
+@@ -2931,6 +2931,9 @@ static u32 __compute_runnable_contrib(u64 n)
+ 		sa->util_avg = sa->util_sum / LOAD_AVG_MAX;
+ 	}
+ 
++	if (cfs_rq)
++		trace_sched_pelt_cfs_rq(cfs_rq);
++
+ 	return decayed;
+ }
+ 
+@@ -3310,6 +3313,8 @@ static void attach_entity_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *s
+ 	set_tg_cfs_propagate(cfs_rq);
+ 
+ 	cfs_rq_util_change(cfs_rq);
++
++	trace_sched_pelt_cfs_rq(cfs_rq);
+ }
+ 
+ /**
+@@ -3330,6 +3335,8 @@ static void detach_entity_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *s
+ 	set_tg_cfs_propagate(cfs_rq);
+ 
+ 	cfs_rq_util_change(cfs_rq);
++
++	trace_sched_pelt_cfs_rq(cfs_rq);
+ }
+ 
+ /* Add the load generated by se into cfs_rq's load average */
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0077-sched-events-Introduce-sched-entity-PELT-trace-event.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0077-sched-events-Introduce-sched-entity-PELT-trace-event.patch
new file mode 100644
index 0000000..5e7d128
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0077-sched-events-Introduce-sched-entity-PELT-trace-event.patch
@@ -0,0 +1,146 @@
+From f815820c55e552529885b5c541be9e2e3000c198 Mon Sep 17 00:00:00 2001
+From: Dietmar Eggemann <dietmar.eggemann@arm.com>
+Date: Mon, 25 Apr 2016 00:48:09 +0100
+Subject: [PATCH 77/92] sched/events: Introduce sched entity PELT trace event
+ sched_pelt_se()
+
+The trace event is only defined if symmetric multi-processing
+(CONFIG_SMP) is enabled.
+To let this trace event work for configurations with and without group
+scheduling support for SCHED_OTHER (CONFIG_FAIR_GROUP_SCHED) the
+following special handling is necessary for non-existent key=value
+pairs:
+
+id = -1      : In case sched entity is representing a task
+             : In case CONFIG_FAIR_GROUP_SCHED is not set
+
+pid = -1     : In case sched entity is representing a task group
+
+comm = "n/a" : In case sched entity is representing a task group
+
+Signed-off-by: Dietmar Eggemann <dietmar.eggemann@arm.com>
+(cherry picked from commit 31f5aeb31289ec28c5831b62a2176da50b3c7fa4)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ include/trace/events/sched.h | 54 ++++++++++++++++++++++++++++++++++++++++++++
+ kernel/sched/fair.c          |  9 ++++++--
+ 2 files changed, 61 insertions(+), 2 deletions(-)
+
+diff --git a/include/trace/events/sched.h b/include/trace/events/sched.h
+index c9c3348..58ba3d5 100644
+--- a/include/trace/events/sched.h
++++ b/include/trace/events/sched.h
+@@ -565,6 +565,60 @@ static inline long __trace_sched_switch_state(bool preempt, struct task_struct *
+ 
+ #ifdef CONFIG_SMP
+ /*
++ * Tracepoint for sched entity Per Entity Load Tracking (PELT).
++ */
++TRACE_EVENT(sched_pelt_se,
++
++	TP_PROTO(struct sched_entity *se),
++
++	TP_ARGS(se),
++
++	TP_STRUCT__entry(
++		__field( int,		cpu			)
++		__field( int,		id			)
++		__array( char,		comm,	TASK_COMM_LEN	)
++		__field( pid_t,		pid			)
++		__field( unsigned long,	load_avg		)
++		__field( unsigned long,	util_avg		)
++		__field( u64,		load_sum		)
++		__field( u32,		util_sum		)
++		__field( u32,		period_contrib		)
++		__field( u64,		last_update_time	)
++	),
++
++	TP_fast_assign(
++		struct task_struct *p = container_of(se, struct task_struct, se);
++
++#ifdef CONFIG_FAIR_GROUP_SCHED
++		__entry->cpu = se->my_q ? cpu_of(se->cfs_rq->rq) : task_cpu(p);
++		__entry->id  = se->my_q ? se->my_q->tg->css.id : -1;
++		memcpy(__entry->comm, se->my_q ? "n/a" : p->comm,
++		       TASK_COMM_LEN);
++		__entry->pid = se->my_q ? -1 : p->pid;
++#else
++		__entry->cpu = task_cpu(p);
++		__entry->id  = -1;
++		memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
++		__entry->pid = p->pid;
++#endif
++		__entry->load_avg		= se->avg.load_avg;
++		__entry->util_avg		= se->avg.util_avg;
++		__entry->load_sum		= se->avg.load_sum;
++		__entry->util_sum		= se->avg.util_sum;
++		__entry->period_contrib		= se->avg.period_contrib;
++		__entry->last_update_time	= se->avg.last_update_time;
++	),
++
++	TP_printk("cpu=%d tg_css_id=%d comm=%s pid=%d load_avg=%lu util_avg=%lu"
++		  " load_sum=%llu util_sum=%u period_contrib=%u"
++		  " last_update_time=%llu",
++		  __entry->cpu, __entry->id, __entry->comm, __entry->pid,
++		  __entry->load_avg, __entry->util_avg, __entry->load_sum,
++		  __entry->util_sum, __entry->period_contrib,
++		  __entry->last_update_time)
++);
++
++/*
+  * Tracepoint for cfs_rq Per Entity Load Tracking (PELT).
+  */
+ TRACE_EVENT(sched_pelt_cfs_rq,
+diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
+index 03b4666..fffe7cb 100644
+--- a/kernel/sched/fair.c
++++ b/kernel/sched/fair.c
+@@ -2845,7 +2845,7 @@ static u32 __compute_runnable_contrib(u64 n)
+ 	 */
+ 	if ((s64)delta < 0) {
+ 		sa->last_update_time = now;
+-		return 0;
++		goto trace;
+ 	}
+ 
+ 	/*
+@@ -2854,7 +2854,7 @@ static u32 __compute_runnable_contrib(u64 n)
+ 	 */
+ 	delta >>= 10;
+ 	if (!delta)
+-		return 0;
++		goto trace;
+ 	sa->last_update_time = now;
+ 
+ 	scale_freq = arch_scale_freq_capacity(NULL, cpu);
+@@ -2931,8 +2931,11 @@ static u32 __compute_runnable_contrib(u64 n)
+ 		sa->util_avg = sa->util_sum / LOAD_AVG_MAX;
+ 	}
+ 
++trace:
+ 	if (cfs_rq)
+ 		trace_sched_pelt_cfs_rq(cfs_rq);
++	else
++		trace_sched_pelt_se(container_of(sa, struct sched_entity, avg));
+ 
+ 	return decayed;
+ }
+@@ -3315,6 +3318,7 @@ static void attach_entity_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *s
+ 	cfs_rq_util_change(cfs_rq);
+ 
+ 	trace_sched_pelt_cfs_rq(cfs_rq);
++	trace_sched_pelt_se(se);
+ }
+ 
+ /**
+@@ -3337,6 +3341,7 @@ static void detach_entity_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *s
+ 	cfs_rq_util_change(cfs_rq);
+ 
+ 	trace_sched_pelt_cfs_rq(cfs_rq);
++	trace_sched_pelt_se(se);
+ }
+ 
+ /* Add the load generated by se into cfs_rq's load average */
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0078-sched-events-Introduce-task-group-PELT-trace-event-s.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0078-sched-events-Introduce-task-group-PELT-trace-event-s.patch
new file mode 100644
index 0000000..970f2e5
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0078-sched-events-Introduce-task-group-PELT-trace-event-s.patch
@@ -0,0 +1,91 @@
+From cf1dd9ac6f0b61e88c4dbeb57aaee06de5f6a250 Mon Sep 17 00:00:00 2001
+From: Dietmar Eggemann <dietmar.eggemann@arm.com>
+Date: Thu, 13 Oct 2016 12:20:12 +0100
+Subject: [PATCH 78/92] sched/events: Introduce task group PELT trace event
+ sched_pelt_tg()
+
+The trace event is only defined if symmetric multi-processing
+(CONFIG_SMP) and group scheduling support for SCHED_OTHER
+(CONFIG_FAIR_GROUP_SCHED) are enabled.
+
+The cfs_rq owned by the task group is used as the only parameter for the
+trace event because it has a reference to the task group and the cpu.
+Using the task group as a parameter instead would require the cpu as a
+second parameter.
+
+Signed-off-by: Dietmar Eggemann <dietmar.eggemann@arm.com>
+(cherry picked from commit 9099eec7854949cf30adf1b5ee026821e1d53e83)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ include/trace/events/sched.h | 33 +++++++++++++++++++++++++++++++++
+ kernel/sched/fair.c          |  5 ++++-
+ 2 files changed, 37 insertions(+), 1 deletion(-)
+
+diff --git a/include/trace/events/sched.h b/include/trace/events/sched.h
+index 58ba3d5..e269b04 100644
+--- a/include/trace/events/sched.h
++++ b/include/trace/events/sched.h
+@@ -666,6 +666,39 @@ static inline long __trace_sched_switch_state(bool preempt, struct task_struct *
+ 		  __entry->period_contrib, __entry->last_update_time,
+ 		  __entry->runnable_load_avg, __entry->runnable_load_sum)
+ );
++
++/*
++ * Tracepoint for task group Per Entity Load Tracking (PELT).
++ */
++#ifdef CONFIG_FAIR_GROUP_SCHED
++TRACE_EVENT(sched_pelt_tg,
++
++	TP_PROTO(struct cfs_rq *cfs_rq),
++
++	TP_ARGS(cfs_rq),
++
++	TP_STRUCT__entry(
++		__field( int,		cpu			)
++		__field( int,		id			)
++		__field( long,		load_avg		)
++		__field( unsigned long,	shares			)
++		__field( unsigned long,	tg_load_avg_contrib	)
++	),
++
++	TP_fast_assign(
++		__entry->cpu			= cfs_rq->rq->cpu;
++		__entry->id			= cfs_rq->tg->css.id;
++		__entry->load_avg		= atomic_long_read(&cfs_rq->tg->load_avg);
++		__entry->shares			= scale_load_down(cfs_rq->tg->shares);
++		__entry->tg_load_avg_contrib	= cfs_rq->tg_load_avg_contrib;
++	),
++
++	TP_printk("cpu=%d tg_css_id=%d load_avg=%ld shares=%lu"
++		  " tg_load_avg_contrib=%lu",
++		  __entry->cpu, __entry->id, __entry->load_avg,
++		  __entry->shares, __entry->tg_load_avg_contrib)
++);
++#endif /* CONFIG_FAIR_GROUP_SCHED */
+ #endif /* CONFIG_SMP */
+ #endif /* _TRACE_SCHED_H */
+ 
+diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
+index fffe7cb..3563486 100644
+--- a/kernel/sched/fair.c
++++ b/kernel/sched/fair.c
+@@ -2985,12 +2985,15 @@ static inline void update_tg_load_avg(struct cfs_rq *cfs_rq, int force)
+ 	 * No need to update load_avg for root_task_group as it is not used.
+ 	 */
+ 	if (cfs_rq->tg == &root_task_group)
+-		return;
++		goto trace;
+ 
+ 	if (force || abs(delta) > cfs_rq->tg_load_avg_contrib / 64) {
+ 		atomic_long_add(delta, &cfs_rq->tg->load_avg);
+ 		cfs_rq->tg_load_avg_contrib = cfs_rq->avg.load_avg;
+ 	}
++
++trace:
++	trace_sched_pelt_tg(cfs_rq);
+ }
+ 
+ /*
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0079-sched-Call-cfs_rq-and-sched_entity-PELT-tracepoints-.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0079-sched-Call-cfs_rq-and-sched_entity-PELT-tracepoints-.patch
new file mode 100644
index 0000000..8666804
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0079-sched-Call-cfs_rq-and-sched_entity-PELT-tracepoints-.patch
@@ -0,0 +1,30 @@
+From 1dc0f447d22d781d4ff4d5fa8f789bf41fd56161 Mon Sep 17 00:00:00 2001
+From: Dietmar Eggemann <dietmar.eggemann@arm.com>
+Date: Wed, 12 Oct 2016 17:36:41 +0100
+Subject: [PATCH 79/92] sched: Call cfs_rq and sched_entity PELT tracepoints
+ also in propagate_entity_load_avg()
+
+Signed-off-by: Dietmar Eggemann <dietmar.eggemann@arm.com>
+(cherry picked from commit 20ab5631c366a28b5c7e598107337ac622c41e31)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ kernel/sched/fair.c | 3 +++
+ 1 file changed, 3 insertions(+)
+
+diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
+index 3563486..489f6d3 100644
+--- a/kernel/sched/fair.c
++++ b/kernel/sched/fair.c
+@@ -3160,6 +3160,9 @@ static inline int propagate_entity_load_avg(struct sched_entity *se)
+ 	update_tg_cfs_util(cfs_rq, se);
+ 	update_tg_cfs_load(cfs_rq, se);
+ 
++	trace_sched_pelt_cfs_rq(cfs_rq);
++	trace_sched_pelt_se(se);
++
+ 	return 1;
+ }
+ 
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0080-sched-core-Fix-find_idlest_group-for-fork.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0080-sched-core-Fix-find_idlest_group-for-fork.patch
new file mode 100644
index 0000000..ccf260c
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0080-sched-core-Fix-find_idlest_group-for-fork.patch
@@ -0,0 +1,86 @@
+From 4e4846aafb09473f1ca69fa061e72437b55f78c7 Mon Sep 17 00:00:00 2001
+From: Vincent Guittot <vincent.guittot@linaro.org>
+Date: Thu, 8 Dec 2016 17:56:53 +0100
+Subject: [PATCH 80/92] sched/core: Fix find_idlest_group() for fork
+
+During fork, the utilization of a task is init once the rq has been
+selected because the current utilization level of the rq is used to
+set the utilization of the fork task. As the task's utilization is
+still 0 at this step of the fork sequence, it doesn't make sense to
+look for some spare capacity that can fit the task's utilization.
+Furthermore, I can see perf regressions for the test:
+
+   hackbench -P -g 1
+
+because the least loaded policy is always bypassed and tasks are not
+spread during fork.
+
+With this patch and the fix below, we are back to same performances as
+for v4.8. The fix below is only a temporary one used for the test
+until a smarter solution is found because we can't simply remove the
+test which is useful for others benchmarks
+
+| @@ -5708,13 +5708,6 @@ static int select_idle_cpu(struct task_struct *p, struct sched_domain *sd, int t
+|
+|	avg_cost = this_sd->avg_scan_cost;
+|
+| -	/*
+| -	 * Due to large variance we need a large fuzz factor; hackbench in
+| -	 * particularly is sensitive here.
+| -	 */
+| -	if ((avg_idle / 512) < avg_cost)
+| -		return -1;
+| -
+|	time = local_clock();
+|
+|	for_each_cpu_wrap(cpu, sched_domain_span(sd), target, wrap) {
+
+Tested-by: Matt Fleming <matt@codeblueprint.co.uk>
+Signed-off-by: Vincent Guittot <vincent.guittot@linaro.org>
+Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
+Reviewed-by: Matt Fleming <matt@codeblueprint.co.uk>
+Acked-by: Morten Rasmussen <morten.rasmussen@arm.com>
+Cc: Linus Torvalds <torvalds@linux-foundation.org>
+Cc: Peter Zijlstra <peterz@infradead.org>
+Cc: Thomas Gleixner <tglx@linutronix.de>
+Cc: dietmar.eggemann@arm.com
+Cc: kernellwp@gmail.com
+Cc: umgwanakikbuti@gmail.com
+Cc: yuyang.du@intel.comc
+Link: http://lkml.kernel.org/r/1481216215-24651-2-git-send-email-vincent.guittot@linaro.org
+Signed-off-by: Ingo Molnar <mingo@kernel.org>
+(cherry picked from commit f2e4ac502860c2adcc5ce56e0064fc4bcab90af4)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ kernel/sched/fair.c | 8 ++++++++
+ 1 file changed, 8 insertions(+)
+
+diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
+index 489f6d3..fea3ca8 100644
+--- a/kernel/sched/fair.c
++++ b/kernel/sched/fair.c
+@@ -5809,13 +5809,21 @@ static unsigned long capacity_spare_wake(int cpu, struct task_struct *p)
+ 	 * utilized systems if we require spare_capacity > task_util(p),
+ 	 * so we allow for some task stuffing by using
+ 	 * spare_capacity > task_util(p)/2.
++	 *
++	 * Spare capacity can't be used for fork because the utilization has
++	 * not been set yet, we must first select a rq to compute the initial
++	 * utilization.
+ 	 */
++	if (sd_flag & SD_BALANCE_FORK)
++		goto skip_spare;
++
+ 	if (this_spare > task_util(p) / 2 &&
+ 	    imbalance*this_spare > 100*most_spare)
+ 		return NULL;
+ 	else if (most_spare > task_util(p) / 2)
+ 		return most_spare_sg;
+ 
++skip_spare:
+ 	if (!idlest || 100*this_load < imbalance*min_load)
+ 		return NULL;
+ 	return idlest;
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0081-SPLIT-sched-fair-Don-t-load-balance-from-group_other.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0081-SPLIT-sched-fair-Don-t-load-balance-from-group_other.patch
new file mode 100644
index 0000000..1258e93
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0081-SPLIT-sched-fair-Don-t-load-balance-from-group_other.patch
@@ -0,0 +1,38 @@
+From 28e38963fbe539c9804d9132aa3613ead32ee330 Mon Sep 17 00:00:00 2001
+From: Brendan Jackman <brendan.jackman@arm.com>
+Date: Wed, 15 Feb 2017 17:17:26 +0000
+Subject: [PATCH 81/92] SPLIT: sched/fair: Don't load balance from group_other
+ to groups without spare capacity
+
+This is split out from 885677858fd "sched: Consider misfit tasks when
+load-balancing" from lsk-4.4-armlt. The rest of that patch will follow, this is
+separated for ease of examination and discussion.
+
+(cherry picked from commit a3e504284acbf3dd12ceec8ebcabaee1892f876e)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ kernel/sched/fair.c | 8 ++++++++
+ 1 file changed, 8 insertions(+)
+
+diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
+index fea3ca8..cf60d93 100644
+--- a/kernel/sched/fair.c
++++ b/kernel/sched/fair.c
+@@ -7750,6 +7750,14 @@ static bool update_sd_pick_busiest(struct lb_env *env,
+ 	if (sgs->group_type < busiest->group_type)
+ 		return false;
+ 
++	/*
++	 * Candidate sg doesn't face any serious load-balance problems
++	 * so don't pick it if the local sg is already filled up.
++	 */
++	if (sgs->group_type == group_other &&
++	    !group_has_capacity(env, &sds->local_stat))
++		return false;
++
+ 	if (sgs->avg_load <= busiest->avg_load)
+ 		return false;
+ 
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0082-sched-Add-group_misfit_task-load-balance-type.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0082-sched-Add-group_misfit_task-load-balance-type.patch
new file mode 100644
index 0000000..d020473
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0082-sched-Add-group_misfit_task-load-balance-type.patch
@@ -0,0 +1,141 @@
+From b58a2c49fdbb556dcc51f750f77424063d92db3c Mon Sep 17 00:00:00 2001
+From: Morten Rasmussen <morten.rasmussen@arm.com>
+Date: Thu, 25 Feb 2016 12:47:54 +0000
+Subject: [PATCH 82/92] sched: Add group_misfit_task load-balance type
+
+To maximize throughput in systems with reduced capacity cpus (e.g.
+high RT/IRQ load and/or ARM big.LITTLE) load-balancing has to consider
+task and cpu utilization as well as per-cpu compute capacity when
+load-balancing in addition to the current average load based
+load-balancing policy. Tasks that are scheduled on a reduced capacity
+cpu need to be identified and migrated to a higher capacity cpu if
+possible.
+
+To implement this additional policy an additional group_type
+(load-balance scenario) is added: group_misfit_task. This represents
+scenarios where a sched_group has tasks that are not suitable for its
+per-cpu capacity. group_misfit_task is only considered if the system is
+not overloaded in any other way (group_imbalanced or group_overloaded).
+
+Identifying misfit tasks requires the rq lock to be held. To avoid
+taking remote rq locks to examine source sched_groups for misfit tasks,
+each cpu is responsible for tracking misfit tasks themselves and update
+the rq->misfit_task flag. This means checking task utilization when
+tasks are scheduled and on sched_tick.
+
+Signed-off-by: Morten Rasmussen <morten.rasmussen@arm.com>
+(cherry picked from commit a1a42660d90a077df8412b6ca763ba76506da8e6)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ kernel/sched/fair.c  | 29 ++++++++++++++++++++++-------
+ kernel/sched/sched.h |  1 +
+ 2 files changed, 23 insertions(+), 7 deletions(-)
+
+diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
+index cf60d93..e7fd15e 100644
+--- a/kernel/sched/fair.c
++++ b/kernel/sched/fair.c
+@@ -6627,6 +6627,8 @@ static void check_preempt_wakeup(struct rq *rq, struct task_struct *p, int wake_
+ 	if (hrtick_enabled(rq))
+ 		hrtick_start_fair(rq, p);
+ 
++	rq->misfit_task = !task_fits_max(p, rq->cpu);
++
+ 	return p;
+ simple:
+ 	cfs_rq = &rq->cfs;
+@@ -6648,9 +6650,12 @@ static void check_preempt_wakeup(struct rq *rq, struct task_struct *p, int wake_
+ 	if (hrtick_enabled(rq))
+ 		hrtick_start_fair(rq, p);
+ 
++	rq->misfit_task = !task_fits_max(p, rq->cpu);
++
+ 	return p;
+ 
+ idle:
++	rq->misfit_task = 0;
+ 	/*
+ 	 * This is OK, because current is on_cpu, which avoids it being picked
+ 	 * for load-balance and preemption/IRQs are still disabled avoiding
+@@ -6863,6 +6868,13 @@ static bool yield_to_task_fair(struct rq *rq, struct task_struct *p, bool preemp
+ 
+ enum fbq_type { regular, remote, all };
+ 
++enum group_type {
++	group_other = 0,
++	group_misfit_task,
++	group_imbalanced,
++	group_overloaded,
++};
++
+ #define LBF_ALL_PINNED	0x01
+ #define LBF_NEED_BREAK	0x02
+ #define LBF_DST_PINNED  0x04
+@@ -7338,12 +7350,6 @@ static unsigned long task_h_load(struct task_struct *p)
+ 
+ /********** Helpers for find_busiest_group ************************/
+ 
+-enum group_type {
+-	group_other = 0,
+-	group_imbalanced,
+-	group_overloaded,
+-};
+-
+ /*
+  * sg_lb_stats - stats of a sched_group required for load_balancing
+  */
+@@ -7359,6 +7365,7 @@ struct sg_lb_stats {
+ 	unsigned int group_weight;
+ 	enum group_type group_type;
+ 	int group_no_capacity;
++	int group_misfit_task; /* A cpu has a task too big for its capacity */
+ #ifdef CONFIG_NUMA_BALANCING
+ 	unsigned int nr_numa_running;
+ 	unsigned int nr_preferred_running;
+@@ -7656,6 +7663,9 @@ group_type group_classify(struct sched_group *group,
+ 	if (sg_imbalanced(group))
+ 		return group_imbalanced;
+ 
++	if (sgs->group_misfit_task)
++		return group_misfit_task;
++
+ 	return group_other;
+ }
+ 
+@@ -7707,8 +7717,11 @@ static inline void update_sg_lb_stats(struct lb_env *env,
+ 		if (!nr_running && idle_cpu(i))
+ 			sgs->idle_cpus++;
+ 
+-		if (cpu_overutilized(i))
++		if (cpu_overutilized(i)) {
+ 			*overutilized = true;
++			if (!sgs->group_misfit_task && rq->misfit_task)
++				sgs->group_misfit_task = capacity_of(i);
++		}
+ 	}
+ 
+ 	/* Adjust by relative CPU capacity of the group */
+@@ -9307,6 +9320,8 @@ static void task_tick_fair(struct rq *rq, struct task_struct *curr, int queued)
+ 
+ 	if (!rq->rd->overutilized && cpu_overutilized(task_cpu(curr)))
+ 		rq->rd->overutilized = true;
++
++	rq->misfit_task = !task_fits_max(curr, rq->cpu);
+ }
+ 
+ /*
+diff --git a/kernel/sched/sched.h b/kernel/sched/sched.h
+index fa98ab3..704d8a4 100644
+--- a/kernel/sched/sched.h
++++ b/kernel/sched/sched.h
+@@ -611,6 +611,7 @@ struct rq {
+ #endif
+ 	#define CPU_LOAD_IDX_MAX 5
+ 	unsigned long cpu_load[CPU_LOAD_IDX_MAX];
++	unsigned int misfit_task;
+ #ifdef CONFIG_NO_HZ_COMMON
+ #ifdef CONFIG_SMP
+ 	unsigned long last_load_update_tick;
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0083-sched-Consider-misfit-tasks-when-load-balancing.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0083-sched-Consider-misfit-tasks-when-load-balancing.patch
new file mode 100644
index 0000000..db57a58
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0083-sched-Consider-misfit-tasks-when-load-balancing.patch
@@ -0,0 +1,180 @@
+From 488802cf1168582adc4fdd039ecd5b3dfe652085 Mon Sep 17 00:00:00 2001
+From: Morten Rasmussen <morten.rasmussen@arm.com>
+Date: Tue, 28 Jul 2015 15:42:47 +0100
+Subject: [PATCH 83/92] sched: Consider misfit tasks when load-balancing
+
+With the new group_misfit_task load-balancing scenario additional policy
+conditions are needed when load-balancing. Misfit task balancing only
+makes sense between source group with lower capacity than the target
+group. If capacities are the same, fallback to normal group_other
+balancing. The aim is to balance tasks such that no task has its
+throughput hindered by compute capacity if a cpu with more capacity is
+available. Load-balancing is generally based on average load in the
+sched_groups, but for misfitting tasks it is necessary to introduce
+exceptions to migrate tasks against usual metrics and optimize
+throughput.
+
+This patch ensures the following load-balance for mixed capacity systems
+(e.g. ARM big.LITTLE) for always-running tasks:
+
+1. Place a task on each cpu starting in order from cpus with highest
+capacity to lowest until all cpus are in use (i.e. one task on each
+cpu).
+
+2. Once all cpus are in use balance according to compute capacity such
+that load per capacity is approximately the same regardless of the
+compute capacity (i.e. big cpus get more tasks than little cpus).
+
+Necessary changes are introduced in find_busiest_group(),
+calculate_imbalance(), and find_busiest_queue(). This includes passing
+the group_type on to find_busiest_queue() through struct lb_env, which
+is currently only considers imbalance and not the imbalance situation
+(group_type).
+
+To avoid taking remote rq locks to examine source sched_groups for
+misfit tasks, each cpu is responsible for tracking misfit tasks
+themselves and update the rq->misfit_task flag. This means checking task
+utilization when tasks are scheduled and on sched_tick.
+
+Change-Id: I458461cebf269d6d4eeac6f83e4c84f4e4d7a9dd
+Signed-off-by: Morten Rasmussen <morten.rasmussen@arm.com>
+(cherry picked from commit bcd0dfada3e8abb6f1d5cff73134fc54ab76f409)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ kernel/sched/fair.c | 64 +++++++++++++++++++++++++++++++++++++++++++++++++++--
+ 1 file changed, 62 insertions(+), 2 deletions(-)
+
+diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
+index e7fd15e..966af0b 100644
+--- a/kernel/sched/fair.c
++++ b/kernel/sched/fair.c
+@@ -6169,6 +6169,27 @@ static int wake_cap(struct task_struct *p, int cpu, int prev_cpu)
+ 	return min_cap * 1024 < task_util(p) * capacity_margin;
+ }
+ 
++static inline bool __task_fits(struct task_struct *p, int cpu, int util)
++{
++	unsigned long capacity = capacity_of(cpu);
++
++	return (capacity * 1024) > (util * capacity_margin);
++}
++
++static inline bool task_fits_max(struct task_struct *p, int cpu)
++{
++	unsigned long capacity = capacity_of(cpu);
++	unsigned long max_capacity = cpu_rq(cpu)->rd->max_cpu_capacity;
++
++	if (capacity == max_capacity)
++		return true;
++
++	if (capacity * capacity_margin > max_capacity * 1024)
++		return true;
++
++	return __task_fits(p, cpu, 0);
++}
++
+ static bool cpu_overutilized(int cpu)
+ {
+ 	return (capacity_of(cpu) * 1024) < (cpu_util(cpu) * capacity_margin);
+@@ -6904,6 +6925,7 @@ struct lb_env {
+ 	unsigned int		loop_max;
+ 
+ 	enum fbq_type		fbq_type;
++	enum group_type		busiest_group_type;
+ 	struct list_head	tasks;
+ };
+ 
+@@ -7902,6 +7924,15 @@ static inline void update_sd_lb_stats(struct lb_env *env, struct sd_lb_stats *sd
+ 			sgs->group_type = group_classify(sg, sgs);
+ 		}
+ 
++		/*
++		 * Ignore task groups with misfit tasks if local group has no
++		 * capacity or if per-cpu capacity isn't higher.
++		 */
++		if (sgs->group_type == group_misfit_task &&
++		    (!group_has_capacity(env, &sds->local_stat) ||
++		     !group_smaller_cpu_capacity(sg, sds->local)))
++			sgs->group_type = group_other;
++
+ 		if (update_sd_pick_busiest(env, sds, sg, sgs)) {
+ 			sds->busiest = sg;
+ 			sds->busiest_stat = *sgs;
+@@ -8082,6 +8113,22 @@ static inline void calculate_imbalance(struct lb_env *env, struct sd_lb_stats *s
+ 	 */
+ 	if (busiest->avg_load <= sds->avg_load ||
+ 	    local->avg_load >= sds->avg_load) {
++		/* Misfitting tasks should be migrated in any case */
++		if (busiest->group_type == group_misfit_task) {
++			env->imbalance = busiest->group_misfit_task;
++			return;
++		}
++
++		/*
++		 * Busiest group is overloaded, local is not, use the spare
++		 * cycles to maximize throughput
++		 */
++		if (busiest->group_type == group_overloaded &&
++		    local->group_type <= group_misfit_task) {
++			env->imbalance = busiest->load_per_task;
++			return;
++		}
++
+ 		env->imbalance = 0;
+ 		return fix_small_imbalance(env, sds);
+ 	}
+@@ -8115,6 +8162,11 @@ static inline void calculate_imbalance(struct lb_env *env, struct sd_lb_stats *s
+ 		(sds->avg_load - local->avg_load) * local->group_capacity
+ 	) / SCHED_CAPACITY_SCALE;
+ 
++	/* Boost imbalance to allow misfit task to be balanced. */
++	if (busiest->group_type == group_misfit_task)
++		env->imbalance = max_t(long, env->imbalance,
++				     busiest->group_misfit_task);
++
+ 	/*
+ 	 * if *imbalance is less than the average load per runnable task
+ 	 * there is no guarantee that any tasks will be moved so we'll have
+@@ -8181,6 +8233,11 @@ static struct sched_group *find_busiest_group(struct lb_env *env)
+ 	    busiest->group_no_capacity)
+ 		goto force_balance;
+ 
++	/* Misfitting tasks should be dealt with regardless of the avg load */
++	if (busiest->group_type == group_misfit_task) {
++		goto force_balance;
++	}
++
+ 	/*
+ 	 * If the local group is busier than the selected busiest group
+ 	 * don't try and pull any tasks.
+@@ -8204,7 +8261,8 @@ static struct sched_group *find_busiest_group(struct lb_env *env)
+ 		 * might end up to just move the imbalance on another group
+ 		 */
+ 		if ((busiest->group_type != group_overloaded) &&
+-				(local->idle_cpus <= (busiest->idle_cpus + 1)))
++		    (local->idle_cpus <= (busiest->idle_cpus + 1)) &&
++		    !group_smaller_cpu_capacity(sds.busiest, sds.local))
+ 			goto out_balanced;
+ 	} else {
+ 		/*
+@@ -8217,6 +8275,7 @@ static struct sched_group *find_busiest_group(struct lb_env *env)
+ 	}
+ 
+ force_balance:
++	env->busiest_group_type = busiest->group_type;
+ 	/* Looks like there is an imbalance. Compute it */
+ 	calculate_imbalance(env, &sds);
+ 	return sds.busiest;
+@@ -8275,7 +8334,8 @@ static struct rq *find_busiest_queue(struct lb_env *env,
+ 		 */
+ 
+ 		if (rq->nr_running == 1 && wl > env->imbalance &&
+-		    !check_cpu_capacity(rq, env->sd))
++		    !check_cpu_capacity(rq, env->sd) &&
++		    env->busiest_group_type != group_misfit_task)
+ 			continue;
+ 
+ 		/*
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0084-arm64-dts-r8a7795-Add-multi-cluster-definition.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0084-arm64-dts-r8a7795-Add-multi-cluster-definition.patch
new file mode 100644
index 0000000..bf83a88
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0084-arm64-dts-r8a7795-Add-multi-cluster-definition.patch
@@ -0,0 +1,59 @@
+From 0fe892a26802ebd96f9e565760c4cb215babb96a Mon Sep 17 00:00:00 2001
+From: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+Date: Thu, 1 Oct 2015 14:50:38 +0900
+Subject: [PATCH 84/92] arm64: dts: r8a7795: Add multi-cluster definition
+
+This patch adds the "cpu-map" for multi-cluster into r8a7795
+device-tree. This definition is used to parse the cpu topology.
+
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ arch/arm64/boot/dts/renesas/r8a7795.dtsi | 32 ++++++++++++++++++++++++++++++++
+ 1 file changed, 32 insertions(+)
+
+diff --git a/arch/arm64/boot/dts/renesas/r8a7795.dtsi b/arch/arm64/boot/dts/renesas/r8a7795.dtsi
+index 94262a1..22df16ba 100644
+--- a/arch/arm64/boot/dts/renesas/r8a7795.dtsi
++++ b/arch/arm64/boot/dts/renesas/r8a7795.dtsi
+@@ -55,6 +55,38 @@
+ 		#address-cells = <1>;
+ 		#size-cells = <0>;
+ 
++		cpu-map {
++			cluster0 {
++				core0 {
++					cpu = <&a57_0>;
++				};
++				core1 {
++					cpu = <&a57_1>;
++				};
++				core2 {
++					cpu = <&a57_2>;
++				};
++				core3 {
++					cpu = <&a57_3>;
++				};
++			};
++
++			cluster1 {
++				core0 {
++					cpu = <&a53_0>;
++				};
++				core1 {
++					cpu = <&a53_1>;
++				};
++				core2 {
++					cpu = <&a53_2>;
++				};
++				core3 {
++					cpu = <&a53_3>;
++				};
++			};
++		};
++
+ 		a57_0: cpu@0 {
+ 			compatible = "arm,cortex-a57", "arm,armv8";
+ 			reg = <0x0>;
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0085-arm64-dts-r8a7796-Add-multi-cluster-definition.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0085-arm64-dts-r8a7796-Add-multi-cluster-definition.patch
new file mode 100644
index 0000000..039b5fe
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0085-arm64-dts-r8a7796-Add-multi-cluster-definition.patch
@@ -0,0 +1,53 @@
+From 5a7311047ea788378333397c2e4659a1623315f5 Mon Sep 17 00:00:00 2001
+From: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+Date: Thu, 25 Aug 2016 14:14:07 +0900
+Subject: [PATCH 85/92] arm64: dts: r8a7796: Add multi-cluster definition
+
+This patch adds the "cpu-map" for multi-cluster into r8a7796
+device-tree. This definition is used to parse the cpu topology.
+
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ arch/arm64/boot/dts/renesas/r8a7796.dtsi | 26 ++++++++++++++++++++++++++
+ 1 file changed, 26 insertions(+)
+
+diff --git a/arch/arm64/boot/dts/renesas/r8a7796.dtsi b/arch/arm64/boot/dts/renesas/r8a7796.dtsi
+index afdd69d..de8e219 100644
+--- a/arch/arm64/boot/dts/renesas/r8a7796.dtsi
++++ b/arch/arm64/boot/dts/renesas/r8a7796.dtsi
+@@ -54,6 +54,32 @@
+ 		#address-cells = <1>;
+ 		#size-cells = <0>;
+ 
++		cpu-map {
++			cluster0 {
++				core0 {
++					cpu = <&a57_0>;
++				};
++				core1 {
++					cpu = <&a57_1>;
++				};
++			};
++
++			cluster1 {
++				core0 {
++					cpu = <&a53_0>;
++				};
++				core1 {
++					cpu = <&a53_1>;
++				};
++				core2 {
++					cpu = <&a53_2>;
++				};
++				core3 {
++					cpu = <&a53_3>;
++				};
++			};
++		};
++
+ 		a57_0: cpu@0 {
+ 			compatible = "arm,cortex-a57", "arm,armv8";
+ 			reg = <0x0>;
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0086-arm64-dts-r8a7795-es1-Add-multi-cluster-definition.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0086-arm64-dts-r8a7795-es1-Add-multi-cluster-definition.patch
new file mode 100644
index 0000000..b0b60f3
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0086-arm64-dts-r8a7795-es1-Add-multi-cluster-definition.patch
@@ -0,0 +1,59 @@
+From 60138899758aaa6b794325dd933911765a8e7ed2 Mon Sep 17 00:00:00 2001
+From: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+Date: Fri, 24 Mar 2017 18:40:28 +0900
+Subject: [PATCH 86/92] arm64: dts: r8a7795-es1: Add multi-cluster definition
+
+This patch adds the "cpu-map" for multi-cluster into r8a7795-es1
+device-tree. This definition is used to parse the cpu topology.
+
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ arch/arm64/boot/dts/renesas/r8a7795-es1.dtsi | 32 ++++++++++++++++++++++++++++
+ 1 file changed, 32 insertions(+)
+
+diff --git a/arch/arm64/boot/dts/renesas/r8a7795-es1.dtsi b/arch/arm64/boot/dts/renesas/r8a7795-es1.dtsi
+index 2bf5911..a8dae60a 100644
+--- a/arch/arm64/boot/dts/renesas/r8a7795-es1.dtsi
++++ b/arch/arm64/boot/dts/renesas/r8a7795-es1.dtsi
+@@ -60,6 +60,38 @@
+ 		#address-cells = <1>;
+ 		#size-cells = <0>;
+ 
++		cpu-map {
++			cluster0 {
++				core0 {
++					cpu = <&a57_0>;
++				};
++				core1 {
++					cpu = <&a57_1>;
++				};
++				core2 {
++					cpu = <&a57_2>;
++				};
++				core3 {
++					cpu = <&a57_3>;
++				};
++			};
++
++			cluster1 {
++				core0 {
++					cpu = <&a53_0>;
++				};
++				core1 {
++					cpu = <&a53_1>;
++				};
++				core2 {
++					cpu = <&a53_2>;
++				};
++				core3 {
++					cpu = <&a53_3>;
++				};
++			};
++		};
++
+ 		a57_0: cpu@0 {
+ 			compatible = "arm,cortex-a57", "arm,armv8";
+ 			reg = <0x0>;
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0087-arm64-dts-r8a7795-Add-cpu-capacity-dmips-mhz.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0087-arm64-dts-r8a7795-Add-cpu-capacity-dmips-mhz.patch
new file mode 100644
index 0000000..a9b9c41
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0087-arm64-dts-r8a7795-Add-cpu-capacity-dmips-mhz.patch
@@ -0,0 +1,84 @@
+From eb679d47b12f08b67c3a1046bd956add4848697f Mon Sep 17 00:00:00 2001
+From: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+Date: Fri, 24 Mar 2017 19:13:27 +0900
+Subject: [PATCH 87/92] arm64: dts: r8a7795: Add cpu capacity-dmips-mhz
+
+Set the capacity-dmips-mhz for R-CAR H3(ES2.0).
+This value is based on the result of the evaluation.
+
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ arch/arm64/boot/dts/renesas/r8a7795.dtsi | 8 ++++++++
+ 1 file changed, 8 insertions(+)
+
+diff --git a/arch/arm64/boot/dts/renesas/r8a7795.dtsi b/arch/arm64/boot/dts/renesas/r8a7795.dtsi
+index 3a27bdb..eff01d6 100644
+--- a/arch/arm64/boot/dts/renesas/r8a7795.dtsi
++++ b/arch/arm64/boot/dts/renesas/r8a7795.dtsi
+@@ -105,6 +105,7 @@
+ 				<&cluster0_opp_tb3>, <&cluster0_opp_tb4>,
+ 				<&cluster0_opp_tb5>, <&cluster0_opp_tb6>,
+ 				<&cluster0_opp_tb7>;
++			capacity-dmips-mhz = <1024>;
+ 		};
+ 
+ 		a57_1: cpu@1 {
+@@ -120,6 +121,7 @@
+ 				<&cluster0_opp_tb3>, <&cluster0_opp_tb4>,
+ 				<&cluster0_opp_tb5>, <&cluster0_opp_tb6>,
+ 				<&cluster0_opp_tb7>;
++			capacity-dmips-mhz = <1024>;
+ 		};
+ 
+ 		a57_2: cpu@2 {
+@@ -135,6 +137,7 @@
+ 				<&cluster0_opp_tb3>, <&cluster0_opp_tb4>,
+ 				<&cluster0_opp_tb5>, <&cluster0_opp_tb6>,
+ 				<&cluster0_opp_tb7>;
++			capacity-dmips-mhz = <1024>;
+ 		};
+ 
+ 		a57_3: cpu@3 {
+@@ -150,6 +153,7 @@
+ 				<&cluster0_opp_tb3>, <&cluster0_opp_tb4>,
+ 				<&cluster0_opp_tb5>, <&cluster0_opp_tb6>,
+ 				<&cluster0_opp_tb7>;
++			capacity-dmips-mhz = <1024>;
+ 		};
+ 
+ 		a53_0: cpu@100 {
+@@ -161,6 +165,7 @@
+ 			dynamic-power-coefficient = <277>;
+ 			clocks =<&cpg CPG_CORE R8A7795_CLK_Z2>;
+ 			operating-points-v2 = <&cluster1_opp_tb0>;
++			capacity-dmips-mhz = <379>;
+ 		};
+ 
+ 		a53_1: cpu@101 {
+@@ -170,6 +175,7 @@
+ 			next-level-cache = <&L2_CA53>;
+ 			enable-method = "psci";
+ 			operating-points-v2 = <&cluster1_opp_tb0>;
++			capacity-dmips-mhz = <379>;
+ 		};
+ 
+ 		a53_2: cpu@102 {
+@@ -179,6 +185,7 @@
+ 			next-level-cache = <&L2_CA53>;
+ 			enable-method = "psci";
+ 			operating-points-v2 = <&cluster1_opp_tb0>;
++			capacity-dmips-mhz = <379>;
+ 		};
+ 
+ 		a53_3: cpu@103 {
+@@ -188,6 +195,7 @@
+ 			next-level-cache = <&L2_CA53>;
+ 			enable-method = "psci";
+ 			operating-points-v2 = <&cluster1_opp_tb0>;
++			capacity-dmips-mhz = <379>;
+ 		};
+ 
+ 		L2_CA57: cache-controller@0 {
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0088-arm64-dts-r8a7796-Add-cpu-capacity-dmips-mhz.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0088-arm64-dts-r8a7796-Add-cpu-capacity-dmips-mhz.patch
new file mode 100644
index 0000000..59e00ef
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0088-arm64-dts-r8a7796-Add-cpu-capacity-dmips-mhz.patch
@@ -0,0 +1,68 @@
+From b97005ea6b5891f1d2251828f38011971545c4f9 Mon Sep 17 00:00:00 2001
+From: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+Date: Fri, 24 Mar 2017 19:56:34 +0900
+Subject: [PATCH 88/92] arm64: dts: r8a7796: Add cpu capacity-dmips-mhz
+
+Set the capacity-dmips-mhz for R-CAR M3.
+This value is based on the result of the evaluation.
+
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ arch/arm64/boot/dts/renesas/r8a7796.dtsi | 6 ++++++
+ 1 file changed, 6 insertions(+)
+
+diff --git a/arch/arm64/boot/dts/renesas/r8a7796.dtsi b/arch/arm64/boot/dts/renesas/r8a7796.dtsi
+index 47b8af0..da26f88 100644
+--- a/arch/arm64/boot/dts/renesas/r8a7796.dtsi
++++ b/arch/arm64/boot/dts/renesas/r8a7796.dtsi
+@@ -98,6 +98,7 @@
+ 				<&cluster0_opp_tb3>, <&cluster0_opp_tb4>,
+ 				<&cluster0_opp_tb5>, <&cluster0_opp_tb6>,
+ 				<&cluster0_opp_tb7>;
++			capacity-dmips-mhz = <1024>;
+ 		};
+ 
+ 		a57_1: cpu@1 {
+@@ -113,6 +114,7 @@
+ 				<&cluster0_opp_tb3>, <&cluster0_opp_tb4>,
+ 				<&cluster0_opp_tb5>, <&cluster0_opp_tb6>,
+ 				<&cluster0_opp_tb7>;
++			capacity-dmips-mhz = <1024>;
+ 		};
+ 
+ 		a53_0: cpu@100 {
+@@ -124,6 +126,7 @@
+ 			dynamic-power-coefficient = <277>;
+ 			clocks =<&cpg CPG_CORE R8A7796_CLK_Z2>;
+ 			operating-points-v2 = <&cluster1_opp_tb0>;
++			capacity-dmips-mhz = <362>;
+ 		};
+ 
+ 		a53_1: cpu@101 {
+@@ -133,6 +136,7 @@
+ 			next-level-cache = <&L2_CA53>;
+ 			enable-method = "psci";
+ 			operating-points-v2 = <&cluster1_opp_tb0>;
++			capacity-dmips-mhz = <362>;
+ 		};
+ 
+ 		a53_2: cpu@102 {
+@@ -142,6 +146,7 @@
+ 			next-level-cache = <&L2_CA53>;
+ 			enable-method = "psci";
+ 			operating-points-v2 = <&cluster1_opp_tb0>;
++			capacity-dmips-mhz = <362>;
+ 		};
+ 
+ 		a53_3: cpu@103 {
+@@ -151,6 +156,7 @@
+ 			next-level-cache = <&L2_CA53>;
+ 			enable-method = "psci";
+ 			operating-points-v2 = <&cluster1_opp_tb0>;
++			capacity-dmips-mhz = <362>;
+ 		};
+ 
+ 		L2_CA57: cache-controller@0 {
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0089-arm64-dts-r8a7795-es1-Add-cpu-capacity-dmips-mhz.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0089-arm64-dts-r8a7795-es1-Add-cpu-capacity-dmips-mhz.patch
new file mode 100644
index 0000000..5ef1bf8
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0089-arm64-dts-r8a7795-es1-Add-cpu-capacity-dmips-mhz.patch
@@ -0,0 +1,84 @@
+From 4461e893a07445bcbb54a6bbf4919955c1d22e5e Mon Sep 17 00:00:00 2001
+From: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+Date: Fri, 24 Mar 2017 19:59:17 +0900
+Subject: [PATCH 89/92] arm64: dts: r8a7795-es1: Add cpu capacity-dmips-mhz
+
+Set the capacity-dmips-mhz for R-CAR H3(ES1.x).
+This value is based on the result of the evaluation.
+
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ arch/arm64/boot/dts/renesas/r8a7795-es1.dtsi | 8 ++++++++
+ 1 file changed, 8 insertions(+)
+
+diff --git a/arch/arm64/boot/dts/renesas/r8a7795-es1.dtsi b/arch/arm64/boot/dts/renesas/r8a7795-es1.dtsi
+index 172007a..c2b5b8d 100644
+--- a/arch/arm64/boot/dts/renesas/r8a7795-es1.dtsi
++++ b/arch/arm64/boot/dts/renesas/r8a7795-es1.dtsi
+@@ -110,6 +110,7 @@
+ 				<&cluster0_opp_tb3>, <&cluster0_opp_tb4>,
+ 				<&cluster0_opp_tb5>, <&cluster0_opp_tb6>,
+ 				<&cluster0_opp_tb7>;
++			capacity-dmips-mhz = <1024>;
+ 		};
+ 
+ 		a57_1: cpu@1 {
+@@ -125,6 +126,7 @@
+ 				<&cluster0_opp_tb3>, <&cluster0_opp_tb4>,
+ 				<&cluster0_opp_tb5>, <&cluster0_opp_tb6>,
+ 				<&cluster0_opp_tb7>;
++			capacity-dmips-mhz = <1024>;
+ 		};
+ 
+ 		a57_2: cpu@2 {
+@@ -140,6 +142,7 @@
+ 				<&cluster0_opp_tb3>, <&cluster0_opp_tb4>,
+ 				<&cluster0_opp_tb5>, <&cluster0_opp_tb6>,
+ 				<&cluster0_opp_tb7>;
++			capacity-dmips-mhz = <1024>;
+ 		};
+ 
+ 		a57_3: cpu@3 {
+@@ -155,6 +158,7 @@
+ 				<&cluster0_opp_tb3>, <&cluster0_opp_tb4>,
+ 				<&cluster0_opp_tb5>, <&cluster0_opp_tb6>,
+ 				<&cluster0_opp_tb7>;
++			capacity-dmips-mhz = <1024>;
+ 		};
+ 
+ 		a53_0: cpu@100 {
+@@ -166,6 +170,7 @@
+ 			dynamic-power-coefficient = <277>;
+ 			clocks =<&cpg CPG_CORE R8A7795_CLK_Z2>;
+ 			operating-points-v2 = <&cluster1_opp_tb0>;
++			capacity-dmips-mhz = <379>;
+ 		};
+ 
+ 		a53_1: cpu@101 {
+@@ -175,6 +180,7 @@
+ 			next-level-cache = <&L2_CA53>;
+ 			enable-method = "psci";
+ 			operating-points-v2 = <&cluster1_opp_tb0>;
++			capacity-dmips-mhz = <379>;
+ 		};
+ 
+ 		a53_2: cpu@102 {
+@@ -184,6 +190,7 @@
+ 			next-level-cache = <&L2_CA53>;
+ 			enable-method = "psci";
+ 			operating-points-v2 = <&cluster1_opp_tb0>;
++			capacity-dmips-mhz = <379>;
+ 		};
+ 
+ 		a53_3: cpu@103 {
+@@ -193,6 +200,7 @@
+ 			next-level-cache = <&L2_CA53>;
+ 			enable-method = "psci";
+ 			operating-points-v2 = <&cluster1_opp_tb0>;
++			capacity-dmips-mhz = <379>;
+ 		};
+ 
+ 		L2_CA57: cache-controller@0 {
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0090-arm64-Define-R-CAR-Gen3-energy-and-provide-it-to-the.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0090-arm64-Define-R-CAR-Gen3-energy-and-provide-it-to-the.patch
new file mode 100644
index 0000000..c1d7ef8
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0090-arm64-Define-R-CAR-Gen3-energy-and-provide-it-to-the.patch
@@ -0,0 +1,224 @@
+From 5881cc9ff86977d3d506f9f9549f2ffcca0fb932 Mon Sep 17 00:00:00 2001
+From: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+Date: Fri, 24 Mar 2017 20:10:51 +0900
+Subject: [PATCH 90/92] arm64: Define R-CAR Gen3 energy and provide it to the
+ scheduler
+
+Set the capacity and the power for R-CAR H3 and M3.
+This value is based on the result of the evaluation.
+
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ arch/arm64/kernel/energy_model.h | 186 +++++++++++++++++++++++++++++++++++++++
+ 1 file changed, 186 insertions(+)
+
+diff --git a/arch/arm64/kernel/energy_model.h b/arch/arm64/kernel/energy_model.h
+index 0a7c134..c2aae4f 100644
+--- a/arch/arm64/kernel/energy_model.h
++++ b/arch/arm64/kernel/energy_model.h
+@@ -171,6 +171,178 @@
+ 	.cap_states     = cap_states_core_hikey,
+ };
+ 
++/* R-Car Gen3 */
++
++static struct idle_state idle_states_cluster_h3_a53[] = {
++	{ .power = 17 }, /* arch_cpu_idle() (active idle) = WFI */
++	{ .power = 17 }, /* WFI */
++	{ .power =  0 }, /* cpu-sleep-0 */
++	{ .power =  0 }, /* cluster-sleep-0 */
++};
++
++static struct idle_state idle_states_cluster_h3_a57[] = {
++	{ .power = 112 }, /* arch_cpu_idle() (active idle) = WFI */
++	{ .power = 112 }, /* WFI */
++	{ .power =   0 }, /* cpu-sleep-0 */
++	{ .power =   0 }, /* cluster-sleep-0 */
++};
++
++static struct capacity_state cap_states_cluster_h3_a53[] = {
++	/* Power per cluster */
++	{ .cap =  379, .power = 16, }, /* 1200 MHz */
++};
++
++static struct capacity_state cap_states_cluster_h3_a57[] = {
++	/* Power per cluster */
++	{ .cap =  308, .power =  33, }, /*  500 MHz */
++	{ .cap =  596, .power =  71, }, /* 1000 MHz */
++	{ .cap =  898, .power = 112, }, /* 1500 MHz */
++	{ .cap =  965, .power = 126, }, /* 1600 MHz */
++	{ .cap = 1024, .power = 154, }, /* 1700 MHz */
++};
++
++static struct sched_group_energy energy_cluster_h3_a53 = {
++	.nr_idle_states = ARRAY_SIZE(idle_states_cluster_h3_a53),
++	.idle_states    = idle_states_cluster_h3_a53,
++	.nr_cap_states  = ARRAY_SIZE(cap_states_cluster_h3_a53),
++	.cap_states     = cap_states_cluster_h3_a53,
++};
++
++static struct sched_group_energy energy_cluster_h3_a57 = {
++	.nr_idle_states = ARRAY_SIZE(idle_states_cluster_h3_a57),
++	.idle_states    = idle_states_cluster_h3_a57,
++	.nr_cap_states  = ARRAY_SIZE(cap_states_cluster_h3_a57),
++	.cap_states     = cap_states_cluster_h3_a57,
++};
++
++static struct idle_state idle_states_core_h3_a53[] = {
++	{ .power = 17 }, /* arch_cpu_idle() (active idle) = WFI */
++	{ .power = 17 }, /* WFI */
++	{ .power =  0 }, /* cpu-sleep-0 */
++	{ .power =  0 }, /* cluster-sleep-0 */
++};
++
++static struct idle_state idle_states_core_h3_a57[] = {
++	{ .power = 71 }, /* arch_cpu_idle() (active idle) = WFI */
++	{ .power = 71 }, /* WFI */
++	{ .power =  0 }, /* cpu-sleep-0 */
++	{ .power =  0 }, /* cluster-sleep-0 */
++};
++
++static struct capacity_state cap_states_core_h3_a53[] = {
++	/* Power per cpu */
++	{ .cap =  379, .power = 131, }, /* 1200 MHz */
++};
++
++static struct capacity_state cap_states_core_h3_a57[] = {
++	/* Power per cpu */
++	{ .cap =  308, .power =  315, }, /*  500 MHz */
++	{ .cap =  596, .power =  618, }, /* 1000 MHz */
++	{ .cap =  898, .power =  934, }, /* 1500 MHz */
++	{ .cap =  965, .power = 1044, }, /* 1600 MHz */
++	{ .cap = 1024, .power = 1286, }, /* 1700 MHz */
++};
++
++static struct sched_group_energy energy_core_h3_a53 = {
++	.nr_idle_states = ARRAY_SIZE(idle_states_core_h3_a53),
++	.idle_states    = idle_states_core_h3_a53,
++	.nr_cap_states  = ARRAY_SIZE(cap_states_core_h3_a53),
++	.cap_states     = cap_states_core_h3_a53,
++};
++
++static struct sched_group_energy energy_core_h3_a57 = {
++	.nr_idle_states = ARRAY_SIZE(idle_states_core_h3_a57),
++	.idle_states    = idle_states_core_h3_a57,
++	.nr_cap_states  = ARRAY_SIZE(cap_states_core_h3_a57),
++	.cap_states     = cap_states_core_h3_a57,
++};
++
++static struct idle_state idle_states_cluster_m3_a53[] = {
++	{ .power = 33 }, /* arch_cpu_idle() (active idle) = WFI */
++	{ .power = 33 }, /* WFI */
++	{ .power =  0 }, /* cpu-sleep-0 */
++	{ .power =  0 }, /* cluster-sleep-0 */
++};
++
++static struct idle_state idle_states_cluster_m3_a57[] = {
++	{ .power = 66 }, /* arch_cpu_idle() (active idle) = WFI */
++	{ .power = 66 }, /* WFI */
++	{ .power =  0 }, /* cpu-sleep-0 */
++	{ .power =  0 }, /* cluster-sleep-0 */
++};
++
++static struct capacity_state cap_states_cluster_m3_a53[] = {
++	/* Power per cluster */
++	{ .cap =  362, .power = 33, }, /* 1200 MHz */
++};
++
++static struct capacity_state cap_states_cluster_m3_a57[] = {
++	/* Power per cluster */
++	{ .cap =  293, .power =  17, }, /*  500 MHz */
++	{ .cap =  560, .power =  42, }, /* 1000 MHz */
++	{ .cap =  853, .power =  66, }, /* 1500 MHz */
++	{ .cap =  910, .power =  72, }, /* 1600 MHz */
++	{ .cap =  967, .power =  90, }, /* 1700 MHz */
++	{ .cap = 1024, .power = 115, }, /* 1800 MHz */
++};
++
++static struct sched_group_energy energy_cluster_m3_a53 = {
++	.nr_idle_states = ARRAY_SIZE(idle_states_cluster_m3_a53),
++	.idle_states    = idle_states_cluster_m3_a53,
++	.nr_cap_states  = ARRAY_SIZE(cap_states_cluster_m3_a53),
++	.cap_states     = cap_states_cluster_m3_a53,
++};
++
++static struct sched_group_energy energy_cluster_m3_a57 = {
++	.nr_idle_states = ARRAY_SIZE(idle_states_cluster_m3_a57),
++	.idle_states    = idle_states_cluster_m3_a57,
++	.nr_cap_states  = ARRAY_SIZE(cap_states_cluster_m3_a57),
++	.cap_states     = cap_states_cluster_m3_a57,
++};
++
++static struct idle_state idle_states_core_m3_a53[] = {
++	{ .power = 16 }, /* arch_cpu_idle() (active idle) = WFI */
++	{ .power = 16 }, /* WFI */
++	{ .power =  0 }, /* cpu-sleep-0 */
++	{ .power =  0 }, /* cluster-sleep-0 */
++};
++
++static struct idle_state idle_states_core_m3_a57[] = {
++	{ .power = 83 }, /* arch_cpu_idle() (active idle) = WFI */
++	{ .power = 83 }, /* WFI */
++	{ .power =  0 }, /* cpu-sleep-0 */
++	{ .power =  0 }, /* cluster-sleep-0 */
++};
++
++static struct capacity_state cap_states_core_m3_a53[] = {
++	/* Power per cpu */
++	{ .cap =  362, .power = 131, }, /* 1200 MHz */
++};
++
++static struct capacity_state cap_states_core_m3_a57[] = {
++	/* Power per cpu */
++	{ .cap =  293, .power =  299, }, /*  500 MHz */
++	{ .cap =  560, .power =  581, }, /* 1000 MHz */
++	{ .cap =  853, .power =  888, }, /* 1500 MHz */
++	{ .cap =  910, .power = 1098, }, /* 1600 MHz */
++	{ .cap =  967, .power = 1179, }, /* 1700 MHz */
++	{ .cap = 1024, .power = 1421, }, /* 1800 MHz */
++};
++
++static struct sched_group_energy energy_core_m3_a53 = {
++	.nr_idle_states = ARRAY_SIZE(idle_states_core_m3_a53),
++	.idle_states    = idle_states_core_m3_a53,
++	.nr_cap_states  = ARRAY_SIZE(cap_states_core_m3_a53),
++	.cap_states     = cap_states_core_m3_a53,
++};
++
++static struct sched_group_energy energy_core_m3_a57 = {
++	  .nr_idle_states = ARRAY_SIZE(idle_states_core_m3_a57),
++	  .idle_states    = idle_states_core_m3_a57,
++	  .nr_cap_states  = ARRAY_SIZE(cap_states_core_m3_a57),
++	  .cap_states     = cap_states_core_m3_a57,
++};
++
+ /* An energy model contains core, cluster and system sched group energy
+  * for 2 clusters (cluster id 0 and 1). set_energy_model() relies on
+  * this feature. It is enforced by a BUG_ON in energy().
+@@ -194,9 +366,23 @@ struct energy_model {
+ 	{ &energy_system_hikey, &energy_system_hikey, },
+ };
+ 
++static struct energy_model r8a7795_model = {
++	{ &energy_core_h3_a57, &energy_core_h3_a53, },
++	{ &energy_cluster_h3_a57, &energy_cluster_h3_a53, },
++	{},
++};
++
++static struct energy_model r8a7796_model = {
++	{ &energy_core_m3_a57, &energy_core_m3_a53, },
++	{ &energy_cluster_m3_a57, &energy_cluster_m3_a53, },
++	{},
++};
++
+ static struct of_device_id model_matches[] = {
+ 	{ .compatible = "arm,juno", .data = &juno_model },
+ 	{ .compatible = "hisilicon,hi6220-hikey", .data = &hikey_model },
++	{ .compatible = "renesas,r8a7795", .data = &r8a7795_model },
++	{ .compatible = "renesas,r8a7796", .data = &r8a7796_model },
+ 	{},
+ };
+ 
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0091-sched-Enable-energy-awareness-a-sched-feature-by-def.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0091-sched-Enable-energy-awareness-a-sched-feature-by-def.patch
new file mode 100644
index 0000000..a4aa860
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0091-sched-Enable-energy-awareness-a-sched-feature-by-def.patch
@@ -0,0 +1,27 @@
+From 68769e6bf0143899b9d1559a6afc2d45b8c0bc43 Mon Sep 17 00:00:00 2001
+From: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+Date: Thu, 25 Aug 2016 15:21:45 +0900
+Subject: [PATCH 91/92] sched: Enable energy awareness a sched feature by
+ default
+
+This patch set the ENERGY_AWARE by default. If you will change
+a sched feuture, CONFIG_SCHED_DEBUG should be enabled.
+
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ kernel/sched/features.h | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/kernel/sched/features.h b/kernel/sched/features.h
+index b634151..9ca672e 100644
+--- a/kernel/sched/features.h
++++ b/kernel/sched/features.h
+@@ -73,4 +73,4 @@
+  * Energy aware scheduling. Use platform energy model to guide scheduling
+  * decisions optimizing for energy efficiency.
+  */
+-SCHED_FEAT(ENERGY_AWARE, false)
++SCHED_FEAT(ENERGY_AWARE, true)
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0092-cpufreq-schedutil-Use-policy-dependent-transition-de.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0092-cpufreq-schedutil-Use-policy-dependent-transition-de.patch
new file mode 100644
index 0000000..29fdd5c
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0092-cpufreq-schedutil-Use-policy-dependent-transition-de.patch
@@ -0,0 +1,93 @@
+From fd991617b51a628a72bdb45b20fbc5c01d666b70 Mon Sep 17 00:00:00 2001
+From: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+Date: Fri, 7 Jul 2017 15:04:31 +0900
+Subject: [PATCH 92/92] cpufreq: schedutil: Use policy-dependent transition
+ delays for R-Car
+
+Make the schedutil governor take the initial (default) value of the
+rate_limit_us sysfs attribute from the (new) transition_delay_us
+policy parameter (to be set by the scaling driver).
+
+That will allow scaling drivers to make schedutil use smaller default
+values of rate_limit_us and reduce the default average time interval
+between consecutive frequency changes.
+
+The cpufreq-dt driver for R-Car H3/M3 set transition_delay_us to value
+same as transition_latency.
+
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ drivers/cpufreq/cpufreq-dt.c     |  4 ++++
+ include/linux/cpufreq.h          |  7 +++++++
+ kernel/sched/cpufreq_schedutil.c | 15 ++++++++++-----
+ 3 files changed, 21 insertions(+), 5 deletions(-)
+
+diff --git a/drivers/cpufreq/cpufreq-dt.c b/drivers/cpufreq/cpufreq-dt.c
+index 5c07ae0..57cd54e 100644
+--- a/drivers/cpufreq/cpufreq-dt.c
++++ b/drivers/cpufreq/cpufreq-dt.c
+@@ -276,6 +276,10 @@ static int cpufreq_init(struct cpufreq_policy *policy)
+ 
+ 	policy->cpuinfo.transition_latency = transition_latency;
+ 
++#if IS_ENABLED(CONFIG_ARCH_R8A7795) || IS_ENABLED(CONFIG_ARCH_R8A7796)
++	policy->transition_delay_us = transition_latency;
++#endif
++
+ 	return 0;
+ 
+ out_free_cpufreq_table:
+diff --git a/include/linux/cpufreq.h b/include/linux/cpufreq.h
+index 32dc0cbd..7df5d88 100644
+--- a/include/linux/cpufreq.h
++++ b/include/linux/cpufreq.h
+@@ -120,6 +120,13 @@ struct cpufreq_policy {
+ 	bool			fast_switch_possible;
+ 	bool			fast_switch_enabled;
+ 
++	/*
++	 * Preferred average time interval between consecutive invocations of
++	 * the driver to set the frequency for this policy.  To be set by the
++	 * scaling driver (0, which is the default, means no preference).
++	 */
++	unsigned int		transition_delay_us;
++
+ 	 /* Cached frequency lookup from cpufreq_driver_resolve_freq. */
+ 	unsigned int cached_target_freq;
+ 	int cached_resolved_idx;
+diff --git a/kernel/sched/cpufreq_schedutil.c b/kernel/sched/cpufreq_schedutil.c
+index 42a220e..9668e0e 100644
+--- a/kernel/sched/cpufreq_schedutil.c
++++ b/kernel/sched/cpufreq_schedutil.c
+@@ -473,7 +473,6 @@ static int sugov_init(struct cpufreq_policy *policy)
+ {
+ 	struct sugov_policy *sg_policy;
+ 	struct sugov_tunables *tunables;
+-	unsigned int lat;
+ 	int ret = 0;
+ 
+ 	/* State should be equivalent to EXIT */
+@@ -512,10 +511,16 @@ static int sugov_init(struct cpufreq_policy *policy)
+ 		goto stop_kthread;
+ 	}
+ 
+-	tunables->rate_limit_us = LATENCY_MULTIPLIER;
+-	lat = policy->cpuinfo.transition_latency / NSEC_PER_USEC;
+-	if (lat)
+-		tunables->rate_limit_us *= lat;
++	if (policy->transition_delay_us) {
++		tunables->rate_limit_us = policy->transition_delay_us;
++	} else {
++		unsigned int lat;
++
++		tunables->rate_limit_us = LATENCY_MULTIPLIER;
++		lat = policy->cpuinfo.transition_latency / NSEC_PER_USEC;
++		if (lat)
++			tunables->rate_limit_us *= lat;
++	}
+ 
+ 	policy->governor_data = sg_policy;
+ 	sg_policy->tunables = tunables;
+-- 
+1.9.1
+
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/eas.cfg b/meta-eas/recipes-kernel/linux/linux-renesas/eas.cfg
new file mode 100644
index 0000000..e8b09aa
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/eas.cfg
@@ -0,0 +1 @@
+CONFIG_SCHED_DEBUG=y
diff --git a/meta-eas/recipes-kernel/linux/linux-renesas_%.bbappend b/meta-eas/recipes-kernel/linux/linux-renesas_%.bbappend
new file mode 100644
index 0000000..b225d0c
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas_%.bbappend
@@ -0,0 +1,103 @@
+FILESEXTRAPATHS_prepend := "${THISDIR}/${PN}/:"
+
+EAS_PATCHES = " \
+	file://0001-sched-fair-Kill-the-unused-sched_shares_window_ns-tu.patch \
+	file://0002-sched-fair-Compute-task-cpu-utilization-at-wake-up-c.patch \
+	file://0003-sched-fair-Consider-spare-capacity-in-find_idlest_gr.patch \
+	file://0004-sched-fair-Add-per-CPU-min-capacity-to-sched_group_c.patch \
+	file://0005-sched-fair-Avoid-pulling-tasks-from-non-overloaded-h.patch \
+	file://0006-sched-fair-Fix-incorrect-comment-for-capacity_margin.patch \
+	file://0007-sched-fair-Factorize-attach-detach-entity.patch \
+	file://0008-sched-fair-Fix-hierarchical-order-in-rq-leaf_cfs_rq_.patch \
+	file://0009-sched-fair-Factorize-PELT-update.patch \
+	file://0010-sched-fair-Propagate-load-during-synchronous-attach-.patch \
+	file://0011-sched-fair-Propagate-asynchrous-detach.patch \
+	file://0012-sched-fair-Fix-task-group-initialization.patch \
+	file://0013-sched-dl-Fix-comment-in-pick_next_task_dl.patch \
+	file://0014-sched-fair-Clean-up-the-tunable-parameter-definition.patch \
+	file://0015-sched-Extend-scheduler-s-asym-packing.patch \
+	file://0016-cpufreq-schedutil-Avoid-indented-labels.patch \
+	file://0017-cpufreq-schedutil-enable-fast-switch-earlier.patch \
+	file://0018-cpufreq-schedutil-move-slow-path-from-workqueue-to-S.patch \
+	file://0019-cpufreq-schedutil-irq-work-and-mutex-are-only-used-i.patch \
+	file://0020-x86-topology-Define-x86-s-arch_update_cpu_topology.patch \
+	file://0021-sched-Prevent-unnecessary-active-balance-of-single-t.patch \
+	file://0022-sched-Enable-idle-balance-to-pull-single-task-toward.patch \
+	file://0023-Documentation-arm-define-DT-cpu-capacity-dmips-mhz-b.patch \
+	file://0024-arm-parse-cpu-capacity-dmips-mhz-from-DT.patch \
+	file://0025-fixup-arm-parse-cpu-capacity-dmips-mhz-from-DT.patch \
+	file://0026-arm-dts-add-TC2-cpu-capacity-dmips-mhz-information.patch \
+	file://0027-arm64-parse-cpu-capacity-dmips-mhz-from-DT.patch \
+	file://0028-fixup-arm64-parse-cpu-capacity-dmips-mhz-from-DT.patch \
+	file://0029-arm64-dts-add-Juno-cpu-capacity-dmips-mhz-informatio.patch \
+	file://0030-arm64-dts-add-Juno-r2-cpu-capacity-dmips-mhz-informa.patch \
+	file://0031-arm-add-sysfs-cpu_capacity-attribute.patch \
+	file://0032-arm64-add-sysfs-cpu_capacity-attribute.patch \
+	file://0033-fixup-arm-include-linux-cpufreq.h.patch \
+	file://0034-arm-Re-wire-cpu-invariant-load-tracking-support-up-t.patch \
+	file://0035-arm-Make-cpufreq-policy-notifier-usable-for-frequenc.patch \
+	file://0036-arm-Frequency-invariant-load-tracking-support.patch \
+	file://0037-arm-Wire-frequency-invariant-load-tracking-support-u.patch \
+	file://0038-arm64-Wire-cpu-invariant-load-tracking-support-up-to.patch \
+	file://0039-arm64-Make-cpufreq-policy-notifier-usable-for-freque.patch \
+	file://0040-arm64-Frequency-invariant-load-tracking-support.patch \
+	file://0041-arm64-Wire-frequency-invariant-load-tracking-support.patch \
+	file://0042-arm-Set-SD_ASYM_CPUCAPACITY-for-big.LITTLE-platforms.patch \
+	file://0043-arm-Update-SD_ASYM_CPUCAPACITY-topology-flag-when-cp.patch \
+	file://0044-arm64-Set-SD_ASYM_CPUCAPACITY-topology-flag-for-asym.patch \
+	file://0045-sched-Documentation-for-scheduler-energy-cost-model.patch \
+	file://0046-sched-Make-energy-awareness-a-sched-feature.patch \
+	file://0047-sched-Introduce-energy-data-structures.patch \
+	file://0048-sched-Initialize-energy-data-structures.patch \
+	file://0049-sched-EAS-cpu-hotplug-interoperability.patch \
+	file://0050-sched-Introduce-SD_SHARE_CAP_STATES-sched_domain-fla.patch \
+	file://0051-sched-Relocated-cpu_util-and-change-return-type.patch \
+	file://0052-sched-Highest-energy-aware-balancing-sched_domain-le.patch \
+	file://0053-sched-Calculate-energy-consumption-of-sched_group.patch \
+	file://0054-sched-Extend-sched_group_energy-to-test-load-balanci.patch \
+	file://0055-sched-Estimate-energy-impact-of-scheduling-decisions.patch \
+	file://0056-sched-cpuidle-Track-cpuidle-state-index-in-the-sched.patch \
+	file://0057-sched-Determine-the-current-sched_group-idle-state.patch \
+	file://0058-sched-fair-Add-energy_diff-dead-zone-margin.patch \
+	file://0059-sched-Add-over-utilization-tipping-point-indicator.patch \
+	file://0060-sched-fair-Energy-aware-wake-up-task-placement.patch \
+	file://0061-sched-fair-Fix-select_task_rq_brute-rcu_unlock-when-.patch \
+	file://0062-sched-Consider-a-not-over-utilized-energy-aware-syst.patch \
+	file://0063-sched-Disable-energy-unfriendly-nohz-kicks.patch \
+	file://0064-arm-Set-SD_SHARE_CAP_STATES-sched_domain-flag-when-a.patch \
+	file://0065-arm64-Set-SD_SHARE_CAP_STATES-sched_domain-flag-when.patch \
+	file://0066-arm-topology-Define-TC2-energy-and-provide-it-to-the.patch \
+	file://0067-arm-Cpu-invariant-scheduler-load-tracking-and-capaci.patch \
+	file://0068-arm64-topology-Define-JUNO-energy-and-provide-it-to-.patch \
+	file://0069-arm64-Cpu-invariant-scheduler-load-tracking-and-capa.patch \
+	file://0070-arm64-Factor-out-energy-model-from-topology-shim-lay.patch \
+	file://0071-arm64-Add-Hikey-energy-model.patch \
+	file://0072-arm64-dts-Add-Hikey-cpu-capacity-dmips-mhz-informati.patch \	
+	file://0073-arm64-Introduce-sys-sd-energy-model-infrastructure.patch \
+	file://0074-arm64-Define-Hi6220-SYS-sd-energy-model.patch \
+	file://0075-sched-debug-Add-energy-procfs-interface.patch \
+	file://0076-sched-events-Introduce-cfs_rq-PELT-trace-event-sched.patch \
+	file://0077-sched-events-Introduce-sched-entity-PELT-trace-event.patch \
+	file://0078-sched-events-Introduce-task-group-PELT-trace-event-s.patch \
+	file://0079-sched-Call-cfs_rq-and-sched_entity-PELT-tracepoints-.patch \
+	file://0080-sched-core-Fix-find_idlest_group-for-fork.patch \
+	file://0081-SPLIT-sched-fair-Don-t-load-balance-from-group_other.patch \
+	file://0082-sched-Add-group_misfit_task-load-balance-type.patch \
+	file://0083-sched-Consider-misfit-tasks-when-load-balancing.patch \
+	file://0084-arm64-dts-r8a7795-Add-multi-cluster-definition.patch \
+	file://0085-arm64-dts-r8a7796-Add-multi-cluster-definition.patch \
+	file://0086-arm64-dts-r8a7795-es1-Add-multi-cluster-definition.patch \
+	file://0087-arm64-dts-r8a7795-Add-cpu-capacity-dmips-mhz.patch \
+	file://0088-arm64-dts-r8a7796-Add-cpu-capacity-dmips-mhz.patch \
+	file://0089-arm64-dts-r8a7795-es1-Add-cpu-capacity-dmips-mhz.patch \
+	file://0090-arm64-Define-R-CAR-Gen3-energy-and-provide-it-to-the.patch \
+	file://0091-sched-Enable-energy-awareness-a-sched-feature-by-def.patch \
+	file://0092-cpufreq-schedutil-Use-policy-dependent-transition-de.patch \
+	file://0001-arm64-dts-r8a7795-Update-cpu-capacity-dmips-mhz.patch \
+	file://0002-arm64-dts-r8a7796-Update-cpu-capacity-dmips-mhz.patch \
+	file://0003-arm64-dts-r8a7795-es1-Update-cpu-capacity-dmips-mhz.patch \
+	file://0004-arm64-Update-the-energy-model-on-CA53-for-R-Car-Gen3.patch \
+	file://eas.cfg \
+	"
+
+SRC_URI_append = "${@bb.utils.contains('MACHINE_FEATURES','biglittle','${EAS_PATCHES}','',d)}"
diff --git a/templates/feature/eas/50_bblayers.conf.inc b/templates/feature/eas/50_bblayers.conf.inc
new file mode 100644
index 0000000..772ea4d
--- /dev/null
+++ b/templates/feature/eas/50_bblayers.conf.inc
@@ -0,0 +1,3 @@
+BBLAYERS =+ "\
+  ${METADIR}/meta-agl-extra/meta-eas \
+  "
author	Frode Isaksen <fisaksen@baylibre.com>	2017-12-19 11:15:35 +0000
committer	Jan-Simon Moeller <jsmoeller@linuxfoundation.org>	2018-02-07 11:47:29 +0000
commit	c4a6287185179732dfc1e903c195ff90c19f1065 (patch)
tree	d35f5010dbd952e40f5c178322026445b55757c1
parent	109dea1d5c5a38807b098b588584636ae636a302 (diff)