freebsd/sys/dev/acpica/acpi_cpu.c

/*-
 * Copyright (c) 2001 Michael Smith
 * 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 "opt_acpi.h"
#include <sys/param.h>
#include <sys/kernel.h>
#include <sys/bus.h>
#include <sys/power.h>

#include <machine/bus_pio.h>
#include <machine/bus.h>
#include <machine/resource.h>
#include <sys/rman.h>

#include "acpi.h"
#include <dev/acpica/acpivar.h>

/*
 * Support for ACPI Processor devices.
 *
 * Note that this only provides ACPI 1.0 support (with the exception of the
 * PSTATE_CNT field).  2.0 support will involve implementing _PTC, _PCT,
 * _PSS and _PPC.
 */

/* Hooks for the ACPI CA debugging infrastructure */
#define _COMPONENT	ACPI_PROCESSOR
ACPI_MODULE_NAME("PROCESSOR")

struct acpi_cpu_softc {
    device_t		cpu_dev;
    ACPI_HANDLE		cpu_handle;

    u_int32_t		cpu_id;

    /* CPU throttling control register */
    struct resource	*cpu_p_blk;
#define CPU_P_CNT_THT_EN (1<<4)
};

#define CPU_GET_P_CNT(sc) 					\
    (bus_space_read_4(rman_get_bustag((sc)->cpu_p_blk), 	\
		      rman_get_bushandle((sc)->cpu_p_blk), 0))
#define CPU_SET_P_CNT(sc, val)					\
    (bus_space_write_4(rman_get_bustag((sc)->cpu_p_blk), 	\
		       rman_get_bushandle((sc)->cpu_p_blk), 0, (val)))

/* 
 * Speeds are stored in counts, from 1 - CPU_MAX_SPEED, and
 * reported to the user in tenths of a percent.
 */
static u_int32_t	cpu_duty_offset;
static u_int32_t	cpu_duty_width;
#define CPU_MAX_SPEED		(1 << cpu_duty_width)
#define CPU_SPEED_PERCENT(x)	((1000 * (x)) / CPU_MAX_SPEED)
#define CPU_SPEED_PRINTABLE(x)	(CPU_SPEED_PERCENT(x) / 10),(CPU_SPEED_PERCENT(x) % 10)

/* XXX Should be a generic way to do this */
static u_int32_t	cpu_smi_cmd;
static u_int8_t		cpu_pstate_cnt;

static u_int32_t	cpu_current_state;
static u_int32_t	cpu_performance_state;
static u_int32_t	cpu_economy_state;
static u_int32_t	cpu_max_state;

static device_t		*cpu_devices;
static int		cpu_ndevices;

static struct sysctl_ctx_list	acpi_cpu_sysctl_ctx;
static struct sysctl_oid	*acpi_cpu_sysctl_tree;

static int	acpi_cpu_probe(device_t dev);
static int	acpi_cpu_attach(device_t dev);
static void	acpi_cpu_init_throttling(void *arg);
static void	acpi_cpu_set_speed(u_int32_t speed);
static void	acpi_cpu_power_profile(void *arg);
static int	acpi_cpu_speed_sysctl(SYSCTL_HANDLER_ARGS);

static device_method_t acpi_cpu_methods[] = {
    /* Device interface */
    DEVMETHOD(device_probe,	acpi_cpu_probe),
    DEVMETHOD(device_attach,	acpi_cpu_attach),

    {0, 0}
};

static driver_t acpi_cpu_driver = {
    "acpi_cpu",
    acpi_cpu_methods,
    sizeof(struct acpi_cpu_softc),
};

static devclass_t acpi_cpu_devclass;
DRIVER_MODULE(acpi_cpu, acpi, acpi_cpu_driver, acpi_cpu_devclass, 0, 0);

static int
acpi_cpu_probe(device_t dev)
{
    if (!acpi_disabled("cpu") && acpi_get_type(dev) == ACPI_TYPE_PROCESSOR) {
	/* XXX get more verbose description? */
	device_set_desc(dev, "CPU");
	return (0);
    }

    return (ENXIO);
}

static int
acpi_cpu_attach(device_t dev)
{
    struct acpi_cpu_softc	*sc;
    struct acpi_softc		*acpi_sc;
    ACPI_OBJECT			processor;
    ACPI_BUFFER			buf;
    ACPI_STATUS			status;
    u_int32_t			p_blk;
    u_int32_t			p_blk_length;
    u_int32_t			duty_end;
    int				rid;

    ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);

    ACPI_ASSERTLOCK;

    sc = device_get_softc(dev);
    sc->cpu_dev = dev;
    sc->cpu_handle = acpi_get_handle(dev);

    /* Get global parameters from the FADT. */
    if (device_get_unit(sc->cpu_dev) == 0) {
	cpu_duty_offset = AcpiGbl_FADT->DutyOffset;
	cpu_duty_width = AcpiGbl_FADT->DutyWidth;
	cpu_smi_cmd = AcpiGbl_FADT->SmiCmd;
	cpu_pstate_cnt = AcpiGbl_FADT->PstateCnt;

	/* Validate the offset/width */
	if (cpu_duty_width > 0) {
	    duty_end = cpu_duty_offset + cpu_duty_width - 1;

	    /* Check that it fits */
	    if (duty_end > 31) {
		printf("acpi_cpu: CLK_VAL field overflows P_CNT register\n");
		cpu_duty_width = 0;
	    }

	    /* Check for overlap with the THT_EN bit */
	    if (cpu_duty_offset <= 4 && duty_end >= 4) {
		printf("acpi_cpu: CLK_VAL field overlaps THT_EN bit\n");
		cpu_duty_width = 0;
	    }
	}

	/* 
	 * Start the throttling process once the probe phase completes, if we
	 * think that it's going to be useful.  If the duty width value is
	 * zero, there are no significant bits in the register and thus no
	 * throttled states.
	 */
	if (cpu_duty_width > 0) {
	    AcpiOsQueueForExecution(OSD_PRIORITY_LO, acpi_cpu_init_throttling,
				    NULL);
	    acpi_sc = acpi_device_get_parent_softc(dev);
	    sysctl_ctx_init(&acpi_cpu_sysctl_ctx);
	    acpi_cpu_sysctl_tree = SYSCTL_ADD_NODE(&acpi_cpu_sysctl_ctx,
				   SYSCTL_CHILDREN(acpi_sc->acpi_sysctl_tree),
				   OID_AUTO, "cpu", CTLFLAG_RD, 0, "");

	    SYSCTL_ADD_INT(&acpi_cpu_sysctl_ctx,
			   SYSCTL_CHILDREN(acpi_cpu_sysctl_tree),
			   OID_AUTO, "max_speed", CTLFLAG_RD,
			   &cpu_max_state, 0, "maximum CPU speed");
	    SYSCTL_ADD_INT(&acpi_cpu_sysctl_ctx,
			   SYSCTL_CHILDREN(acpi_cpu_sysctl_tree),
			   OID_AUTO, "current_speed", CTLFLAG_RD,
			   &cpu_current_state, 0, "current CPU speed");
	    SYSCTL_ADD_PROC(&acpi_cpu_sysctl_ctx,
			    SYSCTL_CHILDREN(acpi_cpu_sysctl_tree),
			    OID_AUTO, "performance_speed",
			    CTLTYPE_INT | CTLFLAG_RW, &cpu_performance_state,
			    0, acpi_cpu_speed_sysctl, "I", "");
	    SYSCTL_ADD_PROC(&acpi_cpu_sysctl_ctx,
			    SYSCTL_CHILDREN(acpi_cpu_sysctl_tree),
			    OID_AUTO, "economy_speed",
			    CTLTYPE_INT | CTLFLAG_RW, &cpu_economy_state,
			    0, acpi_cpu_speed_sysctl, "I", "");
	}
    }

    /* Get the processor object. */
    buf.Pointer = &processor;
    buf.Length = sizeof(processor);
    status = AcpiEvaluateObject(sc->cpu_handle, NULL, NULL, &buf);
    if (ACPI_FAILURE(status)) {
	device_printf(sc->cpu_dev, "couldn't get Processor object - %s\n",
		      AcpiFormatException(status));
	return_VALUE (ENXIO);
    }
    if (processor.Type != ACPI_TYPE_PROCESSOR) {
	device_printf(sc->cpu_dev, "Processor object has bad type %d\n",
		      processor.Type);
	return_VALUE (ENXIO);
    }
    sc->cpu_id = processor.Processor.ProcId;

    /*
     * If it looks like we support throttling, find this CPU's P_BLK.
     *
     * Note that some systems seem to duplicate the P_BLK pointer across  
     * multiple CPUs, so not getting the resource is not fatal.
     * 
     * XXX should support _PTC here as well, once we work out how to parse it.
     *
     * XXX is it valid to assume that the P_BLK must be 6 bytes long?
     */
    if (cpu_duty_width > 0) {
	p_blk = processor.Processor.PblkAddress;
	p_blk_length = processor.Processor.PblkLength;
    
	/* allocate bus space if possible */
	if (p_blk > 0 && p_blk_length == 6) {
	    rid = 0;
	    bus_set_resource(sc->cpu_dev, SYS_RES_IOPORT, rid, p_blk,
			     p_blk_length);
	    sc->cpu_p_blk = bus_alloc_resource(sc->cpu_dev, SYS_RES_IOPORT,
					       &rid, 0, ~0, 1, RF_ACTIVE);

	    ACPI_DEBUG_PRINT((ACPI_DB_IO, "acpi_cpu%d: throttling with P_BLK "
			     "at 0x%x/%d%s\n", device_get_unit(sc->cpu_dev),
			     p_blk, p_blk_length,
			     sc->cpu_p_blk ? "" : " (shadowed)"));
	}
    }

    return_VALUE (0);
}

/*
 * Call this *after* all CPUs have been attached.
 *
 * Takes the ACPI lock to avoid fighting anyone over the SMI command
 * port.  Could probably lock less code.
 */
static void
acpi_cpu_init_throttling(void *arg)
{
    int cpu_temp_speed;
    ACPI_LOCK_DECL;

    ACPI_LOCK;

    /* Get set of CPU devices */
    devclass_get_devices(acpi_cpu_devclass, &cpu_devices, &cpu_ndevices);

    /* Initialise throttling states */
    cpu_max_state = CPU_MAX_SPEED;
    cpu_performance_state = cpu_max_state;
    cpu_economy_state = cpu_performance_state / 2;

    /* 0 is 'reserved' */
    if (cpu_economy_state == 0)	
	cpu_economy_state++;
    if (TUNABLE_INT_FETCH("hw.acpi.cpu.performance_speed", &cpu_temp_speed) &&
	cpu_temp_speed > 0 && cpu_temp_speed <= cpu_max_state) {

	cpu_performance_state = cpu_temp_speed;
    }
    if (TUNABLE_INT_FETCH("hw.acpi.cpu.economy_speed", &cpu_temp_speed) &&
	cpu_temp_speed > 0 && cpu_temp_speed <= cpu_max_state) {

	cpu_economy_state = cpu_temp_speed;
    }

    /* Register performance profile change handler */
    EVENTHANDLER_REGISTER(power_profile_change, acpi_cpu_power_profile, NULL,
			  0);

    /*
     * If ACPI 2.0+, signal platform that we are taking over throttling
     * XXX should be a generic interface for this
     */
    if (cpu_pstate_cnt != 0)
	AcpiOsWritePort(cpu_smi_cmd, cpu_pstate_cnt, 8);

    ACPI_UNLOCK;

    /* Set initial speed */
    acpi_cpu_power_profile(NULL);
    
    printf("acpi_cpu: throttling enabled, %d steps (100%% to %d.%d%%), " 
	   "currently %d.%d%%\n", CPU_MAX_SPEED, CPU_SPEED_PRINTABLE(1),
	   CPU_SPEED_PRINTABLE(cpu_current_state));
}

/*
 * Set CPUs to the new state.
 *
 * Must be called with the ACPI lock held.
 */
static void
acpi_cpu_set_speed(u_int32_t speed)
{
    struct acpi_cpu_softc	*sc;
    int				i;
    u_int32_t			p_cnt, clk_val;

    ACPI_ASSERTLOCK;

    /* Iterate over processors */
    for (i = 0; i < cpu_ndevices; i++) {
	sc = device_get_softc(cpu_devices[i]);
	if (sc->cpu_p_blk == NULL)
	    continue;

	/* Get the current P_CNT value and disable throttling */
	p_cnt = CPU_GET_P_CNT(sc);
	p_cnt &= ~CPU_P_CNT_THT_EN;
	CPU_SET_P_CNT(sc, p_cnt);

	/* If we're at maximum speed, that's all */
	if (speed < CPU_MAX_SPEED) {
	    /* Mask the old CLK_VAL off and or-in the new value */
	    clk_val = CPU_MAX_SPEED << cpu_duty_offset;
	    p_cnt &= ~clk_val;
	    p_cnt |= (speed << cpu_duty_offset);
	
	    /* Write the new P_CNT value and then enable throttling */
	    CPU_SET_P_CNT(sc, p_cnt);
	    p_cnt |= CPU_P_CNT_THT_EN;
	    CPU_SET_P_CNT(sc, p_cnt);
	}
	ACPI_VPRINT(sc->cpu_dev, acpi_device_get_parent_softc(sc->cpu_dev),
		    "set speed to %d.%d%%\n", CPU_SPEED_PRINTABLE(speed));
    }
    cpu_current_state = speed;
}

/*
 * Power profile change hook.
 *
 * Uses the ACPI lock to avoid reentrancy.
 */
static void
acpi_cpu_power_profile(void *arg)
{
    int		state;
    u_int32_t	new;
    ACPI_LOCK_DECL;

    state = power_profile_get_state();
    if (state != POWER_PROFILE_PERFORMANCE && state != POWER_PROFILE_ECONOMY)
	return;

    ACPI_LOCK;
    
    switch (state) {
    case POWER_PROFILE_PERFORMANCE:
	new = cpu_performance_state;
	break;
    case POWER_PROFILE_ECONOMY:
	new = cpu_economy_state;
	break;
    default:
	new = cpu_current_state;
	break;
    }

    if (cpu_current_state != new)
	acpi_cpu_set_speed(new);

    ACPI_UNLOCK;
}

/*
 * Handle changes in the performance/ecomony CPU settings.
 *
 * Does not need the ACPI lock (although setting *argp should
 * probably be atomic).
 */
static int
acpi_cpu_speed_sysctl(SYSCTL_HANDLER_ARGS)
{
    u_int32_t	*argp;
    u_int32_t	arg;
    int		error;

    argp = (u_int32_t *)oidp->oid_arg1;
    arg = *argp;
    error = sysctl_handle_int(oidp, &arg, 0, req);

    /* Error or no new value */
    if (error != 0 || req->newptr == NULL)
	return (error);
    if (arg < 1 || arg > cpu_max_state)
	return (EINVAL);

    /* Set new value and possibly switch */
    *argp = arg;
    acpi_cpu_power_profile(NULL);

    return (0);
}