fe4944de64
Our hook creates the sysctl node before root is mounted, but after cpu is probed. It seems that k8temp can be loaded before the cpu module and, in those cases, dev.cpu.0.temperature was not created. PR: 124939
338 lines
8.1 KiB
C
338 lines
8.1 KiB
C
/*-
|
|
* Copyright (c) 2008 Rui Paulo <rpaulo@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.
|
|
*/
|
|
|
|
/*
|
|
* Driver for the AMD K8 thermal sensors. Based on a Linux driver by the
|
|
* same name.
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/bus.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/types.h>
|
|
#include <sys/module.h>
|
|
#include <sys/conf.h>
|
|
#include <sys/kernel.h>
|
|
#include <sys/sysctl.h>
|
|
|
|
#include <machine/specialreg.h>
|
|
#include <machine/cpufunc.h>
|
|
#include <machine/md_var.h>
|
|
|
|
#include <dev/pci/pcireg.h>
|
|
#include <dev/pci/pcivar.h>
|
|
|
|
struct k8temp_softc {
|
|
device_t sc_dev;
|
|
int sc_temps[4];
|
|
int sc_ntemps;
|
|
struct sysctl_oid *sc_oid;
|
|
struct sysctl_oid *sc_sysctl_cpu[2];
|
|
struct intr_config_hook sc_ich;
|
|
};
|
|
|
|
#define VENDORID_AMD 0x1022
|
|
#define DEVICEID_AMD_MISC 0x1103
|
|
|
|
static struct k8temp_product {
|
|
uint16_t k8temp_vendorid;
|
|
uint16_t k8temp_deviceid;
|
|
} k8temp_products[] = {
|
|
{ VENDORID_AMD, DEVICEID_AMD_MISC },
|
|
{ 0, 0 }
|
|
};
|
|
|
|
/*
|
|
* Register control
|
|
*/
|
|
#define K8TEMP_REG 0xe4
|
|
#define K8TEMP_REG_SELSENSOR 0x40
|
|
#define K8TEMP_REG_SELCORE 0x04
|
|
|
|
#define K8TEMP_MINTEMP 49 /* -49 C is the mininum temperature */
|
|
|
|
typedef enum {
|
|
SENSOR0_CORE0,
|
|
SENSOR0_CORE1,
|
|
SENSOR1_CORE0,
|
|
SENSOR1_CORE1,
|
|
CORE0,
|
|
CORE1
|
|
} k8sensor_t;
|
|
|
|
/*
|
|
* Device methods.
|
|
*/
|
|
static void k8temp_identify(driver_t *driver, device_t parent);
|
|
static int k8temp_probe(device_t dev);
|
|
static int k8temp_attach(device_t dev);
|
|
static void k8temp_intrhook(void *arg);
|
|
static int k8temp_detach(device_t dev);
|
|
static int k8temp_match(device_t dev);
|
|
static int32_t k8temp_gettemp(device_t dev, k8sensor_t sensor);
|
|
static int k8temp_sysctl(SYSCTL_HANDLER_ARGS);
|
|
|
|
static device_method_t k8temp_methods[] = {
|
|
/* Device interface */
|
|
DEVMETHOD(device_identify, k8temp_identify),
|
|
DEVMETHOD(device_probe, k8temp_probe),
|
|
DEVMETHOD(device_attach, k8temp_attach),
|
|
DEVMETHOD(device_detach, k8temp_detach),
|
|
|
|
{0, 0}
|
|
};
|
|
|
|
static driver_t k8temp_driver = {
|
|
"k8temp",
|
|
k8temp_methods,
|
|
sizeof(struct k8temp_softc),
|
|
};
|
|
|
|
static devclass_t k8temp_devclass;
|
|
DRIVER_MODULE(k8temp, hostb, k8temp_driver, k8temp_devclass, NULL, NULL);
|
|
|
|
static int
|
|
k8temp_match(device_t dev)
|
|
{
|
|
int i;
|
|
uint16_t vendor, devid;
|
|
|
|
vendor = pci_get_vendor(dev);
|
|
devid = pci_get_device(dev);
|
|
|
|
for (i = 0; k8temp_products[i].k8temp_vendorid != 0; i++) {
|
|
if (vendor == k8temp_products[i].k8temp_vendorid &&
|
|
devid == k8temp_products[i].k8temp_deviceid)
|
|
return (1);
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
static void
|
|
k8temp_identify(driver_t *driver, device_t parent)
|
|
{
|
|
device_t child;
|
|
|
|
/* Make sure we're not being doubly invoked. */
|
|
if (device_find_child(parent, "k8temp", -1) != NULL)
|
|
return;
|
|
|
|
if (k8temp_match(parent)) {
|
|
child = device_add_child(parent, "k8temp", -1);
|
|
if (child == NULL)
|
|
device_printf(parent, "add k8temp child failed\n");
|
|
}
|
|
|
|
}
|
|
|
|
static int
|
|
k8temp_probe(device_t dev)
|
|
{
|
|
uint32_t regs[4];
|
|
|
|
if (resource_disabled("k8temp", 0))
|
|
return (ENXIO);
|
|
|
|
do_cpuid(1, regs);
|
|
switch (regs[0]) {
|
|
case 0xf40:
|
|
case 0xf50:
|
|
case 0xf51:
|
|
return (ENXIO);
|
|
}
|
|
device_set_desc(dev, "AMD K8 Thermal Sensors");
|
|
|
|
return (BUS_PROBE_GENERIC);
|
|
}
|
|
|
|
static int
|
|
k8temp_attach(device_t dev)
|
|
{
|
|
struct k8temp_softc *sc = device_get_softc(dev);
|
|
struct sysctl_ctx_list *sysctlctx;
|
|
struct sysctl_oid *sysctlnode;
|
|
|
|
|
|
/*
|
|
* Setup intrhook function to create dev.cpu sysctl entries. This is
|
|
* needed because the cpu driver may be loaded late on boot, before
|
|
* us.
|
|
*/
|
|
sc->sc_ich.ich_func = k8temp_intrhook;
|
|
sc->sc_ich.ich_arg = dev;
|
|
|
|
/*
|
|
* dev.k8temp.N tree.
|
|
*/
|
|
sysctlctx = device_get_sysctl_ctx(dev);
|
|
sysctlnode = SYSCTL_ADD_NODE(sysctlctx,
|
|
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, "sensor0",
|
|
CTLFLAG_RD, 0, "Sensor 0");
|
|
|
|
SYSCTL_ADD_PROC(sysctlctx,
|
|
SYSCTL_CHILDREN(sysctlnode),
|
|
OID_AUTO, "core0", CTLTYPE_INT | CTLFLAG_RD,
|
|
dev, SENSOR0_CORE0, k8temp_sysctl, "I",
|
|
"Sensor 0 / Core 0 temperature");
|
|
|
|
SYSCTL_ADD_PROC(sysctlctx,
|
|
SYSCTL_CHILDREN(sysctlnode),
|
|
OID_AUTO, "core1", CTLTYPE_INT | CTLFLAG_RD,
|
|
dev, SENSOR0_CORE1, k8temp_sysctl, "I",
|
|
"Sensor 0 / Core 1 temperature");
|
|
|
|
sysctlnode = SYSCTL_ADD_NODE(sysctlctx,
|
|
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, "sensor1",
|
|
CTLFLAG_RD, 0, "Sensor 1");
|
|
|
|
SYSCTL_ADD_PROC(sysctlctx,
|
|
SYSCTL_CHILDREN(sysctlnode),
|
|
OID_AUTO, "core0", CTLTYPE_INT | CTLFLAG_RD,
|
|
dev, SENSOR0_CORE0, k8temp_sysctl, "I",
|
|
"Sensor 1 / Core 0 temperature");
|
|
|
|
SYSCTL_ADD_PROC(sysctlctx,
|
|
SYSCTL_CHILDREN(sysctlnode),
|
|
OID_AUTO, "core1", CTLTYPE_INT | CTLFLAG_RD,
|
|
dev, SENSOR0_CORE0, k8temp_sysctl, "I",
|
|
"Sensor 1 / Core 1 temperature");
|
|
|
|
return (0);
|
|
}
|
|
|
|
void
|
|
k8temp_intrhook(void *arg)
|
|
{
|
|
int i;
|
|
device_t nexus, acpi, cpu;
|
|
device_t dev = (device_t) arg;
|
|
struct k8temp_softc *sc;
|
|
struct sysctl_ctx_list *sysctlctx;
|
|
|
|
sc = device_get_softc(dev);
|
|
|
|
/*
|
|
* dev.cpu.N.temperature.
|
|
*/
|
|
nexus = device_find_child(root_bus, "nexus", 0);
|
|
acpi = device_find_child(nexus, "acpi", 0);
|
|
|
|
for (i = 0; i < 2; i++) {
|
|
cpu = device_find_child(acpi, "cpu",
|
|
device_get_unit(dev) * 2 + i);
|
|
if (cpu) {
|
|
sysctlctx = device_get_sysctl_ctx(cpu);
|
|
|
|
sc->sc_sysctl_cpu[i] = SYSCTL_ADD_PROC(sysctlctx,
|
|
SYSCTL_CHILDREN(device_get_sysctl_tree(cpu)),
|
|
OID_AUTO, "temperature", CTLTYPE_INT | CTLFLAG_RD,
|
|
dev, CORE0, k8temp_sysctl, "I",
|
|
"Max of sensor 0 / 1");
|
|
}
|
|
}
|
|
config_intrhook_disestablish(&sc->sc_ich);
|
|
}
|
|
|
|
int
|
|
k8temp_detach(device_t dev)
|
|
{
|
|
int i;
|
|
struct k8temp_softc *sc = device_get_softc(dev);
|
|
|
|
for (i = 0; i < 2; i++) {
|
|
if (sc->sc_sysctl_cpu[i])
|
|
sysctl_remove_oid(sc->sc_sysctl_cpu[i], 1, 0);
|
|
}
|
|
|
|
/* NewBus removes the dev.k8temp.N tree by itself. */
|
|
|
|
return (0);
|
|
}
|
|
|
|
static int
|
|
k8temp_sysctl(SYSCTL_HANDLER_ARGS)
|
|
{
|
|
device_t dev = (device_t) arg1;
|
|
int error;
|
|
int32_t temp, auxtemp[2];
|
|
|
|
switch (arg2) {
|
|
case CORE0:
|
|
auxtemp[0] = k8temp_gettemp(dev, SENSOR0_CORE0);
|
|
auxtemp[1] = k8temp_gettemp(dev, SENSOR1_CORE0);
|
|
temp = imax(auxtemp[0], auxtemp[1]);
|
|
break;
|
|
case CORE1:
|
|
auxtemp[0] = k8temp_gettemp(dev, SENSOR0_CORE1);
|
|
auxtemp[1] = k8temp_gettemp(dev, SENSOR1_CORE1);
|
|
temp = imax(auxtemp[0], auxtemp[1]);
|
|
break;
|
|
default:
|
|
temp = k8temp_gettemp(dev, arg2);
|
|
break;
|
|
}
|
|
error = sysctl_handle_int(oidp, &temp, 0, req);
|
|
|
|
return (error);
|
|
}
|
|
|
|
static int32_t
|
|
k8temp_gettemp(device_t dev, k8sensor_t sensor)
|
|
{
|
|
uint8_t cfg;
|
|
uint32_t temp;
|
|
|
|
cfg = pci_read_config(dev, K8TEMP_REG, 1);
|
|
switch (sensor) {
|
|
case SENSOR0_CORE0:
|
|
cfg &= ~(K8TEMP_REG_SELSENSOR | K8TEMP_REG_SELCORE);
|
|
break;
|
|
case SENSOR0_CORE1:
|
|
cfg &= ~K8TEMP_REG_SELSENSOR;
|
|
cfg |= K8TEMP_REG_SELCORE;
|
|
break;
|
|
case SENSOR1_CORE0:
|
|
cfg &= ~K8TEMP_REG_SELCORE;
|
|
cfg |= K8TEMP_REG_SELSENSOR;
|
|
break;
|
|
case SENSOR1_CORE1:
|
|
cfg |= (K8TEMP_REG_SELSENSOR | K8TEMP_REG_SELCORE);
|
|
break;
|
|
default:
|
|
cfg = 0;
|
|
break;
|
|
}
|
|
pci_write_config(dev, K8TEMP_REG, cfg, 1);
|
|
temp = pci_read_config(dev, K8TEMP_REG, 4);
|
|
temp = ((temp >> 16) & 0xff) - K8TEMP_MINTEMP;
|
|
|
|
return (temp);
|
|
}
|