Annotation of sys/dev/acpi/acpicpu.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: acpicpu.c,v 1.26 2007/06/15 22:37:40 gwk Exp $ */
! 2: /*
! 3: * Copyright (c) 2005 Marco Peereboom <marco@openbsd.org>
! 4: *
! 5: * Permission to use, copy, modify, and distribute this software for any
! 6: * purpose with or without fee is hereby granted, provided that the above
! 7: * copyright notice and this permission notice appear in all copies.
! 8: *
! 9: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
! 10: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
! 11: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
! 12: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
! 13: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
! 14: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
! 15: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
! 16: */
! 17:
! 18: #include <sys/param.h>
! 19: #include <sys/proc.h>
! 20: #include <sys/signalvar.h>
! 21: #include <sys/sysctl.h>
! 22: #include <sys/systm.h>
! 23: #include <sys/device.h>
! 24: #include <sys/malloc.h>
! 25: #include <sys/queue.h>
! 26:
! 27: #include <machine/bus.h>
! 28: #include <machine/cpu.h>
! 29: #include <machine/cpufunc.h>
! 30: #include <machine/specialreg.h>
! 31:
! 32: #include <dev/acpi/acpireg.h>
! 33: #include <dev/acpi/acpivar.h>
! 34: #include <dev/acpi/acpidev.h>
! 35: #include <dev/acpi/amltypes.h>
! 36: #include <dev/acpi/dsdt.h>
! 37:
! 38: #include <sys/sensors.h>
! 39:
! 40: int acpicpu_match(struct device *, void *, void *);
! 41: void acpicpu_attach(struct device *, struct device *, void *);
! 42: int acpicpu_notify(struct aml_node *, int, void *);
! 43: void acpicpu_setperf(int);
! 44:
! 45: #define ACPI_STATE_C0 0x00
! 46: #define ACPI_STATE_C1 0x01
! 47: #define ACPI_STATE_C2 0x02
! 48: #define ACPI_STATE_C3 0x03
! 49:
! 50: #define FLAGS_NO_C2 0x01
! 51: #define FLAGS_NO_C3 0x02
! 52: #define FLAGS_BMCHECK 0x04
! 53: #define FLAGS_NOTHROTTLE 0x08
! 54: #define FLAGS_NOPSS 0x10
! 55: #define FLAGS_NOPCT 0x20
! 56:
! 57: #define CPU_THT_EN (1L << 4)
! 58: #define CPU_MAXSTATE(sc) (1L << (sc)->sc_duty_wid)
! 59: #define CPU_STATE(sc,pct) ((pct * CPU_MAXSTATE(sc) / 100) << (sc)->sc_duty_off)
! 60: #define CPU_STATEMASK(sc) ((CPU_MAXSTATE(sc) - 1) << (sc)->sc_duty_off)
! 61:
! 62: #define ACPI_MAX_C2_LATENCY 100
! 63: #define ACPI_MAX_C3_LATENCY 1000
! 64:
! 65: /* Make sure throttling bits are valid,a=addr,o=offset,w=width */
! 66: #define valid_throttle(o,w,a) (a && w && (o+w)<=31 && (o>4 || (o+w)<=4))
! 67:
! 68: struct acpi_cstate
! 69: {
! 70: int type;
! 71: int latency;
! 72: int power;
! 73: int address;
! 74:
! 75: SLIST_ENTRY(acpi_cstate) link;
! 76: };
! 77:
! 78: struct acpicpu_softc {
! 79: struct device sc_dev;
! 80: int sc_cpu;
! 81:
! 82: int sc_duty_wid;
! 83: int sc_duty_off;
! 84: int sc_pblk_addr;
! 85: int sc_pblk_len;
! 86: int sc_flags;
! 87:
! 88: SLIST_HEAD(,acpi_cstate) sc_cstates;
! 89:
! 90: bus_space_tag_t sc_iot;
! 91: bus_space_handle_t sc_ioh;
! 92:
! 93: struct acpi_softc *sc_acpi;
! 94: struct aml_node *sc_devnode;
! 95:
! 96: int sc_pss_len;
! 97: struct acpicpu_pss *sc_pss;
! 98:
! 99: struct acpicpu_pct sc_pct;
! 100: /* XXX: _PPC Change listener
! 101: * PPC changes can occur when for example a machine is disconnected
! 102: * from AC power and can no loger support the highest frequency or
! 103: * voltage when driven from the battery.
! 104: * Should probably be reimplemented as a list for now we assume only
! 105: * one listener */
! 106: void (*sc_notify)(struct acpicpu_pss *, int);
! 107: };
! 108:
! 109: void acpicpu_set_throttle(struct acpicpu_softc *, int);
! 110: void acpicpu_add_cstatepkg(struct aml_value *, void *);
! 111: int acpicpu_getpct(struct acpicpu_softc *);
! 112: int acpicpu_getpss(struct acpicpu_softc *);
! 113: struct acpi_cstate *acpicpu_add_cstate(struct acpicpu_softc *, int, int, int, int);
! 114: struct acpi_cstate *acpicpu_find_cstate(struct acpicpu_softc *, int);
! 115:
! 116: struct cfattach acpicpu_ca = {
! 117: sizeof(struct acpicpu_softc), acpicpu_match, acpicpu_attach
! 118: };
! 119:
! 120: struct cfdriver acpicpu_cd = {
! 121: NULL, "acpicpu", DV_DULL
! 122: };
! 123:
! 124: extern int setperf_prio;
! 125:
! 126: #ifdef __i386__
! 127: struct acpicpu_softc *acpicpu_sc[I386_MAXPROCS];
! 128: #elif __amd64__
! 129: struct acpicpu_softc *acpicpu_sc[X86_MAXPROCS];
! 130: #endif
! 131:
! 132: void
! 133: acpicpu_set_throttle(struct acpicpu_softc *sc, int level)
! 134: {
! 135: uint32_t pbval;
! 136:
! 137: if (sc->sc_flags & FLAGS_NOTHROTTLE)
! 138: return;
! 139:
! 140: /* Disable throttling control */
! 141: pbval = inl(sc->sc_pblk_addr);
! 142: outl(sc->sc_pblk_addr, pbval & ~CPU_THT_EN);
! 143: if (level < 100) {
! 144: pbval &= ~CPU_STATEMASK(sc);
! 145: pbval |= CPU_STATE(sc, level);
! 146: outl(sc->sc_pblk_addr, pbval & ~CPU_THT_EN);
! 147: outl(sc->sc_pblk_addr, pbval | CPU_THT_EN);
! 148: }
! 149: }
! 150:
! 151: struct acpi_cstate *
! 152: acpicpu_find_cstate(struct acpicpu_softc *sc, int type)
! 153: {
! 154: struct acpi_cstate *cx;
! 155:
! 156: SLIST_FOREACH(cx, &sc->sc_cstates, link)
! 157: if (cx->type == type)
! 158: return cx;
! 159: return NULL;
! 160: }
! 161:
! 162: struct acpi_cstate *
! 163: acpicpu_add_cstate(struct acpicpu_softc *sc, int type,
! 164: int latency, int power, int address)
! 165: {
! 166: struct acpi_cstate *cx;
! 167:
! 168: dnprintf(10," C%d: latency:.%4x power:%.4x addr:%.8x\n",
! 169: type, latency, power, address);
! 170:
! 171: switch (type) {
! 172: case ACPI_STATE_C2:
! 173: if (latency > ACPI_MAX_C2_LATENCY || !address ||
! 174: (sc->sc_flags & FLAGS_NO_C2))
! 175: goto bad;
! 176: break;
! 177: case ACPI_STATE_C3:
! 178: if (latency > ACPI_MAX_C3_LATENCY || !address ||
! 179: (sc->sc_flags & FLAGS_NO_C3))
! 180: goto bad;
! 181: break;
! 182: }
! 183:
! 184: cx = malloc(sizeof(struct acpi_cstate), M_DEVBUF, M_WAITOK);
! 185: memset(cx, 0, sizeof(struct acpi_cstate));
! 186:
! 187: cx->type = type;
! 188: cx->power = power;
! 189: cx->latency = latency;
! 190: cx->address = address;
! 191:
! 192: SLIST_INSERT_HEAD(&sc->sc_cstates, cx, link);
! 193:
! 194: return cx;
! 195: bad:
! 196: dprintf("acpicpu%d: C%d not supported", sc->sc_cpu, type);
! 197: return NULL;
! 198: }
! 199:
! 200: /* Found a _CST object, add new cstate for each entry */
! 201: void
! 202: acpicpu_add_cstatepkg(struct aml_value *val, void *arg)
! 203: {
! 204: struct acpicpu_softc *sc = arg;
! 205:
! 206: #ifdef ACPI_DEBUG
! 207: aml_showvalue(val, 0);
! 208: #endif
! 209: if (val->type != AML_OBJTYPE_PACKAGE || val->length != 4)
! 210: return;
! 211: acpicpu_add_cstate(sc, val->v_package[1]->v_integer,
! 212: val->v_package[2]->v_integer,
! 213: val->v_package[3]->v_integer,
! 214: -1);
! 215: }
! 216:
! 217:
! 218: int
! 219: acpicpu_match(struct device *parent, void *match, void *aux)
! 220: {
! 221: struct acpi_attach_args *aa = aux;
! 222: struct cfdata *cf = match;
! 223:
! 224: /* sanity */
! 225: if (aa->aaa_name == NULL ||
! 226: strcmp(aa->aaa_name, cf->cf_driver->cd_name) != 0 ||
! 227: aa->aaa_table != NULL)
! 228: return (0);
! 229:
! 230: return (1);
! 231: }
! 232:
! 233: void
! 234: acpicpu_attach(struct device *parent, struct device *self, void *aux)
! 235: {
! 236: struct acpicpu_softc *sc = (struct acpicpu_softc *)self;
! 237: struct acpi_attach_args *aa = aux;
! 238: struct aml_value res;
! 239: int i;
! 240: struct acpi_cstate *cx;
! 241:
! 242: sc->sc_acpi = (struct acpi_softc *)parent;
! 243: sc->sc_devnode = aa->aaa_node;
! 244: acpicpu_sc[sc->sc_dev.dv_unit] = sc;
! 245:
! 246: SLIST_INIT(&sc->sc_cstates);
! 247:
! 248: sc->sc_pss = NULL;
! 249:
! 250: if (aml_evalnode(sc->sc_acpi, sc->sc_devnode, 0, NULL, &res) == 0) {
! 251: if (res.type == AML_OBJTYPE_PROCESSOR) {
! 252: sc->sc_cpu = res.v_processor.proc_id;
! 253: sc->sc_pblk_addr = res.v_processor.proc_addr;
! 254: sc->sc_pblk_len = res.v_processor.proc_len;
! 255: }
! 256: aml_freevalue(&res);
! 257: }
! 258: sc->sc_duty_off = sc->sc_acpi->sc_fadt->duty_offset;
! 259: sc->sc_duty_wid = sc->sc_acpi->sc_fadt->duty_width;
! 260: if (!valid_throttle(sc->sc_duty_off, sc->sc_duty_wid, sc->sc_pblk_addr))
! 261: sc->sc_flags |= FLAGS_NOTHROTTLE;
! 262:
! 263: #ifdef ACPI_DEBUG
! 264: printf(": %s: ", sc->sc_devnode->name);
! 265: printf("\n: hdr:%x pblk:%x,%x duty:%x,%x pstate:%x (%d throttling states)\n",
! 266: sc->sc_acpi->sc_fadt->hdr_revision,
! 267: sc->sc_pblk_addr, sc->sc_pblk_len,
! 268: sc->sc_duty_off, sc->sc_duty_wid,
! 269: sc->sc_acpi->sc_fadt->pstate_cnt,
! 270: CPU_MAXSTATE(sc));
! 271: #endif
! 272:
! 273: /* Get C-States from _CST or FADT */
! 274: if (aml_evalname(sc->sc_acpi, sc->sc_devnode, "_CST", 0, NULL, &res) == 0) {
! 275: aml_foreachpkg(&res, 1, acpicpu_add_cstatepkg, sc);
! 276: aml_freevalue(&res);
! 277: }
! 278: else {
! 279: /* Some systems don't export a full PBLK, reduce functionality */
! 280: if (sc->sc_pblk_len < 5)
! 281: sc->sc_flags |= FLAGS_NO_C2;
! 282: if (sc->sc_pblk_len < 6)
! 283: sc->sc_flags |= FLAGS_NO_C3;
! 284: acpicpu_add_cstate(sc, ACPI_STATE_C2,
! 285: sc->sc_acpi->sc_fadt->p_lvl2_lat, -1,
! 286: sc->sc_pblk_addr + 4);
! 287: acpicpu_add_cstate(sc, ACPI_STATE_C3,
! 288: sc->sc_acpi->sc_fadt->p_lvl3_lat, -1,
! 289: sc->sc_pblk_addr + 5);
! 290: }
! 291: if (acpicpu_getpss(sc)) {
! 292: /* XXX not the right test but has to do for now */
! 293: sc->sc_flags |= FLAGS_NOPSS;
! 294: } else {
! 295:
! 296: #ifdef ACPI_DEBUG
! 297: for (i = 0; i < sc->sc_pss_len; i++) {
! 298: dnprintf(20, "%d %d %d %d %d %d\n",
! 299: sc->sc_pss[i].pss_core_freq,
! 300: sc->sc_pss[i].pss_power,
! 301: sc->sc_pss[i].pss_trans_latency,
! 302: sc->sc_pss[i].pss_bus_latency,
! 303: sc->sc_pss[i].pss_ctrl,
! 304: sc->sc_pss[i].pss_status);
! 305: }
! 306: dnprintf(20, "\n");
! 307: #endif
! 308: /* XXX this needs to be moved to probe routine */
! 309: if (acpicpu_getpct(sc))
! 310: sc->sc_flags |= FLAGS_NOPCT;
! 311: else {
! 312:
! 313: /* Notify BIOS we are handing p-states */
! 314: if (sc->sc_acpi->sc_fadt->pstate_cnt)
! 315: acpi_write_pmreg(sc->sc_acpi, ACPIREG_SMICMD, 0,
! 316: sc->sc_acpi->sc_fadt->pstate_cnt);
! 317:
! 318: aml_register_notify(sc->sc_devnode, NULL,
! 319: acpicpu_notify, sc, ACPIDEV_NOPOLL);
! 320:
! 321: if (setperf_prio < 30) {
! 322: cpu_setperf = acpicpu_setperf;
! 323: setperf_prio = 30;
! 324: acpi_hasprocfvs = 1;
! 325: }
! 326: }
! 327: }
! 328:
! 329: /*
! 330: * Nicely enumerate what power management capabilities
! 331: * ACPI CPU provides.
! 332: * */
! 333: i = 0;
! 334: SLIST_FOREACH(cx, &sc->sc_cstates, link) {
! 335: if (i)
! 336: printf(",");
! 337: switch(cx->type) {
! 338: case ACPI_STATE_C0:
! 339: printf(" C0");
! 340: break;
! 341: case ACPI_STATE_C1:
! 342: printf(" C1");
! 343: break;
! 344: case ACPI_STATE_C2:
! 345: printf(" C2");
! 346: break;
! 347: case ACPI_STATE_C3:
! 348: printf(" C3");
! 349: break;
! 350: }
! 351: i++;
! 352: }
! 353: if (!(sc->sc_flags & FLAGS_NOPSS) && !(sc->sc_flags & FLAGS_NOPCT)) {
! 354: if (i)
! 355: printf(",");
! 356: printf(" FVS");
! 357: } else if (!(sc->sc_flags & FLAGS_NOPSS)) {
! 358: if (i)
! 359: printf(",");
! 360: printf(" PSS");
! 361: }
! 362: printf("\n");
! 363:
! 364: /*
! 365: * If acpicpu is itself providing the capability to transition
! 366: * states, enumerate them in the fashion that est and powernow
! 367: * would.
! 368: */
! 369: if (!(sc->sc_flags & FLAGS_NOPSS) && !(sc->sc_flags & FLAGS_NOPCT)) {
! 370: printf("%s: ", sc->sc_dev.dv_xname);
! 371: for (i = 0; i < sc->sc_pss_len; i++)
! 372: printf("%d%s", sc->sc_pss[i].pss_core_freq,
! 373: i < sc->sc_pss_len - 1 ? ", " : " MHz\n");
! 374: }
! 375: }
! 376:
! 377: int
! 378: acpicpu_getpct(struct acpicpu_softc *sc)
! 379: {
! 380: struct aml_value res;
! 381: int rv = 1;
! 382:
! 383: if (aml_evalname(sc->sc_acpi, sc->sc_devnode, "_PPC", 0, NULL, &res)) {
! 384: dnprintf(20, "%s: no _PPC\n", DEVNAME(sc));
! 385: dnprintf(10, "%s: no _PPC\n", DEVNAME(sc));
! 386: return (1);
! 387: }
! 388:
! 389: dnprintf(10, "_PPC: %d\n", aml_val2int(&res));
! 390: aml_freevalue(&res);
! 391:
! 392: if (aml_evalname(sc->sc_acpi, sc->sc_devnode, "_PCT", 0, NULL, &res)) {
! 393: dnprintf(20, "%s: no _PCT\n", DEVNAME(sc));
! 394: return (1);
! 395: }
! 396:
! 397: if (res.length != 2) {
! 398: dnprintf(20, "%s: %s: invalid _PCT length\n", DEVNAME(sc),
! 399: sc->sc_devnode->name);
! 400: return (1);
! 401: }
! 402:
! 403: memcpy(&sc->sc_pct.pct_ctrl, res.v_package[0]->v_buffer,
! 404: sizeof sc->sc_pct.pct_ctrl);
! 405: if (sc->sc_pct.pct_ctrl.grd_gas.address_space_id ==
! 406: GAS_FUNCTIONAL_FIXED) {
! 407: dnprintf(20, "CTRL GASIO is functional fixed hardware.\n");
! 408: goto ffh;
! 409: }
! 410:
! 411: memcpy(&sc->sc_pct.pct_status, res.v_package[1]->v_buffer,
! 412: sizeof sc->sc_pct.pct_status);
! 413: if (sc->sc_pct.pct_status.grd_gas.address_space_id ==
! 414: GAS_FUNCTIONAL_FIXED) {
! 415: dnprintf(20, "CTRL GASIO is functional fixed hardware.\n");
! 416: goto ffh;
! 417: }
! 418:
! 419: dnprintf(10, "_PCT(ctrl) : %02x %04x %02x %02x %02x %02x %016x\n",
! 420: sc->sc_pct.pct_ctrl.grd_descriptor,
! 421: sc->sc_pct.pct_ctrl.grd_length,
! 422: sc->sc_pct.pct_ctrl.grd_gas.address_space_id,
! 423: sc->sc_pct.pct_ctrl.grd_gas.register_bit_width,
! 424: sc->sc_pct.pct_ctrl.grd_gas.register_bit_offset,
! 425: sc->sc_pct.pct_ctrl.grd_gas.access_size,
! 426: sc->sc_pct.pct_ctrl.grd_gas.address);
! 427:
! 428: dnprintf(10, "_PCT(status): %02x %04x %02x %02x %02x %02x %016x\n",
! 429: sc->sc_pct.pct_status.grd_descriptor,
! 430: sc->sc_pct.pct_status.grd_length,
! 431: sc->sc_pct.pct_status.grd_gas.address_space_id,
! 432: sc->sc_pct.pct_status.grd_gas.register_bit_width,
! 433: sc->sc_pct.pct_status.grd_gas.register_bit_offset,
! 434: sc->sc_pct.pct_status.grd_gas.access_size,
! 435: sc->sc_pct.pct_status.grd_gas.address);
! 436:
! 437: rv = 0;
! 438: ffh:
! 439: aml_freevalue(&res);
! 440: return (rv);
! 441: }
! 442:
! 443: int
! 444: acpicpu_getpss(struct acpicpu_softc *sc)
! 445: {
! 446: struct aml_value res;
! 447: int i;
! 448:
! 449: if (aml_evalname(sc->sc_acpi, sc->sc_devnode, "_PSS", 0, NULL, &res)) {
! 450: dprintf("%s: no _PSS\n", DEVNAME(sc));
! 451: return (1);
! 452: }
! 453:
! 454: if (sc->sc_pss)
! 455: free(sc->sc_pss, M_DEVBUF);
! 456:
! 457: sc->sc_pss = malloc(res.length * sizeof *sc->sc_pss, M_DEVBUF,
! 458: M_WAITOK);
! 459:
! 460: memset(sc->sc_pss, 0, res.length * sizeof *sc->sc_pss);
! 461:
! 462: for (i = 0; i < res.length; i++) {
! 463: sc->sc_pss[i].pss_core_freq = aml_val2int(
! 464: res.v_package[i]->v_package[0]);
! 465: sc->sc_pss[i].pss_power = aml_val2int(
! 466: res.v_package[i]->v_package[1]);
! 467: sc->sc_pss[i].pss_trans_latency = aml_val2int(
! 468: res.v_package[i]->v_package[2]);
! 469: sc->sc_pss[i].pss_bus_latency = aml_val2int(
! 470: res.v_package[i]->v_package[3]);
! 471: sc->sc_pss[i].pss_ctrl = aml_val2int(
! 472: res.v_package[i]->v_package[4]);
! 473: sc->sc_pss[i].pss_status = aml_val2int(
! 474: res.v_package[i]->v_package[5]);
! 475: }
! 476: aml_freevalue(&res);
! 477:
! 478: sc->sc_pss_len = res.length;
! 479:
! 480: return (0);
! 481: }
! 482:
! 483: int
! 484: acpicpu_fetch_pss(struct acpicpu_pss **pss) {
! 485: /*XXX: According to the ACPI spec in an SMP system all processors
! 486: * are supposed to support the same states. For now we prey
! 487: * the bios ensures this...
! 488: */
! 489: struct acpicpu_softc *sc;
! 490:
! 491: sc = acpicpu_sc[0];
! 492: if (!sc) {
! 493: printf("couldnt fetch acpicpu_softc\n");
! 494: return 0;
! 495: }
! 496: *pss = sc->sc_pss;
! 497:
! 498: return sc->sc_pss_len;
! 499: }
! 500:
! 501: int
! 502: acpicpu_notify(struct aml_node *node, int notify_type, void *arg)
! 503: {
! 504: struct acpicpu_softc *sc = arg;
! 505:
! 506: dnprintf(10, "acpicpu_notify: %.2x %s\n", notify_type,
! 507: sc->sc_devnode->name);
! 508:
! 509: switch (notify_type) {
! 510: case 0x80: /* _PPC changed, retrieve new values */
! 511: acpicpu_getpct(sc);
! 512: acpicpu_getpss(sc);
! 513: if (sc->sc_notify)
! 514: sc->sc_notify(sc->sc_pss, sc->sc_pss_len);
! 515: break;
! 516: default:
! 517: printf("%s: unhandled cpu event %x\n", DEVNAME(sc),
! 518: notify_type);
! 519: break;
! 520: }
! 521:
! 522: return (0);
! 523: }
! 524:
! 525: void
! 526: acpicpu_set_notify(void (*func)(struct acpicpu_pss *, int)) {
! 527: struct acpicpu_softc *sc;
! 528:
! 529: sc = acpicpu_sc[0];
! 530: if (sc != NULL)
! 531: sc->sc_notify = func;
! 532: }
! 533:
! 534: void
! 535: acpicpu_setperf(int level) {
! 536: struct acpicpu_softc *sc;
! 537: struct acpicpu_pss *pss = NULL;
! 538: int idx;
! 539: u_int32_t stat_as, ctrl_as, stat_len, ctrl_len;
! 540: u_int32_t status = 0;
! 541:
! 542: sc = acpicpu_sc[cpu_number()];
! 543:
! 544: dnprintf(10, "%s: acpicpu setperf level %d\n",
! 545: sc->sc_devnode->name, level);
! 546:
! 547: if (level < 0 || level > 100) {
! 548: dnprintf(10, "%s: acpicpu setperf illegal percentage\n",
! 549: sc->sc_devnode->name);
! 550: return;
! 551: }
! 552:
! 553: idx = (sc->sc_pss_len - 1) - (level / (100 / sc->sc_pss_len));
! 554: if (idx < 0)
! 555: idx = 0; /* compensate */
! 556: if (idx > sc->sc_pss_len) {
! 557: /* XXX should never happen */
! 558: printf("%s: acpicpu setperf index out of range\n",
! 559: sc->sc_devnode->name);
! 560: return;
! 561: }
! 562:
! 563: dnprintf(10, "%s: acpicpu setperf index %d\n",
! 564: sc->sc_devnode->name, idx);
! 565:
! 566: pss = &sc->sc_pss[idx];
! 567:
! 568: /* if not set assume single 32 bit access */
! 569: stat_as = sc->sc_pct.pct_status.grd_gas.register_bit_width / 8;
! 570: if (stat_as == 0)
! 571: stat_as = 4;
! 572: ctrl_as = sc->sc_pct.pct_ctrl.grd_gas.register_bit_width / 8;
! 573: if (ctrl_as == 0)
! 574: ctrl_as = 4;
! 575: stat_len = sc->sc_pct.pct_status.grd_gas.access_size;
! 576: if (stat_len == 0)
! 577: stat_len = stat_as;
! 578: ctrl_len = sc->sc_pct.pct_ctrl.grd_gas.access_size;
! 579: if (ctrl_len == 0)
! 580: ctrl_len = ctrl_as;
! 581:
! 582: #ifdef ACPI_DEBUG
! 583: /* keep this for now since we will need this for debug in the field */
! 584: printf("0 status: %x %llx %u %u ctrl: %x %llx %u %u\n",
! 585: sc->sc_pct.pct_status.grd_gas.address_space_id,
! 586: sc->sc_pct.pct_status.grd_gas.address,
! 587: stat_as, stat_len,
! 588: sc->sc_pct.pct_ctrl.grd_gas.address_space_id,
! 589: sc->sc_pct.pct_ctrl.grd_gas.address,
! 590: ctrl_as, ctrl_len);
! 591: #endif
! 592: acpi_gasio(sc->sc_acpi, ACPI_IOREAD,
! 593: sc->sc_pct.pct_status.grd_gas.address_space_id,
! 594: sc->sc_pct.pct_status.grd_gas.address, stat_as, stat_len,
! 595: &status);
! 596: dnprintf(20, "status: %u <- %u\n", status, pss->pss_status);
! 597:
! 598: /* Are we already at the requested frequency? */
! 599: if (status == pss->pss_status)
! 600: return;
! 601:
! 602: acpi_gasio(sc->sc_acpi, ACPI_IOWRITE,
! 603: sc->sc_pct.pct_ctrl.grd_gas.address_space_id,
! 604: sc->sc_pct.pct_ctrl.grd_gas.address, ctrl_as, ctrl_len,
! 605: &pss->pss_ctrl);
! 606: dnprintf(20, "pss_ctrl: %x\n", pss->pss_ctrl);
! 607:
! 608: acpi_gasio(sc->sc_acpi, ACPI_IOREAD,
! 609: sc->sc_pct.pct_status.grd_gas.address_space_id,
! 610: sc->sc_pct.pct_status.grd_gas.address, stat_as, stat_as,
! 611: &status);
! 612: dnprintf(20, "3 status: %d\n", status);
! 613:
! 614: /* Did the transition succeed? */
! 615: if (status == pss->pss_status)
! 616: cpuspeed = pss->pss_core_freq;
! 617: else
! 618: printf("%s: acpicpu setperf failed to alter frequency\n",
! 619: sc->sc_devnode->name);
! 620: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to acpicpu.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / acpi