drivers/cpufreq/cpufreq_userspace.c

   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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  15
  16 #include <linux/cpufreq.h>
  17 #include <linux/init.h>
  18 #include <linux/module.h>
  19 #include <linux/mutex.h>
  20 #include <linux/slab.h>
  21
  22 static DEFINE_PER_CPU(unsigned int, cpu_is_managed);
  23 static DEFINE_MUTEX(userspace_mutex);
  24
  25 /**
  26  * cpufreq_set - set the CPU frequency
  27  * @policy: pointer to policy struct where freq is being set
  28  * @freq: target frequency in kHz
  29  *
  30  * Sets the CPU frequency to freq.
  31  */
  32 static int cpufreq_set(struct cpufreq_policy *policy, unsigned int freq)
  33 {
  34         int ret = -EINVAL;
  35         unsigned int *setspeed = policy->governor_data;
  36
  37         pr_debug("cpufreq_set for cpu %u, freq %u kHz\n", policy->cpu, freq);
  38
  39         mutex_lock(&userspace_mutex);
  40         if (!per_cpu(cpu_is_managed, policy->cpu))
  41                 goto err;
  42
  43         *setspeed = freq;
  44
  45         /*
  46          * We're safe from concurrent calls to ->target() here
  47          * as we hold the userspace_mutex lock. If we were calling
  48          * cpufreq_driver_target, a deadlock situation might occur:
  49          * A: cpufreq_set (lock userspace_mutex) ->
  50          *      cpufreq_driver_target(lock policy->lock)
  51          * B: cpufreq_set_policy(lock policy->lock) ->
  52          *      __cpufreq_governor ->
  53          *         cpufreq_governor_userspace (lock userspace_mutex)
  54          */
  55         ret = __cpufreq_driver_target(policy, freq, CPUFREQ_RELATION_L);
  56
  57  err:
  58         mutex_unlock(&userspace_mutex);
  59         return ret;
  60 }
  61
  62 static ssize_t show_speed(struct cpufreq_policy *policy, char *buf)
  63 {
  64         return sprintf(buf, "%u\n", policy->cur);
  65 }
  66
  67 static int cpufreq_userspace_policy_init(struct cpufreq_policy *policy)
  68 {
  69         unsigned int *setspeed;
  70
  71         setspeed = kzalloc(sizeof(*setspeed), GFP_KERNEL);
  72         if (!setspeed)
  73                 return -ENOMEM;
  74
  75         policy->governor_data = setspeed;
  76         return 0;
  77 }
  78
  79 static int cpufreq_governor_userspace(struct cpufreq_policy *policy,
  80                                    unsigned int event)
  81 {
  82         unsigned int *setspeed = policy->governor_data;
  83         unsigned int cpu = policy->cpu;
  84         int rc = 0;
  85
  86         if (event == CPUFREQ_GOV_POLICY_INIT)
  87                 return cpufreq_userspace_policy_init(policy);
  88
  89         if (!setspeed)
  90                 return -EINVAL;
  91
  92         switch (event) {
  93         case CPUFREQ_GOV_POLICY_EXIT:
  94                 mutex_lock(&userspace_mutex);
  95                 policy->governor_data = NULL;
  96                 kfree(setspeed);
  97                 mutex_unlock(&userspace_mutex);
  98                 break;
  99         case CPUFREQ_GOV_START:
 100                 BUG_ON(!policy->cur);
 101                 pr_debug("started managing cpu %u\n", cpu);
 102
 103                 mutex_lock(&userspace_mutex);
 104                 per_cpu(cpu_is_managed, cpu) = 1;
 105                 *setspeed = policy->cur;
 106                 mutex_unlock(&userspace_mutex);
 107                 break;
 108         case CPUFREQ_GOV_STOP:
 109                 pr_debug("managing cpu %u stopped\n", cpu);
 110
 111                 mutex_lock(&userspace_mutex);
 112                 per_cpu(cpu_is_managed, cpu) = 0;
 113                 *setspeed = 0;
 114                 mutex_unlock(&userspace_mutex);
 115                 break;
 116         case CPUFREQ_GOV_LIMITS:
 117                 mutex_lock(&userspace_mutex);
 118                 pr_debug("limit event for cpu %u: %u - %u kHz, currently %u kHz, last set to %u kHz\n",
 119                         cpu, policy->min, policy->max, policy->cur, *setspeed);
 120
 121                 if (policy->max < *setspeed)
 122                         __cpufreq_driver_target(policy, policy->max,
 123                                                 CPUFREQ_RELATION_H);
 124                 else if (policy->min > *setspeed)
 125                         __cpufreq_driver_target(policy, policy->min,
 126                                                 CPUFREQ_RELATION_L);
 127                 else
 128                         __cpufreq_driver_target(policy, *setspeed,
 129                                                 CPUFREQ_RELATION_L);
 130                 mutex_unlock(&userspace_mutex);
 131                 break;
 132         }
 133         return rc;
 134 }
 135
 136 #ifndef CONFIG_CPU_FREQ_DEFAULT_GOV_USERSPACE
 137 static
 138 #endif
 139 struct cpufreq_governor cpufreq_gov_userspace = {
 140         .name           = "userspace",
 141         .governor       = cpufreq_governor_userspace,
 142         .store_setspeed = cpufreq_set,
 143         .show_setspeed  = show_speed,
 144         .owner          = THIS_MODULE,
 145 };
 146
 147 static int __init cpufreq_gov_userspace_init(void)
 148 {
 149         return cpufreq_register_governor(&cpufreq_gov_userspace);
 150 }
 151
 152 static void __exit cpufreq_gov_userspace_exit(void)
 153 {
 154         cpufreq_unregister_governor(&cpufreq_gov_userspace);
 155 }
 156
 157 MODULE_AUTHOR("Dominik Brodowski <linux@brodo.de>, "
 158                 "Russell King <rmk@arm.linux.org.uk>");
 159 MODULE_DESCRIPTION("CPUfreq policy governor 'userspace'");
 160 MODULE_LICENSE("GPL");
 161
 162 #ifdef CONFIG_CPU_FREQ_DEFAULT_GOV_USERSPACE
 163 fs_initcall(cpufreq_gov_userspace_init);
 164 #else
 165 module_init(cpufreq_gov_userspace_init);
 166 #endif
 167 module_exit(cpufreq_gov_userspace_exit);