Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * drivers/cpufreq/cpufreq_ondemand.c |
| 3 | * |
| 4 | * Copyright (C) 2001 Russell King |
| 5 | * (C) 2003 Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>. |
| 6 | * Jun Nakajima <jun.nakajima@intel.com> |
| 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 | |
Viresh Kumar | 4471a34 | 2012-10-26 00:47:42 +0200 | [diff] [blame] | 13 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
| 14 | |
Viresh Kumar | 5ff0a26 | 2013-08-06 22:53:03 +0530 | [diff] [blame] | 15 | #include <linux/cpu.h> |
Viresh Kumar | 4471a34 | 2012-10-26 00:47:42 +0200 | [diff] [blame] | 16 | #include <linux/percpu-defs.h> |
Viresh Kumar | 4d5dcc4 | 2013-03-27 15:58:58 +0000 | [diff] [blame] | 17 | #include <linux/slab.h> |
venkatesh.pallipadi@intel.com | 8080091 | 2008-08-04 11:59:12 -0700 | [diff] [blame] | 18 | #include <linux/tick.h> |
Viresh Kumar | 4471a34 | 2012-10-26 00:47:42 +0200 | [diff] [blame] | 19 | #include "cpufreq_governor.h" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 20 | |
Stratos Karafotis | 06eb09d | 2013-02-08 17:24:18 +0000 | [diff] [blame] | 21 | /* On-demand governor macros */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 22 | #define DEF_FREQUENCY_UP_THRESHOLD (80) |
David C Niemi | 3f78a9f | 2010-10-06 16:54:24 -0400 | [diff] [blame] | 23 | #define DEF_SAMPLING_DOWN_FACTOR (1) |
| 24 | #define MAX_SAMPLING_DOWN_FACTOR (100000) |
venkatesh.pallipadi@intel.com | 8080091 | 2008-08-04 11:59:12 -0700 | [diff] [blame] | 25 | #define MICRO_FREQUENCY_UP_THRESHOLD (95) |
Thomas Renninger | cef9615 | 2009-04-22 13:48:29 +0200 | [diff] [blame] | 26 | #define MICRO_FREQUENCY_MIN_SAMPLE_RATE (10000) |
Dave Jones | c29f140 | 2005-05-31 19:03:50 -0700 | [diff] [blame] | 27 | #define MIN_FREQUENCY_UP_THRESHOLD (11) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 28 | #define MAX_FREQUENCY_UP_THRESHOLD (100) |
| 29 | |
Viresh Kumar | 4471a34 | 2012-10-26 00:47:42 +0200 | [diff] [blame] | 30 | static DEFINE_PER_CPU(struct od_cpu_dbs_info_s, od_cpu_dbs_info); |
Thomas Renninger | 112124a | 2009-02-04 11:55:12 +0100 | [diff] [blame] | 31 | |
Rafael J. Wysocki | a33cce1 | 2016-02-18 02:26:55 +0100 | [diff] [blame] | 32 | static struct dbs_governor od_dbs_gov; |
Jacob Shin | fb30809 | 2013-04-02 09:56:56 -0500 | [diff] [blame] | 33 | static struct od_ops od_ops; |
| 34 | |
Jacob Shin | c283755 | 2013-06-25 22:42:37 +0200 | [diff] [blame] | 35 | static unsigned int default_powersave_bias; |
| 36 | |
Viresh Kumar | 4471a34 | 2012-10-26 00:47:42 +0200 | [diff] [blame] | 37 | /* |
| 38 | * Not all CPUs want IO time to be accounted as busy; this depends on how |
| 39 | * efficient idling at a higher frequency/voltage is. |
| 40 | * Pavel Machek says this is not so for various generations of AMD and old |
| 41 | * Intel systems. |
Stratos Karafotis | 06eb09d | 2013-02-08 17:24:18 +0000 | [diff] [blame] | 42 | * Mike Chan (android.com) claims this is also not true for ARM. |
Viresh Kumar | 4471a34 | 2012-10-26 00:47:42 +0200 | [diff] [blame] | 43 | * Because of this, whitelist specific known (series) of CPUs by default, and |
| 44 | * leave all others up to the user. |
| 45 | */ |
| 46 | static int should_io_be_busy(void) |
| 47 | { |
| 48 | #if defined(CONFIG_X86) |
| 49 | /* |
Stratos Karafotis | 06eb09d | 2013-02-08 17:24:18 +0000 | [diff] [blame] | 50 | * For Intel, Core 2 (model 15) and later have an efficient idle. |
Viresh Kumar | 4471a34 | 2012-10-26 00:47:42 +0200 | [diff] [blame] | 51 | */ |
| 52 | if (boot_cpu_data.x86_vendor == X86_VENDOR_INTEL && |
| 53 | boot_cpu_data.x86 == 6 && |
| 54 | boot_cpu_data.x86_model >= 15) |
| 55 | return 1; |
| 56 | #endif |
| 57 | return 0; |
Arjan van de Ven | 6b8fcd9 | 2010-05-09 08:26:06 -0700 | [diff] [blame] | 58 | } |
| 59 | |
Alexey Starikovskiy | 05ca035 | 2006-07-31 22:28:12 +0400 | [diff] [blame] | 60 | /* |
| 61 | * Find right freq to be set now with powersave_bias on. |
Rafael J. Wysocki | 07aa440 | 2016-02-15 02:22:13 +0100 | [diff] [blame] | 62 | * Returns the freq_hi to be used right now and will set freq_hi_delay_us, |
| 63 | * freq_lo, and freq_lo_delay_us in percpu area for averaging freqs. |
Alexey Starikovskiy | 05ca035 | 2006-07-31 22:28:12 +0400 | [diff] [blame] | 64 | */ |
Jacob Shin | fb30809 | 2013-04-02 09:56:56 -0500 | [diff] [blame] | 65 | static unsigned int generic_powersave_bias_target(struct cpufreq_policy *policy, |
Viresh Kumar | 4471a34 | 2012-10-26 00:47:42 +0200 | [diff] [blame] | 66 | unsigned int freq_next, unsigned int relation) |
Alexey Starikovskiy | 05ca035 | 2006-07-31 22:28:12 +0400 | [diff] [blame] | 67 | { |
| 68 | unsigned int freq_req, freq_reduc, freq_avg; |
| 69 | unsigned int freq_hi, freq_lo; |
| 70 | unsigned int index = 0; |
Rafael J. Wysocki | 07aa440 | 2016-02-15 02:22:13 +0100 | [diff] [blame] | 71 | unsigned int delay_hi_us; |
Viresh Kumar | 4471a34 | 2012-10-26 00:47:42 +0200 | [diff] [blame] | 72 | struct od_cpu_dbs_info_s *dbs_info = &per_cpu(od_cpu_dbs_info, |
Tejun Heo | 245b2e7 | 2009-06-24 15:13:48 +0900 | [diff] [blame] | 73 | policy->cpu); |
Rafael J. Wysocki | bc50547 | 2016-02-07 16:24:26 +0100 | [diff] [blame] | 74 | struct policy_dbs_info *policy_dbs = policy->governor_data; |
| 75 | struct dbs_data *dbs_data = policy_dbs->dbs_data; |
Viresh Kumar | 4d5dcc4 | 2013-03-27 15:58:58 +0000 | [diff] [blame] | 76 | struct od_dbs_tuners *od_tuners = dbs_data->tuners; |
Alexey Starikovskiy | 05ca035 | 2006-07-31 22:28:12 +0400 | [diff] [blame] | 77 | |
| 78 | if (!dbs_info->freq_table) { |
| 79 | dbs_info->freq_lo = 0; |
Rafael J. Wysocki | 07aa440 | 2016-02-15 02:22:13 +0100 | [diff] [blame] | 80 | dbs_info->freq_lo_delay_us = 0; |
Alexey Starikovskiy | 05ca035 | 2006-07-31 22:28:12 +0400 | [diff] [blame] | 81 | return freq_next; |
| 82 | } |
| 83 | |
| 84 | cpufreq_frequency_table_target(policy, dbs_info->freq_table, freq_next, |
| 85 | relation, &index); |
| 86 | freq_req = dbs_info->freq_table[index].frequency; |
Viresh Kumar | 4d5dcc4 | 2013-03-27 15:58:58 +0000 | [diff] [blame] | 87 | freq_reduc = freq_req * od_tuners->powersave_bias / 1000; |
Alexey Starikovskiy | 05ca035 | 2006-07-31 22:28:12 +0400 | [diff] [blame] | 88 | freq_avg = freq_req - freq_reduc; |
| 89 | |
| 90 | /* Find freq bounds for freq_avg in freq_table */ |
| 91 | index = 0; |
| 92 | cpufreq_frequency_table_target(policy, dbs_info->freq_table, freq_avg, |
| 93 | CPUFREQ_RELATION_H, &index); |
| 94 | freq_lo = dbs_info->freq_table[index].frequency; |
| 95 | index = 0; |
| 96 | cpufreq_frequency_table_target(policy, dbs_info->freq_table, freq_avg, |
| 97 | CPUFREQ_RELATION_L, &index); |
| 98 | freq_hi = dbs_info->freq_table[index].frequency; |
| 99 | |
| 100 | /* Find out how long we have to be in hi and lo freqs */ |
| 101 | if (freq_hi == freq_lo) { |
| 102 | dbs_info->freq_lo = 0; |
Rafael J. Wysocki | 07aa440 | 2016-02-15 02:22:13 +0100 | [diff] [blame] | 103 | dbs_info->freq_lo_delay_us = 0; |
Alexey Starikovskiy | 05ca035 | 2006-07-31 22:28:12 +0400 | [diff] [blame] | 104 | return freq_lo; |
| 105 | } |
Rafael J. Wysocki | 07aa440 | 2016-02-15 02:22:13 +0100 | [diff] [blame] | 106 | delay_hi_us = (freq_avg - freq_lo) * dbs_data->sampling_rate; |
| 107 | delay_hi_us += (freq_hi - freq_lo) / 2; |
| 108 | delay_hi_us /= freq_hi - freq_lo; |
| 109 | dbs_info->freq_hi_delay_us = delay_hi_us; |
Alexey Starikovskiy | 05ca035 | 2006-07-31 22:28:12 +0400 | [diff] [blame] | 110 | dbs_info->freq_lo = freq_lo; |
Rafael J. Wysocki | 07aa440 | 2016-02-15 02:22:13 +0100 | [diff] [blame] | 111 | dbs_info->freq_lo_delay_us = dbs_data->sampling_rate - delay_hi_us; |
Alexey Starikovskiy | 05ca035 | 2006-07-31 22:28:12 +0400 | [diff] [blame] | 112 | return freq_hi; |
| 113 | } |
| 114 | |
Rafael J. Wysocki | d1db75f | 2016-02-18 02:28:24 +0100 | [diff] [blame^] | 115 | static void ondemand_powersave_bias_init(struct cpufreq_policy *policy) |
Alexey Starikovskiy | 05ca035 | 2006-07-31 22:28:12 +0400 | [diff] [blame] | 116 | { |
Rafael J. Wysocki | d1db75f | 2016-02-18 02:28:24 +0100 | [diff] [blame^] | 117 | unsigned int cpu = policy->cpu; |
| 118 | struct od_cpu_dbs_info_s *dbs_info = &per_cpu(od_cpu_dbs_info, cpu); |
| 119 | |
| 120 | dbs_info->freq_table = cpufreq_frequency_get_table(cpu); |
| 121 | dbs_info->freq_lo = 0; |
Alexey Starikovskiy | 05ca035 | 2006-07-31 22:28:12 +0400 | [diff] [blame] | 122 | } |
| 123 | |
Viresh Kumar | 3a3e9e0 | 2013-08-06 22:53:05 +0530 | [diff] [blame] | 124 | static void dbs_freq_increase(struct cpufreq_policy *policy, unsigned int freq) |
Viresh Kumar | 4471a34 | 2012-10-26 00:47:42 +0200 | [diff] [blame] | 125 | { |
Rafael J. Wysocki | bc50547 | 2016-02-07 16:24:26 +0100 | [diff] [blame] | 126 | struct policy_dbs_info *policy_dbs = policy->governor_data; |
| 127 | struct dbs_data *dbs_data = policy_dbs->dbs_data; |
Viresh Kumar | 4d5dcc4 | 2013-03-27 15:58:58 +0000 | [diff] [blame] | 128 | struct od_dbs_tuners *od_tuners = dbs_data->tuners; |
| 129 | |
| 130 | if (od_tuners->powersave_bias) |
Viresh Kumar | 3a3e9e0 | 2013-08-06 22:53:05 +0530 | [diff] [blame] | 131 | freq = od_ops.powersave_bias_target(policy, freq, |
Jacob Shin | fb30809 | 2013-04-02 09:56:56 -0500 | [diff] [blame] | 132 | CPUFREQ_RELATION_H); |
Viresh Kumar | 3a3e9e0 | 2013-08-06 22:53:05 +0530 | [diff] [blame] | 133 | else if (policy->cur == policy->max) |
Viresh Kumar | 4471a34 | 2012-10-26 00:47:42 +0200 | [diff] [blame] | 134 | return; |
| 135 | |
Viresh Kumar | 3a3e9e0 | 2013-08-06 22:53:05 +0530 | [diff] [blame] | 136 | __cpufreq_driver_target(policy, freq, od_tuners->powersave_bias ? |
Viresh Kumar | 4471a34 | 2012-10-26 00:47:42 +0200 | [diff] [blame] | 137 | CPUFREQ_RELATION_L : CPUFREQ_RELATION_H); |
| 138 | } |
| 139 | |
| 140 | /* |
| 141 | * Every sampling_rate, we check, if current idle time is less than 20% |
Stratos Karafotis | dfa5bb6 | 2013-06-05 19:01:25 +0300 | [diff] [blame] | 142 | * (default), then we try to increase frequency. Else, we adjust the frequency |
| 143 | * proportional to load. |
Viresh Kumar | 4471a34 | 2012-10-26 00:47:42 +0200 | [diff] [blame] | 144 | */ |
Rafael J. Wysocki | 4cccf75 | 2016-02-15 02:19:31 +0100 | [diff] [blame] | 145 | static void od_update(struct cpufreq_policy *policy) |
Viresh Kumar | 4471a34 | 2012-10-26 00:47:42 +0200 | [diff] [blame] | 146 | { |
Rafael J. Wysocki | 4cccf75 | 2016-02-15 02:19:31 +0100 | [diff] [blame] | 147 | struct od_cpu_dbs_info_s *dbs_info = &per_cpu(od_cpu_dbs_info, policy->cpu); |
Rafael J. Wysocki | bc50547 | 2016-02-07 16:24:26 +0100 | [diff] [blame] | 148 | struct policy_dbs_info *policy_dbs = dbs_info->cdbs.policy_dbs; |
Rafael J. Wysocki | bc50547 | 2016-02-07 16:24:26 +0100 | [diff] [blame] | 149 | struct dbs_data *dbs_data = policy_dbs->dbs_data; |
Viresh Kumar | 4d5dcc4 | 2013-03-27 15:58:58 +0000 | [diff] [blame] | 150 | struct od_dbs_tuners *od_tuners = dbs_data->tuners; |
Rafael J. Wysocki | 4cccf75 | 2016-02-15 02:19:31 +0100 | [diff] [blame] | 151 | unsigned int load = dbs_update(policy); |
Viresh Kumar | 4471a34 | 2012-10-26 00:47:42 +0200 | [diff] [blame] | 152 | |
| 153 | dbs_info->freq_lo = 0; |
| 154 | |
| 155 | /* Check for frequency increase */ |
Viresh Kumar | ff4b178 | 2016-02-09 09:01:32 +0530 | [diff] [blame] | 156 | if (load > dbs_data->up_threshold) { |
Viresh Kumar | 4471a34 | 2012-10-26 00:47:42 +0200 | [diff] [blame] | 157 | /* If switching to max speed, apply sampling_down_factor */ |
| 158 | if (policy->cur < policy->max) |
Rafael J. Wysocki | 57dc3bc | 2016-02-15 02:20:51 +0100 | [diff] [blame] | 159 | policy_dbs->rate_mult = dbs_data->sampling_down_factor; |
Viresh Kumar | 4471a34 | 2012-10-26 00:47:42 +0200 | [diff] [blame] | 160 | dbs_freq_increase(policy, policy->max); |
Stratos Karafotis | dfa5bb6 | 2013-06-05 19:01:25 +0300 | [diff] [blame] | 161 | } else { |
| 162 | /* Calculate the next frequency proportional to load */ |
Stratos Karafotis | 6393d6a | 2014-06-30 19:59:34 +0300 | [diff] [blame] | 163 | unsigned int freq_next, min_f, max_f; |
| 164 | |
| 165 | min_f = policy->cpuinfo.min_freq; |
| 166 | max_f = policy->cpuinfo.max_freq; |
| 167 | freq_next = min_f + load * (max_f - min_f) / 100; |
Viresh Kumar | 4471a34 | 2012-10-26 00:47:42 +0200 | [diff] [blame] | 168 | |
| 169 | /* No longer fully busy, reset rate_mult */ |
Rafael J. Wysocki | 57dc3bc | 2016-02-15 02:20:51 +0100 | [diff] [blame] | 170 | policy_dbs->rate_mult = 1; |
Viresh Kumar | 4471a34 | 2012-10-26 00:47:42 +0200 | [diff] [blame] | 171 | |
Rafael J. Wysocki | a7f35cf | 2016-02-16 21:02:24 +0100 | [diff] [blame] | 172 | if (od_tuners->powersave_bias) |
| 173 | freq_next = od_ops.powersave_bias_target(policy, |
| 174 | freq_next, |
| 175 | CPUFREQ_RELATION_L); |
Jacob Shin | fb30809 | 2013-04-02 09:56:56 -0500 | [diff] [blame] | 176 | |
Stratos Karafotis | 6393d6a | 2014-06-30 19:59:34 +0300 | [diff] [blame] | 177 | __cpufreq_driver_target(policy, freq_next, CPUFREQ_RELATION_C); |
Viresh Kumar | 4471a34 | 2012-10-26 00:47:42 +0200 | [diff] [blame] | 178 | } |
| 179 | } |
| 180 | |
Rafael J. Wysocki | 9be4fd2 | 2016-02-10 16:53:50 +0100 | [diff] [blame] | 181 | static unsigned int od_dbs_timer(struct cpufreq_policy *policy) |
Fabio Baltieri | da53d61 | 2012-12-27 14:55:40 +0000 | [diff] [blame] | 182 | { |
Rafael J. Wysocki | bc50547 | 2016-02-07 16:24:26 +0100 | [diff] [blame] | 183 | struct policy_dbs_info *policy_dbs = policy->governor_data; |
| 184 | struct dbs_data *dbs_data = policy_dbs->dbs_data; |
Rafael J. Wysocki | d10b5eb | 2016-02-06 13:50:24 +0100 | [diff] [blame] | 185 | struct od_cpu_dbs_info_s *dbs_info = &per_cpu(od_cpu_dbs_info, policy->cpu); |
Rafael J. Wysocki | 6e96c5b | 2016-02-15 02:21:35 +0100 | [diff] [blame] | 186 | int sample_type = dbs_info->sample_type; |
Fabio Baltieri | da53d61 | 2012-12-27 14:55:40 +0000 | [diff] [blame] | 187 | |
Viresh Kumar | 4447266 | 2013-01-31 17:28:02 +0000 | [diff] [blame] | 188 | /* Common NORMAL_SAMPLE setup */ |
Viresh Kumar | 43e0ee3 | 2015-07-18 11:31:00 +0530 | [diff] [blame] | 189 | dbs_info->sample_type = OD_NORMAL_SAMPLE; |
Rafael J. Wysocki | 4cccf75 | 2016-02-15 02:19:31 +0100 | [diff] [blame] | 190 | /* |
| 191 | * OD_SUB_SAMPLE doesn't make sense if sample_delay_ns is 0, so ignore |
| 192 | * it then. |
| 193 | */ |
| 194 | if (sample_type == OD_SUB_SAMPLE && policy_dbs->sample_delay_ns > 0) { |
Viresh Kumar | 43e0ee3 | 2015-07-18 11:31:00 +0530 | [diff] [blame] | 195 | __cpufreq_driver_target(policy, dbs_info->freq_lo, |
Viresh Kumar | 42994af | 2015-06-19 17:18:05 +0530 | [diff] [blame] | 196 | CPUFREQ_RELATION_H); |
Rafael J. Wysocki | 07aa440 | 2016-02-15 02:22:13 +0100 | [diff] [blame] | 197 | return dbs_info->freq_lo_delay_us; |
Fabio Baltieri | da53d61 | 2012-12-27 14:55:40 +0000 | [diff] [blame] | 198 | } |
Viresh Kumar | 4447266 | 2013-01-31 17:28:02 +0000 | [diff] [blame] | 199 | |
Rafael J. Wysocki | 6e96c5b | 2016-02-15 02:21:35 +0100 | [diff] [blame] | 200 | od_update(policy); |
| 201 | |
| 202 | if (dbs_info->freq_lo) { |
| 203 | /* Setup timer for SUB_SAMPLE */ |
| 204 | dbs_info->sample_type = OD_SUB_SAMPLE; |
Rafael J. Wysocki | 07aa440 | 2016-02-15 02:22:13 +0100 | [diff] [blame] | 205 | return dbs_info->freq_hi_delay_us; |
Rafael J. Wysocki | 6e96c5b | 2016-02-15 02:21:35 +0100 | [diff] [blame] | 206 | } |
| 207 | |
Rafael J. Wysocki | 07aa440 | 2016-02-15 02:22:13 +0100 | [diff] [blame] | 208 | return dbs_data->sampling_rate * policy_dbs->rate_mult; |
Fabio Baltieri | da53d61 | 2012-12-27 14:55:40 +0000 | [diff] [blame] | 209 | } |
| 210 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 211 | /************************** sysfs interface ************************/ |
Rafael J. Wysocki | 7bdad34 | 2016-02-07 16:05:07 +0100 | [diff] [blame] | 212 | static struct dbs_governor od_dbs_gov; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 213 | |
Viresh Kumar | 4d5dcc4 | 2013-03-27 15:58:58 +0000 | [diff] [blame] | 214 | static ssize_t store_io_is_busy(struct dbs_data *dbs_data, const char *buf, |
| 215 | size_t count) |
Arjan van de Ven | 19379b1 | 2010-05-09 08:26:51 -0700 | [diff] [blame] | 216 | { |
| 217 | unsigned int input; |
| 218 | int ret; |
| 219 | |
| 220 | ret = sscanf(buf, "%u", &input); |
| 221 | if (ret != 1) |
| 222 | return -EINVAL; |
Rafael J. Wysocki | 8847e03 | 2016-02-18 02:20:13 +0100 | [diff] [blame] | 223 | dbs_data->io_is_busy = !!input; |
Stratos Karafotis | 9366d84 | 2013-02-28 16:57:32 +0000 | [diff] [blame] | 224 | |
| 225 | /* we need to re-evaluate prev_cpu_idle */ |
Rafael J. Wysocki | a33cce1 | 2016-02-18 02:26:55 +0100 | [diff] [blame] | 226 | gov_update_cpu_data(&od_dbs_gov, dbs_data); |
| 227 | |
Arjan van de Ven | 19379b1 | 2010-05-09 08:26:51 -0700 | [diff] [blame] | 228 | return count; |
| 229 | } |
| 230 | |
Viresh Kumar | 4d5dcc4 | 2013-03-27 15:58:58 +0000 | [diff] [blame] | 231 | static ssize_t store_up_threshold(struct dbs_data *dbs_data, const char *buf, |
| 232 | size_t count) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 233 | { |
| 234 | unsigned int input; |
| 235 | int ret; |
Venkatesh Pallipadi | ffac80e | 2006-06-28 13:52:18 -0700 | [diff] [blame] | 236 | ret = sscanf(buf, "%u", &input); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 237 | |
Dave Jones | 32ee8c3 | 2006-02-28 00:43:23 -0500 | [diff] [blame] | 238 | if (ret != 1 || input > MAX_FREQUENCY_UP_THRESHOLD || |
Dave Jones | c29f140 | 2005-05-31 19:03:50 -0700 | [diff] [blame] | 239 | input < MIN_FREQUENCY_UP_THRESHOLD) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 240 | return -EINVAL; |
| 241 | } |
Stratos Karafotis | 4bd4e42 | 2013-02-06 13:34:00 +0100 | [diff] [blame] | 242 | |
Viresh Kumar | ff4b178 | 2016-02-09 09:01:32 +0530 | [diff] [blame] | 243 | dbs_data->up_threshold = input; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 244 | return count; |
| 245 | } |
| 246 | |
Viresh Kumar | 4d5dcc4 | 2013-03-27 15:58:58 +0000 | [diff] [blame] | 247 | static ssize_t store_sampling_down_factor(struct dbs_data *dbs_data, |
| 248 | const char *buf, size_t count) |
David C Niemi | 3f78a9f | 2010-10-06 16:54:24 -0400 | [diff] [blame] | 249 | { |
Rafael J. Wysocki | 57dc3bc | 2016-02-15 02:20:51 +0100 | [diff] [blame] | 250 | struct policy_dbs_info *policy_dbs; |
| 251 | unsigned int input; |
David C Niemi | 3f78a9f | 2010-10-06 16:54:24 -0400 | [diff] [blame] | 252 | int ret; |
| 253 | ret = sscanf(buf, "%u", &input); |
| 254 | |
| 255 | if (ret != 1 || input > MAX_SAMPLING_DOWN_FACTOR || input < 1) |
| 256 | return -EINVAL; |
Rafael J. Wysocki | 57dc3bc | 2016-02-15 02:20:51 +0100 | [diff] [blame] | 257 | |
Viresh Kumar | ff4b178 | 2016-02-09 09:01:32 +0530 | [diff] [blame] | 258 | dbs_data->sampling_down_factor = input; |
David C Niemi | 3f78a9f | 2010-10-06 16:54:24 -0400 | [diff] [blame] | 259 | |
| 260 | /* Reset down sampling multiplier in case it was active */ |
Rafael J. Wysocki | 57dc3bc | 2016-02-15 02:20:51 +0100 | [diff] [blame] | 261 | list_for_each_entry(policy_dbs, &dbs_data->policy_dbs_list, list) { |
| 262 | /* |
| 263 | * Doing this without locking might lead to using different |
| 264 | * rate_mult values in od_update() and od_dbs_timer(). |
| 265 | */ |
| 266 | mutex_lock(&policy_dbs->timer_mutex); |
| 267 | policy_dbs->rate_mult = 1; |
| 268 | mutex_unlock(&policy_dbs->timer_mutex); |
David C Niemi | 3f78a9f | 2010-10-06 16:54:24 -0400 | [diff] [blame] | 269 | } |
Rafael J. Wysocki | 57dc3bc | 2016-02-15 02:20:51 +0100 | [diff] [blame] | 270 | |
David C Niemi | 3f78a9f | 2010-10-06 16:54:24 -0400 | [diff] [blame] | 271 | return count; |
| 272 | } |
| 273 | |
Viresh Kumar | 6c4640c | 2013-08-05 12:28:02 +0530 | [diff] [blame] | 274 | static ssize_t store_ignore_nice_load(struct dbs_data *dbs_data, |
| 275 | const char *buf, size_t count) |
Dave Jones | 3d5ee9e | 2005-05-31 19:03:47 -0700 | [diff] [blame] | 276 | { |
| 277 | unsigned int input; |
| 278 | int ret; |
| 279 | |
Venkatesh Pallipadi | ffac80e | 2006-06-28 13:52:18 -0700 | [diff] [blame] | 280 | ret = sscanf(buf, "%u", &input); |
Dave Jones | 2b03f89 | 2009-01-18 01:43:44 -0500 | [diff] [blame] | 281 | if (ret != 1) |
Dave Jones | 3d5ee9e | 2005-05-31 19:03:47 -0700 | [diff] [blame] | 282 | return -EINVAL; |
| 283 | |
Dave Jones | 2b03f89 | 2009-01-18 01:43:44 -0500 | [diff] [blame] | 284 | if (input > 1) |
Dave Jones | 3d5ee9e | 2005-05-31 19:03:47 -0700 | [diff] [blame] | 285 | input = 1; |
Dave Jones | 32ee8c3 | 2006-02-28 00:43:23 -0500 | [diff] [blame] | 286 | |
Viresh Kumar | ff4b178 | 2016-02-09 09:01:32 +0530 | [diff] [blame] | 287 | if (input == dbs_data->ignore_nice_load) { /* nothing to do */ |
Dave Jones | 3d5ee9e | 2005-05-31 19:03:47 -0700 | [diff] [blame] | 288 | return count; |
| 289 | } |
Viresh Kumar | ff4b178 | 2016-02-09 09:01:32 +0530 | [diff] [blame] | 290 | dbs_data->ignore_nice_load = input; |
Dave Jones | 3d5ee9e | 2005-05-31 19:03:47 -0700 | [diff] [blame] | 291 | |
Venkatesh Pallipadi | ccb2fe2 | 2006-06-28 13:49:52 -0700 | [diff] [blame] | 292 | /* we need to re-evaluate prev_cpu_idle */ |
Rafael J. Wysocki | a33cce1 | 2016-02-18 02:26:55 +0100 | [diff] [blame] | 293 | gov_update_cpu_data(&od_dbs_gov, dbs_data); |
Venkatesh Pallipadi | 1ca3abd | 2009-01-23 09:25:02 -0500 | [diff] [blame] | 294 | |
Dave Jones | 3d5ee9e | 2005-05-31 19:03:47 -0700 | [diff] [blame] | 295 | return count; |
| 296 | } |
| 297 | |
Viresh Kumar | 4d5dcc4 | 2013-03-27 15:58:58 +0000 | [diff] [blame] | 298 | static ssize_t store_powersave_bias(struct dbs_data *dbs_data, const char *buf, |
| 299 | size_t count) |
Alexey Starikovskiy | 05ca035 | 2006-07-31 22:28:12 +0400 | [diff] [blame] | 300 | { |
Viresh Kumar | 4d5dcc4 | 2013-03-27 15:58:58 +0000 | [diff] [blame] | 301 | struct od_dbs_tuners *od_tuners = dbs_data->tuners; |
Rafael J. Wysocki | d1db75f | 2016-02-18 02:28:24 +0100 | [diff] [blame^] | 302 | struct policy_dbs_info *policy_dbs; |
Alexey Starikovskiy | 05ca035 | 2006-07-31 22:28:12 +0400 | [diff] [blame] | 303 | unsigned int input; |
| 304 | int ret; |
| 305 | ret = sscanf(buf, "%u", &input); |
| 306 | |
| 307 | if (ret != 1) |
| 308 | return -EINVAL; |
| 309 | |
| 310 | if (input > 1000) |
| 311 | input = 1000; |
| 312 | |
Viresh Kumar | 4d5dcc4 | 2013-03-27 15:58:58 +0000 | [diff] [blame] | 313 | od_tuners->powersave_bias = input; |
Rafael J. Wysocki | d1db75f | 2016-02-18 02:28:24 +0100 | [diff] [blame^] | 314 | |
| 315 | list_for_each_entry(policy_dbs, &dbs_data->policy_dbs_list, list) |
| 316 | ondemand_powersave_bias_init(policy_dbs->policy); |
| 317 | |
Alexey Starikovskiy | 05ca035 | 2006-07-31 22:28:12 +0400 | [diff] [blame] | 318 | return count; |
| 319 | } |
| 320 | |
Viresh Kumar | c443563 | 2016-02-09 09:01:33 +0530 | [diff] [blame] | 321 | gov_show_one_common(sampling_rate); |
| 322 | gov_show_one_common(up_threshold); |
| 323 | gov_show_one_common(sampling_down_factor); |
| 324 | gov_show_one_common(ignore_nice_load); |
| 325 | gov_show_one_common(min_sampling_rate); |
Rafael J. Wysocki | 8847e03 | 2016-02-18 02:20:13 +0100 | [diff] [blame] | 326 | gov_show_one_common(io_is_busy); |
Viresh Kumar | c443563 | 2016-02-09 09:01:33 +0530 | [diff] [blame] | 327 | gov_show_one(od, powersave_bias); |
Viresh Kumar | 4471a34 | 2012-10-26 00:47:42 +0200 | [diff] [blame] | 328 | |
Viresh Kumar | c443563 | 2016-02-09 09:01:33 +0530 | [diff] [blame] | 329 | gov_attr_rw(sampling_rate); |
| 330 | gov_attr_rw(io_is_busy); |
| 331 | gov_attr_rw(up_threshold); |
| 332 | gov_attr_rw(sampling_down_factor); |
| 333 | gov_attr_rw(ignore_nice_load); |
| 334 | gov_attr_rw(powersave_bias); |
| 335 | gov_attr_ro(min_sampling_rate); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 336 | |
Viresh Kumar | c443563 | 2016-02-09 09:01:33 +0530 | [diff] [blame] | 337 | static struct attribute *od_attributes[] = { |
| 338 | &min_sampling_rate.attr, |
| 339 | &sampling_rate.attr, |
| 340 | &up_threshold.attr, |
| 341 | &sampling_down_factor.attr, |
| 342 | &ignore_nice_load.attr, |
| 343 | &powersave_bias.attr, |
| 344 | &io_is_busy.attr, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 345 | NULL |
| 346 | }; |
| 347 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 348 | /************************** sysfs end ************************/ |
| 349 | |
Viresh Kumar | 8e0484d | 2015-06-03 15:57:11 +0530 | [diff] [blame] | 350 | static int od_init(struct dbs_data *dbs_data, bool notify) |
Viresh Kumar | 4d5dcc4 | 2013-03-27 15:58:58 +0000 | [diff] [blame] | 351 | { |
| 352 | struct od_dbs_tuners *tuners; |
| 353 | u64 idle_time; |
| 354 | int cpu; |
| 355 | |
Viresh Kumar | d5b73cd | 2013-08-06 22:53:06 +0530 | [diff] [blame] | 356 | tuners = kzalloc(sizeof(*tuners), GFP_KERNEL); |
Viresh Kumar | 4d5dcc4 | 2013-03-27 15:58:58 +0000 | [diff] [blame] | 357 | if (!tuners) { |
| 358 | pr_err("%s: kzalloc failed\n", __func__); |
| 359 | return -ENOMEM; |
| 360 | } |
| 361 | |
| 362 | cpu = get_cpu(); |
| 363 | idle_time = get_cpu_idle_time_us(cpu, NULL); |
| 364 | put_cpu(); |
| 365 | if (idle_time != -1ULL) { |
| 366 | /* Idle micro accounting is supported. Use finer thresholds */ |
Viresh Kumar | ff4b178 | 2016-02-09 09:01:32 +0530 | [diff] [blame] | 367 | dbs_data->up_threshold = MICRO_FREQUENCY_UP_THRESHOLD; |
Viresh Kumar | 4d5dcc4 | 2013-03-27 15:58:58 +0000 | [diff] [blame] | 368 | /* |
| 369 | * In nohz/micro accounting case we set the minimum frequency |
| 370 | * not depending on HZ, but fixed (very low). The deferred |
| 371 | * timer might skip some samples if idle/sleeping as needed. |
| 372 | */ |
| 373 | dbs_data->min_sampling_rate = MICRO_FREQUENCY_MIN_SAMPLE_RATE; |
| 374 | } else { |
Viresh Kumar | ff4b178 | 2016-02-09 09:01:32 +0530 | [diff] [blame] | 375 | dbs_data->up_threshold = DEF_FREQUENCY_UP_THRESHOLD; |
Viresh Kumar | 4d5dcc4 | 2013-03-27 15:58:58 +0000 | [diff] [blame] | 376 | |
| 377 | /* For correct statistics, we need 10 ticks for each measure */ |
| 378 | dbs_data->min_sampling_rate = MIN_SAMPLING_RATE_RATIO * |
| 379 | jiffies_to_usecs(10); |
| 380 | } |
| 381 | |
Viresh Kumar | ff4b178 | 2016-02-09 09:01:32 +0530 | [diff] [blame] | 382 | dbs_data->sampling_down_factor = DEF_SAMPLING_DOWN_FACTOR; |
| 383 | dbs_data->ignore_nice_load = 0; |
Jacob Shin | c283755 | 2013-06-25 22:42:37 +0200 | [diff] [blame] | 384 | tuners->powersave_bias = default_powersave_bias; |
Rafael J. Wysocki | 8847e03 | 2016-02-18 02:20:13 +0100 | [diff] [blame] | 385 | dbs_data->io_is_busy = should_io_be_busy(); |
Viresh Kumar | 4d5dcc4 | 2013-03-27 15:58:58 +0000 | [diff] [blame] | 386 | |
| 387 | dbs_data->tuners = tuners; |
Viresh Kumar | 4d5dcc4 | 2013-03-27 15:58:58 +0000 | [diff] [blame] | 388 | return 0; |
| 389 | } |
| 390 | |
Viresh Kumar | 8e0484d | 2015-06-03 15:57:11 +0530 | [diff] [blame] | 391 | static void od_exit(struct dbs_data *dbs_data, bool notify) |
Viresh Kumar | 4d5dcc4 | 2013-03-27 15:58:58 +0000 | [diff] [blame] | 392 | { |
| 393 | kfree(dbs_data->tuners); |
| 394 | } |
| 395 | |
Rafael J. Wysocki | 702c9e5 | 2016-02-18 02:21:21 +0100 | [diff] [blame] | 396 | static void od_start(struct cpufreq_policy *policy) |
| 397 | { |
Rafael J. Wysocki | d1db75f | 2016-02-18 02:28:24 +0100 | [diff] [blame^] | 398 | struct od_cpu_dbs_info_s *dbs_info = &per_cpu(od_cpu_dbs_info, policy->cpu); |
Rafael J. Wysocki | 702c9e5 | 2016-02-18 02:21:21 +0100 | [diff] [blame] | 399 | |
| 400 | dbs_info->sample_type = OD_NORMAL_SAMPLE; |
Rafael J. Wysocki | d1db75f | 2016-02-18 02:28:24 +0100 | [diff] [blame^] | 401 | ondemand_powersave_bias_init(policy); |
Rafael J. Wysocki | 702c9e5 | 2016-02-18 02:21:21 +0100 | [diff] [blame] | 402 | } |
| 403 | |
Viresh Kumar | 4471a34 | 2012-10-26 00:47:42 +0200 | [diff] [blame] | 404 | define_get_cpu_dbs_routines(od_cpu_dbs_info); |
Mike Chan | 00e299f | 2010-01-26 17:06:47 -0800 | [diff] [blame] | 405 | |
Viresh Kumar | 4471a34 | 2012-10-26 00:47:42 +0200 | [diff] [blame] | 406 | static struct od_ops od_ops = { |
Jacob Shin | fb30809 | 2013-04-02 09:56:56 -0500 | [diff] [blame] | 407 | .powersave_bias_target = generic_powersave_bias_target, |
Viresh Kumar | 4471a34 | 2012-10-26 00:47:42 +0200 | [diff] [blame] | 408 | }; |
| 409 | |
Rafael J. Wysocki | 7bdad34 | 2016-02-07 16:05:07 +0100 | [diff] [blame] | 410 | static struct dbs_governor od_dbs_gov = { |
Rafael J. Wysocki | af92618 | 2016-02-05 03:16:08 +0100 | [diff] [blame] | 411 | .gov = { |
| 412 | .name = "ondemand", |
Rafael J. Wysocki | 906a6e5 | 2016-02-07 16:07:51 +0100 | [diff] [blame] | 413 | .governor = cpufreq_governor_dbs, |
Rafael J. Wysocki | af92618 | 2016-02-05 03:16:08 +0100 | [diff] [blame] | 414 | .max_transition_latency = TRANSITION_LATENCY_LIMIT, |
| 415 | .owner = THIS_MODULE, |
| 416 | }, |
Viresh Kumar | c443563 | 2016-02-09 09:01:33 +0530 | [diff] [blame] | 417 | .kobj_type = { .default_attrs = od_attributes }, |
Viresh Kumar | 4471a34 | 2012-10-26 00:47:42 +0200 | [diff] [blame] | 418 | .get_cpu_cdbs = get_cpu_cdbs, |
Viresh Kumar | 4471a34 | 2012-10-26 00:47:42 +0200 | [diff] [blame] | 419 | .gov_dbs_timer = od_dbs_timer, |
Viresh Kumar | 4d5dcc4 | 2013-03-27 15:58:58 +0000 | [diff] [blame] | 420 | .init = od_init, |
| 421 | .exit = od_exit, |
Rafael J. Wysocki | 702c9e5 | 2016-02-18 02:21:21 +0100 | [diff] [blame] | 422 | .start = od_start, |
Viresh Kumar | 4471a34 | 2012-10-26 00:47:42 +0200 | [diff] [blame] | 423 | }; |
| 424 | |
Rafael J. Wysocki | 7bdad34 | 2016-02-07 16:05:07 +0100 | [diff] [blame] | 425 | #define CPU_FREQ_GOV_ONDEMAND (&od_dbs_gov.gov) |
Rafael J. Wysocki | af92618 | 2016-02-05 03:16:08 +0100 | [diff] [blame] | 426 | |
Jacob Shin | fb30809 | 2013-04-02 09:56:56 -0500 | [diff] [blame] | 427 | static void od_set_powersave_bias(unsigned int powersave_bias) |
| 428 | { |
| 429 | struct cpufreq_policy *policy; |
| 430 | struct dbs_data *dbs_data; |
| 431 | struct od_dbs_tuners *od_tuners; |
| 432 | unsigned int cpu; |
| 433 | cpumask_t done; |
| 434 | |
Jacob Shin | c283755 | 2013-06-25 22:42:37 +0200 | [diff] [blame] | 435 | default_powersave_bias = powersave_bias; |
Jacob Shin | fb30809 | 2013-04-02 09:56:56 -0500 | [diff] [blame] | 436 | cpumask_clear(&done); |
| 437 | |
| 438 | get_online_cpus(); |
| 439 | for_each_online_cpu(cpu) { |
Rafael J. Wysocki | e40e7b2 | 2016-02-10 17:07:44 +0100 | [diff] [blame] | 440 | struct policy_dbs_info *policy_dbs; |
Viresh Kumar | 44152cb | 2015-07-18 11:30:59 +0530 | [diff] [blame] | 441 | |
Jacob Shin | fb30809 | 2013-04-02 09:56:56 -0500 | [diff] [blame] | 442 | if (cpumask_test_cpu(cpu, &done)) |
| 443 | continue; |
| 444 | |
Rafael J. Wysocki | e40e7b2 | 2016-02-10 17:07:44 +0100 | [diff] [blame] | 445 | policy_dbs = per_cpu(od_cpu_dbs_info, cpu).cdbs.policy_dbs; |
| 446 | if (!policy_dbs) |
Jacob Shin | c283755 | 2013-06-25 22:42:37 +0200 | [diff] [blame] | 447 | continue; |
Jacob Shin | fb30809 | 2013-04-02 09:56:56 -0500 | [diff] [blame] | 448 | |
Rafael J. Wysocki | e40e7b2 | 2016-02-10 17:07:44 +0100 | [diff] [blame] | 449 | policy = policy_dbs->policy; |
Jacob Shin | fb30809 | 2013-04-02 09:56:56 -0500 | [diff] [blame] | 450 | cpumask_or(&done, &done, policy->cpus); |
Jacob Shin | c283755 | 2013-06-25 22:42:37 +0200 | [diff] [blame] | 451 | |
Rafael J. Wysocki | af92618 | 2016-02-05 03:16:08 +0100 | [diff] [blame] | 452 | if (policy->governor != CPU_FREQ_GOV_ONDEMAND) |
Jacob Shin | c283755 | 2013-06-25 22:42:37 +0200 | [diff] [blame] | 453 | continue; |
| 454 | |
Rafael J. Wysocki | bc50547 | 2016-02-07 16:24:26 +0100 | [diff] [blame] | 455 | dbs_data = policy_dbs->dbs_data; |
Jacob Shin | c283755 | 2013-06-25 22:42:37 +0200 | [diff] [blame] | 456 | od_tuners = dbs_data->tuners; |
| 457 | od_tuners->powersave_bias = default_powersave_bias; |
Jacob Shin | fb30809 | 2013-04-02 09:56:56 -0500 | [diff] [blame] | 458 | } |
| 459 | put_online_cpus(); |
| 460 | } |
| 461 | |
| 462 | void od_register_powersave_bias_handler(unsigned int (*f) |
| 463 | (struct cpufreq_policy *, unsigned int, unsigned int), |
| 464 | unsigned int powersave_bias) |
| 465 | { |
| 466 | od_ops.powersave_bias_target = f; |
| 467 | od_set_powersave_bias(powersave_bias); |
| 468 | } |
| 469 | EXPORT_SYMBOL_GPL(od_register_powersave_bias_handler); |
| 470 | |
| 471 | void od_unregister_powersave_bias_handler(void) |
| 472 | { |
| 473 | od_ops.powersave_bias_target = generic_powersave_bias_target; |
| 474 | od_set_powersave_bias(0); |
| 475 | } |
| 476 | EXPORT_SYMBOL_GPL(od_unregister_powersave_bias_handler); |
| 477 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 478 | static int __init cpufreq_gov_dbs_init(void) |
| 479 | { |
Rafael J. Wysocki | af92618 | 2016-02-05 03:16:08 +0100 | [diff] [blame] | 480 | return cpufreq_register_governor(CPU_FREQ_GOV_ONDEMAND); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 481 | } |
| 482 | |
| 483 | static void __exit cpufreq_gov_dbs_exit(void) |
| 484 | { |
Rafael J. Wysocki | af92618 | 2016-02-05 03:16:08 +0100 | [diff] [blame] | 485 | cpufreq_unregister_governor(CPU_FREQ_GOV_ONDEMAND); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 486 | } |
| 487 | |
Venkatesh Pallipadi | ffac80e | 2006-06-28 13:52:18 -0700 | [diff] [blame] | 488 | MODULE_AUTHOR("Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>"); |
| 489 | MODULE_AUTHOR("Alexey Starikovskiy <alexey.y.starikovskiy@intel.com>"); |
| 490 | MODULE_DESCRIPTION("'cpufreq_ondemand' - A dynamic cpufreq governor for " |
Dave Jones | 2b03f89 | 2009-01-18 01:43:44 -0500 | [diff] [blame] | 491 | "Low Latency Frequency Transition capable processors"); |
Venkatesh Pallipadi | ffac80e | 2006-06-28 13:52:18 -0700 | [diff] [blame] | 492 | MODULE_LICENSE("GPL"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 493 | |
Johannes Weiner | 6915719 | 2008-01-17 15:21:08 -0800 | [diff] [blame] | 494 | #ifdef CONFIG_CPU_FREQ_DEFAULT_GOV_ONDEMAND |
Rafael J. Wysocki | de1df26 | 2016-02-05 02:37:42 +0100 | [diff] [blame] | 495 | struct cpufreq_governor *cpufreq_default_governor(void) |
| 496 | { |
Rafael J. Wysocki | af92618 | 2016-02-05 03:16:08 +0100 | [diff] [blame] | 497 | return CPU_FREQ_GOV_ONDEMAND; |
Rafael J. Wysocki | de1df26 | 2016-02-05 02:37:42 +0100 | [diff] [blame] | 498 | } |
| 499 | |
Johannes Weiner | 6915719 | 2008-01-17 15:21:08 -0800 | [diff] [blame] | 500 | fs_initcall(cpufreq_gov_dbs_init); |
| 501 | #else |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 502 | module_init(cpufreq_gov_dbs_init); |
Johannes Weiner | 6915719 | 2008-01-17 15:21:08 -0800 | [diff] [blame] | 503 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 504 | module_exit(cpufreq_gov_dbs_exit); |