/*-
* 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, after
* us.
*/
sc->sc_ich.ich_func = k8temp_intrhook;
sc->sc_ich.ich_arg = dev;
if (config_intrhook_establish(&sc->sc_ich) != 0) {
device_printf(dev, "config_intrhook_establish "
"failed!\n");
return (ENXIO);
}
/*
* 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, SENSOR1_CORE0, k8temp_sysctl, "I",
"Sensor 1 / Core 0 temperature");
SYSCTL_ADD_PROC(sysctlctx,
SYSCTL_CHILDREN(sysctlnode),
OID_AUTO, "core1", CTLTYPE_INT | CTLFLAG_RD,
dev, SENSOR1_CORE1, 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);
}
