/* $NetBSD: acpi_cppc.c,v 1.3 2025/01/31 12:29:19 jmcneill Exp $ */

/*-
* Copyright (c) 2020 Jared McNeill <[email protected]>
* 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
*/

/*
* ACPI Collaborative Processor Performance Control support.
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: acpi_cppc.c,v 1.3 2025/01/31 12:29:19 jmcneill Exp $");

#include <sys/param.h>
#include <sys/bus.h>
#include <sys/cpu.h>
#include <sys/device.h>
#include <sys/kmem.h>
#include <sys/sysctl.h>

#include <dev/acpi/acpireg.h>
#include <dev/acpi/acpivar.h>
#include <dev/acpi/acpi_pcc.h>

#include <external/bsd/acpica/dist/include/amlresrc.h>

/* _CPC package elements */
typedef enum CPCPackageElement {
       CPCNumEntries,
       CPCRevision,
       CPCHighestPerformance,
       CPCNominalPerformance,
       CPCLowestNonlinearPerformance,
       CPCLowestPerformance,
       CPCGuaranteedPerformanceReg,
       CPCDesiredPerformanceReg,
       CPCMinimumPerformanceReg,
       CPCMaximumPerformanceReg,
       CPCPerformanceReductionToleranceReg,
       CPCTimeWindowReg,
       CPCCounterWraparoundTime,
       CPCReferencePerformanceCounterReg,
       CPCDeliveredPerformanceCounterReg,
       CPCPerformanceLimitedReg,
       CPCCPPCEnableReg,
       CPCAutonomousSelectionEnable,
       CPCAutonomousActivityWindowReg,
       CPCEnergyPerformancePreferenceReg,
       CPCReferencePerformance,
       CPCLowestFrequency,
       CPCNominalFrequency,
} CPCPackageElement;

/* PCC command numbers */
#define CPPC_PCC_READ   0x00
#define CPPC_PCC_WRITE  0x01

struct cppc_softc {
       device_t                sc_dev;
       struct cpu_info *       sc_cpuinfo;
       ACPI_HANDLE             sc_handle;
       ACPI_OBJECT *           sc_cpc;
       u_int                   sc_ncpc;

       char *                  sc_available;
       int                     sc_node_target;
       int                     sc_node_current;
       ACPI_INTEGER            sc_max_target;
       ACPI_INTEGER            sc_min_target;
       u_int                   sc_freq_range;
       u_int                   sc_perf_range;
};

static int              cppc_match(device_t, cfdata_t, void *);
static void             cppc_attach(device_t, device_t, void *);

static ACPI_STATUS      cppc_parse_cpc(struct cppc_softc *);
static ACPI_STATUS      cppc_cpufreq_init(struct cppc_softc *);
static ACPI_STATUS      cppc_read(struct cppc_softc *, CPCPackageElement,
                                 ACPI_INTEGER *);
static ACPI_STATUS      cppc_write(struct cppc_softc *, CPCPackageElement,
                                  ACPI_INTEGER);

CFATTACH_DECL_NEW(acpicppc, sizeof(struct cppc_softc),
   cppc_match, cppc_attach, NULL, NULL);

static const struct device_compatible_entry compat_data[] = {
       { .compat = "ACPI0007" },       /* ACPI Processor Device */
       DEVICE_COMPAT_EOL
};

static int
cppc_match(device_t parent, cfdata_t cf, void *aux)
{
       struct acpi_attach_args * const aa = aux;
       ACPI_HANDLE handle;
       ACPI_STATUS rv;

       if (acpi_compatible_match(aa, compat_data) == 0)
               return 0;

       rv = AcpiGetHandle(aa->aa_node->ad_handle, "_CPC", &handle);
       if (ACPI_FAILURE(rv)) {
               return 0;
       }

       if (acpi_match_cpu_handle(aa->aa_node->ad_handle) == NULL) {
               return 0;
       }

       /* When CPPC and P-states/T-states are both available, prefer CPPC */
       return ACPI_MATCHSCORE_CID_MAX + 1;
}

static void
cppc_attach(device_t parent, device_t self, void *aux)
{
       struct cppc_softc * const sc = device_private(self);
       struct acpi_attach_args * const aa = aux;
       ACPI_HANDLE handle = aa->aa_node->ad_handle;
       struct cpu_info *ci;
       ACPI_STATUS rv;

       ci = acpi_match_cpu_handle(handle);
       KASSERT(ci != NULL);

       aprint_naive("\n");
       aprint_normal(": Processor Performance Control (%s)\n", cpu_name(ci));

       sc->sc_dev = self;
       sc->sc_cpuinfo = ci;
       sc->sc_handle = handle;

       rv = cppc_parse_cpc(sc);
       if (ACPI_FAILURE(rv)) {
               aprint_error_dev(self, "failed to parse CPC package: %s\n",
                   AcpiFormatException(rv));
               return;
       }

       cppc_cpufreq_init(sc);
}

/*
* cppc_parse_cpc --
*
*      Read and verify the contents of the _CPC package.
*/
static ACPI_STATUS
cppc_parse_cpc(struct cppc_softc *sc)
{
       ACPI_BUFFER buf;
       ACPI_STATUS rv;

       buf.Pointer = NULL;
       buf.Length = ACPI_ALLOCATE_BUFFER;
       rv = AcpiEvaluateObjectTyped(sc->sc_handle, "_CPC", NULL, &buf,
           ACPI_TYPE_PACKAGE);
       if (ACPI_FAILURE(rv)) {
               return rv;
       }

       sc->sc_cpc = (ACPI_OBJECT *)buf.Pointer;
       if (sc->sc_cpc->Package.Count == 0) {
               return AE_NOT_EXIST;
       }
       if (sc->sc_cpc->Package.Elements[CPCNumEntries].Type !=
           ACPI_TYPE_INTEGER) {
               return AE_TYPE;
       }
       sc->sc_ncpc =
           sc->sc_cpc->Package.Elements[CPCNumEntries].Integer.Value;

       return AE_OK;
}

/*
* cppc_perf_to_freq, cppc_freq_to_perf --
*
*      Convert between abstract performance values and CPU frequencies,
*      when possible.
*/
static ACPI_INTEGER
cppc_perf_to_freq(struct cppc_softc *sc, ACPI_INTEGER perf)
{
       return howmany(perf * sc->sc_freq_range, sc->sc_perf_range);
}
static ACPI_INTEGER
cppc_freq_to_perf(struct cppc_softc *sc, ACPI_INTEGER freq)
{
       return howmany(freq * sc->sc_perf_range, sc->sc_freq_range);
}

/*
* cppc_cpufreq_sysctl --
*
*      sysctl helper function for machdep.cpu.cpuN.{target,current}
*      nodes.
*/
static int
cppc_cpufreq_sysctl(SYSCTLFN_ARGS)
{
       struct cppc_softc * const sc = rnode->sysctl_data;
       struct sysctlnode node;
       u_int fq, oldfq = 0;
       ACPI_INTEGER val;
       ACPI_STATUS rv;
       int error;

       node = *rnode;
       node.sysctl_data = &fq;

       if (rnode->sysctl_num == sc->sc_node_target) {
               rv = cppc_read(sc, CPCDesiredPerformanceReg, &val);
       } else {
               /*
                * XXX We should measure the delivered performance and
                *     report it here. For now, just report the desired
                *     performance level.
                */
               rv = cppc_read(sc, CPCDesiredPerformanceReg, &val);
       }
       if (ACPI_FAILURE(rv)) {
               return EIO;
       }
       if (val > UINT32_MAX) {
               return ERANGE;
       }
       fq = (u_int)cppc_perf_to_freq(sc, val);

       if (rnode->sysctl_num == sc->sc_node_target) {
               oldfq = fq;
       }

       error = sysctl_lookup(SYSCTLFN_CALL(&node));
       if (error != 0 || newp == NULL) {
               return error;
       }

       if (fq == oldfq || rnode->sysctl_num != sc->sc_node_target) {
               return 0;
       }

       if (fq < sc->sc_min_target || fq > sc->sc_max_target) {
               return EINVAL;
       }

       rv = cppc_write(sc, CPCDesiredPerformanceReg,
           cppc_freq_to_perf(sc, fq));
       if (ACPI_FAILURE(rv)) {
               return EIO;
       }

       return 0;
}

/*
* cppc_cpufreq_init --
*
*      Create sysctl machdep.cpu.cpuN.* sysctl tree.
*/
static ACPI_STATUS
cppc_cpufreq_init(struct cppc_softc *sc)
{
       static CPCPackageElement perf_regs[4] = {
               CPCHighestPerformance,
               CPCNominalPerformance,
               CPCLowestNonlinearPerformance,
               CPCLowestPerformance
       };
       ACPI_INTEGER perf[4], min_freq = 0, nom_freq = 0, last;
       const struct sysctlnode *node, *cpunode;
       struct sysctllog *log = NULL;
       struct cpu_info *ci = sc->sc_cpuinfo;
       ACPI_STATUS rv;
       int error, i, n;

       /*
        * Read optional nominal and lowest frequencies. These are used,
        * when present, to scale units for display in the sysctl interface.
        */
       cppc_read(sc, CPCLowestFrequency, &min_freq);
       cppc_read(sc, CPCNominalFrequency, &nom_freq);
       /*
        * Read highest, nominal, lowest nonlinear, and lowest performance
        * levels.
        */
       for (i = 0, n = 0; i < __arraycount(perf_regs); i++) {
               rv = cppc_read(sc, perf_regs[i], &perf[i]);
               if (ACPI_FAILURE(rv)) {
                       return rv;
               }
       }
       if (min_freq && nom_freq) {
               sc->sc_freq_range = nom_freq - min_freq;
               sc->sc_perf_range = perf[1] - perf[3];
       } else {
               sc->sc_freq_range = 1;
               sc->sc_perf_range = 1;
       }

       /*
        * Build a list of performance levels for the
        * machdep.cpufreq.cpuN.available sysctl.
        */
       sc->sc_available = kmem_zalloc(
           strlen("########## ") * __arraycount(perf_regs), KM_SLEEP);
       last = 0;
       for (i = 0, n = 0; i < __arraycount(perf_regs); i++) {
               rv = cppc_read(sc, perf_regs[i], &perf[i]);
               if (ACPI_FAILURE(rv)) {
                       return rv;
               }
               if (perf[i] != last) {
                       char buf[12];
                       snprintf(buf, sizeof(buf), n ? " %u" : "%u",
                           (u_int)cppc_perf_to_freq(sc, perf[i]));
                       strcat(sc->sc_available, buf);
                       last = perf[i];
                       n++;
               }
       }
       sc->sc_max_target = cppc_perf_to_freq(sc, perf[0]);
       sc->sc_min_target = cppc_perf_to_freq(sc, perf[3]);

       error = sysctl_createv(&log, 0, NULL, &node,
           CTLFLAG_PERMANENT, CTLTYPE_NODE, "machdep", NULL,
           NULL, 0, NULL, 0, CTL_MACHDEP, CTL_EOL);
       if (error != 0) {
               goto sysctl_failed;
       }

       error = sysctl_createv(&log, 0, &node, &node,
           0, CTLTYPE_NODE, "cpufreq", NULL,
           NULL, 0, NULL, 0, CTL_CREATE, CTL_EOL);
       if (error != 0) {
               goto sysctl_failed;
       }

       error = sysctl_createv(&log, 0, &node, &cpunode,
           0, CTLTYPE_NODE, cpu_name(ci), NULL,
           NULL, 0, NULL, 0, CTL_CREATE, CTL_EOL);
       if (error != 0) {
               goto sysctl_failed;
       }

       error = sysctl_createv(&log, 0, &cpunode, &node,
           CTLFLAG_READWRITE, CTLTYPE_INT, "target", NULL,
           cppc_cpufreq_sysctl, 0, (void *)sc, 0,
           CTL_CREATE, CTL_EOL);
       if (error != 0) {
               goto sysctl_failed;
       }
       sc->sc_node_target = node->sysctl_num;

       error = sysctl_createv(&log, 0, &cpunode, &node,
           CTLFLAG_READONLY, CTLTYPE_INT, "current", NULL,
           cppc_cpufreq_sysctl, 0, (void *)sc, 0,
           CTL_CREATE, CTL_EOL);
       if (error != 0) {
               goto sysctl_failed;
       }
       sc->sc_node_current = node->sysctl_num;

       error = sysctl_createv(&log, 0, &cpunode, &node,
           CTLFLAG_READONLY, CTLTYPE_STRING, "available", NULL,
           NULL, 0, sc->sc_available, 0,
           CTL_CREATE, CTL_EOL);
       if (error != 0) {
               goto sysctl_failed;
       }

       return AE_OK;

sysctl_failed:
       aprint_error_dev(sc->sc_dev, "couldn't create sysctl nodes: %d\n",
           error);
       sysctl_teardown(&log);

       return AE_ERROR;
}

/*
* cppc_read --
*
*      Read a value from the CPC package that contains either an integer
*      or indirect register reference.
*/
static ACPI_STATUS
cppc_read(struct cppc_softc *sc, CPCPackageElement index, ACPI_INTEGER *val)
{
       ACPI_OBJECT *obj;
       ACPI_GENERIC_ADDRESS addr;
       ACPI_STATUS rv;

       if (index >= sc->sc_ncpc) {
               return AE_NOT_EXIST;
       }

       obj = &sc->sc_cpc->Package.Elements[index];
       switch (obj->Type) {
       case ACPI_TYPE_INTEGER:
               *val = obj->Integer.Value;
               return AE_OK;

       case ACPI_TYPE_BUFFER:
               if (obj->Buffer.Length <
                   sizeof(AML_RESOURCE_GENERIC_REGISTER)) {
                       return AE_TYPE;
               }
               memcpy(&addr, obj->Buffer.Pointer +
                   sizeof(AML_RESOURCE_LARGE_HEADER), sizeof(addr));
               if (addr.SpaceId == ACPI_ADR_SPACE_PLATFORM_COMM) {
                       rv = pcc_message(&addr, CPPC_PCC_READ, PCC_READ, val);
               } else {
                       rv = AcpiRead(val, &addr);
               }
               return rv;

       default:
               return AE_SUPPORT;
       }
}

/*
* cppc_write --
*
*      Write a value based on the CPC package to the specified register.
*/
static ACPI_STATUS
cppc_write(struct cppc_softc *sc, CPCPackageElement index, ACPI_INTEGER val)
{
       ACPI_OBJECT *obj;
       ACPI_GENERIC_ADDRESS addr;
       ACPI_STATUS rv;

       if (index >= sc->sc_ncpc) {
               return AE_NOT_EXIST;
       }

       obj = &sc->sc_cpc->Package.Elements[index];
       if (obj->Type != ACPI_TYPE_BUFFER ||
           obj->Buffer.Length < sizeof(AML_RESOURCE_GENERIC_REGISTER)) {
               return AE_TYPE;
       }

       memcpy(&addr, obj->Buffer.Pointer +
           sizeof(AML_RESOURCE_LARGE_HEADER), sizeof(addr));
       if (addr.SpaceId == ACPI_ADR_SPACE_PLATFORM_COMM) {
               rv = pcc_message(&addr, CPPC_PCC_WRITE, PCC_WRITE, &val);
       } else {
               rv = AcpiWrite(val, &addr);
       }

       return rv;
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.