a7y18lte-ubports/android_kernel_samsung_universal7885
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[CPUFREQ] Convert drivers/cpufreq semaphores to mutexes.

Browse Source 
Semaphore to mutex conversion.

The conversion was generated via scripts, and the result was validated
automatically via a script as well.

Signed-off-by: Arjan van de Ven <arjan@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Dave Jones <davej@redhat.com>
This commit is contained in:
akpm@osdl.org 2006-01-13 15:54:22 -08:00 committed by Dave Jones
parent 7eb9b2f56c
commit 3fc54d37ab
4 changed files with 70 additions and 67 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
drivers/cpufreq/cpufreq.c
View File

@ -26,6 +26,7 @@
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/cpu.h> #include <linux/cpu.h>
#include <linux/completion.h> #include <linux/completion.h>
#include <linux/mutex.h>
#define dprintk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_CORE, "cpufreq-core", msg) #define dprintk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_CORE, "cpufreq-core", msg)
@ -55,7 +56,7 @@ static DECLARE_RWSEM (cpufreq_notifier_rwsem);
static LIST_HEAD(cpufreq_governor_list); static LIST_HEAD(cpufreq_governor_list);
static DECLARE_MUTEX (cpufreq_governor_sem); static DEFINE_MUTEX (cpufreq_governor_mutex);
struct cpufreq_policy * cpufreq_cpu_get(unsigned int cpu) struct cpufreq_policy * cpufreq_cpu_get(unsigned int cpu)
{ {
@ -297,18 +298,18 @@ static int cpufreq_parse_governor (char *str_governor, unsigned int *policy,
return -EINVAL; return -EINVAL;
} else { } else {
struct cpufreq_governor *t; struct cpufreq_governor *t;
down(&cpufreq_governor_sem); mutex_lock(&cpufreq_governor_mutex);
if (!cpufreq_driver || !cpufreq_driver->target) if (!cpufreq_driver || !cpufreq_driver->target)
goto out; goto out;
list_for_each_entry(t, &cpufreq_governor_list, governor_list) { list_for_each_entry(t, &cpufreq_governor_list, governor_list) {
if (!strnicmp(str_governor,t->name,CPUFREQ_NAME_LEN)) { if (!strnicmp(str_governor,t->name,CPUFREQ_NAME_LEN)) {
*governor = t; *governor = t;
up(&cpufreq_governor_sem); mutex_unlock(&cpufreq_governor_mutex);
return 0; return 0;
} }
} }
out: out:
up(&cpufreq_governor_sem); mutex_unlock(&cpufreq_governor_mutex);
} }
return -EINVAL; return -EINVAL;
} }
@ -1217,17 +1218,17 @@ int cpufreq_register_governor(struct cpufreq_governor *governor)
if (!governor) if (!governor)
return -EINVAL; return -EINVAL;
down(&cpufreq_governor_sem); mutex_lock(&cpufreq_governor_mutex);
list_for_each_entry(t, &cpufreq_governor_list, governor_list) { list_for_each_entry(t, &cpufreq_governor_list, governor_list) {
if (!strnicmp(governor->name,t->name,CPUFREQ_NAME_LEN)) { if (!strnicmp(governor->name,t->name,CPUFREQ_NAME_LEN)) {
up(&cpufreq_governor_sem); mutex_unlock(&cpufreq_governor_mutex);
return -EBUSY; return -EBUSY;
} }
} }
list_add(&governor->governor_list, &cpufreq_governor_list); list_add(&governor->governor_list, &cpufreq_governor_list);
up(&cpufreq_governor_sem); mutex_unlock(&cpufreq_governor_mutex);
return 0; return 0;
} }
@ -1239,9 +1240,9 @@ void cpufreq_unregister_governor(struct cpufreq_governor *governor)
if (!governor) if (!governor)
return; return;
down(&cpufreq_governor_sem); mutex_lock(&cpufreq_governor_mutex);
list_del(&governor->governor_list); list_del(&governor->governor_list);
up(&cpufreq_governor_sem); mutex_unlock(&cpufreq_governor_mutex);
return; return;
} }
EXPORT_SYMBOL_GPL(cpufreq_unregister_governor); EXPORT_SYMBOL_GPL(cpufreq_unregister_governor);

52
drivers/cpufreq/cpufreq_conservative.c
View File

@ -28,7 +28,7 @@
#include <linux/jiffies.h> #include <linux/jiffies.h>
#include <linux/kernel_stat.h> #include <linux/kernel_stat.h>
#include <linux/percpu.h> #include <linux/percpu.h>
#include <linux/mutex.h>
/* /*
* dbs is used in this file as a shortform for demandbased switching * dbs is used in this file as a shortform for demandbased switching
* It helps to keep variable names smaller, simpler * It helps to keep variable names smaller, simpler
@ -71,7 +71,7 @@ static DEFINE_PER_CPU(struct cpu_dbs_info_s, cpu_dbs_info);
static unsigned int dbs_enable; /* number of CPUs using this policy */ static unsigned int dbs_enable; /* number of CPUs using this policy */
static DECLARE_MUTEX (dbs_sem); static DEFINE_MUTEX (dbs_mutex);
static DECLARE_WORK (dbs_work, do_dbs_timer, NULL); static DECLARE_WORK (dbs_work, do_dbs_timer, NULL);
struct dbs_tuners { struct dbs_tuners {
@ -139,9 +139,9 @@ static ssize_t store_sampling_down_factor(struct cpufreq_policy *unused,
if (ret != 1 ) if (ret != 1 )
return -EINVAL; return -EINVAL;
down(&dbs_sem); mutex_lock(&dbs_mutex);
dbs_tuners_ins.sampling_down_factor = input; dbs_tuners_ins.sampling_down_factor = input;
up(&dbs_sem); mutex_unlock(&dbs_mutex);
return count; return count;
} }
@ -153,14 +153,14 @@ static ssize_t store_sampling_rate(struct cpufreq_policy *unused,
int ret; int ret;
ret = sscanf (buf, "%u", &input); ret = sscanf (buf, "%u", &input);
down(&dbs_sem); mutex_lock(&dbs_mutex);
if (ret != 1 || input > MAX_SAMPLING_RATE || input < MIN_SAMPLING_RATE) { if (ret != 1 || input > MAX_SAMPLING_RATE || input < MIN_SAMPLING_RATE) {
up(&dbs_sem); mutex_unlock(&dbs_mutex);
return -EINVAL; return -EINVAL;
} }
dbs_tuners_ins.sampling_rate = input; dbs_tuners_ins.sampling_rate = input;
up(&dbs_sem); mutex_unlock(&dbs_mutex);
return count; return count;
} }
@ -172,16 +172,16 @@ static ssize_t store_up_threshold(struct cpufreq_policy *unused,
int ret; int ret;
ret = sscanf (buf, "%u", &input); ret = sscanf (buf, "%u", &input);
down(&dbs_sem); mutex_lock(&dbs_mutex);
if (ret != 1 || input > MAX_FREQUENCY_UP_THRESHOLD || if (ret != 1 || input > MAX_FREQUENCY_UP_THRESHOLD ||
input < MIN_FREQUENCY_UP_THRESHOLD || input < MIN_FREQUENCY_UP_THRESHOLD ||
input <= dbs_tuners_ins.down_threshold) { input <= dbs_tuners_ins.down_threshold) {
up(&dbs_sem); mutex_unlock(&dbs_mutex);
return -EINVAL; return -EINVAL;
} }
dbs_tuners_ins.up_threshold = input; dbs_tuners_ins.up_threshold = input;
up(&dbs_sem); mutex_unlock(&dbs_mutex);
return count; return count;
} }
@ -193,16 +193,16 @@ static ssize_t store_down_threshold(struct cpufreq_policy *unused,
int ret; int ret;
ret = sscanf (buf, "%u", &input); ret = sscanf (buf, "%u", &input);
down(&dbs_sem); mutex_lock(&dbs_mutex);
if (ret != 1 || input > MAX_FREQUENCY_DOWN_THRESHOLD || if (ret != 1 || input > MAX_FREQUENCY_DOWN_THRESHOLD ||
input < MIN_FREQUENCY_DOWN_THRESHOLD || input < MIN_FREQUENCY_DOWN_THRESHOLD ||
input >= dbs_tuners_ins.up_threshold) { input >= dbs_tuners_ins.up_threshold) {
up(&dbs_sem); mutex_unlock(&dbs_mutex);
return -EINVAL; return -EINVAL;
} }
dbs_tuners_ins.down_threshold = input; dbs_tuners_ins.down_threshold = input;
up(&dbs_sem); mutex_unlock(&dbs_mutex);
return count; return count;
} }
@ -222,9 +222,9 @@ static ssize_t store_ignore_nice_load(struct cpufreq_policy *policy,
if ( input > 1 ) if ( input > 1 )
input = 1; input = 1;
down(&dbs_sem); mutex_lock(&dbs_mutex);
if ( input == dbs_tuners_ins.ignore_nice ) { /* nothing to do */ if ( input == dbs_tuners_ins.ignore_nice ) { /* nothing to do */
up(&dbs_sem); mutex_unlock(&dbs_mutex);
return count; return count;
} }
dbs_tuners_ins.ignore_nice = input; dbs_tuners_ins.ignore_nice = input;
@ -236,7 +236,7 @@ static ssize_t store_ignore_nice_load(struct cpufreq_policy *policy,
j_dbs_info->prev_cpu_idle_up = get_cpu_idle_time(j); j_dbs_info->prev_cpu_idle_up = get_cpu_idle_time(j);
j_dbs_info->prev_cpu_idle_down = j_dbs_info->prev_cpu_idle_up; j_dbs_info->prev_cpu_idle_down = j_dbs_info->prev_cpu_idle_up;
} }
up(&dbs_sem); mutex_unlock(&dbs_mutex);
return count; return count;
} }
@ -257,9 +257,9 @@ static ssize_t store_freq_step(struct cpufreq_policy *policy,
/* no need to test here if freq_step is zero as the user might actually /* no need to test here if freq_step is zero as the user might actually
* want this, they would be crazy though :) */ * want this, they would be crazy though :) */
down(&dbs_sem); mutex_lock(&dbs_mutex);
dbs_tuners_ins.freq_step = input; dbs_tuners_ins.freq_step = input;
up(&dbs_sem); mutex_unlock(&dbs_mutex);
return count; return count;
} }
@ -444,12 +444,12 @@ static void dbs_check_cpu(int cpu)
static void do_dbs_timer(void *data) static void do_dbs_timer(void *data)
{ {
int i; int i;
down(&dbs_sem); mutex_lock(&dbs_mutex);
for_each_online_cpu(i) for_each_online_cpu(i)
dbs_check_cpu(i); dbs_check_cpu(i);
schedule_delayed_work(&dbs_work, schedule_delayed_work(&dbs_work,
usecs_to_jiffies(dbs_tuners_ins.sampling_rate)); usecs_to_jiffies(dbs_tuners_ins.sampling_rate));
up(&dbs_sem); mutex_unlock(&dbs_mutex);
} }
static inline void dbs_timer_init(void) static inline void dbs_timer_init(void)
@ -487,7 +487,7 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
if (this_dbs_info->enable) /* Already enabled */ if (this_dbs_info->enable) /* Already enabled */
break; break;
down(&dbs_sem); mutex_lock(&dbs_mutex);
for_each_cpu_mask(j, policy->cpus) { for_each_cpu_mask(j, policy->cpus) {
struct cpu_dbs_info_s *j_dbs_info; struct cpu_dbs_info_s *j_dbs_info;
j_dbs_info = &per_cpu(cpu_dbs_info, j); j_dbs_info = &per_cpu(cpu_dbs_info, j);
@ -521,11 +521,11 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
dbs_timer_init(); dbs_timer_init();
} }
up(&dbs_sem); mutex_unlock(&dbs_mutex);
break; break;
case CPUFREQ_GOV_STOP: case CPUFREQ_GOV_STOP:
down(&dbs_sem); mutex_lock(&dbs_mutex);
this_dbs_info->enable = 0; this_dbs_info->enable = 0;
sysfs_remove_group(&policy->kobj, &dbs_attr_group); sysfs_remove_group(&policy->kobj, &dbs_attr_group);
dbs_enable--; dbs_enable--;
@ -536,12 +536,12 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
if (dbs_enable == 0) if (dbs_enable == 0)
dbs_timer_exit(); dbs_timer_exit();
up(&dbs_sem); mutex_unlock(&dbs_mutex);
break; break;
case CPUFREQ_GOV_LIMITS: case CPUFREQ_GOV_LIMITS:
down(&dbs_sem); mutex_lock(&dbs_mutex);
if (policy->max < this_dbs_info->cur_policy->cur) if (policy->max < this_dbs_info->cur_policy->cur)
__cpufreq_driver_target( __cpufreq_driver_target(
this_dbs_info->cur_policy, this_dbs_info->cur_policy,
@ -550,7 +550,7 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
__cpufreq_driver_target( __cpufreq_driver_target(
this_dbs_info->cur_policy, this_dbs_info->cur_policy,
policy->min, CPUFREQ_RELATION_L); policy->min, CPUFREQ_RELATION_L);
up(&dbs_sem); mutex_unlock(&dbs_mutex);
break; break;
} }
return 0; return 0;

41
drivers/cpufreq/cpufreq_ondemand.c
View File

@ -27,6 +27,7 @@
#include <linux/jiffies.h> #include <linux/jiffies.h>
#include <linux/kernel_stat.h> #include <linux/kernel_stat.h>
#include <linux/percpu.h> #include <linux/percpu.h>
#include <linux/mutex.h>
/* /*
* dbs is used in this file as a shortform for demandbased switching * dbs is used in this file as a shortform for demandbased switching
@ -70,7 +71,7 @@ static DEFINE_PER_CPU(struct cpu_dbs_info_s, cpu_dbs_info);
static unsigned int dbs_enable; /* number of CPUs using this policy */ static unsigned int dbs_enable; /* number of CPUs using this policy */
static DECLARE_MUTEX (dbs_sem); static DEFINE_MUTEX (dbs_mutex);
static DECLARE_WORK (dbs_work, do_dbs_timer, NULL); static DECLARE_WORK (dbs_work, do_dbs_timer, NULL);
struct dbs_tuners { struct dbs_tuners {
@ -136,9 +137,9 @@ static ssize_t store_sampling_down_factor(struct cpufreq_policy *unused,
if (input > MAX_SAMPLING_DOWN_FACTOR || input < 1) if (input > MAX_SAMPLING_DOWN_FACTOR || input < 1)
return -EINVAL; return -EINVAL;
down(&dbs_sem); mutex_lock(&dbs_mutex);
dbs_tuners_ins.sampling_down_factor = input; dbs_tuners_ins.sampling_down_factor = input;
up(&dbs_sem); mutex_unlock(&dbs_mutex);
return count; return count;
} }
@ -150,14 +151,14 @@ static ssize_t store_sampling_rate(struct cpufreq_policy *unused,
int ret; int ret;
ret = sscanf (buf, "%u", &input); ret = sscanf (buf, "%u", &input);
down(&dbs_sem); mutex_lock(&dbs_mutex);
if (ret != 1 || input > MAX_SAMPLING_RATE || input < MIN_SAMPLING_RATE) { if (ret != 1 || input > MAX_SAMPLING_RATE || input < MIN_SAMPLING_RATE) {
up(&dbs_sem); mutex_unlock(&dbs_mutex);
return -EINVAL; return -EINVAL;
} }
dbs_tuners_ins.sampling_rate = input; dbs_tuners_ins.sampling_rate = input;
up(&dbs_sem); mutex_unlock(&dbs_mutex);
return count; return count;
} }
@ -169,15 +170,15 @@ static ssize_t store_up_threshold(struct cpufreq_policy *unused,
int ret; int ret;
ret = sscanf (buf, "%u", &input); ret = sscanf (buf, "%u", &input);
down(&dbs_sem); mutex_lock(&dbs_mutex);
if (ret != 1 || input > MAX_FREQUENCY_UP_THRESHOLD || if (ret != 1 || input > MAX_FREQUENCY_UP_THRESHOLD ||
input < MIN_FREQUENCY_UP_THRESHOLD) { input < MIN_FREQUENCY_UP_THRESHOLD) {
up(&dbs_sem); mutex_unlock(&dbs_mutex);
return -EINVAL; return -EINVAL;
} }
dbs_tuners_ins.up_threshold = input; dbs_tuners_ins.up_threshold = input;
up(&dbs_sem); mutex_unlock(&dbs_mutex);
return count; return count;
} }
@ -197,9 +198,9 @@ static ssize_t store_ignore_nice_load(struct cpufreq_policy *policy,
if ( input > 1 ) if ( input > 1 )
input = 1; input = 1;
down(&dbs_sem); mutex_lock(&dbs_mutex);
if ( input == dbs_tuners_ins.ignore_nice ) { /* nothing to do */ if ( input == dbs_tuners_ins.ignore_nice ) { /* nothing to do */
up(&dbs_sem); mutex_unlock(&dbs_mutex);
return count; return count;
} }
dbs_tuners_ins.ignore_nice = input; dbs_tuners_ins.ignore_nice = input;
@ -211,7 +212,7 @@ static ssize_t store_ignore_nice_load(struct cpufreq_policy *policy,
j_dbs_info->prev_cpu_idle_up = get_cpu_idle_time(j); j_dbs_info->prev_cpu_idle_up = get_cpu_idle_time(j);
j_dbs_info->prev_cpu_idle_down = j_dbs_info->prev_cpu_idle_up; j_dbs_info->prev_cpu_idle_down = j_dbs_info->prev_cpu_idle_up;
} }
up(&dbs_sem); mutex_unlock(&dbs_mutex);
return count; return count;
} }
@ -356,12 +357,12 @@ static void dbs_check_cpu(int cpu)
static void do_dbs_timer(void *data) static void do_dbs_timer(void *data)
{ {
int i; int i;
down(&dbs_sem); mutex_lock(&dbs_mutex);
for_each_online_cpu(i) for_each_online_cpu(i)
dbs_check_cpu(i); dbs_check_cpu(i);
schedule_delayed_work(&dbs_work, schedule_delayed_work(&dbs_work,
usecs_to_jiffies(dbs_tuners_ins.sampling_rate)); usecs_to_jiffies(dbs_tuners_ins.sampling_rate));
up(&dbs_sem); mutex_unlock(&dbs_mutex);
} }
static inline void dbs_timer_init(void) static inline void dbs_timer_init(void)
@ -399,7 +400,7 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
if (this_dbs_info->enable) /* Already enabled */ if (this_dbs_info->enable) /* Already enabled */
break; break;
down(&dbs_sem); mutex_lock(&dbs_mutex);
for_each_cpu_mask(j, policy->cpus) { for_each_cpu_mask(j, policy->cpus) {
struct cpu_dbs_info_s *j_dbs_info; struct cpu_dbs_info_s *j_dbs_info;
j_dbs_info = &per_cpu(cpu_dbs_info, j); j_dbs_info = &per_cpu(cpu_dbs_info, j);
@ -435,11 +436,11 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
dbs_timer_init(); dbs_timer_init();
} }
up(&dbs_sem); mutex_unlock(&dbs_mutex);
break; break;
case CPUFREQ_GOV_STOP: case CPUFREQ_GOV_STOP:
down(&dbs_sem); mutex_lock(&dbs_mutex);
this_dbs_info->enable = 0; this_dbs_info->enable = 0;
sysfs_remove_group(&policy->kobj, &dbs_attr_group); sysfs_remove_group(&policy->kobj, &dbs_attr_group);
dbs_enable--; dbs_enable--;
@ -450,12 +451,12 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
if (dbs_enable == 0) if (dbs_enable == 0)
dbs_timer_exit(); dbs_timer_exit();
up(&dbs_sem); mutex_unlock(&dbs_mutex);
break; break;
case CPUFREQ_GOV_LIMITS: case CPUFREQ_GOV_LIMITS:
down(&dbs_sem); mutex_lock(&dbs_mutex);
if (policy->max < this_dbs_info->cur_policy->cur) if (policy->max < this_dbs_info->cur_policy->cur)
__cpufreq_driver_target( __cpufreq_driver_target(
this_dbs_info->cur_policy, this_dbs_info->cur_policy,
@ -464,7 +465,7 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
__cpufreq_driver_target( __cpufreq_driver_target(
this_dbs_info->cur_policy, this_dbs_info->cur_policy,
policy->min, CPUFREQ_RELATION_L); policy->min, CPUFREQ_RELATION_L);
up(&dbs_sem); mutex_unlock(&dbs_mutex);
break; break;
} }
return 0; return 0;

25
drivers/cpufreq/cpufreq_userspace.c
View File

@ -21,6 +21,7 @@
#include <linux/types.h> #include <linux/types.h>
#include <linux/fs.h> #include <linux/fs.h>
#include <linux/sysfs.h> #include <linux/sysfs.h>
#include <linux/mutex.h>
#include <asm/uaccess.h> #include <asm/uaccess.h>
@ -35,7 +36,7 @@ static unsigned int cpu_set_freq[NR_CPUS]; /* CPU freq desired by userspace */
static unsigned int cpu_is_managed[NR_CPUS]; static unsigned int cpu_is_managed[NR_CPUS];
static struct cpufreq_policy current_policy[NR_CPUS]; static struct cpufreq_policy current_policy[NR_CPUS];
static DECLARE_MUTEX (userspace_sem); static DEFINE_MUTEX (userspace_mutex);
#define dprintk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_GOVERNOR, "userspace", msg) #define dprintk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_GOVERNOR, "userspace", msg)
@ -70,7 +71,7 @@ static int cpufreq_set(unsigned int freq, unsigned int cpu)
dprintk("cpufreq_set for cpu %u, freq %u kHz\n", cpu, freq); dprintk("cpufreq_set for cpu %u, freq %u kHz\n", cpu, freq);
down(&userspace_sem); mutex_lock(&userspace_mutex);
if (!cpu_is_managed[cpu]) if (!cpu_is_managed[cpu])
goto err; goto err;
@ -83,16 +84,16 @@ static int cpufreq_set(unsigned int freq, unsigned int cpu)
/* /*
* We're safe from concurrent calls to ->target() here * We're safe from concurrent calls to ->target() here
* as we hold the userspace_sem lock. If we were calling * as we hold the userspace_mutex lock. If we were calling
* cpufreq_driver_target, a deadlock situation might occur: * cpufreq_driver_target, a deadlock situation might occur:
* A: cpufreq_set (lock userspace_sem) -> cpufreq_driver_target(lock policy->lock) * A: cpufreq_set (lock userspace_mutex) -> cpufreq_driver_target(lock policy->lock)
* B: cpufreq_set_policy(lock policy->lock) -> __cpufreq_governor -> cpufreq_governor_userspace (lock userspace_sem) * B: cpufreq_set_policy(lock policy->lock) -> __cpufreq_governor -> cpufreq_governor_userspace (lock userspace_mutex)
*/ */
ret = __cpufreq_driver_target(&current_policy[cpu], freq, ret = __cpufreq_driver_target(&current_policy[cpu], freq,
CPUFREQ_RELATION_L); CPUFREQ_RELATION_L);
err: err:
up(&userspace_sem); mutex_unlock(&userspace_mutex);
return ret; return ret;
} }
@ -134,7 +135,7 @@ static int cpufreq_governor_userspace(struct cpufreq_policy *policy,
if (!cpu_online(cpu)) if (!cpu_online(cpu))
return -EINVAL; return -EINVAL;
BUG_ON(!policy->cur); BUG_ON(!policy->cur);
down(&userspace_sem); mutex_lock(&userspace_mutex);
cpu_is_managed[cpu] = 1; cpu_is_managed[cpu] = 1;
cpu_min_freq[cpu] = policy->min; cpu_min_freq[cpu] = policy->min;
cpu_max_freq[cpu] = policy->max; cpu_max_freq[cpu] = policy->max;
@ -143,20 +144,20 @@ static int cpufreq_governor_userspace(struct cpufreq_policy *policy,
sysfs_create_file (&policy->kobj, &freq_attr_scaling_setspeed.attr); sysfs_create_file (&policy->kobj, &freq_attr_scaling_setspeed.attr);
memcpy (&current_policy[cpu], policy, sizeof(struct cpufreq_policy)); memcpy (&current_policy[cpu], policy, sizeof(struct cpufreq_policy));
dprintk("managing cpu %u started (%u - %u kHz, currently %u kHz)\n", cpu, cpu_min_freq[cpu], cpu_max_freq[cpu], cpu_cur_freq[cpu]); dprintk("managing cpu %u started (%u - %u kHz, currently %u kHz)\n", cpu, cpu_min_freq[cpu], cpu_max_freq[cpu], cpu_cur_freq[cpu]);
up(&userspace_sem); mutex_unlock(&userspace_mutex);
break; break;
case CPUFREQ_GOV_STOP: case CPUFREQ_GOV_STOP:
down(&userspace_sem); mutex_lock(&userspace_mutex);
cpu_is_managed[cpu] = 0; cpu_is_managed[cpu] = 0;
cpu_min_freq[cpu] = 0; cpu_min_freq[cpu] = 0;
cpu_max_freq[cpu] = 0; cpu_max_freq[cpu] = 0;
cpu_set_freq[cpu] = 0; cpu_set_freq[cpu] = 0;
sysfs_remove_file (&policy->kobj, &freq_attr_scaling_setspeed.attr); sysfs_remove_file (&policy->kobj, &freq_attr_scaling_setspeed.attr);
dprintk("managing cpu %u stopped\n", cpu); dprintk("managing cpu %u stopped\n", cpu);
up(&userspace_sem); mutex_unlock(&userspace_mutex);
break; break;
case CPUFREQ_GOV_LIMITS: case CPUFREQ_GOV_LIMITS:
down(&userspace_sem); mutex_lock(&userspace_mutex);
cpu_min_freq[cpu] = policy->min; cpu_min_freq[cpu] = policy->min;
cpu_max_freq[cpu] = policy->max; cpu_max_freq[cpu] = policy->max;
dprintk("limit event for cpu %u: %u - %u kHz, currently %u kHz, last set to %u kHz\n", cpu, cpu_min_freq[cpu], cpu_max_freq[cpu], cpu_cur_freq[cpu], cpu_set_freq[cpu]); dprintk("limit event for cpu %u: %u - %u kHz, currently %u kHz, last set to %u kHz\n", cpu, cpu_min_freq[cpu], cpu_max_freq[cpu], cpu_cur_freq[cpu], cpu_set_freq[cpu]);
@ -171,7 +172,7 @@ static int cpufreq_governor_userspace(struct cpufreq_policy *policy,
CPUFREQ_RELATION_L); CPUFREQ_RELATION_L);
} }
memcpy (&current_policy[cpu], policy, sizeof(struct cpufreq_policy)); memcpy (&current_policy[cpu], policy, sizeof(struct cpufreq_policy));
up(&userspace_sem); mutex_unlock(&userspace_mutex);
break; break;
} }
return 0; return 0;