Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/dev/acpica/acpi_perf.c
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
1 /*- 2 * Copyright (c) 2003-2005 Nate Lawson (SDG) 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 27 #include <sys/cdefs.h> 28 __FBSDID("$FreeBSD: releng/6.1/sys/dev/acpica/acpi_perf.c 153539 2005-12-19 11:19:26Z bruno $"); 29 30 #include "opt_acpi.h" 31 #include <sys/param.h> 32 #include <sys/kernel.h> 33 #include <sys/proc.h> 34 #include <sys/sched.h> 35 #include <sys/bus.h> 36 #include <sys/cpu.h> 37 #include <sys/power.h> 38 #include <sys/malloc.h> 39 #include <sys/module.h> 40 #include <sys/sbuf.h> 41 #include <sys/pcpu.h> 42 43 #include <machine/bus.h> 44 #include <machine/resource.h> 45 #include <sys/rman.h> 46 47 #include <contrib/dev/acpica/acpi.h> 48 #include <dev/acpica/acpivar.h> 49 50 #include "cpufreq_if.h" 51 52 /* 53 * Support for ACPI processor performance states (Px) according to 54 * section 8.3.3 of the ACPI 2.0c specification. 55 */ 56 57 struct acpi_px { 58 uint32_t core_freq; 59 uint32_t power; 60 uint32_t trans_lat; 61 uint32_t bm_lat; 62 uint32_t ctrl_val; 63 uint32_t sts_val; 64 }; 65 66 /* Offsets in struct cf_setting array for storing driver-specific values. */ 67 #define PX_SPEC_CONTROL 0 68 #define PX_SPEC_STATUS 1 69 70 #define MAX_PX_STATES 16 71 72 struct acpi_perf_softc { 73 device_t dev; 74 ACPI_HANDLE handle; 75 struct resource *perf_ctrl; /* Set new performance state. */ 76 int perf_ctrl_type; /* Resource type for perf_ctrl. */ 77 struct resource *perf_status; /* Check that transition succeeded. */ 78 int perf_sts_type; /* Resource type for perf_status. */ 79 struct acpi_px *px_states; /* ACPI perf states. */ 80 uint32_t px_count; /* Total number of perf states. */ 81 uint32_t px_max_avail; /* Lowest index state available. */ 82 int px_curr_state; /* Active state index. */ 83 int px_rid; 84 int info_only; /* Can we set new states? */ 85 }; 86 87 #define PX_GET_REG(reg) \ 88 (bus_space_read_4(rman_get_bustag((reg)), \ 89 rman_get_bushandle((reg)), 0)) 90 #define PX_SET_REG(reg, val) \ 91 (bus_space_write_4(rman_get_bustag((reg)), \ 92 rman_get_bushandle((reg)), 0, (val))) 93 94 #define ACPI_NOTIFY_PERF_STATES 0x80 /* _PSS changed. */ 95 96 static void acpi_perf_identify(driver_t *driver, device_t parent); 97 static int acpi_perf_probe(device_t dev); 98 static int acpi_perf_attach(device_t dev); 99 static int acpi_perf_detach(device_t dev); 100 static int acpi_perf_evaluate(device_t dev); 101 static int acpi_px_to_set(device_t dev, struct acpi_px *px, 102 struct cf_setting *set); 103 static void acpi_px_available(struct acpi_perf_softc *sc); 104 static void acpi_px_startup(void *arg); 105 static void acpi_px_notify(ACPI_HANDLE h, UINT32 notify, void *context); 106 static int acpi_px_settings(device_t dev, struct cf_setting *sets, 107 int *count); 108 static int acpi_px_set(device_t dev, const struct cf_setting *set); 109 static int acpi_px_get(device_t dev, struct cf_setting *set); 110 static int acpi_px_type(device_t dev, int *type); 111 112 static device_method_t acpi_perf_methods[] = { 113 /* Device interface */ 114 DEVMETHOD(device_identify, acpi_perf_identify), 115 DEVMETHOD(device_probe, acpi_perf_probe), 116 DEVMETHOD(device_attach, acpi_perf_attach), 117 DEVMETHOD(device_detach, acpi_perf_detach), 118 119 /* cpufreq interface */ 120 DEVMETHOD(cpufreq_drv_set, acpi_px_set), 121 DEVMETHOD(cpufreq_drv_get, acpi_px_get), 122 DEVMETHOD(cpufreq_drv_type, acpi_px_type), 123 DEVMETHOD(cpufreq_drv_settings, acpi_px_settings), 124 {0, 0} 125 }; 126 127 static driver_t acpi_perf_driver = { 128 "acpi_perf", 129 acpi_perf_methods, 130 sizeof(struct acpi_perf_softc), 131 }; 132 133 static devclass_t acpi_perf_devclass; 134 DRIVER_MODULE(acpi_perf, cpu, acpi_perf_driver, acpi_perf_devclass, 0, 0); 135 MODULE_DEPEND(acpi_perf, acpi, 1, 1, 1); 136 137 MALLOC_DEFINE(M_ACPIPERF, "acpi_perf", "ACPI Performance states"); 138 139 static void 140 acpi_perf_identify(driver_t *driver, device_t parent) 141 { 142 ACPI_HANDLE handle; 143 device_t dev; 144 145 /* Make sure we're not being doubly invoked. */ 146 if (device_find_child(parent, "acpi_perf", -1) != NULL) 147 return; 148 149 /* Get the handle for the Processor object and check for perf states. */ 150 handle = acpi_get_handle(parent); 151 if (handle == NULL) 152 return; 153 if (ACPI_FAILURE(AcpiEvaluateObject(handle, "_PSS", NULL, NULL))) 154 return; 155 156 /* 157 * Add a child to every CPU that has the right methods. In future 158 * versions of the ACPI spec, CPUs can have different settings. 159 * We probe this child now so that other devices that depend 160 * on it (i.e., for info about supported states) will see it. 161 */ 162 if ((dev = BUS_ADD_CHILD(parent, 0, "acpi_perf", -1)) != NULL) 163 device_probe_and_attach(dev); 164 else 165 device_printf(parent, "add acpi_perf child failed\n"); 166 } 167 168 static int 169 acpi_perf_probe(device_t dev) 170 { 171 ACPI_HANDLE handle; 172 ACPI_OBJECT *pkg; 173 struct resource *res; 174 ACPI_BUFFER buf; 175 int error, rid, type; 176 177 if (resource_disabled("acpi_perf", 0)) 178 return (ENXIO); 179 180 /* 181 * Check the performance state registers. If they are of type 182 * "functional fixed hardware", we attach quietly since we will 183 * only be providing information on settings to other drivers. 184 */ 185 error = ENXIO; 186 handle = acpi_get_handle(dev); 187 buf.Pointer = NULL; 188 buf.Length = ACPI_ALLOCATE_BUFFER; 189 if (ACPI_FAILURE(AcpiEvaluateObject(handle, "_PCT", NULL, &buf))) 190 return (error); 191 pkg = (ACPI_OBJECT *)buf.Pointer; 192 if (ACPI_PKG_VALID(pkg, 2)) { 193 rid = 0; 194 error = acpi_PkgGas(dev, pkg, 0, &type, &rid, &res); 195 switch (error) { 196 case 0: 197 bus_release_resource(dev, type, rid, res); 198 bus_delete_resource(dev, type, rid); 199 device_set_desc(dev, "ACPI CPU Frequency Control"); 200 break; 201 case EOPNOTSUPP: 202 device_quiet(dev); 203 error = 0; 204 break; 205 } 206 } 207 AcpiOsFree(buf.Pointer); 208 209 return (error); 210 } 211 212 static int 213 acpi_perf_attach(device_t dev) 214 { 215 struct acpi_perf_softc *sc; 216 217 sc = device_get_softc(dev); 218 sc->dev = dev; 219 sc->handle = acpi_get_handle(dev); 220 sc->px_max_avail = 0; 221 sc->px_curr_state = CPUFREQ_VAL_UNKNOWN; 222 if (acpi_perf_evaluate(dev) != 0) 223 return (ENXIO); 224 AcpiOsQueueForExecution(OSD_PRIORITY_LO, acpi_px_startup, NULL); 225 if (!sc->info_only) 226 cpufreq_register(dev); 227 228 return (0); 229 } 230 231 static int 232 acpi_perf_detach(device_t dev) 233 { 234 /* TODO: teardown registers, remove notify handler. */ 235 return (ENXIO); 236 } 237 238 /* Probe and setup any valid performance states (Px). */ 239 static int 240 acpi_perf_evaluate(device_t dev) 241 { 242 struct acpi_perf_softc *sc; 243 ACPI_BUFFER buf; 244 ACPI_OBJECT *pkg, *res; 245 ACPI_STATUS status; 246 int count, error, i, j; 247 static int once = 1; 248 uint32_t *p; 249 250 /* Get the control values and parameters for each state. */ 251 error = ENXIO; 252 sc = device_get_softc(dev); 253 buf.Pointer = NULL; 254 buf.Length = ACPI_ALLOCATE_BUFFER; 255 status = AcpiEvaluateObject(sc->handle, "_PSS", NULL, &buf); 256 if (ACPI_FAILURE(status)) 257 return (ENXIO); 258 259 pkg = (ACPI_OBJECT *)buf.Pointer; 260 if (!ACPI_PKG_VALID(pkg, 1)) { 261 device_printf(dev, "invalid top level _PSS package\n"); 262 goto out; 263 } 264 sc->px_count = pkg->Package.Count; 265 266 sc->px_states = malloc(sc->px_count * sizeof(struct acpi_px), 267 M_ACPIPERF, M_WAITOK | M_ZERO); 268 if (sc->px_states == NULL) 269 goto out; 270 271 /* 272 * Each state is a package of {CoreFreq, Power, TransitionLatency, 273 * BusMasterLatency, ControlVal, StatusVal}, sorted from highest 274 * performance to lowest. 275 */ 276 count = 0; 277 for (i = 0; i < sc->px_count; i++) { 278 res = &pkg->Package.Elements[i]; 279 if (!ACPI_PKG_VALID(res, 6)) { 280 if (once) { 281 once = 0; 282 device_printf(dev, "invalid _PSS package\n"); 283 } 284 continue; 285 } 286 287 /* Parse the rest of the package into the struct. */ 288 p = &sc->px_states[count].core_freq; 289 for (j = 0; j < 6; j++, p++) 290 acpi_PkgInt32(res, j, p); 291 292 /* 293 * Check for some impossible frequencies that some systems 294 * use to indicate they don't actually support this Px state. 295 */ 296 if (sc->px_states[count].core_freq == 0 || 297 sc->px_states[count].core_freq == 9999 || 298 sc->px_states[count].core_freq == 0x9999 || 299 sc->px_states[count].core_freq >= 0xffff) 300 continue; 301 302 count++; 303 } 304 sc->px_count = count; 305 306 /* No valid Px state found so give up. */ 307 if (count == 0) 308 goto out; 309 AcpiOsFree(buf.Pointer); 310 311 /* Get the control and status registers (one of each). */ 312 buf.Pointer = NULL; 313 buf.Length = ACPI_ALLOCATE_BUFFER; 314 status = AcpiEvaluateObject(sc->handle, "_PCT", NULL, &buf); 315 if (ACPI_FAILURE(status)) 316 goto out; 317 318 /* Check the package of two registers, each a Buffer in GAS format. */ 319 pkg = (ACPI_OBJECT *)buf.Pointer; 320 if (!ACPI_PKG_VALID(pkg, 2)) { 321 device_printf(dev, "invalid perf register package\n"); 322 goto out; 323 } 324 325 error = acpi_PkgGas(sc->dev, pkg, 0, &sc->perf_ctrl_type, &sc->px_rid, 326 &sc->perf_ctrl); 327 if (error) { 328 /* 329 * If the register is of type FFixedHW, we can only return 330 * info, we can't get or set new settings. 331 */ 332 if (error == EOPNOTSUPP) { 333 sc->info_only = TRUE; 334 error = 0; 335 } else 336 device_printf(dev, "failed in PERF_CTL attach\n"); 337 goto out; 338 } 339 sc->px_rid++; 340 341 error = acpi_PkgGas(sc->dev, pkg, 1, &sc->perf_sts_type, &sc->px_rid, 342 &sc->perf_status); 343 if (error) { 344 if (error == EOPNOTSUPP) { 345 sc->info_only = TRUE; 346 error = 0; 347 } else 348 device_printf(dev, "failed in PERF_STATUS attach\n"); 349 goto out; 350 } 351 sc->px_rid++; 352 353 /* Get our current limit and register for notifies. */ 354 acpi_px_available(sc); 355 AcpiInstallNotifyHandler(sc->handle, ACPI_DEVICE_NOTIFY, 356 acpi_px_notify, sc); 357 error = 0; 358 359 out: 360 if (error) { 361 if (sc->px_states) { 362 free(sc->px_states, M_ACPIPERF); 363 sc->px_states = NULL; 364 } 365 if (sc->perf_ctrl) { 366 bus_release_resource(sc->dev, sc->perf_ctrl_type, 0, 367 sc->perf_ctrl); 368 bus_delete_resource(sc->dev, sc->perf_ctrl_type, 0); 369 sc->perf_ctrl = NULL; 370 } 371 if (sc->perf_status) { 372 bus_release_resource(sc->dev, sc->perf_sts_type, 1, 373 sc->perf_status); 374 bus_delete_resource(sc->dev, sc->perf_sts_type, 1); 375 sc->perf_status = NULL; 376 } 377 sc->px_rid = 0; 378 sc->px_count = 0; 379 } 380 if (buf.Pointer) 381 AcpiOsFree(buf.Pointer); 382 return (error); 383 } 384 385 static void 386 acpi_px_startup(void *arg) 387 { 388 389 /* Signal to the platform that we are taking over CPU control. */ 390 if (AcpiGbl_FADT->PstateCnt == 0) 391 return; 392 ACPI_LOCK(acpi); 393 AcpiOsWritePort(AcpiGbl_FADT->SmiCmd, AcpiGbl_FADT->PstateCnt, 8); 394 ACPI_UNLOCK(acpi); 395 } 396 397 static void 398 acpi_px_notify(ACPI_HANDLE h, UINT32 notify, void *context) 399 { 400 struct acpi_perf_softc *sc; 401 402 sc = context; 403 if (notify != ACPI_NOTIFY_PERF_STATES) 404 return; 405 406 acpi_px_available(sc); 407 408 /* TODO: Implement notification when frequency changes. */ 409 } 410 411 /* 412 * Find the highest currently-supported performance state. 413 * This can be called at runtime (e.g., due to a docking event) at 414 * the request of a Notify on the processor object. 415 */ 416 static void 417 acpi_px_available(struct acpi_perf_softc *sc) 418 { 419 ACPI_STATUS status; 420 struct cf_setting set; 421 422 status = acpi_GetInteger(sc->handle, "_PPC", &sc->px_max_avail); 423 424 /* If the old state is too high, set current state to the new max. */ 425 if (ACPI_SUCCESS(status)) { 426 if (sc->px_curr_state != CPUFREQ_VAL_UNKNOWN && 427 sc->px_curr_state > sc->px_max_avail) { 428 acpi_px_to_set(sc->dev, 429 &sc->px_states[sc->px_max_avail], &set); 430 acpi_px_set(sc->dev, &set); 431 } 432 } else 433 sc->px_max_avail = 0; 434 } 435 436 static int 437 acpi_px_to_set(device_t dev, struct acpi_px *px, struct cf_setting *set) 438 { 439 440 if (px == NULL || set == NULL) 441 return (EINVAL); 442 443 set->freq = px->core_freq; 444 set->power = px->power; 445 /* XXX Include BM latency too? */ 446 set->lat = px->trans_lat; 447 set->volts = CPUFREQ_VAL_UNKNOWN; 448 set->dev = dev; 449 set->spec[PX_SPEC_CONTROL] = px->ctrl_val; 450 set->spec[PX_SPEC_STATUS] = px->sts_val; 451 452 return (0); 453 } 454 455 static int 456 acpi_px_settings(device_t dev, struct cf_setting *sets, int *count) 457 { 458 struct acpi_perf_softc *sc; 459 int x, y; 460 461 sc = device_get_softc(dev); 462 if (sets == NULL || count == NULL) 463 return (EINVAL); 464 if (*count < sc->px_count - sc->px_max_avail) 465 return (E2BIG); 466 467 /* Return a list of settings that are currently valid. */ 468 y = 0; 469 for (x = sc->px_max_avail; x < sc->px_count; x++, y++) 470 acpi_px_to_set(dev, &sc->px_states[x], &sets[y]); 471 *count = sc->px_count - sc->px_max_avail; 472 473 return (0); 474 } 475 476 static int 477 acpi_px_set(device_t dev, const struct cf_setting *set) 478 { 479 struct acpi_perf_softc *sc; 480 int i, status, sts_val, tries; 481 482 if (set == NULL) 483 return (EINVAL); 484 sc = device_get_softc(dev); 485 486 /* If we can't set new states, return immediately. */ 487 if (sc->info_only) 488 return (ENXIO); 489 490 /* Look up appropriate state, based on frequency. */ 491 for (i = sc->px_max_avail; i < sc->px_count; i++) { 492 if (CPUFREQ_CMP(set->freq, sc->px_states[i].core_freq)) 493 break; 494 } 495 if (i == sc->px_count) 496 return (EINVAL); 497 498 /* Write the appropriate value to the register. */ 499 PX_SET_REG(sc->perf_ctrl, sc->px_states[i].ctrl_val); 500 501 /* 502 * Try for up to 10 ms to verify the desired state was selected. 503 * This is longer than the standard says (1 ms) but in some modes, 504 * systems may take longer to respond. 505 */ 506 sts_val = sc->px_states[i].sts_val; 507 for (tries = 0; tries < 1000; tries++) { 508 status = PX_GET_REG(sc->perf_status); 509 510 /* 511 * If we match the status or the desired status is 8 bits 512 * and matches the relevant bits, assume we succeeded. It 513 * appears some systems (IBM R32) expect byte-wide access 514 * even though the standard says the register is 32-bit. 515 */ 516 if (status == sts_val || 517 ((sts_val & ~0xff) == 0 && (status & 0xff) == sts_val)) 518 break; 519 DELAY(10); 520 } 521 if (tries == 1000) { 522 device_printf(dev, "Px transition to %d failed\n", 523 sc->px_states[i].core_freq); 524 return (ENXIO); 525 } 526 sc->px_curr_state = i; 527 528 return (0); 529 } 530 531 static int 532 acpi_px_get(device_t dev, struct cf_setting *set) 533 { 534 struct acpi_perf_softc *sc; 535 uint64_t rate; 536 int i; 537 struct pcpu *pc; 538 539 if (set == NULL) 540 return (EINVAL); 541 sc = device_get_softc(dev); 542 543 /* If we can't get new states, return immediately. */ 544 if (sc->info_only) 545 return (ENXIO); 546 547 /* If we've set the rate before, use the cached value. */ 548 if (sc->px_curr_state != CPUFREQ_VAL_UNKNOWN) { 549 acpi_px_to_set(dev, &sc->px_states[sc->px_curr_state], set); 550 return (0); 551 } 552 553 /* Otherwise, estimate and try to match against our settings. */ 554 pc = cpu_get_pcpu(dev); 555 if (pc == NULL) 556 return (ENXIO); 557 cpu_est_clockrate(pc->pc_cpuid, &rate); 558 rate /= 1000000; 559 for (i = 0; i < sc->px_count; i++) { 560 if (CPUFREQ_CMP(sc->px_states[i].core_freq, rate)) { 561 sc->px_curr_state = i; 562 acpi_px_to_set(dev, &sc->px_states[i], set); 563 break; 564 } 565 } 566 567 /* No match, give up. */ 568 if (i == sc->px_count) { 569 sc->px_curr_state = CPUFREQ_VAL_UNKNOWN; 570 set->freq = CPUFREQ_VAL_UNKNOWN; 571 } 572 573 return (0); 574 } 575 576 static int 577 acpi_px_type(device_t dev, int *type) 578 { 579 struct acpi_perf_softc *sc; 580 581 if (type == NULL) 582 return (EINVAL); 583 sc = device_get_softc(dev); 584 585 *type = CPUFREQ_TYPE_ABSOLUTE; 586 if (sc->info_only) 587 *type |= CPUFREQ_FLAG_INFO_ONLY; 588 return (0); 589 }
Cache object: 02042550675816bc0997403f1b2ad4bf
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]