Blame view
kernel/sched/cpufreq_schedutil.c
14.6 KB
9bdcb44e3 cpufreq: scheduti... |
1 2 3 4 5 6 7 8 9 10 |
/* * CPUFreq governor based on scheduler-provided CPU utilization data. * * Copyright (C) 2016, Intel Corporation * Author: Rafael J. Wysocki <rafael.j.wysocki@intel.com> * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. */ |
60f05e86c cpufreq: scheduti... |
11 |
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
9bdcb44e3 cpufreq: scheduti... |
12 |
#include <linux/cpufreq.h> |
9bdcb44e3 cpufreq: scheduti... |
13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 |
#include <linux/slab.h> #include <trace/events/power.h> #include "sched.h" struct sugov_tunables { struct gov_attr_set attr_set; unsigned int rate_limit_us; }; struct sugov_policy { struct cpufreq_policy *policy; struct sugov_tunables *tunables; struct list_head tunables_hook; raw_spinlock_t update_lock; /* For shared policies */ u64 last_freq_update_time; s64 freq_update_delay_ns; unsigned int next_freq; /* The next fields are only needed if fast switch cannot be used. */ struct irq_work irq_work; struct work_struct work; struct mutex work_lock; bool work_in_progress; bool need_freq_update; }; struct sugov_cpu { struct update_util_data update_util; struct sugov_policy *sg_policy; |
5cbea4698 cpufreq: scheduti... |
46 |
unsigned int cached_raw_freq; |
21ca6d2c5 cpufreq: scheduti... |
47 48 49 |
unsigned long iowait_boost; unsigned long iowait_boost_max; u64 last_update; |
5cbea4698 cpufreq: scheduti... |
50 |
|
9bdcb44e3 cpufreq: scheduti... |
51 52 53 |
/* The fields below are only needed when sharing a policy. */ unsigned long util; unsigned long max; |
58919e83c cpufreq / sched: ... |
54 |
unsigned int flags; |
9bdcb44e3 cpufreq: scheduti... |
55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 |
}; static DEFINE_PER_CPU(struct sugov_cpu, sugov_cpu); /************************ Governor internals ***********************/ static bool sugov_should_update_freq(struct sugov_policy *sg_policy, u64 time) { s64 delta_ns; if (sg_policy->work_in_progress) return false; if (unlikely(sg_policy->need_freq_update)) { sg_policy->need_freq_update = false; /* * This happens when limits change, so forget the previous * next_freq value and force an update. */ sg_policy->next_freq = UINT_MAX; return true; } delta_ns = time - sg_policy->last_freq_update_time; return delta_ns >= sg_policy->freq_update_delay_ns; } static void sugov_update_commit(struct sugov_policy *sg_policy, u64 time, unsigned int next_freq) { struct cpufreq_policy *policy = sg_policy->policy; sg_policy->last_freq_update_time = time; if (policy->fast_switch_enabled) { if (sg_policy->next_freq == next_freq) { trace_cpu_frequency(policy->cur, smp_processor_id()); return; } sg_policy->next_freq = next_freq; next_freq = cpufreq_driver_fast_switch(policy, next_freq); if (next_freq == CPUFREQ_ENTRY_INVALID) return; policy->cur = next_freq; trace_cpu_frequency(next_freq, smp_processor_id()); } else if (sg_policy->next_freq != next_freq) { sg_policy->next_freq = next_freq; sg_policy->work_in_progress = true; irq_work_queue(&sg_policy->irq_work); } } /** * get_next_freq - Compute a new frequency for a given cpufreq policy. |
5cbea4698 cpufreq: scheduti... |
110 |
* @sg_cpu: schedutil cpu object to compute the new frequency for. |
9bdcb44e3 cpufreq: scheduti... |
111 112 113 114 115 116 117 118 119 120 121 122 123 124 |
* @util: Current CPU utilization. * @max: CPU capacity. * * If the utilization is frequency-invariant, choose the new frequency to be * proportional to it, that is * * next_freq = C * max_freq * util / max * * Otherwise, approximate the would-be frequency-invariant utilization by * util_raw * (curr_freq / max_freq) which leads to * * next_freq = C * curr_freq * util_raw / max * * Take C = 1.25 for the frequency tipping point at (util / max) = 0.8. |
5cbea4698 cpufreq: scheduti... |
125 126 127 128 |
* * The lowest driver-supported frequency which is equal or greater than the raw * next_freq (as calculated above) is returned, subject to policy min/max and * cpufreq driver limitations. |
9bdcb44e3 cpufreq: scheduti... |
129 |
*/ |
5cbea4698 cpufreq: scheduti... |
130 131 |
static unsigned int get_next_freq(struct sugov_cpu *sg_cpu, unsigned long util, unsigned long max) |
9bdcb44e3 cpufreq: scheduti... |
132 |
{ |
5cbea4698 cpufreq: scheduti... |
133 134 |
struct sugov_policy *sg_policy = sg_cpu->sg_policy; struct cpufreq_policy *policy = sg_policy->policy; |
9bdcb44e3 cpufreq: scheduti... |
135 136 |
unsigned int freq = arch_scale_freq_invariant() ? policy->cpuinfo.max_freq : policy->cur; |
5cbea4698 cpufreq: scheduti... |
137 138 139 140 141 142 |
freq = (freq + (freq >> 2)) * util / max; if (freq == sg_cpu->cached_raw_freq && sg_policy->next_freq != UINT_MAX) return sg_policy->next_freq; sg_cpu->cached_raw_freq = freq; return cpufreq_driver_resolve_freq(policy, freq); |
9bdcb44e3 cpufreq: scheduti... |
143 |
} |
58919e83c cpufreq / sched: ... |
144 145 146 |
static void sugov_get_util(unsigned long *util, unsigned long *max) { struct rq *rq = this_rq(); |
8314bc83f cpufreq / sched: ... |
147 148 149 |
unsigned long cfs_max; cfs_max = arch_scale_cpu_capacity(NULL, smp_processor_id()); |
58919e83c cpufreq / sched: ... |
150 151 152 153 |
*util = min(rq->cfs.avg.util_avg, cfs_max); *max = cfs_max; } |
21ca6d2c5 cpufreq: scheduti... |
154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 |
static void sugov_set_iowait_boost(struct sugov_cpu *sg_cpu, u64 time, unsigned int flags) { if (flags & SCHED_CPUFREQ_IOWAIT) { sg_cpu->iowait_boost = sg_cpu->iowait_boost_max; } else if (sg_cpu->iowait_boost) { s64 delta_ns = time - sg_cpu->last_update; /* Clear iowait_boost if the CPU apprears to have been idle. */ if (delta_ns > TICK_NSEC) sg_cpu->iowait_boost = 0; } } static void sugov_iowait_boost(struct sugov_cpu *sg_cpu, unsigned long *util, unsigned long *max) { unsigned long boost_util = sg_cpu->iowait_boost; unsigned long boost_max = sg_cpu->iowait_boost_max; if (!boost_util) return; if (*util * boost_max < *max * boost_util) { *util = boost_util; *max = boost_max; } sg_cpu->iowait_boost >>= 1; } |
9bdcb44e3 cpufreq: scheduti... |
183 |
static void sugov_update_single(struct update_util_data *hook, u64 time, |
58919e83c cpufreq / sched: ... |
184 |
unsigned int flags) |
9bdcb44e3 cpufreq: scheduti... |
185 186 187 188 |
{ struct sugov_cpu *sg_cpu = container_of(hook, struct sugov_cpu, update_util); struct sugov_policy *sg_policy = sg_cpu->sg_policy; struct cpufreq_policy *policy = sg_policy->policy; |
58919e83c cpufreq / sched: ... |
189 |
unsigned long util, max; |
9bdcb44e3 cpufreq: scheduti... |
190 |
unsigned int next_f; |
21ca6d2c5 cpufreq: scheduti... |
191 192 |
sugov_set_iowait_boost(sg_cpu, time, flags); sg_cpu->last_update = time; |
9bdcb44e3 cpufreq: scheduti... |
193 194 |
if (!sugov_should_update_freq(sg_policy, time)) return; |
58919e83c cpufreq / sched: ... |
195 196 197 198 |
if (flags & SCHED_CPUFREQ_RT_DL) { next_f = policy->cpuinfo.max_freq; } else { sugov_get_util(&util, &max); |
21ca6d2c5 cpufreq: scheduti... |
199 |
sugov_iowait_boost(sg_cpu, &util, &max); |
58919e83c cpufreq / sched: ... |
200 201 |
next_f = get_next_freq(sg_cpu, util, max); } |
9bdcb44e3 cpufreq: scheduti... |
202 203 |
sugov_update_commit(sg_policy, time, next_f); } |
5cbea4698 cpufreq: scheduti... |
204 |
static unsigned int sugov_next_freq_shared(struct sugov_cpu *sg_cpu, |
58919e83c cpufreq / sched: ... |
205 206 |
unsigned long util, unsigned long max, unsigned int flags) |
9bdcb44e3 cpufreq: scheduti... |
207 |
{ |
5cbea4698 cpufreq: scheduti... |
208 |
struct sugov_policy *sg_policy = sg_cpu->sg_policy; |
9bdcb44e3 cpufreq: scheduti... |
209 210 211 212 |
struct cpufreq_policy *policy = sg_policy->policy; unsigned int max_f = policy->cpuinfo.max_freq; u64 last_freq_update_time = sg_policy->last_freq_update_time; unsigned int j; |
58919e83c cpufreq / sched: ... |
213 |
if (flags & SCHED_CPUFREQ_RT_DL) |
9bdcb44e3 cpufreq: scheduti... |
214 |
return max_f; |
21ca6d2c5 cpufreq: scheduti... |
215 |
sugov_iowait_boost(sg_cpu, &util, &max); |
9bdcb44e3 cpufreq: scheduti... |
216 217 218 219 220 221 222 223 224 225 226 227 228 229 |
for_each_cpu(j, policy->cpus) { struct sugov_cpu *j_sg_cpu; unsigned long j_util, j_max; s64 delta_ns; if (j == smp_processor_id()) continue; j_sg_cpu = &per_cpu(sugov_cpu, j); /* * If the CPU utilization was last updated before the previous * frequency update and the time elapsed between the last update * of the CPU utilization and the last frequency update is long * enough, don't take the CPU into account as it probably is |
21ca6d2c5 cpufreq: scheduti... |
230 |
* idle now (and clear iowait_boost for it). |
9bdcb44e3 cpufreq: scheduti... |
231 232 |
*/ delta_ns = last_freq_update_time - j_sg_cpu->last_update; |
21ca6d2c5 cpufreq: scheduti... |
233 234 |
if (delta_ns > TICK_NSEC) { j_sg_cpu->iowait_boost = 0; |
9bdcb44e3 cpufreq: scheduti... |
235 |
continue; |
21ca6d2c5 cpufreq: scheduti... |
236 |
} |
58919e83c cpufreq / sched: ... |
237 |
if (j_sg_cpu->flags & SCHED_CPUFREQ_RT_DL) |
9bdcb44e3 cpufreq: scheduti... |
238 |
return max_f; |
58919e83c cpufreq / sched: ... |
239 |
j_util = j_sg_cpu->util; |
9bdcb44e3 cpufreq: scheduti... |
240 241 242 243 244 |
j_max = j_sg_cpu->max; if (j_util * max > j_max * util) { util = j_util; max = j_max; } |
21ca6d2c5 cpufreq: scheduti... |
245 246 |
sugov_iowait_boost(j_sg_cpu, &util, &max); |
9bdcb44e3 cpufreq: scheduti... |
247 |
} |
5cbea4698 cpufreq: scheduti... |
248 |
return get_next_freq(sg_cpu, util, max); |
9bdcb44e3 cpufreq: scheduti... |
249 250 251 |
} static void sugov_update_shared(struct update_util_data *hook, u64 time, |
58919e83c cpufreq / sched: ... |
252 |
unsigned int flags) |
9bdcb44e3 cpufreq: scheduti... |
253 254 255 |
{ struct sugov_cpu *sg_cpu = container_of(hook, struct sugov_cpu, update_util); struct sugov_policy *sg_policy = sg_cpu->sg_policy; |
58919e83c cpufreq / sched: ... |
256 |
unsigned long util, max; |
9bdcb44e3 cpufreq: scheduti... |
257 |
unsigned int next_f; |
58919e83c cpufreq / sched: ... |
258 |
sugov_get_util(&util, &max); |
9bdcb44e3 cpufreq: scheduti... |
259 260 261 262 |
raw_spin_lock(&sg_policy->update_lock); sg_cpu->util = util; sg_cpu->max = max; |
58919e83c cpufreq / sched: ... |
263 |
sg_cpu->flags = flags; |
21ca6d2c5 cpufreq: scheduti... |
264 265 |
sugov_set_iowait_boost(sg_cpu, time, flags); |
9bdcb44e3 cpufreq: scheduti... |
266 267 268 |
sg_cpu->last_update = time; if (sugov_should_update_freq(sg_policy, time)) { |
58919e83c cpufreq / sched: ... |
269 |
next_f = sugov_next_freq_shared(sg_cpu, util, max, flags); |
9bdcb44e3 cpufreq: scheduti... |
270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 |
sugov_update_commit(sg_policy, time, next_f); } raw_spin_unlock(&sg_policy->update_lock); } static void sugov_work(struct work_struct *work) { struct sugov_policy *sg_policy = container_of(work, struct sugov_policy, work); mutex_lock(&sg_policy->work_lock); __cpufreq_driver_target(sg_policy->policy, sg_policy->next_freq, CPUFREQ_RELATION_L); mutex_unlock(&sg_policy->work_lock); sg_policy->work_in_progress = false; } static void sugov_irq_work(struct irq_work *irq_work) { struct sugov_policy *sg_policy; sg_policy = container_of(irq_work, struct sugov_policy, irq_work); schedule_work_on(smp_processor_id(), &sg_policy->work); } /************************** sysfs interface ************************/ static struct sugov_tunables *global_tunables; static DEFINE_MUTEX(global_tunables_lock); static inline struct sugov_tunables *to_sugov_tunables(struct gov_attr_set *attr_set) { return container_of(attr_set, struct sugov_tunables, attr_set); } |
ebea2cd2b cpufreq: Move gov... |
305 |
static ssize_t show_rate_limit_us(struct gov_attr_set *attr_set, char *buf) |
9bdcb44e3 cpufreq: scheduti... |
306 307 308 309 310 311 |
{ struct sugov_tunables *tunables = to_sugov_tunables(attr_set); return sprintf(buf, "%u ", tunables->rate_limit_us); } |
ebea2cd2b cpufreq: Move gov... |
312 313 |
static ssize_t store_rate_limit_us(struct gov_attr_set *attr_set, const char *buf, size_t count) |
9bdcb44e3 cpufreq: scheduti... |
314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 |
{ struct sugov_tunables *tunables = to_sugov_tunables(attr_set); struct sugov_policy *sg_policy; unsigned int rate_limit_us; if (kstrtouint(buf, 10, &rate_limit_us)) return -EINVAL; tunables->rate_limit_us = rate_limit_us; list_for_each_entry(sg_policy, &attr_set->policy_list, tunables_hook) sg_policy->freq_update_delay_ns = rate_limit_us * NSEC_PER_USEC; return count; } |
ebea2cd2b cpufreq: Move gov... |
329 |
gov_attr_rw(rate_limit_us); |
9bdcb44e3 cpufreq: scheduti... |
330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 |
static struct attribute *sugov_attributes[] = { &rate_limit_us.attr, NULL }; static struct kobj_type sugov_tunables_ktype = { .default_attrs = sugov_attributes, .sysfs_ops = &governor_sysfs_ops, }; /********************** cpufreq governor interface *********************/ static struct cpufreq_governor schedutil_gov; static struct sugov_policy *sugov_policy_alloc(struct cpufreq_policy *policy) { struct sugov_policy *sg_policy; sg_policy = kzalloc(sizeof(*sg_policy), GFP_KERNEL); if (!sg_policy) return NULL; sg_policy->policy = policy; init_irq_work(&sg_policy->irq_work, sugov_irq_work); INIT_WORK(&sg_policy->work, sugov_work); mutex_init(&sg_policy->work_lock); raw_spin_lock_init(&sg_policy->update_lock); return sg_policy; } static void sugov_policy_free(struct sugov_policy *sg_policy) { mutex_destroy(&sg_policy->work_lock); kfree(sg_policy); } static struct sugov_tunables *sugov_tunables_alloc(struct sugov_policy *sg_policy) { struct sugov_tunables *tunables; tunables = kzalloc(sizeof(*tunables), GFP_KERNEL); if (tunables) { gov_attr_set_init(&tunables->attr_set, &sg_policy->tunables_hook); if (!have_governor_per_policy()) global_tunables = tunables; } return tunables; } static void sugov_tunables_free(struct sugov_tunables *tunables) { if (!have_governor_per_policy()) global_tunables = NULL; kfree(tunables); } static int sugov_init(struct cpufreq_policy *policy) { struct sugov_policy *sg_policy; struct sugov_tunables *tunables; unsigned int lat; int ret = 0; /* State should be equivalent to EXIT */ if (policy->governor_data) return -EBUSY; sg_policy = sugov_policy_alloc(policy); if (!sg_policy) return -ENOMEM; mutex_lock(&global_tunables_lock); if (global_tunables) { if (WARN_ON(have_governor_per_policy())) { ret = -EINVAL; goto free_sg_policy; } policy->governor_data = sg_policy; sg_policy->tunables = global_tunables; gov_attr_set_get(&global_tunables->attr_set, &sg_policy->tunables_hook); goto out; } tunables = sugov_tunables_alloc(sg_policy); if (!tunables) { ret = -ENOMEM; goto free_sg_policy; } tunables->rate_limit_us = LATENCY_MULTIPLIER; lat = policy->cpuinfo.transition_latency / NSEC_PER_USEC; if (lat) tunables->rate_limit_us *= lat; policy->governor_data = sg_policy; sg_policy->tunables = tunables; ret = kobject_init_and_add(&tunables->attr_set.kobj, &sugov_tunables_ktype, get_governor_parent_kobj(policy), "%s", schedutil_gov.name); if (ret) goto fail; out: mutex_unlock(&global_tunables_lock); cpufreq_enable_fast_switch(policy); return 0; fail: policy->governor_data = NULL; sugov_tunables_free(tunables); free_sg_policy: mutex_unlock(&global_tunables_lock); sugov_policy_free(sg_policy); |
60f05e86c cpufreq: scheduti... |
451 452 |
pr_err("initialization failed (error %d) ", ret); |
9bdcb44e3 cpufreq: scheduti... |
453 454 |
return ret; } |
e788892ba cpufreq: governor... |
455 |
static void sugov_exit(struct cpufreq_policy *policy) |
9bdcb44e3 cpufreq: scheduti... |
456 457 458 459 |
{ struct sugov_policy *sg_policy = policy->governor_data; struct sugov_tunables *tunables = sg_policy->tunables; unsigned int count; |
6c9d9c819 cpufreq: Call cpu... |
460 |
cpufreq_disable_fast_switch(policy); |
9bdcb44e3 cpufreq: scheduti... |
461 462 463 464 465 466 467 468 469 470 |
mutex_lock(&global_tunables_lock); count = gov_attr_set_put(&tunables->attr_set, &sg_policy->tunables_hook); policy->governor_data = NULL; if (!count) sugov_tunables_free(tunables); mutex_unlock(&global_tunables_lock); sugov_policy_free(sg_policy); |
9bdcb44e3 cpufreq: scheduti... |
471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 |
} static int sugov_start(struct cpufreq_policy *policy) { struct sugov_policy *sg_policy = policy->governor_data; unsigned int cpu; sg_policy->freq_update_delay_ns = sg_policy->tunables->rate_limit_us * NSEC_PER_USEC; sg_policy->last_freq_update_time = 0; sg_policy->next_freq = UINT_MAX; sg_policy->work_in_progress = false; sg_policy->need_freq_update = false; for_each_cpu(cpu, policy->cpus) { struct sugov_cpu *sg_cpu = &per_cpu(sugov_cpu, cpu); sg_cpu->sg_policy = sg_policy; if (policy_is_shared(policy)) { |
58919e83c cpufreq / sched: ... |
489 |
sg_cpu->util = 0; |
9bdcb44e3 cpufreq: scheduti... |
490 |
sg_cpu->max = 0; |
58919e83c cpufreq / sched: ... |
491 |
sg_cpu->flags = SCHED_CPUFREQ_RT; |
9bdcb44e3 cpufreq: scheduti... |
492 |
sg_cpu->last_update = 0; |
5cbea4698 cpufreq: scheduti... |
493 |
sg_cpu->cached_raw_freq = 0; |
21ca6d2c5 cpufreq: scheduti... |
494 495 |
sg_cpu->iowait_boost = 0; sg_cpu->iowait_boost_max = policy->cpuinfo.max_freq; |
9bdcb44e3 cpufreq: scheduti... |
496 497 498 499 500 501 502 503 504 |
cpufreq_add_update_util_hook(cpu, &sg_cpu->update_util, sugov_update_shared); } else { cpufreq_add_update_util_hook(cpu, &sg_cpu->update_util, sugov_update_single); } } return 0; } |
e788892ba cpufreq: governor... |
505 |
static void sugov_stop(struct cpufreq_policy *policy) |
9bdcb44e3 cpufreq: scheduti... |
506 507 508 509 510 511 512 513 514 515 516 |
{ struct sugov_policy *sg_policy = policy->governor_data; unsigned int cpu; for_each_cpu(cpu, policy->cpus) cpufreq_remove_update_util_hook(cpu); synchronize_sched(); irq_work_sync(&sg_policy->irq_work); cancel_work_sync(&sg_policy->work); |
9bdcb44e3 cpufreq: scheduti... |
517 |
} |
e788892ba cpufreq: governor... |
518 |
static void sugov_limits(struct cpufreq_policy *policy) |
9bdcb44e3 cpufreq: scheduti... |
519 520 521 522 523 |
{ struct sugov_policy *sg_policy = policy->governor_data; if (!policy->fast_switch_enabled) { mutex_lock(&sg_policy->work_lock); |
bf2be2de8 cpufreq: governor... |
524 |
cpufreq_policy_apply_limits(policy); |
9bdcb44e3 cpufreq: scheduti... |
525 526 527 528 |
mutex_unlock(&sg_policy->work_lock); } sg_policy->need_freq_update = true; |
9bdcb44e3 cpufreq: scheduti... |
529 530 531 532 |
} static struct cpufreq_governor schedutil_gov = { .name = "schedutil", |
9bdcb44e3 cpufreq: scheduti... |
533 |
.owner = THIS_MODULE, |
e788892ba cpufreq: governor... |
534 535 536 537 538 |
.init = sugov_init, .exit = sugov_exit, .start = sugov_start, .stop = sugov_stop, .limits = sugov_limits, |
9bdcb44e3 cpufreq: scheduti... |
539 |
}; |
9bdcb44e3 cpufreq: scheduti... |
540 541 542 543 544 |
#ifdef CONFIG_CPU_FREQ_DEFAULT_GOV_SCHEDUTIL struct cpufreq_governor *cpufreq_default_governor(void) { return &schedutil_gov; } |
9bdcb44e3 cpufreq: scheduti... |
545 |
#endif |
58919e83c cpufreq / sched: ... |
546 547 548 549 550 551 |
static int __init sugov_register(void) { return cpufreq_register_governor(&schedutil_gov); } fs_initcall(sugov_register); |