d/freebsd-nq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
416e232cc6
freebsd-nq/sys/kern/kern_cpu.c

1089 lines
29 KiB
C
Raw Normal View History

Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
/*-
sys/kern: adoption of SPDX licensing ID tags. Mainly focus on files that use BSD 2-Clause license, however the tool I was using misidentified many licenses so this was mostly a manual - error prone - task. The Software Package Data Exchange (SPDX) group provides a specification to make it easier for automated tools to detect and summarize well known opensource licenses. We are gradually adopting the specification, noting that the tags are considered only advisory and do not, in any way, superceed or replace the license texts.
2017-11-27 15:20:12 +00:00
* SPDX-License-Identifier: BSD-2-Clause-FreeBSD
*
Add an interface for drivers to be notified of changes to CPU frequency. cpufreq_pre_change is called before the change, giving each driver a chance to revoke the change. cpufreq_post_change provides the results of the change (success or failure). cpufreq_levels_changed gives the unit number of the cpufreq device whose number of available levels has changed. Hook in all the drivers I could find that needed it. * TSC: update TSC frequency value. When the available levels change, take the highest possible level and notify the timecounter set_cputicker() of that freq. This gets rid of the "calcru: runtime went backwards" messages. * identcpu: updates the sysctl hw.clockrate value * Profiling: if profiling is active when the clock changes, let the user know the results may be inaccurate. Reviewed by: bde, phk MFC after: 1 month
2007-03-26 18:03:29 +00:00
* Copyright (c) 2004-2007 Nate Lawson (SDG)
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include <sys/param.h>
#include <sys/bus.h>
#include <sys/cpu.h>
#include <sys/eventhandler.h>
#include <sys/kernel.h>
Add locking to handle multiple threads getting/setting frequencies at the same time. We use an sx lock and serialize the cpufreq device's get/set/levels methods.
2005-02-27 01:34:08 +00:00
#include <sys/lock.h>
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
#include <sys/malloc.h>
#include <sys/module.h>
#include <sys/proc.h>
#include <sys/queue.h>
If we're on an SMP kernel and there is more than 1 CPU, reject any attempts to change the freq before the other CPUs are active. The current code always attempts to change all CPUs to match each other, and the requisite sched_bind() call won't work before APs are launched.
2007-10-30 22:18:08 +00:00
#include <sys/sbuf.h>
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
#include <sys/sched.h>
If we're on an SMP kernel and there is more than 1 CPU, reject any attempts to change the freq before the other CPUs are active. The current code always attempts to change all CPUs to match each other, and the requisite sched_bind() call won't work before APs are launched.
2007-10-30 22:18:08 +00:00
#include <sys/smp.h>
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
#include <sys/sysctl.h>
#include <sys/systm.h>
Add locking to handle multiple threads getting/setting frequencies at the same time. We use an sx lock and serialize the cpufreq device's get/set/levels methods.
2005-02-27 01:34:08 +00:00
#include <sys/sx.h>
Set levels on all CPUs and attach a cpufreq device to each one. Sysctl on dev.cpu.0 will affect all of the CPUs together. In the future, independent control will be supported but this is good enough for now. Check that the timecounter isn't TSC before switching (from Colin Percival.)
2005-02-13 17:31:56 +00:00
#include <sys/timetc.h>
Add an interface for drivers to be notified of changes to CPU frequency. cpufreq_pre_change is called before the change, giving each driver a chance to revoke the change. cpufreq_post_change provides the results of the change (success or failure). cpufreq_levels_changed gives the unit number of the cpufreq device whose number of available levels has changed. Hook in all the drivers I could find that needed it. * TSC: update TSC frequency value. When the available levels change, take the highest possible level and notify the timecounter set_cputicker() of that freq. This gets rid of the "calcru: runtime went backwards" messages. * identcpu: updates the sysctl hw.clockrate value * Profiling: if profiling is active when the clock changes, let the user know the results may be inaccurate. Reviewed by: bde, phk MFC after: 1 month
2007-03-26 18:03:29 +00:00
#include <sys/taskqueue.h>
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
#include "cpufreq_if.h"
/*
* Common CPU frequency glue code. Drivers for specific hardware can
* attach this interface to allow users to get/set the CPU frequency.
*/
/*
* Number of levels we can handle. Levels are synthesized from settings
Bump the maximum number of levels to 64 and add warning messages about what to do to fix reduced functionality if the number of levels is too low.
2005-02-24 20:21:41 +00:00
* so for M settings and N drivers, there may be M*N levels.
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
*/
Introduce PMCR-based cpufreq(4) driver, for IBM POWER8 and POWER9 systems Summary: POWER8 and POWER9 use a single CPU register, per core, to change clock speed. Everything else is handled by the on-chip controller. This change necessitates a change to the cpufreq global kernel driver to bump supported levels, as the device tree for these systems can have theoretically 256 different options. On my POWER9 Talos, the list consists of 100 items. At 16.67MHz intervals, that allows for a change of roughly 1.67GHz between lowest and highest. This has only been tested on the POWER9. However, since they're similar, this should work on POWER8 as well. Reviewed By: nwhitehorn Differential Revision: https://reviews.freebsd.org/D15932
2018-06-21 14:26:43 +00:00
#define CF_MAX_LEVELS 256
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
make saved cpu level stackable.
2005-10-03 06:57:29 +00:00
struct cf_saved_freq {
struct cf_level level;
int priority;
SLIST_ENTRY(cf_saved_freq) link;
};
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
struct cpufreq_softc {
Add locking to handle multiple threads getting/setting frequencies at the same time. We use an sx lock and serialize the cpufreq device's get/set/levels methods.
2005-02-27 01:34:08 +00:00
struct sx lock;
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
struct cf_level curr_level;
Implement priorities. This allows a driver (say, for cooling purposes) to override the current freq level temporarily and restore it when the higher priority condition is past. Note that only the first overridden value is saved. Callers pass NULL to CPUFREQ_SET to restore the saved level. Priorities are not yet used so this commit should have no effect.
2005-02-14 18:16:35 +00:00
int curr_priority;
make saved cpu level stackable.
2005-10-03 06:57:29 +00:00
SLIST_HEAD(, cf_saved_freq) saved_freq;
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
struct cf_level_lst all_levels;
Implement priorities. This allows a driver (say, for cooling purposes) to override the current freq level temporarily and restore it when the higher priority condition is past. Note that only the first overridden value is saved. Callers pass NULL to CPUFREQ_SET to restore the saved level. Priorities are not yet used so this commit should have no effect.
2005-02-14 18:16:35 +00:00
int all_count;
When dealing with systems with no absolute drivers attached, only calibrate the rate for the 100% state once. Afterwards, use that value for deriving states. This should fix the problem where the calibrated frequency was different once a switch was done, giving a different set of levels each time. Also, properly search for the right cpufreqX device when detaching.
2005-02-15 07:43:48 +00:00
int max_mhz;
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
device_t dev;
struct sysctl_ctx_list sysctl_ctx;
Add an interface for drivers to be notified of changes to CPU frequency. cpufreq_pre_change is called before the change, giving each driver a chance to revoke the change. cpufreq_post_change provides the results of the change (success or failure). cpufreq_levels_changed gives the unit number of the cpufreq device whose number of available levels has changed. Hook in all the drivers I could find that needed it. * TSC: update TSC frequency value. When the available levels change, take the highest possible level and notify the timecounter set_cputicker() of that freq. This gets rid of the "calcru: runtime went backwards" messages. * identcpu: updates the sysctl hw.clockrate value * Profiling: if profiling is active when the clock changes, let the user know the results may be inaccurate. Reviewed by: bde, phk MFC after: 1 month
2007-03-26 18:03:29 +00:00
struct task startup_task;
cpufreq: allocate long-lived buffer for handling of sysctl requests At present the cpufreq sysctl handler for current level setting would allocate and deallocate a temporary buffer of 24KB even to handle a read-only query. This puts unnecessary load on memory subsystem when current level is checked frequently, e.g. when the likes of powerd and system monitoring software are running. Change the strategy to allocating a long-lived buffer for handling the requests. Reviewed by: njl MFC after: 2 weeks
2010-07-23 16:46:42 +00:00
struct cf_level *levels_buf;
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
};
struct cf_setting_array {
struct cf_setting sets[MAX_SETTINGS];
int count;
TAILQ_ENTRY(cf_setting_array) link;
};
TAILQ_HEAD(cf_setting_lst, cf_setting_array);
Add locking to handle multiple threads getting/setting frequencies at the same time. We use an sx lock and serialize the cpufreq device's get/set/levels methods.
2005-02-27 01:34:08 +00:00
#define CF_MTX_INIT(x) sx_init((x), "cpufreq lock")
#define CF_MTX_LOCK(x) sx_xlock((x))
#define CF_MTX_UNLOCK(x) sx_xunlock((x))
#define CF_MTX_ASSERT(x) sx_assert((x), SX_XLOCKED)
Add debugging prints to all the methods in case there are problems with managing levels. This can be enabled with the debug.cpufreq.verbose tunable and sysctl.
2005-04-10 19:11:23 +00:00
#define CF_DEBUG(msg...) do { \
if (cf_verbose) \
printf("cpufreq: " msg); \
} while (0)
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
static int cpufreq_attach(device_t dev);
Add an interface for drivers to be notified of changes to CPU frequency. cpufreq_pre_change is called before the change, giving each driver a chance to revoke the change. cpufreq_post_change provides the results of the change (success or failure). cpufreq_levels_changed gives the unit number of the cpufreq device whose number of available levels has changed. Hook in all the drivers I could find that needed it. * TSC: update TSC frequency value. When the available levels change, take the highest possible level and notify the timecounter set_cputicker() of that freq. This gets rid of the "calcru: runtime went backwards" messages. * identcpu: updates the sysctl hw.clockrate value * Profiling: if profiling is active when the clock changes, let the user know the results may be inaccurate. Reviewed by: bde, phk MFC after: 1 month
2007-03-26 18:03:29 +00:00
static void cpufreq_startup_task(void *ctx, int pending);
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
static int cpufreq_detach(device_t dev);
static int cf_set_method(device_t dev, const struct cf_level *level,
int priority);
static int cf_get_method(device_t dev, struct cf_level *level);
static int cf_levels_method(device_t dev, struct cf_level *levels,
int *count);
Add support for relative cpufreq drivers. Such drivers modulate clock frequency as a percentage of the base rate and do not change the base rate directly. The cpufreq framework combines these with absolute drivers to produce synthesized levels made of one or more settings.
2005-02-06 21:08:35 +00:00
static int cpufreq_insert_abs(struct cpufreq_softc *sc,
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
struct cf_setting *sets, int count);
Add support for relative cpufreq drivers. Such drivers modulate clock frequency as a percentage of the base rate and do not change the base rate directly. The cpufreq framework combines these with absolute drivers to produce synthesized levels made of one or more settings.
2005-02-06 21:08:35 +00:00
static int cpufreq_expand_set(struct cpufreq_softc *sc,
struct cf_setting_array *set_arr);
static struct cf_level *cpufreq_dup_set(struct cpufreq_softc *sc,
struct cf_level *dup, struct cf_setting *set);
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
static int cpufreq_curr_sysctl(SYSCTL_HANDLER_ARGS);
static int cpufreq_levels_sysctl(SYSCTL_HANDLER_ARGS);
Add the "freq_settings" sysctl to each device that registers with cpufreq so their individual settings can be seen separately for debugging.
2005-02-20 00:59:15 +00:00
static int cpufreq_settings_sysctl(SYSCTL_HANDLER_ARGS);
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
static device_method_t cpufreq_methods[] = {
DEVMETHOD(device_probe, bus_generic_probe),
DEVMETHOD(device_attach, cpufreq_attach),
DEVMETHOD(device_detach, cpufreq_detach),
DEVMETHOD(cpufreq_set, cf_set_method),
DEVMETHOD(cpufreq_get, cf_get_method),
DEVMETHOD(cpufreq_levels, cf_levels_method),
{0, 0}
};
static driver_t cpufreq_driver = {
"cpufreq", cpufreq_methods, sizeof(struct cpufreq_softc)
};
static devclass_t cpufreq_dc;
DRIVER_MODULE(cpufreq, cpu, cpufreq_driver, cpufreq_dc, 0, 0);
Allow users to reject levels below a given frequency (in MHz) via the debug.cpufreq.lowest tunable and sysctl. Some systems seem to have problems with the lowest frequencies so setting this prevents them from being available or used.
2005-02-26 22:37:49 +00:00
static int cf_lowest_freq;
Add debugging prints to all the methods in case there are problems with managing levels. This can be enabled with the debug.cpufreq.verbose tunable and sysctl.
2005-04-10 19:11:23 +00:00
static int cf_verbose;
Mark all SYSCTL_NODEs static that have no corresponding SYSCTL_DECLs. The SYSCTL_NODE macro defines a list that stores all child-elements of that node. If there's no SYSCTL_DECL macro anywhere else, there's no reason why it shouldn't be static.
2011-11-07 15:43:11 +00:00
static SYSCTL_NODE(_debug, OID_AUTO, cpufreq, CTLFLAG_RD, NULL,
"cpufreq debugging");
Pull in r267961 and r267973 again. Fix for issues reported will follow.
2014-06-28 03:56:17 +00:00
SYSCTL_INT(_debug_cpufreq, OID_AUTO, lowest, CTLFLAG_RWTUN, &cf_lowest_freq, 1,
Allow users to reject levels below a given frequency (in MHz) via the debug.cpufreq.lowest tunable and sysctl. Some systems seem to have problems with the lowest frequencies so setting this prevents them from being available or used.
2005-02-26 22:37:49 +00:00
"Don't provide levels below this frequency.");
Pull in r267961 and r267973 again. Fix for issues reported will follow.
2014-06-28 03:56:17 +00:00
SYSCTL_INT(_debug_cpufreq, OID_AUTO, verbose, CTLFLAG_RWTUN, &cf_verbose, 1,
Add debugging prints to all the methods in case there are problems with managing levels. This can be enabled with the debug.cpufreq.verbose tunable and sysctl.
2005-04-10 19:11:23 +00:00
"Print verbose debugging messages");
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
static int
cpufreq_attach(device_t dev)
{
struct cpufreq_softc *sc;
If possible, try to obtain max_mhz on cpufreq attach instead of first request. On HyperThreading CPUs logical cores have same frequency, so setting it on any core will change the other's one. In most cases first request to the second core will be the "set" request, done after setting frequency of the first core. In such case second CPU will obtain throttled frequency of the first core as it's max_mhz making cpufreq broken due to different frequency sets.
2008-12-16 01:24:05 +00:00
struct pcpu *pc;
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
device_t parent;
If possible, try to obtain max_mhz on cpufreq attach instead of first request. On HyperThreading CPUs logical cores have same frequency, so setting it on any core will change the other's one. In most cases first request to the second core will be the "set" request, done after setting frequency of the first core. In such case second CPU will obtain throttled frequency of the first core as it's max_mhz making cpufreq broken due to different frequency sets.
2008-12-16 01:24:05 +00:00
uint64_t rate;
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
int numdevs;
Add debugging prints to all the methods in case there are problems with managing levels. This can be enabled with the debug.cpufreq.verbose tunable and sysctl.
2005-04-10 19:11:23 +00:00
CF_DEBUG("initializing %s\n", device_get_nameunit(dev));
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
sc = device_get_softc(dev);
parent = device_get_parent(dev);
sc->dev = dev;
sysctl_ctx_init(&sc->sysctl_ctx);
TAILQ_INIT(&sc->all_levels);
Add locking to handle multiple threads getting/setting frequencies at the same time. We use an sx lock and serialize the cpufreq device's get/set/levels methods.
2005-02-27 01:34:08 +00:00
CF_MTX_INIT(&sc->lock);
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
sc->curr_level.total_set.freq = CPUFREQ_VAL_UNKNOWN;
make saved cpu level stackable.
2005-10-03 06:57:29 +00:00
SLIST_INIT(&sc->saved_freq);
Provide a new CPU device driver ivar to report the nominal speed of the CPU, if available. This is meant to solve the issue of cpufreq misreporting speeds on CPUs that boot in a reduced power mode and have only relative speed control.
2009-05-31 08:59:15 +00:00
/* Try to get nominal CPU freq to use it as maximum later if needed */
sc->max_mhz = cpu_get_nominal_mhz(dev);
/* If that fails, try to measure the current rate */
if (sc->max_mhz <= 0) {
pc = cpu_get_pcpu(dev);
if (cpu_est_clockrate(pc->pc_cpuid, &rate) == 0)
sc->max_mhz = rate / 1000000;
else
sc->max_mhz = CPUFREQ_VAL_UNKNOWN;
}
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
/*
* Only initialize one set of sysctls for all CPUs. In the future,
* if multiple CPUs can have different settings, we can move these
* sysctls to be under every CPU instead of just the first one.
*/
numdevs = devclass_get_count(cpufreq_dc);
if (numdevs > 1)
return (0);
Add debugging prints to all the methods in case there are problems with managing levels. This can be enabled with the debug.cpufreq.verbose tunable and sysctl.
2005-04-10 19:11:23 +00:00
CF_DEBUG("initializing one-time data for %s\n",
device_get_nameunit(dev));
cpufreq: allocate long-lived buffer for handling of sysctl requests At present the cpufreq sysctl handler for current level setting would allocate and deallocate a temporary buffer of 24KB even to handle a read-only query. This puts unnecessary load on memory subsystem when current level is checked frequently, e.g. when the likes of powerd and system monitoring software are running. Change the strategy to allocating a long-lived buffer for handling the requests. Reviewed by: njl MFC after: 2 weeks
2010-07-23 16:46:42 +00:00
sc->levels_buf = malloc(CF_MAX_LEVELS * sizeof(*sc->levels_buf),
M_DEVBUF, M_WAITOK);
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
SYSCTL_ADD_PROC(&sc->sysctl_ctx,
SYSCTL_CHILDREN(device_get_sysctl_tree(parent)),
OID_AUTO, "freq", CTLTYPE_INT | CTLFLAG_RW, sc, 0,
cpufreq_curr_sysctl, "I", "Current CPU frequency");
SYSCTL_ADD_PROC(&sc->sysctl_ctx,
SYSCTL_CHILDREN(device_get_sysctl_tree(parent)),
OID_AUTO, "freq_levels", CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
cpufreq_levels_sysctl, "A", "CPU frequency levels");
Add an interface for drivers to be notified of changes to CPU frequency. cpufreq_pre_change is called before the change, giving each driver a chance to revoke the change. cpufreq_post_change provides the results of the change (success or failure). cpufreq_levels_changed gives the unit number of the cpufreq device whose number of available levels has changed. Hook in all the drivers I could find that needed it. * TSC: update TSC frequency value. When the available levels change, take the highest possible level and notify the timecounter set_cputicker() of that freq. This gets rid of the "calcru: runtime went backwards" messages. * identcpu: updates the sysctl hw.clockrate value * Profiling: if profiling is active when the clock changes, let the user know the results may be inaccurate. Reviewed by: bde, phk MFC after: 1 month
2007-03-26 18:03:29 +00:00
/*
* Queue a one-shot broadcast that levels have changed.
* It will run once the system has completed booting.
*/
TASK_INIT(&sc->startup_task, 0, cpufreq_startup_task, dev);
taskqueue_enqueue(taskqueue_thread, &sc->startup_task);
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
return (0);
}
Add an interface for drivers to be notified of changes to CPU frequency. cpufreq_pre_change is called before the change, giving each driver a chance to revoke the change. cpufreq_post_change provides the results of the change (success or failure). cpufreq_levels_changed gives the unit number of the cpufreq device whose number of available levels has changed. Hook in all the drivers I could find that needed it. * TSC: update TSC frequency value. When the available levels change, take the highest possible level and notify the timecounter set_cputicker() of that freq. This gets rid of the "calcru: runtime went backwards" messages. * identcpu: updates the sysctl hw.clockrate value * Profiling: if profiling is active when the clock changes, let the user know the results may be inaccurate. Reviewed by: bde, phk MFC after: 1 month
2007-03-26 18:03:29 +00:00
/* Handle any work to be done for all drivers that attached during boot. */
static void
cpufreq_startup_task(void *ctx, int pending)
{
cpufreq_settings_changed((device_t)ctx);
}
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
static int
cpufreq_detach(device_t dev)
{
struct cpufreq_softc *sc;
make saved cpu level stackable.
2005-10-03 06:57:29 +00:00
struct cf_saved_freq *saved_freq;
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
int numdevs;
Add debugging prints to all the methods in case there are problems with managing levels. This can be enabled with the debug.cpufreq.verbose tunable and sysctl.
2005-04-10 19:11:23 +00:00
CF_DEBUG("shutdown %s\n", device_get_nameunit(dev));
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
sc = device_get_softc(dev);
sysctl_ctx_free(&sc->sysctl_ctx);
make saved cpu level stackable.
2005-10-03 06:57:29 +00:00
while ((saved_freq = SLIST_FIRST(&sc->saved_freq)) != NULL) {
SLIST_REMOVE_HEAD(&sc->saved_freq, link);
free(saved_freq, M_TEMP);
}
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
/* Only clean up these resources when the last device is detaching. */
numdevs = devclass_get_count(cpufreq_dc);
Add debugging prints to all the methods in case there are problems with managing levels. This can be enabled with the debug.cpufreq.verbose tunable and sysctl.
2005-04-10 19:11:23 +00:00
if (numdevs == 1) {
CF_DEBUG("final shutdown for %s\n", device_get_nameunit(dev));
cpufreq: allocate long-lived buffer for handling of sysctl requests At present the cpufreq sysctl handler for current level setting would allocate and deallocate a temporary buffer of 24KB even to handle a read-only query. This puts unnecessary load on memory subsystem when current level is checked frequently, e.g. when the likes of powerd and system monitoring software are running. Change the strategy to allocating a long-lived buffer for handling the requests. Reviewed by: njl MFC after: 2 weeks
2010-07-23 16:46:42 +00:00
free(sc->levels_buf, M_DEVBUF);
Add debugging prints to all the methods in case there are problems with managing levels. This can be enabled with the debug.cpufreq.verbose tunable and sysctl.
2005-04-10 19:11:23 +00:00
}
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
return (0);
}
static int
cf_set_method(device_t dev, const struct cf_level *level, int priority)
{
struct cpufreq_softc *sc;
const struct cf_setting *set;
make saved cpu level stackable.
2005-10-03 06:57:29 +00:00
struct cf_saved_freq *saved_freq, *curr_freq;
Set levels on all CPUs and attach a cpufreq device to each one. Sysctl on dev.cpu.0 will affect all of the CPUs together. In the future, independent control will be supported but this is good enough for now. Check that the timecounter isn't TSC before switching (from Colin Percival.)
2005-02-13 17:31:56 +00:00
struct pcpu *pc;
Always call sched_bind(), even if on the CPU in question. It is wrong to check if we're already on that cpu and skip the bind since the thread could be migrated off in the meantime. Suggested by: jeff Approved by: re
2007-08-20 06:28:26 +00:00
int error, i;
Boost thread priority while changing CPU frequency Boost the priority of user-space threads when they set their affinity to a core to adjust its frequency. This avoids a situation where a CPU bound kernel thread with the same affinity is running on a down-clocked core, and will "block" powerd from up-clocking the core until the kernel thread yields. This can lead to poor perfomance, and to things potentially getting stuck on Giant. Reviewed by: kib (imp reviewed earlier version) Sponsored by: Netflix Differential Revision: https://reviews.freebsd.org/D15246
2018-05-07 15:24:03 +00:00
u_char pri;
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
sc = device_get_softc(dev);
Add locking to handle multiple threads getting/setting frequencies at the same time. We use an sx lock and serialize the cpufreq device's get/set/levels methods.
2005-02-27 01:34:08 +00:00
error = 0;
set = NULL;
make saved cpu level stackable.
2005-10-03 06:57:29 +00:00
saved_freq = NULL;
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
Add an interface for drivers to be notified of changes to CPU frequency. cpufreq_pre_change is called before the change, giving each driver a chance to revoke the change. cpufreq_post_change provides the results of the change (success or failure). cpufreq_levels_changed gives the unit number of the cpufreq device whose number of available levels has changed. Hook in all the drivers I could find that needed it. * TSC: update TSC frequency value. When the available levels change, take the highest possible level and notify the timecounter set_cputicker() of that freq. This gets rid of the "calcru: runtime went backwards" messages. * identcpu: updates the sysctl hw.clockrate value * Profiling: if profiling is active when the clock changes, let the user know the results may be inaccurate. Reviewed by: bde, phk MFC after: 1 month
2007-03-26 18:03:29 +00:00
/* We are going to change levels so notify the pre-change handler. */
EVENTHANDLER_INVOKE(cpufreq_pre_change, level, &error);
if (error != 0) {
EVENTHANDLER_INVOKE(cpufreq_post_change, level, error);
return (error);
- Print message about cpufreq and timecounter TSC Approved by: njl MFC after: 1 day
2006-03-03 02:06:04 +00:00
}
Set levels on all CPUs and attach a cpufreq device to each one. Sysctl on dev.cpu.0 will affect all of the CPUs together. In the future, independent control will be supported but this is good enough for now. Check that the timecounter isn't TSC before switching (from Colin Percival.)
2005-02-13 17:31:56 +00:00
make saved cpu level stackable.
2005-10-03 06:57:29 +00:00
CF_MTX_LOCK(&sc->lock);
If we're on an SMP kernel and there is more than 1 CPU, reject any attempts to change the freq before the other CPUs are active. The current code always attempts to change all CPUs to match each other, and the requisite sched_bind() call won't work before APs are launched.
2007-10-30 22:18:08 +00:00
#ifdef SMP
Add an EARLY_AP_STARTUP option to start APs earlier during boot. Currently, Application Processors (non-boot CPUs) are started by MD code at SI_SUB_CPU, but they are kept waiting in a "pen" until SI_SUB_SMP at which point they are released to run kernel threads. SI_SUB_SMP is one of the last SYSINIT levels, so APs don't enter the scheduler and start running threads until fairly late in the boot. This change moves SI_SUB_SMP up to just before software interrupt threads are created allowing the APs to start executing kernel threads much sooner (before any devices are probed). This allows several initialization routines that need to perform initialization on all CPUs to now perform that initialization in one step rather than having to defer the AP initialization to a second SYSINIT run at SI_SUB_SMP. It also permits all CPUs to be available for handling interrupts before any devices are probed. This last feature fixes a problem on with interrupt vector exhaustion. Specifically, in the old model all device interrupts were routed onto the boot CPU during boot. Later after the APs were released at SI_SUB_SMP, interrupts were redistributed across all CPUs. However, several drivers for multiqueue hardware allocate N interrupts per CPU in the system. In a system with many CPUs, just a few drivers doing this could exhaust the available pool of interrupt vectors on the boot CPU as each driver was allocating N * mp_ncpu vectors on the boot CPU. Now, drivers will allocate interrupts on their desired CPUs during boot meaning that only N interrupts are allocated from the boot CPU instead of N * mp_ncpu. Some other bits of code can also be simplified as smp_started is now true much earlier and will now always be true for these bits of code. This removes the need to treat the single-CPU boot environment as a special case. As a transition aid, the new behavior is available under a new kernel option (EARLY_AP_STARTUP). This will allow the option to be turned off if need be during initial testing. I plan to enable this on x86 by default in a followup commit in the next few days and to have all platforms moved over before 11.0. Once the transition is complete, the option will be removed along with the !EARLY_AP_STARTUP code. These changes have only been tested on x86. Other platform maintainers are encouraged to port their architectures over as well. The main things to check for are any uses of smp_started in MD code that can be simplified and SI_SUB_SMP SYSINITs in MD code that can be removed in the EARLY_AP_STARTUP case (e.g. the interrupt shuffling). PR: kern/199321 Reviewed by: markj, gnn, kib Sponsored by: Netflix
2016-05-14 18:22:52 +00:00
#ifdef EARLY_AP_STARTUP
MPASS(mp_ncpus == 1 || smp_started);
#else
If we're on an SMP kernel and there is more than 1 CPU, reject any attempts to change the freq before the other CPUs are active. The current code always attempts to change all CPUs to match each other, and the requisite sched_bind() call won't work before APs are launched.
2007-10-30 22:18:08 +00:00
/*
* If still booting and secondary CPUs not started yet, don't allow
* changing the frequency until they're online. This is because we
* can't switch to them using sched_bind() and thus we'd only be
* switching the main CPU. XXXTODO: Need to think more about how to
* handle having different CPUs at different frequencies.
*/
Retire smp_active. It was racey and caused demonstrated problems with the cpufreq code. Replace its use with smp_started. There's at least one userland tool that still looks at the kern.smp.active sysctl, so preserve it but point it to smp_started as well. Discussed with: peter, jhb MFC after: 3 days Obtained from: Netflix
2014-04-26 20:27:54 +00:00
if (mp_ncpus > 1 && !smp_started) {
If we're on an SMP kernel and there is more than 1 CPU, reject any attempts to change the freq before the other CPUs are active. The current code always attempts to change all CPUs to match each other, and the requisite sched_bind() call won't work before APs are launched.
2007-10-30 22:18:08 +00:00
device_printf(dev, "rejecting change, SMP not started yet\n");
error = ENXIO;
goto out;
}
Add an EARLY_AP_STARTUP option to start APs earlier during boot. Currently, Application Processors (non-boot CPUs) are started by MD code at SI_SUB_CPU, but they are kept waiting in a "pen" until SI_SUB_SMP at which point they are released to run kernel threads. SI_SUB_SMP is one of the last SYSINIT levels, so APs don't enter the scheduler and start running threads until fairly late in the boot. This change moves SI_SUB_SMP up to just before software interrupt threads are created allowing the APs to start executing kernel threads much sooner (before any devices are probed). This allows several initialization routines that need to perform initialization on all CPUs to now perform that initialization in one step rather than having to defer the AP initialization to a second SYSINIT run at SI_SUB_SMP. It also permits all CPUs to be available for handling interrupts before any devices are probed. This last feature fixes a problem on with interrupt vector exhaustion. Specifically, in the old model all device interrupts were routed onto the boot CPU during boot. Later after the APs were released at SI_SUB_SMP, interrupts were redistributed across all CPUs. However, several drivers for multiqueue hardware allocate N interrupts per CPU in the system. In a system with many CPUs, just a few drivers doing this could exhaust the available pool of interrupt vectors on the boot CPU as each driver was allocating N * mp_ncpu vectors on the boot CPU. Now, drivers will allocate interrupts on their desired CPUs during boot meaning that only N interrupts are allocated from the boot CPU instead of N * mp_ncpu. Some other bits of code can also be simplified as smp_started is now true much earlier and will now always be true for these bits of code. This removes the need to treat the single-CPU boot environment as a special case. As a transition aid, the new behavior is available under a new kernel option (EARLY_AP_STARTUP). This will allow the option to be turned off if need be during initial testing. I plan to enable this on x86 by default in a followup commit in the next few days and to have all platforms moved over before 11.0. Once the transition is complete, the option will be removed along with the !EARLY_AP_STARTUP code. These changes have only been tested on x86. Other platform maintainers are encouraged to port their architectures over as well. The main things to check for are any uses of smp_started in MD code that can be simplified and SI_SUB_SMP SYSINITs in MD code that can be removed in the EARLY_AP_STARTUP case (e.g. the interrupt shuffling). PR: kern/199321 Reviewed by: markj, gnn, kib Sponsored by: Netflix
2016-05-14 18:22:52 +00:00
#endif
If we're on an SMP kernel and there is more than 1 CPU, reject any attempts to change the freq before the other CPUs are active. The current code always attempts to change all CPUs to match each other, and the requisite sched_bind() call won't work before APs are launched.
2007-10-30 22:18:08 +00:00
#endif /* SMP */
make saved cpu level stackable.
2005-10-03 06:57:29 +00:00
/*
* If the requested level has a lower priority, don't allow
* the new level right now.
*/
if (priority < sc->curr_priority) {
CF_DEBUG("ignoring, curr prio %d less than %d\n", priority,
sc->curr_priority);
error = EPERM;
goto out;
}
Implement priorities. This allows a driver (say, for cooling purposes) to override the current freq level temporarily and restore it when the higher priority condition is past. Note that only the first overridden value is saved. Callers pass NULL to CPUFREQ_SET to restore the saved level. Priorities are not yet used so this commit should have no effect.
2005-02-14 18:16:35 +00:00
/*
* If the caller didn't specify a level and one is saved, prepare to
* restore the saved level. If none has been saved, return an error.
*/
if (level == NULL) {
make saved cpu level stackable.
2005-10-03 06:57:29 +00:00
saved_freq = SLIST_FIRST(&sc->saved_freq);
if (saved_freq == NULL) {
Add debugging prints to all the methods in case there are problems with managing levels. This can be enabled with the debug.cpufreq.verbose tunable and sysctl.
2005-04-10 19:11:23 +00:00
CF_DEBUG("NULL level, no saved level\n");
Add locking to handle multiple threads getting/setting frequencies at the same time. We use an sx lock and serialize the cpufreq device's get/set/levels methods.
2005-02-27 01:34:08 +00:00
error = ENXIO;
goto out;
}
make saved cpu level stackable.
2005-10-03 06:57:29 +00:00
level = &saved_freq->level;
priority = saved_freq->priority;
CF_DEBUG("restoring saved level, freq %d prio %d\n",
level->total_set.freq, priority);
Add locking to handle multiple threads getting/setting frequencies at the same time. We use an sx lock and serialize the cpufreq device's get/set/levels methods.
2005-02-27 01:34:08 +00:00
}
Implement priorities. This allows a driver (say, for cooling purposes) to override the current freq level temporarily and restore it when the higher priority condition is past. Note that only the first overridden value is saved. Callers pass NULL to CPUFREQ_SET to restore the saved level. Priorities are not yet used so this commit should have no effect.
2005-02-14 18:16:35 +00:00
Allow users to reject levels below a given frequency (in MHz) via the debug.cpufreq.lowest tunable and sysctl. Some systems seem to have problems with the lowest frequencies so setting this prevents them from being available or used.
2005-02-26 22:37:49 +00:00
/* Reject levels that are below our specified threshold. */
The "lowest" sysctl setting makes more sense as the lowest one to use, so discard all levels less than this setting, not less than/equal to. MFC after: 1 day
2005-08-11 18:40:58 +00:00
if (level->total_set.freq < cf_lowest_freq) {
Add debugging prints to all the methods in case there are problems with managing levels. This can be enabled with the debug.cpufreq.verbose tunable and sysctl.
2005-04-10 19:11:23 +00:00
CF_DEBUG("rejecting freq %d, less than %d limit\n",
level->total_set.freq, cf_lowest_freq);
Add locking to handle multiple threads getting/setting frequencies at the same time. We use an sx lock and serialize the cpufreq device's get/set/levels methods.
2005-02-27 01:34:08 +00:00
error = EINVAL;
goto out;
}
Allow users to reject levels below a given frequency (in MHz) via the debug.cpufreq.lowest tunable and sysctl. Some systems seem to have problems with the lowest frequencies so setting this prevents them from being available or used.
2005-02-26 22:37:49 +00:00
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
/* If already at this level, just return. */
Revert r175376 and tune cpufreq(4) frequency comparison logic instead. Instead of using 25MHz equality threshold, look for the nearest value when handling dev.cpu.0.freq sysctl and for exact match when it is expected. ACPI may report extra level with frequency 1MHz above the nominal to control Intel Turbo Boost operation. It is not a bug, but feature: dev.cpu.0.freq_levels: 2934/106000 2933/95000 2800/82000 ... In this case value 2933 means 2.93GHz, but 2934 means 3.2-3.6GHz. I've found that my Core i7-870 based system has Intel Turbo Boost disabled by default and without this change it was absolutely invisible and hard to control. MFC after: 2 weeks
2012-03-10 18:56:16 +00:00
if (sc->curr_level.total_set.freq == level->total_set.freq) {
Add debugging prints to all the methods in case there are problems with managing levels. This can be enabled with the debug.cpufreq.verbose tunable and sysctl.
2005-04-10 19:11:23 +00:00
CF_DEBUG("skipping freq %d, same as current level %d\n",
level->total_set.freq, sc->curr_level.total_set.freq);
- don't forget to save freqency when priority is raised. - nuke redundant variable initialization.
2005-08-18 16:41:25 +00:00
goto skip;
Add debugging prints to all the methods in case there are problems with managing levels. This can be enabled with the debug.cpufreq.verbose tunable and sysctl.
2005-04-10 19:11:23 +00:00
}
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
/* First, set the absolute frequency via its driver. */
set = &level->abs_set;
if (set->dev) {
if (!device_is_attached(set->dev)) {
error = ENXIO;
goto out;
}
Bind to the driver's parent cpu before switching, for both absolute and relative drivers. Remove some extraneous KASSERTs since NULL pointers will be found when they're used right afterwards.
2005-02-15 07:22:42 +00:00
Always call sched_bind(), even if on the CPU in question. It is wrong to check if we're already on that cpu and skip the bind since the thread could be migrated off in the meantime. Suggested by: jeff Approved by: re
2007-08-20 06:28:26 +00:00
/* Bind to the target CPU before switching. */
Bind to the driver's parent cpu before switching, for both absolute and relative drivers. Remove some extraneous KASSERTs since NULL pointers will be found when they're used right afterwards.
2005-02-15 07:22:42 +00:00
pc = cpu_get_pcpu(set->dev);
Always call sched_bind(), even if on the CPU in question. It is wrong to check if we're already on that cpu and skip the bind since the thread could be migrated off in the meantime. Suggested by: jeff Approved by: re
2007-08-20 06:28:26 +00:00
thread_lock(curthread);
Boost thread priority while changing CPU frequency Boost the priority of user-space threads when they set their affinity to a core to adjust its frequency. This avoids a situation where a CPU bound kernel thread with the same affinity is running on a down-clocked core, and will "block" powerd from up-clocking the core until the kernel thread yields. This can lead to poor perfomance, and to things potentially getting stuck on Giant. Reviewed by: kib (imp reviewed earlier version) Sponsored by: Netflix Differential Revision: https://reviews.freebsd.org/D15246
2018-05-07 15:24:03 +00:00
pri = curthread->td_priority;
sched_prio(curthread, PRI_MIN);
Always call sched_bind(), even if on the CPU in question. It is wrong to check if we're already on that cpu and skip the bind since the thread could be migrated off in the meantime. Suggested by: jeff Approved by: re
2007-08-20 06:28:26 +00:00
sched_bind(curthread, pc->pc_cpuid);
thread_unlock(curthread);
Add debugging prints to all the methods in case there are problems with managing levels. This can be enabled with the debug.cpufreq.verbose tunable and sysctl.
2005-04-10 19:11:23 +00:00
CF_DEBUG("setting abs freq %d on %s (cpu %d)\n", set->freq,
device_get_nameunit(set->dev), PCPU_GET(cpuid));
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
error = CPUFREQ_DRV_SET(set->dev, set);
Always call sched_bind(), even if on the CPU in question. It is wrong to check if we're already on that cpu and skip the bind since the thread could be migrated off in the meantime. Suggested by: jeff Approved by: re
2007-08-20 06:28:26 +00:00
thread_lock(curthread);
sched_unbind(curthread);
Boost thread priority while changing CPU frequency Boost the priority of user-space threads when they set their affinity to a core to adjust its frequency. This avoids a situation where a CPU bound kernel thread with the same affinity is running on a down-clocked core, and will "block" powerd from up-clocking the core until the kernel thread yields. This can lead to poor perfomance, and to things potentially getting stuck on Giant. Reviewed by: kib (imp reviewed earlier version) Sponsored by: Netflix Differential Revision: https://reviews.freebsd.org/D15246
2018-05-07 15:24:03 +00:00
sched_prio(curthread, pri);
Always call sched_bind(), even if on the CPU in question. It is wrong to check if we're already on that cpu and skip the bind since the thread could be migrated off in the meantime. Suggested by: jeff Approved by: re
2007-08-20 06:28:26 +00:00
thread_unlock(curthread);
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
if (error) {
goto out;
}
}
Add support for relative cpufreq drivers. Such drivers modulate clock frequency as a percentage of the base rate and do not change the base rate directly. The cpufreq framework combines these with absolute drivers to produce synthesized levels made of one or more settings.
2005-02-06 21:08:35 +00:00
/* Next, set any/all relative frequencies via their drivers. */
for (i = 0; i < level->rel_count; i++) {
set = &level->rel_set[i];
if (!device_is_attached(set->dev)) {
error = ENXIO;
goto out;
}
Bind to the driver's parent cpu before switching, for both absolute and relative drivers. Remove some extraneous KASSERTs since NULL pointers will be found when they're used right afterwards.
2005-02-15 07:22:42 +00:00
Always call sched_bind(), even if on the CPU in question. It is wrong to check if we're already on that cpu and skip the bind since the thread could be migrated off in the meantime. Suggested by: jeff Approved by: re
2007-08-20 06:28:26 +00:00
/* Bind to the target CPU before switching. */
Bind to the driver's parent cpu before switching, for both absolute and relative drivers. Remove some extraneous KASSERTs since NULL pointers will be found when they're used right afterwards.
2005-02-15 07:22:42 +00:00
pc = cpu_get_pcpu(set->dev);
Always call sched_bind(), even if on the CPU in question. It is wrong to check if we're already on that cpu and skip the bind since the thread could be migrated off in the meantime. Suggested by: jeff Approved by: re
2007-08-20 06:28:26 +00:00
thread_lock(curthread);
Boost thread priority while changing CPU frequency Boost the priority of user-space threads when they set their affinity to a core to adjust its frequency. This avoids a situation where a CPU bound kernel thread with the same affinity is running on a down-clocked core, and will "block" powerd from up-clocking the core until the kernel thread yields. This can lead to poor perfomance, and to things potentially getting stuck on Giant. Reviewed by: kib (imp reviewed earlier version) Sponsored by: Netflix Differential Revision: https://reviews.freebsd.org/D15246
2018-05-07 15:24:03 +00:00
pri = curthread->td_priority;
sched_prio(curthread, PRI_MIN);
Always call sched_bind(), even if on the CPU in question. It is wrong to check if we're already on that cpu and skip the bind since the thread could be migrated off in the meantime. Suggested by: jeff Approved by: re
2007-08-20 06:28:26 +00:00
sched_bind(curthread, pc->pc_cpuid);
thread_unlock(curthread);
Add debugging prints to all the methods in case there are problems with managing levels. This can be enabled with the debug.cpufreq.verbose tunable and sysctl.
2005-04-10 19:11:23 +00:00
CF_DEBUG("setting rel freq %d on %s (cpu %d)\n", set->freq,
device_get_nameunit(set->dev), PCPU_GET(cpuid));
Add support for relative cpufreq drivers. Such drivers modulate clock frequency as a percentage of the base rate and do not change the base rate directly. The cpufreq framework combines these with absolute drivers to produce synthesized levels made of one or more settings.
2005-02-06 21:08:35 +00:00
error = CPUFREQ_DRV_SET(set->dev, set);
Always call sched_bind(), even if on the CPU in question. It is wrong to check if we're already on that cpu and skip the bind since the thread could be migrated off in the meantime. Suggested by: jeff Approved by: re
2007-08-20 06:28:26 +00:00
thread_lock(curthread);
sched_unbind(curthread);
Boost thread priority while changing CPU frequency Boost the priority of user-space threads when they set their affinity to a core to adjust its frequency. This avoids a situation where a CPU bound kernel thread with the same affinity is running on a down-clocked core, and will "block" powerd from up-clocking the core until the kernel thread yields. This can lead to poor perfomance, and to things potentially getting stuck on Giant. Reviewed by: kib (imp reviewed earlier version) Sponsored by: Netflix Differential Revision: https://reviews.freebsd.org/D15246
2018-05-07 15:24:03 +00:00
sched_prio(curthread, pri);
Always call sched_bind(), even if on the CPU in question. It is wrong to check if we're already on that cpu and skip the bind since the thread could be migrated off in the meantime. Suggested by: jeff Approved by: re
2007-08-20 06:28:26 +00:00
thread_unlock(curthread);
Add support for relative cpufreq drivers. Such drivers modulate clock frequency as a percentage of the base rate and do not change the base rate directly. The cpufreq framework combines these with absolute drivers to produce synthesized levels made of one or more settings.
2005-02-06 21:08:35 +00:00
if (error) {
/* XXX Back out any successful setting? */
goto out;
}
}
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
- don't forget to save freqency when priority is raised. - nuke redundant variable initialization.
2005-08-18 16:41:25 +00:00
skip:
Implement priorities. This allows a driver (say, for cooling purposes) to override the current freq level temporarily and restore it when the higher priority condition is past. Note that only the first overridden value is saved. Callers pass NULL to CPUFREQ_SET to restore the saved level. Priorities are not yet used so this commit should have no effect.
2005-02-14 18:16:35 +00:00
/*
* Before recording the current level, check if we're going to a
make saved cpu level stackable.
2005-10-03 06:57:29 +00:00
* higher priority. If so, save the previous level and priority.
Implement priorities. This allows a driver (say, for cooling purposes) to override the current freq level temporarily and restore it when the higher priority condition is past. Note that only the first overridden value is saved. Callers pass NULL to CPUFREQ_SET to restore the saved level. Priorities are not yet used so this commit should have no effect.
2005-02-14 18:16:35 +00:00
*/
if (sc->curr_level.total_set.freq != CPUFREQ_VAL_UNKNOWN &&
make saved cpu level stackable.
2005-10-03 06:57:29 +00:00
priority > sc->curr_priority) {
Add debugging prints to all the methods in case there are problems with managing levels. This can be enabled with the debug.cpufreq.verbose tunable and sysctl.
2005-04-10 19:11:23 +00:00
CF_DEBUG("saving level, freq %d prio %d\n",
sc->curr_level.total_set.freq, sc->curr_priority);
make saved cpu level stackable.
2005-10-03 06:57:29 +00:00
curr_freq = malloc(sizeof(*curr_freq), M_TEMP, M_NOWAIT);
if (curr_freq == NULL) {
error = ENOMEM;
goto out;
}
curr_freq->level = sc->curr_level;
curr_freq->priority = sc->curr_priority;
SLIST_INSERT_HEAD(&sc->saved_freq, curr_freq, link);
Implement priorities. This allows a driver (say, for cooling purposes) to override the current freq level temporarily and restore it when the higher priority condition is past. Note that only the first overridden value is saved. Callers pass NULL to CPUFREQ_SET to restore the saved level. Priorities are not yet used so this commit should have no effect.
2005-02-14 18:16:35 +00:00
}
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
sc->curr_level = *level;
Implement priorities. This allows a driver (say, for cooling purposes) to override the current freq level temporarily and restore it when the higher priority condition is past. Note that only the first overridden value is saved. Callers pass NULL to CPUFREQ_SET to restore the saved level. Priorities are not yet used so this commit should have no effect.
2005-02-14 18:16:35 +00:00
sc->curr_priority = priority;
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
make saved cpu level stackable.
2005-10-03 06:57:29 +00:00
/* If we were restoring a saved state, reset it to "unused". */
if (saved_freq != NULL) {
CF_DEBUG("resetting saved level\n");
sc->curr_level.total_set.freq = CPUFREQ_VAL_UNKNOWN;
SLIST_REMOVE_HEAD(&sc->saved_freq, link);
free(saved_freq, M_TEMP);
}
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
out:
Add locking to handle multiple threads getting/setting frequencies at the same time. We use an sx lock and serialize the cpufreq device's get/set/levels methods.
2005-02-27 01:34:08 +00:00
CF_MTX_UNLOCK(&sc->lock);
Add an interface for drivers to be notified of changes to CPU frequency. cpufreq_pre_change is called before the change, giving each driver a chance to revoke the change. cpufreq_post_change provides the results of the change (success or failure). cpufreq_levels_changed gives the unit number of the cpufreq device whose number of available levels has changed. Hook in all the drivers I could find that needed it. * TSC: update TSC frequency value. When the available levels change, take the highest possible level and notify the timecounter set_cputicker() of that freq. This gets rid of the "calcru: runtime went backwards" messages. * identcpu: updates the sysctl hw.clockrate value * Profiling: if profiling is active when the clock changes, let the user know the results may be inaccurate. Reviewed by: bde, phk MFC after: 1 month
2007-03-26 18:03:29 +00:00
/*
* We changed levels (or attempted to) so notify the post-change
* handler of new frequency or error.
*/
EVENTHANDLER_INVOKE(cpufreq_post_change, level, error);
Add locking to handle multiple threads getting/setting frequencies at the same time. We use an sx lock and serialize the cpufreq device's get/set/levels methods.
2005-02-27 01:34:08 +00:00
if (error && set)
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
device_printf(set->dev, "set freq failed, err %d\n", error);
Add an interface for drivers to be notified of changes to CPU frequency. cpufreq_pre_change is called before the change, giving each driver a chance to revoke the change. cpufreq_post_change provides the results of the change (success or failure). cpufreq_levels_changed gives the unit number of the cpufreq device whose number of available levels has changed. Hook in all the drivers I could find that needed it. * TSC: update TSC frequency value. When the available levels change, take the highest possible level and notify the timecounter set_cputicker() of that freq. This gets rid of the "calcru: runtime went backwards" messages. * identcpu: updates the sysctl hw.clockrate value * Profiling: if profiling is active when the clock changes, let the user know the results may be inaccurate. Reviewed by: bde, phk MFC after: 1 month
2007-03-26 18:03:29 +00:00
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
return (error);
}
static int
cf_get_method(device_t dev, struct cf_level *level)
{
struct cpufreq_softc *sc;
struct cf_level *levels;
struct cf_setting *curr_set, set;
struct pcpu *pc;
device_t *devs;
In cf_get_method, when we don't already know what clock speed the CPU is running at, guess the nearest value instead of looking for a value within 25 MHz of the observed frequency. Prior to this change, if a system booted with Intel Turbo Boost enabled, the dev.cpu.0.freq sysctl is nonfunctional, since the ACPI-reported frequency for Turbo Boost states does not match the actual clock frequency (and thus no levels are within 25 MHz of the observed frequency) and the current performance level is read before a new level is set. MFC after: 3 days Relnotes: Bug fix in power management on CPUs with Intel Turbo Boost
2014-05-11 10:32:58 +00:00
int bdiff, count, diff, error, i, n, numdevs;
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
uint64_t rate;
sc = device_get_softc(dev);
Add locking to handle multiple threads getting/setting frequencies at the same time. We use an sx lock and serialize the cpufreq device's get/set/levels methods.
2005-02-27 01:34:08 +00:00
error = 0;
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
levels = NULL;
/* If we already know the current frequency, we're done. */
Add locking to handle multiple threads getting/setting frequencies at the same time. We use an sx lock and serialize the cpufreq device's get/set/levels methods.
2005-02-27 01:34:08 +00:00
CF_MTX_LOCK(&sc->lock);
curr_set = &sc->curr_level.total_set;
Add debugging prints to all the methods in case there are problems with managing levels. This can be enabled with the debug.cpufreq.verbose tunable and sysctl.
2005-04-10 19:11:23 +00:00
if (curr_set->freq != CPUFREQ_VAL_UNKNOWN) {
CF_DEBUG("get returning known freq %d\n", curr_set->freq);
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
goto out;
Add debugging prints to all the methods in case there are problems with managing levels. This can be enabled with the debug.cpufreq.verbose tunable and sysctl.
2005-04-10 19:11:23 +00:00
}
Add locking to handle multiple threads getting/setting frequencies at the same time. We use an sx lock and serialize the cpufreq device's get/set/levels methods.
2005-02-27 01:34:08 +00:00
CF_MTX_UNLOCK(&sc->lock);
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
/*
* We need to figure out the current level. Loop through every
* driver, getting the current setting. Then, attempt to get a best
* match of settings against each level.
*/
count = CF_MAX_LEVELS;
Revert r327828, r327949, r327953, r328016-r328026, r328041: Uses of mallocarray(9). The use of mallocarray(9) has rocketed the required swap to build FreeBSD. This is likely caused by the allocation size attributes which put extra pressure on the compiler. Given that most of these checks are superfluous we have to choose better where to use mallocarray(9). We still have more uses of mallocarray(9) but hopefully this is enough to bring swap usage to a reasonable level. Reported by: wosch PR: 225197
2018-01-21 15:42:36 +00:00
levels = malloc(count * sizeof(*levels), M_TEMP, M_NOWAIT);
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
if (levels == NULL)
return (ENOMEM);
error = CPUFREQ_LEVELS(sc->dev, levels, &count);
Bump the maximum number of levels to 64 and add warning messages about what to do to fix reduced functionality if the number of levels is too low.
2005-02-24 20:21:41 +00:00
if (error) {
if (error == E2BIG)
printf("cpufreq: need to increase CF_MAX_LEVELS\n");
Add locking to handle multiple threads getting/setting frequencies at the same time. We use an sx lock and serialize the cpufreq device's get/set/levels methods.
2005-02-27 01:34:08 +00:00
free(levels, M_TEMP);
return (error);
Bump the maximum number of levels to 64 and add warning messages about what to do to fix reduced functionality if the number of levels is too low.
2005-02-24 20:21:41 +00:00
}
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
error = device_get_children(device_get_parent(dev), &devs, &numdevs);
Add locking to handle multiple threads getting/setting frequencies at the same time. We use an sx lock and serialize the cpufreq device's get/set/levels methods.
2005-02-27 01:34:08 +00:00
if (error) {
free(levels, M_TEMP);
return (error);
}
/*
* Reacquire the lock and search for the given level.
*
* XXX Note: this is not quite right since we really need to go
* through each level and compare both absolute and relative
* settings for each driver in the system before making a match.
* The estimation code below catches this case though.
*/
CF_MTX_LOCK(&sc->lock);
Use a different loop variable for the inner loop. This previous reuse could have caused a hang, but we got lucky with the available multi-CPU states on actual hardware. Submitted by: Bjorn Koenig <bkoenig / alpha-tierchen.de> Approved by: re MFC after: 3 days
2007-08-19 20:34:13 +00:00
for (n = 0; n < numdevs && curr_set->freq == CPUFREQ_VAL_UNKNOWN; n++) {
if (!device_is_attached(devs[n]))
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
continue;
Fix a few edge cases with error handling in cpufreq(4)'s CPUFREQ_GET() method: - If the last of the child cpufreq drivers returns an error while trying to fetch its list of supported frequencies but an earlier driver found the requested frequency, don't return an error to the caller. - If all of the child cpufreq drivers fail and the attempt to match the frequency based on 'cpu_est_clockrate()' fails, return ENXIO rather than returning success and returning a frequency of CPUFREQ_VAL_UNKNOWN. MFC after: 3 days PR: kern/121433 Reported by: Eugene Grosbein eugen ! kuzbass dot ru
2008-05-05 19:13:52 +00:00
if (CPUFREQ_DRV_GET(devs[n], &set) != 0)
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
continue;
for (i = 0; i < count; i++) {
Revert r175376 and tune cpufreq(4) frequency comparison logic instead. Instead of using 25MHz equality threshold, look for the nearest value when handling dev.cpu.0.freq sysctl and for exact match when it is expected. ACPI may report extra level with frequency 1MHz above the nominal to control Intel Turbo Boost operation. It is not a bug, but feature: dev.cpu.0.freq_levels: 2934/106000 2933/95000 2800/82000 ... In this case value 2933 means 2.93GHz, but 2934 means 3.2-3.6GHz. I've found that my Core i7-870 based system has Intel Turbo Boost disabled by default and without this change it was absolutely invisible and hard to control. MFC after: 2 weeks
2012-03-10 18:56:16 +00:00
if (set.freq == levels[i].total_set.freq) {
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
sc->curr_level = levels[i];
break;
}
}
}
free(devs, M_TEMP);
Add debugging prints to all the methods in case there are problems with managing levels. This can be enabled with the debug.cpufreq.verbose tunable and sysctl.
2005-04-10 19:11:23 +00:00
if (curr_set->freq != CPUFREQ_VAL_UNKNOWN) {
CF_DEBUG("get matched freq %d from drivers\n", curr_set->freq);
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
goto out;
Add debugging prints to all the methods in case there are problems with managing levels. This can be enabled with the debug.cpufreq.verbose tunable and sysctl.
2005-04-10 19:11:23 +00:00
}
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
/*
* We couldn't find an exact match, so attempt to estimate and then
* match against a level.
*/
pc = cpu_get_pcpu(dev);
if (pc == NULL) {
error = ENXIO;
goto out;
}
cpu_est_clockrate(pc->pc_cpuid, &rate);
rate /= 1000000;
In cf_get_method, when we don't already know what clock speed the CPU is running at, guess the nearest value instead of looking for a value within 25 MHz of the observed frequency. Prior to this change, if a system booted with Intel Turbo Boost enabled, the dev.cpu.0.freq sysctl is nonfunctional, since the ACPI-reported frequency for Turbo Boost states does not match the actual clock frequency (and thus no levels are within 25 MHz of the observed frequency) and the current performance level is read before a new level is set. MFC after: 3 days Relnotes: Bug fix in power management on CPUs with Intel Turbo Boost
2014-05-11 10:32:58 +00:00
bdiff = 1 << 30;
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
for (i = 0; i < count; i++) {
In cf_get_method, when we don't already know what clock speed the CPU is running at, guess the nearest value instead of looking for a value within 25 MHz of the observed frequency. Prior to this change, if a system booted with Intel Turbo Boost enabled, the dev.cpu.0.freq sysctl is nonfunctional, since the ACPI-reported frequency for Turbo Boost states does not match the actual clock frequency (and thus no levels are within 25 MHz of the observed frequency) and the current performance level is read before a new level is set. MFC after: 3 days Relnotes: Bug fix in power management on CPUs with Intel Turbo Boost
2014-05-11 10:32:58 +00:00
diff = abs(levels[i].total_set.freq - rate);
if (diff < bdiff) {
bdiff = diff;
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
sc->curr_level = levels[i];
}
}
In cf_get_method, when we don't already know what clock speed the CPU is running at, guess the nearest value instead of looking for a value within 25 MHz of the observed frequency. Prior to this change, if a system booted with Intel Turbo Boost enabled, the dev.cpu.0.freq sysctl is nonfunctional, since the ACPI-reported frequency for Turbo Boost states does not match the actual clock frequency (and thus no levels are within 25 MHz of the observed frequency) and the current performance level is read before a new level is set. MFC after: 3 days Relnotes: Bug fix in power management on CPUs with Intel Turbo Boost
2014-05-11 10:32:58 +00:00
CF_DEBUG("get estimated freq %d\n", curr_set->freq);
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
out:
Add locking to handle multiple threads getting/setting frequencies at the same time. We use an sx lock and serialize the cpufreq device's get/set/levels methods.
2005-02-27 01:34:08 +00:00
if (error == 0)
*level = sc->curr_level;
CF_MTX_UNLOCK(&sc->lock);
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
if (levels)
free(levels, M_TEMP);
Add locking to handle multiple threads getting/setting frequencies at the same time. We use an sx lock and serialize the cpufreq device's get/set/levels methods.
2005-02-27 01:34:08 +00:00
return (error);
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
}
static int
cf_levels_method(device_t dev, struct cf_level *levels, int *count)
{
Add support for relative cpufreq drivers. Such drivers modulate clock frequency as a percentage of the base rate and do not change the base rate directly. The cpufreq framework combines these with absolute drivers to produce synthesized levels made of one or more settings.
2005-02-06 21:08:35 +00:00
struct cf_setting_array *set_arr;
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
struct cf_setting_lst rel_sets;
struct cpufreq_softc *sc;
struct cf_level *lev;
struct cf_setting *sets;
struct pcpu *pc;
device_t *devs;
Add support for relative cpufreq drivers. Such drivers modulate clock frequency as a percentage of the base rate and do not change the base rate directly. The cpufreq framework combines these with absolute drivers to produce synthesized levels made of one or more settings.
2005-02-06 21:08:35 +00:00
int error, i, numdevs, set_count, type;
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
uint64_t rate;
if (levels == NULL || count == NULL)
return (EINVAL);
TAILQ_INIT(&rel_sets);
sc = device_get_softc(dev);
error = device_get_children(device_get_parent(dev), &devs, &numdevs);
if (error)
return (error);
sets = malloc(MAX_SETTINGS * sizeof(*sets), M_TEMP, M_NOWAIT);
if (sets == NULL) {
free(devs, M_TEMP);
return (ENOMEM);
}
/* Get settings from all cpufreq drivers. */
Add locking to handle multiple threads getting/setting frequencies at the same time. We use an sx lock and serialize the cpufreq device's get/set/levels methods.
2005-02-27 01:34:08 +00:00
CF_MTX_LOCK(&sc->lock);
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
for (i = 0; i < numdevs; i++) {
Add support for the CPUFREQ_FLAG_INFO_ONLY flag. Devices that report this are not added to the list(s) of available settings. However, other drivers can call the CPUFREQ_DRV_SETTINGS() method on those devices directly to get info about available settings. Update the acpi_perf(4) driver to use this flag in the presence of "functional fixed hardware." Thus, future drivers like Powernow can query acpi_perf for platform info but perform frequency transitions themselves.
2005-02-13 18:49:48 +00:00
/* Skip devices that aren't ready. */
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
if (!device_is_attached(devs[i]))
continue;
Add support for the CPUFREQ_FLAG_INFO_ONLY flag. Devices that report this are not added to the list(s) of available settings. However, other drivers can call the CPUFREQ_DRV_SETTINGS() method on those devices directly to get info about available settings. Update the acpi_perf(4) driver to use this flag in the presence of "functional fixed hardware." Thus, future drivers like Powernow can query acpi_perf for platform info but perform frequency transitions themselves.
2005-02-13 18:49:48 +00:00
/*
* Get settings, skipping drivers that offer no settings or
* provide settings for informational purposes only.
*/
Introduce a new method, cpufreq_drv_type(), that returns the type of the driver. This used to be handled by cpufreq_drv_settings() but it's useful to get the type/flags separately from getting the settings. (For example, you don't have to pass an array of cf_setting just to find the driver type.) Use this new method in our in-tree drivers to detect reliably if acpi_perf is present and owns the hardware. This simplifies logic in drivers as well as fixing a bug introduced in my last commit where too many drivers attached.
2005-02-18 00:23:36 +00:00
error = CPUFREQ_DRV_TYPE(devs[i], &type);
Add debugging prints to all the methods in case there are problems with managing levels. This can be enabled with the debug.cpufreq.verbose tunable and sysctl.
2005-04-10 19:11:23 +00:00
if (error || (type & CPUFREQ_FLAG_INFO_ONLY)) {
if (error == 0) {
CF_DEBUG("skipping info-only driver %s\n",
device_get_nameunit(devs[i]));
}
Introduce a new method, cpufreq_drv_type(), that returns the type of the driver. This used to be handled by cpufreq_drv_settings() but it's useful to get the type/flags separately from getting the settings. (For example, you don't have to pass an array of cf_setting just to find the driver type.) Use this new method in our in-tree drivers to detect reliably if acpi_perf is present and owns the hardware. This simplifies logic in drivers as well as fixing a bug introduced in my last commit where too many drivers attached.
2005-02-18 00:23:36 +00:00
continue;
Add debugging prints to all the methods in case there are problems with managing levels. This can be enabled with the debug.cpufreq.verbose tunable and sysctl.
2005-04-10 19:11:23 +00:00
}
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
set_count = MAX_SETTINGS;
Introduce a new method, cpufreq_drv_type(), that returns the type of the driver. This used to be handled by cpufreq_drv_settings() but it's useful to get the type/flags separately from getting the settings. (For example, you don't have to pass an array of cf_setting just to find the driver type.) Use this new method in our in-tree drivers to detect reliably if acpi_perf is present and owns the hardware. This simplifies logic in drivers as well as fixing a bug introduced in my last commit where too many drivers attached.
2005-02-18 00:23:36 +00:00
error = CPUFREQ_DRV_SETTINGS(devs[i], sets, &set_count);
if (error || set_count == 0)
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
continue;
Add support for relative cpufreq drivers. Such drivers modulate clock frequency as a percentage of the base rate and do not change the base rate directly. The cpufreq framework combines these with absolute drivers to produce synthesized levels made of one or more settings.
2005-02-06 21:08:35 +00:00
Add support for the CPUFREQ_FLAG_INFO_ONLY flag. Devices that report this are not added to the list(s) of available settings. However, other drivers can call the CPUFREQ_DRV_SETTINGS() method on those devices directly to get info about available settings. Update the acpi_perf(4) driver to use this flag in the presence of "functional fixed hardware." Thus, future drivers like Powernow can query acpi_perf for platform info but perform frequency transitions themselves.
2005-02-13 18:49:48 +00:00
/* Add the settings to our absolute/relative lists. */
Set levels on all CPUs and attach a cpufreq device to each one. Sysctl on dev.cpu.0 will affect all of the CPUs together. In the future, independent control will be supported but this is good enough for now. Check that the timecounter isn't TSC before switching (from Colin Percival.)
2005-02-13 17:31:56 +00:00
switch (type & CPUFREQ_TYPE_MASK) {
Add support for relative cpufreq drivers. Such drivers modulate clock frequency as a percentage of the base rate and do not change the base rate directly. The cpufreq framework combines these with absolute drivers to produce synthesized levels made of one or more settings.
2005-02-06 21:08:35 +00:00
case CPUFREQ_TYPE_ABSOLUTE:
error = cpufreq_insert_abs(sc, sets, set_count);
break;
case CPUFREQ_TYPE_RELATIVE:
Add debugging prints to all the methods in case there are problems with managing levels. This can be enabled with the debug.cpufreq.verbose tunable and sysctl.
2005-04-10 19:11:23 +00:00
CF_DEBUG("adding %d relative settings\n", set_count);
Add support for relative cpufreq drivers. Such drivers modulate clock frequency as a percentage of the base rate and do not change the base rate directly. The cpufreq framework combines these with absolute drivers to produce synthesized levels made of one or more settings.
2005-02-06 21:08:35 +00:00
set_arr = malloc(sizeof(*set_arr), M_TEMP, M_NOWAIT);
if (set_arr == NULL) {
error = ENOMEM;
goto out;
}
bcopy(sets, set_arr->sets, set_count * sizeof(*sets));
set_arr->count = set_count;
TAILQ_INSERT_TAIL(&rel_sets, set_arr, link);
break;
default:
error = EINVAL;
}
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
if (error)
goto out;
}
When dealing with systems with no absolute drivers attached, only calibrate the rate for the 100% state once. Afterwards, use that value for deriving states. This should fix the problem where the calibrated frequency was different once a switch was done, giving a different set of levels each time. Also, properly search for the right cpufreqX device when detaching.
2005-02-15 07:43:48 +00:00
/*
* If there are no absolute levels, create a fake one at 100%. We
* then cache the clockrate for later use as our base frequency.
*/
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
if (TAILQ_EMPTY(&sc->all_levels)) {
When dealing with systems with no absolute drivers attached, only calibrate the rate for the 100% state once. Afterwards, use that value for deriving states. This should fix the problem where the calibrated frequency was different once a switch was done, giving a different set of levels each time. Also, properly search for the right cpufreqX device when detaching.
2005-02-15 07:43:48 +00:00
if (sc->max_mhz == CPUFREQ_VAL_UNKNOWN) {
Provide a new CPU device driver ivar to report the nominal speed of the CPU, if available. This is meant to solve the issue of cpufreq misreporting speeds on CPUs that boot in a reduced power mode and have only relative speed control.
2009-05-31 08:59:15 +00:00
sc->max_mhz = cpu_get_nominal_mhz(dev);
/*
* If the CPU can't report a rate for 100%, hope
* the CPU is running at its nominal rate right now,
* and use that instead.
*/
if (sc->max_mhz <= 0) {
pc = cpu_get_pcpu(dev);
cpu_est_clockrate(pc->pc_cpuid, &rate);
sc->max_mhz = rate / 1000000;
}
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
}
When dealing with systems with no absolute drivers attached, only calibrate the rate for the 100% state once. Afterwards, use that value for deriving states. This should fix the problem where the calibrated frequency was different once a switch was done, giving a different set of levels each time. Also, properly search for the right cpufreqX device when detaching.
2005-02-15 07:43:48 +00:00
memset(&sets[0], CPUFREQ_VAL_UNKNOWN, sizeof(*sets));
sets[0].freq = sc->max_mhz;
sets[0].dev = NULL;
Add support for relative cpufreq drivers. Such drivers modulate clock frequency as a percentage of the base rate and do not change the base rate directly. The cpufreq framework combines these with absolute drivers to produce synthesized levels made of one or more settings.
2005-02-06 21:08:35 +00:00
error = cpufreq_insert_abs(sc, sets, 1);
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
if (error)
goto out;
}
Add support for relative cpufreq drivers. Such drivers modulate clock frequency as a percentage of the base rate and do not change the base rate directly. The cpufreq framework combines these with absolute drivers to produce synthesized levels made of one or more settings.
2005-02-06 21:08:35 +00:00
/* Create a combined list of absolute + relative levels. */
TAILQ_FOREACH(set_arr, &rel_sets, link)
cpufreq_expand_set(sc, set_arr);
/* If the caller doesn't have enough space, return the actual count. */
if (sc->all_count > *count) {
*count = sc->all_count;
error = E2BIG;
goto out;
}
/* Finally, output the list of levels. */
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
i = 0;
TAILQ_FOREACH(lev, &sc->all_levels, link) {
Remove duplicate cpufreq levels, i.e. ones that are within 25 Mhz of each other. The first one survives, the rest are removed. So far, it appears only some acpi_perf(4) BIOS tables have these invalid states, but address this in the core to be sure to handle other potential driver data. PR: kern/114722 Tested by: stefan.lambrev / moneybookers.com MFC after: 3 days
2008-01-16 01:05:21 +00:00
Allow users to reject levels below a given frequency (in MHz) via the debug.cpufreq.lowest tunable and sysctl. Some systems seem to have problems with the lowest frequencies so setting this prevents them from being available or used.
2005-02-26 22:37:49 +00:00
/* Skip levels that have a frequency that is too low. */
The "lowest" sysctl setting makes more sense as the lowest one to use, so discard all levels less than this setting, not less than/equal to. MFC after: 1 day
2005-08-11 18:40:58 +00:00
if (lev->total_set.freq < cf_lowest_freq) {
Allow users to reject levels below a given frequency (in MHz) via the debug.cpufreq.lowest tunable and sysctl. Some systems seem to have problems with the lowest frequencies so setting this prevents them from being available or used.
2005-02-26 22:37:49 +00:00
sc->all_count--;
continue;
}
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
levels[i] = *lev;
i++;
}
Add support for relative cpufreq drivers. Such drivers modulate clock frequency as a percentage of the base rate and do not change the base rate directly. The cpufreq framework combines these with absolute drivers to produce synthesized levels made of one or more settings.
2005-02-06 21:08:35 +00:00
*count = sc->all_count;
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
error = 0;
out:
/* Clear all levels since we regenerate them each time. */
while ((lev = TAILQ_FIRST(&sc->all_levels)) != NULL) {
TAILQ_REMOVE(&sc->all_levels, lev, link);
free(lev, M_TEMP);
}
Add locking to handle multiple threads getting/setting frequencies at the same time. We use an sx lock and serialize the cpufreq device's get/set/levels methods.
2005-02-27 01:34:08 +00:00
sc->all_count = 0;
CF_MTX_UNLOCK(&sc->lock);
Add support for relative cpufreq drivers. Such drivers modulate clock frequency as a percentage of the base rate and do not change the base rate directly. The cpufreq framework combines these with absolute drivers to produce synthesized levels made of one or more settings.
2005-02-06 21:08:35 +00:00
while ((set_arr = TAILQ_FIRST(&rel_sets)) != NULL) {
TAILQ_REMOVE(&rel_sets, set_arr, link);
free(set_arr, M_TEMP);
}
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
free(devs, M_TEMP);
free(sets, M_TEMP);
return (error);
}
/*
* Create levels for an array of absolute settings and insert them in
* sorted order in the specified list.
*/
static int
Add support for relative cpufreq drivers. Such drivers modulate clock frequency as a percentage of the base rate and do not change the base rate directly. The cpufreq framework combines these with absolute drivers to produce synthesized levels made of one or more settings.
2005-02-06 21:08:35 +00:00
cpufreq_insert_abs(struct cpufreq_softc *sc, struct cf_setting *sets,
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
int count)
{
Add support for relative cpufreq drivers. Such drivers modulate clock frequency as a percentage of the base rate and do not change the base rate directly. The cpufreq framework combines these with absolute drivers to produce synthesized levels made of one or more settings.
2005-02-06 21:08:35 +00:00
struct cf_level_lst *list;
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
struct cf_level *level, *search;
kern_cpu: When adding abs frequency allow for unordered insertion Keep the list ordered as some code assume that it is but allow for unordered cf_settings sets.
2018-07-19 11:28:14 +00:00
int i, inserted;
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
Add locking to handle multiple threads getting/setting frequencies at the same time. We use an sx lock and serialize the cpufreq device's get/set/levels methods.
2005-02-27 01:34:08 +00:00
CF_MTX_ASSERT(&sc->lock);
Add support for relative cpufreq drivers. Such drivers modulate clock frequency as a percentage of the base rate and do not change the base rate directly. The cpufreq framework combines these with absolute drivers to produce synthesized levels made of one or more settings.
2005-02-06 21:08:35 +00:00
list = &sc->all_levels;
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
for (i = 0; i < count; i++) {
level = malloc(sizeof(*level), M_TEMP, M_NOWAIT | M_ZERO);
if (level == NULL)
return (ENOMEM);
level->abs_set = sets[i];
Add support for relative cpufreq drivers. Such drivers modulate clock frequency as a percentage of the base rate and do not change the base rate directly. The cpufreq framework combines these with absolute drivers to produce synthesized levels made of one or more settings.
2005-02-06 21:08:35 +00:00
level->total_set = sets[i];
level->total_set.dev = NULL;
sc->all_count++;
kern_cpu: When adding abs frequency allow for unordered insertion Keep the list ordered as some code assume that it is but allow for unordered cf_settings sets.
2018-07-19 11:28:14 +00:00
inserted = 0;
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
if (TAILQ_EMPTY(list)) {
Add debugging prints to all the methods in case there are problems with managing levels. This can be enabled with the debug.cpufreq.verbose tunable and sysctl.
2005-04-10 19:11:23 +00:00
CF_DEBUG("adding abs setting %d at head\n",
sets[i].freq);
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
TAILQ_INSERT_HEAD(list, level, link);
continue;
}
kern_cpu: When adding abs frequency allow for unordered insertion Keep the list ordered as some code assume that it is but allow for unordered cf_settings sets.
2018-07-19 11:28:14 +00:00
TAILQ_FOREACH_REVERSE(search, list, cf_level_lst, link)
Add support for relative cpufreq drivers. Such drivers modulate clock frequency as a percentage of the base rate and do not change the base rate directly. The cpufreq framework combines these with absolute drivers to produce synthesized levels made of one or more settings.
2005-02-06 21:08:35 +00:00
if (sets[i].freq <= search->total_set.freq) {
Add debugging prints to all the methods in case there are problems with managing levels. This can be enabled with the debug.cpufreq.verbose tunable and sysctl.
2005-04-10 19:11:23 +00:00
CF_DEBUG("adding abs setting %d after %d\n",
sets[i].freq, search->total_set.freq);
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
TAILQ_INSERT_AFTER(list, search, level, link);
kern_cpu: When adding abs frequency allow for unordered insertion Keep the list ordered as some code assume that it is but allow for unordered cf_settings sets.
2018-07-19 11:28:14 +00:00
inserted = 1;
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
break;
}
kern_cpu: When adding abs frequency allow for unordered insertion Keep the list ordered as some code assume that it is but allow for unordered cf_settings sets.
2018-07-19 11:28:14 +00:00
if (inserted == 0) {
TAILQ_FOREACH(search, list, link)
if (sets[i].freq >= search->total_set.freq) {
CF_DEBUG("adding abs setting %d before %d\n",
sets[i].freq, search->total_set.freq);
TAILQ_INSERT_BEFORE(search, level, link);
break;
}
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
}
}
kern_cpu: When adding abs frequency allow for unordered insertion Keep the list ordered as some code assume that it is but allow for unordered cf_settings sets.
2018-07-19 11:28:14 +00:00
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
return (0);
}
Add support for relative cpufreq drivers. Such drivers modulate clock frequency as a percentage of the base rate and do not change the base rate directly. The cpufreq framework combines these with absolute drivers to produce synthesized levels made of one or more settings.
2005-02-06 21:08:35 +00:00
/*
* Expand a group of relative settings, creating derived levels from them.
*/
static int
cpufreq_expand_set(struct cpufreq_softc *sc, struct cf_setting_array *set_arr)
{
struct cf_level *fill, *search;
struct cf_setting *set;
int i;
Add locking to handle multiple threads getting/setting frequencies at the same time. We use an sx lock and serialize the cpufreq device's get/set/levels methods.
2005-02-27 01:34:08 +00:00
CF_MTX_ASSERT(&sc->lock);
Eliminate cpufreq levels for two cases that are less than optimal: 1. Walk the absolute list in reverse to prefer duplicated levels that have a lower absolute setting, i.e. 800 Mhz/50% is better than 1600 Mhz/25% even though both have the same actual frequency. This also removes the need to check for already-modified levels since by definition, those will be added later in the sorted list. 2. Compare the absolute settings for derived levels and don't use the new level if it's higher. For example, a level of 800 Mhz/75% is preferable to 1600 Mhz/25% even though the latter has a lower total frequency. This work is based on a patch from the submitter but reworked by myself. Submitted by: Tijl Coosemans (tijl/ulyssis.org)
2005-08-30 04:45:32 +00:00
/*
* Walk the set of all existing levels in reverse. This is so we
* create derived states from the lowest absolute settings first
* and discard duplicates created from higher absolute settings.
* For instance, a level of 50 Mhz derived from 100 Mhz + 50% is
* preferable to 200 Mhz + 25% because absolute settings are more
* efficient since they often change the voltage as well.
*/
TAILQ_FOREACH_REVERSE(search, &sc->all_levels, cf_level_lst, link) {
Add support for relative cpufreq drivers. Such drivers modulate clock frequency as a percentage of the base rate and do not change the base rate directly. The cpufreq framework combines these with absolute drivers to produce synthesized levels made of one or more settings.
2005-02-06 21:08:35 +00:00
/* Add each setting to the level, duplicating if necessary. */
for (i = 0; i < set_arr->count; i++) {
set = &set_arr->sets[i];
/*
* If this setting is less than 100%, split the level
* into two and add this setting to the new level.
*/
fill = search;
Eliminate cpufreq levels for two cases that are less than optimal: 1. Walk the absolute list in reverse to prefer duplicated levels that have a lower absolute setting, i.e. 800 Mhz/50% is better than 1600 Mhz/25% even though both have the same actual frequency. This also removes the need to check for already-modified levels since by definition, those will be added later in the sorted list. 2. Compare the absolute settings for derived levels and don't use the new level if it's higher. For example, a level of 800 Mhz/75% is preferable to 1600 Mhz/25% even though the latter has a lower total frequency. This work is based on a patch from the submitter but reworked by myself. Submitted by: Tijl Coosemans (tijl/ulyssis.org)
2005-08-30 04:45:32 +00:00
if (set->freq < 10000) {
Add support for relative cpufreq drivers. Such drivers modulate clock frequency as a percentage of the base rate and do not change the base rate directly. The cpufreq framework combines these with absolute drivers to produce synthesized levels made of one or more settings.
2005-02-06 21:08:35 +00:00
fill = cpufreq_dup_set(sc, search, set);
Eliminate cpufreq levels for two cases that are less than optimal: 1. Walk the absolute list in reverse to prefer duplicated levels that have a lower absolute setting, i.e. 800 Mhz/50% is better than 1600 Mhz/25% even though both have the same actual frequency. This also removes the need to check for already-modified levels since by definition, those will be added later in the sorted list. 2. Compare the absolute settings for derived levels and don't use the new level if it's higher. For example, a level of 800 Mhz/75% is preferable to 1600 Mhz/25% even though the latter has a lower total frequency. This work is based on a patch from the submitter but reworked by myself. Submitted by: Tijl Coosemans (tijl/ulyssis.org)
2005-08-30 04:45:32 +00:00
/*
* The new level was a duplicate of an existing
* level or its absolute setting is too high
* so we freed it. For example, we discard a
* derived level of 1000 MHz/25% if a level
* of 500 MHz/100% already exists.
*/
if (fill == NULL)
break;
}
Add support for relative cpufreq drivers. Such drivers modulate clock frequency as a percentage of the base rate and do not change the base rate directly. The cpufreq framework combines these with absolute drivers to produce synthesized levels made of one or more settings.
2005-02-06 21:08:35 +00:00
/* Add this setting to the existing or new level. */
KASSERT(fill->rel_count < MAX_SETTINGS,
("cpufreq: too many relative drivers (%d)",
MAX_SETTINGS));
fill->rel_set[fill->rel_count] = *set;
fill->rel_count++;
Add debugging prints to all the methods in case there are problems with managing levels. This can be enabled with the debug.cpufreq.verbose tunable and sysctl.
2005-04-10 19:11:23 +00:00
CF_DEBUG(
"expand set added rel setting %d%% to %d level\n",
set->freq / 100, fill->total_set.freq);
Add support for relative cpufreq drivers. Such drivers modulate clock frequency as a percentage of the base rate and do not change the base rate directly. The cpufreq framework combines these with absolute drivers to produce synthesized levels made of one or more settings.
2005-02-06 21:08:35 +00:00
}
}
return (0);
}
static struct cf_level *
cpufreq_dup_set(struct cpufreq_softc *sc, struct cf_level *dup,
struct cf_setting *set)
{
struct cf_level_lst *list;
struct cf_level *fill, *itr;
struct cf_setting *fill_set, *itr_set;
int i;
Add locking to handle multiple threads getting/setting frequencies at the same time. We use an sx lock and serialize the cpufreq device's get/set/levels methods.
2005-02-27 01:34:08 +00:00
CF_MTX_ASSERT(&sc->lock);
Add support for relative cpufreq drivers. Such drivers modulate clock frequency as a percentage of the base rate and do not change the base rate directly. The cpufreq framework combines these with absolute drivers to produce synthesized levels made of one or more settings.
2005-02-06 21:08:35 +00:00
/*
* Create a new level, copy it from the old one, and update the
* total frequency and power by the percentage specified in the
* relative setting.
*/
fill = malloc(sizeof(*fill), M_TEMP, M_NOWAIT);
if (fill == NULL)
return (NULL);
*fill = *dup;
fill_set = &fill->total_set;
fill_set->freq =
((uint64_t)fill_set->freq * set->freq) / 10000;
if (fill_set->power != CPUFREQ_VAL_UNKNOWN) {
fill_set->power = ((uint64_t)fill_set->power * set->freq)
/ 10000;
}
if (set->lat != CPUFREQ_VAL_UNKNOWN) {
if (fill_set->lat != CPUFREQ_VAL_UNKNOWN)
fill_set->lat += set->lat;
else
fill_set->lat = set->lat;
}
Add debugging prints to all the methods in case there are problems with managing levels. This can be enabled with the debug.cpufreq.verbose tunable and sysctl.
2005-04-10 19:11:23 +00:00
CF_DEBUG("dup set considering derived setting %d\n", fill_set->freq);
Add support for relative cpufreq drivers. Such drivers modulate clock frequency as a percentage of the base rate and do not change the base rate directly. The cpufreq framework combines these with absolute drivers to produce synthesized levels made of one or more settings.
2005-02-06 21:08:35 +00:00
/*
* If we copied an old level that we already modified (say, at 100%),
* we need to remove that setting before adding this one. Since we
* process each setting array in order, we know any settings for this
* driver will be found at the end.
*/
for (i = fill->rel_count; i != 0; i--) {
if (fill->rel_set[i - 1].dev != set->dev)
break;
Add debugging prints to all the methods in case there are problems with managing levels. This can be enabled with the debug.cpufreq.verbose tunable and sysctl.
2005-04-10 19:11:23 +00:00
CF_DEBUG("removed last relative driver: %s\n",
device_get_nameunit(set->dev));
Add support for relative cpufreq drivers. Such drivers modulate clock frequency as a percentage of the base rate and do not change the base rate directly. The cpufreq framework combines these with absolute drivers to produce synthesized levels made of one or more settings.
2005-02-06 21:08:35 +00:00
fill->rel_count--;
}
/*
Eliminate cpufreq levels for two cases that are less than optimal: 1. Walk the absolute list in reverse to prefer duplicated levels that have a lower absolute setting, i.e. 800 Mhz/50% is better than 1600 Mhz/25% even though both have the same actual frequency. This also removes the need to check for already-modified levels since by definition, those will be added later in the sorted list. 2. Compare the absolute settings for derived levels and don't use the new level if it's higher. For example, a level of 800 Mhz/75% is preferable to 1600 Mhz/25% even though the latter has a lower total frequency. This work is based on a patch from the submitter but reworked by myself. Submitted by: Tijl Coosemans (tijl/ulyssis.org)
2005-08-30 04:45:32 +00:00
* Insert the new level in sorted order. If it is a duplicate of an
* existing level (1) or has an absolute setting higher than the
* existing level (2), do not add it. We can do this since any such
* level is guaranteed use less power. For example (1), a level with
* one absolute setting of 800 Mhz uses less power than one composed
* of an absolute setting of 1600 Mhz and a relative setting at 50%.
* Also for example (2), a level of 800 Mhz/75% is preferable to
* 1600 Mhz/25% even though the latter has a lower total frequency.
Add support for relative cpufreq drivers. Such drivers modulate clock frequency as a percentage of the base rate and do not change the base rate directly. The cpufreq framework combines these with absolute drivers to produce synthesized levels made of one or more settings.
2005-02-06 21:08:35 +00:00
*/
list = &sc->all_levels;
Eliminate cpufreq levels for two cases that are less than optimal: 1. Walk the absolute list in reverse to prefer duplicated levels that have a lower absolute setting, i.e. 800 Mhz/50% is better than 1600 Mhz/25% even though both have the same actual frequency. This also removes the need to check for already-modified levels since by definition, those will be added later in the sorted list. 2. Compare the absolute settings for derived levels and don't use the new level if it's higher. For example, a level of 800 Mhz/75% is preferable to 1600 Mhz/25% even though the latter has a lower total frequency. This work is based on a patch from the submitter but reworked by myself. Submitted by: Tijl Coosemans (tijl/ulyssis.org)
2005-08-30 04:45:32 +00:00
KASSERT(!TAILQ_EMPTY(list), ("all levels list empty in dup set"));
TAILQ_FOREACH_REVERSE(itr, list, cf_level_lst, link) {
itr_set = &itr->total_set;
Break out the checks for duplicates and absolute settings being too high instead of trying to do them all at once. This should fix the level sorting problems from the previous revision. Testing help: ume
2005-09-02 16:32:43 +00:00
if (CPUFREQ_CMP(fill_set->freq, itr_set->freq)) {
CF_DEBUG("dup set rejecting %d (dupe)\n",
fill_set->freq);
itr = NULL;
break;
} else if (fill_set->freq < itr_set->freq) {
if (fill->abs_set.freq <= itr->abs_set.freq) {
CF_DEBUG(
"dup done, inserting new level %d after %d\n",
fill_set->freq, itr_set->freq);
TAILQ_INSERT_AFTER(list, itr, fill, link);
sc->all_count++;
} else {
CF_DEBUG("dup set rejecting %d (abs too big)\n",
fill_set->freq);
itr = NULL;
}
Eliminate cpufreq levels for two cases that are less than optimal: 1. Walk the absolute list in reverse to prefer duplicated levels that have a lower absolute setting, i.e. 800 Mhz/50% is better than 1600 Mhz/25% even though both have the same actual frequency. This also removes the need to check for already-modified levels since by definition, those will be added later in the sorted list. 2. Compare the absolute settings for derived levels and don't use the new level if it's higher. For example, a level of 800 Mhz/75% is preferable to 1600 Mhz/25% even though the latter has a lower total frequency. This work is based on a patch from the submitter but reworked by myself. Submitted by: Tijl Coosemans (tijl/ulyssis.org)
2005-08-30 04:45:32 +00:00
break;
Add support for relative cpufreq drivers. Such drivers modulate clock frequency as a percentage of the base rate and do not change the base rate directly. The cpufreq framework combines these with absolute drivers to produce synthesized levels made of one or more settings.
2005-02-06 21:08:35 +00:00
}
}
Eliminate cpufreq levels for two cases that are less than optimal: 1. Walk the absolute list in reverse to prefer duplicated levels that have a lower absolute setting, i.e. 800 Mhz/50% is better than 1600 Mhz/25% even though both have the same actual frequency. This also removes the need to check for already-modified levels since by definition, those will be added later in the sorted list. 2. Compare the absolute settings for derived levels and don't use the new level if it's higher. For example, a level of 800 Mhz/75% is preferable to 1600 Mhz/25% even though the latter has a lower total frequency. This work is based on a patch from the submitter but reworked by myself. Submitted by: Tijl Coosemans (tijl/ulyssis.org)
2005-08-30 04:45:32 +00:00
/* We didn't find a good place for this new level so free it. */
if (itr == NULL) {
CF_DEBUG("dup set freeing new level %d (not optimal)\n",
fill_set->freq);
free(fill, M_TEMP);
fill = NULL;
}
Add support for relative cpufreq drivers. Such drivers modulate clock frequency as a percentage of the base rate and do not change the base rate directly. The cpufreq framework combines these with absolute drivers to produce synthesized levels made of one or more settings.
2005-02-06 21:08:35 +00:00
return (fill);
}
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
static int
cpufreq_curr_sysctl(SYSCTL_HANDLER_ARGS)
{
struct cpufreq_softc *sc;
struct cf_level *levels;
Revert r175376 and tune cpufreq(4) frequency comparison logic instead. Instead of using 25MHz equality threshold, look for the nearest value when handling dev.cpu.0.freq sysctl and for exact match when it is expected. ACPI may report extra level with frequency 1MHz above the nominal to control Intel Turbo Boost operation. It is not a bug, but feature: dev.cpu.0.freq_levels: 2934/106000 2933/95000 2800/82000 ... In this case value 2933 means 2.93GHz, but 2934 means 3.2-3.6GHz. I've found that my Core i7-870 based system has Intel Turbo Boost disabled by default and without this change it was absolutely invisible and hard to control. MFC after: 2 weeks
2012-03-10 18:56:16 +00:00
int best, count, diff, bdiff, devcount, error, freq, i, n;
Set levels on all CPUs and attach a cpufreq device to each one. Sysctl on dev.cpu.0 will affect all of the CPUs together. In the future, independent control will be supported but this is good enough for now. Check that the timecounter isn't TSC before switching (from Colin Percival.)
2005-02-13 17:31:56 +00:00
device_t *devs;
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
Set levels on all CPUs and attach a cpufreq device to each one. Sysctl on dev.cpu.0 will affect all of the CPUs together. In the future, independent control will be supported but this is good enough for now. Check that the timecounter isn't TSC before switching (from Colin Percival.)
2005-02-13 17:31:56 +00:00
devs = NULL;
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
sc = oidp->oid_arg1;
cpufreq: allocate long-lived buffer for handling of sysctl requests At present the cpufreq sysctl handler for current level setting would allocate and deallocate a temporary buffer of 24KB even to handle a read-only query. This puts unnecessary load on memory subsystem when current level is checked frequently, e.g. when the likes of powerd and system monitoring software are running. Change the strategy to allocating a long-lived buffer for handling the requests. Reviewed by: njl MFC after: 2 weeks
2010-07-23 16:46:42 +00:00
levels = sc->levels_buf;
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
error = CPUFREQ_GET(sc->dev, &levels[0]);
if (error)
goto out;
freq = levels[0].total_set.freq;
error = sysctl_handle_int(oidp, &freq, 0, req);
if (error != 0 || req->newptr == NULL)
goto out;
Set levels on all CPUs and attach a cpufreq device to each one. Sysctl on dev.cpu.0 will affect all of the CPUs together. In the future, independent control will be supported but this is good enough for now. Check that the timecounter isn't TSC before switching (from Colin Percival.)
2005-02-13 17:31:56 +00:00
/*
* While we only call cpufreq_get() on one device (assuming all
* CPUs have equal levels), we call cpufreq_set() on all CPUs.
* This is needed for some MP systems.
*/
error = devclass_get_devices(cpufreq_dc, &devs, &devcount);
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
if (error)
goto out;
Set levels on all CPUs and attach a cpufreq device to each one. Sysctl on dev.cpu.0 will affect all of the CPUs together. In the future, independent control will be supported but this is good enough for now. Check that the timecounter isn't TSC before switching (from Colin Percival.)
2005-02-13 17:31:56 +00:00
for (n = 0; n < devcount; n++) {
count = CF_MAX_LEVELS;
error = CPUFREQ_LEVELS(devs[n], levels, &count);
Bump the maximum number of levels to 64 and add warning messages about what to do to fix reduced functionality if the number of levels is too low.
2005-02-24 20:21:41 +00:00
if (error) {
if (error == E2BIG)
printf(
"cpufreq: need to increase CF_MAX_LEVELS\n");
Set levels on all CPUs and attach a cpufreq device to each one. Sysctl on dev.cpu.0 will affect all of the CPUs together. In the future, independent control will be supported but this is good enough for now. Check that the timecounter isn't TSC before switching (from Colin Percival.)
2005-02-13 17:31:56 +00:00
break;
Bump the maximum number of levels to 64 and add warning messages about what to do to fix reduced functionality if the number of levels is too low.
2005-02-24 20:21:41 +00:00
}
Revert r175376 and tune cpufreq(4) frequency comparison logic instead. Instead of using 25MHz equality threshold, look for the nearest value when handling dev.cpu.0.freq sysctl and for exact match when it is expected. ACPI may report extra level with frequency 1MHz above the nominal to control Intel Turbo Boost operation. It is not a bug, but feature: dev.cpu.0.freq_levels: 2934/106000 2933/95000 2800/82000 ... In this case value 2933 means 2.93GHz, but 2934 means 3.2-3.6GHz. I've found that my Core i7-870 based system has Intel Turbo Boost disabled by default and without this change it was absolutely invisible and hard to control. MFC after: 2 weeks
2012-03-10 18:56:16 +00:00
best = 0;
bdiff = 1 << 30;
Set levels on all CPUs and attach a cpufreq device to each one. Sysctl on dev.cpu.0 will affect all of the CPUs together. In the future, independent control will be supported but this is good enough for now. Check that the timecounter isn't TSC before switching (from Colin Percival.)
2005-02-13 17:31:56 +00:00
for (i = 0; i < count; i++) {
Revert r175376 and tune cpufreq(4) frequency comparison logic instead. Instead of using 25MHz equality threshold, look for the nearest value when handling dev.cpu.0.freq sysctl and for exact match when it is expected. ACPI may report extra level with frequency 1MHz above the nominal to control Intel Turbo Boost operation. It is not a bug, but feature: dev.cpu.0.freq_levels: 2934/106000 2933/95000 2800/82000 ... In this case value 2933 means 2.93GHz, but 2934 means 3.2-3.6GHz. I've found that my Core i7-870 based system has Intel Turbo Boost disabled by default and without this change it was absolutely invisible and hard to control. MFC after: 2 weeks
2012-03-10 18:56:16 +00:00
diff = abs(levels[i].total_set.freq - freq);
if (diff < bdiff) {
bdiff = diff;
best = i;
Set levels on all CPUs and attach a cpufreq device to each one. Sysctl on dev.cpu.0 will affect all of the CPUs together. In the future, independent control will be supported but this is good enough for now. Check that the timecounter isn't TSC before switching (from Colin Percival.)
2005-02-13 17:31:56 +00:00
}
}
Revert r175376 and tune cpufreq(4) frequency comparison logic instead. Instead of using 25MHz equality threshold, look for the nearest value when handling dev.cpu.0.freq sysctl and for exact match when it is expected. ACPI may report extra level with frequency 1MHz above the nominal to control Intel Turbo Boost operation. It is not a bug, but feature: dev.cpu.0.freq_levels: 2934/106000 2933/95000 2800/82000 ... In this case value 2933 means 2.93GHz, but 2934 means 3.2-3.6GHz. I've found that my Core i7-870 based system has Intel Turbo Boost disabled by default and without this change it was absolutely invisible and hard to control. MFC after: 2 weeks
2012-03-10 18:56:16 +00:00
error = CPUFREQ_SET(devs[n], &levels[best], CPUFREQ_PRIO_USER);
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
}
out:
Set levels on all CPUs and attach a cpufreq device to each one. Sysctl on dev.cpu.0 will affect all of the CPUs together. In the future, independent control will be supported but this is good enough for now. Check that the timecounter isn't TSC before switching (from Colin Percival.)
2005-02-13 17:31:56 +00:00
if (devs)
free(devs, M_TEMP);
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
return (error);
}
static int
cpufreq_levels_sysctl(SYSCTL_HANDLER_ARGS)
{
struct cpufreq_softc *sc;
struct cf_level *levels;
struct cf_setting *set;
struct sbuf sb;
int count, error, i;
sc = oidp->oid_arg1;
sbuf_new(&sb, NULL, 128, SBUF_AUTOEXTEND);
/* Get settings from the device and generate the output string. */
count = CF_MAX_LEVELS;
cpufreq: allocate long-lived buffer for handling of sysctl requests At present the cpufreq sysctl handler for current level setting would allocate and deallocate a temporary buffer of 24KB even to handle a read-only query. This puts unnecessary load on memory subsystem when current level is checked frequently, e.g. when the likes of powerd and system monitoring software are running. Change the strategy to allocating a long-lived buffer for handling the requests. Reviewed by: njl MFC after: 2 weeks
2010-07-23 16:46:42 +00:00
levels = sc->levels_buf;
Free allocated sbufs before returning ENOMEM. PR: 128335 Submitted by: Mateusz Guzik <mjguzik@gmail.com> MFC after: 2 week
2010-01-08 22:58:50 +00:00
if (levels == NULL) {
sbuf_delete(&sb);
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
return (ENOMEM);
Free allocated sbufs before returning ENOMEM. PR: 128335 Submitted by: Mateusz Guzik <mjguzik@gmail.com> MFC after: 2 week
2010-01-08 22:58:50 +00:00
}
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
error = CPUFREQ_LEVELS(sc->dev, levels, &count);
Bump the maximum number of levels to 64 and add warning messages about what to do to fix reduced functionality if the number of levels is too low.
2005-02-24 20:21:41 +00:00
if (error) {
if (error == E2BIG)
printf("cpufreq: need to increase CF_MAX_LEVELS\n");
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
goto out;
Bump the maximum number of levels to 64 and add warning messages about what to do to fix reduced functionality if the number of levels is too low.
2005-02-24 20:21:41 +00:00
}
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
if (count) {
for (i = 0; i < count; i++) {
set = &levels[i].total_set;
sbuf_printf(&sb, "%d/%d ", set->freq, set->power);
}
} else
sbuf_cpy(&sb, "0");
sbuf_trim(&sb);
sbuf_finish(&sb);
error = sysctl_handle_string(oidp, sbuf_data(&sb), sbuf_len(&sb), req);
out:
sbuf_delete(&sb);
return (error);
}
Add the "freq_settings" sysctl to each device that registers with cpufreq so their individual settings can be seen separately for debugging.
2005-02-20 00:59:15 +00:00
static int
cpufreq_settings_sysctl(SYSCTL_HANDLER_ARGS)
{
device_t dev;
struct cf_setting *sets;
struct sbuf sb;
int error, i, set_count;
dev = oidp->oid_arg1;
sbuf_new(&sb, NULL, 128, SBUF_AUTOEXTEND);
/* Get settings from the device and generate the output string. */
set_count = MAX_SETTINGS;
Revert r327828, r327949, r327953, r328016-r328026, r328041: Uses of mallocarray(9). The use of mallocarray(9) has rocketed the required swap to build FreeBSD. This is likely caused by the allocation size attributes which put extra pressure on the compiler. Given that most of these checks are superfluous we have to choose better where to use mallocarray(9). We still have more uses of mallocarray(9) but hopefully this is enough to bring swap usage to a reasonable level. Reported by: wosch PR: 225197
2018-01-21 15:42:36 +00:00
sets = malloc(set_count * sizeof(*sets), M_TEMP, M_NOWAIT);
Free allocated sbufs before returning ENOMEM. PR: 128335 Submitted by: Mateusz Guzik <mjguzik@gmail.com> MFC after: 2 week
2010-01-08 22:58:50 +00:00
if (sets == NULL) {
sbuf_delete(&sb);
Add the "freq_settings" sysctl to each device that registers with cpufreq so their individual settings can be seen separately for debugging.
2005-02-20 00:59:15 +00:00
return (ENOMEM);
Free allocated sbufs before returning ENOMEM. PR: 128335 Submitted by: Mateusz Guzik <mjguzik@gmail.com> MFC after: 2 week
2010-01-08 22:58:50 +00:00
}
Add the "freq_settings" sysctl to each device that registers with cpufreq so their individual settings can be seen separately for debugging.
2005-02-20 00:59:15 +00:00
error = CPUFREQ_DRV_SETTINGS(dev, sets, &set_count);
if (error)
goto out;
if (set_count) {
for (i = 0; i < set_count; i++)
sbuf_printf(&sb, "%d/%d ", sets[i].freq, sets[i].power);
} else
sbuf_cpy(&sb, "0");
sbuf_trim(&sb);
sbuf_finish(&sb);
error = sysctl_handle_string(oidp, sbuf_data(&sb), sbuf_len(&sb), req);
out:
free(sets, M_TEMP);
sbuf_delete(&sb);
return (error);
}
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
int
cpufreq_register(device_t dev)
{
When dealing with systems with no absolute drivers attached, only calibrate the rate for the 100% state once. Afterwards, use that value for deriving states. This should fix the problem where the calibrated frequency was different once a switch was done, giving a different set of levels each time. Also, properly search for the right cpufreqX device when detaching.
2005-02-15 07:43:48 +00:00
struct cpufreq_softc *sc;
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
device_t cf_dev, cpu_dev;
Add the "freq_settings" sysctl to each device that registers with cpufreq so their individual settings can be seen separately for debugging.
2005-02-20 00:59:15 +00:00
/* Add a sysctl to get each driver's settings separately. */
SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
OID_AUTO, "freq_settings", CTLTYPE_STRING | CTLFLAG_RD, dev, 0,
cpufreq_settings_sysctl, "A", "CPU frequency driver settings");
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
/*
Set levels on all CPUs and attach a cpufreq device to each one. Sysctl on dev.cpu.0 will affect all of the CPUs together. In the future, independent control will be supported but this is good enough for now. Check that the timecounter isn't TSC before switching (from Colin Percival.)
2005-02-13 17:31:56 +00:00
* Add only one cpufreq device to each CPU. Currently, all CPUs
* must offer the same levels and be switched at the same time.
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
*/
Set levels on all CPUs and attach a cpufreq device to each one. Sysctl on dev.cpu.0 will affect all of the CPUs together. In the future, independent control will be supported but this is good enough for now. Check that the timecounter isn't TSC before switching (from Colin Percival.)
2005-02-13 17:31:56 +00:00
cpu_dev = device_get_parent(dev);
When dealing with systems with no absolute drivers attached, only calibrate the rate for the 100% state once. Afterwards, use that value for deriving states. This should fix the problem where the calibrated frequency was different once a switch was done, giving a different set of levels each time. Also, properly search for the right cpufreqX device when detaching.
2005-02-15 07:43:48 +00:00
if ((cf_dev = device_find_child(cpu_dev, "cpufreq", -1))) {
sc = device_get_softc(cf_dev);
sc->max_mhz = CPUFREQ_VAL_UNKNOWN;
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
return (0);
When dealing with systems with no absolute drivers attached, only calibrate the rate for the 100% state once. Afterwards, use that value for deriving states. This should fix the problem where the calibrated frequency was different once a switch was done, giving a different set of levels each time. Also, properly search for the right cpufreqX device when detaching.
2005-02-15 07:43:48 +00:00
}
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
Set levels on all CPUs and attach a cpufreq device to each one. Sysctl on dev.cpu.0 will affect all of the CPUs together. In the future, independent control will be supported but this is good enough for now. Check that the timecounter isn't TSC before switching (from Colin Percival.)
2005-02-13 17:31:56 +00:00
/* Add the child device and possibly sysctls. */
cf_dev = BUS_ADD_CHILD(cpu_dev, 0, "cpufreq", -1);
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
if (cf_dev == NULL)
return (ENOMEM);
device_quiet(cf_dev);
return (device_probe_and_attach(cf_dev));
}
int
cpufreq_unregister(device_t dev)
{
device_t cf_dev, *devs;
Introduce a new method, cpufreq_drv_type(), that returns the type of the driver. This used to be handled by cpufreq_drv_settings() but it's useful to get the type/flags separately from getting the settings. (For example, you don't have to pass an array of cf_setting just to find the driver type.) Use this new method in our in-tree drivers to detect reliably if acpi_perf is present and owns the hardware. This simplifies logic in drivers as well as fixing a bug introduced in my last commit where too many drivers attached.
2005-02-18 00:23:36 +00:00
int cfcount, devcount, error, i, type;
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
/*
* If this is the last cpufreq child device, remove the control
* device as well. We identify cpufreq children by calling a method
* they support.
*/
error = device_get_children(device_get_parent(dev), &devs, &devcount);
if (error)
return (error);
When dealing with systems with no absolute drivers attached, only calibrate the rate for the 100% state once. Afterwards, use that value for deriving states. This should fix the problem where the calibrated frequency was different once a switch was done, giving a different set of levels each time. Also, properly search for the right cpufreqX device when detaching.
2005-02-15 07:43:48 +00:00
cf_dev = device_find_child(device_get_parent(dev), "cpufreq", -1);
Add a check for cpufreq_unregister() being called with no cpufreq device active. Note that the logic indicates this should not be possible so generate a warning if this ever happens. Found by: Coverity Prevent (via sam)
2005-03-31 18:56:54 +00:00
if (cf_dev == NULL) {
device_printf(dev,
"warning: cpufreq_unregister called with no cpufreq device active\n");
Free resources in an error case. CID: 1018947 Found with: Coverity Prevent(tm) MFC after: 1 week
2014-05-02 21:34:17 +00:00
free(devs, M_TEMP);
Add a check for cpufreq_unregister() being called with no cpufreq device active. Note that the logic indicates this should not be possible so generate a warning if this ever happens. Found by: Coverity Prevent (via sam)
2005-03-31 18:56:54 +00:00
return (0);
}
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
cfcount = 0;
for (i = 0; i < devcount; i++) {
if (!device_is_attached(devs[i]))
continue;
Introduce a new method, cpufreq_drv_type(), that returns the type of the driver. This used to be handled by cpufreq_drv_settings() but it's useful to get the type/flags separately from getting the settings. (For example, you don't have to pass an array of cf_setting just to find the driver type.) Use this new method in our in-tree drivers to detect reliably if acpi_perf is present and owns the hardware. This simplifies logic in drivers as well as fixing a bug introduced in my last commit where too many drivers attached.
2005-02-18 00:23:36 +00:00
if (CPUFREQ_DRV_TYPE(devs[i], &type) == 0)
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
cfcount++;
}
Set levels on all CPUs and attach a cpufreq device to each one. Sysctl on dev.cpu.0 will affect all of the CPUs together. In the future, independent control will be supported but this is good enough for now. Check that the timecounter isn't TSC before switching (from Colin Percival.)
2005-02-13 17:31:56 +00:00
if (cfcount <= 1)
Add the cpufreq framework. This code manages multiple drivers and presents a unified kernel and user interface for controlling cpu frequencies.
2005-02-04 05:39:19 +00:00
device_delete_child(device_get_parent(cf_dev), cf_dev);
free(devs, M_TEMP);
return (0);
}
Add an interface for drivers to be notified of changes to CPU frequency. cpufreq_pre_change is called before the change, giving each driver a chance to revoke the change. cpufreq_post_change provides the results of the change (success or failure). cpufreq_levels_changed gives the unit number of the cpufreq device whose number of available levels has changed. Hook in all the drivers I could find that needed it. * TSC: update TSC frequency value. When the available levels change, take the highest possible level and notify the timecounter set_cputicker() of that freq. This gets rid of the "calcru: runtime went backwards" messages. * identcpu: updates the sysctl hw.clockrate value * Profiling: if profiling is active when the clock changes, let the user know the results may be inaccurate. Reviewed by: bde, phk MFC after: 1 month
2007-03-26 18:03:29 +00:00
int
cpufreq_settings_changed(device_t dev)
{
EVENTHANDLER_INVOKE(cpufreq_levels_changed,
device_get_unit(device_get_parent(dev)));
return (0);
}
Reference in New Issue Copy Permalink