diff --git a/sys/dev/amdtemp/amdtemp.c b/sys/dev/amdtemp/amdtemp.c index 35cca988e351..0898405172db 100644 --- a/sys/dev/amdtemp/amdtemp.c +++ b/sys/dev/amdtemp/amdtemp.c @@ -1,5 +1,6 @@ /*- - * Copyright (c) 2008 Rui Paulo + * Copyright (c) 2008, 2009 Rui Paulo + * Copyright (c) 2009 Norikatsu Shigemura * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -25,8 +26,8 @@ */ /* - * Driver for the AMD K8 thermal sensors. Based on a Linux driver by the - * same name. + * Driver for the AMD K8/K10/K11 thermal sensors. Initially based on the + * amdtemp Linux driver. */ #include @@ -48,35 +49,6 @@ __FBSDID("$FreeBSD$"); #include #include -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, @@ -84,41 +56,85 @@ typedef enum { SENSOR1_CORE1, CORE0, CORE1 -} k8sensor_t; +} amdsensor_t; + +struct amdtemp_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; + int32_t (*sc_gettemp)(device_t, amdsensor_t); +}; + +#define VENDORID_AMD 0x1022 +#define DEVICEID_AMD_MISC0F 0x1103 +#define DEVICEID_AMD_MISC10 0x1203 +#define DEVICEID_AMD_MISC11 0x1303 + +static struct amdtemp_product { + uint16_t amdtemp_vendorid; + uint16_t amdtemp_deviceid; +} amdtemp_products[] = { + { VENDORID_AMD, DEVICEID_AMD_MISC0F }, + { VENDORID_AMD, DEVICEID_AMD_MISC10 }, + { VENDORID_AMD, DEVICEID_AMD_MISC11 }, + { 0, 0 } +}; + +/* + * Register control (K8 family) + */ +#define AMDTEMP_REG0F 0xe4 +#define AMDTEMP_REG_SELSENSOR 0x40 +#define AMDTEMP_REG_SELCORE 0x04 + +/* + * Register control (K10 & K11) family + */ +#define AMDTEMP_REG 0xa4 + +#define TZ_ZEROC 2732 + + /* -49 C is the mininum temperature */ +#define AMDTEMP_OFFSET0F (TZ_ZEROC-490) +#define AMDTEMP_OFFSET (TZ_ZEROC) /* * 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 void amdtemp_identify(driver_t *driver, device_t parent); +static int amdtemp_probe(device_t dev); +static int amdtemp_attach(device_t dev); +static void amdtemp_intrhook(void *arg); +static int amdtemp_detach(device_t dev); +static int amdtemp_match(device_t dev); +static int32_t amdtemp_gettemp0f(device_t dev, amdsensor_t sensor); +static int32_t amdtemp_gettemp(device_t dev, amdsensor_t sensor); +static int amdtemp_sysctl(SYSCTL_HANDLER_ARGS); -static device_method_t k8temp_methods[] = { +static device_method_t amdtemp_methods[] = { /* Device interface */ - DEVMETHOD(device_identify, k8temp_identify), - DEVMETHOD(device_probe, k8temp_probe), - DEVMETHOD(device_attach, k8temp_attach), - DEVMETHOD(device_detach, k8temp_detach), + DEVMETHOD(device_identify, amdtemp_identify), + DEVMETHOD(device_probe, amdtemp_probe), + DEVMETHOD(device_attach, amdtemp_attach), + DEVMETHOD(device_detach, amdtemp_detach), {0, 0} }; -static driver_t k8temp_driver = { - "k8temp", - k8temp_methods, - sizeof(struct k8temp_softc), +static driver_t amdtemp_driver = { + "amdtemp", + amdtemp_methods, + sizeof(struct amdtemp_softc), }; -static devclass_t k8temp_devclass; -DRIVER_MODULE(k8temp, hostb, k8temp_driver, k8temp_devclass, NULL, NULL); +static devclass_t amdtemp_devclass; +DRIVER_MODULE(amdtemp, hostb, amdtemp_driver, amdtemp_devclass, NULL, NULL); static int -k8temp_match(device_t dev) +amdtemp_match(device_t dev) { int i; uint16_t vendor, devid; @@ -126,9 +142,9 @@ k8temp_match(device_t dev) 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) + for (i = 0; amdtemp_products[i].amdtemp_vendorid != 0; i++) { + if (vendor == amdtemp_products[i].amdtemp_vendorid && + devid == amdtemp_products[i].amdtemp_deviceid) return (1); } @@ -136,28 +152,28 @@ k8temp_match(device_t dev) } static void -k8temp_identify(driver_t *driver, device_t parent) +amdtemp_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) + if (device_find_child(parent, "amdtemp", -1) != NULL) return; - if (k8temp_match(parent)) { - child = device_add_child(parent, "k8temp", -1); + if (amdtemp_match(parent)) { + child = device_add_child(parent, "amdtemp", -1); if (child == NULL) - device_printf(parent, "add k8temp child failed\n"); + device_printf(parent, "add amdtemp child failed\n"); } } static int -k8temp_probe(device_t dev) +amdtemp_probe(device_t dev) { uint32_t regs[4]; - if (resource_disabled("k8temp", 0)) + if (resource_disabled("amdtemp", 0)) return (ENXIO); do_cpuid(1, regs); @@ -173,9 +189,9 @@ k8temp_probe(device_t dev) } static int -k8temp_attach(device_t dev) +amdtemp_attach(device_t dev) { - struct k8temp_softc *sc = device_get_softc(dev); + struct amdtemp_softc *sc = device_get_softc(dev); struct sysctl_ctx_list *sysctlctx; struct sysctl_oid *sysctlnode; @@ -185,7 +201,7 @@ k8temp_attach(device_t dev) * needed because the cpu driver may be loaded late on boot, after * us. */ - sc->sc_ich.ich_func = k8temp_intrhook; + sc->sc_ich.ich_func = amdtemp_intrhook; sc->sc_ich.ich_arg = dev; if (config_intrhook_establish(&sc->sc_ich) != 0) { device_printf(dev, "config_intrhook_establish " @@ -193,8 +209,15 @@ k8temp_attach(device_t dev) return (ENXIO); } + if (pci_get_device(dev) == DEVICEID_AMD_MISC0F) + sc->sc_gettemp = amdtemp_gettemp0f; + else { + sc->sc_gettemp = amdtemp_gettemp; + return (0); + } + /* - * dev.k8temp.N tree. + * dev.amdtemp.N tree. */ sysctlctx = device_get_sysctl_ctx(dev); sysctlnode = SYSCTL_ADD_NODE(sysctlctx, @@ -204,13 +227,13 @@ k8temp_attach(device_t dev) SYSCTL_ADD_PROC(sysctlctx, SYSCTL_CHILDREN(sysctlnode), OID_AUTO, "core0", CTLTYPE_INT | CTLFLAG_RD, - dev, SENSOR0_CORE0, k8temp_sysctl, "I", + dev, SENSOR0_CORE0, amdtemp_sysctl, "IK", "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", + dev, SENSOR0_CORE1, amdtemp_sysctl, "IK", "Sensor 0 / Core 1 temperature"); sysctlnode = SYSCTL_ADD_NODE(sysctlctx, @@ -220,25 +243,25 @@ k8temp_attach(device_t dev) SYSCTL_ADD_PROC(sysctlctx, SYSCTL_CHILDREN(sysctlnode), OID_AUTO, "core0", CTLTYPE_INT | CTLFLAG_RD, - dev, SENSOR1_CORE0, k8temp_sysctl, "I", + dev, SENSOR1_CORE0, amdtemp_sysctl, "IK", "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", + dev, SENSOR1_CORE1, amdtemp_sysctl, "IK", "Sensor 1 / Core 1 temperature"); return (0); } void -k8temp_intrhook(void *arg) +amdtemp_intrhook(void *arg) { int i; device_t nexus, acpi, cpu; device_t dev = (device_t) arg; - struct k8temp_softc *sc; + struct amdtemp_softc *sc; struct sysctl_ctx_list *sysctlctx; sc = device_get_softc(dev); @@ -258,7 +281,7 @@ k8temp_intrhook(void *arg) 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", + dev, CORE0, amdtemp_sysctl, "IK", "Max of sensor 0 / 1"); } } @@ -266,41 +289,42 @@ k8temp_intrhook(void *arg) } int -k8temp_detach(device_t dev) +amdtemp_detach(device_t dev) { int i; - struct k8temp_softc *sc = device_get_softc(dev); + struct amdtemp_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. */ + /* NewBus removes the dev.amdtemp.N tree by itself. */ return (0); } static int -k8temp_sysctl(SYSCTL_HANDLER_ARGS) +amdtemp_sysctl(SYSCTL_HANDLER_ARGS) { device_t dev = (device_t) arg1; + struct amdtemp_softc *sc = device_get_softc(dev); 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); + auxtemp[0] = sc->sc_gettemp(dev, SENSOR0_CORE0); + auxtemp[1] = sc->sc_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); + auxtemp[0] = sc->sc_gettemp(dev, SENSOR0_CORE1); + auxtemp[1] = sc->sc_gettemp(dev, SENSOR1_CORE1); temp = imax(auxtemp[0], auxtemp[1]); break; default: - temp = k8temp_gettemp(dev, arg2); + temp = sc->sc_gettemp(dev, arg2); break; } error = sysctl_handle_int(oidp, &temp, 0, req); @@ -309,34 +333,45 @@ k8temp_sysctl(SYSCTL_HANDLER_ARGS) } static int32_t -k8temp_gettemp(device_t dev, k8sensor_t sensor) +amdtemp_gettemp0f(device_t dev, amdsensor_t sensor) { uint8_t cfg; uint32_t temp; - cfg = pci_read_config(dev, K8TEMP_REG, 1); + cfg = pci_read_config(dev, AMDTEMP_REG0F, 1); switch (sensor) { case SENSOR0_CORE0: - cfg &= ~(K8TEMP_REG_SELSENSOR | K8TEMP_REG_SELCORE); + cfg &= ~(AMDTEMP_REG_SELSENSOR | AMDTEMP_REG_SELCORE); break; case SENSOR0_CORE1: - cfg &= ~K8TEMP_REG_SELSENSOR; - cfg |= K8TEMP_REG_SELCORE; + cfg &= ~AMDTEMP_REG_SELSENSOR; + cfg |= AMDTEMP_REG_SELCORE; break; case SENSOR1_CORE0: - cfg &= ~K8TEMP_REG_SELCORE; - cfg |= K8TEMP_REG_SELSENSOR; + cfg &= ~AMDTEMP_REG_SELCORE; + cfg |= AMDTEMP_REG_SELSENSOR; break; case SENSOR1_CORE1: - cfg |= (K8TEMP_REG_SELSENSOR | K8TEMP_REG_SELCORE); + cfg |= (AMDTEMP_REG_SELSENSOR | AMDTEMP_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; + pci_write_config(dev, AMDTEMP_REG0F, cfg, 1); + temp = pci_read_config(dev, AMDTEMP_REG0F, 4); + temp = ((temp >> 16) & 0xff) * 10 + AMDTEMP_OFFSET0F; return (temp); } + +static int32_t +amdtemp_gettemp(device_t dev, amdsensor_t sensor) +{ + uint32_t temp; + + temp = pci_read_config(dev, AMDTEMP_REG, 4); + temp = ((temp >> 21) & 0x3ff) * 10 / 8 + AMDTEMP_OFFSET; + + return (temp); +}