acpi_cpu_pstate.c revision 1.14
1 /* $NetBSD: acpi_cpu_pstate.c,v 1.14 2010/08/12 06:17:14 jruoho Exp $ */ 2 3 /*- 4 * Copyright (c) 2010 Jukka Ruohonen <jruohonen (at) iki.fi> 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 * 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 */ 29 #include <sys/cdefs.h> 30 __KERNEL_RCSID(0, "$NetBSD: acpi_cpu_pstate.c,v 1.14 2010/08/12 06:17:14 jruoho Exp $"); 31 32 #include <sys/param.h> 33 #include <sys/evcnt.h> 34 #include <sys/kmem.h> 35 #include <sys/once.h> 36 37 #include <dev/acpi/acpireg.h> 38 #include <dev/acpi/acpivar.h> 39 #include <dev/acpi/acpi_cpu.h> 40 41 #define _COMPONENT ACPI_BUS_COMPONENT 42 ACPI_MODULE_NAME ("acpi_cpu_pstate") 43 44 static void acpicpu_pstate_attach_print(struct acpicpu_softc *); 45 static void acpicpu_pstate_attach_evcnt(struct acpicpu_softc *); 46 static void acpicpu_pstate_detach_evcnt(struct acpicpu_softc *); 47 static ACPI_STATUS acpicpu_pstate_pss(struct acpicpu_softc *sc); 48 static ACPI_STATUS acpicpu_pstate_pss_add(struct acpicpu_pstate *, 49 ACPI_OBJECT *); 50 static ACPI_STATUS acpicpu_pstate_pct(struct acpicpu_softc *); 51 static int acpicpu_pstate_max(struct acpicpu_softc *); 52 static void acpicpu_pstate_change(struct acpicpu_softc *); 53 static void acpicpu_pstate_bios(void); 54 55 void 56 acpicpu_pstate_attach(device_t self) 57 { 58 struct acpicpu_softc *sc = device_private(self); 59 const char *str; 60 ACPI_STATUS rv; 61 62 rv = acpicpu_pstate_pss(sc); 63 64 if (ACPI_FAILURE(rv)) { 65 str = "_PSS"; 66 goto fail; 67 } 68 69 rv = acpicpu_pstate_pct(sc); 70 71 if (rv == AE_SUPPORT) { 72 aprint_error_dev(sc->sc_dev, "CPU not supported\n"); 73 return; 74 } 75 76 if (ACPI_FAILURE(rv)) { 77 str = "_PCT"; 78 goto fail; 79 } 80 81 rv = acpicpu_pstate_max(sc); 82 83 if (rv == 0) 84 sc->sc_flags |= ACPICPU_FLAG_P_PPC; 85 86 sc->sc_flags |= ACPICPU_FLAG_P; 87 sc->sc_pstate_current = sc->sc_pstate[0].ps_freq; 88 89 acpicpu_pstate_bios(); 90 acpicpu_pstate_attach_evcnt(sc); 91 acpicpu_pstate_attach_print(sc); 92 93 return; 94 95 fail: 96 aprint_error_dev(sc->sc_dev, "failed to evaluate " 97 "%s: %s\n", str, AcpiFormatException(rv)); 98 } 99 100 static void 101 acpicpu_pstate_attach_print(struct acpicpu_softc *sc) 102 { 103 const uint8_t method = sc->sc_pstate_control.reg_spaceid; 104 struct acpicpu_pstate *ps; 105 static bool once = false; 106 const char *str; 107 uint32_t i; 108 109 if (once != false) 110 return; 111 112 str = (method != ACPI_ADR_SPACE_SYSTEM_IO) ? "FFH" : "I/O"; 113 114 for (i = 0; i < sc->sc_pstate_count; i++) { 115 116 ps = &sc->sc_pstate[i]; 117 118 if (ps->ps_freq == 0) 119 continue; 120 121 aprint_debug_dev(sc->sc_dev, "P%d: %3s, " 122 "lat %3u us, pow %5u mW, %4u MHz\n", 123 i, str, ps->ps_latency, ps->ps_power, ps->ps_freq); 124 } 125 126 once = true; 127 } 128 129 static void 130 acpicpu_pstate_attach_evcnt(struct acpicpu_softc *sc) 131 { 132 struct acpicpu_pstate *ps; 133 uint32_t i; 134 135 for (i = 0; i < sc->sc_pstate_count; i++) { 136 137 ps = &sc->sc_pstate[i]; 138 139 if (ps->ps_freq == 0) 140 continue; 141 142 (void)snprintf(ps->ps_name, sizeof(ps->ps_name), 143 "P%u (%u MHz)", i, ps->ps_freq); 144 145 evcnt_attach_dynamic(&ps->ps_evcnt, EVCNT_TYPE_MISC, 146 NULL, device_xname(sc->sc_dev), ps->ps_name); 147 } 148 } 149 150 int 151 acpicpu_pstate_detach(device_t self) 152 { 153 struct acpicpu_softc *sc = device_private(self); 154 static ONCE_DECL(once_detach); 155 size_t size; 156 int rv; 157 158 if ((sc->sc_flags & ACPICPU_FLAG_P) == 0) 159 return 0; 160 161 rv = RUN_ONCE(&once_detach, acpicpu_md_pstate_stop); 162 163 if (rv != 0) 164 return rv; 165 166 size = sc->sc_pstate_count * sizeof(*sc->sc_pstate); 167 168 if (sc->sc_pstate != NULL) 169 kmem_free(sc->sc_pstate, size); 170 171 sc->sc_flags &= ~ACPICPU_FLAG_P; 172 acpicpu_pstate_detach_evcnt(sc); 173 174 return 0; 175 } 176 177 static void 178 acpicpu_pstate_detach_evcnt(struct acpicpu_softc *sc) 179 { 180 struct acpicpu_pstate *ps; 181 uint32_t i; 182 183 for (i = 0; i < sc->sc_pstate_count; i++) { 184 185 ps = &sc->sc_pstate[i]; 186 187 if (ps->ps_freq != 0) 188 evcnt_detach(&ps->ps_evcnt); 189 } 190 } 191 192 int 193 acpicpu_pstate_start(device_t self) 194 { 195 struct acpicpu_softc *sc = device_private(self); 196 static ONCE_DECL(once_start); 197 198 if ((sc->sc_flags & ACPICPU_FLAG_P) == 0) 199 return 0; 200 201 return RUN_ONCE(&once_start, acpicpu_md_pstate_start); 202 } 203 204 bool 205 acpicpu_pstate_suspend(device_t self) 206 { 207 208 return true; 209 } 210 211 bool 212 acpicpu_pstate_resume(device_t self) 213 { 214 static const ACPI_OSD_EXEC_CALLBACK func = acpicpu_pstate_callback; 215 struct acpicpu_softc *sc = device_private(self); 216 217 KASSERT((sc->sc_flags & ACPICPU_FLAG_P) != 0); 218 219 if ((sc->sc_flags & ACPICPU_FLAG_P_PPC) != 0) 220 (void)AcpiOsExecute(OSL_NOTIFY_HANDLER, func, sc->sc_dev); 221 222 return true; 223 } 224 225 void 226 acpicpu_pstate_callback(void *aux) 227 { 228 struct acpicpu_softc *sc; 229 device_t self = aux; 230 uint32_t old, new; 231 232 sc = device_private(self); 233 234 if ((sc->sc_flags & ACPICPU_FLAG_P_PPC) == 0) 235 return; 236 237 mutex_enter(&sc->sc_mtx); 238 239 old = sc->sc_pstate_max; 240 acpicpu_pstate_change(sc); 241 new = sc->sc_pstate_max; 242 243 mutex_exit(&sc->sc_mtx); 244 245 if (old != new) { 246 247 aprint_debug_dev(sc->sc_dev, "maximum frequency " 248 "changed from P%u (%u MHz) to P%u (%u MHz)\n", 249 old, sc->sc_pstate[old].ps_freq, new, 250 sc->sc_pstate[sc->sc_pstate_max].ps_freq); 251 #if 0 252 /* 253 * If the maximum changed, proactively 254 * raise or lower the target frequency. 255 */ 256 acpicpu_pstate_set(sc, sc->sc_pstate[new].ps_freq); 257 258 #endif 259 } 260 } 261 262 ACPI_STATUS 263 acpicpu_pstate_pss(struct acpicpu_softc *sc) 264 { 265 struct acpicpu_pstate *ps; 266 ACPI_OBJECT *obj; 267 ACPI_BUFFER buf; 268 ACPI_STATUS rv; 269 uint32_t count; 270 uint32_t i, j; 271 272 rv = acpi_eval_struct(sc->sc_node->ad_handle, "_PSS", &buf); 273 274 if (ACPI_FAILURE(rv)) 275 return rv; 276 277 obj = buf.Pointer; 278 279 if (obj->Type != ACPI_TYPE_PACKAGE) { 280 rv = AE_TYPE; 281 goto out; 282 } 283 284 sc->sc_pstate_count = obj->Package.Count; 285 286 if (sc->sc_pstate_count == 0) { 287 rv = AE_NOT_EXIST; 288 goto out; 289 } 290 291 if (sc->sc_pstate_count > ACPICPU_P_STATE_MAX) { 292 rv = AE_LIMIT; 293 goto out; 294 } 295 296 sc->sc_pstate = kmem_zalloc(sc->sc_pstate_count * 297 sizeof(struct acpicpu_pstate), KM_SLEEP); 298 299 if (sc->sc_pstate == NULL) { 300 rv = AE_NO_MEMORY; 301 goto out; 302 } 303 304 for (count = i = 0; i < sc->sc_pstate_count; i++) { 305 306 ps = &sc->sc_pstate[i]; 307 rv = acpicpu_pstate_pss_add(ps, &obj->Package.Elements[i]); 308 309 if (ACPI_FAILURE(rv)) { 310 ps->ps_freq = 0; 311 continue; 312 } 313 314 for (j = 0; j < i; j++) { 315 316 if (ps->ps_freq >= sc->sc_pstate[j].ps_freq) { 317 ps->ps_freq = 0; 318 break; 319 } 320 } 321 322 if (ps->ps_freq != 0) 323 count++; 324 } 325 326 rv = (count != 0) ? AE_OK : AE_NOT_EXIST; 327 328 out: 329 if (buf.Pointer != NULL) 330 ACPI_FREE(buf.Pointer); 331 332 return rv; 333 } 334 335 static ACPI_STATUS 336 acpicpu_pstate_pss_add(struct acpicpu_pstate *ps, ACPI_OBJECT *obj) 337 { 338 ACPI_OBJECT *elm; 339 uint32_t val[6]; 340 uint32_t *p; 341 int i; 342 343 if (obj->Type != ACPI_TYPE_PACKAGE) 344 return AE_TYPE; 345 346 if (obj->Package.Count != 6) 347 return AE_BAD_DATA; 348 349 elm = obj->Package.Elements; 350 351 for (i = 0; i < 6; i++) { 352 353 if (elm[i].Type != ACPI_TYPE_INTEGER) 354 return AE_TYPE; 355 356 if (elm[i].Integer.Value > UINT32_MAX) 357 return AE_AML_NUMERIC_OVERFLOW; 358 359 val[i] = elm[i].Integer.Value; 360 } 361 362 CTASSERT(sizeof(val) == sizeof(struct acpicpu_pstate) - 363 offsetof(struct acpicpu_pstate, ps_freq)); 364 365 p = &ps->ps_freq; 366 367 for (i = 0; i < 6; i++, p++) 368 *p = val[i]; 369 370 if (ps->ps_freq == 0 || ps->ps_freq > 9999) 371 return AE_BAD_DECIMAL_CONSTANT; 372 373 /* 374 * The latency is typically around 10 usec 375 * on Intel CPUs. Use that as the minimum. 376 */ 377 if (ps->ps_latency < 10) 378 ps->ps_latency = 10; 379 380 return AE_OK; 381 } 382 383 ACPI_STATUS 384 acpicpu_pstate_pct(struct acpicpu_softc *sc) 385 { 386 static const size_t size = sizeof(struct acpicpu_reg); 387 struct acpicpu_reg *reg[2]; 388 ACPI_OBJECT *elm, *obj; 389 ACPI_BUFFER buf; 390 ACPI_STATUS rv; 391 uint8_t width; 392 int i; 393 394 rv = acpi_eval_struct(sc->sc_node->ad_handle, "_PCT", &buf); 395 396 if (ACPI_FAILURE(rv)) 397 return rv; 398 399 obj = buf.Pointer; 400 401 if (obj->Type != ACPI_TYPE_PACKAGE) { 402 rv = AE_TYPE; 403 goto out; 404 } 405 406 if (obj->Package.Count != 2) { 407 rv = AE_LIMIT; 408 goto out; 409 } 410 411 for (i = 0; i < 2; i++) { 412 413 elm = &obj->Package.Elements[i]; 414 415 if (elm->Type != ACPI_TYPE_BUFFER) { 416 rv = AE_TYPE; 417 goto out; 418 } 419 420 if (size > elm->Buffer.Length) { 421 rv = AE_AML_BAD_RESOURCE_LENGTH; 422 goto out; 423 } 424 425 reg[i] = (struct acpicpu_reg *)elm->Buffer.Pointer; 426 427 switch (reg[i]->reg_spaceid) { 428 429 case ACPI_ADR_SPACE_SYSTEM_IO: 430 431 if (reg[i]->reg_addr == 0) { 432 rv = AE_AML_ILLEGAL_ADDRESS; 433 goto out; 434 } 435 436 width = reg[i]->reg_bitwidth; 437 438 if (width + reg[i]->reg_bitoffset > 32) { 439 rv = AE_AML_BAD_RESOURCE_VALUE; 440 goto out; 441 } 442 443 if (width != 8 && width != 16 && width != 32) { 444 rv = AE_AML_BAD_RESOURCE_VALUE; 445 goto out; 446 } 447 448 break; 449 450 case ACPI_ADR_SPACE_FIXED_HARDWARE: 451 452 if ((sc->sc_flags & ACPICPU_FLAG_P_FFH) == 0) { 453 rv = AE_SUPPORT; 454 goto out; 455 } 456 457 break; 458 459 default: 460 rv = AE_AML_INVALID_SPACE_ID; 461 goto out; 462 } 463 } 464 465 if (reg[0]->reg_spaceid != reg[1]->reg_spaceid) { 466 rv = AE_AML_INVALID_SPACE_ID; 467 goto out; 468 } 469 470 (void)memcpy(&sc->sc_pstate_control, reg[0], size); /* PERF_CTRL */ 471 (void)memcpy(&sc->sc_pstate_status, reg[1], size); /* PERF_STATUS */ 472 473 out: 474 if (buf.Pointer != NULL) 475 ACPI_FREE(buf.Pointer); 476 477 return rv; 478 } 479 480 static int 481 acpicpu_pstate_max(struct acpicpu_softc *sc) 482 { 483 ACPI_INTEGER val; 484 ACPI_STATUS rv; 485 486 /* 487 * Evaluate the currently highest P-state that can be used. 488 * If available, we can use either this state or any lower 489 * power (i.e. higher numbered) state from the _PSS object. 490 */ 491 rv = acpi_eval_integer(sc->sc_node->ad_handle, "_PPC", &val); 492 493 sc->sc_pstate_max = 0; 494 495 if (ACPI_FAILURE(rv)) 496 return 1; 497 498 if (val > sc->sc_pstate_count - 1) 499 return 1; 500 501 if (sc->sc_pstate[val].ps_freq == 0) 502 return 1; 503 504 sc->sc_pstate_max = val; 505 506 return 0; 507 } 508 509 static void 510 acpicpu_pstate_change(struct acpicpu_softc *sc) 511 { 512 ACPI_OBJECT_LIST arg; 513 ACPI_OBJECT obj[2]; 514 515 arg.Count = 2; 516 arg.Pointer = obj; 517 518 obj[0].Type = ACPI_TYPE_INTEGER; 519 obj[1].Type = ACPI_TYPE_INTEGER; 520 521 obj[0].Integer.Value = ACPICPU_P_NOTIFY; 522 obj[1].Integer.Value = acpicpu_pstate_max(sc); 523 524 (void)AcpiEvaluateObject(sc->sc_node->ad_handle, "_OST", &arg, NULL); 525 } 526 527 static void 528 acpicpu_pstate_bios(void) 529 { 530 const uint8_t val = AcpiGbl_FADT.PstateControl; 531 const uint32_t addr = AcpiGbl_FADT.SmiCommand; 532 533 if (addr == 0) 534 return; 535 536 (void)AcpiOsWritePort(addr, val, 8); 537 } 538 539 int 540 acpicpu_pstate_get(struct acpicpu_softc *sc, uint32_t *freq) 541 { 542 const uint8_t method = sc->sc_pstate_control.reg_spaceid; 543 struct acpicpu_pstate *ps = NULL; 544 uint32_t i, val = 0; 545 uint64_t addr; 546 uint8_t width; 547 int rv; 548 549 if (sc->sc_cold != false) { 550 rv = EBUSY; 551 goto fail; 552 } 553 554 if ((sc->sc_flags & ACPICPU_FLAG_P) == 0) { 555 rv = ENODEV; 556 goto fail; 557 } 558 559 mutex_enter(&sc->sc_mtx); 560 561 if (sc->sc_pstate_current != ACPICPU_P_STATE_UNKNOWN) { 562 *freq = sc->sc_pstate_current; 563 mutex_exit(&sc->sc_mtx); 564 return 0; 565 } 566 567 mutex_exit(&sc->sc_mtx); 568 569 switch (method) { 570 571 case ACPI_ADR_SPACE_FIXED_HARDWARE: 572 573 rv = acpicpu_md_pstate_get(sc, freq); 574 575 if (rv != 0) 576 goto fail; 577 578 break; 579 580 case ACPI_ADR_SPACE_SYSTEM_IO: 581 582 addr = sc->sc_pstate_status.reg_addr; 583 width = sc->sc_pstate_status.reg_bitwidth; 584 585 (void)AcpiOsReadPort(addr, &val, width); 586 587 if (val == 0) { 588 rv = EIO; 589 goto fail; 590 } 591 592 mutex_enter(&sc->sc_mtx); 593 594 for (i = 0; i < sc->sc_pstate_count; i++) { 595 596 if (sc->sc_pstate[i].ps_freq == 0) 597 continue; 598 599 if (val == sc->sc_pstate[i].ps_status) { 600 ps = &sc->sc_pstate[i]; 601 break; 602 } 603 } 604 605 mutex_exit(&sc->sc_mtx); 606 607 if (ps == NULL) { 608 rv = EIO; 609 goto fail; 610 } 611 612 *freq = ps->ps_freq; 613 break; 614 615 default: 616 rv = ENOTTY; 617 goto fail; 618 } 619 620 mutex_enter(&sc->sc_mtx); 621 sc->sc_pstate_current = *freq; 622 mutex_exit(&sc->sc_mtx); 623 624 return 0; 625 626 fail: 627 aprint_error_dev(sc->sc_dev, "failed " 628 "to get frequency (err %d)\n", rv); 629 630 mutex_enter(&sc->sc_mtx); 631 *freq = sc->sc_pstate_current = ACPICPU_P_STATE_UNKNOWN; 632 mutex_exit(&sc->sc_mtx); 633 634 return rv; 635 } 636 637 int 638 acpicpu_pstate_set(struct acpicpu_softc *sc, uint32_t freq) 639 { 640 const uint8_t method = sc->sc_pstate_control.reg_spaceid; 641 struct acpicpu_pstate *ps = NULL; 642 uint32_t i, val; 643 uint64_t addr; 644 uint8_t width; 645 int rv; 646 647 if (sc->sc_cold != false) { 648 rv = EBUSY; 649 goto fail; 650 } 651 652 if ((sc->sc_flags & ACPICPU_FLAG_P) == 0) { 653 rv = ENODEV; 654 goto fail; 655 } 656 657 mutex_enter(&sc->sc_mtx); 658 659 for (i = sc->sc_pstate_max; i < sc->sc_pstate_count; i++) { 660 661 if (sc->sc_pstate[i].ps_freq == 0) 662 continue; 663 664 if (sc->sc_pstate[i].ps_freq == freq) { 665 ps = &sc->sc_pstate[i]; 666 break; 667 } 668 } 669 670 mutex_exit(&sc->sc_mtx); 671 672 if (ps == NULL) { 673 rv = EINVAL; 674 goto fail; 675 } 676 677 switch (method) { 678 679 case ACPI_ADR_SPACE_FIXED_HARDWARE: 680 681 rv = acpicpu_md_pstate_set(ps); 682 683 if (rv != 0) 684 goto fail; 685 686 break; 687 688 case ACPI_ADR_SPACE_SYSTEM_IO: 689 690 addr = sc->sc_pstate_control.reg_addr; 691 width = sc->sc_pstate_control.reg_bitwidth; 692 693 (void)AcpiOsWritePort(addr, ps->ps_control, width); 694 695 addr = sc->sc_pstate_status.reg_addr; 696 width = sc->sc_pstate_status.reg_bitwidth; 697 698 /* 699 * Some systems take longer to respond 700 * than the reported worst-case latency. 701 */ 702 for (i = val = 0; i < ACPICPU_P_STATE_RETRY; i++) { 703 704 (void)AcpiOsReadPort(addr, &val, width); 705 706 if (val == ps->ps_status) 707 break; 708 709 DELAY(ps->ps_latency); 710 } 711 712 if (i == ACPICPU_P_STATE_RETRY) { 713 rv = EAGAIN; 714 goto fail; 715 } 716 717 break; 718 719 default: 720 rv = ENOTTY; 721 goto fail; 722 } 723 724 ps->ps_evcnt.ev_count++; 725 726 mutex_enter(&sc->sc_mtx); 727 sc->sc_pstate_current = freq; 728 mutex_exit(&sc->sc_mtx); 729 730 return 0; 731 732 fail: 733 aprint_error_dev(sc->sc_dev, "failed to set " 734 "frequency to %u (err %d)\n", freq, rv); 735 736 mutex_enter(&sc->sc_mtx); 737 sc->sc_pstate_current = ACPICPU_P_STATE_UNKNOWN; 738 mutex_exit(&sc->sc_mtx); 739 740 return rv; 741 } 742
Indexes created Tue Sep 30 20:09:53 GMT 2025