1 /* 2 * Copyright (c) 2009 The DragonFly Project. All rights reserved. 3 * 4 * This code is derived from software contributed to The DragonFly Project 5 * by Sepherosa Ziehau <sepherosa@gmail.com> 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 15 * the documentation and/or other materials provided with the 16 * distribution. 17 * 3. Neither the name of The DragonFly Project nor the names of its 18 * contributors may be used to endorse or promote products derived 19 * from this software without specific, prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 24 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 25 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 26 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, 27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 31 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 */ 34 35 #include "opt_acpi.h" 36 37 #include <sys/param.h> 38 #include <sys/bus.h> 39 #include <sys/kernel.h> 40 #include <sys/malloc.h> 41 #include <sys/queue.h> 42 #include <sys/rman.h> 43 #include <sys/sysctl.h> 44 #include <sys/msgport2.h> 45 #include <sys/cpu_topology.h> 46 47 #include <net/netisr2.h> 48 #include <net/netmsg2.h> 49 #include <net/if_var.h> 50 51 #include "acpi.h" 52 #include "acpivar.h" 53 #include "acpi_cpu.h" 54 #include "acpi_cpu_pstate.h" 55 56 #define ACPI_NPSTATE_MAX 32 57 58 #define ACPI_PSS_PX_NENTRY 6 59 60 #define ACPI_PSD_COORD_SWALL 0xfc 61 #define ACPI_PSD_COORD_SWANY 0xfd 62 #define ACPI_PSD_COORD_HWALL 0xfe 63 #define ACPI_PSD_COORD_VALID(coord) \ 64 ((coord) == ACPI_PSD_COORD_SWALL || \ 65 (coord) == ACPI_PSD_COORD_SWANY || \ 66 (coord) == ACPI_PSD_COORD_HWALL) 67 68 struct acpi_pst_softc; 69 LIST_HEAD(acpi_pst_list, acpi_pst_softc); 70 71 struct netmsg_acpi_pst { 72 struct netmsg_base base; 73 const struct acpi_pst_res *ctrl; 74 const struct acpi_pst_res *status; 75 }; 76 77 struct acpi_pst_domain { 78 uint32_t pd_dom; 79 uint32_t pd_coord; 80 uint32_t pd_nproc; 81 LIST_ENTRY(acpi_pst_domain) pd_link; 82 83 uint32_t pd_flags; 84 85 int pd_state; 86 struct acpi_pst_list pd_pstlist; 87 88 struct sysctl_ctx_list pd_sysctl_ctx; 89 struct sysctl_oid *pd_sysctl_tree; 90 }; 91 LIST_HEAD(acpi_pst_domlist, acpi_pst_domain); 92 93 #define ACPI_PSTDOM_FLAG_STUB 0x1 /* stub domain, no _PSD */ 94 #define ACPI_PSTDOM_FLAG_DEAD 0x2 /* domain can't be started */ 95 #define ACPI_PSTDOM_FLAG_INT 0x4 /* domain created from Integer _PSD */ 96 97 struct acpi_pst_softc { 98 device_t pst_dev; 99 struct acpi_cpu_softc *pst_parent; 100 struct acpi_pst_domain *pst_domain; 101 struct acpi_pst_res pst_creg; 102 struct acpi_pst_res pst_sreg; 103 104 int pst_state; 105 int pst_cpuid; 106 107 ACPI_HANDLE pst_handle; 108 109 LIST_ENTRY(acpi_pst_softc) pst_link; 110 }; 111 112 static int acpi_pst_probe(device_t dev); 113 static int acpi_pst_attach(device_t dev); 114 115 static void acpi_pst_postattach(void *); 116 static struct acpi_pst_domain * 117 acpi_pst_domain_create_int(device_t, uint32_t); 118 static struct acpi_pst_domain * 119 acpi_pst_domain_create_pkg(device_t, ACPI_OBJECT *); 120 static struct acpi_pst_domain * 121 acpi_pst_domain_find(uint32_t); 122 static struct acpi_pst_domain * 123 acpi_pst_domain_alloc(uint32_t, uint32_t, uint32_t); 124 static int acpi_pst_domain_set_pstate(struct acpi_pst_domain *, int); 125 static void acpi_pst_domain_check_nproc(device_t, struct acpi_pst_domain *); 126 static int acpi_pst_global_set_pstate(int); 127 128 static int acpi_pst_check_csr(struct acpi_pst_softc *); 129 static int acpi_pst_check_pstates(struct acpi_pst_softc *); 130 static int acpi_pst_init(struct acpi_pst_softc *); 131 static int acpi_pst_set_pstate(struct acpi_pst_softc *, 132 const struct acpi_pstate *); 133 static const struct acpi_pstate * 134 acpi_pst_get_pstate(struct acpi_pst_softc *); 135 static int acpi_pst_alloc_resource(device_t, ACPI_OBJECT *, int, 136 struct acpi_pst_res *); 137 138 static void acpi_pst_check_csr_handler(netmsg_t); 139 static void acpi_pst_check_pstates_handler(netmsg_t); 140 static void acpi_pst_init_handler(netmsg_t); 141 static void acpi_pst_set_pstate_handler(netmsg_t); 142 static void acpi_pst_get_pstate_handler(netmsg_t); 143 144 static int acpi_pst_sysctl_freqs(SYSCTL_HANDLER_ARGS); 145 static int acpi_pst_sysctl_freqs_bin(SYSCTL_HANDLER_ARGS); 146 static int acpi_pst_sysctl_power(SYSCTL_HANDLER_ARGS); 147 static int acpi_pst_sysctl_members(SYSCTL_HANDLER_ARGS); 148 static int acpi_pst_sysctl_select(SYSCTL_HANDLER_ARGS); 149 static int acpi_pst_sysctl_global(SYSCTL_HANDLER_ARGS); 150 151 static struct acpi_pst_domlist acpi_pst_domains = 152 LIST_HEAD_INITIALIZER(acpi_pst_domains); 153 static int acpi_pst_domain_id; 154 155 static int acpi_pst_global_state; 156 157 static int acpi_pstate_start = -1; 158 static int acpi_pstate_count; 159 static int acpi_npstates; 160 static struct acpi_pstate *acpi_pstates; 161 162 static const struct acpi_pst_md *acpi_pst_md; 163 164 static int acpi_pst_pdl = -1; 165 TUNABLE_INT("hw.acpi.cpu.pst.pdl", &acpi_pst_pdl); 166 167 static int acpi_pst_ht_reuse_domain = 1; 168 TUNABLE_INT("hw.acpi.cpu.pst.ht_reuse_domain", &acpi_pst_ht_reuse_domain); 169 170 static int acpi_pst_force_pkg_domain = 0; 171 TUNABLE_INT("hw.acpi.cpu.pst.force_pkg_domain", &acpi_pst_force_pkg_domain); 172 173 static device_method_t acpi_pst_methods[] = { 174 /* Device interface */ 175 DEVMETHOD(device_probe, acpi_pst_probe), 176 DEVMETHOD(device_attach, acpi_pst_attach), 177 DEVMETHOD(device_detach, bus_generic_detach), 178 DEVMETHOD(device_shutdown, bus_generic_shutdown), 179 DEVMETHOD(device_suspend, bus_generic_suspend), 180 DEVMETHOD(device_resume, bus_generic_resume), 181 182 /* Bus interface */ 183 DEVMETHOD(bus_add_child, bus_generic_add_child), 184 DEVMETHOD(bus_print_child, bus_generic_print_child), 185 DEVMETHOD(bus_read_ivar, bus_generic_read_ivar), 186 DEVMETHOD(bus_write_ivar, bus_generic_write_ivar), 187 DEVMETHOD(bus_get_resource_list, bus_generic_get_resource_list), 188 DEVMETHOD(bus_set_resource, bus_generic_rl_set_resource), 189 DEVMETHOD(bus_get_resource, bus_generic_rl_get_resource), 190 DEVMETHOD(bus_alloc_resource, bus_generic_alloc_resource), 191 DEVMETHOD(bus_release_resource, bus_generic_release_resource), 192 DEVMETHOD(bus_driver_added, bus_generic_driver_added), 193 DEVMETHOD(bus_activate_resource, bus_generic_activate_resource), 194 DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource), 195 DEVMETHOD(bus_setup_intr, bus_generic_setup_intr), 196 DEVMETHOD(bus_teardown_intr, bus_generic_teardown_intr), 197 198 DEVMETHOD_END 199 }; 200 201 static driver_t acpi_pst_driver = { 202 "cpu_pst", 203 acpi_pst_methods, 204 sizeof(struct acpi_pst_softc) 205 }; 206 207 static devclass_t acpi_pst_devclass; 208 DRIVER_MODULE(cpu_pst, cpu, acpi_pst_driver, acpi_pst_devclass, NULL, NULL); 209 MODULE_DEPEND(cpu_pst, acpi, 1, 1, 1); 210 211 static __inline int 212 acpi_pst_freq2index(int freq) 213 { 214 int i; 215 216 for (i = 0; i < acpi_npstates; ++i) { 217 if (acpi_pstates[i].st_freq == freq) 218 return i; 219 } 220 return -1; 221 } 222 223 static int 224 acpi_pst_probe(device_t dev) 225 { 226 ACPI_BUFFER buf; 227 ACPI_HANDLE handle; 228 ACPI_STATUS status; 229 ACPI_OBJECT *obj; 230 231 if (acpi_disabled("cpu_pst") || 232 acpi_get_type(dev) != ACPI_TYPE_PROCESSOR) 233 return ENXIO; 234 235 if (acpi_pst_md == NULL) 236 acpi_pst_md = acpi_pst_md_probe(); 237 238 handle = acpi_get_handle(dev); 239 240 /* 241 * Check _PSD package 242 * 243 * NOTE: 244 * Some BIOSes do not expose _PCT for the second thread of 245 * CPU cores. In this case, _PSD should be enough to get the 246 * P-state of the second thread working, since it must have 247 * the same _PCT and _PSS as the first thread in the same 248 * core. 249 */ 250 buf.Pointer = NULL; 251 buf.Length = ACPI_ALLOCATE_BUFFER; 252 status = AcpiEvaluateObject(handle, "_PSD", NULL, &buf); 253 if (!ACPI_FAILURE(status)) { 254 AcpiOsFree((ACPI_OBJECT *)buf.Pointer); 255 goto done; 256 } 257 258 /* 259 * Check _PCT package 260 */ 261 buf.Pointer = NULL; 262 buf.Length = ACPI_ALLOCATE_BUFFER; 263 status = AcpiEvaluateObject(handle, "_PCT", NULL, &buf); 264 if (ACPI_FAILURE(status)) { 265 if (bootverbose) { 266 device_printf(dev, "Can't get _PCT package - %s\n", 267 AcpiFormatException(status)); 268 } 269 return ENXIO; 270 } 271 272 obj = (ACPI_OBJECT *)buf.Pointer; 273 if (!ACPI_PKG_VALID_EQ(obj, 2)) { 274 device_printf(dev, "Invalid _PCT package\n"); 275 AcpiOsFree(obj); 276 return ENXIO; 277 } 278 AcpiOsFree(obj); 279 280 /* 281 * Check _PSS package 282 */ 283 buf.Pointer = NULL; 284 buf.Length = ACPI_ALLOCATE_BUFFER; 285 status = AcpiEvaluateObject(handle, "_PSS", NULL, &buf); 286 if (ACPI_FAILURE(status)) { 287 device_printf(dev, "Can't get _PSS package - %s\n", 288 AcpiFormatException(status)); 289 return ENXIO; 290 } 291 292 obj = (ACPI_OBJECT *)buf.Pointer; 293 if (!ACPI_PKG_VALID(obj, 1)) { 294 device_printf(dev, "Invalid _PSS package\n"); 295 AcpiOsFree(obj); 296 return ENXIO; 297 } 298 AcpiOsFree(obj); 299 300 done: 301 device_set_desc(dev, "ACPI CPU P-State"); 302 return 0; 303 } 304 305 static int 306 acpi_pst_attach(device_t dev) 307 { 308 struct acpi_pst_softc *sc = device_get_softc(dev); 309 struct acpi_pst_domain *dom = NULL; 310 ACPI_BUFFER buf; 311 ACPI_STATUS status; 312 ACPI_OBJECT *obj; 313 struct acpi_pstate *pstate, *p; 314 int i, npstate, error, sstart, scount; 315 316 sc->pst_dev = dev; 317 sc->pst_parent = device_get_softc(device_get_parent(dev)); 318 sc->pst_handle = acpi_get_handle(dev); 319 sc->pst_cpuid = acpi_get_magic(dev); 320 321 /* 322 * If there is a _PSD, then we create procossor domain 323 * accordingly. If there is no _PSD, we just fake a 324 * default processor domain0. 325 */ 326 buf.Pointer = NULL; 327 buf.Length = ACPI_ALLOCATE_BUFFER; 328 status = AcpiEvaluateObject(sc->pst_handle, "_PSD", NULL, &buf); 329 if (!ACPI_FAILURE(status)) { 330 obj = (ACPI_OBJECT *)buf.Pointer; 331 332 if (acpi_pst_domain_id > 0) { 333 device_printf(dev, "Missing _PSD for certain CPUs\n"); 334 AcpiOsFree(obj); 335 return ENXIO; 336 } 337 acpi_pst_domain_id = -1; 338 339 if (ACPI_PKG_VALID_EQ(obj, 1)) { 340 dom = acpi_pst_domain_create_pkg(dev, 341 &obj->Package.Elements[0]); 342 if (dom == NULL) { 343 AcpiOsFree(obj); 344 return ENXIO; 345 } 346 } else { 347 if (obj->Type != ACPI_TYPE_INTEGER) { 348 device_printf(dev, 349 "Invalid _PSD package, Type 0x%x\n", 350 obj->Type); 351 AcpiOsFree(obj); 352 return ENXIO; 353 } else { 354 device_printf(dev, "Integer _PSD %ju\n", 355 (uintmax_t)obj->Integer.Value); 356 dom = acpi_pst_domain_create_int(dev, 357 obj->Integer.Value); 358 if (dom == NULL) { 359 AcpiOsFree(obj); 360 return ENXIO; 361 } 362 } 363 } 364 365 /* Free _PSD */ 366 AcpiOsFree(buf.Pointer); 367 } else { 368 if (acpi_pst_domain_id < 0) { 369 device_printf(dev, "Missing _PSD for cpu%d\n", 370 sc->pst_cpuid); 371 return ENXIO; 372 } 373 374 /* 375 * Create a stub one processor domain for each processor 376 */ 377 dom = acpi_pst_domain_alloc(acpi_pst_domain_id, 378 ACPI_PSD_COORD_SWANY, 1); 379 dom->pd_flags |= ACPI_PSTDOM_FLAG_STUB; 380 381 ++acpi_pst_domain_id; 382 } 383 384 /* Make sure that adding us will not overflow our domain */ 385 acpi_pst_domain_check_nproc(dev, dom); 386 387 /* 388 * Get control/status registers from _PCT 389 */ 390 buf.Pointer = NULL; 391 buf.Length = ACPI_ALLOCATE_BUFFER; 392 status = AcpiEvaluateObject(sc->pst_handle, "_PCT", NULL, &buf); 393 if (ACPI_FAILURE(status)) { 394 struct acpi_pst_softc *pst; 395 396 /* 397 * No _PCT. See the comment in acpi_pst_probe() near 398 * _PSD check. 399 * 400 * Use control/status registers of another CPU in the 401 * same domain, or in the same core, if the type of 402 * these registers are "Fixed Hardware", e.g. on most 403 * of the model Intel CPUs. 404 */ 405 pst = LIST_FIRST(&dom->pd_pstlist); 406 if (pst == NULL) { 407 cpumask_t mask; 408 409 mask = get_cpumask_from_level(sc->pst_cpuid, 410 CORE_LEVEL); 411 if (CPUMASK_TESTNZERO(mask)) { 412 struct acpi_pst_domain *dom1; 413 414 LIST_FOREACH(dom1, &acpi_pst_domains, pd_link) { 415 LIST_FOREACH(pst, &dom1->pd_pstlist, 416 pst_link) { 417 if (CPUMASK_TESTBIT(mask, 418 pst->pst_cpuid)) 419 break; 420 } 421 if (pst != NULL) 422 break; 423 } 424 if (pst != NULL && acpi_pst_ht_reuse_domain) { 425 /* 426 * Use the same domain for CPUs in the 427 * same core. 428 */ 429 device_printf(dev, "Destroy domain%u, " 430 "reuse domain%u\n", 431 dom->pd_dom, dom1->pd_dom); 432 LIST_REMOVE(dom, pd_link); 433 kfree(dom, M_DEVBUF); 434 dom = dom1; 435 /* 436 * Make sure that adding us will not 437 * overflow the domain containing 438 * siblings in the same core. 439 */ 440 acpi_pst_domain_check_nproc(dev, dom); 441 } 442 } 443 } 444 if (pst != NULL && 445 pst->pst_creg.pr_res == NULL && 446 pst->pst_creg.pr_rid == 0 && 447 pst->pst_creg.pr_gas.SpaceId == 448 ACPI_ADR_SPACE_FIXED_HARDWARE && 449 pst->pst_sreg.pr_res == NULL && 450 pst->pst_sreg.pr_rid == 0 && 451 pst->pst_sreg.pr_gas.SpaceId == 452 ACPI_ADR_SPACE_FIXED_HARDWARE) { 453 sc->pst_creg = pst->pst_creg; 454 sc->pst_sreg = pst->pst_sreg; 455 device_printf(dev, 456 "No _PCT; reuse %s control/status regs\n", 457 device_get_nameunit(pst->pst_dev)); 458 goto fetch_pss; 459 } 460 device_printf(dev, "Can't get _PCT package - %s\n", 461 AcpiFormatException(status)); 462 return ENXIO; 463 } 464 465 obj = (ACPI_OBJECT *)buf.Pointer; 466 if (!ACPI_PKG_VALID_EQ(obj, 2)) { 467 device_printf(dev, "Invalid _PCT package\n"); 468 AcpiOsFree(obj); 469 return ENXIO; 470 } 471 472 /* Save and try allocating control register */ 473 error = acpi_pst_alloc_resource(dev, obj, 0, &sc->pst_creg); 474 if (error) { 475 AcpiOsFree(obj); 476 return error; 477 } 478 if (bootverbose) { 479 device_printf(dev, "control reg %d %jx\n", 480 sc->pst_creg.pr_gas.SpaceId, 481 (uintmax_t)sc->pst_creg.pr_gas.Address); 482 } 483 484 /* Save and try allocating status register */ 485 error = acpi_pst_alloc_resource(dev, obj, 1, &sc->pst_sreg); 486 if (error) { 487 AcpiOsFree(obj); 488 return error; 489 } 490 if (bootverbose) { 491 device_printf(dev, "status reg %d %jx\n", 492 sc->pst_sreg.pr_gas.SpaceId, 493 (uintmax_t)sc->pst_sreg.pr_gas.Address); 494 } 495 496 /* Free _PCT */ 497 AcpiOsFree(obj); 498 499 fetch_pss: 500 /* 501 * Create P-State table according to _PSS 502 */ 503 buf.Pointer = NULL; 504 buf.Length = ACPI_ALLOCATE_BUFFER; 505 status = AcpiEvaluateObject(sc->pst_handle, "_PSS", NULL, &buf); 506 if (ACPI_FAILURE(status)) { 507 /* 508 * No _PSS. See the comment in acpi_pst_probe() near 509 * _PSD check. 510 * 511 * Assume _PSS are same across all CPUs; well, they 512 * should/have to be so. 513 */ 514 if (acpi_npstates > 0 && acpi_pstates != NULL) { 515 device_printf(dev, "No _PSS\n"); 516 goto fetch_ppc; 517 } 518 device_printf(dev, "Can't get _PSS package - %s\n", 519 AcpiFormatException(status)); 520 return ENXIO; 521 } 522 523 obj = (ACPI_OBJECT *)buf.Pointer; 524 if (!ACPI_PKG_VALID(obj, 1)) { 525 device_printf(dev, "Invalid _PSS package\n"); 526 AcpiOsFree(obj); 527 return ENXIO; 528 } 529 530 /* Don't create too many P-States */ 531 npstate = obj->Package.Count; 532 if (npstate > ACPI_NPSTATE_MAX) { 533 device_printf(dev, "Too many P-States, %d->%d\n", 534 npstate, ACPI_NPSTATE_MAX); 535 npstate = ACPI_NPSTATE_MAX; 536 } 537 538 /* 539 * If we have already created P-State table, 540 * we must make sure that number of entries 541 * is consistent. 542 */ 543 if (acpi_pstates != NULL && acpi_npstates != npstate) { 544 device_printf(dev, "Inconsistent # of P-States " 545 "cross Processor objects\n"); 546 AcpiOsFree(obj); 547 return ENXIO; 548 } 549 550 /* 551 * Create a temporary P-State table 552 */ 553 pstate = kmalloc(sizeof(*pstate) * npstate, M_TEMP, M_WAITOK); 554 for (i = 0, p = pstate; i < npstate; ++i, ++p) { 555 ACPI_OBJECT *pkg; 556 uint32_t *ptr[ACPI_PSS_PX_NENTRY] = { 557 &p->st_freq, &p->st_power, &p->st_xsit_lat, 558 &p->st_bm_lat, &p->st_cval, &p->st_sval 559 }; 560 int j; 561 562 pkg = &obj->Package.Elements[i]; 563 if (!ACPI_PKG_VALID(pkg, ACPI_PSS_PX_NENTRY)) { 564 device_printf(dev, "Invalud _PSS P%d\n", i); 565 AcpiOsFree(obj); 566 kfree(pstate, M_TEMP); 567 return ENXIO; 568 } 569 for (j = 0; j < ACPI_PSS_PX_NENTRY; ++j) { 570 if (acpi_PkgInt32(pkg, j, ptr[j]) != 0) { 571 device_printf(dev, "Can't extract " 572 "_PSS P%d %dth entry\n", i, j); 573 AcpiOsFree(obj); 574 kfree(pstate, M_TEMP); 575 return ENXIO; 576 } 577 } 578 } 579 580 /* Free _PSS */ 581 AcpiOsFree(obj); 582 583 if (acpi_pstates == NULL) { 584 /* 585 * If no P-State table is created yet, 586 * save the temporary one we just created. 587 */ 588 acpi_pstates = pstate; 589 acpi_npstates = npstate; 590 pstate = NULL; 591 592 if (bootverbose) { 593 for (i = 0; i < acpi_npstates; ++i) { 594 device_printf(dev, 595 "freq %u, pwr %u, xlat %u, blat %u, " 596 "cv %08x, sv %08x\n", 597 acpi_pstates[i].st_freq, 598 acpi_pstates[i].st_power, 599 acpi_pstates[i].st_xsit_lat, 600 acpi_pstates[i].st_bm_lat, 601 acpi_pstates[i].st_cval, 602 acpi_pstates[i].st_sval); 603 } 604 } 605 } else { 606 /* 607 * Make sure that P-State tables are same 608 * for all processors. 609 */ 610 if (memcmp(pstate, acpi_pstates, 611 sizeof(*pstate) * npstate) != 0) { 612 device_printf(dev, "Inconsistent _PSS " 613 "cross Processor objects\n"); 614 #if 0 615 /* 616 * Some BIOSes create different P-State tables; 617 * just trust the one from the BSP and move on. 618 */ 619 kfree(pstate, M_TEMP); 620 return ENXIO; 621 #endif 622 } 623 kfree(pstate, M_TEMP); 624 } 625 626 fetch_ppc: 627 /* By default, we start from P-State table's first entry */ 628 sstart = 0; 629 630 /* 631 * Adjust the usable first entry of P-State table, 632 * if there is _PPC object. 633 */ 634 buf.Pointer = NULL; 635 buf.Length = ACPI_ALLOCATE_BUFFER; 636 status = AcpiEvaluateObject(sc->pst_handle, "_PPC", NULL, &buf); 637 if (!ACPI_FAILURE(status)) { 638 ACPI_OBJECT_LIST arglist; 639 ACPI_OBJECT arg[2]; 640 641 obj = (ACPI_OBJECT *)buf.Pointer; 642 if (obj->Type == ACPI_TYPE_INTEGER) { 643 if (obj->Integer.Value >= acpi_npstates) { 644 device_printf(dev, "Invalid _PPC value\n"); 645 AcpiOsFree(obj); 646 return ENXIO; 647 } 648 sstart = obj->Integer.Value; 649 if (bootverbose) 650 device_printf(dev, "_PPC %d\n", sstart); 651 652 /* TODO: Install notifiy handler */ 653 } else { 654 device_printf(dev, "Invalid _PPC object\n"); 655 AcpiOsFree(obj); 656 return ENXIO; 657 } 658 659 /* Free _PPC */ 660 AcpiOsFree(obj); 661 662 /* _PPC has been successfully processed */ 663 arglist.Pointer = arg; 664 arglist.Count = 2; 665 arg[0].Type = ACPI_TYPE_INTEGER; 666 arg[0].Integer.Value = 0x80; 667 arg[1].Type = ACPI_TYPE_INTEGER; 668 arg[1].Integer.Value = 0; 669 AcpiEvaluateObject(sc->pst_handle, "_OST", &arglist, NULL); 670 } 671 if (acpi_pstate_start < 0) { 672 acpi_pstate_start = sstart; 673 } else if (acpi_pstate_start != sstart) { 674 device_printf(dev, "_PPC mismatch, was %d, now %d\n", 675 acpi_pstate_start, sstart); 676 if (acpi_pstate_start < sstart) { 677 device_printf(dev, "_PPC %d -> %d\n", 678 acpi_pstate_start, sstart); 679 acpi_pstate_start = sstart; 680 } 681 } 682 683 /* 684 * By default, we assume number of usable P-States is same as 685 * number of P-States. 686 */ 687 scount = acpi_npstates; 688 689 /* 690 * Allow users to override or set _PDL 691 */ 692 if (acpi_pst_pdl >= 0) { 693 if (acpi_pst_pdl < acpi_npstates) { 694 if (bootverbose) { 695 device_printf(dev, "_PDL override %d\n", 696 acpi_pst_pdl); 697 } 698 scount = acpi_pst_pdl + 1; 699 goto proc_pdl; 700 } else { 701 device_printf(dev, "Invalid _PDL override %d, " 702 "must be less than %d\n", acpi_pst_pdl, 703 acpi_npstates); 704 } 705 } 706 707 /* 708 * Adjust the number of usable entries in P-State table, 709 * if there is _PDL object. 710 */ 711 buf.Pointer = NULL; 712 buf.Length = ACPI_ALLOCATE_BUFFER; 713 status = AcpiEvaluateObject(sc->pst_handle, "_PDL", NULL, &buf); 714 if (!ACPI_FAILURE(status)) { 715 obj = (ACPI_OBJECT *)buf.Pointer; 716 if (obj->Type == ACPI_TYPE_INTEGER) { 717 if (obj->Integer.Value >= acpi_npstates) { 718 device_printf(dev, "Invalid _PDL value\n"); 719 AcpiOsFree(obj); 720 return ENXIO; 721 } 722 if (obj->Integer.Value >= acpi_pstate_start) { 723 scount = obj->Integer.Value + 1; 724 if (bootverbose) 725 device_printf(dev, "_PDL %d\n", scount); 726 } else { 727 /* Prefer _PPC as stated in ACPI 5.1 8.4.4.6 */ 728 device_printf(dev, "conflict _PDL %ju and " 729 "_PPC %d, ignore\n", 730 (uintmax_t)obj->Integer.Value, 731 acpi_pstate_start); 732 } 733 734 /* TODO: Install notifiy handler */ 735 } else { 736 device_printf(dev, "Invalid _PDL object\n"); 737 AcpiOsFree(obj); 738 return ENXIO; 739 } 740 741 /* Free _PDL */ 742 AcpiOsFree(obj); 743 } 744 proc_pdl: 745 if (acpi_pstate_count == 0) { 746 acpi_pstate_count = scount; 747 } else if (acpi_pstate_count != scount) { 748 device_printf(dev, "_PDL mismatch, was %d, now %d\n", 749 acpi_pstate_count, scount); 750 if (acpi_pstate_count > scount) { 751 device_printf(dev, "_PDL %d -> %d\n", 752 acpi_pstate_count, scount); 753 acpi_pstate_count = scount; 754 } 755 } 756 757 /* 758 * Some CPUs only have package P-states, but some BIOSes put each 759 * hyperthread to its own P-state domain; allow user to override. 760 */ 761 if (LIST_EMPTY(&dom->pd_pstlist) && acpi_pst_force_pkg_domain) { 762 cpumask_t mask; 763 764 mask = get_cpumask_from_level(sc->pst_cpuid, CHIP_LEVEL); 765 if (CPUMASK_TESTNZERO(mask)) { 766 struct acpi_pst_softc *pst = NULL; 767 struct acpi_pst_domain *dom1; 768 769 LIST_FOREACH(dom1, &acpi_pst_domains, pd_link) { 770 LIST_FOREACH(pst, &dom1->pd_pstlist, 771 pst_link) { 772 if (CPUMASK_TESTBIT(mask, 773 pst->pst_cpuid)) 774 break; 775 } 776 if (pst != NULL) 777 break; 778 } 779 if (pst != NULL && 780 memcmp(&pst->pst_creg, &sc->pst_creg, 781 sizeof(sc->pst_creg)) == 0 && 782 memcmp(&pst->pst_sreg, &sc->pst_sreg, 783 sizeof(sc->pst_sreg)) == 0) { 784 /* 785 * Use the same domain for CPUs in the 786 * same package. 787 */ 788 device_printf(dev, "Destroy domain%u, " 789 "force pkg domain%u\n", 790 dom->pd_dom, dom1->pd_dom); 791 LIST_REMOVE(dom, pd_link); 792 kfree(dom, M_DEVBUF); 793 dom = dom1; 794 /* 795 * Make sure that adding us will not 796 * overflow the domain containing 797 * siblings in the same package. 798 */ 799 acpi_pst_domain_check_nproc(dev, dom); 800 } 801 } 802 } 803 804 /* Link us with the domain */ 805 sc->pst_domain = dom; 806 LIST_INSERT_HEAD(&dom->pd_pstlist, sc, pst_link); 807 808 if (device_get_unit(dev) == 0) 809 AcpiOsExecute(OSL_NOTIFY_HANDLER, acpi_pst_postattach, NULL); 810 811 return 0; 812 } 813 814 static struct acpi_pst_domain * 815 acpi_pst_domain_create_pkg(device_t dev, ACPI_OBJECT *obj) 816 { 817 struct acpi_pst_domain *dom; 818 uint32_t val, domain, coord, nproc; 819 820 if (!ACPI_PKG_VALID_EQ(obj, 5)) { 821 device_printf(dev, "Invalid _PSD package\n"); 822 return NULL; 823 } 824 825 /* NumberOfEntries */ 826 if (acpi_PkgInt32(obj, 0, &val) != 0 || val != 5) { 827 device_printf(dev, "Invalid _PSD NumberOfEntries\n"); 828 return NULL; 829 } 830 831 /* Revision */ 832 if (acpi_PkgInt32(obj, 1, &val) != 0 || val != 0) { 833 device_printf(dev, "Invalid _PSD Revision\n"); 834 return NULL; 835 } 836 837 if (acpi_PkgInt32(obj, 2, &domain) != 0 || 838 acpi_PkgInt32(obj, 3, &coord) != 0 || 839 acpi_PkgInt32(obj, 4, &nproc) != 0) { 840 device_printf(dev, "Can't extract _PSD package\n"); 841 return NULL; 842 } 843 844 if (!ACPI_PSD_COORD_VALID(coord)) { 845 device_printf(dev, "Invalid _PSD CoordType (%#x)\n", coord); 846 return NULL; 847 } 848 849 if (nproc > MAXCPU) { 850 /* 851 * If NumProcessors is greater than MAXCPU 852 * and domain's coordination is SWALL, then 853 * we will never be able to start all CPUs 854 * within this domain, and power state 855 * transition will never be completed, so we 856 * just bail out here. 857 */ 858 if (coord == ACPI_PSD_COORD_SWALL) { 859 device_printf(dev, "Unsupported _PSD NumProcessors " 860 "(%d)\n", nproc); 861 return NULL; 862 } 863 } else if (nproc == 0) { 864 device_printf(dev, "_PSD NumProcessors are zero\n"); 865 return NULL; 866 } 867 868 dom = acpi_pst_domain_find(domain); 869 if (dom != NULL) { 870 if (dom->pd_flags & ACPI_PSTDOM_FLAG_INT) { 871 device_printf(dev, "Mixed Integer _PSD and " 872 "Package _PSD\n"); 873 return NULL; 874 } 875 if (dom->pd_coord != coord) { 876 device_printf(dev, "Inconsistent _PSD coord " 877 "information cross Processor objects\n"); 878 return NULL; 879 } 880 if (dom->pd_nproc != nproc) { 881 device_printf(dev, "Inconsistent _PSD nproc " 882 "information cross Processor objects\n"); 883 /* 884 * Some stupid BIOSes will set wrong "# of processors", 885 * e.g. 1 for CPU w/ hyperthreading; Be lenient here. 886 */ 887 } 888 return dom; 889 } 890 891 dom = acpi_pst_domain_alloc(domain, coord, nproc); 892 if (bootverbose) { 893 device_printf(dev, "create pkg domain%u, coord %#x\n", 894 dom->pd_dom, dom->pd_coord); 895 } 896 897 return dom; 898 } 899 900 static struct acpi_pst_domain * 901 acpi_pst_domain_create_int(device_t dev, uint32_t domain) 902 { 903 struct acpi_pst_domain *dom; 904 905 dom = acpi_pst_domain_find(domain); 906 if (dom != NULL) { 907 if ((dom->pd_flags & ACPI_PSTDOM_FLAG_INT) == 0) { 908 device_printf(dev, "Mixed Package _PSD and " 909 "Integer _PSD\n"); 910 return NULL; 911 } 912 KKASSERT(dom->pd_coord == ACPI_PSD_COORD_SWALL); 913 914 dom->pd_nproc++; 915 return dom; 916 } 917 918 dom = acpi_pst_domain_alloc(domain, ACPI_PSD_COORD_SWALL, 1); 919 dom->pd_flags |= ACPI_PSTDOM_FLAG_INT; 920 921 if (bootverbose) 922 device_printf(dev, "create int domain%u\n", dom->pd_dom); 923 924 return dom; 925 } 926 927 static struct acpi_pst_domain * 928 acpi_pst_domain_find(uint32_t domain) 929 { 930 struct acpi_pst_domain *dom; 931 932 LIST_FOREACH(dom, &acpi_pst_domains, pd_link) { 933 if (dom->pd_flags & ACPI_PSTDOM_FLAG_STUB) 934 continue; 935 if (dom->pd_dom == domain) 936 return dom; 937 } 938 return NULL; 939 } 940 941 static struct acpi_pst_domain * 942 acpi_pst_domain_alloc(uint32_t domain, uint32_t coord, uint32_t nproc) 943 { 944 struct acpi_pst_domain *dom; 945 946 dom = kmalloc(sizeof(*dom), M_DEVBUF, M_WAITOK | M_ZERO); 947 dom->pd_dom = domain; 948 dom->pd_coord = coord; 949 dom->pd_nproc = nproc; 950 LIST_INIT(&dom->pd_pstlist); 951 952 LIST_INSERT_HEAD(&acpi_pst_domains, dom, pd_link); 953 954 return dom; 955 } 956 957 static int 958 acpi_pst_domain_set_pstate(struct acpi_pst_domain *dom, int i) 959 { 960 const struct acpi_pstate *pstate; 961 struct acpi_pst_softc *sc; 962 int done, error; 963 964 KKASSERT(i >= 0 && i < acpi_npstates); 965 pstate = &acpi_pstates[i]; 966 967 done = 0; 968 LIST_FOREACH(sc, &dom->pd_pstlist, pst_link) { 969 if (!done) { 970 error = acpi_pst_set_pstate(sc, pstate); 971 if (error) { 972 device_printf(sc->pst_dev, "can't set " 973 "freq %d\n", pstate->st_freq); 974 /* XXX error cleanup? */ 975 } 976 if (dom->pd_coord == ACPI_PSD_COORD_SWANY) 977 done = 1; 978 } 979 sc->pst_state = i; 980 } 981 dom->pd_state = i; 982 983 return 0; 984 } 985 986 static int 987 acpi_pst_global_set_pstate(int i) 988 { 989 struct acpi_pst_domain *dom; 990 991 LIST_FOREACH(dom, &acpi_pst_domains, pd_link) { 992 /* Skip dead domain */ 993 if (dom->pd_flags & ACPI_PSTDOM_FLAG_DEAD) 994 continue; 995 acpi_pst_domain_set_pstate(dom, i); 996 } 997 acpi_pst_global_state = i; 998 999 return 0; 1000 } 1001 1002 static void 1003 acpi_pst_postattach(void *arg __unused) 1004 { 1005 struct acpi_pst_domain *dom; 1006 struct acpi_cpu_softc *cpu; 1007 device_t *devices; 1008 int i, ndevices, error, has_domain; 1009 1010 devices = NULL; 1011 ndevices = 0; 1012 error = devclass_get_devices(acpi_pst_devclass, &devices, &ndevices); 1013 if (error) 1014 return; 1015 1016 if (ndevices == 0) 1017 return; 1018 1019 cpu = NULL; 1020 for (i = 0; i < ndevices; ++i) { 1021 cpu = device_get_softc(device_get_parent(devices[i])); 1022 if (cpu->glob_sysctl_tree != NULL) 1023 break; 1024 } 1025 kfree(devices, M_TEMP); 1026 KKASSERT(cpu != NULL); 1027 1028 if (acpi_pst_md == NULL) 1029 kprintf("ACPI: no P-State CPU driver\n"); 1030 1031 has_domain = 0; 1032 LIST_FOREACH(dom, &acpi_pst_domains, pd_link) { 1033 struct acpi_pst_softc *sc; 1034 char buf[32]; 1035 1036 dom->pd_state = acpi_pstate_start; 1037 1038 /* 1039 * Make sure that all processors belonging to this 1040 * domain are located. 1041 */ 1042 i = 0; 1043 LIST_FOREACH(sc, &dom->pd_pstlist, pst_link) { 1044 sc->pst_state = acpi_pstate_start; 1045 ++i; 1046 } 1047 if (i != dom->pd_nproc) { 1048 KKASSERT(i < dom->pd_nproc); 1049 1050 kprintf("ACPI: domain%u misses processors, " 1051 "should be %d, got %d\n", dom->pd_dom, 1052 dom->pd_nproc, i); 1053 if (dom->pd_coord == ACPI_PSD_COORD_SWALL) { 1054 /* 1055 * If this domain's coordination is 1056 * SWALL and we don't see all of the 1057 * member CPUs of this domain, then 1058 * the P-State transition will never 1059 * be completed, so just leave this 1060 * domain out. 1061 */ 1062 dom->pd_flags |= ACPI_PSTDOM_FLAG_DEAD; 1063 continue; 1064 } 1065 dom->pd_nproc = i; 1066 } 1067 1068 /* 1069 * Validate P-State configurations for this domain 1070 */ 1071 LIST_FOREACH(sc, &dom->pd_pstlist, pst_link) { 1072 error = acpi_pst_check_csr(sc); 1073 if (error) 1074 break; 1075 1076 error = acpi_pst_check_pstates(sc); 1077 if (error) 1078 break; 1079 } 1080 if (sc != NULL) { 1081 kprintf("ACPI: domain%u P-State configuration " 1082 "check failed\n", dom->pd_dom); 1083 dom->pd_flags |= ACPI_PSTDOM_FLAG_DEAD; 1084 continue; 1085 } 1086 1087 /* 1088 * Do necssary P-State initialization 1089 */ 1090 LIST_FOREACH(sc, &dom->pd_pstlist, pst_link) { 1091 error = acpi_pst_init(sc); 1092 if (error) 1093 break; 1094 } 1095 if (sc != NULL) { 1096 kprintf("ACPI: domain%u P-State initialization " 1097 "check failed\n", dom->pd_dom); 1098 dom->pd_flags |= ACPI_PSTDOM_FLAG_DEAD; 1099 continue; 1100 } 1101 1102 has_domain = 1; 1103 1104 ksnprintf(buf, sizeof(buf), "px_dom%u", dom->pd_dom); 1105 1106 sysctl_ctx_init(&dom->pd_sysctl_ctx); 1107 dom->pd_sysctl_tree = 1108 SYSCTL_ADD_NODE(&dom->pd_sysctl_ctx, 1109 SYSCTL_CHILDREN(cpu->glob_sysctl_tree), 1110 OID_AUTO, buf, CTLFLAG_RD, 0, 1111 "P-State domain"); 1112 if (dom->pd_sysctl_tree == NULL) { 1113 kprintf("ACPI: Can't create sysctl tree for domain%u", 1114 dom->pd_dom); 1115 continue; 1116 } 1117 1118 SYSCTL_ADD_PROC(&dom->pd_sysctl_ctx, 1119 SYSCTL_CHILDREN(dom->pd_sysctl_tree), 1120 OID_AUTO, "available", 1121 CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_SKIP, 1122 dom, 0, acpi_pst_sysctl_freqs, "A", 1123 "available frequencies"); 1124 1125 SYSCTL_ADD_PROC(&dom->pd_sysctl_ctx, 1126 SYSCTL_CHILDREN(dom->pd_sysctl_tree), 1127 OID_AUTO, "avail", 1128 CTLTYPE_OPAQUE | CTLFLAG_RD, 1129 dom, 0, acpi_pst_sysctl_freqs_bin, "IU", 1130 "available frequencies"); 1131 1132 SYSCTL_ADD_PROC(&dom->pd_sysctl_ctx, 1133 SYSCTL_CHILDREN(dom->pd_sysctl_tree), 1134 OID_AUTO, "power", 1135 CTLTYPE_OPAQUE | CTLFLAG_RD, 1136 dom, 0, acpi_pst_sysctl_power, "IU", 1137 "power of available frequencies"); 1138 1139 SYSCTL_ADD_PROC(&dom->pd_sysctl_ctx, 1140 SYSCTL_CHILDREN(dom->pd_sysctl_tree), 1141 OID_AUTO, "members", 1142 CTLTYPE_STRING | CTLFLAG_RD, 1143 dom, 0, acpi_pst_sysctl_members, "A", 1144 "member cpus"); 1145 1146 if (acpi_pst_md != NULL && 1147 acpi_pst_md->pmd_set_pstate != NULL) { 1148 SYSCTL_ADD_PROC(&dom->pd_sysctl_ctx, 1149 SYSCTL_CHILDREN(dom->pd_sysctl_tree), 1150 OID_AUTO, "select", 1151 CTLTYPE_UINT | CTLFLAG_RW, 1152 dom, 0, acpi_pst_sysctl_select, 1153 "IU", "select freq"); 1154 } 1155 } 1156 1157 if (has_domain && acpi_pst_md != NULL && 1158 acpi_pst_md->pmd_set_pstate != NULL) { 1159 SYSCTL_ADD_PROC(&cpu->glob_sysctl_ctx, 1160 SYSCTL_CHILDREN(cpu->glob_sysctl_tree), 1161 OID_AUTO, "px_global", 1162 CTLTYPE_UINT | CTLFLAG_RW, 1163 NULL, 0, acpi_pst_sysctl_global, 1164 "IU", "select freq for all domains"); 1165 1166 acpi_pst_global_set_pstate(acpi_pstate_start); 1167 } 1168 } 1169 1170 static int 1171 acpi_pst_sysctl_freqs(SYSCTL_HANDLER_ARGS) 1172 { 1173 int i, error; 1174 1175 error = 0; 1176 for (i = 0; i < acpi_npstates; ++i) { 1177 if (error == 0 && i) 1178 error = SYSCTL_OUT(req, " ", 1); 1179 if (error == 0) { 1180 const char *pat; 1181 char buf[32]; 1182 1183 if (i < acpi_pstate_start || i >= acpi_pstate_count) 1184 pat = "(%u)"; 1185 else 1186 pat = "%u"; 1187 1188 ksnprintf(buf, sizeof(buf), pat, 1189 acpi_pstates[i].st_freq); 1190 error = SYSCTL_OUT(req, buf, strlen(buf)); 1191 } 1192 } 1193 return error; 1194 } 1195 1196 static int 1197 acpi_pst_sysctl_freqs_bin(SYSCTL_HANDLER_ARGS) 1198 { 1199 uint32_t freqs[ACPI_NPSTATE_MAX]; 1200 int cnt, i; 1201 1202 cnt = acpi_pstate_count - acpi_pstate_start; 1203 for (i = 0; i < cnt; ++i) 1204 freqs[i] = acpi_pstates[acpi_pstate_start + i].st_freq; 1205 1206 return sysctl_handle_opaque(oidp, freqs, cnt * sizeof(freqs[0]), req); 1207 } 1208 1209 static int 1210 acpi_pst_sysctl_power(SYSCTL_HANDLER_ARGS) 1211 { 1212 uint32_t power[ACPI_NPSTATE_MAX]; 1213 int cnt, i; 1214 1215 cnt = acpi_pstate_count - acpi_pstate_start; 1216 for (i = 0; i < cnt; ++i) 1217 power[i] = acpi_pstates[acpi_pstate_start + i].st_power; 1218 1219 return sysctl_handle_opaque(oidp, power, cnt * sizeof(power[0]), req); 1220 } 1221 1222 static int 1223 acpi_pst_sysctl_members(SYSCTL_HANDLER_ARGS) 1224 { 1225 struct acpi_pst_domain *dom = arg1; 1226 struct acpi_pst_softc *sc; 1227 int loop, error; 1228 1229 loop = error = 0; 1230 LIST_FOREACH(sc, &dom->pd_pstlist, pst_link) { 1231 char buf[32]; 1232 1233 if (error == 0 && loop) 1234 error = SYSCTL_OUT(req, " ", 1); 1235 if (error == 0) { 1236 ksnprintf(buf, sizeof(buf), "cpu%d", sc->pst_cpuid); 1237 error = SYSCTL_OUT(req, buf, strlen(buf)); 1238 } 1239 1240 if (error == 0 && acpi_pst_md && acpi_pst_md->pmd_get_pstate) { 1241 const struct acpi_pstate *pstate; 1242 const char *str; 1243 1244 pstate = acpi_pst_get_pstate(sc); 1245 if (pstate == NULL) { 1246 str = "(*)"; 1247 } else { 1248 ksnprintf(buf, sizeof(buf), "(%d)", 1249 pstate->st_freq); 1250 str = buf; 1251 } 1252 error = SYSCTL_OUT(req, str, strlen(str)); 1253 } 1254 ++loop; 1255 } 1256 return error; 1257 } 1258 1259 static int 1260 acpi_pst_sysctl_select(SYSCTL_HANDLER_ARGS) 1261 { 1262 struct acpi_pst_domain *dom = arg1; 1263 int error, i, freq; 1264 1265 KKASSERT(dom->pd_state >= 0 && dom->pd_state < acpi_npstates); 1266 1267 freq = acpi_pstates[dom->pd_state].st_freq; 1268 1269 error = sysctl_handle_int(oidp, &freq, 0, req); 1270 if (error || req->newptr == NULL) 1271 return error; 1272 1273 i = acpi_pst_freq2index(freq); 1274 if (i < 0) 1275 return EINVAL; 1276 1277 acpi_pst_domain_set_pstate(dom, i); 1278 return 0; 1279 } 1280 1281 static int 1282 acpi_pst_sysctl_global(SYSCTL_HANDLER_ARGS) 1283 { 1284 int error, i, freq; 1285 1286 KKASSERT(acpi_pst_global_state >= 0 && 1287 acpi_pst_global_state < acpi_npstates); 1288 1289 freq = acpi_pstates[acpi_pst_global_state].st_freq; 1290 1291 error = sysctl_handle_int(oidp, &freq, 0, req); 1292 if (error || req->newptr == NULL) 1293 return error; 1294 1295 i = acpi_pst_freq2index(freq); 1296 if (i < 0) 1297 return EINVAL; 1298 1299 acpi_pst_global_set_pstate(i); 1300 1301 return 0; 1302 } 1303 1304 static void 1305 acpi_pst_check_csr_handler(netmsg_t msg) 1306 { 1307 struct netmsg_acpi_pst *rmsg = (struct netmsg_acpi_pst *)msg; 1308 int error; 1309 1310 error = acpi_pst_md->pmd_check_csr(rmsg->ctrl, rmsg->status); 1311 lwkt_replymsg(&rmsg->base.lmsg, error); 1312 } 1313 1314 static int 1315 acpi_pst_check_csr(struct acpi_pst_softc *sc) 1316 { 1317 struct netmsg_acpi_pst msg; 1318 1319 if (acpi_pst_md == NULL) 1320 return 0; 1321 1322 netmsg_init(&msg.base, NULL, &curthread->td_msgport, 1323 MSGF_PRIORITY, acpi_pst_check_csr_handler); 1324 msg.ctrl = &sc->pst_creg; 1325 msg.status = &sc->pst_sreg; 1326 1327 return lwkt_domsg(netisr_cpuport(sc->pst_cpuid), &msg.base.lmsg, 0); 1328 } 1329 1330 static void 1331 acpi_pst_check_pstates_handler(netmsg_t msg) 1332 { 1333 int error; 1334 1335 error = acpi_pst_md->pmd_check_pstates(acpi_pstates, acpi_npstates); 1336 lwkt_replymsg(&msg->lmsg, error); 1337 } 1338 1339 static int 1340 acpi_pst_check_pstates(struct acpi_pst_softc *sc) 1341 { 1342 struct netmsg_base msg; 1343 1344 if (acpi_pst_md == NULL) 1345 return 0; 1346 1347 netmsg_init(&msg, NULL, &curthread->td_msgport, 1348 MSGF_PRIORITY, acpi_pst_check_pstates_handler); 1349 1350 return lwkt_domsg(netisr_cpuport(sc->pst_cpuid), &msg.lmsg, 0); 1351 } 1352 1353 static void 1354 acpi_pst_init_handler(netmsg_t msg) 1355 { 1356 struct netmsg_acpi_pst *rmsg = (struct netmsg_acpi_pst *)msg; 1357 int error; 1358 1359 error = acpi_pst_md->pmd_init(rmsg->ctrl, rmsg->status); 1360 lwkt_replymsg(&rmsg->base.lmsg, error); 1361 } 1362 1363 static int 1364 acpi_pst_init(struct acpi_pst_softc *sc) 1365 { 1366 struct netmsg_acpi_pst msg; 1367 1368 if (acpi_pst_md == NULL) 1369 return 0; 1370 1371 netmsg_init(&msg.base, NULL, &curthread->td_msgport, 1372 MSGF_PRIORITY, acpi_pst_init_handler); 1373 msg.ctrl = &sc->pst_creg; 1374 msg.status = &sc->pst_sreg; 1375 1376 return lwkt_domsg(netisr_cpuport(sc->pst_cpuid), &msg.base.lmsg, 0); 1377 } 1378 1379 static void 1380 acpi_pst_set_pstate_handler(netmsg_t msg) 1381 { 1382 struct netmsg_acpi_pst *rmsg = (struct netmsg_acpi_pst *)msg; 1383 int error; 1384 1385 error = acpi_pst_md->pmd_set_pstate(rmsg->ctrl, rmsg->status, 1386 rmsg->base.lmsg.u.ms_resultp); 1387 lwkt_replymsg(&rmsg->base.lmsg, error); 1388 } 1389 1390 static int 1391 acpi_pst_set_pstate(struct acpi_pst_softc *sc, const struct acpi_pstate *pstate) 1392 { 1393 struct netmsg_acpi_pst msg; 1394 1395 KKASSERT(acpi_pst_md != NULL); 1396 1397 netmsg_init(&msg.base, NULL, &curthread->td_msgport, 1398 MSGF_PRIORITY, acpi_pst_set_pstate_handler); 1399 msg.base.lmsg.u.ms_resultp = __DECONST(void *, pstate); 1400 msg.ctrl = &sc->pst_creg; 1401 msg.status = &sc->pst_sreg; 1402 1403 return lwkt_domsg(netisr_cpuport(sc->pst_cpuid), &msg.base.lmsg, 0); 1404 } 1405 1406 static void 1407 acpi_pst_get_pstate_handler(netmsg_t msg) 1408 { 1409 struct netmsg_acpi_pst *rmsg = (struct netmsg_acpi_pst *)msg; 1410 const struct acpi_pstate *pstate; 1411 1412 pstate = acpi_pst_md->pmd_get_pstate(rmsg->status, acpi_pstates, 1413 acpi_npstates); 1414 rmsg->base.lmsg.u.ms_resultp = __DECONST(void *, pstate); 1415 lwkt_replymsg(&rmsg->base.lmsg, 0); 1416 } 1417 1418 static const struct acpi_pstate * 1419 acpi_pst_get_pstate(struct acpi_pst_softc *sc) 1420 { 1421 struct netmsg_acpi_pst msg; 1422 1423 if (acpi_pst_md == NULL) 1424 return 0; 1425 1426 netmsg_init(&msg.base, NULL, &curthread->td_msgport, 1427 MSGF_PRIORITY, acpi_pst_get_pstate_handler); 1428 msg.status = &sc->pst_sreg; 1429 1430 lwkt_domsg(netisr_cpuport(sc->pst_cpuid), &msg.base.lmsg, 0); 1431 return msg.base.lmsg.u.ms_resultp; 1432 } 1433 1434 static int 1435 acpi_pst_alloc_resource(device_t dev, ACPI_OBJECT *obj, int idx, 1436 struct acpi_pst_res *res) 1437 { 1438 struct acpi_pst_softc *sc = device_get_softc(dev); 1439 int error, type; 1440 1441 /* Save GAS */ 1442 error = acpi_PkgRawGas(obj, idx, &res->pr_gas); 1443 if (error) 1444 return error; 1445 1446 /* Allocate resource, if possible */ 1447 res->pr_rid = sc->pst_parent->cpu_next_rid; 1448 acpi_bus_alloc_gas(dev, &type, &res->pr_rid, &res->pr_gas, &res->pr_res, 0); 1449 if (res->pr_res != NULL) { 1450 sc->pst_parent->cpu_next_rid++; 1451 res->pr_bt = rman_get_bustag(res->pr_res); 1452 res->pr_bh = rman_get_bushandle(res->pr_res); 1453 } else { 1454 res->pr_rid = 0; 1455 } 1456 return 0; 1457 } 1458 1459 static void 1460 acpi_pst_domain_check_nproc(device_t dev, struct acpi_pst_domain *dom) 1461 { 1462 struct acpi_pst_softc *pst; 1463 int i; 1464 1465 i = 0; 1466 LIST_FOREACH(pst, &dom->pd_pstlist, pst_link) 1467 ++i; 1468 if (i == dom->pd_nproc) { 1469 /* 1470 * Some stupid BIOSes will set wrong "# of processors", 1471 * e.g. 1 for CPU w/ hyperthreading; Be lenient here. 1472 */ 1473 if (bootverbose) { 1474 device_printf(dev, "domain%u already contains %d " 1475 "P-States\n", dom->pd_dom, dom->pd_nproc); 1476 } 1477 dom->pd_nproc++; 1478 } 1479 KKASSERT(i < dom->pd_nproc); 1480 } 1481