 @@ -1,753 +1,749 @@
-/* $NetBSD: acpi_cpu_cstate.c,v 1.15 2010/08/08 16:58:42 jruoho Exp $ */
+/* $NetBSD: acpi_cpu_cstate.c,v 1.16 2010/08/08 18:25:06 jruoho Exp $ */
 /*-
  * Copyright (c) 2010 Jukka Ruohonen <jruohonen@iki.fi>
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
+ *
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: acpi_cpu_cstate.c,v 1.15 2010/08/08 16:58:42 jruoho Exp $");
+__KERNEL_RCSID(0, "$NetBSD: acpi_cpu_cstate.c,v 1.16 2010/08/08 18:25:06 jruoho Exp $");
 #include <sys/param.h>
 #include <sys/cpu.h>
 #include <sys/device.h>
 #include <sys/kernel.h>
 #include <sys/once.h>
 #include <sys/mutex.h>
 #include <sys/timetc.h>
 #include <dev/pci/pcivar.h>
 #include <dev/pci/pcidevs.h>
 #include <dev/acpi/acpireg.h>
 #include <dev/acpi/acpivar.h>
 #include <dev/acpi/acpi_cpu.h>
 #include <dev/acpi/acpi_timer.h>
 #include <machine/acpi_machdep.h>
 #define _COMPONENT	 ACPI_BUS_COMPONENT
 ACPI_MODULE_NAME	 ("acpi_cpu_cstate")
 static void		 acpicpu_cstate_attach_print(struct acpicpu_softc *);
 static ACPI_STATUS	 acpicpu_cstate_cst(struct acpicpu_softc *);
 static ACPI_STATUS	 acpicpu_cstate_cst_add(struct acpicpu_softc *,
 						ACPI_OBJECT *);
 static void		 acpicpu_cstate_cst_bios(void);
 static void		 acpicpu_cstate_fadt(struct acpicpu_softc *);
 static void		 acpicpu_cstate_quirks(struct acpicpu_softc *);
 static int		 acpicpu_cstate_quirks_piix4(struct pci_attach_args *);
 static int		 acpicpu_cstate_latency(struct acpicpu_softc *);
 static bool		 acpicpu_cstate_bm_check(void);
 static void		 acpicpu_cstate_idle_enter(struct acpicpu_softc *,int);
 extern struct acpicpu_softc **acpicpu_sc;
 /*
  * XXX:	The local APIC timer (as well as TSC) is typically
  *	stopped in C3. For now, we cannot but disable C3.
  */
 #ifdef ACPICPU_ENABLE_C3
 static int cs_state_max = ACPI_STATE_C3;
 #else
 static int cs_state_max = ACPI_STATE_C2;
 #endif
 void
 acpicpu_cstate_attach(device_t self)
+{
 	struct acpicpu_softc *sc = device_private(self);
 	ACPI_STATUS rv;
 	/*
 	 * Either use the preferred _CST or resort to FADT.
 	 */
 	rv = acpicpu_cstate_cst(sc);
 	switch (rv) {
 	case AE_OK:
 		sc->sc_flags |= ACPICPU_FLAG_C_CST;
 		acpicpu_cstate_cst_bios();
 		break;
 	default:
 		sc->sc_flags |= ACPICPU_FLAG_C_FADT;
 		acpicpu_cstate_fadt(sc);
 		break;
+	}
 	acpicpu_cstate_quirks(sc);
 	acpicpu_cstate_attach_print(sc);
+}
 void
 acpicpu_cstate_attach_print(struct acpicpu_softc *sc)
+{
 	struct acpicpu_cstate *cs;
 	const char *str;
 	int i;
 	for (i = 0; i < ACPI_C_STATE_COUNT; i++) {
 		cs = &sc->sc_cstate[i];
 		if (cs->cs_method == 0)
 			continue;
 		switch (cs->cs_method) {
 		case ACPICPU_C_STATE_HALT:
 			str = "HALT";
 			break;
 		case ACPICPU_C_STATE_FFH:
 			str = "FFH";
 			break;
 		case ACPICPU_C_STATE_SYSIO:
 			str = "SYSIO";
 			break;
 		default:
 			panic("NOTREACHED");
+		}
-		aprint_verbose_dev(sc->sc_dev, "C%d: %5s, "
+		aprint_debug_dev(sc->sc_dev, "C%d: %5s, "
 		    "lat %3u us, pow %5u mW, addr 0x%06x, flags 0x%02x\n",
 		    i, str, cs->cs_latency, cs->cs_power,
 		    (uint32_t)cs->cs_addr, cs->cs_flags);
+	}
+}
 int
 acpicpu_cstate_detach(device_t self)
+{
 	struct acpicpu_softc *sc = device_private(self);
 	static ONCE_DECL(once_detach);
 	int rv;
 	rv = RUN_ONCE(&once_detach, acpicpu_md_idle_stop);
 	if (rv != 0)
 		return rv;
 	sc->sc_flags &= ~ACPICPU_FLAG_C;
 	return 0;
+}
 int
 acpicpu_cstate_start(device_t self)
+{
 	struct acpicpu_softc *sc = device_private(self);
 	static ONCE_DECL(once_start);
 	static ONCE_DECL(once_save);
 	int rv;
 	/*
 	 * Save the existing idle-mechanism and claim the idle_loop(9).
 	 * This should be called after all ACPI CPUs have been attached.
 	 */
 	rv = RUN_ONCE(&once_save, acpicpu_md_idle_init);
 	if (rv != 0)
 		return rv;
 	rv = RUN_ONCE(&once_start, acpicpu_md_idle_start);
 	if (rv == 0)
 		sc->sc_flags |= ACPICPU_FLAG_C;
 	return rv;
+}
 bool
 acpicpu_cstate_suspend(device_t self)
+{
 	return true;
+}
 bool
 acpicpu_cstate_resume(device_t self)
+{
 	static const ACPI_OSD_EXEC_CALLBACK func = acpicpu_cstate_callback;
 	struct acpicpu_softc *sc = device_private(self);
 	if ((sc->sc_flags & ACPICPU_FLAG_C_CST) != 0)
 		(void)AcpiOsExecute(OSL_NOTIFY_HANDLER, func, sc->sc_dev);
 	return true;
+}
 void
 acpicpu_cstate_callback(void *aux)
+{
 	struct acpicpu_softc *sc;
 	device_t self = aux;
 	sc = device_private(self);
 	if ((sc->sc_flags & ACPICPU_FLAG_C_FADT) != 0) {
 		KASSERT((sc->sc_flags & ACPICPU_FLAG_C_CST) == 0);
 		return;
+	}
 	mutex_enter(&sc->sc_mtx);
 	(void)acpicpu_cstate_cst(sc);
 	mutex_exit(&sc->sc_mtx);
+}
 static ACPI_STATUS
 acpicpu_cstate_cst(struct acpicpu_softc *sc)
+{
 	ACPI_OBJECT *elm, *obj;
 	ACPI_BUFFER buf;
 	ACPI_STATUS rv;
 	uint32_t i, n;
 	uint8_t count;
 	rv = acpi_eval_struct(sc->sc_node->ad_handle, "_CST", &buf);
 	if (ACPI_FAILURE(rv))
 		return rv;
 	obj = buf.Pointer;
 	if (obj->Type != ACPI_TYPE_PACKAGE) {
 		rv = AE_TYPE;
 		goto out;
+	}
 	if (obj->Package.Count < 2) {
 		rv = AE_LIMIT;
 		goto out;
+	}
 	elm = obj->Package.Elements;
 	if (elm[0].Type != ACPI_TYPE_INTEGER) {
 		rv = AE_TYPE;
 		goto out;
+	}
 	n = elm[0].Integer.Value;
 	if (n != obj->Package.Count - 1) {
 		rv = AE_BAD_VALUE;
 		goto out;
+	}
 	if (n > ACPI_C_STATES_MAX) {
 		rv = AE_LIMIT;
 		goto out;
+	}
 	(void)memset(sc->sc_cstate, 0,
 	    sizeof(*sc->sc_cstate) * ACPI_C_STATE_COUNT);
 	CTASSERT(ACPI_STATE_C0 == 0 && ACPI_STATE_C1 == 1);
 	CTASSERT(ACPI_STATE_C2 == 2 && ACPI_STATE_C3 == 3);
 	for (count = 0, i = 1; i <= n; i++) {
 		elm = &obj->Package.Elements[i];
 		rv = acpicpu_cstate_cst_add(sc, elm);
 		if (ACPI_SUCCESS(rv))
 			count++;
+	}
 	rv = (count != 0) ? AE_OK : AE_NOT_EXIST;
 out:
 	if (buf.Pointer != NULL)
 		ACPI_FREE(buf.Pointer);
 	if (ACPI_FAILURE(rv))
 		aprint_error_dev(sc->sc_dev, "failed to evaluate "
 		    "_CST: %s\n", AcpiFormatException(rv));
 	return rv;
+}
 static ACPI_STATUS
 acpicpu_cstate_cst_add(struct acpicpu_softc *sc, ACPI_OBJECT *elm)
+{
 	const struct acpicpu_object *ao = &sc->sc_object;
 	struct acpicpu_cstate *cs = sc->sc_cstate;
 	struct acpicpu_cstate state;
 	struct acpicpu_reg *reg;
 	ACPI_STATUS rv = AE_OK;
 	ACPI_OBJECT *obj;
 	uint32_t type;
 	(void)memset(&state, 0, sizeof(*cs));
 	state.cs_flags = ACPICPU_FLAG_C_BM_STS;
 	if (elm->Type != ACPI_TYPE_PACKAGE) {
 		rv = AE_TYPE;
 		goto out;
+	}
 	if (elm->Package.Count != 4) {
 		rv = AE_LIMIT;
 		goto out;
+	}
 	/*
 	 * Type.
 	 */
 	obj = &elm->Package.Elements[1];
 	if (obj->Type != ACPI_TYPE_INTEGER) {
 		rv = AE_TYPE;
 		goto out;
+	}
 	type = obj->Integer.Value;
 	if (type < ACPI_STATE_C1 || type > ACPI_STATE_C3) {
 		rv = AE_TYPE;
 		goto out;
+	}
 	/*
 	 * Latency.
 	 */
 	obj = &elm->Package.Elements[2];
 	if (obj->Type != ACPI_TYPE_INTEGER) {
 		rv = AE_TYPE;
 		goto out;
+	}
 	state.cs_latency = obj->Integer.Value;
 	/*
 	 * Power.
 	 */
 	obj = &elm->Package.Elements[3];
 	if (obj->Type != ACPI_TYPE_INTEGER) {
 		rv = AE_TYPE;
 		goto out;
+	}
 	state.cs_power = obj->Integer.Value;
 	/*
 	 * Register.
 	 */
 	obj = &elm->Package.Elements[0];
 	if (obj->Type != ACPI_TYPE_BUFFER) {
 		rv = AE_TYPE;
 		goto out;
+	}
 	CTASSERT(sizeof(struct acpicpu_reg) == 15);
 	if (obj->Buffer.Length < sizeof(struct acpicpu_reg)) {
 		rv = AE_LIMIT;
 		goto out;
+	}
 	reg = (struct acpicpu_reg *)obj->Buffer.Pointer;
 	switch (reg->reg_spaceid) {
 	case ACPI_ADR_SPACE_SYSTEM_IO:
 		state.cs_method = ACPICPU_C_STATE_SYSIO;
 		if (reg->reg_addr == 0) {
 			rv = AE_AML_ILLEGAL_ADDRESS;
 			goto out;
+		}
 		if (reg->reg_bitwidth != 8) {
 			rv = AE_AML_BAD_RESOURCE_LENGTH;
 			goto out;
+		}
 		/*
 		 * Check only that the address is in the mapped space.
 		 * Systems are allowed to change it when operating
 		 * with _CST (see ACPI 4.0, pp. 94-95). For instance,
 		 * the offset of P_LVL3 may change depending on whether
 		 * acpiacad(4) is connected or disconnected.
 		 */
 		if (reg->reg_addr > ao->ao_pblkaddr + ao->ao_pblklen) {
 			rv = AE_BAD_ADDRESS;
 			goto out;
+		}
 		state.cs_addr = reg->reg_addr;
 		break;
 	case ACPI_ADR_SPACE_FIXED_HARDWARE:
 		state.cs_method = ACPICPU_C_STATE_FFH;
 		switch (type) {
 		case ACPI_STATE_C1:
 			if ((sc->sc_flags & ACPICPU_FLAG_C_FFH) == 0)
 				state.cs_method = ACPICPU_C_STATE_HALT;
 			break;
 		default:
 			if ((sc->sc_flags & ACPICPU_FLAG_C_FFH) == 0) {
-				rv = AE_AML_BAD_RESOURCE_VALUE;
+				rv = AE_SUPPORT;
 				goto out;
+			}
+		}
 		if (sc->sc_cap != 0) {
 			/*
 			 * The _CST FFH GAS encoding may contain
 			 * additional hints on Intel processors.
 			 * Use these to determine whether we can
 			 * avoid the bus master activity check.
 			 */
 			if ((reg->reg_accesssize & ACPICPU_PDC_GAS_BM) == 0)
 				state.cs_flags &= ~ACPICPU_FLAG_C_BM_STS;
+		}
 		break;
 	default:
 		rv = AE_AML_INVALID_SPACE_ID;
 		goto out;
+	}
 	if (cs[type].cs_method != 0) {
 		rv = AE_ALREADY_EXISTS;
 		goto out;
+	}
 	cs[type].cs_addr = state.cs_addr;
 	cs[type].cs_power = state.cs_power;
 	cs[type].cs_flags = state.cs_flags;
 	cs[type].cs_method = state.cs_method;
 	cs[type].cs_latency = state.cs_latency;
 out:
 	if (ACPI_FAILURE(rv))
-		aprint_verbose_dev(sc->sc_dev,
+		aprint_debug_dev(sc->sc_dev, "invalid "
-		    "invalid _CST: %s\n", AcpiFormatException(rv));
+		    "_CST: %s\n", AcpiFormatException(rv));
 	return rv;
+}
 static void
 acpicpu_cstate_cst_bios(void)
+{
 	const uint8_t val = AcpiGbl_FADT.CstControl;
 	const uint32_t addr = AcpiGbl_FADT.SmiCommand;
 	if (addr == 0)
 		return;
 	(void)AcpiOsWritePort(addr, val, 8);
+}
 static void
 acpicpu_cstate_fadt(struct acpicpu_softc *sc)
+{
 	struct acpicpu_cstate *cs = sc->sc_cstate;
 	(void)memset(cs, 0, sizeof(*cs) * ACPI_C_STATE_COUNT);
 	/*
 	 * All x86 processors should support C1 (a.k.a. HALT).
 	 */
 	if ((AcpiGbl_FADT.Flags & ACPI_FADT_C1_SUPPORTED) != 0)
 		cs[ACPI_STATE_C1].cs_method = ACPICPU_C_STATE_HALT;
 	if ((acpicpu_md_cpus_running() > 1) &&
 	    (AcpiGbl_FADT.Flags & ACPI_FADT_C2_MP_SUPPORTED) == 0)
 		return;
 	cs[ACPI_STATE_C2].cs_method = ACPICPU_C_STATE_SYSIO;
 	cs[ACPI_STATE_C3].cs_method = ACPICPU_C_STATE_SYSIO;
 	cs[ACPI_STATE_C2].cs_latency = AcpiGbl_FADT.C2Latency;
 	cs[ACPI_STATE_C3].cs_latency = AcpiGbl_FADT.C3Latency;
 	cs[ACPI_STATE_C2].cs_addr = sc->sc_object.ao_pblkaddr + 4;
 	cs[ACPI_STATE_C3].cs_addr = sc->sc_object.ao_pblkaddr + 5;
 	/*
 	 * The P_BLK length should always be 6. If it
 	 * is not, reduce functionality accordingly.
 	 * Sanity check also FADT's latency levels.
 	 */
 	if (sc->sc_object.ao_pblklen < 5)
 		cs[ACPI_STATE_C2].cs_method = 0;
 	if (sc->sc_object.ao_pblklen < 6)
 		cs[ACPI_STATE_C3].cs_method = 0;
 	CTASSERT(ACPICPU_C_C2_LATENCY_MAX == 100);
 	CTASSERT(ACPICPU_C_C3_LATENCY_MAX == 1000);
 	if (AcpiGbl_FADT.C2Latency > ACPICPU_C_C2_LATENCY_MAX)
 		cs[ACPI_STATE_C2].cs_method = 0;
 	if (AcpiGbl_FADT.C3Latency > ACPICPU_C_C3_LATENCY_MAX)
 		cs[ACPI_STATE_C3].cs_method = 0;
+}
 static void
 acpicpu_cstate_quirks(struct acpicpu_softc *sc)
+{
 	const uint32_t reg = AcpiGbl_FADT.Pm2ControlBlock;
 	const uint32_t len = AcpiGbl_FADT.Pm2ControlLength;
 	struct pci_attach_args pa;
 	/*
 	 * Check bus master arbitration. If ARB_DIS
 	 * is not available, processor caches must be
 	 * flushed before C3 (ACPI 4.0, section 8.2).
 	 */
 	if (reg != 0 && len != 0)
 		sc->sc_flags |= ACPICPU_FLAG_C_ARB;
 	else {
 		/*
 		 * Disable C3 entirely if WBINVD is not present.
 		 */
 		if ((AcpiGbl_FADT.Flags & ACPI_FADT_WBINVD) == 0)
 			sc->sc_flags |= ACPICPU_FLAG_C_NOC3;
 		else {
 			/*
 			 * If WBINVD is present and functioning properly,
 			 * flush all processor caches before entering C3.
 			 */
 			if ((AcpiGbl_FADT.Flags & ACPI_FADT_WBINVD_FLUSH) == 0)
 				sc->sc_flags &= ~ACPICPU_FLAG_C_BM;
 			else
 				sc->sc_flags |= ACPICPU_FLAG_C_NOC3;
+		}
+	}
 	/*
 	 * There are several erratums for PIIX4.
 	 */
 	if (pci_find_device(&pa, acpicpu_cstate_quirks_piix4) != 0)
 		sc->sc_flags |= ACPICPU_FLAG_C_NOC3;
 	if ((sc->sc_flags & ACPICPU_FLAG_C_NOC3) != 0)
 		sc->sc_cstate[ACPI_STATE_C3].cs_method = 0;
+}
 static int
 acpicpu_cstate_quirks_piix4(struct pci_attach_args *pa)
+{
 	if (PCI_VENDOR(pa->pa_id) != PCI_VENDOR_INTEL)
 		return 0;
 	if (PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_INTEL_82371AB_ISA ||
 	    PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_INTEL_82440MX_PMC)
 		return 1;
 	return 0;
+}
 static int
 acpicpu_cstate_latency(struct acpicpu_softc *sc)
+{
 	static const uint32_t cs_factor = 3;
 	struct acpicpu_cstate *cs;
 	int i;
 	for (i = cs_state_max; i > 0; i--) {
 		cs = &sc->sc_cstate[i];
 		if (__predict_false(cs->cs_method == 0))
 			continue;
 		/*
 		 * Choose a state if we have previously slept
 		 * longer than the worst case latency of the
 		 * state times an arbitrary multiplier.
 		 */
 		if (sc->sc_cstate_sleep > cs->cs_latency * cs_factor)
 			return i;
+	}
 	return ACPI_STATE_C1;
+}
 /*
  * The main idle loop.
  */
 void
 acpicpu_cstate_idle(void)
+{
         struct cpu_info *ci = curcpu();
 	struct acpicpu_softc *sc;
 	int state;
 	if (__predict_false(ci->ci_want_resched) != 0)
 		return;
 	acpi_md_OsDisableInterrupt();
 	KASSERT(acpicpu_sc != NULL);
 	KASSERT(ci->ci_acpiid < maxcpus);
 	KASSERT(ci->ci_ilevel == IPL_NONE);
 	sc = acpicpu_sc[ci->ci_acpiid];
 	if (__predict_false(sc == NULL))
 		goto halt;
 	if (__predict_false(sc->sc_cold != false))
 		goto halt;
 	if (__predict_false((sc->sc_flags & ACPICPU_FLAG_C) == 0))
 		goto halt;
 	if (__predict_false(mutex_tryenter(&sc->sc_mtx) == 0))
 		goto halt;
 	mutex_exit(&sc->sc_mtx);
 	state = acpicpu_cstate_latency(sc);
 	/*
 	 * Check for bus master activity. Note that particularly usb(4)
 	 * causes high activity, which may prevent the use of C3 states.
 	 */
 	if ((sc->sc_cstate[state].cs_flags & ACPICPU_FLAG_C_BM_STS) != 0) {
 		if (acpicpu_cstate_bm_check() != false)
 			state--;
 		if (__predict_false(sc->sc_cstate[state].cs_method == 0))
 			state = ACPI_STATE_C1;
+	}
 	KASSERT(state != ACPI_STATE_C0);
 	if (state != ACPI_STATE_C3) {
 		acpicpu_cstate_idle_enter(sc, state);
 		return;
+	}
 	/*
 	 * On all recent (Intel) CPUs caches are shared
 	 * by CPUs and bus master control is required to
 	 * keep these coherent while in C3. Flushing the
 	 * CPU caches is only the last resort.
 	 */
 	if ((sc->sc_flags & ACPICPU_FLAG_C_BM) == 0)
 		ACPI_FLUSH_CPU_CACHE();
 	/*
 	 * Allow the bus master to request that any given
 	 * CPU should return immediately to C0 from C3.
 	 */
 	if ((sc->sc_flags & ACPICPU_FLAG_C_BM) != 0)
 		(void)AcpiWriteBitRegister(ACPI_BITREG_BUS_MASTER_RLD, 1);
 	/*
 	 * It may be necessary to disable bus master arbitration
 	 * to ensure that bus master cycles do not occur while
 	 * sleeping in C3 (see ACPI 4.0, section 8.1.4).
 	 */
 	if ((sc->sc_flags & ACPICPU_FLAG_C_ARB) != 0)
 		(void)AcpiWriteBitRegister(ACPI_BITREG_ARB_DISABLE, 1);
 	acpicpu_cstate_idle_enter(sc, state);
 	/*
 	 * Disable bus master wake and re-enable the arbiter.
 	 */
 	if ((sc->sc_flags & ACPICPU_FLAG_C_BM) != 0)
 		(void)AcpiWriteBitRegister(ACPI_BITREG_BUS_MASTER_RLD, 0);
 	if ((sc->sc_flags & ACPICPU_FLAG_C_ARB) != 0)
 		(void)AcpiWriteBitRegister(ACPI_BITREG_ARB_DISABLE, 0);
 	return;
 halt:
 	acpicpu_md_idle_enter(ACPICPU_C_STATE_HALT, ACPI_STATE_C1);
+}
 static void
 acpicpu_cstate_idle_enter(struct acpicpu_softc *sc, int state)
+{
 	struct acpicpu_cstate *cs = &sc->sc_cstate[state];
 	uint32_t end, start, val;
 	start = acpitimer_read_safe(NULL);
 	switch (cs->cs_method) {
 	case ACPICPU_C_STATE_FFH:
 	case ACPICPU_C_STATE_HALT:
 		acpicpu_md_idle_enter(cs->cs_method, state);
 		break;
 	case ACPICPU_C_STATE_SYSIO:
 		(void)AcpiOsReadPort(cs->cs_addr, &val, 8);
 		break;
 	default:
 		acpicpu_md_idle_enter(ACPICPU_C_STATE_HALT, ACPI_STATE_C1);
 		break;
+	}
 	cs->cs_stat++;
 	end = acpitimer_read_safe(NULL);
 	sc->sc_cstate_sleep = hztoms(acpitimer_delta(end, start)) * 1000;
 	acpi_md_OsEnableInterrupt();
+}
 static bool
 acpicpu_cstate_bm_check(void)
+{
 	uint32_t val = 0;
 	ACPI_STATUS rv;
 	rv = AcpiReadBitRegister(ACPI_BITREG_BUS_MASTER_STATUS, &val);
 	if (ACPI_FAILURE(rv) || val == 0)
 		return false;
 	(void)AcpiWriteBitRegister(ACPI_BITREG_BUS_MASTER_STATUS, 1);
 	return true;
+}

 @@ -1,661 +1,661 @@
-/* $NetBSD: acpi_cpu_pstate.c,v 1.3 2010/08/08 18:10:34 jruoho Exp $ */
+/* $NetBSD: acpi_cpu_pstate.c,v 1.4 2010/08/08 18:25:06 jruoho Exp $ */
 /*-
  * Copyright (c) 2010 Jukka Ruohonen <jruohonen@iki.fi>
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
+ *
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: acpi_cpu_pstate.c,v 1.3 2010/08/08 18:10:34 jruoho Exp $");
+__KERNEL_RCSID(0, "$NetBSD: acpi_cpu_pstate.c,v 1.4 2010/08/08 18:25:06 jruoho Exp $");
 #include <sys/param.h>
 #include <sys/kmem.h>
 #include <sys/once.h>
 #include <dev/acpi/acpireg.h>
 #include <dev/acpi/acpivar.h>
 #include <dev/acpi/acpi_cpu.h>
 #define _COMPONENT	 ACPI_BUS_COMPONENT
 ACPI_MODULE_NAME	 ("acpi_cpu_pstate")
 static void		 acpicpu_pstate_attach_print(struct acpicpu_softc *);
 static ACPI_STATUS	 acpicpu_pstate_pss(struct acpicpu_softc *sc);
 static ACPI_STATUS	 acpicpu_pstate_pss_add(struct acpicpu_pstate *,
 						ACPI_OBJECT *);
 static ACPI_STATUS	 acpicpu_pstate_pct(struct acpicpu_softc *);
 static int		 acpicpu_pstate_max(struct acpicpu_softc *);
 static void		 acpicpu_pstate_change(struct acpicpu_softc *);
 static void		 acpicpu_pstate_bios(void);
 void
 acpicpu_pstate_attach(device_t self)
+{
 	struct acpicpu_softc *sc = device_private(self);
 	const char *str;
 	ACPI_STATUS rv;
 	rv = acpicpu_pstate_pss(sc);
 	if (ACPI_FAILURE(rv)) {
 		str = "_PSS";
 		goto fail;
+	}
 	rv = acpicpu_pstate_pct(sc);
 	if (rv == AE_SUPPORT) {
 		aprint_error_dev(sc->sc_dev, "CPU not supported\n");
 		return;
+	}
 	if (ACPI_FAILURE(rv)) {
 		str = "_PCT";
 		goto fail;
+	}
 	rv = acpicpu_pstate_max(sc);
 	if (rv == 0)
 		sc->sc_flags |= ACPICPU_FLAG_P_PPC;
 	sc->sc_flags |= ACPICPU_FLAG_P;
 	acpicpu_pstate_bios();
 	acpicpu_pstate_attach_print(sc);
 	return;
 fail:
 	aprint_error_dev(sc->sc_dev, "failed to evaluate "
 	    "%s: %s\n", str, AcpiFormatException(rv));
+}
 static void
 acpicpu_pstate_attach_print(struct acpicpu_softc *sc)
+{
 	const uint8_t method = sc->sc_pstate_control.reg_spaceid;
 	struct acpicpu_pstate *ps;
 	const char *str;
 	uint32_t i;
 	str = (method != ACPI_ADR_SPACE_SYSTEM_IO) ? "FFH" : "SYSIO";
 	for (i = 0; i < sc->sc_pstate_count; i++) {
 		ps = &sc->sc_pstate[i];
 		if (ps->ps_freq == 0)
 			continue;
 		aprint_debug_dev(sc->sc_dev, "P%d: %5s, "
 		    "lat %3u us, pow %5u mW, %4u MHz\n",
 		    i, str, ps->ps_latency, ps->ps_power, ps->ps_freq);
+	}
+}
 int
 acpicpu_pstate_detach(device_t self)
+{
 	struct acpicpu_softc *sc = device_private(self);
 	static ONCE_DECL(once_detach);
 	size_t size;
 	int rv;
 	if ((sc->sc_flags & ACPICPU_FLAG_P) == 0)
 		return 0;
 	rv = RUN_ONCE(&once_detach, acpicpu_md_pstate_stop);
 	if (rv != 0)
 		return rv;
 	size = sc->sc_pstate_count * sizeof(*sc->sc_pstate);
 	if (sc->sc_pstate != NULL)
 		kmem_free(sc->sc_pstate, size);
 	sc->sc_flags &= ~ACPICPU_FLAG_P;
 	return 0;
+}
 int
 acpicpu_pstate_start(device_t self)
+{
 	struct acpicpu_softc *sc = device_private(self);
 	static ONCE_DECL(once_start);
 	if ((sc->sc_flags & ACPICPU_FLAG_P) == 0)
 		return 0;
 	return RUN_ONCE(&once_start, acpicpu_md_pstate_start);
+}
 bool
 acpicpu_pstate_suspend(device_t self)
+{
 	return true;
+}
 bool
 acpicpu_pstate_resume(device_t self)
+{
 	static const ACPI_OSD_EXEC_CALLBACK func = acpicpu_pstate_callback;
 	struct acpicpu_softc *sc = device_private(self);
 	KASSERT((sc->sc_flags & ACPICPU_FLAG_P) != 0);
 	if ((sc->sc_flags & ACPICPU_FLAG_P_PPC) != 0)
 		(void)AcpiOsExecute(OSL_NOTIFY_HANDLER, func, sc->sc_dev);
 	return true;
+}
 void
 acpicpu_pstate_callback(void *aux)
+{
 	struct acpicpu_softc *sc;
 	device_t self = aux;
 	uint32_t old, new;
 	sc = device_private(self);
 	if ((sc->sc_flags & ACPICPU_FLAG_P_PPC) == 0)
 		return;
 	mutex_enter(&sc->sc_mtx);
 	old = sc->sc_pstate_max;
 	acpicpu_pstate_change(sc);
 	new = sc->sc_pstate_max;
 	mutex_exit(&sc->sc_mtx);
 #if 0
 	if (old != new) {
 		/*
 		 * If the maximum changed, proactively
 		 * raise or lower the target frequency.
 		 */
 		acpicpu_pstate_set(sc, sc->sc_pstate[new].ps_freq);
 		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "frequency changed from "
 			"%u MHz to %u MHz\n", sc->sc_pstate[old].ps_freq,
 			sc->sc_pstate[sc->sc_pstate_max].ps_freq));
+	}
 #endif
+}
 ACPI_STATUS
 acpicpu_pstate_pss(struct acpicpu_softc *sc)
+{
 	struct acpicpu_pstate *ps;
 	ACPI_OBJECT *obj;
 	ACPI_BUFFER buf;
 	ACPI_STATUS rv;
 	uint32_t count;
 	uint32_t i, j;
 	rv = acpi_eval_struct(sc->sc_node->ad_handle, "_PSS", &buf);
 	if (ACPI_FAILURE(rv))
 		return rv;
 	obj = buf.Pointer;
 	if (obj->Type != ACPI_TYPE_PACKAGE) {
 		rv = AE_TYPE;
 		goto out;
+	}
 	sc->sc_pstate_count = obj->Package.Count;
 	if (sc->sc_pstate_count == 0) {
 		rv = AE_NOT_EXIST;
 		goto out;
+	}
 	if (sc->sc_pstate_count > 0xFF) {
 		rv = AE_LIMIT;
 		goto out;
+	}
 	sc->sc_pstate = kmem_zalloc(sc->sc_pstate_count *
 	    sizeof(struct acpicpu_pstate), KM_SLEEP);
 	if (sc->sc_pstate == NULL) {
 		rv = AE_NO_MEMORY;
 		goto out;
+	}
 	for (count = i = 0; i < sc->sc_pstate_count; i++) {
 		ps = &sc->sc_pstate[i];
 		rv = acpicpu_pstate_pss_add(ps, &obj->Package.Elements[i]);
 		if (ACPI_FAILURE(rv))
 			continue;
 		for (j = 0; j < i; j++) {
 			if (ps->ps_freq >= sc->sc_pstate[j].ps_freq) {
 				ps->ps_freq = 0;
 				break;
+			}
+		}
 		if (ps->ps_freq != 0)
 			count++;
+	}
 	rv = (count != 0) ? AE_OK : AE_NOT_EXIST;
 out:
 	if (buf.Pointer != NULL)
 		ACPI_FREE(buf.Pointer);
 	return rv;
+}
 static ACPI_STATUS
 acpicpu_pstate_pss_add(struct acpicpu_pstate *ps, ACPI_OBJECT *obj)
+{
 	ACPI_OBJECT *elm;
 	uint32_t val[6];
 	uint32_t *p;
 	int i;
 	if (obj->Type != ACPI_TYPE_PACKAGE)
 		return AE_TYPE;
 	if (obj->Package.Count != 6)
 		return AE_BAD_DATA;
 	elm = obj->Package.Elements;
 	for (i = 0; i < 6; i++) {
 		if (elm[i].Type != ACPI_TYPE_INTEGER)
 			return AE_TYPE;
 		if (elm[i].Integer.Value > UINT32_MAX)
 			return AE_AML_NUMERIC_OVERFLOW;
 		val[i] = elm[i].Integer.Value;
+	}
 	if (val[0] == 0 || val[0] >= 0xFFFF)
 		return AE_BAD_DECIMAL_CONSTANT;
 	CTASSERT(sizeof(val) == sizeof(struct acpicpu_pstate) -
 	         offsetof(struct acpicpu_pstate, ps_freq));
 	p = &ps->ps_freq;
 	for (i = 0; i < 6; i++, p++)
 		*p = val[i];
 	/*
 	 * The latency is typically around 10 usec
 	 * on Intel CPUs. Use that as the minimum.
 	 */
 	if (ps->ps_latency < 10)
 		ps->ps_latency = 10;
 	return AE_OK;
+}
 ACPI_STATUS
 acpicpu_pstate_pct(struct acpicpu_softc *sc)
+{
 	static const size_t size = sizeof(struct acpicpu_reg);
 	struct acpicpu_reg *reg[2];
 	ACPI_OBJECT *elm, *obj;
 	ACPI_BUFFER buf;
 	ACPI_STATUS rv;
 	uint8_t width;
 	int i;
 	rv = acpi_eval_struct(sc->sc_node->ad_handle, "_PCT", &buf);
 	if (ACPI_FAILURE(rv))
 		return rv;
 	obj = buf.Pointer;
 	if (obj->Type != ACPI_TYPE_PACKAGE) {
 		rv = AE_TYPE;
 		goto out;
+	}
 	if (obj->Package.Count != 2) {
 		rv = AE_LIMIT;
 		goto out;
+	}
 	for (i = 0; i < 2; i++) {
 		elm = &obj->Package.Elements[i];
 		if (elm->Type != ACPI_TYPE_BUFFER) {
 			rv = AE_TYPE;
 			goto out;
+		}
 		if (size > elm->Buffer.Length) {
 			rv = AE_AML_BAD_RESOURCE_LENGTH;
 			goto out;
+		}
 		reg[i] = (struct acpicpu_reg *)elm->Buffer.Pointer;
 		switch (reg[i]->reg_spaceid) {
 		case ACPI_ADR_SPACE_SYSTEM_IO:
 			if (reg[i]->reg_addr == 0) {
 				rv = AE_AML_ILLEGAL_ADDRESS;
 				goto out;
+			}
 			width = reg[i]->reg_bitwidth;
 			if (width != 8 && width != 16 && width != 32) {
-				rv = AE_SUPPORT;
+				rv = AE_AML_BAD_RESOURCE_VALUE;
 				goto out;
+			}
 			break;
 		case ACPI_ADR_SPACE_FIXED_HARDWARE:
 			if ((sc->sc_flags & ACPICPU_FLAG_P_FFH) == 0) {
-				rv = AE_AML_BAD_RESOURCE_VALUE;
+				rv = AE_SUPPORT;
 				goto out;
+			}
 			break;
 		default:
 			rv = AE_AML_INVALID_SPACE_ID;
 			goto out;
+		}
+	}
 	if (reg[0]->reg_spaceid != reg[1]->reg_spaceid) {
 		rv = AE_AML_INVALID_SPACE_ID;
 		goto out;
+	}
 	(void)memcpy(&sc->sc_pstate_control, reg[0], size); /* PERF_CTRL   */
 	(void)memcpy(&sc->sc_pstate_status,  reg[1], size); /* PERF_STATUS */
 out:
 	if (buf.Pointer != NULL)
 		ACPI_FREE(buf.Pointer);
 	return rv;
+}
 static int
 acpicpu_pstate_max(struct acpicpu_softc *sc)
+{
 	ACPI_INTEGER val;
 	ACPI_STATUS rv;
 	/*
 	 * Evaluate the currently highest P-state that can be used.
 	 * If available, we can use either this state or any lower
 	 * power (i.e. higher numbered) state from the _PSS object.
 	 */
 	rv = acpi_eval_integer(sc->sc_node->ad_handle, "_PPC", &val);
 	sc->sc_pstate_max = 0;
 	if (ACPI_FAILURE(rv))
 		return 1;
 	if (val > (uint64_t)sc->sc_pstate_count)
 		return 1;
 	if (sc->sc_pstate[val].ps_freq == 0)
 		return 1;
 	sc->sc_pstate_max = val;		/* XXX: sysctl(8) knob?  */
 	return 0;
+}
 static void
 acpicpu_pstate_change(struct acpicpu_softc *sc)
+{
 	ACPI_OBJECT_LIST arg;
 	ACPI_OBJECT obj[2];
 	arg.Count = 2;
 	arg.Pointer = obj;
 	obj[0].Type = ACPI_TYPE_INTEGER;
 	obj[1].Type = ACPI_TYPE_INTEGER;
 	obj[0].Integer.Value = ACPICPU_P_NOTIFY;
 	obj[1].Integer.Value = acpicpu_pstate_max(sc);
 	(void)AcpiEvaluateObject(sc->sc_node->ad_handle, "_OST", &arg, NULL);
+}
 static void
 acpicpu_pstate_bios(void)
+{
 	const uint8_t val = AcpiGbl_FADT.PstateControl;
 	const uint32_t addr = AcpiGbl_FADT.SmiCommand;
 	if (addr == 0)
 		return;
 	(void)AcpiOsWritePort(addr, val, 8);
+}
 int
 acpicpu_pstate_get(struct acpicpu_softc *sc, uint32_t *freq)
+{
 	const uint8_t method = sc->sc_pstate_control.reg_spaceid;
 	struct acpicpu_pstate *ps = NULL;
 	uint32_t i, val = 0;
 	uint64_t addr;
 	uint8_t width;
 	int rv;
 	if ((sc->sc_flags & ACPICPU_FLAG_P) == 0) {
 		rv = ENODEV;
 		goto fail;
+	}
 	if (sc->sc_pstate_current != ACPICPU_P_STATE_UNKNOWN) {
 		*freq = sc->sc_pstate_current;
 		return 0;
+	}
 	switch (method) {
 	case ACPI_ADR_SPACE_FIXED_HARDWARE:
 		rv = acpicpu_md_pstate_get(sc, freq);
 		if (rv != 0)
 			goto fail;
 		break;
 	case ACPI_ADR_SPACE_SYSTEM_IO:
 		addr  = sc->sc_pstate_status.reg_addr;
 		width = sc->sc_pstate_status.reg_bitwidth;
 		(void)AcpiOsReadPort(addr, &val, width);
 		if (val == 0) {
 			rv = EIO;
 			goto fail;
+		}
 		mutex_enter(&sc->sc_mtx);
 		for (i = sc->sc_pstate_max; i < sc->sc_pstate_count; i++) {
 			if (sc->sc_pstate[i].ps_freq == 0)
 				continue;
 			if (val == sc->sc_pstate[i].ps_status) {
 				ps = &sc->sc_pstate[i];
 				break;
+			}
+		}
 		mutex_exit(&sc->sc_mtx);
 		if (ps == NULL) {
 			rv = EIO;
 			goto fail;
+		}
 		*freq = ps->ps_freq;
 		break;
 	default:
 		rv = ENOTTY;
 		goto fail;
+	}
 	sc->sc_pstate_current = *freq;
 	return 0;
 fail:
 	aprint_error_dev(sc->sc_dev, "failed "
 	    "to get frequency (err %d)\n", rv);
 	*freq = sc->sc_pstate_current = ACPICPU_P_STATE_UNKNOWN;
 	return rv;
+}
 int
 acpicpu_pstate_set(struct acpicpu_softc *sc, uint32_t freq)
+{
 	const uint8_t method = sc->sc_pstate_control.reg_spaceid;
 	struct acpicpu_pstate *ps = NULL;
 	uint32_t i, val;
 	uint64_t addr;
 	uint8_t width;
 	int rv;
 	if ((sc->sc_flags & ACPICPU_FLAG_P) == 0) {
 		rv = ENODEV;
 		goto fail;
+	}
 	mutex_enter(&sc->sc_mtx);
 	for (i = sc->sc_pstate_max; i < sc->sc_pstate_count; i++) {
 		if (sc->sc_pstate[i].ps_freq == 0)
 			continue;
 		if (sc->sc_pstate[i].ps_freq == freq) {
 			ps = &sc->sc_pstate[i];
 			break;
+		}
+	}
 	mutex_exit(&sc->sc_mtx);
 	if (ps == NULL) {
 		rv = EINVAL;
 		goto fail;
+	}
 	switch (method) {
 	case ACPI_ADR_SPACE_FIXED_HARDWARE:
 		rv = acpicpu_md_pstate_set(ps);
 		if (rv != 0)
 			goto fail;
 		break;
 	case ACPI_ADR_SPACE_SYSTEM_IO:
 		addr  = sc->sc_pstate_control.reg_addr;
 		width = sc->sc_pstate_control.reg_bitwidth;
 		(void)AcpiOsWritePort(addr, ps->ps_control, width);
 		addr  = sc->sc_pstate_status.reg_addr;
 		width = sc->sc_pstate_status.reg_bitwidth;
 		/*
 		 * Some systems take longer to respond
 		 * than the reported worst-case latency.
 		 */
 		for (i = val = 0; i < ACPICPU_P_STATE_RETRY; i++) {
 			(void)AcpiOsReadPort(addr, &val, width);
 			if (val == ps->ps_status)
 				break;
 			DELAY(ps->ps_latency);
+		}
 		if (i == ACPICPU_P_STATE_RETRY) {
 			rv = EAGAIN;
 			goto fail;
+		}
 		break;
 	default:
 		rv = ENOTTY;
 		goto fail;
+	}
 	ps->ps_stat++;
 	sc->sc_pstate_current = freq;
 	return 0;
 fail:
 	aprint_error_dev(sc->sc_dev, "failed to set "
 	    "frequency to %u (err %d)\n", freq, rv);
 	sc->sc_pstate_current = ACPICPU_P_STATE_UNKNOWN;
 	return rv;
+}