svn commit: r189769 - head/sys/dev/amdtemp
Rui Paulo
rpaulo at FreeBSD.org
Fri Mar 13 09:28:26 PDT 2009
Author: rpaulo
Date: Fri Mar 13 16:28:25 2009
New Revision: 189769
URL: http://svn.freebsd.org/changeset/base/189769
Log:
Rename all the variables/function names/structs/etc. to reflect the
driver name change.
While there, update copyright.
MFC after: 2 weeks
Modified:
head/sys/dev/amdtemp/amdtemp.c
Modified: head/sys/dev/amdtemp/amdtemp.c
==============================================================================
--- head/sys/dev/amdtemp/amdtemp.c Fri Mar 13 16:08:08 2009 (r189768)
+++ head/sys/dev/amdtemp/amdtemp.c Fri Mar 13 16:28:25 2009 (r189769)
@@ -1,5 +1,6 @@
/*-
- * Copyright (c) 2008 Rui Paulo <rpaulo at FreeBSD.org>
+ * Copyright (c) 2008, 2009 Rui Paulo <rpaulo at FreeBSD.org>
+ * Copyright (c) 2009 Norikatsu Shigemura <nork at FreeBSD.org>
* 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 <sys/cdefs.h>
@@ -48,77 +49,92 @@ __FBSDID("$FreeBSD$");
#include <dev/pci/pcireg.h>
#include <dev/pci/pcivar.h>
-struct k8temp_softc {
+typedef enum {
+ SENSOR0_CORE0,
+ SENSOR0_CORE1,
+ SENSOR1_CORE0,
+ SENSOR1_CORE1,
+ CORE0,
+ CORE1
+} 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_MISC 0x1103
-
-static struct k8temp_product {
- uint16_t k8temp_vendorid;
- uint16_t k8temp_deviceid;
-} k8temp_products[] = {
- { VENDORID_AMD, DEVICEID_AMD_MISC },
+#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
+ * Register control (K8 family)
*/
-#define K8TEMP_REG 0xe4
-#define K8TEMP_REG_SELSENSOR 0x40
-#define K8TEMP_REG_SELCORE 0x04
+#define AMDTEMP_REG0F 0xe4
+#define AMDTEMP_REG_SELSENSOR 0x40
+#define AMDTEMP_REG_SELCORE 0x04
-#define K8TEMP_MINTEMP 49 /* -49 C is the mininum temperature */
+/*
+ * Register control (K10 & K11) family
+ */
+#define AMDTEMP_REG 0xa4
-typedef enum {
- SENSOR0_CORE0,
- SENSOR0_CORE1,
- SENSOR1_CORE0,
- SENSOR1_CORE1,
- CORE0,
- CORE1
-} k8sensor_t;
+#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);
+}
More information about the svn-src-head
mailing list