155static void acpi_cpu_notify(ACPI_HANDLE h, UINT32 notify, void *context); 156static int acpi_cpu_quirks(struct acpi_cpu_softc *sc); 157static int acpi_cpu_throttle_sysctl(SYSCTL_HANDLER_ARGS); 158static int acpi_cpu_usage_sysctl(SYSCTL_HANDLER_ARGS); 159static int acpi_cpu_cx_lowest_sysctl(SYSCTL_HANDLER_ARGS); 160 161static device_method_t acpi_cpu_methods[] = { 162 /* Device interface */ 163 DEVMETHOD(device_probe, acpi_cpu_probe), 164 DEVMETHOD(device_attach, acpi_cpu_attach), 165 DEVMETHOD(device_shutdown, acpi_cpu_shutdown), 166 167 {0, 0} 168}; 169 170static driver_t acpi_cpu_driver = { 171 "cpu", 172 acpi_cpu_methods, 173 sizeof(struct acpi_cpu_softc), 174}; 175 176static devclass_t acpi_cpu_devclass; 177DRIVER_MODULE(cpu, acpi, acpi_cpu_driver, acpi_cpu_devclass, 0, 0); 178MODULE_DEPEND(cpu, acpi, 1, 1, 1); 179 180static int 181acpi_cpu_probe(device_t dev) 182{ 183 int acpi_id, cpu_id, cx_count; 184 ACPI_BUFFER buf; 185 ACPI_HANDLE handle; 186 char msg[32]; 187 ACPI_OBJECT *obj; 188 ACPI_STATUS status; 189 190 if (acpi_disabled("cpu") || acpi_get_type(dev) != ACPI_TYPE_PROCESSOR) 191 return (ENXIO); 192 193 handle = acpi_get_handle(dev); 194 if (cpu_softc == NULL) 195 cpu_softc = malloc(sizeof(struct acpi_cpu_softc *) * 196 (mp_maxid + 1), M_TEMP /* XXX */, M_WAITOK | M_ZERO); 197 198 /* Get our Processor object. */ 199 buf.Pointer = NULL; 200 buf.Length = ACPI_ALLOCATE_BUFFER; 201 status = AcpiEvaluateObject(handle, NULL, NULL, &buf); 202 if (ACPI_FAILURE(status)) { 203 device_printf(dev, "probe failed to get Processor obj - %s\n", 204 AcpiFormatException(status)); 205 return (ENXIO); 206 } 207 obj = (ACPI_OBJECT *)buf.Pointer; 208 if (obj->Type != ACPI_TYPE_PROCESSOR) { 209 device_printf(dev, "Processor object has bad type %d\n", obj->Type); 210 AcpiOsFree(obj); 211 return (ENXIO); 212 } 213 214 /* 215 * Find the processor associated with our unit. We could use the 216 * ProcId as a key, however, some boxes do not have the same values 217 * in their Processor object as the ProcId values in the MADT. 218 */ 219 acpi_id = obj->Processor.ProcId; 220 AcpiOsFree(obj); 221 if (acpi_pcpu_get_id(device_get_unit(dev), &acpi_id, &cpu_id) != 0) 222 return (ENXIO); 223 224 /* 225 * Check if we already probed this processor. We scan the bus twice 226 * so it's possible we've already seen this one. 227 */ 228 if (cpu_softc[cpu_id] != NULL) 229 return (ENXIO); 230 231 /* Get a count of Cx states for our device string. */ 232 cx_count = 0; 233 buf.Pointer = NULL; 234 buf.Length = ACPI_ALLOCATE_BUFFER; 235 status = AcpiEvaluateObject(handle, "_CST", NULL, &buf); 236 if (ACPI_SUCCESS(status)) { 237 obj = (ACPI_OBJECT *)buf.Pointer; 238 if (ACPI_PKG_VALID(obj, 2)) 239 acpi_PkgInt32(obj, 0, &cx_count); 240 AcpiOsFree(obj); 241 } else { 242 if (AcpiGbl_FADT->Plvl2Lat <= 100) 243 cx_count++; 244 if (AcpiGbl_FADT->Plvl3Lat <= 1000) 245 cx_count++; 246 if (cx_count > 0) 247 cx_count++; 248 } 249 if (cx_count > 0) 250 snprintf(msg, sizeof(msg), "ACPI CPU (%d Cx states)", cx_count); 251 else 252 strlcpy(msg, "ACPI CPU", sizeof(msg)); 253 device_set_desc_copy(dev, msg); 254 255 /* Mark this processor as in-use and save our derived id for attach. */ 256 cpu_softc[cpu_id] = (void *)1; 257 acpi_set_magic(dev, cpu_id); 258 259 return (0); 260} 261 262static int 263acpi_cpu_attach(device_t dev) 264{ 265 ACPI_BUFFER buf; 266 ACPI_OBJECT *obj; 267 struct acpi_cpu_softc *sc; 268 struct acpi_softc *acpi_sc; 269 ACPI_STATUS status; 270 int thr_ret, cx_ret; 271 272 ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 273 274 sc = device_get_softc(dev); 275 sc->cpu_dev = dev; 276 sc->cpu_handle = acpi_get_handle(dev); 277 cpu_softc[acpi_get_magic(dev)] = sc; 278 279 buf.Pointer = NULL; 280 buf.Length = ACPI_ALLOCATE_BUFFER; 281 status = AcpiEvaluateObject(sc->cpu_handle, NULL, NULL, &buf); 282 if (ACPI_FAILURE(status)) { 283 device_printf(dev, "attach failed to get Processor obj - %s\n", 284 AcpiFormatException(status)); 285 return (ENXIO); 286 } 287 obj = (ACPI_OBJECT *)buf.Pointer; 288 sc->cpu_p_blk = obj->Processor.PblkAddress; 289 sc->cpu_p_blk_len = obj->Processor.PblkLength; 290 sc->acpi_id = obj->Processor.ProcId; 291 AcpiOsFree(obj); 292 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "acpi_cpu%d: P_BLK at %#x/%d\n", 293 device_get_unit(dev), sc->cpu_p_blk, sc->cpu_p_blk_len)); 294 295 acpi_sc = acpi_device_get_parent_softc(dev); 296 sysctl_ctx_init(&acpi_cpu_sysctl_ctx); 297 acpi_cpu_sysctl_tree = SYSCTL_ADD_NODE(&acpi_cpu_sysctl_ctx, 298 SYSCTL_CHILDREN(acpi_sc->acpi_sysctl_tree), 299 OID_AUTO, "cpu", CTLFLAG_RD, 0, ""); 300 301 /* If this is the first device probed, check for quirks. */ 302 if (device_get_unit(dev) == 0) 303 acpi_cpu_quirks(sc); 304 305 /* 306 * Probe for throttling and Cx state support. 307 * If none of these is present, free up unused resources. 308 */ 309 thr_ret = acpi_cpu_throttle_probe(sc); 310 cx_ret = acpi_cpu_cx_probe(sc); 311 if (thr_ret == 0 || cx_ret == 0) { 312 status = AcpiInstallNotifyHandler(sc->cpu_handle, ACPI_DEVICE_NOTIFY, 313 acpi_cpu_notify, sc); 314 if (device_get_unit(dev) == 0) 315 AcpiOsQueueForExecution(OSD_PRIORITY_LO, acpi_cpu_startup, NULL); 316 } else { 317 sysctl_ctx_free(&acpi_cpu_sysctl_ctx); 318 } 319 320 return_VALUE (0); 321} 322 323/* 324 * Find the nth present CPU and return its pc_cpuid as well as set the 325 * pc_acpi_id from the most reliable source. 326 */ 327static int 328acpi_pcpu_get_id(uint32_t idx, uint32_t *acpi_id, uint32_t *cpu_id) 329{ 330 struct pcpu *pcpu_data; 331 uint32_t i; 332 333 KASSERT(acpi_id != NULL, ("Null acpi_id")); 334 KASSERT(cpu_id != NULL, ("Null cpu_id")); 335 for (i = 0; i <= mp_maxid; i++) { 336 if (CPU_ABSENT(i)) 337 continue; 338 pcpu_data = pcpu_find(i); 339 KASSERT(pcpu_data != NULL, ("no pcpu data for %d", i)); 340 if (idx-- == 0) { 341 /* 342 * If pc_acpi_id was not initialized (e.g., a non-APIC UP box) 343 * override it with the value from the ASL. Otherwise, if the 344 * two don't match, prefer the MADT-derived value. Finally, 345 * return the pc_cpuid to reference this processor. 346 */ 347 if (pcpu_data->pc_acpi_id == 0xffffffff) 348 pcpu_data->pc_acpi_id = *acpi_id; 349 else if (pcpu_data->pc_acpi_id != *acpi_id) 350 *acpi_id = pcpu_data->pc_acpi_id; 351 *cpu_id = pcpu_data->pc_cpuid; 352 return (0); 353 } 354 } 355 356 return (ESRCH); 357} 358 359static int 360acpi_cpu_shutdown(device_t dev) 361{ 362 ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 363 364 /* Disable any entry to the idle function. */ 365 cpu_cx_count = 0; 366 367 /* Signal and wait for all processors to exit acpi_cpu_idle(). */ 368 smp_rendezvous(NULL, NULL, NULL, NULL); 369 370 return_VALUE (0); 371} 372 373static int 374acpi_cpu_throttle_probe(struct acpi_cpu_softc *sc) 375{ 376 uint32_t duty_end; 377 ACPI_BUFFER buf; 378 ACPI_OBJECT obj; 379 ACPI_GENERIC_ADDRESS gas; 380 ACPI_STATUS status; 381 382 ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 383 384 /* Get throttling parameters from the FADT. 0 means not supported. */ 385 if (device_get_unit(sc->cpu_dev) == 0) { 386 cpu_smi_cmd = AcpiGbl_FADT->SmiCmd; 387 cpu_pstate_cnt = AcpiGbl_FADT->PstateCnt; 388 cpu_cst_cnt = AcpiGbl_FADT->CstCnt; 389 cpu_duty_offset = AcpiGbl_FADT->DutyOffset; 390 cpu_duty_width = AcpiGbl_FADT->DutyWidth; 391 } 392 if (cpu_duty_width == 0 || (cpu_quirks & CPU_QUIRK_NO_THROTTLE) != 0) 393 return (ENXIO); 394 395 /* Validate the duty offset/width. */ 396 duty_end = cpu_duty_offset + cpu_duty_width - 1; 397 if (duty_end > 31) { 398 device_printf(sc->cpu_dev, "CLK_VAL field overflows P_CNT register\n"); 399 return (ENXIO); 400 } 401 if (cpu_duty_offset <= 4 && duty_end >= 4) { 402 device_printf(sc->cpu_dev, "CLK_VAL field overlaps THT_EN bit\n"); 403 return (ENXIO); 404 } 405 406 /* 407 * If not present, fall back to using the processor's P_BLK to find 408 * the P_CNT register. 409 * 410 * Note that some systems seem to duplicate the P_BLK pointer 411 * across multiple CPUs, so not getting the resource is not fatal. 412 */ 413 buf.Pointer = &obj; 414 buf.Length = sizeof(obj); 415 status = AcpiEvaluateObject(sc->cpu_handle, "_PTC", NULL, &buf); 416 if (ACPI_SUCCESS(status)) { 417 if (obj.Buffer.Length < sizeof(ACPI_GENERIC_ADDRESS) + 3) { 418 device_printf(sc->cpu_dev, "_PTC buffer too small\n"); 419 return (ENXIO); 420 } 421 memcpy(&gas, obj.Buffer.Pointer + 3, sizeof(gas)); 422 sc->cpu_p_cnt = acpi_bus_alloc_gas(sc->cpu_dev, &cpu_rid, &gas); 423 if (sc->cpu_p_cnt != NULL) { 424 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "acpi_cpu%d: P_CNT from _PTC\n", 425 device_get_unit(sc->cpu_dev))); 426 } 427 } 428 429 /* If _PTC not present or other failure, try the P_BLK. */ 430 if (sc->cpu_p_cnt == NULL) { 431 /* 432 * The spec says P_BLK must be 6 bytes long. However, some 433 * systems use it to indicate a fractional set of features 434 * present so we take anything >= 4. 435 */ 436 if (sc->cpu_p_blk_len < 4) 437 return (ENXIO); 438 gas.Address = sc->cpu_p_blk; 439 gas.AddressSpaceId = ACPI_ADR_SPACE_SYSTEM_IO; 440 gas.RegisterBitWidth = 32; 441 sc->cpu_p_cnt = acpi_bus_alloc_gas(sc->cpu_dev, &cpu_rid, &gas); 442 if (sc->cpu_p_cnt != NULL) { 443 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "acpi_cpu%d: P_CNT from P_BLK\n", 444 device_get_unit(sc->cpu_dev))); 445 } else { 446 device_printf(sc->cpu_dev, "Failed to attach throttling P_CNT\n"); 447 return (ENXIO); 448 } 449 } 450 cpu_rid++; 451 452 return (0); 453} 454 455static int 456acpi_cpu_cx_probe(struct acpi_cpu_softc *sc) 457{ 458 ACPI_GENERIC_ADDRESS gas; 459 struct acpi_cx *cx_ptr; 460 int error; 461 462 ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 463 464 /* Bus mastering arbitration control is needed for C3. */ 465 if (AcpiGbl_FADT->V1_Pm2CntBlk == 0 || AcpiGbl_FADT->Pm2CntLen == 0) { 466 cpu_quirks |= CPU_QUIRK_NO_C3; 467 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 468 "acpi_cpu%d: No BM control, C3 disabled\n", 469 device_get_unit(sc->cpu_dev))); 470 } 471 472 /* 473 * First, check for the ACPI 2.0 _CST sleep states object. 474 * If not usable, fall back to the P_BLK's P_LVL2 and P_LVL3. 475 */ 476 sc->cpu_cx_count = 0; 477 error = acpi_cpu_cx_cst(sc); 478 if (error != 0) { 479 cx_ptr = sc->cpu_cx_states; 480 481 /* C1 has been required since just after ACPI 1.0 */ 482 cx_ptr->type = ACPI_STATE_C1; 483 cx_ptr->trans_lat = 0; 484 cpu_non_c3 = 0; 485 cx_ptr++; 486 sc->cpu_cx_count++; 487 488 /* 489 * The spec says P_BLK must be 6 bytes long. However, some systems 490 * use it to indicate a fractional set of features present so we 491 * take 5 as C2. Some may also have a value of 7 to indicate 492 * another C3 but most use _CST for this (as required) and having 493 * "only" C1-C3 is not a hardship. 494 */ 495 if (sc->cpu_p_blk_len < 5) 496 goto done; 497 498 /* Validate and allocate resources for C2 (P_LVL2). */ 499 gas.AddressSpaceId = ACPI_ADR_SPACE_SYSTEM_IO; 500 gas.RegisterBitWidth = 8; 501 if (AcpiGbl_FADT->Plvl2Lat <= 100) { 502 gas.Address = sc->cpu_p_blk + 4; 503 cx_ptr->p_lvlx = acpi_bus_alloc_gas(sc->cpu_dev, &cpu_rid, &gas); 504 if (cx_ptr->p_lvlx != NULL) { 505 cpu_rid++; 506 cx_ptr->type = ACPI_STATE_C2; 507 cx_ptr->trans_lat = AcpiGbl_FADT->Plvl2Lat; 508 cpu_non_c3 = 1; 509 cx_ptr++; 510 sc->cpu_cx_count++; 511 } 512 } 513 if (sc->cpu_p_blk_len < 6) 514 goto done; 515 516 /* Validate and allocate resources for C3 (P_LVL3). */ 517 if (AcpiGbl_FADT->Plvl3Lat <= 1000 && 518 (cpu_quirks & CPU_QUIRK_NO_C3) == 0) { 519 520 gas.Address = sc->cpu_p_blk + 5; 521 cx_ptr->p_lvlx = acpi_bus_alloc_gas(sc->cpu_dev, &cpu_rid, &gas); 522 if (cx_ptr->p_lvlx != NULL) { 523 cpu_rid++; 524 cx_ptr->type = ACPI_STATE_C3; 525 cx_ptr->trans_lat = AcpiGbl_FADT->Plvl3Lat; 526 cx_ptr++; 527 sc->cpu_cx_count++; 528 } 529 } 530 } 531 532done: 533 /* If no valid registers were found, don't attach. */ 534 if (sc->cpu_cx_count == 0) 535 return (ENXIO); 536 537 /* Use initial sleep value of 1 sec. to start with lowest idle state. */ 538 sc->cpu_prev_sleep = 1000000; 539 540 return (0); 541} 542 543/* 544 * Parse a _CST package and set up its Cx states. Since the _CST object 545 * can change dynamically, our notify handler may call this function 546 * to clean up and probe the new _CST package. 547 */ 548static int 549acpi_cpu_cx_cst(struct acpi_cpu_softc *sc) 550{ 551 struct acpi_cx *cx_ptr; 552 ACPI_STATUS status; 553 ACPI_BUFFER buf; 554 ACPI_OBJECT *top; 555 ACPI_OBJECT *pkg; 556 uint32_t count; 557 int i; 558 559 ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 560 561 buf.Pointer = NULL; 562 buf.Length = ACPI_ALLOCATE_BUFFER; 563 status = AcpiEvaluateObject(sc->cpu_handle, "_CST", NULL, &buf); 564 if (ACPI_FAILURE(status)) 565 return (ENXIO); 566 567 /* _CST is a package with a count and at least one Cx package. */ 568 top = (ACPI_OBJECT *)buf.Pointer; 569 if (!ACPI_PKG_VALID(top, 2) || acpi_PkgInt32(top, 0, &count) != 0) { 570 device_printf(sc->cpu_dev, "Invalid _CST package\n"); 571 AcpiOsFree(buf.Pointer); 572 return (ENXIO); 573 } 574 if (count != top->Package.Count - 1) { 575 device_printf(sc->cpu_dev, "Invalid _CST state count (%d != %d)\n", 576 count, top->Package.Count - 1); 577 count = top->Package.Count - 1; 578 } 579 if (count > MAX_CX_STATES) { 580 device_printf(sc->cpu_dev, "_CST has too many states (%d)\n", count); 581 count = MAX_CX_STATES; 582 } 583 584 /* Set up all valid states. */ 585 sc->cpu_cx_count = 0; 586 cx_ptr = sc->cpu_cx_states; 587 for (i = 0; i < count; i++) { 588 pkg = &top->Package.Elements[i + 1]; 589 if (!ACPI_PKG_VALID(pkg, 4) || 590 acpi_PkgInt32(pkg, 1, &cx_ptr->type) != 0 || 591 acpi_PkgInt32(pkg, 2, &cx_ptr->trans_lat) != 0 || 592 acpi_PkgInt32(pkg, 3, &cx_ptr->power) != 0) { 593 594 device_printf(sc->cpu_dev, "Skipping invalid Cx state package\n"); 595 continue; 596 } 597 598 /* Validate the state to see if we should use it. */ 599 switch (cx_ptr->type) { 600 case ACPI_STATE_C1: 601 cpu_non_c3 = i; 602 cx_ptr++; 603 sc->cpu_cx_count++; 604 continue; 605 case ACPI_STATE_C2: 606 if (cx_ptr->trans_lat > 100) { 607 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 608 "acpi_cpu%d: C2[%d] not available.\n", 609 device_get_unit(sc->cpu_dev), i)); 610 continue; 611 } 612 cpu_non_c3 = i; 613 break; 614 case ACPI_STATE_C3: 615 default: 616 if (cx_ptr->trans_lat > 1000 || 617 (cpu_quirks & CPU_QUIRK_NO_C3) != 0) { 618 619 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 620 "acpi_cpu%d: C3[%d] not available.\n", 621 device_get_unit(sc->cpu_dev), i)); 622 continue; 623 } 624 break; 625 } 626 627#ifdef notyet 628 /* Free up any previous register. */ 629 if (cx_ptr->p_lvlx != NULL) { 630 bus_release_resource(sc->cpu_dev, 0, 0, cx_ptr->p_lvlx); 631 cx_ptr->p_lvlx = NULL; 632 } 633#endif 634 635 /* Allocate the control register for C2 or C3. */ 636 acpi_PkgGas(sc->cpu_dev, pkg, 0, &cpu_rid, &cx_ptr->p_lvlx); 637 if (cx_ptr->p_lvlx != NULL) { 638 cpu_rid++; 639 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 640 "acpi_cpu%d: Got C%d - %d latency\n", 641 device_get_unit(sc->cpu_dev), cx_ptr->type, 642 cx_ptr->trans_lat)); 643 cx_ptr++; 644 sc->cpu_cx_count++; 645 } 646 } 647 AcpiOsFree(buf.Pointer); 648 649 return (0); 650} 651 652/* 653 * Call this *after* all CPUs have been attached. 654 */ 655static void 656acpi_cpu_startup(void *arg) 657{ 658 struct acpi_cpu_softc *sc; 659 int count, i; 660 661 /* Get set of CPU devices */ 662 devclass_get_devices(acpi_cpu_devclass, &cpu_devices, &cpu_ndevices); 663 664 /* 665 * Make sure all the processors' Cx counts match. We should probably 666 * also check the contents of each. However, no known systems have 667 * non-matching Cx counts so we'll deal with this later. 668 */ 669 count = MAX_CX_STATES; 670 for (i = 0; i < cpu_ndevices; i++) { 671 sc = device_get_softc(cpu_devices[i]); 672 count = min(sc->cpu_cx_count, count); 673 } 674 cpu_cx_count = count; 675 676 /* Perform throttling and Cx final initialization. */ 677 sc = device_get_softc(cpu_devices[0]); 678 if (sc->cpu_p_cnt != NULL) 679 acpi_cpu_startup_throttling(); 680 if (cpu_cx_count > 0) 681 acpi_cpu_startup_cx(); 682} 683 684/* 685 * Takes the ACPI lock to avoid fighting anyone over the SMI command 686 * port. 687 */ 688static void 689acpi_cpu_startup_throttling() 690{ 691 692 /* Initialise throttling states */ 693 cpu_throttle_max = CPU_MAX_SPEED; 694 cpu_throttle_state = CPU_MAX_SPEED; 695 696 SYSCTL_ADD_INT(&acpi_cpu_sysctl_ctx, 697 SYSCTL_CHILDREN(acpi_cpu_sysctl_tree), 698 OID_AUTO, "throttle_max", CTLFLAG_RD, 699 &cpu_throttle_max, 0, "maximum CPU speed"); 700 SYSCTL_ADD_PROC(&acpi_cpu_sysctl_ctx, 701 SYSCTL_CHILDREN(acpi_cpu_sysctl_tree), 702 OID_AUTO, "throttle_state", 703 CTLTYPE_INT | CTLFLAG_RW, &cpu_throttle_state, 704 0, acpi_cpu_throttle_sysctl, "I", "current CPU speed"); 705 706 /* If ACPI 2.0+, signal platform that we are taking over throttling. */ 707 if (cpu_pstate_cnt != 0) { 708 ACPI_LOCK(acpi); 709 AcpiOsWritePort(cpu_smi_cmd, cpu_pstate_cnt, 8); 710 ACPI_UNLOCK(acpi); 711 } 712 713 /* Set initial speed to maximum. */ 714 ACPI_SERIAL_BEGIN(cpu); 715 acpi_cpu_throttle_set(cpu_throttle_max); 716 ACPI_SERIAL_END(cpu); 717 718 printf("acpi_cpu: throttling enabled, %d steps (100%% to %d.%d%%), " 719 "currently %d.%d%%\n", CPU_MAX_SPEED, CPU_SPEED_PRINTABLE(1), 720 CPU_SPEED_PRINTABLE(cpu_throttle_state)); 721} 722 723static void 724acpi_cpu_startup_cx() 725{ 726 struct acpi_cpu_softc *sc; 727 struct sbuf sb; 728 int i; 729 730 sc = device_get_softc(cpu_devices[0]); 731 sbuf_new(&sb, cpu_cx_supported, sizeof(cpu_cx_supported), SBUF_FIXEDLEN); 732 for (i = 0; i < cpu_cx_count; i++) 733 sbuf_printf(&sb, "C%d/%d ", i + 1, sc->cpu_cx_states[i].trans_lat); 734 sbuf_trim(&sb); 735 sbuf_finish(&sb); 736 SYSCTL_ADD_STRING(&acpi_cpu_sysctl_ctx, 737 SYSCTL_CHILDREN(acpi_cpu_sysctl_tree), 738 OID_AUTO, "cx_supported", CTLFLAG_RD, cpu_cx_supported, 739 0, "Cx/microsecond values for supported Cx states"); 740 SYSCTL_ADD_PROC(&acpi_cpu_sysctl_ctx, 741 SYSCTL_CHILDREN(acpi_cpu_sysctl_tree), 742 OID_AUTO, "cx_lowest", CTLTYPE_STRING | CTLFLAG_RW, 743 NULL, 0, acpi_cpu_cx_lowest_sysctl, "A", 744 "lowest Cx sleep state to use"); 745 SYSCTL_ADD_PROC(&acpi_cpu_sysctl_ctx, 746 SYSCTL_CHILDREN(acpi_cpu_sysctl_tree), 747 OID_AUTO, "cx_usage", CTLTYPE_STRING | CTLFLAG_RD, 748 NULL, 0, acpi_cpu_usage_sysctl, "A", 749 "percent usage for each Cx state"); 750 751#ifdef notyet 752 /* Signal platform that we can handle _CST notification. */ 753 if (cpu_cst_cnt != 0) { 754 ACPI_LOCK(acpi); 755 AcpiOsWritePort(cpu_smi_cmd, cpu_cst_cnt, 8); 756 ACPI_UNLOCK(acpi); 757 } 758#endif 759 760 /* Take over idling from cpu_idle_default(). */ 761 cpu_idle_hook = acpi_cpu_idle; 762} 763 764/* 765 * Set CPUs to the new state. 766 * 767 * Must be called with the ACPI lock held. 768 */ 769static void 770acpi_cpu_throttle_set(uint32_t speed) 771{ 772 struct acpi_cpu_softc *sc; 773 int i; 774 uint32_t p_cnt, clk_val; 775 776 ACPI_SERIAL_ASSERT(cpu); 777 778 /* Iterate over processors */ 779 for (i = 0; i < cpu_ndevices; i++) { 780 sc = device_get_softc(cpu_devices[i]); 781 if (sc->cpu_p_cnt == NULL) 782 continue; 783 784 /* Get the current P_CNT value and disable throttling */ 785 p_cnt = CPU_GET_REG(sc->cpu_p_cnt, 4); 786 p_cnt &= ~CPU_P_CNT_THT_EN; 787 CPU_SET_REG(sc->cpu_p_cnt, 4, p_cnt); 788 789 /* If we're at maximum speed, that's all */ 790 if (speed < CPU_MAX_SPEED) { 791 /* Mask the old CLK_VAL off and or-in the new value */ 792 clk_val = (CPU_MAX_SPEED - 1) << cpu_duty_offset; 793 p_cnt &= ~clk_val; 794 p_cnt |= (speed << cpu_duty_offset); 795 796 /* Write the new P_CNT value and then enable throttling */ 797 CPU_SET_REG(sc->cpu_p_cnt, 4, p_cnt); 798 p_cnt |= CPU_P_CNT_THT_EN; 799 CPU_SET_REG(sc->cpu_p_cnt, 4, p_cnt); 800 } 801 ACPI_VPRINT(sc->cpu_dev, acpi_device_get_parent_softc(sc->cpu_dev), 802 "set speed to %d.%d%%\n", CPU_SPEED_PRINTABLE(speed)); 803 } 804 cpu_throttle_state = speed; 805} 806 807/* 808 * Idle the CPU in the lowest state possible. This function is called with 809 * interrupts disabled. Note that once it re-enables interrupts, a task 810 * switch can occur so do not access shared data (i.e. the softc) after 811 * interrupts are re-enabled. 812 */ 813static void 814acpi_cpu_idle() 815{ 816 struct acpi_cpu_softc *sc; 817 struct acpi_cx *cx_next; 818 uint32_t start_time, end_time; 819 int bm_active, cx_next_idx, i; 820 821 /* If disabled, return immediately. */ 822 if (cpu_cx_count == 0) { 823 ACPI_ENABLE_IRQS(); 824 return; 825 } 826 827 /* 828 * Look up our CPU id to get our softc. If it's NULL, we'll use C1 829 * since there is no ACPI processor object for this CPU. This occurs 830 * for logical CPUs in the HTT case. 831 */ 832 sc = cpu_softc[PCPU_GET(cpuid)]; 833 if (sc == NULL) { 834 acpi_cpu_c1(); 835 return; 836 } 837 838 /* 839 * If we slept 100 us or more, use the lowest Cx state. Otherwise, 840 * find the lowest state that has a latency less than or equal to 841 * the length of our last sleep. 842 */ 843 cx_next_idx = cpu_cx_lowest; 844 if (sc->cpu_prev_sleep < 100) 845 for (i = cpu_cx_lowest; i >= 0; i--) 846 if (sc->cpu_cx_states[i].trans_lat <= sc->cpu_prev_sleep) { 847 cx_next_idx = i; 848 break; 849 } 850 851 /* 852 * Check for bus master activity. If there was activity, clear 853 * the bit and use the lowest non-C3 state. Note that the USB 854 * driver polling for new devices keeps this bit set all the 855 * time if USB is loaded. 856 */ 857 AcpiGetRegister(ACPI_BITREG_BUS_MASTER_STATUS, &bm_active, 858 ACPI_MTX_DO_NOT_LOCK); 859 if (bm_active != 0) { 860 AcpiSetRegister(ACPI_BITREG_BUS_MASTER_STATUS, 1, 861 ACPI_MTX_DO_NOT_LOCK); 862 cx_next_idx = min(cx_next_idx, cpu_non_c3); 863 } 864 865 /* Select the next state and update statistics. */ 866 cx_next = &sc->cpu_cx_states[cx_next_idx]; 867 cpu_cx_stats[cx_next_idx]++; 868 KASSERT(cx_next->type != ACPI_STATE_C0, ("acpi_cpu_idle: C0 sleep")); 869 870 /* 871 * Execute HLT (or equivalent) and wait for an interrupt. We can't 872 * calculate the time spent in C1 since the place we wake up is an 873 * ISR. Assume we slept one quantum and return. 874 */ 875 if (cx_next->type == ACPI_STATE_C1) { 876 sc->cpu_prev_sleep = 1000000 / hz; 877 acpi_cpu_c1(); 878 return; 879 } 880 881 /* For C3, disable bus master arbitration and enable bus master wake. */ 882 if (cx_next->type == ACPI_STATE_C3) { 883 AcpiSetRegister(ACPI_BITREG_ARB_DISABLE, 1, ACPI_MTX_DO_NOT_LOCK); 884 AcpiSetRegister(ACPI_BITREG_BUS_MASTER_RLD, 1, ACPI_MTX_DO_NOT_LOCK); 885 } 886 887 /* 888 * Read from P_LVLx to enter C2(+), checking time spent asleep. 889 * Use the ACPI timer for measuring sleep time. Since we need to 890 * get the time very close to the CPU start/stop clock logic, this 891 * is the only reliable time source. 892 */ 893 AcpiHwLowLevelRead(32, &start_time, &AcpiGbl_FADT->XPmTmrBlk); 894 CPU_GET_REG(cx_next->p_lvlx, 1); 895 896 /* 897 * Read the end time twice. Since it may take an arbitrary time 898 * to enter the idle state, the first read may be executed before 899 * the processor has stopped. Doing it again provides enough 900 * margin that we are certain to have a correct value. 901 */ 902 AcpiHwLowLevelRead(32, &end_time, &AcpiGbl_FADT->XPmTmrBlk); 903 AcpiHwLowLevelRead(32, &end_time, &AcpiGbl_FADT->XPmTmrBlk); 904 905 /* Enable bus master arbitration and disable bus master wakeup. */ 906 if (cx_next->type == ACPI_STATE_C3) { 907 AcpiSetRegister(ACPI_BITREG_ARB_DISABLE, 0, ACPI_MTX_DO_NOT_LOCK); 908 AcpiSetRegister(ACPI_BITREG_BUS_MASTER_RLD, 0, ACPI_MTX_DO_NOT_LOCK); 909 } 910 911 /* Find the actual time asleep in microseconds, minus overhead. */ 912 end_time = acpi_TimerDelta(end_time, start_time); 913 sc->cpu_prev_sleep = PM_USEC(end_time) - cx_next->trans_lat; 914 ACPI_ENABLE_IRQS(); 915} 916
|