branch Attitude Adjustment

git-svn-id: svn://svn.openwrt.org/openwrt/branches/attitude_adjustment@33625 3c298f89-4303-0410-b956-a3cf2f4a3e73

1 files changed, 301 insertions, 0 deletions

diff --git a/target/linux/xburst/patches-3.3/0010-cpufreq_stats-Support-runtime-changes-to-frequency-t.patch b/target/linux/xburst/patches-3.3/0010-cpufreq_stats-Support-runtime-changes-to-frequency-t.patch
new file mode 100644
index 000000000..95803e313
--- /dev/null
+++ b/target/linux/xburst/patches-3.3/0010-cpufreq_stats-Support-runtime-changes-to-frequency-t.patch
@@ -0,0 +1,301 @@
+From ca40c7542f0cd0e0dfa074bd4ccefc04b8561427 Mon Sep 17 00:00:00 2001
+From: Maarten ter Huurne <maarten@treewalker.org>
+Date: Tue, 2 Aug 2011 10:26:09 +0200
+Subject: [PATCH 10/21] cpufreq_stats: Support runtime changes to frequency
+ table.
+
+---
+ drivers/cpufreq/cpufreq_stats.c |  161 ++++++++++++++++++++-------------------
+ 1 files changed, 83 insertions(+), 78 deletions(-)
+
+--- a/drivers/cpufreq/cpufreq_stats.c
++++ b/drivers/cpufreq/cpufreq_stats.c
+@@ -20,6 +20,7 @@
+ #include <linux/kobject.h>
+ #include <linux/spinlock.h>
+ #include <linux/notifier.h>
++#include <linux/string.h>
+ #include <asm/cputime.h>
+ 
+ static spinlock_t cpufreq_stats_lock;
+@@ -36,7 +37,7 @@ struct cpufreq_stats {
+ 	unsigned long long  last_time;
+ 	unsigned int max_state;
+ 	unsigned int state_num;
+-	unsigned int last_index;
++	int last_index;
+ 	cputime64_t *time_in_state;
+ 	unsigned int *freq_table;
+ #ifdef CONFIG_CPU_FREQ_STAT_DETAILS
+@@ -59,7 +60,7 @@ static int cpufreq_stats_update(unsigned
+ 	cur_time = get_jiffies_64();
+ 	spin_lock(&cpufreq_stats_lock);
+ 	stat = per_cpu(cpufreq_stats_table, cpu);
+-	if (stat->time_in_state)
++	if (stat->time_in_state && stat->last_index != -1)
+ 		stat->time_in_state[stat->last_index] +=
+ 			cur_time - stat->last_time;
+ 	stat->last_time = cur_time;
+@@ -81,7 +82,7 @@ static ssize_t show_time_in_state(struct
+ 	ssize_t len = 0;
+ 	int i;
+ 	struct cpufreq_stats *stat = per_cpu(cpufreq_stats_table, policy->cpu);
+-	if (!stat)
++	if (!stat || !stat->time_in_state)
+ 		return 0;
+ 	cpufreq_stats_update(stat->cpu);
+ 	for (i = 0; i < stat->state_num; i++) {
+@@ -99,7 +100,7 @@ static ssize_t show_trans_table(struct c
+ 	int i, j;
+ 
+ 	struct cpufreq_stats *stat = per_cpu(cpufreq_stats_table, policy->cpu);
+-	if (!stat)
++	if (!stat || !stat->trans_table)
+ 		return 0;
+ 	cpufreq_stats_update(stat->cpu);
+ 	len += snprintf(buf + len, PAGE_SIZE - len, "   From  :    To\n");
+@@ -158,63 +159,35 @@ static struct attribute_group stats_attr
+ static int freq_table_get_index(struct cpufreq_stats *stat, unsigned int freq)
+ {
+ 	int index;
+-	for (index = 0; index < stat->max_state; index++)
+-		if (stat->freq_table[index] == freq)
+-			return index;
++	if (stat->freq_table)
++		for (index = 0; index < stat->max_state; index++)
++			if (stat->freq_table[index] == freq)
++				return index;
+ 	return -1;
+ }
+ 
+-/* should be called late in the CPU removal sequence so that the stats
+- * memory is still available in case someone tries to use it.
+- */
+ static void cpufreq_stats_free_table(unsigned int cpu)
+ {
+ 	struct cpufreq_stats *stat = per_cpu(cpufreq_stats_table, cpu);
++	struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
++	if (policy && policy->cpu == cpu)
++		sysfs_remove_group(&policy->kobj, &stats_attr_group);
+ 	if (stat) {
+ 		kfree(stat->time_in_state);
+ 		kfree(stat);
+ 	}
+ 	per_cpu(cpufreq_stats_table, cpu) = NULL;
+-}
+-
+-/* must be called early in the CPU removal sequence (before
+- * cpufreq_remove_dev) so that policy is still valid.
+- */
+-static void cpufreq_stats_free_sysfs(unsigned int cpu)
+-{
+-	struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
+-	if (policy && policy->cpu == cpu)
+-		sysfs_remove_group(&policy->kobj, &stats_attr_group);
+ 	if (policy)
+ 		cpufreq_cpu_put(policy);
+ }
+ 
+-static int cpufreq_stats_create_table(struct cpufreq_policy *policy,
++static int cpufreq_stats_update_table(struct cpufreq_policy *policy,
+ 		struct cpufreq_frequency_table *table)
+ {
+-	unsigned int i, j, count = 0, ret = 0;
+-	struct cpufreq_stats *stat;
+-	struct cpufreq_policy *data;
++	unsigned int i, j, count = 0;
+ 	unsigned int alloc_size;
+ 	unsigned int cpu = policy->cpu;
+-	if (per_cpu(cpufreq_stats_table, cpu))
+-		return -EBUSY;
+-	stat = kzalloc(sizeof(struct cpufreq_stats), GFP_KERNEL);
+-	if ((stat) == NULL)
+-		return -ENOMEM;
+-
+-	data = cpufreq_cpu_get(cpu);
+-	if (data == NULL) {
+-		ret = -EINVAL;
+-		goto error_get_fail;
+-	}
+-
+-	ret = sysfs_create_group(&data->kobj, &stats_attr_group);
+-	if (ret)
+-		goto error_out;
+-
+-	stat->cpu = cpu;
+-	per_cpu(cpufreq_stats_table, cpu) = stat;
++	struct cpufreq_stats *stat = per_cpu(cpufreq_stats_table, cpu);
+ 
+ 	for (i = 0; table[i].frequency != CPUFREQ_TABLE_END; i++) {
+ 		unsigned int freq = table[i].frequency;
+@@ -223,40 +196,73 @@ static int cpufreq_stats_create_table(st
+ 		count++;
+ 	}
+ 
++	if (stat->max_state != count) {
++		stat->max_state = count;
++		kfree(stat->time_in_state);
++		stat->time_in_state = NULL;
++	}
+ 	alloc_size = count * sizeof(int) + count * sizeof(cputime64_t);
+-
+ #ifdef CONFIG_CPU_FREQ_STAT_DETAILS
+ 	alloc_size += count * count * sizeof(int);
+ #endif
+-	stat->max_state = count;
+-	stat->time_in_state = kzalloc(alloc_size, GFP_KERNEL);
+-	if (!stat->time_in_state) {
+-		ret = -ENOMEM;
+-		goto error_out;
+-	}
+-	stat->freq_table = (unsigned int *)(stat->time_in_state + count);
+-
++	if (stat->time_in_state) {
++		memset(stat->time_in_state, 0, alloc_size);
++	} else {
++		stat->time_in_state = kzalloc(alloc_size, GFP_KERNEL);
++		if (!stat->time_in_state)
++			return -ENOMEM;
++		stat->freq_table = (unsigned int *)(
++				stat->time_in_state + count);
+ #ifdef CONFIG_CPU_FREQ_STAT_DETAILS
+-	stat->trans_table = stat->freq_table + count;
++		stat->trans_table = stat->freq_table + count;
+ #endif
++	}
++
+ 	j = 0;
+-	for (i = 0; table[i].frequency != CPUFREQ_TABLE_END; i++) {
+-		unsigned int freq = table[i].frequency;
+-		if (freq == CPUFREQ_ENTRY_INVALID)
+-			continue;
+-		if (freq_table_get_index(stat, freq) == -1)
+-			stat->freq_table[j++] = freq;
++	if (stat->freq_table) {
++		for (i = 0; table[i].frequency != CPUFREQ_TABLE_END; i++) {
++			unsigned int freq = table[i].frequency;
++			if (freq == CPUFREQ_ENTRY_INVALID)
++				continue;
++			if (freq_table_get_index(stat, freq) == -1)
++				stat->freq_table[j++] = freq;
++		}
+ 	}
+ 	stat->state_num = j;
+ 	spin_lock(&cpufreq_stats_lock);
+ 	stat->last_time = get_jiffies_64();
+ 	stat->last_index = freq_table_get_index(stat, policy->cur);
+ 	spin_unlock(&cpufreq_stats_lock);
++	return 0;
++}
++
++static int cpufreq_stats_create_table(struct cpufreq_policy *policy,
++		struct cpufreq_frequency_table *table)
++{
++	unsigned int ret = 0;
++	struct cpufreq_stats *stat;
++	struct cpufreq_policy *data;
++	unsigned int cpu = policy->cpu;
++
++	stat = kzalloc(sizeof(struct cpufreq_stats), GFP_KERNEL);
++	if ((stat) == NULL)
++		return -ENOMEM;
++
++	data = cpufreq_cpu_get(cpu);
++	if (data == NULL) {
++		ret = -EINVAL;
++		goto error_out;
++	}
++	ret = sysfs_create_group(&data->kobj, &stats_attr_group);
+ 	cpufreq_cpu_put(data);
++	if (ret)
++		goto error_out;
++
++	stat->cpu = cpu;
++	per_cpu(cpufreq_stats_table, cpu) = stat;
++
+ 	return 0;
+ error_out:
+-	cpufreq_cpu_put(data);
+-error_get_fail:
+ 	kfree(stat);
+ 	per_cpu(cpufreq_stats_table, cpu) = NULL;
+ 	return ret;
+@@ -274,10 +280,12 @@ static int cpufreq_stat_notifier_policy(
+ 	table = cpufreq_frequency_get_table(cpu);
+ 	if (!table)
+ 		return 0;
+-	ret = cpufreq_stats_create_table(policy, table);
+-	if (ret)
+-		return ret;
+-	return 0;
++	if (!per_cpu(cpufreq_stats_table, cpu)) {
++		ret = cpufreq_stats_create_table(policy, table);
++		if (ret)
++			return ret;
++	}
++	return cpufreq_stats_update_table(policy, table);
+ }
+ 
+ static int cpufreq_stat_notifier_trans(struct notifier_block *nb,
+@@ -297,21 +305,23 @@ static int cpufreq_stat_notifier_trans(s
+ 	old_index = stat->last_index;
+ 	new_index = freq_table_get_index(stat, freq->new);
+ 
+-	/* We can't do stat->time_in_state[-1]= .. */
+-	if (old_index == -1 || new_index == -1)
+-		return 0;
+-
+ 	cpufreq_stats_update(freq->cpu);
+-
+ 	if (old_index == new_index)
+ 		return 0;
+ 
++	if (new_index == -1)
++		return 0;
++
+ 	spin_lock(&cpufreq_stats_lock);
+ 	stat->last_index = new_index;
++	if (old_index != -1) {
+ #ifdef CONFIG_CPU_FREQ_STAT_DETAILS
+-	stat->trans_table[old_index * stat->max_state + new_index]++;
++		if (stat->trans_table)
++			stat->trans_table[old_index * stat->max_state +
++					  new_index]++;
+ #endif
+-	stat->total_trans++;
++		stat->total_trans++;
++	}
+ 	spin_unlock(&cpufreq_stats_lock);
+ 	return 0;
+ }
+@@ -327,9 +337,6 @@ static int __cpuinit cpufreq_stat_cpu_ca
+ 	case CPU_ONLINE_FROZEN:
+ 		cpufreq_update_policy(cpu);
+ 		break;
+-	case CPU_DOWN_PREPARE:
+-		cpufreq_stats_free_sysfs(cpu);
+-		break;
+ 	case CPU_DEAD:
+ 	case CPU_DEAD_FROZEN:
+ 		cpufreq_stats_free_table(cpu);
+@@ -338,10 +345,9 @@ static int __cpuinit cpufreq_stat_cpu_ca
+ 	return NOTIFY_OK;
+ }
+ 
+-/* priority=1 so this will get called before cpufreq_remove_dev */
+-static struct notifier_block cpufreq_stat_cpu_notifier __refdata = {
++static struct notifier_block cpufreq_stat_cpu_notifier __refdata =
++{
+ 	.notifier_call = cpufreq_stat_cpu_callback,
+-	.priority = 1,
+ };
+ 
+ static struct notifier_block notifier_policy_block = {
+@@ -388,7 +394,6 @@ static void __exit cpufreq_stats_exit(vo
+ 	unregister_hotcpu_notifier(&cpufreq_stat_cpu_notifier);
+ 	for_each_online_cpu(cpu) {
+ 		cpufreq_stats_free_table(cpu);
+-		cpufreq_stats_free_sysfs(cpu);
+ 	}
+ }
+