diff --git a/drivers/soc/qcom/msm_performance.c b/drivers/soc/qcom/msm_performance.c
index 9d7f16d0a512..4c570d70a538 100644
--- a/drivers/soc/qcom/msm_performance.c
+++ b/drivers/soc/qcom/msm_performance.c
@@ -46,7 +46,8 @@ struct cluster {
 	unsigned int mode;
 	bool mode_change;
 	u64 last_mode_check_ts;
-	unsigned int single_cycle_cnt;
+	unsigned int single_enter_cycle_cnt;
+	unsigned int single_exit_cycle_cnt;
 	unsigned int multi_cycle_cnt;
 	spinlock_t mode_lock;
 	/* Tunables */
@@ -54,8 +55,12 @@ struct cluster {
 	unsigned int pcpu_multi_enter_load;
 	unsigned int single_exit_load;
 	unsigned int pcpu_multi_exit_load;
-	unsigned int single_cycles;
+	unsigned int single_enter_cycles;
+	unsigned int single_exit_cycles;
 	unsigned int multi_cycles;
+	spinlock_t timer_lock;
+	unsigned int timer_rate;
+	struct timer_list mode_exit_timer;
 };
 static struct cluster **managed_clusters;
 static bool clusters_inited;
@@ -112,7 +117,8 @@ static struct task_struct *notify_thread;
 #define DEF_PCPU_MULTI_ENT	85
 #define DEF_SINGLE_EX		60
 #define DEF_PCPU_MULTI_EX	50
-#define DEF_SINGLE_CYCLE	4
+#define DEF_SINGLE_ENTER_CYCLE	4
+#define DEF_SINGLE_EXIT_CYCLE	4
 #define DEF_MULTI_CYCLE		4
 #define LAST_LD_CHECK_TOL	(2 * USEC_PER_MSEC)
 
@@ -676,7 +682,8 @@ static const struct kernel_param_ops param_ops_pcpu_multi_exit_load = {
 device_param_cb(pcpu_multi_exit_load, &param_ops_pcpu_multi_exit_load,
 								NULL, 0644);
 
-static int set_single_cycles(const char *buf, const struct kernel_param *kp)
+static int set_single_enter_cycles(const char *buf,
+					const struct kernel_param *kp)
 {
 	unsigned int val, i, ntokens = 0;
 	const char *cp = buf;
@@ -697,7 +704,7 @@ static int set_single_cycles(const char *buf, const struct kernel_param *kp)
 		if (sscanf(cp, "%u\n", &val) != 1)
 			return -EINVAL;
 
-		managed_clusters[i]->single_cycles = val;
+		managed_clusters[i]->single_enter_cycles = val;
 
 		bytes_left = PAGE_SIZE - (cp - buf);
 		cp = strnchr(cp, bytes_left, ':');
@@ -707,7 +714,62 @@ static int set_single_cycles(const char *buf, const struct kernel_param *kp)
 	return 0;
 }
 
-static int get_single_cycles(char *buf, const struct kernel_param *kp)
+static int get_single_enter_cycles(char *buf, const struct kernel_param *kp)
+{
+	int i, cnt = 0;
+
+	if (!clusters_inited)
+		return cnt;
+
+	for (i = 0; i < num_clusters; i++)
+		cnt += snprintf(buf + cnt, PAGE_SIZE - cnt, "%u:",
+				managed_clusters[i]->single_enter_cycles);
+	cnt--;
+	cnt += snprintf(buf + cnt, PAGE_SIZE - cnt, " ");
+	return cnt;
+}
+
+static const struct kernel_param_ops param_ops_single_enter_cycles = {
+	.set = set_single_enter_cycles,
+	.get = get_single_enter_cycles,
+};
+device_param_cb(single_enter_cycles, &param_ops_single_enter_cycles,
+								NULL, 0644);
+
+
+static int set_single_exit_cycles(const char *buf,
+					const struct kernel_param *kp)
+{
+	unsigned int val, i, ntokens = 0;
+	const char *cp = buf;
+	unsigned int bytes_left;
+
+	if (!clusters_inited)
+		return -EINVAL;
+
+	while ((cp = strpbrk(cp + 1, ":")))
+		ntokens++;
+
+	if (ntokens != (num_clusters - 1))
+		return -EINVAL;
+
+	cp = buf;
+	for (i = 0; i < num_clusters; i++) {
+
+		if (sscanf(cp, "%u\n", &val) != 1)
+			return -EINVAL;
+
+		managed_clusters[i]->single_exit_cycles = val;
+
+		bytes_left = PAGE_SIZE - (cp - buf);
+		cp = strnchr(cp, bytes_left, ':');
+		cp++;
+	}
+
+	return 0;
+}
+
+static int get_single_exit_cycles(char *buf, const struct kernel_param *kp)
 {
 	int i, cnt = 0;
 
@@ -716,17 +778,17 @@ static int get_single_cycles(char *buf, const struct kernel_param *kp)
 
 	for (i = 0; i < num_clusters; i++)
 		cnt += snprintf(buf + cnt, PAGE_SIZE - cnt,
-				"%u:", managed_clusters[i]->single_cycles);
+				"%u:", managed_clusters[i]->single_exit_cycles);
 	cnt--;
 	cnt += snprintf(buf + cnt, PAGE_SIZE - cnt, " ");
 	return cnt;
 }
 
-static const struct kernel_param_ops param_ops_single_cycles = {
-	.set = set_single_cycles,
-	.get = get_single_cycles,
+static const struct kernel_param_ops param_ops_single_exit_cycles = {
+	.set = set_single_exit_cycles,
+	.get = get_single_exit_cycles,
 };
-device_param_cb(single_cycles, &param_ops_single_cycles, NULL, 0644);
+device_param_cb(single_exit_cycles, &param_ops_single_exit_cycles, NULL, 0644);
 
 static int set_multi_cycles(const char *buf, const struct kernel_param *kp)
 {
@@ -885,7 +947,8 @@ static int set_workload_detect(const char *buf, const struct kernel_param *kp)
 		for (i = 0; i < num_clusters; i++) {
 			i_cl = managed_clusters[i];
 			spin_lock_irqsave(&i_cl->mode_lock, flags);
-			i_cl->single_cycle_cnt = 0;
+			i_cl->single_enter_cycle_cnt = 0;
+			i_cl->single_exit_cycle_cnt = 0;
 			i_cl->multi_cycle_cnt = 0;
 			i_cl->mode = 0;
 			i_cl->mode_change = true;
@@ -1039,7 +1102,7 @@ static int notify_userspace(void *data)
 	return 0;
 }
 
-static void check_cluster_iowait(struct cluster *cl, unsigned int rate, u64 now)
+static void check_cluster_iowait(struct cluster *cl, u64 now)
 {
 	struct load_stats *pcpu_st;
 	unsigned int i;
@@ -1049,8 +1112,9 @@ static void check_cluster_iowait(struct cluster *cl, unsigned int rate, u64 now)
 
 	spin_lock_irqsave(&cl->iowait_lock, flags);
 
-	if (((now - cl->last_io_check_ts) < (rate - LAST_IO_CHECK_TOL)) ||
-					!(workload_detect & IO_DETECT)) {
+	if (((now - cl->last_io_check_ts)
+		< (cl->timer_rate - LAST_IO_CHECK_TOL)) ||
+		!(workload_detect & IO_DETECT)) {
 		spin_unlock_irqrestore(&cl->iowait_lock, flags);
 		return;
 	}
@@ -1058,7 +1122,8 @@ static void check_cluster_iowait(struct cluster *cl, unsigned int rate, u64 now)
 	temp_iobusy = cl->cur_io_busy;
 	for_each_cpu(i, cl->cpus) {
 		pcpu_st = &per_cpu(cpu_load_stats, i);
-		if ((now - pcpu_st->last_wallclock) > (rate + LAST_UPDATE_TOL))
+		if ((now - pcpu_st->last_wallclock)
+			> (cl->timer_rate + LAST_UPDATE_TOL))
 			continue;
 		if (max_iowait < pcpu_st->last_iopercent)
 			max_iowait = pcpu_st->last_iopercent;
@@ -1095,7 +1160,44 @@ static void check_cluster_iowait(struct cluster *cl, unsigned int rate, u64 now)
 		wake_up_process(notify_thread);
 }
 
-static void check_cpu_load(struct cluster *cl, unsigned int rate, u64 now)
+static void disable_timer(struct cluster *cl)
+{
+	unsigned long flags;
+
+	spin_lock_irqsave(&cl->timer_lock, flags);
+
+	if (del_timer(&cl->mode_exit_timer)) {
+		trace_single_cycle_exit_timer_stop(cpumask_first(cl->cpus),
+			cl->single_enter_cycles, cl->single_enter_cycle_cnt,
+			cl->single_exit_cycles, cl->single_exit_cycle_cnt,
+			cl->multi_cycles, cl->multi_cycle_cnt, cl->timer_rate,
+			cl->mode);
+	}
+
+	spin_unlock_irqrestore(&cl->timer_lock, flags);
+}
+
+static void start_timer(struct cluster *cl)
+{
+	unsigned long flags;
+
+	spin_lock_irqsave(&cl->timer_lock, flags);
+	if ((cl->mode & SINGLE) && !timer_pending(&cl->mode_exit_timer)) {
+		/*Set timer for the Cluster since there is none pending*/
+		cl->mode_exit_timer.expires = get_jiffies_64() +
+		usecs_to_jiffies(cl->single_exit_cycles * cl->timer_rate);
+		cl->mode_exit_timer.data = cpumask_first(cl->cpus);
+		add_timer(&cl->mode_exit_timer);
+		trace_single_cycle_exit_timer_start(cpumask_first(cl->cpus),
+			cl->single_enter_cycles, cl->single_enter_cycle_cnt,
+			cl->single_exit_cycles, cl->single_exit_cycle_cnt,
+			cl->multi_cycles, cl->multi_cycle_cnt, cl->timer_rate,
+			cl->mode);
+	}
+	spin_unlock_irqrestore(&cl->timer_lock, flags);
+}
+
+static void check_cpu_load(struct cluster *cl, u64 now)
 {
 	struct load_stats *pcpu_st;
 	unsigned int i, max_load = 0, total_load = 0, ret_mode, cpu_cnt = 0;
@@ -1104,15 +1206,17 @@ static void check_cpu_load(struct cluster *cl, unsigned int rate, u64 now)
 
 	spin_lock_irqsave(&cl->mode_lock, flags);
 
-	if (((now - cl->last_mode_check_ts) < (rate - LAST_LD_CHECK_TOL)) ||
-					!(workload_detect & MODE_DETECT)) {
+	if (((now - cl->last_mode_check_ts)
+		< (cl->timer_rate - LAST_LD_CHECK_TOL)) ||
+		!(workload_detect & MODE_DETECT)) {
 		spin_unlock_irqrestore(&cl->mode_lock, flags);
 		return;
 	}
 
 	for_each_cpu(i, cl->cpus) {
 		pcpu_st = &per_cpu(cpu_load_stats, i);
-		if ((now - pcpu_st->last_wallclock) > (rate + LAST_UPDATE_TOL))
+		if ((now - pcpu_st->last_wallclock)
+			> (cl->timer_rate + LAST_UPDATE_TOL))
 			continue;
 		if (pcpu_st->cpu_load > max_load)
 			max_load = pcpu_st->cpu_load;
@@ -1131,19 +1235,28 @@ static void check_cpu_load(struct cluster *cl, unsigned int rate, u64 now)
 	ret_mode = cl->mode;
 	if (!(cl->mode & SINGLE)) {
 		if (max_load >= cl->single_enter_load) {
-			cl->single_cycle_cnt++;
-			if (cl->single_cycle_cnt >= cl->single_cycles)
+			cl->single_enter_cycle_cnt++;
+			if (cl->single_enter_cycle_cnt
+				>= cl->single_enter_cycles) {
 				ret_mode |= SINGLE;
+				cl->single_enter_cycle_cnt = 0;
+			}
 		} else {
-			cl->single_cycle_cnt = 0;
+			cl->single_enter_cycle_cnt = 0;
 		}
 	} else {
 		if (max_load < cl->single_exit_load) {
-			cl->single_cycle_cnt--;
-			if (!cl->single_cycle_cnt)
+			start_timer(cl);
+			cl->single_exit_cycle_cnt++;
+			if (cl->single_exit_cycle_cnt
+				>= cl->single_exit_cycles) {
 				ret_mode &= ~SINGLE;
+				cl->single_exit_cycle_cnt = 0;
+				disable_timer(cl);
+			}
 		} else {
-			cl->single_cycle_cnt = cl->single_cycles;
+			cl->single_exit_cycle_cnt = 0;
+			disable_timer(cl);
 		}
 	}
 
@@ -1174,7 +1287,8 @@ static void check_cpu_load(struct cluster *cl, unsigned int rate, u64 now)
 	}
 
 	trace_cpu_mode_detect(cpumask_first(cl->cpus), max_load,
-		cl->single_cycle_cnt, total_load, cl->multi_cycle_cnt,
+		cl->single_enter_cycle_cnt, cl->single_exit_cycle_cnt,
+		total_load, cl->multi_cycle_cnt,
 		cl->mode, cpu_cnt);
 
 	spin_unlock_irqrestore(&cl->mode_lock, flags);
@@ -1183,8 +1297,7 @@ static void check_cpu_load(struct cluster *cl, unsigned int rate, u64 now)
 		wake_up_process(notify_thread);
 }
 
-static void check_workload_stats(unsigned int cpu, unsigned int timer_rate,
-									u64 now)
+static void check_workload_stats(unsigned int cpu, unsigned int rate, u64 now)
 {
 	struct cluster *cl = NULL;
 	unsigned int i;
@@ -1198,8 +1311,9 @@ static void check_workload_stats(unsigned int cpu, unsigned int timer_rate,
 	if (cl == NULL)
 		return;
 
-	check_cluster_iowait(cl, timer_rate, now);
-	check_cpu_load(cl, timer_rate, now);
+	cl->timer_rate = rate;
+	check_cluster_iowait(cl, now);
+	check_cpu_load(cl, now);
 }
 
 static int perf_govinfo_notify(struct notifier_block *nb, unsigned long val,
@@ -1475,6 +1589,43 @@ static struct notifier_block __refdata msm_performance_cpu_notifier = {
 	.notifier_call = msm_performance_cpu_callback,
 };
 
+static void single_mod_exit_timer(unsigned long data)
+{
+	int i;
+	struct cluster *i_cl = NULL;
+	unsigned long flags;
+
+	if (!clusters_inited)
+		return;
+
+	for (i = 0; i < num_clusters; i++) {
+		if (cpumask_test_cpu(data,
+			managed_clusters[i]->cpus)) {
+			i_cl = managed_clusters[i];
+			break;
+		}
+	}
+
+	if (i_cl == NULL)
+		return;
+
+	spin_lock_irqsave(&i_cl->mode_lock, flags);
+	if (i_cl->mode & SINGLE) {
+		/*Disable SINGLE mode and exit since the timer expired*/
+		i_cl->mode = i_cl->mode & ~SINGLE;
+		i_cl->single_enter_cycle_cnt = 0;
+		i_cl->single_exit_cycle_cnt = 0;
+		trace_single_mode_timeout(cpumask_first(i_cl->cpus),
+			i_cl->single_enter_cycles,
+			i_cl->single_enter_cycle_cnt,
+			i_cl->single_exit_cycles, i_cl->single_exit_cycle_cnt,
+			i_cl->multi_cycles, i_cl->multi_cycle_cnt,
+			i_cl->timer_rate, i_cl->mode);
+	}
+	spin_unlock_irqrestore(&i_cl->mode_lock, flags);
+	wake_up_process(notify_thread);
+}
+
 static int init_cluster_control(void)
 {
 	unsigned int i;
@@ -1493,14 +1644,21 @@ static int init_cluster_control(void)
 		managed_clusters[i]->max_cpu_request = -1;
 		managed_clusters[i]->single_enter_load = DEF_SINGLE_ENT;
 		managed_clusters[i]->single_exit_load = DEF_SINGLE_EX;
-		managed_clusters[i]->single_cycles = DEF_SINGLE_CYCLE;
-		managed_clusters[i]->pcpu_multi_enter_load = DEF_PCPU_MULTI_ENT;
+		managed_clusters[i]->single_enter_cycles
+						= DEF_SINGLE_ENTER_CYCLE;
+		managed_clusters[i]->single_exit_cycles
+						= DEF_SINGLE_EXIT_CYCLE;
+		managed_clusters[i]->pcpu_multi_enter_load
+						= DEF_PCPU_MULTI_ENT;
 		managed_clusters[i]->pcpu_multi_exit_load = DEF_PCPU_MULTI_EX;
-		managed_clusters[i]->single_cycles = DEF_SINGLE_CYCLE;
 		managed_clusters[i]->multi_cycles = DEF_MULTI_CYCLE;
 
 		spin_lock_init(&(managed_clusters[i]->iowait_lock));
 		spin_lock_init(&(managed_clusters[i]->mode_lock));
+		spin_lock_init(&(managed_clusters[i]->timer_lock));
+		init_timer(&managed_clusters[i]->mode_exit_timer);
+		managed_clusters[i]->mode_exit_timer.function =
+			single_mod_exit_timer;
 	}
 
 	INIT_DELAYED_WORK(&evaluate_hotplug_work, check_cluster_status);
diff --git a/include/trace/events/power.h b/include/trace/events/power.h
index 45382f5479bf..37d28157c0af 100644
--- a/include/trace/events/power.h
+++ b/include/trace/events/power.h
@@ -830,17 +830,19 @@ DEFINE_EVENT(kpm_module2, track_iowait,
 DECLARE_EVENT_CLASS(cpu_modes,
 
 	TP_PROTO(unsigned int cpu, unsigned int max_load,
-		unsigned int single_cycles, unsigned int total_load,
-		unsigned int multi_cycles, unsigned int mode,
-		unsigned int cpu_cnt),
+		unsigned int single_enter_cycle_cnt,
+		unsigned int single_exit_cycle_cnt,
+		unsigned int total_load, unsigned int multi_cycles,
+		unsigned int mode, unsigned int cpu_cnt),
 
-	TP_ARGS(cpu, max_load, single_cycles, total_load, multi_cycles,
-								mode, cpu_cnt),
+	TP_ARGS(cpu, max_load, single_enter_cycle_cnt, single_exit_cycle_cnt,
+		total_load, multi_cycles, mode, cpu_cnt),
 
 	TP_STRUCT__entry(
 		__field(u32, cpu)
 		__field(u32, max_load)
-		__field(u32, single_cycles)
+		__field(u32, single_enter_cycle_cnt)
+		__field(u32, single_exit_cycle_cnt)
 		__field(u32, total_load)
 		__field(u32, multi_cycles)
 		__field(u32, mode)
@@ -850,16 +852,18 @@ DECLARE_EVENT_CLASS(cpu_modes,
 	TP_fast_assign(
 		__entry->cpu = cpu;
 		__entry->max_load = max_load;
-		__entry->single_cycles = single_cycles;
+		__entry->single_enter_cycle_cnt = single_enter_cycle_cnt;
+		__entry->single_exit_cycle_cnt = single_exit_cycle_cnt;
 		__entry->total_load = total_load;
 		__entry->multi_cycles = multi_cycles;
 		__entry->mode = mode;
 		__entry->cpu_cnt = cpu_cnt;
 	),
 
-	TP_printk("CPU:%u ml=%4u sc=%4u tl=%4u mc=%4u mode=%4u cpu_cnt=%u",
+	TP_printk("%u:%4u:%4u:%4u:%4u:%4u:%4u:%u",
 		(unsigned int)__entry->cpu, (unsigned int)__entry->max_load,
-		(unsigned int)__entry->single_cycles,
+		(unsigned int)__entry->single_enter_cycle_cnt,
+		(unsigned int)__entry->single_exit_cycle_cnt,
 		(unsigned int)__entry->total_load,
 		(unsigned int)__entry->multi_cycles,
 		(unsigned int)__entry->mode,
@@ -868,11 +872,95 @@ DECLARE_EVENT_CLASS(cpu_modes,
 
 DEFINE_EVENT(cpu_modes, cpu_mode_detect,
 	TP_PROTO(unsigned int cpu, unsigned int max_load,
-		unsigned int single_cycles, unsigned int total_load,
-		unsigned int multi_cycles, unsigned int mode,
-		unsigned int cpu_cnt),
-	TP_ARGS(cpu, max_load, single_cycles, total_load, multi_cycles,
-								mode, cpu_cnt)
+		unsigned int single_enter_cycle_cnt,
+		unsigned int single_exit_cycle_cnt,
+		unsigned int total_load, unsigned int multi_cycles,
+		unsigned int mode, unsigned int cpu_cnt),
+	TP_ARGS(cpu, max_load, single_enter_cycle_cnt, single_exit_cycle_cnt,
+		total_load, multi_cycles, mode, cpu_cnt)
+);
+
+DECLARE_EVENT_CLASS(timer_status,
+	TP_PROTO(unsigned int cpu, unsigned int single_enter_cycles,
+		unsigned int single_enter_cycle_cnt,
+		unsigned int single_exit_cycles,
+		unsigned int single_exit_cycle_cnt, unsigned int multi_cycles,
+		unsigned int multi_cycle_cnt, unsigned int timer_rate,
+		unsigned int mode),
+	TP_ARGS(cpu, single_enter_cycles, single_enter_cycle_cnt,
+		single_exit_cycles, single_exit_cycle_cnt, multi_cycles,
+		multi_cycle_cnt, timer_rate, mode),
+
+	TP_STRUCT__entry(
+		__field(unsigned int, cpu)
+		__field(unsigned int, single_enter_cycles)
+		__field(unsigned int, single_enter_cycle_cnt)
+		__field(unsigned int, single_exit_cycles)
+		__field(unsigned int, single_exit_cycle_cnt)
+		__field(unsigned int, multi_cycles)
+		__field(unsigned int, multi_cycle_cnt)
+		__field(unsigned int, timer_rate)
+		__field(unsigned int, mode)
+	),
+
+	TP_fast_assign(
+		__entry->cpu = cpu;
+		__entry->single_enter_cycles = single_enter_cycles;
+		__entry->single_enter_cycle_cnt = single_enter_cycle_cnt;
+		__entry->single_exit_cycles = single_exit_cycles;
+		__entry->single_exit_cycle_cnt = single_exit_cycle_cnt;
+		__entry->multi_cycles = multi_cycles;
+		__entry->multi_cycle_cnt = multi_cycle_cnt;
+		__entry->timer_rate = timer_rate;
+		__entry->mode = mode;
+	),
+
+	TP_printk("%u:%4u:%4u:%4u:%4u:%4u:%4u:%4u:%4u",
+		__entry->cpu,
+		__entry->single_enter_cycles,
+		__entry->single_enter_cycle_cnt,
+		__entry->single_exit_cycles,
+		__entry->single_exit_cycle_cnt,
+		__entry->multi_cycles,
+		__entry->multi_cycle_cnt,
+		__entry->timer_rate,
+		__entry->mode)
+);
+
+DEFINE_EVENT(timer_status, single_mode_timeout,
+	TP_PROTO(unsigned int cpu, unsigned int single_enter_cycles,
+		unsigned int single_enter_cycle_cnt,
+		unsigned int single_exit_cycles,
+		unsigned int single_exit_cycle_cnt, unsigned int multi_cycles,
+		unsigned int multi_cycle_cnt, unsigned int timer_rate,
+		unsigned int mode),
+	TP_ARGS(cpu, single_enter_cycles, single_enter_cycle_cnt,
+		single_exit_cycles, single_exit_cycle_cnt, multi_cycles,
+		multi_cycle_cnt, timer_rate, mode)
+);
+
+DEFINE_EVENT(timer_status, single_cycle_exit_timer_start,
+	TP_PROTO(unsigned int cpu, unsigned int single_enter_cycles,
+		unsigned int single_enter_cycle_cnt,
+		unsigned int single_exit_cycles,
+		unsigned int single_exit_cycle_cnt, unsigned int multi_cycles,
+		unsigned int multi_cycle_cnt, unsigned int timer_rate,
+		unsigned int mode),
+	TP_ARGS(cpu, single_enter_cycles, single_enter_cycle_cnt,
+		single_exit_cycles, single_exit_cycle_cnt, multi_cycles,
+		multi_cycle_cnt, timer_rate, mode)
+);
+
+DEFINE_EVENT(timer_status, single_cycle_exit_timer_stop,
+	TP_PROTO(unsigned int cpu, unsigned int single_enter_cycles,
+		unsigned int single_enter_cycle_cnt,
+		unsigned int single_exit_cycles,
+		unsigned int single_exit_cycle_cnt, unsigned int multi_cycles,
+		unsigned int multi_cycle_cnt, unsigned int timer_rate,
+		unsigned int mode),
+	TP_ARGS(cpu, single_enter_cycles, single_enter_cycle_cnt,
+		single_exit_cycles, single_exit_cycle_cnt, multi_cycles,
+		multi_cycle_cnt, timer_rate, mode)
 );
 
 #endif /* _TRACE_POWER_H */