d/freebsd-nq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

MFC r204082,204179,204180,204218,204241,204247,204270,204692:

Browse Source 
Provide thermal management and monitoring features in smu(4). This allows
fan control and thermal monitoring on SMU-based Apple G5 machines, as well
as an led(4) interface to control the sleep LED.
This commit is contained in:
Nathan Whitehorn 2010-03-20 14:49:44 +00:00
parent 2219384ff7
commit 81484b9174
3 changed files with 908 additions and 25 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
share/man/man4/man4.powerpc/Makefile
View File

@ -7,6 +7,7 @@ MAN= adb.4 \
cuda.4 \
pmu.4 \
powermac_nvram.4 \
smu.4 \
snd_ai2s.4 \
snd_davbus.4 \
tsec.4

125
share/man/man4/man4.powerpc/smu.4 Normal file
View File

@ -0,0 +1,125 @@
.\"-
.\" Copyright (c) 2010 Nathan Whitehorn <nwhitehorn@FreeBSD.org>
.\" 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 ``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 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.
.\"
.\" $FreeBSD$
.\"
.Dd February 22, 2010
.Dt SMU 4
.Os
.Sh NAME
.Nm smu
.Nd Apple System Management Unit Driver
.Sh SYNOPSIS
To compile this driver into the kernel,
place the following lines in your
kernel configuration file:
.Bd -ragged -offset indent
.Cd "device smu"
.Ed
.Sh DESCRIPTION
The
.Nm
driver provides support for the System Management Unit (SMU) found in many
Apple G5 systems.
This includes most Power Macintosh G5 and all iMac G5 systems.
.Pp
The Apple SMU controller provides software power management and thermal
control functionality, and is responsible for managing system cooling
devices.
.Sh HARDWARE
Chips supported by the
.Nm
driver include:
.Pp
.Bl -bullet -compact
.It
Apple System Management Unit
.El
.Sh THERMAL MANAGEMENT
The
.Nm
driver provides basic automatic thermal management. Without a userspace
daemon providing more advanced control, the driver will attempt to maintain
system temperatures in a conservative range through coarse-grained control of
system cooling devices (see below). Automatic kernel-level thermal control
will take over if more than 3 seconds elapses between userspace cooling
setting adjustments.
.Sh SYSCTL VARIABLES
The
.Nm
driver provides power management services and thermal readout through a
sysctl interface.
The following sysctls can be used to control the
power management behavior and to examine current system power and
thermal conditions.
.Bl -tag -width indent
.It Va dev.smu.%d.server_mode
Restart after power failure behavior (1 causes system to reboot after power
cut, 0 causes system to remain off).
.It Va dev.smu.%d.target_temp
Target system temperature, in degrees Celsius. The
.Nm
driver will attempt to adjust fans to maintain the temperature of the
warmest component in the system at or below this level.
.It Va dev.smu.%d.critical_temp
System critical temperature, in degrees Celsius. If any component in
the system exceeds this temperature, the machine will be shut down within
500 ms.
.It Va dev.smu.%d.fans.%s.minrpm
Minimum allowed speed for this fan.
.It Va dev.smu.%d.fans.%s.maxrpm
Maximum allowed speed for this fan.
.It Va dev.smu.%d.fans.%s.rpm
Current speed for this fan. The fan speed can be adjusted by changing this
sysctl. If more than 3 seconds elapses between fan speed adjustments, the
kernel will resume automatic control of the fan.
.It Va dev.smu.%d.sensors.%s
Current reading from this sensor. Four sensor types are supported. Temperature
sensors are in units of degrees Celsius, current sensors in milliamps, voltage
sensors in millivolts, and power sensors in milliwatts.
.El
.Sh LED INTERFACE
The
.Nm
driver provides an
.Xr led 4
annunciator interface at
.Pa /dev/led/sleepled .
.Sh SEE ALSO
.Xr acpi 4 ,
.Xr pmu 4 ,
.Xr led 4
.Sh HISTORY
The
.Nm
device driver appeared in
.Fx 8.0 .
.Sh AUTHORS
.An -nosplit
The
.Nm
driver was written by
.An Nathan Whitehorn
.Aq nwhitehorn@FreeBSD.org .

807
sys/powerpc/powermac/smu.c
View File

@ -34,21 +34,53 @@ __FBSDID("$FreeBSD$");
#include <sys/module.h>
#include <sys/conf.h>
#include <sys/cpu.h>
#include <sys/ctype.h>
#include <sys/kernel.h>
#include <sys/kthread.h>
#include <sys/reboot.h>
#include <sys/rman.h>
#include <sys/sysctl.h>
#include <sys/unistd.h>
#include <machine/bus.h>
#include <machine/intr_machdep.h>
#include <machine/md_var.h>
#include <dev/led/led.h>
#include <dev/ofw/openfirm.h>
#include <dev/ofw/ofw_bus.h>
#include <powerpc/powermac/macgpiovar.h>
struct smu_cmd {
uint8_t cmd;
volatile uint8_t cmd;
uint8_t len;
uint8_t data[254];
STAILQ_ENTRY(smu_cmd) cmd_q;
};
STAILQ_HEAD(smu_cmdq, smu_cmd);
struct smu_fan {
cell_t reg;
cell_t min_rpm;
cell_t max_rpm;
cell_t unmanaged_rpm;
char location[32];
int old_style;
int setpoint;
};
struct smu_sensor {
cell_t reg;
char location[32];
enum {
SMU_CURRENT_SENSOR,
SMU_VOLTAGE_SENSOR,
SMU_POWER_SENSOR,
SMU_TEMP_SENSOR
} type;
};
struct smu_softc {
@ -62,9 +94,40 @@ struct smu_softc {
bus_space_tag_t sc_bt;
bus_space_handle_t sc_mailbox;
struct smu_cmd *sc_cmd;
struct smu_cmd *sc_cmd, *sc_cur_cmd;
bus_addr_t sc_cmd_phys;
bus_dmamap_t sc_cmd_dmamap;
struct smu_cmdq sc_cmdq;
struct smu_fan *sc_fans;
int sc_nfans;
struct smu_sensor *sc_sensors;
int sc_nsensors;
int sc_doorbellirqid;
struct resource *sc_doorbellirq;
void *sc_doorbellirqcookie;
struct proc *sc_fanmgt_proc;
time_t sc_lastuserchange;
/* Calibration data */
uint16_t sc_cpu_diode_scale;
int16_t sc_cpu_diode_offset;
uint16_t sc_cpu_volt_scale;
int16_t sc_cpu_volt_offset;
uint16_t sc_cpu_curr_scale;
int16_t sc_cpu_curr_offset;
uint16_t sc_slots_pow_scale;
int16_t sc_slots_pow_offset;
/* Thermal management parameters */
int sc_target_temp; /* Default 55 C */
int sc_critical_temp; /* Default 90 C */
struct cdev *sc_leddev;
};
/* regular bus attachment functions */
@ -77,6 +140,18 @@ static int smu_attach(device_t);
static void smu_cpufreq_pre_change(device_t, const struct cf_level *level);
static void smu_cpufreq_post_change(device_t, const struct cf_level *level);
/* utility functions */
static int smu_run_cmd(device_t dev, struct smu_cmd *cmd, int wait);
static int smu_get_datablock(device_t dev, int8_t id, uint8_t *buf,
size_t len);
static void smu_attach_fans(device_t dev, phandle_t fanroot);
static void smu_attach_sensors(device_t dev, phandle_t sensroot);
static void smu_fan_management_proc(void *xdev);
static void smu_manage_fans(device_t smu);
static void smu_set_sleepled(void *xdev, int onoff);
static int smu_server_mode(SYSCTL_HANDLER_ARGS);
static void smu_doorbell_intr(void *xdev);
/* where to find the doorbell GPIO */
static device_t smu_doorbell = NULL;
@ -97,11 +172,43 @@ static driver_t smu_driver = {
static devclass_t smu_devclass;
DRIVER_MODULE(smu, nexus, smu_driver, smu_devclass, 0, 0);
MALLOC_DEFINE(M_SMU, "smu", "SMU Sensor Information");
#define SMU_MAILBOX 0x860c
#define SMU_MAILBOX 0x8000860c
#define SMU_FANMGT_INTERVAL 1000 /* ms */
/* Command types */
#define SMU_POWER 0xaa
#define SMU_ADC 0xd8
#define SMU_FAN 0x4a
#define SMU_I2C 0x9a
#define SMU_I2C_SIMPLE 0x00
#define SMU_I2C_NORMAL 0x01
#define SMU_I2C_COMBINED 0x02
#define SMU_MISC 0xee
#define SMU_MISC_GET_DATA 0x02
#define SMU_MISC_LED_CTRL 0x04
#define SMU_POWER 0xaa
#define SMU_POWER_EVENTS 0x8f
#define SMU_PWR_GET_POWERUP 0x00
#define SMU_PWR_SET_POWERUP 0x01
#define SMU_PWR_CLR_POWERUP 0x02
/* Power event types */
#define SMU_WAKEUP_KEYPRESS 0x01
#define SMU_WAKEUP_AC_INSERT 0x02
#define SMU_WAKEUP_AC_CHANGE 0x04
#define SMU_WAKEUP_RING 0x10
/* Data blocks */
#define SMU_CPUTEMP_CAL 0x18
#define SMU_CPUVOLT_CAL 0x21
#define SMU_SLOTPW_CAL 0x78
/* Partitions */
#define SMU_PARTITION 0x3e
#define SMU_PARTITION_LATEST 0x01
#define SMU_PARTITION_BASE 0x02
#define SMU_PARTITION_UPDATE 0x03
static int
smu_probe(device_t dev)
@ -127,10 +234,14 @@ static int
smu_attach(device_t dev)
{
struct smu_softc *sc;
phandle_t node, child;
uint8_t data[12];
sc = device_get_softc(dev);
mtx_init(&sc->sc_mtx, "smu", NULL, MTX_DEF);
sc->sc_cur_cmd = NULL;
sc->sc_doorbellirqid = -1;
/*
* Map the mailbox area. This should be determined from firmware,
@ -139,7 +250,7 @@ smu_attach(device_t dev)
bus_dma_tag_create(NULL, 16, 0, BUS_SPACE_MAXADDR_32BIT,
BUS_SPACE_MAXADDR, NULL, NULL, PAGE_SIZE, 1, PAGE_SIZE, 0, NULL,
NULL, &(sc->sc_dmatag));
sc->sc_bt = &bs_be_tag;
sc->sc_bt = &bs_le_tag;
bus_space_map(sc->sc_bt, SMU_MAILBOX, 4, 0, &sc->sc_mailbox);
/*
@ -150,6 +261,7 @@ smu_attach(device_t dev)
BUS_DMA_ZERO, &sc->sc_cmd_dmamap);
bus_dmamap_load(sc->sc_dmatag, sc->sc_cmd_dmamap,
sc->sc_cmd, PAGE_SIZE, smu_phys_callback, sc, 0);
STAILQ_INIT(&sc->sc_cmdq);
/*
* Set up handlers to change CPU voltage when CPU frequency is changed.
@ -159,51 +271,241 @@ smu_attach(device_t dev)
EVENTHANDLER_REGISTER(cpufreq_post_change, smu_cpufreq_post_change, dev,
EVENTHANDLER_PRI_ANY);
/*
* Detect and attach child devices.
*/
node = ofw_bus_get_node(dev);
for (child = OF_child(node); child != 0; child = OF_peer(child)) {
char name[32];
memset(name, 0, sizeof(name));
OF_getprop(child, "name", name, sizeof(name));
if (strncmp(name, "rpm-fans", 9) == 0 ||
strncmp(name, "fans", 5) == 0)
smu_attach_fans(dev, child);
if (strncmp(name, "sensors", 8) == 0)
smu_attach_sensors(dev, child);
}
/*
* Collect calibration constants.
*/
smu_get_datablock(dev, SMU_CPUTEMP_CAL, data, sizeof(data));
sc->sc_cpu_diode_scale = (data[4] << 8) + data[5];
sc->sc_cpu_diode_offset = (data[6] << 8) + data[7];
smu_get_datablock(dev, SMU_CPUVOLT_CAL, data, sizeof(data));
sc->sc_cpu_volt_scale = (data[4] << 8) + data[5];
sc->sc_cpu_volt_offset = (data[6] << 8) + data[7];
sc->sc_cpu_curr_scale = (data[8] << 8) + data[9];
sc->sc_cpu_curr_offset = (data[10] << 8) + data[11];
smu_get_datablock(dev, SMU_SLOTPW_CAL, data, sizeof(data));
sc->sc_slots_pow_scale = (data[4] << 8) + data[5];
sc->sc_slots_pow_offset = (data[6] << 8) + data[7];
/*
* Set up simple-minded thermal management.
*/
sc->sc_target_temp = 55;
sc->sc_critical_temp = 90;
SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
"target_temp", CTLTYPE_INT | CTLFLAG_RW, &sc->sc_target_temp,
sizeof(int), "Target temperature (C)");
SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
"critical_temp", CTLTYPE_INT | CTLFLAG_RW,
&sc->sc_critical_temp, sizeof(int), "Critical temperature (C)");
kproc_create(smu_fan_management_proc, dev, &sc->sc_fanmgt_proc,
RFHIGHPID, 0, "smu_thermal");
/*
* Set up LED interface
*/
sc->sc_leddev = led_create(smu_set_sleepled, dev, "sleepled");
/*
* Reset on power loss behavior
*/
SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
"server_mode", CTLTYPE_INT | CTLFLAG_RW, dev, 0,
smu_server_mode, "I", "Enable reboot after power failure");
/*
* Set up doorbell interrupt.
*/
sc->sc_doorbellirqid = 0;
sc->sc_doorbellirq = bus_alloc_resource_any(smu_doorbell, SYS_RES_IRQ,
&sc->sc_doorbellirqid, RF_ACTIVE);
bus_setup_intr(smu_doorbell, sc->sc_doorbellirq,
INTR_TYPE_MISC | INTR_MPSAFE, NULL, smu_doorbell_intr, dev,
&sc->sc_doorbellirqcookie);
powerpc_config_intr(rman_get_start(sc->sc_doorbellirq),
INTR_TRIGGER_EDGE, INTR_POLARITY_LOW);
return (0);
}
static int
smu_run_cmd(device_t dev, struct smu_cmd *cmd)
static void
smu_send_cmd(device_t dev, struct smu_cmd *cmd)
{
struct smu_softc *sc;
int doorbell_ack, result;
sc = device_get_softc(dev);
mtx_lock(&sc->sc_mtx);
mtx_assert(&sc->sc_mtx, MA_OWNED);
powerpc_pow_enabled = 0; /* SMU cannot work if we go to NAP */
sc->sc_cur_cmd = cmd;
/* Copy the command to the mailbox */
memcpy(sc->sc_cmd, cmd, sizeof(*cmd));
sc->sc_cmd->cmd = cmd->cmd;
sc->sc_cmd->len = cmd->len;
memcpy(sc->sc_cmd->data, cmd->data, sizeof(cmd->data));
bus_dmamap_sync(sc->sc_dmatag, sc->sc_cmd_dmamap, BUS_DMASYNC_PREWRITE);
bus_space_write_4(sc->sc_bt, sc->sc_mailbox, 0, sc->sc_cmd_phys);
/* Invalidate the cacheline it is in -- SMU bypasses the cache */
__asm __volatile("dcbst 0,%0; sync" :: "r"(sc->sc_cmd): "memory");
/* Flush the cacheline it is in -- SMU bypasses the cache */
__asm __volatile("sync; dcbf 0,%0; sync" :: "r"(sc->sc_cmd): "memory");
/* Ring SMU doorbell */
macgpio_write(smu_doorbell, GPIO_DDR_OUTPUT);
}
/* Wait for the doorbell GPIO to go high, signaling completion */
do {
/* XXX: timeout */
DELAY(50);
doorbell_ack = macgpio_read(smu_doorbell);
} while (!doorbell_ack);
static void
smu_doorbell_intr(void *xdev)
{
device_t smu;
struct smu_softc *sc;
int doorbell_ack;
smu = xdev;
doorbell_ack = macgpio_read(smu_doorbell);
sc = device_get_softc(smu);
if (doorbell_ack != (GPIO_DDR_OUTPUT | GPIO_LEVEL_RO | GPIO_DATA))
return;
mtx_lock(&sc->sc_mtx);
if (sc->sc_cur_cmd == NULL) /* spurious */
goto done;
/* Check result. First invalidate the cache again... */
__asm __volatile("dcbf 0,%0; sync" :: "r"(sc->sc_cmd) : "memory");
bus_dmamap_sync(sc->sc_dmatag, sc->sc_cmd_dmamap, BUS_DMASYNC_POSTREAD);
/* SMU acks the command by inverting the command bits */
if (sc->sc_cmd->cmd == ~cmd->cmd)
result = 0;
else
result = EIO;
sc->sc_cur_cmd->cmd = sc->sc_cmd->cmd;
sc->sc_cur_cmd->len = sc->sc_cmd->len;
memcpy(sc->sc_cur_cmd->data, sc->sc_cmd->data,
sizeof(sc->sc_cmd->data));
wakeup(sc->sc_cur_cmd);
sc->sc_cur_cmd = NULL;
powerpc_pow_enabled = 1;
done:
/* Queue next command if one is pending */
if (STAILQ_FIRST(&sc->sc_cmdq) != NULL) {
sc->sc_cur_cmd = STAILQ_FIRST(&sc->sc_cmdq);
STAILQ_REMOVE_HEAD(&sc->sc_cmdq, cmd_q);
smu_send_cmd(smu, sc->sc_cur_cmd);
}
mtx_unlock(&sc->sc_mtx);
}
return (result);
static int
smu_run_cmd(device_t dev, struct smu_cmd *cmd, int wait)
{
struct smu_softc *sc;
uint8_t cmd_code;
int error;
sc = device_get_softc(dev);
cmd_code = cmd->cmd;
mtx_lock(&sc->sc_mtx);
if (sc->sc_cur_cmd != NULL) {
STAILQ_INSERT_TAIL(&sc->sc_cmdq, cmd, cmd_q);
} else
smu_send_cmd(dev, cmd);
mtx_unlock(&sc->sc_mtx);
if (!wait)
return (0);
if (sc->sc_doorbellirqid < 0) {
/* Poll if the IRQ has not been set up yet */
do {
DELAY(50);
smu_doorbell_intr(dev);
} while (sc->sc_cur_cmd != NULL);
} else {
/* smu_doorbell_intr will wake us when the command is ACK'ed */
error = tsleep(cmd, 0, "smu", 800 * hz / 1000);
if (error != 0)
smu_doorbell_intr(dev); /* One last chance */
if (error != 0) {
mtx_lock(&sc->sc_mtx);
if (cmd->cmd == cmd_code) { /* Never processed */
/* Abort this command if we timed out */
if (sc->sc_cur_cmd == cmd)
sc->sc_cur_cmd = NULL;
else
STAILQ_REMOVE(&sc->sc_cmdq, cmd, smu_cmd,
cmd_q);
mtx_unlock(&sc->sc_mtx);
return (error);
}
error = 0;
mtx_unlock(&sc->sc_mtx);
}
}
/* SMU acks the command by inverting the command bits */
if (cmd->cmd == ((~cmd_code) & 0xff))
error = 0;
else
error = EIO;
return (error);
}
static int
smu_get_datablock(device_t dev, int8_t id, uint8_t *buf, size_t len)
{
struct smu_cmd cmd;
uint8_t addr[4];
cmd.cmd = SMU_PARTITION;
cmd.len = 2;
cmd.data[0] = SMU_PARTITION_LATEST;
cmd.data[1] = id;
smu_run_cmd(dev, &cmd, 1);
addr[0] = addr[1] = 0;
addr[2] = cmd.data[0];
addr[3] = cmd.data[1];
cmd.cmd = SMU_MISC;
cmd.len = 7;
cmd.data[0] = SMU_MISC_GET_DATA;
cmd.data[1] = sizeof(addr);
memcpy(&cmd.data[2], addr, sizeof(addr));
cmd.data[6] = len;
smu_run_cmd(dev, &cmd, 1);
memcpy(buf, cmd.data, len);
return (0);
}
static void
@ -222,7 +524,7 @@ smu_slew_cpu_voltage(device_t dev, int to)
cmd.data[6] = 1;
cmd.data[7] = to;
smu_run_cmd(dev, &cmd);
smu_run_cmd(dev, &cmd, 1);
}
static void
@ -286,3 +588,458 @@ doorbell_attach(device_t dev)
smu_doorbell = dev;
return (0);
}
/*
* Sensor and fan management
*/
static int
smu_fan_set_rpm(device_t smu, struct smu_fan *fan, int rpm)
{
struct smu_cmd cmd;
int error;
cmd.cmd = SMU_FAN;
error = EIO;
/* Clamp to allowed range */
rpm = max(fan->min_rpm, rpm);
rpm = min(fan->max_rpm, rpm);
/*
* Apple has two fan control mechanisms. We can't distinguish
* them except by seeing if the new one fails. If the new one
* fails, use the old one.
*/
if (!fan->old_style) {
cmd.len = 4;
cmd.data[0] = 0x30;
cmd.data[1] = fan->reg;
cmd.data[2] = (rpm >> 8) & 0xff;
cmd.data[3] = rpm & 0xff;
error = smu_run_cmd(smu, &cmd, 1);
if (error)
fan->old_style = 1;
}
if (fan->old_style) {
cmd.len = 14;
cmd.data[0] = 0;
cmd.data[1] = 1 << fan->reg;
cmd.data[2 + 2*fan->reg] = (rpm >> 8) & 0xff;
cmd.data[3 + 2*fan->reg] = rpm & 0xff;
error = smu_run_cmd(smu, &cmd, 1);
}
if (error == 0)
fan->setpoint = rpm;
return (error);
}
static int
smu_fan_read_rpm(device_t smu, struct smu_fan *fan)
{
struct smu_cmd cmd;
cmd.cmd = SMU_FAN;
cmd.len = 1;
cmd.data[0] = 1;
smu_run_cmd(smu, &cmd, 1);
return ((cmd.data[fan->reg*2+1] << 8) | cmd.data[fan->reg*2+2]);
}
static int
smu_fanrpm_sysctl(SYSCTL_HANDLER_ARGS)
{
device_t smu;
struct smu_softc *sc;
struct smu_fan *fan;
int rpm, error;
smu = arg1;
sc = device_get_softc(smu);
fan = &sc->sc_fans[arg2];
rpm = smu_fan_read_rpm(smu, fan);
error = sysctl_handle_int(oidp, &rpm, 0, req);
if (error || !req->newptr)
return (error);
sc->sc_lastuserchange = time_uptime;
return (smu_fan_set_rpm(smu, fan, rpm));
}
static void
smu_attach_fans(device_t dev, phandle_t fanroot)
{
struct smu_fan *fan;
struct smu_softc *sc;
struct sysctl_oid *oid, *fanroot_oid;
struct sysctl_ctx_list *ctx;
phandle_t child;
char type[32], sysctl_name[32];
int i;
sc = device_get_softc(dev);
sc->sc_nfans = 0;
for (child = OF_child(fanroot); child != 0; child = OF_peer(child))
sc->sc_nfans++;
if (sc->sc_nfans == 0) {
device_printf(dev, "WARNING: No fans detected!\n");
return;
}
sc->sc_fans = malloc(sc->sc_nfans * sizeof(struct smu_fan), M_SMU,
M_WAITOK | M_ZERO);
fan = sc->sc_fans;
sc->sc_nfans = 0;
ctx = device_get_sysctl_ctx(dev);
fanroot_oid = SYSCTL_ADD_NODE(ctx,
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, "fans",
CTLFLAG_RD, 0, "SMU Fan Information");
for (child = OF_child(fanroot); child != 0; child = OF_peer(child)) {
OF_getprop(child, "device_type", type, sizeof(type));
if (strcmp(type, "fan-rpm-control") != 0)
continue;
fan->old_style = 0;
OF_getprop(child, "reg", &fan->reg, sizeof(cell_t));
OF_getprop(child, "min-value", &fan->min_rpm, sizeof(cell_t));
OF_getprop(child, "max-value", &fan->max_rpm, sizeof(cell_t));
if (OF_getprop(child, "unmanaged-value", &fan->unmanaged_rpm,
sizeof(cell_t)) != sizeof(cell_t))
fan->unmanaged_rpm = fan->max_rpm;
fan->setpoint = smu_fan_read_rpm(dev, fan);
OF_getprop(child, "location", fan->location,
sizeof(fan->location));
/* Add sysctls */
for (i = 0; i < strlen(fan->location); i++) {
sysctl_name[i] = tolower(fan->location[i]);
if (isspace(sysctl_name[i]))
sysctl_name[i] = '_';
}
sysctl_name[i] = 0;
oid = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(fanroot_oid),
OID_AUTO, sysctl_name, CTLFLAG_RD, 0, "Fan Information");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, "minrpm",
CTLTYPE_INT | CTLFLAG_RD, &fan->min_rpm, sizeof(cell_t),
"Minimum allowed RPM");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, "maxrpm",
CTLTYPE_INT | CTLFLAG_RD, &fan->max_rpm, sizeof(cell_t),
"Maximum allowed RPM");
SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, "rpm",
CTLTYPE_INT | CTLFLAG_RW, dev, sc->sc_nfans,
smu_fanrpm_sysctl, "I", "Fan RPM");
fan++;
sc->sc_nfans++;
}
}
static int
smu_sensor_read(device_t smu, struct smu_sensor *sens, int *val)
{
struct smu_cmd cmd;
struct smu_softc *sc;
int64_t value;
int error;
cmd.cmd = SMU_ADC;
cmd.len = 1;
cmd.data[0] = sens->reg;
error = 0;
error = smu_run_cmd(smu, &cmd, 1);
if (error != 0)
return (error);
sc = device_get_softc(smu);
value = (cmd.data[0] << 8) | cmd.data[1];
switch (sens->type) {
case SMU_TEMP_SENSOR:
value *= sc->sc_cpu_diode_scale;
value >>= 3;
value += ((int64_t)sc->sc_cpu_diode_offset) << 9;
value <<= 1;
/* Convert from 16.16 fixed point degC into integer C. */
value >>= 16;
break;
case SMU_VOLTAGE_SENSOR:
value *= sc->sc_cpu_volt_scale;
value += sc->sc_cpu_volt_offset;
value <<= 4;
/* Convert from 16.16 fixed point V into mV. */
value *= 15625;
value /= 1024;
value /= 1000;
break;
case SMU_CURRENT_SENSOR:
value *= sc->sc_cpu_curr_scale;
value += sc->sc_cpu_curr_offset;
value <<= 4;
/* Convert from 16.16 fixed point A into mA. */
value *= 15625;
value /= 1024;
value /= 1000;
break;
case SMU_POWER_SENSOR:
value *= sc->sc_slots_pow_scale;
value += sc->sc_slots_pow_offset;
value <<= 4;
/* Convert from 16.16 fixed point W into mW. */
value *= 15625;
value /= 1024;
value /= 1000;
break;
}
*val = value;
return (0);
}
static int
smu_sensor_sysctl(SYSCTL_HANDLER_ARGS)
{
device_t smu;
struct smu_softc *sc;
struct smu_sensor *sens;
int value, error;
smu = arg1;
sc = device_get_softc(smu);
sens = &sc->sc_sensors[arg2];
error = smu_sensor_read(smu, sens, &value);
if (error != 0)
return (error);
error = sysctl_handle_int(oidp, &value, 0, req);
return (error);
}
static void
smu_attach_sensors(device_t dev, phandle_t sensroot)
{
struct smu_sensor *sens;
struct smu_softc *sc;
struct sysctl_oid *sensroot_oid;
struct sysctl_ctx_list *ctx;
phandle_t child;
char type[32];
int i;
sc = device_get_softc(dev);
sc->sc_nsensors = 0;
for (child = OF_child(sensroot); child != 0; child = OF_peer(child))
sc->sc_nsensors++;
if (sc->sc_nsensors == 0) {
device_printf(dev, "WARNING: No sensors detected!\n");
return;
}
sc->sc_sensors = malloc(sc->sc_nsensors * sizeof(struct smu_sensor),
M_SMU, M_WAITOK | M_ZERO);
sens = sc->sc_sensors;
sc->sc_nsensors = 0;
ctx = device_get_sysctl_ctx(dev);
sensroot_oid = SYSCTL_ADD_NODE(ctx,
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, "sensors",
CTLFLAG_RD, 0, "SMU Sensor Information");
for (child = OF_child(sensroot); child != 0; child = OF_peer(child)) {
char sysctl_name[40], sysctl_desc[40];
const char *units;
OF_getprop(child, "device_type", type, sizeof(type));
if (strcmp(type, "current-sensor") == 0) {
sens->type = SMU_CURRENT_SENSOR;
units = "mA";
} else if (strcmp(type, "temp-sensor") == 0) {
sens->type = SMU_TEMP_SENSOR;
units = "C";
} else if (strcmp(type, "voltage-sensor") == 0) {
sens->type = SMU_VOLTAGE_SENSOR;
units = "mV";
} else if (strcmp(type, "power-sensor") == 0) {
sens->type = SMU_POWER_SENSOR;
units = "mW";
} else {
continue;
}
OF_getprop(child, "reg", &sens->reg, sizeof(cell_t));
OF_getprop(child, "location", sens->location,
sizeof(sens->location));
for (i = 0; i < strlen(sens->location); i++) {
sysctl_name[i] = tolower(sens->location[i]);
if (isspace(sysctl_name[i]))
sysctl_name[i] = '_';
}
sysctl_name[i] = 0;
sprintf(sysctl_desc,"%s (%s)", sens->location, units);
SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(sensroot_oid), OID_AUTO,
sysctl_name, CTLTYPE_INT | CTLFLAG_RD, dev, sc->sc_nsensors,
smu_sensor_sysctl, "I", sysctl_desc);
sens++;
sc->sc_nsensors++;
}
}
static void
smu_fan_management_proc(void *xdev)
{
device_t smu = xdev;
while(1) {
smu_manage_fans(smu);
pause("smu", SMU_FANMGT_INTERVAL * hz / 1000);
}
}
static void
smu_manage_fans(device_t smu)
{
struct smu_softc *sc;
int i, maxtemp, temp, factor, error;
sc = device_get_softc(smu);
maxtemp = 0;
for (i = 0; i < sc->sc_nsensors; i++) {
if (sc->sc_sensors[i].type != SMU_TEMP_SENSOR)
continue;
error = smu_sensor_read(smu, &sc->sc_sensors[i], &temp);
if (error == 0 && temp > maxtemp)
maxtemp = temp;
}
if (maxtemp < 10) { /* Bail if no good sensors */
for (i = 0; i < sc->sc_nfans; i++)
smu_fan_set_rpm(smu, &sc->sc_fans[i],
sc->sc_fans[i].unmanaged_rpm);
return;
}
if (maxtemp > sc->sc_critical_temp) {
device_printf(smu, "WARNING: Current system temperature (%d C) "
"exceeds critical temperature (%d C)! Shutting down!\n",
maxtemp, sc->sc_critical_temp);
shutdown_nice(RB_POWEROFF);
}
if (maxtemp - sc->sc_target_temp > 20)
device_printf(smu, "WARNING: Current system temperature (%d C) "
"more than 20 degrees over target temperature (%d C)!\n",
maxtemp, sc->sc_target_temp);
if (time_uptime - sc->sc_lastuserchange < 3) {
/*
* If we have heard from a user process in the last 3 seconds,
* go away.
*/
return;
}
if (maxtemp - sc->sc_target_temp > 4)
factor = 110;
else if (maxtemp - sc->sc_target_temp > 1)
factor = 105;
else if (sc->sc_target_temp - maxtemp > 4)
factor = 90;
else if (sc->sc_target_temp - maxtemp > 1)
factor = 95;
else
factor = 100;
for (i = 0; i < sc->sc_nfans; i++)
smu_fan_set_rpm(smu, &sc->sc_fans[i],
(sc->sc_fans[i].setpoint * factor) / 100);
}
static void
smu_set_sleepled(void *xdev, int onoff)
{
static struct smu_cmd cmd;
device_t smu = xdev;
cmd.cmd = SMU_MISC;
cmd.len = 3;
cmd.data[0] = SMU_MISC_LED_CTRL;
cmd.data[1] = 0;
cmd.data[2] = onoff;
smu_run_cmd(smu, &cmd, 0);
}
static int
smu_server_mode(SYSCTL_HANDLER_ARGS)
{
struct smu_cmd cmd;
u_int server_mode;
device_t smu = arg1;
int error;
cmd.cmd = SMU_POWER_EVENTS;
cmd.len = 1;
cmd.data[0] = SMU_PWR_GET_POWERUP;
error = smu_run_cmd(smu, &cmd, 1);
if (error)
return (error);
server_mode = (cmd.data[1] & SMU_WAKEUP_AC_INSERT) ? 1 : 0;
error = sysctl_handle_int(oidp, &server_mode, 0, req);
if (error || !req->newptr)
return (error);
if (server_mode == 1)
cmd.data[0] = SMU_PWR_SET_POWERUP;
else if (server_mode == 0)
cmd.data[0] = SMU_PWR_CLR_POWERUP;
else
return (EINVAL);
cmd.len = 3;
cmd.data[1] = 0;
cmd.data[2] = SMU_WAKEUP_AC_INSERT;
return (smu_run_cmd(smu, &cmd, 1));
}