173347b07SNate Lawson /*-
24d846d26SWarner Losh * SPDX-License-Identifier: BSD-2-Clause
38a36da99SPedro F. Giffuni *
40d4ac62aSNate Lawson * Copyright (c) 2004-2007 Nate Lawson (SDG)
573347b07SNate Lawson * All rights reserved.
673347b07SNate Lawson *
773347b07SNate Lawson * Redistribution and use in source and binary forms, with or without
873347b07SNate Lawson * modification, are permitted provided that the following conditions
973347b07SNate Lawson * are met:
1073347b07SNate Lawson * 1. Redistributions of source code must retain the above copyright
1173347b07SNate Lawson * notice, this list of conditions and the following disclaimer.
1273347b07SNate Lawson * 2. Redistributions in binary form must reproduce the above copyright
1373347b07SNate Lawson * notice, this list of conditions and the following disclaimer in the
1473347b07SNate Lawson * documentation and/or other materials provided with the distribution.
1573347b07SNate Lawson *
1673347b07SNate Lawson * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
1773347b07SNate Lawson * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
1873347b07SNate Lawson * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
1973347b07SNate Lawson * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
2073347b07SNate Lawson * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
2173347b07SNate Lawson * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
2273347b07SNate Lawson * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
2373347b07SNate Lawson * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
2473347b07SNate Lawson * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
2573347b07SNate Lawson * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
2673347b07SNate Lawson * SUCH DAMAGE.
2773347b07SNate Lawson */
2873347b07SNate Lawson
2973347b07SNate Lawson #include <sys/param.h>
3073347b07SNate Lawson #include <sys/bus.h>
3173347b07SNate Lawson #include <sys/cpu.h>
3273347b07SNate Lawson #include <sys/eventhandler.h>
3373347b07SNate Lawson #include <sys/kernel.h>
34789f03ceSNate Lawson #include <sys/lock.h>
3573347b07SNate Lawson #include <sys/malloc.h>
3673347b07SNate Lawson #include <sys/module.h>
3773347b07SNate Lawson #include <sys/proc.h>
3873347b07SNate Lawson #include <sys/queue.h>
39a15e947dSNate Lawson #include <sys/sbuf.h>
4073347b07SNate Lawson #include <sys/sched.h>
41a15e947dSNate Lawson #include <sys/smp.h>
4273347b07SNate Lawson #include <sys/sysctl.h>
4373347b07SNate Lawson #include <sys/systm.h>
44789f03ceSNate Lawson #include <sys/sx.h>
450325089dSNate Lawson #include <sys/timetc.h>
460d4ac62aSNate Lawson #include <sys/taskqueue.h>
4773347b07SNate Lawson
4873347b07SNate Lawson #include "cpufreq_if.h"
4973347b07SNate Lawson
5073347b07SNate Lawson /*
5173347b07SNate Lawson * Common CPU frequency glue code. Drivers for specific hardware can
5273347b07SNate Lawson * attach this interface to allow users to get/set the CPU frequency.
5373347b07SNate Lawson */
5473347b07SNate Lawson
5573347b07SNate Lawson /*
5673347b07SNate Lawson * Number of levels we can handle. Levels are synthesized from settings
57d269386aSNate Lawson * so for M settings and N drivers, there may be M*N levels.
5873347b07SNate Lawson */
5922c1b4c0SJustin Hibbits #define CF_MAX_LEVELS 256
6073347b07SNate Lawson
6156e5a87aSHajimu UMEMOTO struct cf_saved_freq {
6256e5a87aSHajimu UMEMOTO struct cf_level level;
6356e5a87aSHajimu UMEMOTO int priority;
6456e5a87aSHajimu UMEMOTO SLIST_ENTRY(cf_saved_freq) link;
6556e5a87aSHajimu UMEMOTO };
6656e5a87aSHajimu UMEMOTO
6773347b07SNate Lawson struct cpufreq_softc {
68789f03ceSNate Lawson struct sx lock;
6973347b07SNate Lawson struct cf_level curr_level;
705f0afa04SNate Lawson int curr_priority;
7156e5a87aSHajimu UMEMOTO SLIST_HEAD(, cf_saved_freq) saved_freq;
7273347b07SNate Lawson struct cf_level_lst all_levels;
735f0afa04SNate Lawson int all_count;
7467c8649fSNate Lawson int max_mhz;
7573347b07SNate Lawson device_t dev;
764577cf37SConrad Meyer device_t cf_drv_dev;
7773347b07SNate Lawson struct sysctl_ctx_list sysctl_ctx;
780d4ac62aSNate Lawson struct task startup_task;
79dac50931SAndriy Gapon struct cf_level *levels_buf;
8073347b07SNate Lawson };
8173347b07SNate Lawson
8273347b07SNate Lawson struct cf_setting_array {
8373347b07SNate Lawson struct cf_setting sets[MAX_SETTINGS];
8473347b07SNate Lawson int count;
8573347b07SNate Lawson TAILQ_ENTRY(cf_setting_array) link;
8673347b07SNate Lawson };
8773347b07SNate Lawson
8873347b07SNate Lawson TAILQ_HEAD(cf_setting_lst, cf_setting_array);
8973347b07SNate Lawson
90789f03ceSNate Lawson #define CF_MTX_INIT(x) sx_init((x), "cpufreq lock")
91789f03ceSNate Lawson #define CF_MTX_LOCK(x) sx_xlock((x))
92789f03ceSNate Lawson #define CF_MTX_UNLOCK(x) sx_xunlock((x))
93789f03ceSNate Lawson #define CF_MTX_ASSERT(x) sx_assert((x), SX_XLOCKED)
94789f03ceSNate Lawson
958d913481SNate Lawson #define CF_DEBUG(msg...) do { \
968d913481SNate Lawson if (cf_verbose) \
978d913481SNate Lawson printf("cpufreq: " msg); \
988d913481SNate Lawson } while (0)
998d913481SNate Lawson
10073347b07SNate Lawson static int cpufreq_attach(device_t dev);
1010d4ac62aSNate Lawson static void cpufreq_startup_task(void *ctx, int pending);
10273347b07SNate Lawson static int cpufreq_detach(device_t dev);
10373347b07SNate Lawson static int cf_set_method(device_t dev, const struct cf_level *level,
10473347b07SNate Lawson int priority);
10573347b07SNate Lawson static int cf_get_method(device_t dev, struct cf_level *level);
10673347b07SNate Lawson static int cf_levels_method(device_t dev, struct cf_level *levels,
10773347b07SNate Lawson int *count);
10888c9b54cSNate Lawson static int cpufreq_insert_abs(struct cpufreq_softc *sc,
10973347b07SNate Lawson struct cf_setting *sets, int count);
11088c9b54cSNate Lawson static int cpufreq_expand_set(struct cpufreq_softc *sc,
11188c9b54cSNate Lawson struct cf_setting_array *set_arr);
11288c9b54cSNate Lawson static struct cf_level *cpufreq_dup_set(struct cpufreq_softc *sc,
11388c9b54cSNate Lawson struct cf_level *dup, struct cf_setting *set);
11473347b07SNate Lawson static int cpufreq_curr_sysctl(SYSCTL_HANDLER_ARGS);
11573347b07SNate Lawson static int cpufreq_levels_sysctl(SYSCTL_HANDLER_ARGS);
116e959a70bSNate Lawson static int cpufreq_settings_sysctl(SYSCTL_HANDLER_ARGS);
11773347b07SNate Lawson
11873347b07SNate Lawson static device_method_t cpufreq_methods[] = {
11973347b07SNate Lawson DEVMETHOD(device_probe, bus_generic_probe),
12073347b07SNate Lawson DEVMETHOD(device_attach, cpufreq_attach),
12173347b07SNate Lawson DEVMETHOD(device_detach, cpufreq_detach),
12273347b07SNate Lawson
12373347b07SNate Lawson DEVMETHOD(cpufreq_set, cf_set_method),
12473347b07SNate Lawson DEVMETHOD(cpufreq_get, cf_get_method),
12573347b07SNate Lawson DEVMETHOD(cpufreq_levels, cf_levels_method),
12673347b07SNate Lawson {0, 0}
12773347b07SNate Lawson };
1282fdcc2efSJohn Baldwin
12973347b07SNate Lawson static driver_t cpufreq_driver = {
13073347b07SNate Lawson "cpufreq", cpufreq_methods, sizeof(struct cpufreq_softc)
13173347b07SNate Lawson };
1322fdcc2efSJohn Baldwin
1332fdcc2efSJohn Baldwin DRIVER_MODULE(cpufreq, cpu, cpufreq_driver, 0, 0);
13473347b07SNate Lawson
135b070969bSNate Lawson static int cf_lowest_freq;
1368d913481SNate Lawson static int cf_verbose;
1377029da5cSPawel Biernacki static SYSCTL_NODE(_debug, OID_AUTO, cpufreq, CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
1386472ac3dSEd Schouten "cpufreq debugging");
139af3b2549SHans Petter Selasky SYSCTL_INT(_debug_cpufreq, OID_AUTO, lowest, CTLFLAG_RWTUN, &cf_lowest_freq, 1,
140b070969bSNate Lawson "Don't provide levels below this frequency.");
141af3b2549SHans Petter Selasky SYSCTL_INT(_debug_cpufreq, OID_AUTO, verbose, CTLFLAG_RWTUN, &cf_verbose, 1,
1428d913481SNate Lawson "Print verbose debugging messages");
143b070969bSNate Lawson
1444577cf37SConrad Meyer /*
1454577cf37SConrad Meyer * This is called as the result of a hardware specific frequency control driver
1464577cf37SConrad Meyer * calling cpufreq_register. It provides a general interface for system wide
1474577cf37SConrad Meyer * frequency controls and operates on a per cpu basis.
1484577cf37SConrad Meyer */
14973347b07SNate Lawson static int
cpufreq_attach(device_t dev)15073347b07SNate Lawson cpufreq_attach(device_t dev)
15173347b07SNate Lawson {
15273347b07SNate Lawson struct cpufreq_softc *sc;
153d288bcc4SAlexander Motin struct pcpu *pc;
15473347b07SNate Lawson device_t parent;
155d288bcc4SAlexander Motin uint64_t rate;
15673347b07SNate Lawson
1578d913481SNate Lawson CF_DEBUG("initializing %s\n", device_get_nameunit(dev));
15873347b07SNate Lawson sc = device_get_softc(dev);
15973347b07SNate Lawson parent = device_get_parent(dev);
16073347b07SNate Lawson sc->dev = dev;
16173347b07SNate Lawson sysctl_ctx_init(&sc->sysctl_ctx);
16273347b07SNate Lawson TAILQ_INIT(&sc->all_levels);
163789f03ceSNate Lawson CF_MTX_INIT(&sc->lock);
16473347b07SNate Lawson sc->curr_level.total_set.freq = CPUFREQ_VAL_UNKNOWN;
16556e5a87aSHajimu UMEMOTO SLIST_INIT(&sc->saved_freq);
166f436f175SNathan Whitehorn /* Try to get nominal CPU freq to use it as maximum later if needed */
167f436f175SNathan Whitehorn sc->max_mhz = cpu_get_nominal_mhz(dev);
168f436f175SNathan Whitehorn /* If that fails, try to measure the current rate */
169f436f175SNathan Whitehorn if (sc->max_mhz <= 0) {
1704577cf37SConrad Meyer CF_DEBUG("Unable to obtain nominal frequency.\n");
171d288bcc4SAlexander Motin pc = cpu_get_pcpu(dev);
172d288bcc4SAlexander Motin if (cpu_est_clockrate(pc->pc_cpuid, &rate) == 0)
173d288bcc4SAlexander Motin sc->max_mhz = rate / 1000000;
174d288bcc4SAlexander Motin else
17567c8649fSNate Lawson sc->max_mhz = CPUFREQ_VAL_UNKNOWN;
176f436f175SNathan Whitehorn }
17773347b07SNate Lawson
1788d913481SNate Lawson CF_DEBUG("initializing one-time data for %s\n",
1798d913481SNate Lawson device_get_nameunit(dev));
180dac50931SAndriy Gapon sc->levels_buf = malloc(CF_MAX_LEVELS * sizeof(*sc->levels_buf),
181dac50931SAndriy Gapon M_DEVBUF, M_WAITOK);
18273347b07SNate Lawson SYSCTL_ADD_PROC(&sc->sysctl_ctx,
18373347b07SNate Lawson SYSCTL_CHILDREN(device_get_sysctl_tree(parent)),
1847029da5cSPawel Biernacki OID_AUTO, "freq", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
1857029da5cSPawel Biernacki sc, 0, cpufreq_curr_sysctl, "I", "Current CPU frequency");
18673347b07SNate Lawson SYSCTL_ADD_PROC(&sc->sysctl_ctx,
18773347b07SNate Lawson SYSCTL_CHILDREN(device_get_sysctl_tree(parent)),
1887029da5cSPawel Biernacki OID_AUTO, "freq_levels",
1897029da5cSPawel Biernacki CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
19073347b07SNate Lawson cpufreq_levels_sysctl, "A", "CPU frequency levels");
1910d4ac62aSNate Lawson
1920d4ac62aSNate Lawson /*
1930d4ac62aSNate Lawson * Queue a one-shot broadcast that levels have changed.
1940d4ac62aSNate Lawson * It will run once the system has completed booting.
1950d4ac62aSNate Lawson */
1960d4ac62aSNate Lawson TASK_INIT(&sc->startup_task, 0, cpufreq_startup_task, dev);
1970d4ac62aSNate Lawson taskqueue_enqueue(taskqueue_thread, &sc->startup_task);
19873347b07SNate Lawson
19973347b07SNate Lawson return (0);
20073347b07SNate Lawson }
20173347b07SNate Lawson
2020d4ac62aSNate Lawson /* Handle any work to be done for all drivers that attached during boot. */
2030d4ac62aSNate Lawson static void
cpufreq_startup_task(void * ctx,int pending)2040d4ac62aSNate Lawson cpufreq_startup_task(void *ctx, int pending)
2050d4ac62aSNate Lawson {
2060d4ac62aSNate Lawson
2070d4ac62aSNate Lawson cpufreq_settings_changed((device_t)ctx);
2080d4ac62aSNate Lawson }
2090d4ac62aSNate Lawson
21073347b07SNate Lawson static int
cpufreq_detach(device_t dev)21173347b07SNate Lawson cpufreq_detach(device_t dev)
21273347b07SNate Lawson {
21373347b07SNate Lawson struct cpufreq_softc *sc;
21456e5a87aSHajimu UMEMOTO struct cf_saved_freq *saved_freq;
21573347b07SNate Lawson
2168d913481SNate Lawson CF_DEBUG("shutdown %s\n", device_get_nameunit(dev));
21773347b07SNate Lawson sc = device_get_softc(dev);
21873347b07SNate Lawson sysctl_ctx_free(&sc->sysctl_ctx);
21973347b07SNate Lawson
22056e5a87aSHajimu UMEMOTO while ((saved_freq = SLIST_FIRST(&sc->saved_freq)) != NULL) {
22156e5a87aSHajimu UMEMOTO SLIST_REMOVE_HEAD(&sc->saved_freq, link);
22256e5a87aSHajimu UMEMOTO free(saved_freq, M_TEMP);
22356e5a87aSHajimu UMEMOTO }
22456e5a87aSHajimu UMEMOTO
225dac50931SAndriy Gapon free(sc->levels_buf, M_DEVBUF);
22673347b07SNate Lawson
22773347b07SNate Lawson return (0);
22873347b07SNate Lawson }
22973347b07SNate Lawson
23073347b07SNate Lawson static int
cf_set_method(device_t dev,const struct cf_level * level,int priority)23173347b07SNate Lawson cf_set_method(device_t dev, const struct cf_level *level, int priority)
23273347b07SNate Lawson {
23373347b07SNate Lawson struct cpufreq_softc *sc;
23473347b07SNate Lawson const struct cf_setting *set;
23556e5a87aSHajimu UMEMOTO struct cf_saved_freq *saved_freq, *curr_freq;
2360325089dSNate Lawson struct pcpu *pc;
23762db376aSNate Lawson int error, i;
238e7bd0750SAndrew Gallatin u_char pri;
23973347b07SNate Lawson
24073347b07SNate Lawson sc = device_get_softc(dev);
241789f03ceSNate Lawson error = 0;
242789f03ceSNate Lawson set = NULL;
24356e5a87aSHajimu UMEMOTO saved_freq = NULL;
24473347b07SNate Lawson
2450d4ac62aSNate Lawson /* We are going to change levels so notify the pre-change handler. */
2460d4ac62aSNate Lawson EVENTHANDLER_INVOKE(cpufreq_pre_change, level, &error);
2470d4ac62aSNate Lawson if (error != 0) {
2480d4ac62aSNate Lawson EVENTHANDLER_INVOKE(cpufreq_post_change, level, error);
2490d4ac62aSNate Lawson return (error);
250b4130b8aSMarcus Alves Grando }
2510325089dSNate Lawson
252789f03ceSNate Lawson CF_MTX_LOCK(&sc->lock);
25356e5a87aSHajimu UMEMOTO
254a15e947dSNate Lawson #ifdef SMP
255fdce57a0SJohn Baldwin #ifdef EARLY_AP_STARTUP
256fdce57a0SJohn Baldwin MPASS(mp_ncpus == 1 || smp_started);
257fdce57a0SJohn Baldwin #else
258a15e947dSNate Lawson /*
259a15e947dSNate Lawson * If still booting and secondary CPUs not started yet, don't allow
260a15e947dSNate Lawson * changing the frequency until they're online. This is because we
261a15e947dSNate Lawson * can't switch to them using sched_bind() and thus we'd only be
262a15e947dSNate Lawson * switching the main CPU. XXXTODO: Need to think more about how to
263a15e947dSNate Lawson * handle having different CPUs at different frequencies.
264a15e947dSNate Lawson */
26560ad8150SScott Long if (mp_ncpus > 1 && !smp_started) {
266a15e947dSNate Lawson device_printf(dev, "rejecting change, SMP not started yet\n");
267a15e947dSNate Lawson error = ENXIO;
268a15e947dSNate Lawson goto out;
269a15e947dSNate Lawson }
270fdce57a0SJohn Baldwin #endif
271a15e947dSNate Lawson #endif /* SMP */
272a15e947dSNate Lawson
27356e5a87aSHajimu UMEMOTO /*
27456e5a87aSHajimu UMEMOTO * If the requested level has a lower priority, don't allow
27556e5a87aSHajimu UMEMOTO * the new level right now.
27656e5a87aSHajimu UMEMOTO */
27756e5a87aSHajimu UMEMOTO if (priority < sc->curr_priority) {
2788d913481SNate Lawson CF_DEBUG("ignoring, curr prio %d less than %d\n", priority,
2798d913481SNate Lawson sc->curr_priority);
280789f03ceSNate Lawson error = EPERM;
281789f03ceSNate Lawson goto out;
282789f03ceSNate Lawson }
2835f0afa04SNate Lawson
28456e5a87aSHajimu UMEMOTO /*
28556e5a87aSHajimu UMEMOTO * If the caller didn't specify a level and one is saved, prepare to
28656e5a87aSHajimu UMEMOTO * restore the saved level. If none has been saved, return an error.
28756e5a87aSHajimu UMEMOTO */
28856e5a87aSHajimu UMEMOTO if (level == NULL) {
28956e5a87aSHajimu UMEMOTO saved_freq = SLIST_FIRST(&sc->saved_freq);
29056e5a87aSHajimu UMEMOTO if (saved_freq == NULL) {
29156e5a87aSHajimu UMEMOTO CF_DEBUG("NULL level, no saved level\n");
29256e5a87aSHajimu UMEMOTO error = ENXIO;
29356e5a87aSHajimu UMEMOTO goto out;
29456e5a87aSHajimu UMEMOTO }
29556e5a87aSHajimu UMEMOTO level = &saved_freq->level;
29656e5a87aSHajimu UMEMOTO priority = saved_freq->priority;
29756e5a87aSHajimu UMEMOTO CF_DEBUG("restoring saved level, freq %d prio %d\n",
29856e5a87aSHajimu UMEMOTO level->total_set.freq, priority);
29956e5a87aSHajimu UMEMOTO }
30056e5a87aSHajimu UMEMOTO
301b070969bSNate Lawson /* Reject levels that are below our specified threshold. */
302da8a77c1SNate Lawson if (level->total_set.freq < cf_lowest_freq) {
3038d913481SNate Lawson CF_DEBUG("rejecting freq %d, less than %d limit\n",
3048d913481SNate Lawson level->total_set.freq, cf_lowest_freq);
305789f03ceSNate Lawson error = EINVAL;
306789f03ceSNate Lawson goto out;
307789f03ceSNate Lawson }
308b070969bSNate Lawson
30973347b07SNate Lawson /* If already at this level, just return. */
3105f3818a5SAlexander Motin if (sc->curr_level.total_set.freq == level->total_set.freq) {
3118d913481SNate Lawson CF_DEBUG("skipping freq %d, same as current level %d\n",
3128d913481SNate Lawson level->total_set.freq, sc->curr_level.total_set.freq);
3131fea6ce7SHajimu UMEMOTO goto skip;
3148d913481SNate Lawson }
31573347b07SNate Lawson
31673347b07SNate Lawson /* First, set the absolute frequency via its driver. */
31773347b07SNate Lawson set = &level->abs_set;
31873347b07SNate Lawson if (set->dev) {
31973347b07SNate Lawson if (!device_is_attached(set->dev)) {
32073347b07SNate Lawson error = ENXIO;
32173347b07SNate Lawson goto out;
32273347b07SNate Lawson }
3231196826aSNate Lawson
32462db376aSNate Lawson /* Bind to the target CPU before switching. */
3251196826aSNate Lawson pc = cpu_get_pcpu(set->dev);
3265ab94f48SMichal Meloun
3275ab94f48SMichal Meloun /* Skip settings if CPU is not started. */
3285ab94f48SMichal Meloun if (pc == NULL) {
3295ab94f48SMichal Meloun error = 0;
3305ab94f48SMichal Meloun goto out;
3315ab94f48SMichal Meloun }
332982d11f8SJeff Roberson thread_lock(curthread);
333e7bd0750SAndrew Gallatin pri = curthread->td_priority;
334e7bd0750SAndrew Gallatin sched_prio(curthread, PRI_MIN);
3351196826aSNate Lawson sched_bind(curthread, pc->pc_cpuid);
336982d11f8SJeff Roberson thread_unlock(curthread);
3378d913481SNate Lawson CF_DEBUG("setting abs freq %d on %s (cpu %d)\n", set->freq,
3388d913481SNate Lawson device_get_nameunit(set->dev), PCPU_GET(cpuid));
33973347b07SNate Lawson error = CPUFREQ_DRV_SET(set->dev, set);
340982d11f8SJeff Roberson thread_lock(curthread);
3411196826aSNate Lawson sched_unbind(curthread);
342e7bd0750SAndrew Gallatin sched_prio(curthread, pri);
343982d11f8SJeff Roberson thread_unlock(curthread);
34473347b07SNate Lawson if (error) {
34573347b07SNate Lawson goto out;
34673347b07SNate Lawson }
34773347b07SNate Lawson }
34873347b07SNate Lawson
34988c9b54cSNate Lawson /* Next, set any/all relative frequencies via their drivers. */
35088c9b54cSNate Lawson for (i = 0; i < level->rel_count; i++) {
35188c9b54cSNate Lawson set = &level->rel_set[i];
35288c9b54cSNate Lawson if (!device_is_attached(set->dev)) {
35388c9b54cSNate Lawson error = ENXIO;
35488c9b54cSNate Lawson goto out;
35588c9b54cSNate Lawson }
3561196826aSNate Lawson
35762db376aSNate Lawson /* Bind to the target CPU before switching. */
3581196826aSNate Lawson pc = cpu_get_pcpu(set->dev);
359982d11f8SJeff Roberson thread_lock(curthread);
360e7bd0750SAndrew Gallatin pri = curthread->td_priority;
361e7bd0750SAndrew Gallatin sched_prio(curthread, PRI_MIN);
3621196826aSNate Lawson sched_bind(curthread, pc->pc_cpuid);
363982d11f8SJeff Roberson thread_unlock(curthread);
3648d913481SNate Lawson CF_DEBUG("setting rel freq %d on %s (cpu %d)\n", set->freq,
3658d913481SNate Lawson device_get_nameunit(set->dev), PCPU_GET(cpuid));
36688c9b54cSNate Lawson error = CPUFREQ_DRV_SET(set->dev, set);
367982d11f8SJeff Roberson thread_lock(curthread);
3681196826aSNate Lawson sched_unbind(curthread);
369e7bd0750SAndrew Gallatin sched_prio(curthread, pri);
370982d11f8SJeff Roberson thread_unlock(curthread);
37188c9b54cSNate Lawson if (error) {
37288c9b54cSNate Lawson /* XXX Back out any successful setting? */
37388c9b54cSNate Lawson goto out;
37488c9b54cSNate Lawson }
37588c9b54cSNate Lawson }
37673347b07SNate Lawson
3771fea6ce7SHajimu UMEMOTO skip:
3785f0afa04SNate Lawson /*
3795f0afa04SNate Lawson * Before recording the current level, check if we're going to a
38056e5a87aSHajimu UMEMOTO * higher priority. If so, save the previous level and priority.
3815f0afa04SNate Lawson */
3825f0afa04SNate Lawson if (sc->curr_level.total_set.freq != CPUFREQ_VAL_UNKNOWN &&
38356e5a87aSHajimu UMEMOTO priority > sc->curr_priority) {
3848d913481SNate Lawson CF_DEBUG("saving level, freq %d prio %d\n",
3858d913481SNate Lawson sc->curr_level.total_set.freq, sc->curr_priority);
38656e5a87aSHajimu UMEMOTO curr_freq = malloc(sizeof(*curr_freq), M_TEMP, M_NOWAIT);
38756e5a87aSHajimu UMEMOTO if (curr_freq == NULL) {
38856e5a87aSHajimu UMEMOTO error = ENOMEM;
38956e5a87aSHajimu UMEMOTO goto out;
39056e5a87aSHajimu UMEMOTO }
39156e5a87aSHajimu UMEMOTO curr_freq->level = sc->curr_level;
39256e5a87aSHajimu UMEMOTO curr_freq->priority = sc->curr_priority;
39356e5a87aSHajimu UMEMOTO SLIST_INSERT_HEAD(&sc->saved_freq, curr_freq, link);
3945f0afa04SNate Lawson }
39573347b07SNate Lawson sc->curr_level = *level;
3965f0afa04SNate Lawson sc->curr_priority = priority;
39773347b07SNate Lawson
39856e5a87aSHajimu UMEMOTO /* If we were restoring a saved state, reset it to "unused". */
39956e5a87aSHajimu UMEMOTO if (saved_freq != NULL) {
40056e5a87aSHajimu UMEMOTO CF_DEBUG("resetting saved level\n");
40156e5a87aSHajimu UMEMOTO sc->curr_level.total_set.freq = CPUFREQ_VAL_UNKNOWN;
40256e5a87aSHajimu UMEMOTO SLIST_REMOVE_HEAD(&sc->saved_freq, link);
40356e5a87aSHajimu UMEMOTO free(saved_freq, M_TEMP);
40456e5a87aSHajimu UMEMOTO }
40556e5a87aSHajimu UMEMOTO
40673347b07SNate Lawson out:
407789f03ceSNate Lawson CF_MTX_UNLOCK(&sc->lock);
4080d4ac62aSNate Lawson
4090d4ac62aSNate Lawson /*
4100d4ac62aSNate Lawson * We changed levels (or attempted to) so notify the post-change
4110d4ac62aSNate Lawson * handler of new frequency or error.
4120d4ac62aSNate Lawson */
4130d4ac62aSNate Lawson EVENTHANDLER_INVOKE(cpufreq_post_change, level, error);
414789f03ceSNate Lawson if (error && set)
41573347b07SNate Lawson device_printf(set->dev, "set freq failed, err %d\n", error);
4160d4ac62aSNate Lawson
41773347b07SNate Lawson return (error);
41873347b07SNate Lawson }
41973347b07SNate Lawson
42073347b07SNate Lawson static int
cpufreq_get_frequency(device_t dev)4214577cf37SConrad Meyer cpufreq_get_frequency(device_t dev)
4224577cf37SConrad Meyer {
4234577cf37SConrad Meyer struct cf_setting set;
4244577cf37SConrad Meyer
4254577cf37SConrad Meyer if (CPUFREQ_DRV_GET(dev, &set) != 0)
4264577cf37SConrad Meyer return (-1);
4274577cf37SConrad Meyer
4284577cf37SConrad Meyer return (set.freq);
4294577cf37SConrad Meyer }
4304577cf37SConrad Meyer
4314577cf37SConrad Meyer /* Returns the index into *levels with the match */
4324577cf37SConrad Meyer static int
cpufreq_get_level(device_t dev,struct cf_level * levels,int count)4334577cf37SConrad Meyer cpufreq_get_level(device_t dev, struct cf_level *levels, int count)
4344577cf37SConrad Meyer {
4354577cf37SConrad Meyer int i, freq;
4364577cf37SConrad Meyer
4374577cf37SConrad Meyer if ((freq = cpufreq_get_frequency(dev)) < 0)
4384577cf37SConrad Meyer return (-1);
4394577cf37SConrad Meyer for (i = 0; i < count; i++)
4404577cf37SConrad Meyer if (freq == levels[i].total_set.freq)
4414577cf37SConrad Meyer return (i);
4424577cf37SConrad Meyer
4434577cf37SConrad Meyer return (-1);
4444577cf37SConrad Meyer }
4454577cf37SConrad Meyer
4464577cf37SConrad Meyer /*
4474577cf37SConrad Meyer * Used by the cpufreq core, this function will populate *level with the current
4484577cf37SConrad Meyer * frequency as either determined by a cached value sc->curr_level, or in the
4494577cf37SConrad Meyer * case the lower level driver has set the CPUFREQ_FLAG_UNCACHED flag, it will
4504577cf37SConrad Meyer * obtain the frequency from the driver itself.
4514577cf37SConrad Meyer */
4524577cf37SConrad Meyer static int
cf_get_method(device_t dev,struct cf_level * level)45373347b07SNate Lawson cf_get_method(device_t dev, struct cf_level *level)
45473347b07SNate Lawson {
45573347b07SNate Lawson struct cpufreq_softc *sc;
45673347b07SNate Lawson struct cf_level *levels;
4574577cf37SConrad Meyer struct cf_setting *curr_set;
45873347b07SNate Lawson struct pcpu *pc;
4594577cf37SConrad Meyer int bdiff, count, diff, error, i, type;
46073347b07SNate Lawson uint64_t rate;
46173347b07SNate Lawson
46273347b07SNate Lawson sc = device_get_softc(dev);
463789f03ceSNate Lawson error = 0;
46473347b07SNate Lawson levels = NULL;
46573347b07SNate Lawson
4664577cf37SConrad Meyer /*
4674577cf37SConrad Meyer * If we already know the current frequency, and the driver didn't ask
4684577cf37SConrad Meyer * for uncached usage, we're done.
4694577cf37SConrad Meyer */
470789f03ceSNate Lawson CF_MTX_LOCK(&sc->lock);
471789f03ceSNate Lawson curr_set = &sc->curr_level.total_set;
4724577cf37SConrad Meyer error = CPUFREQ_DRV_TYPE(sc->cf_drv_dev, &type);
4734577cf37SConrad Meyer if (error == 0 && (type & CPUFREQ_FLAG_UNCACHED)) {
4744577cf37SConrad Meyer struct cf_setting set;
4754577cf37SConrad Meyer
4764577cf37SConrad Meyer /*
4774577cf37SConrad Meyer * If the driver wants to always report back the real frequency,
4784577cf37SConrad Meyer * first try the driver and if that fails, fall back to
4794577cf37SConrad Meyer * estimating.
4804577cf37SConrad Meyer */
48107a65f9dSConrad Meyer if (CPUFREQ_DRV_GET(sc->cf_drv_dev, &set) == 0) {
4824577cf37SConrad Meyer sc->curr_level.total_set = set;
48307a65f9dSConrad Meyer CF_DEBUG("get returning immediate freq %d\n",
48407a65f9dSConrad Meyer curr_set->freq);
4854577cf37SConrad Meyer goto out;
48607a65f9dSConrad Meyer }
4874577cf37SConrad Meyer } else if (curr_set->freq != CPUFREQ_VAL_UNKNOWN) {
4888d913481SNate Lawson CF_DEBUG("get returning known freq %d\n", curr_set->freq);
4894577cf37SConrad Meyer error = 0;
49073347b07SNate Lawson goto out;
4918d913481SNate Lawson }
492789f03ceSNate Lawson CF_MTX_UNLOCK(&sc->lock);
49373347b07SNate Lawson
49473347b07SNate Lawson /*
49573347b07SNate Lawson * We need to figure out the current level. Loop through every
49673347b07SNate Lawson * driver, getting the current setting. Then, attempt to get a best
49773347b07SNate Lawson * match of settings against each level.
49873347b07SNate Lawson */
49973347b07SNate Lawson count = CF_MAX_LEVELS;
500ac2fffa4SPedro F. Giffuni levels = malloc(count * sizeof(*levels), M_TEMP, M_NOWAIT);
50173347b07SNate Lawson if (levels == NULL)
50273347b07SNate Lawson return (ENOMEM);
50373347b07SNate Lawson error = CPUFREQ_LEVELS(sc->dev, levels, &count);
504d269386aSNate Lawson if (error) {
505d269386aSNate Lawson if (error == E2BIG)
506d269386aSNate Lawson printf("cpufreq: need to increase CF_MAX_LEVELS\n");
507789f03ceSNate Lawson free(levels, M_TEMP);
508789f03ceSNate Lawson return (error);
509d269386aSNate Lawson }
510789f03ceSNate Lawson
511789f03ceSNate Lawson /*
512789f03ceSNate Lawson * Reacquire the lock and search for the given level.
513789f03ceSNate Lawson *
514789f03ceSNate Lawson * XXX Note: this is not quite right since we really need to go
515789f03ceSNate Lawson * through each level and compare both absolute and relative
516789f03ceSNate Lawson * settings for each driver in the system before making a match.
517789f03ceSNate Lawson * The estimation code below catches this case though.
518789f03ceSNate Lawson */
519789f03ceSNate Lawson CF_MTX_LOCK(&sc->lock);
5204577cf37SConrad Meyer i = cpufreq_get_level(sc->cf_drv_dev, levels, count);
5214577cf37SConrad Meyer if (i >= 0)
52273347b07SNate Lawson sc->curr_level = levels[i];
5234577cf37SConrad Meyer else
5244577cf37SConrad Meyer CF_DEBUG("Couldn't find supported level for %s\n",
5254577cf37SConrad Meyer device_get_nameunit(sc->cf_drv_dev));
5264577cf37SConrad Meyer
5278d913481SNate Lawson if (curr_set->freq != CPUFREQ_VAL_UNKNOWN) {
5288d913481SNate Lawson CF_DEBUG("get matched freq %d from drivers\n", curr_set->freq);
52973347b07SNate Lawson goto out;
5308d913481SNate Lawson }
53173347b07SNate Lawson
53273347b07SNate Lawson /*
53373347b07SNate Lawson * We couldn't find an exact match, so attempt to estimate and then
53473347b07SNate Lawson * match against a level.
53573347b07SNate Lawson */
53673347b07SNate Lawson pc = cpu_get_pcpu(dev);
53773347b07SNate Lawson if (pc == NULL) {
53873347b07SNate Lawson error = ENXIO;
53973347b07SNate Lawson goto out;
54073347b07SNate Lawson }
54173347b07SNate Lawson cpu_est_clockrate(pc->pc_cpuid, &rate);
54273347b07SNate Lawson rate /= 1000000;
543760f4decSColin Percival bdiff = 1 << 30;
54473347b07SNate Lawson for (i = 0; i < count; i++) {
545760f4decSColin Percival diff = abs(levels[i].total_set.freq - rate);
546760f4decSColin Percival if (diff < bdiff) {
547760f4decSColin Percival bdiff = diff;
54873347b07SNate Lawson sc->curr_level = levels[i];
549760f4decSColin Percival }
550760f4decSColin Percival }
5518d913481SNate Lawson CF_DEBUG("get estimated freq %d\n", curr_set->freq);
55273347b07SNate Lawson
55373347b07SNate Lawson out:
554789f03ceSNate Lawson if (error == 0)
555789f03ceSNate Lawson *level = sc->curr_level;
556789f03ceSNate Lawson
557789f03ceSNate Lawson CF_MTX_UNLOCK(&sc->lock);
55873347b07SNate Lawson if (levels)
55973347b07SNate Lawson free(levels, M_TEMP);
560789f03ceSNate Lawson return (error);
56173347b07SNate Lawson }
56273347b07SNate Lawson
5634577cf37SConrad Meyer /*
5644577cf37SConrad Meyer * Either directly obtain settings from the cpufreq driver, or build a list of
5654577cf37SConrad Meyer * relative settings to be integrated later against an absolute max.
5664577cf37SConrad Meyer */
56773347b07SNate Lawson static int
cpufreq_add_levels(device_t cf_dev,struct cf_setting_lst * rel_sets)5684577cf37SConrad Meyer cpufreq_add_levels(device_t cf_dev, struct cf_setting_lst *rel_sets)
56973347b07SNate Lawson {
57088c9b54cSNate Lawson struct cf_setting_array *set_arr;
57173347b07SNate Lawson struct cf_setting *sets;
5724577cf37SConrad Meyer device_t dev;
5734577cf37SConrad Meyer struct cpufreq_softc *sc;
5744577cf37SConrad Meyer int type, set_count, error;
57573347b07SNate Lawson
5764577cf37SConrad Meyer sc = device_get_softc(cf_dev);
5774577cf37SConrad Meyer dev = sc->cf_drv_dev;
57873347b07SNate Lawson
579e22cd41cSNate Lawson /* Skip devices that aren't ready. */
5804577cf37SConrad Meyer if (!device_is_attached(cf_dev))
5814577cf37SConrad Meyer return (0);
582e22cd41cSNate Lawson
583e22cd41cSNate Lawson /*
584e22cd41cSNate Lawson * Get settings, skipping drivers that offer no settings or
585e22cd41cSNate Lawson * provide settings for informational purposes only.
586e22cd41cSNate Lawson */
5874577cf37SConrad Meyer error = CPUFREQ_DRV_TYPE(dev, &type);
5884577cf37SConrad Meyer if (error != 0 || (type & CPUFREQ_FLAG_INFO_ONLY)) {
5898d913481SNate Lawson if (error == 0) {
5908d913481SNate Lawson CF_DEBUG("skipping info-only driver %s\n",
5914577cf37SConrad Meyer device_get_nameunit(cf_dev));
5928d913481SNate Lawson }
5934577cf37SConrad Meyer return (error);
5948d913481SNate Lawson }
5954577cf37SConrad Meyer
5964577cf37SConrad Meyer sets = malloc(MAX_SETTINGS * sizeof(*sets), M_TEMP, M_NOWAIT);
5974577cf37SConrad Meyer if (sets == NULL)
5984577cf37SConrad Meyer return (ENOMEM);
5994577cf37SConrad Meyer
60073347b07SNate Lawson set_count = MAX_SETTINGS;
6014577cf37SConrad Meyer error = CPUFREQ_DRV_SETTINGS(dev, sets, &set_count);
6024577cf37SConrad Meyer if (error != 0 || set_count == 0)
6034577cf37SConrad Meyer goto out;
60473347b07SNate Lawson
605e22cd41cSNate Lawson /* Add the settings to our absolute/relative lists. */
6060325089dSNate Lawson switch (type & CPUFREQ_TYPE_MASK) {
60788c9b54cSNate Lawson case CPUFREQ_TYPE_ABSOLUTE:
60888c9b54cSNate Lawson error = cpufreq_insert_abs(sc, sets, set_count);
60988c9b54cSNate Lawson break;
61088c9b54cSNate Lawson case CPUFREQ_TYPE_RELATIVE:
6118d913481SNate Lawson CF_DEBUG("adding %d relative settings\n", set_count);
61288c9b54cSNate Lawson set_arr = malloc(sizeof(*set_arr), M_TEMP, M_NOWAIT);
61388c9b54cSNate Lawson if (set_arr == NULL) {
61488c9b54cSNate Lawson error = ENOMEM;
61588c9b54cSNate Lawson goto out;
61688c9b54cSNate Lawson }
61788c9b54cSNate Lawson bcopy(sets, set_arr->sets, set_count * sizeof(*sets));
61888c9b54cSNate Lawson set_arr->count = set_count;
6194577cf37SConrad Meyer TAILQ_INSERT_TAIL(rel_sets, set_arr, link);
62088c9b54cSNate Lawson break;
62188c9b54cSNate Lawson default:
62288c9b54cSNate Lawson error = EINVAL;
62388c9b54cSNate Lawson }
6244577cf37SConrad Meyer
6254577cf37SConrad Meyer out:
6264577cf37SConrad Meyer free(sets, M_TEMP);
6274577cf37SConrad Meyer return (error);
6284577cf37SConrad Meyer }
6294577cf37SConrad Meyer
6304577cf37SConrad Meyer static int
cf_levels_method(device_t dev,struct cf_level * levels,int * count)6314577cf37SConrad Meyer cf_levels_method(device_t dev, struct cf_level *levels, int *count)
6324577cf37SConrad Meyer {
6334577cf37SConrad Meyer struct cf_setting_array *set_arr;
6344577cf37SConrad Meyer struct cf_setting_lst rel_sets;
6354577cf37SConrad Meyer struct cpufreq_softc *sc;
6364577cf37SConrad Meyer struct cf_level *lev;
6374577cf37SConrad Meyer struct pcpu *pc;
6384577cf37SConrad Meyer int error, i;
6394577cf37SConrad Meyer uint64_t rate;
6404577cf37SConrad Meyer
6414577cf37SConrad Meyer if (levels == NULL || count == NULL)
6424577cf37SConrad Meyer return (EINVAL);
6434577cf37SConrad Meyer
6444577cf37SConrad Meyer TAILQ_INIT(&rel_sets);
6454577cf37SConrad Meyer sc = device_get_softc(dev);
6464577cf37SConrad Meyer
6474577cf37SConrad Meyer CF_MTX_LOCK(&sc->lock);
6484577cf37SConrad Meyer error = cpufreq_add_levels(sc->dev, &rel_sets);
64988c9b54cSNate Lawson if (error)
65073347b07SNate Lawson goto out;
65173347b07SNate Lawson
65267c8649fSNate Lawson /*
65367c8649fSNate Lawson * If there are no absolute levels, create a fake one at 100%. We
65467c8649fSNate Lawson * then cache the clockrate for later use as our base frequency.
65567c8649fSNate Lawson */
65673347b07SNate Lawson if (TAILQ_EMPTY(&sc->all_levels)) {
6574577cf37SConrad Meyer struct cf_setting set;
6584577cf37SConrad Meyer
6594577cf37SConrad Meyer CF_DEBUG("No absolute levels returned by driver\n");
6604577cf37SConrad Meyer
66167c8649fSNate Lawson if (sc->max_mhz == CPUFREQ_VAL_UNKNOWN) {
662f436f175SNathan Whitehorn sc->max_mhz = cpu_get_nominal_mhz(dev);
663f436f175SNathan Whitehorn /*
664f436f175SNathan Whitehorn * If the CPU can't report a rate for 100%, hope
665f436f175SNathan Whitehorn * the CPU is running at its nominal rate right now,
666f436f175SNathan Whitehorn * and use that instead.
667f436f175SNathan Whitehorn */
668f436f175SNathan Whitehorn if (sc->max_mhz <= 0) {
66973347b07SNate Lawson pc = cpu_get_pcpu(dev);
67073347b07SNate Lawson cpu_est_clockrate(pc->pc_cpuid, &rate);
67167c8649fSNate Lawson sc->max_mhz = rate / 1000000;
67267c8649fSNate Lawson }
673f436f175SNathan Whitehorn }
6744577cf37SConrad Meyer memset(&set, CPUFREQ_VAL_UNKNOWN, sizeof(set));
6754577cf37SConrad Meyer set.freq = sc->max_mhz;
6764577cf37SConrad Meyer set.dev = NULL;
6774577cf37SConrad Meyer error = cpufreq_insert_abs(sc, &set, 1);
67873347b07SNate Lawson if (error)
67973347b07SNate Lawson goto out;
68073347b07SNate Lawson }
68173347b07SNate Lawson
68288c9b54cSNate Lawson /* Create a combined list of absolute + relative levels. */
68388c9b54cSNate Lawson TAILQ_FOREACH(set_arr, &rel_sets, link)
68488c9b54cSNate Lawson cpufreq_expand_set(sc, set_arr);
68588c9b54cSNate Lawson
68688c9b54cSNate Lawson /* If the caller doesn't have enough space, return the actual count. */
68788c9b54cSNate Lawson if (sc->all_count > *count) {
68888c9b54cSNate Lawson *count = sc->all_count;
68988c9b54cSNate Lawson error = E2BIG;
69088c9b54cSNate Lawson goto out;
69188c9b54cSNate Lawson }
69288c9b54cSNate Lawson
69388c9b54cSNate Lawson /* Finally, output the list of levels. */
69473347b07SNate Lawson i = 0;
69573347b07SNate Lawson TAILQ_FOREACH(lev, &sc->all_levels, link) {
696b070969bSNate Lawson /* Skip levels that have a frequency that is too low. */
697da8a77c1SNate Lawson if (lev->total_set.freq < cf_lowest_freq) {
698b070969bSNate Lawson sc->all_count--;
699b070969bSNate Lawson continue;
700b070969bSNate Lawson }
701b070969bSNate Lawson
70273347b07SNate Lawson levels[i] = *lev;
70373347b07SNate Lawson i++;
70473347b07SNate Lawson }
70588c9b54cSNate Lawson *count = sc->all_count;
70673347b07SNate Lawson error = 0;
70773347b07SNate Lawson
70873347b07SNate Lawson out:
70973347b07SNate Lawson /* Clear all levels since we regenerate them each time. */
71073347b07SNate Lawson while ((lev = TAILQ_FIRST(&sc->all_levels)) != NULL) {
71173347b07SNate Lawson TAILQ_REMOVE(&sc->all_levels, lev, link);
71273347b07SNate Lawson free(lev, M_TEMP);
71373347b07SNate Lawson }
714789f03ceSNate Lawson sc->all_count = 0;
715789f03ceSNate Lawson
716789f03ceSNate Lawson CF_MTX_UNLOCK(&sc->lock);
71788c9b54cSNate Lawson while ((set_arr = TAILQ_FIRST(&rel_sets)) != NULL) {
71888c9b54cSNate Lawson TAILQ_REMOVE(&rel_sets, set_arr, link);
71988c9b54cSNate Lawson free(set_arr, M_TEMP);
72088c9b54cSNate Lawson }
72173347b07SNate Lawson return (error);
72273347b07SNate Lawson }
72373347b07SNate Lawson
72473347b07SNate Lawson /*
72573347b07SNate Lawson * Create levels for an array of absolute settings and insert them in
72673347b07SNate Lawson * sorted order in the specified list.
72773347b07SNate Lawson */
72873347b07SNate Lawson static int
cpufreq_insert_abs(struct cpufreq_softc * sc,struct cf_setting * sets,int count)72988c9b54cSNate Lawson cpufreq_insert_abs(struct cpufreq_softc *sc, struct cf_setting *sets,
73073347b07SNate Lawson int count)
73173347b07SNate Lawson {
73288c9b54cSNate Lawson struct cf_level_lst *list;
73373347b07SNate Lawson struct cf_level *level, *search;
73432686761SEmmanuel Vadot int i, inserted;
73573347b07SNate Lawson
736789f03ceSNate Lawson CF_MTX_ASSERT(&sc->lock);
737789f03ceSNate Lawson
73888c9b54cSNate Lawson list = &sc->all_levels;
73973347b07SNate Lawson for (i = 0; i < count; i++) {
74073347b07SNate Lawson level = malloc(sizeof(*level), M_TEMP, M_NOWAIT | M_ZERO);
74173347b07SNate Lawson if (level == NULL)
74273347b07SNate Lawson return (ENOMEM);
74373347b07SNate Lawson level->abs_set = sets[i];
74488c9b54cSNate Lawson level->total_set = sets[i];
74588c9b54cSNate Lawson level->total_set.dev = NULL;
74688c9b54cSNate Lawson sc->all_count++;
74732686761SEmmanuel Vadot inserted = 0;
74873347b07SNate Lawson
74973347b07SNate Lawson if (TAILQ_EMPTY(list)) {
7508d913481SNate Lawson CF_DEBUG("adding abs setting %d at head\n",
7518d913481SNate Lawson sets[i].freq);
75273347b07SNate Lawson TAILQ_INSERT_HEAD(list, level, link);
75373347b07SNate Lawson continue;
75473347b07SNate Lawson }
75573347b07SNate Lawson
75632686761SEmmanuel Vadot TAILQ_FOREACH_REVERSE(search, list, cf_level_lst, link)
75788c9b54cSNate Lawson if (sets[i].freq <= search->total_set.freq) {
7588d913481SNate Lawson CF_DEBUG("adding abs setting %d after %d\n",
7598d913481SNate Lawson sets[i].freq, search->total_set.freq);
76073347b07SNate Lawson TAILQ_INSERT_AFTER(list, search, level, link);
76132686761SEmmanuel Vadot inserted = 1;
76232686761SEmmanuel Vadot break;
76332686761SEmmanuel Vadot }
76432686761SEmmanuel Vadot
76532686761SEmmanuel Vadot if (inserted == 0) {
76632686761SEmmanuel Vadot TAILQ_FOREACH(search, list, link)
76732686761SEmmanuel Vadot if (sets[i].freq >= search->total_set.freq) {
76832686761SEmmanuel Vadot CF_DEBUG("adding abs setting %d before %d\n",
76932686761SEmmanuel Vadot sets[i].freq, search->total_set.freq);
77032686761SEmmanuel Vadot TAILQ_INSERT_BEFORE(search, level, link);
77173347b07SNate Lawson break;
77273347b07SNate Lawson }
77373347b07SNate Lawson }
77473347b07SNate Lawson }
77532686761SEmmanuel Vadot
77673347b07SNate Lawson return (0);
77773347b07SNate Lawson }
77873347b07SNate Lawson
77988c9b54cSNate Lawson /*
78088c9b54cSNate Lawson * Expand a group of relative settings, creating derived levels from them.
78188c9b54cSNate Lawson */
78288c9b54cSNate Lawson static int
cpufreq_expand_set(struct cpufreq_softc * sc,struct cf_setting_array * set_arr)78388c9b54cSNate Lawson cpufreq_expand_set(struct cpufreq_softc *sc, struct cf_setting_array *set_arr)
78488c9b54cSNate Lawson {
78588c9b54cSNate Lawson struct cf_level *fill, *search;
78688c9b54cSNate Lawson struct cf_setting *set;
78788c9b54cSNate Lawson int i;
78888c9b54cSNate Lawson
789789f03ceSNate Lawson CF_MTX_ASSERT(&sc->lock);
790789f03ceSNate Lawson
7915308b2a6SNate Lawson /*
7925308b2a6SNate Lawson * Walk the set of all existing levels in reverse. This is so we
7935308b2a6SNate Lawson * create derived states from the lowest absolute settings first
7945308b2a6SNate Lawson * and discard duplicates created from higher absolute settings.
7955308b2a6SNate Lawson * For instance, a level of 50 Mhz derived from 100 Mhz + 50% is
7965308b2a6SNate Lawson * preferable to 200 Mhz + 25% because absolute settings are more
7975308b2a6SNate Lawson * efficient since they often change the voltage as well.
7985308b2a6SNate Lawson */
7995308b2a6SNate Lawson TAILQ_FOREACH_REVERSE(search, &sc->all_levels, cf_level_lst, link) {
80088c9b54cSNate Lawson /* Add each setting to the level, duplicating if necessary. */
80188c9b54cSNate Lawson for (i = 0; i < set_arr->count; i++) {
80288c9b54cSNate Lawson set = &set_arr->sets[i];
80388c9b54cSNate Lawson
80488c9b54cSNate Lawson /*
80588c9b54cSNate Lawson * If this setting is less than 100%, split the level
80688c9b54cSNate Lawson * into two and add this setting to the new level.
80788c9b54cSNate Lawson */
80888c9b54cSNate Lawson fill = search;
8095308b2a6SNate Lawson if (set->freq < 10000) {
81088c9b54cSNate Lawson fill = cpufreq_dup_set(sc, search, set);
81188c9b54cSNate Lawson
81288c9b54cSNate Lawson /*
8135308b2a6SNate Lawson * The new level was a duplicate of an existing
8145308b2a6SNate Lawson * level or its absolute setting is too high
8155308b2a6SNate Lawson * so we freed it. For example, we discard a
8165308b2a6SNate Lawson * derived level of 1000 MHz/25% if a level
8175308b2a6SNate Lawson * of 500 MHz/100% already exists.
81888c9b54cSNate Lawson */
81988c9b54cSNate Lawson if (fill == NULL)
8205308b2a6SNate Lawson break;
8215308b2a6SNate Lawson }
82288c9b54cSNate Lawson
82388c9b54cSNate Lawson /* Add this setting to the existing or new level. */
82488c9b54cSNate Lawson KASSERT(fill->rel_count < MAX_SETTINGS,
82588c9b54cSNate Lawson ("cpufreq: too many relative drivers (%d)",
82688c9b54cSNate Lawson MAX_SETTINGS));
82788c9b54cSNate Lawson fill->rel_set[fill->rel_count] = *set;
82888c9b54cSNate Lawson fill->rel_count++;
8298d913481SNate Lawson CF_DEBUG(
8308d913481SNate Lawson "expand set added rel setting %d%% to %d level\n",
8318d913481SNate Lawson set->freq / 100, fill->total_set.freq);
83288c9b54cSNate Lawson }
83388c9b54cSNate Lawson }
83488c9b54cSNate Lawson
83588c9b54cSNate Lawson return (0);
83688c9b54cSNate Lawson }
83788c9b54cSNate Lawson
83888c9b54cSNate Lawson static struct cf_level *
cpufreq_dup_set(struct cpufreq_softc * sc,struct cf_level * dup,struct cf_setting * set)83988c9b54cSNate Lawson cpufreq_dup_set(struct cpufreq_softc *sc, struct cf_level *dup,
84088c9b54cSNate Lawson struct cf_setting *set)
84188c9b54cSNate Lawson {
84288c9b54cSNate Lawson struct cf_level_lst *list;
84388c9b54cSNate Lawson struct cf_level *fill, *itr;
84488c9b54cSNate Lawson struct cf_setting *fill_set, *itr_set;
84588c9b54cSNate Lawson int i;
84688c9b54cSNate Lawson
847789f03ceSNate Lawson CF_MTX_ASSERT(&sc->lock);
848789f03ceSNate Lawson
84988c9b54cSNate Lawson /*
85088c9b54cSNate Lawson * Create a new level, copy it from the old one, and update the
85188c9b54cSNate Lawson * total frequency and power by the percentage specified in the
85288c9b54cSNate Lawson * relative setting.
85388c9b54cSNate Lawson */
85488c9b54cSNate Lawson fill = malloc(sizeof(*fill), M_TEMP, M_NOWAIT);
85588c9b54cSNate Lawson if (fill == NULL)
85688c9b54cSNate Lawson return (NULL);
85788c9b54cSNate Lawson *fill = *dup;
85888c9b54cSNate Lawson fill_set = &fill->total_set;
85988c9b54cSNate Lawson fill_set->freq =
86088c9b54cSNate Lawson ((uint64_t)fill_set->freq * set->freq) / 10000;
86188c9b54cSNate Lawson if (fill_set->power != CPUFREQ_VAL_UNKNOWN) {
86288c9b54cSNate Lawson fill_set->power = ((uint64_t)fill_set->power * set->freq)
86388c9b54cSNate Lawson / 10000;
86488c9b54cSNate Lawson }
86588c9b54cSNate Lawson if (set->lat != CPUFREQ_VAL_UNKNOWN) {
86688c9b54cSNate Lawson if (fill_set->lat != CPUFREQ_VAL_UNKNOWN)
86788c9b54cSNate Lawson fill_set->lat += set->lat;
86888c9b54cSNate Lawson else
86988c9b54cSNate Lawson fill_set->lat = set->lat;
87088c9b54cSNate Lawson }
8718d913481SNate Lawson CF_DEBUG("dup set considering derived setting %d\n", fill_set->freq);
87288c9b54cSNate Lawson
87388c9b54cSNate Lawson /*
87488c9b54cSNate Lawson * If we copied an old level that we already modified (say, at 100%),
87588c9b54cSNate Lawson * we need to remove that setting before adding this one. Since we
87688c9b54cSNate Lawson * process each setting array in order, we know any settings for this
87788c9b54cSNate Lawson * driver will be found at the end.
87888c9b54cSNate Lawson */
87988c9b54cSNate Lawson for (i = fill->rel_count; i != 0; i--) {
88088c9b54cSNate Lawson if (fill->rel_set[i - 1].dev != set->dev)
88188c9b54cSNate Lawson break;
8828d913481SNate Lawson CF_DEBUG("removed last relative driver: %s\n",
8838d913481SNate Lawson device_get_nameunit(set->dev));
88488c9b54cSNate Lawson fill->rel_count--;
88588c9b54cSNate Lawson }
88688c9b54cSNate Lawson
88788c9b54cSNate Lawson /*
8885308b2a6SNate Lawson * Insert the new level in sorted order. If it is a duplicate of an
8895308b2a6SNate Lawson * existing level (1) or has an absolute setting higher than the
8905308b2a6SNate Lawson * existing level (2), do not add it. We can do this since any such
8915308b2a6SNate Lawson * level is guaranteed use less power. For example (1), a level with
8925308b2a6SNate Lawson * one absolute setting of 800 Mhz uses less power than one composed
8935308b2a6SNate Lawson * of an absolute setting of 1600 Mhz and a relative setting at 50%.
8945308b2a6SNate Lawson * Also for example (2), a level of 800 Mhz/75% is preferable to
8955308b2a6SNate Lawson * 1600 Mhz/25% even though the latter has a lower total frequency.
89688c9b54cSNate Lawson */
89788c9b54cSNate Lawson list = &sc->all_levels;
8985308b2a6SNate Lawson KASSERT(!TAILQ_EMPTY(list), ("all levels list empty in dup set"));
89988c9b54cSNate Lawson TAILQ_FOREACH_REVERSE(itr, list, cf_level_lst, link) {
90088c9b54cSNate Lawson itr_set = &itr->total_set;
9019000b91eSNate Lawson if (CPUFREQ_CMP(fill_set->freq, itr_set->freq)) {
9029000b91eSNate Lawson CF_DEBUG("dup set rejecting %d (dupe)\n",
9039000b91eSNate Lawson fill_set->freq);
9049000b91eSNate Lawson itr = NULL;
9059000b91eSNate Lawson break;
9069000b91eSNate Lawson } else if (fill_set->freq < itr_set->freq) {
9079000b91eSNate Lawson if (fill->abs_set.freq <= itr->abs_set.freq) {
9088d913481SNate Lawson CF_DEBUG(
9098d913481SNate Lawson "dup done, inserting new level %d after %d\n",
9108d913481SNate Lawson fill_set->freq, itr_set->freq);
91188c9b54cSNate Lawson TAILQ_INSERT_AFTER(list, itr, fill, link);
91288c9b54cSNate Lawson sc->all_count++;
9139000b91eSNate Lawson } else {
9149000b91eSNate Lawson CF_DEBUG("dup set rejecting %d (abs too big)\n",
9159000b91eSNate Lawson fill_set->freq);
9169000b91eSNate Lawson itr = NULL;
9179000b91eSNate Lawson }
91888c9b54cSNate Lawson break;
91988c9b54cSNate Lawson }
92088c9b54cSNate Lawson }
9215308b2a6SNate Lawson
9225308b2a6SNate Lawson /* We didn't find a good place for this new level so free it. */
9235308b2a6SNate Lawson if (itr == NULL) {
9245308b2a6SNate Lawson CF_DEBUG("dup set freeing new level %d (not optimal)\n",
9255308b2a6SNate Lawson fill_set->freq);
9265308b2a6SNate Lawson free(fill, M_TEMP);
9275308b2a6SNate Lawson fill = NULL;
92888c9b54cSNate Lawson }
92988c9b54cSNate Lawson
93088c9b54cSNate Lawson return (fill);
93188c9b54cSNate Lawson }
93288c9b54cSNate Lawson
93373347b07SNate Lawson static int
cpufreq_curr_sysctl(SYSCTL_HANDLER_ARGS)93473347b07SNate Lawson cpufreq_curr_sysctl(SYSCTL_HANDLER_ARGS)
93573347b07SNate Lawson {
93673347b07SNate Lawson struct cpufreq_softc *sc;
93773347b07SNate Lawson struct cf_level *levels;
9385f3818a5SAlexander Motin int best, count, diff, bdiff, devcount, error, freq, i, n;
9390325089dSNate Lawson device_t *devs;
94073347b07SNate Lawson
9410325089dSNate Lawson devs = NULL;
94273347b07SNate Lawson sc = oidp->oid_arg1;
943dac50931SAndriy Gapon levels = sc->levels_buf;
94473347b07SNate Lawson
94573347b07SNate Lawson error = CPUFREQ_GET(sc->dev, &levels[0]);
94673347b07SNate Lawson if (error)
94773347b07SNate Lawson goto out;
94873347b07SNate Lawson freq = levels[0].total_set.freq;
94973347b07SNate Lawson error = sysctl_handle_int(oidp, &freq, 0, req);
95073347b07SNate Lawson if (error != 0 || req->newptr == NULL)
95173347b07SNate Lawson goto out;
95273347b07SNate Lawson
9530325089dSNate Lawson /*
9540325089dSNate Lawson * While we only call cpufreq_get() on one device (assuming all
9550325089dSNate Lawson * CPUs have equal levels), we call cpufreq_set() on all CPUs.
9560325089dSNate Lawson * This is needed for some MP systems.
9570325089dSNate Lawson */
9583d7e90fcSJohn Baldwin error = devclass_get_devices(devclass_find("cpufreq"), &devs, &devcount);
95973347b07SNate Lawson if (error)
96073347b07SNate Lawson goto out;
9610325089dSNate Lawson for (n = 0; n < devcount; n++) {
9620325089dSNate Lawson count = CF_MAX_LEVELS;
9630325089dSNate Lawson error = CPUFREQ_LEVELS(devs[n], levels, &count);
964d269386aSNate Lawson if (error) {
965d269386aSNate Lawson if (error == E2BIG)
966d269386aSNate Lawson printf(
967d269386aSNate Lawson "cpufreq: need to increase CF_MAX_LEVELS\n");
9680325089dSNate Lawson break;
969d269386aSNate Lawson }
9705f3818a5SAlexander Motin best = 0;
9715f3818a5SAlexander Motin bdiff = 1 << 30;
97273347b07SNate Lawson for (i = 0; i < count; i++) {
9735f3818a5SAlexander Motin diff = abs(levels[i].total_set.freq - freq);
9745f3818a5SAlexander Motin if (diff < bdiff) {
9755f3818a5SAlexander Motin bdiff = diff;
9765f3818a5SAlexander Motin best = i;
97773347b07SNate Lawson }
97873347b07SNate Lawson }
9795f3818a5SAlexander Motin error = CPUFREQ_SET(devs[n], &levels[best], CPUFREQ_PRIO_USER);
9800325089dSNate Lawson }
98173347b07SNate Lawson
98273347b07SNate Lawson out:
9830325089dSNate Lawson if (devs)
9840325089dSNate Lawson free(devs, M_TEMP);
98573347b07SNate Lawson return (error);
98673347b07SNate Lawson }
98773347b07SNate Lawson
98873347b07SNate Lawson static int
cpufreq_levels_sysctl(SYSCTL_HANDLER_ARGS)98973347b07SNate Lawson cpufreq_levels_sysctl(SYSCTL_HANDLER_ARGS)
99073347b07SNate Lawson {
99173347b07SNate Lawson struct cpufreq_softc *sc;
99273347b07SNate Lawson struct cf_level *levels;
99373347b07SNate Lawson struct cf_setting *set;
99473347b07SNate Lawson struct sbuf sb;
99573347b07SNate Lawson int count, error, i;
99673347b07SNate Lawson
99773347b07SNate Lawson sc = oidp->oid_arg1;
99873347b07SNate Lawson sbuf_new(&sb, NULL, 128, SBUF_AUTOEXTEND);
99973347b07SNate Lawson
100073347b07SNate Lawson /* Get settings from the device and generate the output string. */
100173347b07SNate Lawson count = CF_MAX_LEVELS;
1002dac50931SAndriy Gapon levels = sc->levels_buf;
100330215f48SChristian Brueffer if (levels == NULL) {
100430215f48SChristian Brueffer sbuf_delete(&sb);
100573347b07SNate Lawson return (ENOMEM);
100630215f48SChristian Brueffer }
100773347b07SNate Lawson error = CPUFREQ_LEVELS(sc->dev, levels, &count);
1008d269386aSNate Lawson if (error) {
1009d269386aSNate Lawson if (error == E2BIG)
1010d269386aSNate Lawson printf("cpufreq: need to increase CF_MAX_LEVELS\n");
101173347b07SNate Lawson goto out;
1012d269386aSNate Lawson }
101373347b07SNate Lawson if (count) {
101473347b07SNate Lawson for (i = 0; i < count; i++) {
101573347b07SNate Lawson set = &levels[i].total_set;
101673347b07SNate Lawson sbuf_printf(&sb, "%d/%d ", set->freq, set->power);
101773347b07SNate Lawson }
101873347b07SNate Lawson } else
101973347b07SNate Lawson sbuf_cpy(&sb, "0");
102073347b07SNate Lawson sbuf_trim(&sb);
102173347b07SNate Lawson sbuf_finish(&sb);
102273347b07SNate Lawson error = sysctl_handle_string(oidp, sbuf_data(&sb), sbuf_len(&sb), req);
102373347b07SNate Lawson
102473347b07SNate Lawson out:
102573347b07SNate Lawson sbuf_delete(&sb);
102673347b07SNate Lawson return (error);
102773347b07SNate Lawson }
102873347b07SNate Lawson
1029e959a70bSNate Lawson static int
cpufreq_settings_sysctl(SYSCTL_HANDLER_ARGS)1030e959a70bSNate Lawson cpufreq_settings_sysctl(SYSCTL_HANDLER_ARGS)
1031e959a70bSNate Lawson {
1032e959a70bSNate Lawson device_t dev;
1033e959a70bSNate Lawson struct cf_setting *sets;
1034e959a70bSNate Lawson struct sbuf sb;
1035e959a70bSNate Lawson int error, i, set_count;
1036e959a70bSNate Lawson
1037e959a70bSNate Lawson dev = oidp->oid_arg1;
1038e959a70bSNate Lawson sbuf_new(&sb, NULL, 128, SBUF_AUTOEXTEND);
1039e959a70bSNate Lawson
1040e959a70bSNate Lawson /* Get settings from the device and generate the output string. */
1041e959a70bSNate Lawson set_count = MAX_SETTINGS;
1042ac2fffa4SPedro F. Giffuni sets = malloc(set_count * sizeof(*sets), M_TEMP, M_NOWAIT);
104330215f48SChristian Brueffer if (sets == NULL) {
104430215f48SChristian Brueffer sbuf_delete(&sb);
1045e959a70bSNate Lawson return (ENOMEM);
104630215f48SChristian Brueffer }
1047e959a70bSNate Lawson error = CPUFREQ_DRV_SETTINGS(dev, sets, &set_count);
1048e959a70bSNate Lawson if (error)
1049e959a70bSNate Lawson goto out;
1050e959a70bSNate Lawson if (set_count) {
1051e959a70bSNate Lawson for (i = 0; i < set_count; i++)
1052e959a70bSNate Lawson sbuf_printf(&sb, "%d/%d ", sets[i].freq, sets[i].power);
1053e959a70bSNate Lawson } else
1054e959a70bSNate Lawson sbuf_cpy(&sb, "0");
1055e959a70bSNate Lawson sbuf_trim(&sb);
1056e959a70bSNate Lawson sbuf_finish(&sb);
1057e959a70bSNate Lawson error = sysctl_handle_string(oidp, sbuf_data(&sb), sbuf_len(&sb), req);
1058e959a70bSNate Lawson
1059e959a70bSNate Lawson out:
1060e959a70bSNate Lawson free(sets, M_TEMP);
1061e959a70bSNate Lawson sbuf_delete(&sb);
1062e959a70bSNate Lawson return (error);
1063e959a70bSNate Lawson }
1064e959a70bSNate Lawson
10654577cf37SConrad Meyer static void
cpufreq_add_freq_driver_sysctl(device_t cf_dev)10664577cf37SConrad Meyer cpufreq_add_freq_driver_sysctl(device_t cf_dev)
10674577cf37SConrad Meyer {
10684577cf37SConrad Meyer struct cpufreq_softc *sc;
10694577cf37SConrad Meyer
10704577cf37SConrad Meyer sc = device_get_softc(cf_dev);
10714577cf37SConrad Meyer SYSCTL_ADD_CONST_STRING(&sc->sysctl_ctx,
10724577cf37SConrad Meyer SYSCTL_CHILDREN(device_get_sysctl_tree(cf_dev)), OID_AUTO,
10734577cf37SConrad Meyer "freq_driver", CTLFLAG_RD, device_get_nameunit(sc->cf_drv_dev),
10744577cf37SConrad Meyer "cpufreq driver used by this cpu");
10754577cf37SConrad Meyer }
10764577cf37SConrad Meyer
107773347b07SNate Lawson int
cpufreq_register(device_t dev)107873347b07SNate Lawson cpufreq_register(device_t dev)
107973347b07SNate Lawson {
108067c8649fSNate Lawson struct cpufreq_softc *sc;
108173347b07SNate Lawson device_t cf_dev, cpu_dev;
10824577cf37SConrad Meyer int error;
108373347b07SNate Lawson
1084e959a70bSNate Lawson /* Add a sysctl to get each driver's settings separately. */
1085e959a70bSNate Lawson SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
1086e959a70bSNate Lawson SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
10877029da5cSPawel Biernacki OID_AUTO, "freq_settings",
10887029da5cSPawel Biernacki CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, dev, 0,
1089e959a70bSNate Lawson cpufreq_settings_sysctl, "A", "CPU frequency driver settings");
1090e959a70bSNate Lawson
109173347b07SNate Lawson /*
10920325089dSNate Lawson * Add only one cpufreq device to each CPU. Currently, all CPUs
10930325089dSNate Lawson * must offer the same levels and be switched at the same time.
109473347b07SNate Lawson */
10950325089dSNate Lawson cpu_dev = device_get_parent(dev);
109667c8649fSNate Lawson if ((cf_dev = device_find_child(cpu_dev, "cpufreq", -1))) {
109767c8649fSNate Lawson sc = device_get_softc(cf_dev);
109867c8649fSNate Lawson sc->max_mhz = CPUFREQ_VAL_UNKNOWN;
10994577cf37SConrad Meyer MPASS(sc->cf_drv_dev != NULL);
110073347b07SNate Lawson return (0);
110167c8649fSNate Lawson }
110273347b07SNate Lawson
11030325089dSNate Lawson /* Add the child device and possibly sysctls. */
1104d3a8f98aSAlexander Motin cf_dev = BUS_ADD_CHILD(cpu_dev, 0, "cpufreq", device_get_unit(cpu_dev));
110573347b07SNate Lawson if (cf_dev == NULL)
110673347b07SNate Lawson return (ENOMEM);
110773347b07SNate Lawson device_quiet(cf_dev);
110873347b07SNate Lawson
11094577cf37SConrad Meyer error = device_probe_and_attach(cf_dev);
11104577cf37SConrad Meyer if (error)
11114577cf37SConrad Meyer return (error);
11124577cf37SConrad Meyer
11134577cf37SConrad Meyer sc = device_get_softc(cf_dev);
11144577cf37SConrad Meyer sc->cf_drv_dev = dev;
11154577cf37SConrad Meyer cpufreq_add_freq_driver_sysctl(cf_dev);
11164577cf37SConrad Meyer return (error);
111773347b07SNate Lawson }
111873347b07SNate Lawson
111973347b07SNate Lawson int
cpufreq_unregister(device_t dev)112073347b07SNate Lawson cpufreq_unregister(device_t dev)
112173347b07SNate Lawson {
11224577cf37SConrad Meyer device_t cf_dev;
112395d35d7aSScott Long struct cpufreq_softc *sc __diagused;
112473347b07SNate Lawson
112573347b07SNate Lawson /*
112673347b07SNate Lawson * If this is the last cpufreq child device, remove the control
112773347b07SNate Lawson * device as well. We identify cpufreq children by calling a method
112873347b07SNate Lawson * they support.
112973347b07SNate Lawson */
113067c8649fSNate Lawson cf_dev = device_find_child(device_get_parent(dev), "cpufreq", -1);
113171ab130cSNate Lawson if (cf_dev == NULL) {
113271ab130cSNate Lawson device_printf(dev,
113371ab130cSNate Lawson "warning: cpufreq_unregister called with no cpufreq device active\n");
113471ab130cSNate Lawson return (0);
113571ab130cSNate Lawson }
11364577cf37SConrad Meyer sc = device_get_softc(cf_dev);
11374577cf37SConrad Meyer MPASS(sc->cf_drv_dev == dev);
113873347b07SNate Lawson device_delete_child(device_get_parent(cf_dev), cf_dev);
113973347b07SNate Lawson
114073347b07SNate Lawson return (0);
114173347b07SNate Lawson }
11420d4ac62aSNate Lawson
11430d4ac62aSNate Lawson int
cpufreq_settings_changed(device_t dev)11440d4ac62aSNate Lawson cpufreq_settings_changed(device_t dev)
11450d4ac62aSNate Lawson {
11460d4ac62aSNate Lawson
11470d4ac62aSNate Lawson EVENTHANDLER_INVOKE(cpufreq_levels_changed,
11480d4ac62aSNate Lawson device_get_unit(device_get_parent(dev)));
11490d4ac62aSNate Lawson return (0);
11500d4ac62aSNate Lawson }
1151