1 /*- 2 * Copyright (c) 2008, 2009 Rui Paulo <rpaulo@FreeBSD.org> 3 * Copyright (c) 2009 Norikatsu Shigemura <nork@FreeBSD.org> 4 * Copyright (c) 2009-2012 Jung-uk Kim <jkim@FreeBSD.org> 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 18 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 19 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, 20 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 21 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 22 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 24 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 25 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 26 * POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29 /* 30 * Driver for the AMD CPU on-die thermal sensors. 31 * Initially based on the k8temp Linux driver. 32 */ 33 34 #include <sys/cdefs.h> 35 __FBSDID("$FreeBSD$"); 36 37 #include <sys/param.h> 38 #include <sys/bus.h> 39 #include <sys/conf.h> 40 #include <sys/kernel.h> 41 #include <sys/module.h> 42 #include <sys/sysctl.h> 43 #include <sys/systm.h> 44 45 #include <machine/cpufunc.h> 46 #include <machine/md_var.h> 47 #include <machine/specialreg.h> 48 49 #include <dev/pci/pcivar.h> 50 #include <x86/pci_cfgreg.h> 51 52 typedef enum { 53 CORE0_SENSOR0, 54 CORE0_SENSOR1, 55 CORE1_SENSOR0, 56 CORE1_SENSOR1, 57 CORE0, 58 CORE1 59 } amdsensor_t; 60 61 struct amdtemp_softc { 62 device_t sc_dev; 63 int sc_ncores; 64 int sc_ntemps; 65 int sc_flags; 66 #define AMDTEMP_FLAG_CS_SWAP 0x01 /* ThermSenseCoreSel is inverted. */ 67 #define AMDTEMP_FLAG_CT_10BIT 0x02 /* CurTmp is 10-bit wide. */ 68 #define AMDTEMP_FLAG_ALT_OFFSET 0x04 /* CurTmp starts at -28C. */ 69 int32_t sc_offset; 70 int32_t (*sc_gettemp)(device_t, amdsensor_t); 71 struct sysctl_oid *sc_sysctl_cpu[MAXCPU]; 72 struct intr_config_hook sc_ich; 73 }; 74 75 #define VENDORID_AMD 0x1022 76 #define DEVICEID_AMD_MISC0F 0x1103 77 #define DEVICEID_AMD_MISC10 0x1203 78 #define DEVICEID_AMD_MISC11 0x1303 79 #define DEVICEID_AMD_MISC14 0x1703 80 #define DEVICEID_AMD_MISC15 0x1603 81 82 static struct amdtemp_product { 83 uint16_t amdtemp_vendorid; 84 uint16_t amdtemp_deviceid; 85 } amdtemp_products[] = { 86 { VENDORID_AMD, DEVICEID_AMD_MISC0F }, 87 { VENDORID_AMD, DEVICEID_AMD_MISC10 }, 88 { VENDORID_AMD, DEVICEID_AMD_MISC11 }, 89 { VENDORID_AMD, DEVICEID_AMD_MISC14 }, 90 { VENDORID_AMD, DEVICEID_AMD_MISC15 }, 91 { 0, 0 } 92 }; 93 94 /* 95 * Reported Temperature Control Register 96 */ 97 #define AMDTEMP_REPTMP_CTRL 0xa4 98 99 /* 100 * Thermaltrip Status Register (Family 0Fh only) 101 */ 102 #define AMDTEMP_THERMTP_STAT 0xe4 103 #define AMDTEMP_TTSR_SELCORE 0x04 104 #define AMDTEMP_TTSR_SELSENSOR 0x40 105 106 /* 107 * DRAM Configuration High Register 108 */ 109 #define AMDTEMP_DRAM_CONF_HIGH 0x94 /* Function 2 */ 110 #define AMDTEMP_DRAM_MODE_DDR3 0x0100 111 112 /* 113 * CPU Family/Model Register 114 */ 115 #define AMDTEMP_CPUID 0xfc 116 117 /* 118 * Device methods. 119 */ 120 static void amdtemp_identify(driver_t *driver, device_t parent); 121 static int amdtemp_probe(device_t dev); 122 static int amdtemp_attach(device_t dev); 123 static void amdtemp_intrhook(void *arg); 124 static int amdtemp_detach(device_t dev); 125 static int amdtemp_match(device_t dev); 126 static int32_t amdtemp_gettemp0f(device_t dev, amdsensor_t sensor); 127 static int32_t amdtemp_gettemp(device_t dev, amdsensor_t sensor); 128 static int amdtemp_sysctl(SYSCTL_HANDLER_ARGS); 129 130 static device_method_t amdtemp_methods[] = { 131 /* Device interface */ 132 DEVMETHOD(device_identify, amdtemp_identify), 133 DEVMETHOD(device_probe, amdtemp_probe), 134 DEVMETHOD(device_attach, amdtemp_attach), 135 DEVMETHOD(device_detach, amdtemp_detach), 136 137 {0, 0} 138 }; 139 140 static driver_t amdtemp_driver = { 141 "amdtemp", 142 amdtemp_methods, 143 sizeof(struct amdtemp_softc), 144 }; 145 146 static devclass_t amdtemp_devclass; 147 DRIVER_MODULE(amdtemp, hostb, amdtemp_driver, amdtemp_devclass, NULL, NULL); 148 149 static int 150 amdtemp_match(device_t dev) 151 { 152 int i; 153 uint16_t vendor, devid; 154 155 vendor = pci_get_vendor(dev); 156 devid = pci_get_device(dev); 157 158 for (i = 0; amdtemp_products[i].amdtemp_vendorid != 0; i++) { 159 if (vendor == amdtemp_products[i].amdtemp_vendorid && 160 devid == amdtemp_products[i].amdtemp_deviceid) 161 return (1); 162 } 163 164 return (0); 165 } 166 167 static void 168 amdtemp_identify(driver_t *driver, device_t parent) 169 { 170 device_t child; 171 172 /* Make sure we're not being doubly invoked. */ 173 if (device_find_child(parent, "amdtemp", -1) != NULL) 174 return; 175 176 if (amdtemp_match(parent)) { 177 child = device_add_child(parent, "amdtemp", -1); 178 if (child == NULL) 179 device_printf(parent, "add amdtemp child failed\n"); 180 } 181 } 182 183 static int 184 amdtemp_probe(device_t dev) 185 { 186 uint32_t family, model; 187 188 if (resource_disabled("amdtemp", 0)) 189 return (ENXIO); 190 191 family = CPUID_TO_FAMILY(cpu_id); 192 model = CPUID_TO_MODEL(cpu_id); 193 194 switch (family) { 195 case 0x0f: 196 if ((model == 0x04 && (cpu_id & CPUID_STEPPING) == 0) || 197 (model == 0x05 && (cpu_id & CPUID_STEPPING) <= 1)) 198 return (ENXIO); 199 break; 200 case 0x10: 201 case 0x11: 202 case 0x12: 203 case 0x14: 204 case 0x15: 205 break; 206 default: 207 return (ENXIO); 208 } 209 device_set_desc(dev, "AMD CPU On-Die Thermal Sensors"); 210 211 return (BUS_PROBE_GENERIC); 212 } 213 214 static int 215 amdtemp_attach(device_t dev) 216 { 217 char tn[32]; 218 u_int regs[4]; 219 struct amdtemp_softc *sc = device_get_softc(dev); 220 struct sysctl_ctx_list *sysctlctx; 221 struct sysctl_oid *sysctlnode; 222 uint32_t cpuid, family, model; 223 u_int bid; 224 int erratum319, unit; 225 226 erratum319 = 0; 227 228 /* 229 * CPUID Register is available from Revision F. 230 */ 231 cpuid = cpu_id; 232 family = CPUID_TO_FAMILY(cpuid); 233 model = CPUID_TO_MODEL(cpuid); 234 if (family != 0x0f || model >= 0x40) { 235 cpuid = pci_read_config(dev, AMDTEMP_CPUID, 4); 236 family = CPUID_TO_FAMILY(cpuid); 237 model = CPUID_TO_MODEL(cpuid); 238 } 239 240 switch (family) { 241 case 0x0f: 242 /* 243 * Thermaltrip Status Register 244 * 245 * - ThermSenseCoreSel 246 * 247 * Revision F & G: 0 - Core1, 1 - Core0 248 * Other: 0 - Core0, 1 - Core1 249 * 250 * - CurTmp 251 * 252 * Revision G: bits 23-14 253 * Other: bits 23-16 254 * 255 * XXX According to the BKDG, CurTmp, ThermSenseSel and 256 * ThermSenseCoreSel bits were introduced in Revision F 257 * but CurTmp seems working fine as early as Revision C. 258 * However, it is not clear whether ThermSenseSel and/or 259 * ThermSenseCoreSel work in undocumented cases as well. 260 * In fact, the Linux driver suggests it may not work but 261 * we just assume it does until we find otherwise. 262 * 263 * XXX According to Linux, CurTmp starts at -28C on 264 * Socket AM2 Revision G processors, which is not 265 * documented anywhere. 266 */ 267 if (model >= 0x40) 268 sc->sc_flags |= AMDTEMP_FLAG_CS_SWAP; 269 if (model >= 0x60 && model != 0xc1) { 270 do_cpuid(0x80000001, regs); 271 bid = (regs[1] >> 9) & 0x1f; 272 switch (model) { 273 case 0x68: /* Socket S1g1 */ 274 case 0x6c: 275 case 0x7c: 276 break; 277 case 0x6b: /* Socket AM2 and ASB1 (2 cores) */ 278 if (bid != 0x0b && bid != 0x0c) 279 sc->sc_flags |= 280 AMDTEMP_FLAG_ALT_OFFSET; 281 break; 282 case 0x6f: /* Socket AM2 and ASB1 (1 core) */ 283 case 0x7f: 284 if (bid != 0x07 && bid != 0x09 && 285 bid != 0x0c) 286 sc->sc_flags |= 287 AMDTEMP_FLAG_ALT_OFFSET; 288 break; 289 default: 290 sc->sc_flags |= AMDTEMP_FLAG_ALT_OFFSET; 291 } 292 sc->sc_flags |= AMDTEMP_FLAG_CT_10BIT; 293 } 294 295 /* 296 * There are two sensors per core. 297 */ 298 sc->sc_ntemps = 2; 299 300 sc->sc_gettemp = amdtemp_gettemp0f; 301 break; 302 case 0x10: 303 /* 304 * Erratum 319 Inaccurate Temperature Measurement 305 * 306 * http://support.amd.com/us/Processor_TechDocs/41322.pdf 307 */ 308 do_cpuid(0x80000001, regs); 309 switch ((regs[1] >> 28) & 0xf) { 310 case 0: /* Socket F */ 311 erratum319 = 1; 312 break; 313 case 1: /* Socket AM2+ or AM3 */ 314 if ((pci_cfgregread(pci_get_bus(dev), 315 pci_get_slot(dev), 2, AMDTEMP_DRAM_CONF_HIGH, 2) & 316 AMDTEMP_DRAM_MODE_DDR3) != 0 || model > 0x04 || 317 (model == 0x04 && (cpuid & CPUID_STEPPING) >= 3)) 318 break; 319 /* XXX 00100F42h (RB-C2) exists in both formats. */ 320 erratum319 = 1; 321 break; 322 } 323 /* FALLTHROUGH */ 324 case 0x11: 325 case 0x12: 326 case 0x14: 327 case 0x15: 328 /* 329 * There is only one sensor per package. 330 */ 331 sc->sc_ntemps = 1; 332 333 sc->sc_gettemp = amdtemp_gettemp; 334 break; 335 } 336 337 /* Find number of cores per package. */ 338 sc->sc_ncores = (amd_feature2 & AMDID2_CMP) != 0 ? 339 (cpu_procinfo2 & AMDID_CMP_CORES) + 1 : 1; 340 if (sc->sc_ncores > MAXCPU) 341 return (ENXIO); 342 343 if (erratum319) 344 device_printf(dev, 345 "Erratum 319: temperature measurement may be inaccurate\n"); 346 if (bootverbose) 347 device_printf(dev, "Found %d cores and %d sensors.\n", 348 sc->sc_ncores, 349 sc->sc_ntemps > 1 ? sc->sc_ntemps * sc->sc_ncores : 1); 350 351 /* 352 * dev.amdtemp.N tree. 353 */ 354 unit = device_get_unit(dev); 355 snprintf(tn, sizeof(tn), "dev.amdtemp.%d.sensor_offset", unit); 356 TUNABLE_INT_FETCH(tn, &sc->sc_offset); 357 358 sysctlctx = device_get_sysctl_ctx(dev); 359 SYSCTL_ADD_INT(sysctlctx, 360 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, 361 "sensor_offset", CTLFLAG_RW, &sc->sc_offset, 0, 362 "Temperature sensor offset"); 363 sysctlnode = SYSCTL_ADD_NODE(sysctlctx, 364 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, 365 "core0", CTLFLAG_RD, 0, "Core 0"); 366 367 SYSCTL_ADD_PROC(sysctlctx, 368 SYSCTL_CHILDREN(sysctlnode), 369 OID_AUTO, "sensor0", CTLTYPE_INT | CTLFLAG_RD, 370 dev, CORE0_SENSOR0, amdtemp_sysctl, "IK", 371 "Core 0 / Sensor 0 temperature"); 372 373 if (sc->sc_ntemps > 1) { 374 SYSCTL_ADD_PROC(sysctlctx, 375 SYSCTL_CHILDREN(sysctlnode), 376 OID_AUTO, "sensor1", CTLTYPE_INT | CTLFLAG_RD, 377 dev, CORE0_SENSOR1, amdtemp_sysctl, "IK", 378 "Core 0 / Sensor 1 temperature"); 379 380 if (sc->sc_ncores > 1) { 381 sysctlnode = SYSCTL_ADD_NODE(sysctlctx, 382 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), 383 OID_AUTO, "core1", CTLFLAG_RD, 0, "Core 1"); 384 385 SYSCTL_ADD_PROC(sysctlctx, 386 SYSCTL_CHILDREN(sysctlnode), 387 OID_AUTO, "sensor0", CTLTYPE_INT | CTLFLAG_RD, 388 dev, CORE1_SENSOR0, amdtemp_sysctl, "IK", 389 "Core 1 / Sensor 0 temperature"); 390 391 SYSCTL_ADD_PROC(sysctlctx, 392 SYSCTL_CHILDREN(sysctlnode), 393 OID_AUTO, "sensor1", CTLTYPE_INT | CTLFLAG_RD, 394 dev, CORE1_SENSOR1, amdtemp_sysctl, "IK", 395 "Core 1 / Sensor 1 temperature"); 396 } 397 } 398 399 /* 400 * Try to create dev.cpu sysctl entries and setup intrhook function. 401 * This is needed because the cpu driver may be loaded late on boot, 402 * after us. 403 */ 404 amdtemp_intrhook(dev); 405 sc->sc_ich.ich_func = amdtemp_intrhook; 406 sc->sc_ich.ich_arg = dev; 407 if (config_intrhook_establish(&sc->sc_ich) != 0) { 408 device_printf(dev, "config_intrhook_establish failed!\n"); 409 return (ENXIO); 410 } 411 412 return (0); 413 } 414 415 void 416 amdtemp_intrhook(void *arg) 417 { 418 struct amdtemp_softc *sc; 419 struct sysctl_ctx_list *sysctlctx; 420 device_t dev = (device_t)arg; 421 device_t acpi, cpu, nexus; 422 amdsensor_t sensor; 423 int i; 424 425 sc = device_get_softc(dev); 426 427 /* 428 * dev.cpu.N.temperature. 429 */ 430 nexus = device_find_child(root_bus, "nexus", 0); 431 acpi = device_find_child(nexus, "acpi", 0); 432 433 for (i = 0; i < sc->sc_ncores; i++) { 434 if (sc->sc_sysctl_cpu[i] != NULL) 435 continue; 436 cpu = device_find_child(acpi, "cpu", 437 device_get_unit(dev) * sc->sc_ncores + i); 438 if (cpu != NULL) { 439 sysctlctx = device_get_sysctl_ctx(cpu); 440 441 sensor = sc->sc_ntemps > 1 ? 442 (i == 0 ? CORE0 : CORE1) : CORE0_SENSOR0; 443 sc->sc_sysctl_cpu[i] = SYSCTL_ADD_PROC(sysctlctx, 444 SYSCTL_CHILDREN(device_get_sysctl_tree(cpu)), 445 OID_AUTO, "temperature", CTLTYPE_INT | CTLFLAG_RD, 446 dev, sensor, amdtemp_sysctl, "IK", 447 "Current temparature"); 448 } 449 } 450 if (sc->sc_ich.ich_arg != NULL) 451 config_intrhook_disestablish(&sc->sc_ich); 452 } 453 454 int 455 amdtemp_detach(device_t dev) 456 { 457 struct amdtemp_softc *sc = device_get_softc(dev); 458 int i; 459 460 for (i = 0; i < sc->sc_ncores; i++) 461 if (sc->sc_sysctl_cpu[i] != NULL) 462 sysctl_remove_oid(sc->sc_sysctl_cpu[i], 1, 0); 463 464 /* NewBus removes the dev.amdtemp.N tree by itself. */ 465 466 return (0); 467 } 468 469 static int 470 amdtemp_sysctl(SYSCTL_HANDLER_ARGS) 471 { 472 device_t dev = (device_t)arg1; 473 struct amdtemp_softc *sc = device_get_softc(dev); 474 amdsensor_t sensor = (amdsensor_t)arg2; 475 int32_t auxtemp[2], temp; 476 int error; 477 478 switch (sensor) { 479 case CORE0: 480 auxtemp[0] = sc->sc_gettemp(dev, CORE0_SENSOR0); 481 auxtemp[1] = sc->sc_gettemp(dev, CORE0_SENSOR1); 482 temp = imax(auxtemp[0], auxtemp[1]); 483 break; 484 case CORE1: 485 auxtemp[0] = sc->sc_gettemp(dev, CORE1_SENSOR0); 486 auxtemp[1] = sc->sc_gettemp(dev, CORE1_SENSOR1); 487 temp = imax(auxtemp[0], auxtemp[1]); 488 break; 489 default: 490 temp = sc->sc_gettemp(dev, sensor); 491 break; 492 } 493 error = sysctl_handle_int(oidp, &temp, 0, req); 494 495 return (error); 496 } 497 498 #define AMDTEMP_ZERO_C_TO_K 2732 499 500 static int32_t 501 amdtemp_gettemp0f(device_t dev, amdsensor_t sensor) 502 { 503 struct amdtemp_softc *sc = device_get_softc(dev); 504 uint32_t mask, offset, temp; 505 506 /* Set Sensor/Core selector. */ 507 temp = pci_read_config(dev, AMDTEMP_THERMTP_STAT, 1); 508 temp &= ~(AMDTEMP_TTSR_SELCORE | AMDTEMP_TTSR_SELSENSOR); 509 switch (sensor) { 510 case CORE0_SENSOR1: 511 temp |= AMDTEMP_TTSR_SELSENSOR; 512 /* FALLTHROUGH */ 513 case CORE0_SENSOR0: 514 case CORE0: 515 if ((sc->sc_flags & AMDTEMP_FLAG_CS_SWAP) != 0) 516 temp |= AMDTEMP_TTSR_SELCORE; 517 break; 518 case CORE1_SENSOR1: 519 temp |= AMDTEMP_TTSR_SELSENSOR; 520 /* FALLTHROUGH */ 521 case CORE1_SENSOR0: 522 case CORE1: 523 if ((sc->sc_flags & AMDTEMP_FLAG_CS_SWAP) == 0) 524 temp |= AMDTEMP_TTSR_SELCORE; 525 break; 526 } 527 pci_write_config(dev, AMDTEMP_THERMTP_STAT, temp, 1); 528 529 mask = (sc->sc_flags & AMDTEMP_FLAG_CT_10BIT) != 0 ? 0x3ff : 0x3fc; 530 offset = (sc->sc_flags & AMDTEMP_FLAG_ALT_OFFSET) != 0 ? 28 : 49; 531 temp = pci_read_config(dev, AMDTEMP_THERMTP_STAT, 4); 532 temp = ((temp >> 14) & mask) * 5 / 2; 533 temp += AMDTEMP_ZERO_C_TO_K + (sc->sc_offset - offset) * 10; 534 535 return (temp); 536 } 537 538 static int32_t 539 amdtemp_gettemp(device_t dev, amdsensor_t sensor) 540 { 541 struct amdtemp_softc *sc = device_get_softc(dev); 542 uint32_t temp; 543 544 temp = pci_read_config(dev, AMDTEMP_REPTMP_CTRL, 4); 545 temp = ((temp >> 21) & 0x7ff) * 5 / 4; 546 temp += AMDTEMP_ZERO_C_TO_K + sc->sc_offset * 10; 547 548 return (temp); 549 } 550