1 2 /* 3 * linux/drivers/cpufreq/cpufreq_userspace.c 4 * 5 * Copyright (C) 2001 Russell King 6 * (C) 2002 - 2004 Dominik Brodowski <linux@brodo.de> 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License version 2 as 10 * published by the Free Software Foundation. 11 * 12 */ 13 14 #include <linux/kernel.h> 15 #include <linux/module.h> 16 #include <linux/smp.h> 17 #include <linux/init.h> 18 #include <linux/spinlock.h> 19 #include <linux/interrupt.h> 20 #include <linux/cpufreq.h> 21 #include <linux/cpu.h> 22 #include <linux/types.h> 23 #include <linux/fs.h> 24 #include <linux/sysfs.h> 25 #include <linux/mutex.h> 26 27 #include <asm/uaccess.h> 28 29 30 /** 31 * A few values needed by the userspace governor 32 */ 33 static unsigned int cpu_max_freq[NR_CPUS]; 34 static unsigned int cpu_min_freq[NR_CPUS]; 35 static unsigned int cpu_cur_freq[NR_CPUS]; /* current CPU freq */ 36 static unsigned int cpu_set_freq[NR_CPUS]; /* CPU freq desired by userspace */ 37 static unsigned int cpu_is_managed[NR_CPUS]; 38 39 static DEFINE_MUTEX (userspace_mutex); 40 41 #define dprintk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_GOVERNOR, "userspace", msg) 42 43 /* keep track of frequency transitions */ 44 static int 45 userspace_cpufreq_notifier(struct notifier_block *nb, unsigned long val, 46 void *data) 47 { 48 struct cpufreq_freqs *freq = data; 49 50 dprintk("saving cpu_cur_freq of cpu %u to be %u kHz\n", freq->cpu, freq->new); 51 cpu_cur_freq[freq->cpu] = freq->new; 52 53 return 0; 54 } 55 56 static struct notifier_block userspace_cpufreq_notifier_block = { 57 .notifier_call = userspace_cpufreq_notifier 58 }; 59 60 61 /** 62 * cpufreq_set - set the CPU frequency 63 * @freq: target frequency in kHz 64 * @cpu: CPU for which the frequency is to be set 65 * 66 * Sets the CPU frequency to freq. 67 */ 68 static int cpufreq_set(unsigned int freq, struct cpufreq_policy *policy) 69 { 70 int ret = -EINVAL; 71 72 dprintk("cpufreq_set for cpu %u, freq %u kHz\n", policy->cpu, freq); 73 74 lock_cpu_hotplug(); 75 mutex_lock(&userspace_mutex); 76 if (!cpu_is_managed[policy->cpu]) 77 goto err; 78 79 cpu_set_freq[policy->cpu] = freq; 80 81 if (freq < cpu_min_freq[policy->cpu]) 82 freq = cpu_min_freq[policy->cpu]; 83 if (freq > cpu_max_freq[policy->cpu]) 84 freq = cpu_max_freq[policy->cpu]; 85 86 /* 87 * We're safe from concurrent calls to ->target() here 88 * as we hold the userspace_mutex lock. If we were calling 89 * cpufreq_driver_target, a deadlock situation might occur: 90 * A: cpufreq_set (lock userspace_mutex) -> cpufreq_driver_target(lock policy->lock) 91 * B: cpufreq_set_policy(lock policy->lock) -> __cpufreq_governor -> cpufreq_governor_userspace (lock userspace_mutex) 92 */ 93 ret = __cpufreq_driver_target(policy, freq, CPUFREQ_RELATION_L); 94 95 err: 96 mutex_unlock(&userspace_mutex); 97 unlock_cpu_hotplug(); 98 return ret; 99 } 100 101 102 /************************** sysfs interface ************************/ 103 static ssize_t show_speed (struct cpufreq_policy *policy, char *buf) 104 { 105 return sprintf (buf, "%u\n", cpu_cur_freq[policy->cpu]); 106 } 107 108 static ssize_t 109 store_speed (struct cpufreq_policy *policy, const char *buf, size_t count) 110 { 111 unsigned int freq = 0; 112 unsigned int ret; 113 114 ret = sscanf (buf, "%u", &freq); 115 if (ret != 1) 116 return -EINVAL; 117 118 cpufreq_set(freq, policy); 119 120 return count; 121 } 122 123 static struct freq_attr freq_attr_scaling_setspeed = 124 { 125 .attr = { .name = "scaling_setspeed", .mode = 0644, .owner = THIS_MODULE }, 126 .show = show_speed, 127 .store = store_speed, 128 }; 129 130 static int cpufreq_governor_userspace(struct cpufreq_policy *policy, 131 unsigned int event) 132 { 133 unsigned int cpu = policy->cpu; 134 switch (event) { 135 case CPUFREQ_GOV_START: 136 if (!cpu_online(cpu)) 137 return -EINVAL; 138 BUG_ON(!policy->cur); 139 mutex_lock(&userspace_mutex); 140 cpu_is_managed[cpu] = 1; 141 cpu_min_freq[cpu] = policy->min; 142 cpu_max_freq[cpu] = policy->max; 143 cpu_cur_freq[cpu] = policy->cur; 144 cpu_set_freq[cpu] = policy->cur; 145 sysfs_create_file (&policy->kobj, &freq_attr_scaling_setspeed.attr); 146 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]); 147 mutex_unlock(&userspace_mutex); 148 break; 149 case CPUFREQ_GOV_STOP: 150 mutex_lock(&userspace_mutex); 151 cpu_is_managed[cpu] = 0; 152 cpu_min_freq[cpu] = 0; 153 cpu_max_freq[cpu] = 0; 154 cpu_set_freq[cpu] = 0; 155 sysfs_remove_file (&policy->kobj, &freq_attr_scaling_setspeed.attr); 156 dprintk("managing cpu %u stopped\n", cpu); 157 mutex_unlock(&userspace_mutex); 158 break; 159 case CPUFREQ_GOV_LIMITS: 160 mutex_lock(&userspace_mutex); 161 dprintk("limit event for cpu %u: %u - %u kHz," 162 "currently %u kHz, last set to %u kHz\n", 163 cpu, policy->min, policy->max, 164 cpu_cur_freq[cpu], cpu_set_freq[cpu]); 165 if (policy->max < cpu_set_freq[cpu]) { 166 __cpufreq_driver_target(policy, policy->max, 167 CPUFREQ_RELATION_H); 168 } 169 else if (policy->min > cpu_set_freq[cpu]) { 170 __cpufreq_driver_target(policy, policy->min, 171 CPUFREQ_RELATION_L); 172 } 173 else { 174 __cpufreq_driver_target(policy, cpu_set_freq[cpu], 175 CPUFREQ_RELATION_L); 176 } 177 cpu_min_freq[cpu] = policy->min; 178 cpu_max_freq[cpu] = policy->max; 179 cpu_cur_freq[cpu] = policy->cur; 180 mutex_unlock(&userspace_mutex); 181 break; 182 } 183 return 0; 184 } 185 186 187 struct cpufreq_governor cpufreq_gov_userspace = { 188 .name = "userspace", 189 .governor = cpufreq_governor_userspace, 190 .owner = THIS_MODULE, 191 }; 192 EXPORT_SYMBOL(cpufreq_gov_userspace); 193 194 static int __init cpufreq_gov_userspace_init(void) 195 { 196 cpufreq_register_notifier(&userspace_cpufreq_notifier_block, CPUFREQ_TRANSITION_NOTIFIER); 197 return cpufreq_register_governor(&cpufreq_gov_userspace); 198 } 199 200 201 static void __exit cpufreq_gov_userspace_exit(void) 202 { 203 cpufreq_unregister_governor(&cpufreq_gov_userspace); 204 cpufreq_unregister_notifier(&userspace_cpufreq_notifier_block, CPUFREQ_TRANSITION_NOTIFIER); 205 } 206 207 208 MODULE_AUTHOR ("Dominik Brodowski <linux@brodo.de>, Russell King <rmk@arm.linux.org.uk>"); 209 MODULE_DESCRIPTION ("CPUfreq policy governor 'userspace'"); 210 MODULE_LICENSE ("GPL"); 211 212 fs_initcall(cpufreq_gov_userspace_init); 213 module_exit(cpufreq_gov_userspace_exit); 214