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