 @@ -1,14 +1,14 @@
-/*	$NetBSD: wmi_acpi.c,v 1.15 2010/03/05 14:00:17 jruoho Exp $	*/
+/*	$NetBSD: wmi_acpi.c,v 1.16 2010/03/08 10:53:03 jruoho Exp $	*/
 /*-
  * Copyright (c) 2009, 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
 @@ -17,27 +17,27 @@
  * 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: wmi_acpi.c,v 1.15 2010/03/05 14:00:17 jruoho Exp $");
+__KERNEL_RCSID(0, "$NetBSD: wmi_acpi.c,v 1.16 2010/03/08 10:53:03 jruoho Exp $");
 #include <sys/param.h>
 #include <sys/device.h>
 #include <sys/endian.h>
 #include <sys/kmem.h>
 #include <sys/systm.h>
 #include <dev/acpi/acpireg.h>
 #include <dev/acpi/acpivar.h>
 #include <dev/acpi/wmi_acpivar.h>
 #define _COMPONENT          ACPI_RESOURCE_COMPONENT
 ACPI_MODULE_NAME            ("wmi_acpi")
 @@ -107,96 +107,115 @@ struct acpi_wmi_softc {
 #define HEXCHAR(x)  (((x) >= '0' && (x) <= '9') ||			\
 	             ((x) >= 'a' && (x) <= 'f') ||			\
 		     ((x) >= 'A' && (x) <= 'F'))
 #define GUIDCMP(a, b)							\
 	((a)->data1 == (b)->data1 &&					\
 	 (a)->data2 == (b)->data2 &&					\
 	 (a)->data3 == (b)->data3 &&					\
 	 UGET64((a)->data4) == UGET64((b)->data4))
 static int         acpi_wmi_match(device_t, cfdata_t, void *);
 static void        acpi_wmi_attach(device_t, device_t, void *);
 static int         acpi_wmi_detach(device_t, int);
 static int         acpi_wmi_print(void *, const char *);
 static bool        acpi_wmi_init(struct acpi_wmi_softc *);
 static bool        acpi_wmi_add(struct acpi_wmi_softc *, ACPI_OBJECT *);
 static void        acpi_wmi_del(struct acpi_wmi_softc *);
 #ifdef ACPIVERBOSE
 static void        acpi_wmi_dump(struct acpi_wmi_softc *);
 #endif
 static ACPI_STATUS acpi_wmi_guid_get(struct acpi_wmi_softc *,
                                      const char *, struct wmi_t **);
-static void        acpi_wmi_event_add(struct acpi_wmi_softc *);
+static ACPI_STATUS acpi_wmi_event_add(struct acpi_wmi_softc *);
-static void        acpi_wmi_event_del(struct acpi_wmi_softc *);
+static ACPI_STATUS acpi_wmi_event_del(struct acpi_wmi_softc *);
 static void        acpi_wmi_event_handler(ACPI_HANDLE, uint32_t, void *);
 static bool        acpi_wmi_suspend(device_t, const pmf_qual_t *);
 static bool        acpi_wmi_resume(device_t, const pmf_qual_t *);
 static ACPI_STATUS acpi_wmi_enable(ACPI_HANDLE, const char *, bool, bool);
 static bool        acpi_wmi_input(struct wmi_t *, uint8_t, uint8_t);
 const char * const acpi_wmi_ids[] = {
 	"PNP0C14",
 	NULL
 };
 CFATTACH_DECL_NEW(acpiwmi, sizeof(struct acpi_wmi_softc),
-    acpi_wmi_match, acpi_wmi_attach, NULL, NULL);
+    acpi_wmi_match, acpi_wmi_attach, acpi_wmi_detach, NULL);
 static int
 acpi_wmi_match(device_t parent, cfdata_t match, void *aux)
+{
 	struct acpi_attach_args *aa = aux;
 	if (aa->aa_node->ad_type != ACPI_TYPE_DEVICE)
 		return 0;
 	return acpi_match_hid(aa->aa_node->ad_devinfo, acpi_wmi_ids);
+}
 static void
 acpi_wmi_attach(device_t parent, device_t self, void *aux)
+{
 	struct acpi_wmi_softc *sc = device_private(self);
 	struct acpi_attach_args *aa = aux;
 	sc->sc_dev = self;
 	sc->sc_node = aa->aa_node;
 	sc->sc_child = NULL;
 	sc->sc_handler = NULL;
 	aprint_naive("\n");
 	aprint_normal(": ACPI WMI Interface\n");
 	if (acpi_wmi_init(sc) != true)
 		return;
 #ifdef ACPIVERBOSE
 	acpi_wmi_dump(sc);
 #endif
-	acpi_wmi_event_add(sc);
+	(void)acpi_wmi_event_add(sc);
 	(void)pmf_device_register(self, acpi_wmi_suspend, acpi_wmi_resume);
 	if (pmf_device_register(sc->sc_dev,
 		acpi_wmi_suspend, acpi_wmi_resume) != true)
 		aprint_error_dev(self, "failed to register power handler\n");
 	/* Attach a child device to the pseudo-bus. */
 	sc->sc_child = config_found_ia(self, "acpiwmibus",
 	    NULL, acpi_wmi_print);
+}
 static int
 acpi_wmi_detach(device_t self, int flags)
+{
 	struct acpi_wmi_softc *sc = device_private(self);
 	ACPI_STATUS rv;
 	rv = acpi_wmi_event_del(sc);
 	if (ACPI_FAILURE(rv))
 		return EBUSY;
 	if (sc->sc_child != NULL)
 		(void)config_detach(sc->sc_child, flags);
 	acpi_wmi_del(sc);
 	pmf_device_deregister(self);
 	return 0;
+}
 static int
 acpi_wmi_print(void *aux, const char *pnp)
+{
 	if (pnp != NULL)
 		aprint_normal("acpiwmibus at %s", pnp);
 	return UNCONF;
+}
 static bool
 acpi_wmi_init(struct acpi_wmi_softc *sc)
+{
 	ACPI_OBJECT *obj;
 @@ -379,98 +398,102 @@ int
 acpi_wmi_guid_match(device_t self, const char *guid)
+{
 	struct acpi_wmi_softc *sc = device_private(self);
 	if (ACPI_SUCCESS(acpi_wmi_guid_get(sc, guid, NULL)))
 		return 1;
 	return 0;
+}
 /*
  * Adds internal event handler.
  */
-static void
+static ACPI_STATUS
 acpi_wmi_event_add(struct acpi_wmi_softc *sc)
+{
 	struct wmi_t *wmi;
 	ACPI_STATUS rv;
 	rv = AcpiInstallNotifyHandler(sc->sc_node->ad_handle,
 	    ACPI_ALL_NOTIFY, acpi_wmi_event_handler, sc);
 	if (ACPI_FAILURE(rv)) {
 		aprint_error_dev(sc->sc_dev, "failed to install notify "
 		    "handler: %s\n", AcpiFormatException(rv));
-		return;
+		return rv;
+	}
 	/* Enable possible expensive events. */
 	SIMPLEQ_FOREACH(wmi, &sc->wmi_head, wmi_link) {
 		if ((wmi->guid.flags & ACPI_WMI_FLAG_EVENT) &&
 		    (wmi->guid.flags & ACPI_WMI_FLAG_EXPENSIVE)) {
 			rv = acpi_wmi_enable(sc->sc_node->ad_handle,
 			    wmi->guid.oid, false, true);
 			if (ACPI_SUCCESS(rv)) {
 				wmi->eevent = true;
 				continue;
+			}
 			aprint_error_dev(sc->sc_dev, "failed to enable "
 			    "expensive WExx: %s\n", AcpiFormatException(rv));
+		}
+	}
 	return AE_OK;
+}
 /*
  * Removes the internal event handler.
  */
-static void
+static ACPI_STATUS
 acpi_wmi_event_del(struct acpi_wmi_softc *sc)
+{
 	struct wmi_t *wmi;
 	ACPI_STATUS rv;
 	rv = AcpiRemoveNotifyHandler(sc->sc_node->ad_handle,
 	    ACPI_ALL_NOTIFY, acpi_wmi_event_handler);
 	if (ACPI_FAILURE(rv)) {
 		aprint_debug_dev(sc->sc_dev, "failed to remove notify "
 		    "handler: %s\n", AcpiFormatException(rv));
-		return;
+		return rv;
+	}
 	SIMPLEQ_FOREACH(wmi, &sc->wmi_head, wmi_link) {
 		if (wmi->eevent != true)
 			continue;
 		KASSERT(wmi->guid.flags & ACPI_WMI_FLAG_EVENT);
 		KASSERT(wmi->guid.flags & ACPI_WMI_FLAG_EXPENSIVE);
 		rv = acpi_wmi_enable(sc->sc_node->ad_handle,
 		    wmi->guid.oid, false, false);
 		if (ACPI_SUCCESS(rv)) {
 			wmi->eevent = false;
 			continue;
+		}
 		aprint_error_dev(sc->sc_dev, "failed to disable "
 		    "expensive WExx: %s\n", AcpiFormatException(rv));
+	}
 	return AE_OK;
+}
 /*
  * Returns extra information possibly associated with an event.
  */
 ACPI_STATUS
 acpi_wmi_event_get(device_t self, uint32_t event, ACPI_BUFFER *obuf)
+{
 	struct acpi_wmi_softc *sc = device_private(self);
 	struct wmi_t *wmi;
 	ACPI_OBJECT_LIST arg;
 	ACPI_OBJECT obj;
 @@ -502,26 +525,29 @@ acpi_wmi_event_get(device_t self, uint32
+	}
 	return AE_NOT_FOUND;
+}
 /*
  * Forwards events to the external handler through the internal one.
  */
 static void
 acpi_wmi_event_handler(ACPI_HANDLE hdl, uint32_t evt, void *aux)
+{
 	struct acpi_wmi_softc *sc = aux;
 	if (sc->sc_child == NULL)
 		return;
 	if (sc->sc_handler == NULL)
 		return;
 	(*sc->sc_handler)(NULL, evt, sc->sc_child);
+}
 /*
  * Adds or removes (NULL) the external event handler.
  */
 ACPI_STATUS
 acpi_wmi_event_register(device_t self, ACPI_NOTIFY_HANDLER handler)
+{
 	struct acpi_wmi_softc *sc = device_private(self);