xref: /freebsd/sys/dev/acpica/acpi.c (revision 4c1cdee628e4dcd31d92ba03cca1cf8910ff7fb6)
115e32d5dSMike Smith /*-
215e32d5dSMike Smith  * Copyright (c) 2000 Takanori Watanabe <takawata@jp.freebsd.org>
315e32d5dSMike Smith  * Copyright (c) 2000 Mitsuru IWASAKI <iwasaki@jp.freebsd.org>
4cb9b0d80SMike Smith  * Copyright (c) 2000, 2001 Michael Smith
515e32d5dSMike Smith  * Copyright (c) 2000 BSDi
615e32d5dSMike Smith  * All rights reserved.
715e32d5dSMike Smith  *
815e32d5dSMike Smith  * Redistribution and use in source and binary forms, with or without
915e32d5dSMike Smith  * modification, are permitted provided that the following conditions
1015e32d5dSMike Smith  * are met:
1115e32d5dSMike Smith  * 1. Redistributions of source code must retain the above copyright
1215e32d5dSMike Smith  *    notice, this list of conditions and the following disclaimer.
1315e32d5dSMike Smith  * 2. Redistributions in binary form must reproduce the above copyright
1415e32d5dSMike Smith  *    notice, this list of conditions and the following disclaimer in the
1515e32d5dSMike Smith  *    documentation and/or other materials provided with the distribution.
1615e32d5dSMike Smith  *
1715e32d5dSMike Smith  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
1815e32d5dSMike Smith  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
1915e32d5dSMike Smith  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
2015e32d5dSMike Smith  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
2115e32d5dSMike Smith  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
2215e32d5dSMike Smith  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
2315e32d5dSMike Smith  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
2415e32d5dSMike Smith  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
2515e32d5dSMike Smith  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
2615e32d5dSMike Smith  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
2715e32d5dSMike Smith  * SUCH DAMAGE.
2815e32d5dSMike Smith  *
2915e32d5dSMike Smith  *	$FreeBSD$
3015e32d5dSMike Smith  */
3115e32d5dSMike Smith 
3215e32d5dSMike Smith #include "opt_acpi.h"
3315e32d5dSMike Smith #include <sys/param.h>
3415e32d5dSMike Smith #include <sys/kernel.h>
35fb919e4dSMark Murray #include <sys/proc.h>
36f34fa851SJohn Baldwin #include <sys/lock.h>
3715e32d5dSMike Smith #include <sys/malloc.h>
38b2c9c0daSMitsuru IWASAKI #include <sys/mutex.h>
3915e32d5dSMike Smith #include <sys/bus.h>
4015e32d5dSMike Smith #include <sys/conf.h>
4115e32d5dSMike Smith #include <sys/ioccom.h>
4215e32d5dSMike Smith #include <sys/reboot.h>
4315e32d5dSMike Smith #include <sys/sysctl.h>
4415e32d5dSMike Smith #include <sys/ctype.h>
4515e32d5dSMike Smith 
4615e32d5dSMike Smith #include <machine/clock.h>
4715e32d5dSMike Smith 
4815e32d5dSMike Smith #include <machine/resource.h>
4915e32d5dSMike Smith 
5015e32d5dSMike Smith #include "acpi.h"
5115e32d5dSMike Smith 
5215e32d5dSMike Smith #include <dev/acpica/acpivar.h>
5315e32d5dSMike Smith #include <dev/acpica/acpiio.h>
5415e32d5dSMike Smith 
5515e32d5dSMike Smith MALLOC_DEFINE(M_ACPIDEV, "acpidev", "ACPI devices");
5615e32d5dSMike Smith 
5715e32d5dSMike Smith /*
580ae55423SMike Smith  * Hooks for the ACPI CA debugging infrastructure
590ae55423SMike Smith  */
60cb9b0d80SMike Smith #define _COMPONENT	ACPI_BUS
610ae55423SMike Smith MODULE_NAME("ACPI")
620ae55423SMike Smith 
630ae55423SMike Smith /*
6415e32d5dSMike Smith  * Character device
6515e32d5dSMike Smith  */
6615e32d5dSMike Smith 
6715e32d5dSMike Smith static d_open_t		acpiopen;
6815e32d5dSMike Smith static d_close_t	acpiclose;
6915e32d5dSMike Smith static d_ioctl_t	acpiioctl;
7015e32d5dSMike Smith 
7115e32d5dSMike Smith #define CDEV_MAJOR 152
7215e32d5dSMike Smith static struct cdevsw acpi_cdevsw = {
7315e32d5dSMike Smith     acpiopen,
7415e32d5dSMike Smith     acpiclose,
7515e32d5dSMike Smith     noread,
7615e32d5dSMike Smith     nowrite,
7715e32d5dSMike Smith     acpiioctl,
7815e32d5dSMike Smith     nopoll,
7915e32d5dSMike Smith     nommap,
8015e32d5dSMike Smith     nostrategy,
8115e32d5dSMike Smith     "acpi",
8215e32d5dSMike Smith     CDEV_MAJOR,
8315e32d5dSMike Smith     nodump,
8415e32d5dSMike Smith     nopsize,
85606e1d68SJohn Baldwin     0
8615e32d5dSMike Smith };
8715e32d5dSMike Smith 
881d073b1dSJohn Baldwin static const char* sleep_state_names[] = {
89a5d1879bSMitsuru IWASAKI     "S0", "S1", "S2", "S3", "S4", "S5", "S4B" };
901d073b1dSJohn Baldwin 
912a4ac806SMike Smith /* this has to be static, as the softc is gone when we need it */
922a4ac806SMike Smith static int acpi_off_state = ACPI_STATE_S5;
932a4ac806SMike Smith 
94cb9b0d80SMike Smith struct mtx	acpi_mutex;
95cb9b0d80SMike Smith 
966d63101aSMike Smith static int	acpi_modevent(struct module *mod, int event, void *junk);
9715e32d5dSMike Smith static void	acpi_identify(driver_t *driver, device_t parent);
9815e32d5dSMike Smith static int	acpi_probe(device_t dev);
9915e32d5dSMike Smith static int	acpi_attach(device_t dev);
10015e32d5dSMike Smith static device_t	acpi_add_child(device_t bus, int order, const char *name, int unit);
10115e32d5dSMike Smith static int	acpi_print_resources(struct resource_list *rl, const char *name, int type,
10215e32d5dSMike Smith 				     const char *format);
10315e32d5dSMike Smith static int	acpi_print_child(device_t bus, device_t child);
10415e32d5dSMike Smith static int	acpi_read_ivar(device_t dev, device_t child, int index, uintptr_t *result);
10515e32d5dSMike Smith static int	acpi_write_ivar(device_t dev, device_t child, int index, uintptr_t value);
10615e32d5dSMike Smith static int	acpi_set_resource(device_t dev, device_t child, int type, int rid, u_long start,
10715e32d5dSMike Smith 				  u_long count);
10815e32d5dSMike Smith static int	acpi_get_resource(device_t dev, device_t child, int type, int rid, u_long *startp,
10915e32d5dSMike Smith 				  u_long *countp);
11015e32d5dSMike Smith static struct resource *acpi_alloc_resource(device_t bus, device_t child, int type, int *rid,
11115e32d5dSMike Smith 					    u_long start, u_long end, u_long count, u_int flags);
11215e32d5dSMike Smith static int	acpi_release_resource(device_t bus, device_t child, int type, int rid, struct resource *r);
11315e32d5dSMike Smith 
11415e32d5dSMike Smith static void	acpi_probe_children(device_t bus);
11515e32d5dSMike Smith static ACPI_STATUS acpi_probe_child(ACPI_HANDLE handle, UINT32 level, void *context, void **status);
11615e32d5dSMike Smith 
11715e32d5dSMike Smith static void	acpi_shutdown_pre_sync(void *arg, int howto);
11815e32d5dSMike Smith static void	acpi_shutdown_final(void *arg, int howto);
11915e32d5dSMike Smith 
12013d4f7baSMitsuru IWASAKI static void	acpi_enable_fixed_events(struct acpi_softc *sc);
12113d4f7baSMitsuru IWASAKI 
12215e32d5dSMike Smith static void	acpi_system_eventhandler_sleep(void *arg, int state);
12315e32d5dSMike Smith static void	acpi_system_eventhandler_wakeup(void *arg, int state);
1241d073b1dSJohn Baldwin static int	acpi_sleep_state_sysctl(SYSCTL_HANDLER_ARGS);
12515e32d5dSMike Smith 
12615e32d5dSMike Smith static device_method_t acpi_methods[] = {
12715e32d5dSMike Smith     /* Device interface */
12815e32d5dSMike Smith     DEVMETHOD(device_identify,		acpi_identify),
12915e32d5dSMike Smith     DEVMETHOD(device_probe,		acpi_probe),
13015e32d5dSMike Smith     DEVMETHOD(device_attach,		acpi_attach),
13115e32d5dSMike Smith     DEVMETHOD(device_shutdown,		bus_generic_shutdown),
13215e32d5dSMike Smith     DEVMETHOD(device_suspend,		bus_generic_suspend),
13315e32d5dSMike Smith     DEVMETHOD(device_resume,		bus_generic_resume),
13415e32d5dSMike Smith 
13515e32d5dSMike Smith     /* Bus interface */
13615e32d5dSMike Smith     DEVMETHOD(bus_add_child,		acpi_add_child),
13715e32d5dSMike Smith     DEVMETHOD(bus_print_child,		acpi_print_child),
13815e32d5dSMike Smith     DEVMETHOD(bus_read_ivar,		acpi_read_ivar),
13915e32d5dSMike Smith     DEVMETHOD(bus_write_ivar,		acpi_write_ivar),
14015e32d5dSMike Smith     DEVMETHOD(bus_set_resource,		acpi_set_resource),
14115e32d5dSMike Smith     DEVMETHOD(bus_get_resource,		acpi_get_resource),
14215e32d5dSMike Smith     DEVMETHOD(bus_alloc_resource,	acpi_alloc_resource),
14315e32d5dSMike Smith     DEVMETHOD(bus_release_resource,	acpi_release_resource),
14415e32d5dSMike Smith     DEVMETHOD(bus_driver_added,		bus_generic_driver_added),
14515e32d5dSMike Smith     DEVMETHOD(bus_activate_resource,	bus_generic_activate_resource),
14615e32d5dSMike Smith     DEVMETHOD(bus_deactivate_resource,	bus_generic_deactivate_resource),
14715e32d5dSMike Smith     DEVMETHOD(bus_setup_intr,		bus_generic_setup_intr),
14815e32d5dSMike Smith     DEVMETHOD(bus_teardown_intr,	bus_generic_teardown_intr),
14915e32d5dSMike Smith 
15015e32d5dSMike Smith     {0, 0}
15115e32d5dSMike Smith };
15215e32d5dSMike Smith 
15315e32d5dSMike Smith static driver_t acpi_driver = {
15415e32d5dSMike Smith     "acpi",
15515e32d5dSMike Smith     acpi_methods,
15615e32d5dSMike Smith     sizeof(struct acpi_softc),
15715e32d5dSMike Smith };
15815e32d5dSMike Smith 
15915e32d5dSMike Smith devclass_t acpi_devclass;
1606d63101aSMike Smith DRIVER_MODULE(acpi, nexus, acpi_driver, acpi_devclass, acpi_modevent, 0);
16115e32d5dSMike Smith 
16215e32d5dSMike Smith SYSCTL_INT(_debug, OID_AUTO, acpi_debug_layer, CTLFLAG_RW, &AcpiDbgLayer, 0, "");
16315e32d5dSMike Smith SYSCTL_INT(_debug, OID_AUTO, acpi_debug_level, CTLFLAG_RW, &AcpiDbgLevel, 0, "");
16415e32d5dSMike Smith 
16515e32d5dSMike Smith /*
1666d63101aSMike Smith  * ACPI can only be loaded as a module by the loader; activating it after
1676d63101aSMike Smith  * system bootstrap time is not useful, and can be fatal to the system.
1686d63101aSMike Smith  * It also cannot be unloaded, since the entire system bus heirarchy hangs off it.
1696d63101aSMike Smith  */
1706d63101aSMike Smith static int
1716d63101aSMike Smith acpi_modevent(struct module *mod, int event, void *junk)
1726d63101aSMike Smith {
1736d63101aSMike Smith     switch(event) {
1746d63101aSMike Smith     case MOD_LOAD:
1756d63101aSMike Smith 	if (!cold)
1766d63101aSMike Smith 	    return(EPERM);
1776d63101aSMike Smith 	break;
1786d63101aSMike Smith     case MOD_UNLOAD:
1796d63101aSMike Smith 	return(EBUSY);
1806d63101aSMike Smith     default:
1816d63101aSMike Smith 	break;
1826d63101aSMike Smith     }
1836d63101aSMike Smith     return(0);
1846d63101aSMike Smith }
1856d63101aSMike Smith 
1866d63101aSMike Smith /*
18715e32d5dSMike Smith  * Detect ACPI, perform early initialisation
18815e32d5dSMike Smith  */
18915e32d5dSMike Smith static void
19015e32d5dSMike Smith acpi_identify(driver_t *driver, device_t parent)
19115e32d5dSMike Smith {
19215e32d5dSMike Smith     device_t			child;
19315e32d5dSMike Smith     int				error;
19415e32d5dSMike Smith #ifdef ENABLE_DEBUGGER
19515e32d5dSMike Smith     char			*debugpoint = getenv("debug.acpi.debugger");
19615e32d5dSMike Smith #endif
19715e32d5dSMike Smith 
1982a4ac806SMike Smith     FUNCTION_TRACE(__func__);
1990ae55423SMike Smith 
200840f9b53STakanori Watanabe     if(!cold){
201840f9b53STakanori Watanabe 	    printf("Don't load this driver from userland!!\n");
202840f9b53STakanori Watanabe 	    return ;
203840f9b53STakanori Watanabe     }
204840f9b53STakanori Watanabe 
20515e32d5dSMike Smith     /*
20615e32d5dSMike Smith      * Make sure we're not being doubly invoked.
20715e32d5dSMike Smith      */
20815e32d5dSMike Smith     if (device_find_child(parent, "acpi", 0) != NULL)
2090ae55423SMike Smith 	return_VOID;
21015e32d5dSMike Smith 
211cb9b0d80SMike Smith     /* initialise the ACPI mutex */
212cb9b0d80SMike Smith     mtx_init(&acpi_mutex, "ACPI global lock", MTX_DEF);
213cb9b0d80SMike Smith 
21415e32d5dSMike Smith     /*
2152a4ac806SMike Smith      * Start up the ACPI CA subsystem.
21615e32d5dSMike Smith      */
21715e32d5dSMike Smith #ifdef ENABLE_DEBUGGER
21815e32d5dSMike Smith     if (debugpoint && !strcmp(debugpoint, "init"))
21915e32d5dSMike Smith 	acpi_EnterDebugger();
22015e32d5dSMike Smith #endif
22115e32d5dSMike Smith     if ((error = AcpiInitializeSubsystem()) != AE_OK) {
222bfae45aaSMike Smith 	printf("ACPI: initialisation failed: %s\n", AcpiFormatException(error));
2230ae55423SMike Smith 	return_VOID;
22415e32d5dSMike Smith     }
22515e32d5dSMike Smith #ifdef ENABLE_DEBUGGER
22615e32d5dSMike Smith     if (debugpoint && !strcmp(debugpoint, "tables"))
22715e32d5dSMike Smith 	acpi_EnterDebugger();
22815e32d5dSMike Smith #endif
229acf72ef4SMike Smith     if ((error = AcpiLoadTables()) != AE_OK) {
230bfae45aaSMike Smith 	printf("ACPI: table load failed: %s\n", AcpiFormatException(error));
2310ae55423SMike Smith 	return_VOID;
23215e32d5dSMike Smith     }
23315e32d5dSMike Smith 
23415e32d5dSMike Smith     /*
23515e32d5dSMike Smith      * Attach the actual ACPI device.
23615e32d5dSMike Smith      */
23715e32d5dSMike Smith     if ((child = BUS_ADD_CHILD(parent, 0, "acpi", 0)) == NULL) {
23815e32d5dSMike Smith 	    device_printf(parent, "ACPI: could not attach\n");
2390ae55423SMike Smith 	    return_VOID;
24015e32d5dSMike Smith     }
24115e32d5dSMike Smith }
24215e32d5dSMike Smith 
24315e32d5dSMike Smith /*
24415e32d5dSMike Smith  * Fetch some descriptive data from ACPI to put in our attach message
24515e32d5dSMike Smith  */
24615e32d5dSMike Smith static int
24715e32d5dSMike Smith acpi_probe(device_t dev)
24815e32d5dSMike Smith {
24915e32d5dSMike Smith     ACPI_TABLE_HEADER	th;
25015e32d5dSMike Smith     char		buf[20];
251cb9b0d80SMike Smith     ACPI_STATUS		status;
25215e32d5dSMike Smith     int			error;
25315e32d5dSMike Smith 
2542a4ac806SMike Smith     FUNCTION_TRACE(__func__);
255cb9b0d80SMike Smith     ACPI_LOCK;
2560ae55423SMike Smith 
257cb9b0d80SMike Smith     if ((status = AcpiGetTableHeader(ACPI_TABLE_XSDT, 1, &th)) != AE_OK) {
258bfae45aaSMike Smith 	device_printf(dev, "couldn't get XSDT header: %s\n", AcpiFormatException(status));
259cb9b0d80SMike Smith 	error = ENXIO;
260cb9b0d80SMike Smith     } else {
26115e32d5dSMike Smith 	sprintf(buf, "%.6s %.8s", th.OemId, th.OemTableId);
26215e32d5dSMike Smith 	device_set_desc_copy(dev, buf);
263cb9b0d80SMike Smith 	error = 0;
264cb9b0d80SMike Smith     }
265cb9b0d80SMike Smith     ACPI_UNLOCK;
266cb9b0d80SMike Smith     return_VALUE(error);
26715e32d5dSMike Smith }
26815e32d5dSMike Smith 
26915e32d5dSMike Smith static int
27015e32d5dSMike Smith acpi_attach(device_t dev)
27115e32d5dSMike Smith {
27215e32d5dSMike Smith     struct acpi_softc	*sc;
273cb9b0d80SMike Smith     ACPI_STATUS		status;
27415e32d5dSMike Smith     int			error;
27515e32d5dSMike Smith #ifdef ENABLE_DEBUGGER
27615e32d5dSMike Smith     char		*debugpoint = getenv("debug.acpi.debugger");
27715e32d5dSMike Smith #endif
27815e32d5dSMike Smith 
2792a4ac806SMike Smith     FUNCTION_TRACE(__func__);
280cb9b0d80SMike Smith     ACPI_LOCK;
28115e32d5dSMike Smith     sc = device_get_softc(dev);
28215e32d5dSMike Smith     bzero(sc, sizeof(*sc));
28315e32d5dSMike Smith     sc->acpi_dev = dev;
28415e32d5dSMike Smith 
2856161544cSTakanori Watanabe     acpi_install_wakeup_handler(sc);
2866161544cSTakanori Watanabe 
28715e32d5dSMike Smith #ifdef ENABLE_DEBUGGER
28815e32d5dSMike Smith     if (debugpoint && !strcmp(debugpoint, "spaces"))
28915e32d5dSMike Smith 	acpi_EnterDebugger();
29015e32d5dSMike Smith #endif
29115e32d5dSMike Smith 
29215e32d5dSMike Smith     /*
29315e32d5dSMike Smith      * Install the default address space handlers.
29415e32d5dSMike Smith      */
295cb9b0d80SMike Smith     error = ENXIO;
296cb9b0d80SMike Smith     if ((status = AcpiInstallAddressSpaceHandler(ACPI_ROOT_OBJECT,
2972a4ac806SMike Smith 						ACPI_ADR_SPACE_SYSTEM_MEMORY,
29815e32d5dSMike Smith 						ACPI_DEFAULT_HANDLER,
29915e32d5dSMike Smith 						NULL, NULL)) != AE_OK) {
300bfae45aaSMike Smith 	device_printf(dev, "could not initialise SystemMemory handler: %s\n", AcpiFormatException(status));
301cb9b0d80SMike Smith 	goto out;
30215e32d5dSMike Smith     }
303cb9b0d80SMike Smith     if ((status = AcpiInstallAddressSpaceHandler(ACPI_ROOT_OBJECT,
3042a4ac806SMike Smith 						ACPI_ADR_SPACE_SYSTEM_IO,
30515e32d5dSMike Smith 						ACPI_DEFAULT_HANDLER,
30615e32d5dSMike Smith 						NULL, NULL)) != AE_OK) {
307bfae45aaSMike Smith 	device_printf(dev, "could not initialise SystemIO handler: %s\n", AcpiFormatException(status));
308cb9b0d80SMike Smith 	goto out;
30915e32d5dSMike Smith     }
310cb9b0d80SMike Smith     if ((status = AcpiInstallAddressSpaceHandler(ACPI_ROOT_OBJECT,
3112a4ac806SMike Smith 						ACPI_ADR_SPACE_PCI_CONFIG,
31215e32d5dSMike Smith 						ACPI_DEFAULT_HANDLER,
31315e32d5dSMike Smith 						NULL, NULL)) != AE_OK) {
314bfae45aaSMike Smith 	device_printf(dev, "could not initialise PciConfig handler: %s\n", AcpiFormatException(status));
315cb9b0d80SMike Smith 	goto out;
31615e32d5dSMike Smith     }
31715e32d5dSMike Smith 
31815e32d5dSMike Smith     /*
31915e32d5dSMike Smith      * Bring ACPI fully online.
32015e32d5dSMike Smith      *
32115e32d5dSMike Smith      * Note that we request that device _STA and _INI methods not be run (ACPI_NO_DEVICE_INIT)
32215e32d5dSMike Smith      * and the final object initialisation pass be skipped (ACPI_NO_OBJECT_INIT).
32315e32d5dSMike Smith      *
32415e32d5dSMike Smith      * XXX We need to arrange for the object init pass after we have attached all our
32515e32d5dSMike Smith      *     child devices.
32615e32d5dSMike Smith      */
32715e32d5dSMike Smith #ifdef ENABLE_DEBUGGER
32815e32d5dSMike Smith     if (debugpoint && !strcmp(debugpoint, "enable"))
32915e32d5dSMike Smith 	acpi_EnterDebugger();
33015e32d5dSMike Smith #endif
331cb9b0d80SMike Smith     if ((status = AcpiEnableSubsystem(ACPI_NO_DEVICE_INIT | ACPI_NO_OBJECT_INIT)) != AE_OK) {
332bfae45aaSMike Smith 	device_printf(dev, "could not enable ACPI: %s\n", AcpiFormatException(status));
333cb9b0d80SMike Smith 	goto out;
33415e32d5dSMike Smith     }
33515e32d5dSMike Smith 
33615e32d5dSMike Smith     /*
3371d073b1dSJohn Baldwin      * Setup our sysctl tree.
3381d073b1dSJohn Baldwin      *
3391d073b1dSJohn Baldwin      * XXX: This doesn't check to make sure that none of these fail.
3401d073b1dSJohn Baldwin      */
3411d073b1dSJohn Baldwin     sysctl_ctx_init(&sc->acpi_sysctl_ctx);
3421d073b1dSJohn Baldwin     sc->acpi_sysctl_tree = SYSCTL_ADD_NODE(&sc->acpi_sysctl_ctx,
3431d073b1dSJohn Baldwin 			       SYSCTL_STATIC_CHILDREN(_hw), OID_AUTO,
3441d073b1dSJohn Baldwin 			       device_get_name(dev), CTLFLAG_RD, 0, "");
3451d073b1dSJohn Baldwin     SYSCTL_ADD_PROC(&sc->acpi_sysctl_ctx, SYSCTL_CHILDREN(sc->acpi_sysctl_tree),
3461d073b1dSJohn Baldwin 	OID_AUTO, "power_button_state", CTLTYPE_STRING | CTLFLAG_RW,
3471d073b1dSJohn Baldwin 	&sc->acpi_power_button_sx, 0, acpi_sleep_state_sysctl, "A", "");
3481d073b1dSJohn Baldwin     SYSCTL_ADD_PROC(&sc->acpi_sysctl_ctx, SYSCTL_CHILDREN(sc->acpi_sysctl_tree),
3491d073b1dSJohn Baldwin 	OID_AUTO, "sleep_button_state", CTLTYPE_STRING | CTLFLAG_RW,
3501d073b1dSJohn Baldwin 	&sc->acpi_sleep_button_sx, 0, acpi_sleep_state_sysctl, "A", "");
3511d073b1dSJohn Baldwin     SYSCTL_ADD_PROC(&sc->acpi_sysctl_ctx, SYSCTL_CHILDREN(sc->acpi_sysctl_tree),
3521d073b1dSJohn Baldwin 	OID_AUTO, "lid_switch_state", CTLTYPE_STRING | CTLFLAG_RW,
3531d073b1dSJohn Baldwin 	&sc->acpi_lid_switch_sx, 0, acpi_sleep_state_sysctl, "A", "");
3541d073b1dSJohn Baldwin 
3551d073b1dSJohn Baldwin     /*
35615e32d5dSMike Smith      * Dispatch the default sleep state to devices.
35715e32d5dSMike Smith      * TBD: should be configured from userland policy manager.
35815e32d5dSMike Smith      */
35915e32d5dSMike Smith     sc->acpi_power_button_sx = ACPI_POWER_BUTTON_DEFAULT_SX;
36015e32d5dSMike Smith     sc->acpi_sleep_button_sx = ACPI_SLEEP_BUTTON_DEFAULT_SX;
36115e32d5dSMike Smith     sc->acpi_lid_switch_sx = ACPI_LID_SWITCH_DEFAULT_SX;
36215e32d5dSMike Smith 
36313d4f7baSMitsuru IWASAKI     acpi_enable_fixed_events(sc);
36415e32d5dSMike Smith 
36515e32d5dSMike Smith     /*
36615e32d5dSMike Smith      * Scan the namespace and attach/initialise children.
36715e32d5dSMike Smith      */
36815e32d5dSMike Smith #ifdef ENABLE_DEBUGGER
36915e32d5dSMike Smith     if (debugpoint && !strcmp(debugpoint, "probe"))
37015e32d5dSMike Smith 	acpi_EnterDebugger();
37115e32d5dSMike Smith #endif
3720ae55423SMike Smith     if (!acpi_disabled("bus"))
37315e32d5dSMike Smith 	acpi_probe_children(dev);
37415e32d5dSMike Smith 
37515e32d5dSMike Smith     /*
37615e32d5dSMike Smith      * Register our shutdown handlers
37715e32d5dSMike Smith      */
37815e32d5dSMike Smith     EVENTHANDLER_REGISTER(shutdown_pre_sync, acpi_shutdown_pre_sync, sc, SHUTDOWN_PRI_LAST);
37915e32d5dSMike Smith     EVENTHANDLER_REGISTER(shutdown_final, acpi_shutdown_final, sc, SHUTDOWN_PRI_LAST);
38015e32d5dSMike Smith 
38115e32d5dSMike Smith     /*
38215e32d5dSMike Smith      * Register our acpi event handlers.
38315e32d5dSMike Smith      * XXX should be configurable eg. via userland policy manager.
38415e32d5dSMike Smith      */
38515e32d5dSMike Smith     EVENTHANDLER_REGISTER(acpi_sleep_event, acpi_system_eventhandler_sleep, sc, ACPI_EVENT_PRI_LAST);
38615e32d5dSMike Smith     EVENTHANDLER_REGISTER(acpi_wakeup_event, acpi_system_eventhandler_wakeup, sc, ACPI_EVENT_PRI_LAST);
38715e32d5dSMike Smith 
38815e32d5dSMike Smith     /*
38915e32d5dSMike Smith      * Flag our initial states.
39015e32d5dSMike Smith      */
39115e32d5dSMike Smith     sc->acpi_enabled = 1;
39215e32d5dSMike Smith     sc->acpi_sstate = ACPI_STATE_S0;
39315e32d5dSMike Smith 
39415e32d5dSMike Smith     /*
39515e32d5dSMike Smith      * Create the control device
39615e32d5dSMike Smith      */
39715e32d5dSMike Smith     sc->acpi_dev_t = make_dev(&acpi_cdevsw, 0, 0, 5, 0660, "acpi");
39815e32d5dSMike Smith     sc->acpi_dev_t->si_drv1 = sc;
39915e32d5dSMike Smith 
40015e32d5dSMike Smith #ifdef ENABLE_DEBUGGER
40115e32d5dSMike Smith     if (debugpoint && !strcmp(debugpoint, "running"))
40215e32d5dSMike Smith 	acpi_EnterDebugger();
40315e32d5dSMike Smith #endif
404cb9b0d80SMike Smith     error = 0;
405cb9b0d80SMike Smith 
406cb9b0d80SMike Smith  out:
407cb9b0d80SMike Smith     ACPI_UNLOCK;
408cb9b0d80SMike Smith     return_VALUE(error);
40915e32d5dSMike Smith }
41015e32d5dSMike Smith 
41115e32d5dSMike Smith /*
41215e32d5dSMike Smith  * Handle a new device being added
41315e32d5dSMike Smith  */
41415e32d5dSMike Smith static device_t
41515e32d5dSMike Smith acpi_add_child(device_t bus, int order, const char *name, int unit)
41615e32d5dSMike Smith {
41715e32d5dSMike Smith     struct acpi_device	*ad;
41815e32d5dSMike Smith     device_t		child;
41915e32d5dSMike Smith 
42015e32d5dSMike Smith     if ((ad = malloc(sizeof(*ad), M_ACPIDEV, M_NOWAIT)) == NULL)
42115e32d5dSMike Smith 	return(NULL);
42215e32d5dSMike Smith     bzero(ad, sizeof(*ad));
42315e32d5dSMike Smith 
42415e32d5dSMike Smith     resource_list_init(&ad->ad_rl);
42515e32d5dSMike Smith 
42615e32d5dSMike Smith     child = device_add_child_ordered(bus, order, name, unit);
42715e32d5dSMike Smith     if (child != NULL)
42815e32d5dSMike Smith 	device_set_ivars(child, ad);
42915e32d5dSMike Smith     return(child);
43015e32d5dSMike Smith }
43115e32d5dSMike Smith 
43215e32d5dSMike Smith /*
43315e32d5dSMike Smith  * Print child device resource usage
43415e32d5dSMike Smith  */
43515e32d5dSMike Smith static int
43615e32d5dSMike Smith acpi_print_resources(struct resource_list *rl, const char *name, int type, const char *format)
43715e32d5dSMike Smith {
43815e32d5dSMike Smith     struct resource_list_entry	*rle;
43915e32d5dSMike Smith     int				printed, retval;
44015e32d5dSMike Smith 
44115e32d5dSMike Smith     printed = 0;
44215e32d5dSMike Smith     retval = 0;
44315e32d5dSMike Smith 
44415e32d5dSMike Smith     if (!SLIST_FIRST(rl))
44515e32d5dSMike Smith 	return(0);
44615e32d5dSMike Smith 
44715e32d5dSMike Smith     /* Yes, this is kinda cheating */
44815e32d5dSMike Smith     SLIST_FOREACH(rle, rl, link) {
44915e32d5dSMike Smith 	if (rle->type == type) {
45015e32d5dSMike Smith 	    if (printed == 0)
45115e32d5dSMike Smith 		retval += printf(" %s ", name);
45215e32d5dSMike Smith 	    else if (printed > 0)
45315e32d5dSMike Smith 		retval += printf(",");
45415e32d5dSMike Smith 	    printed++;
45515e32d5dSMike Smith 	    retval += printf(format, rle->start);
45615e32d5dSMike Smith 	    if (rle->count > 1) {
45715e32d5dSMike Smith 		retval += printf("-");
45815e32d5dSMike Smith 		retval += printf(format, rle->start +
45915e32d5dSMike Smith 				 rle->count - 1);
46015e32d5dSMike Smith 	    }
46115e32d5dSMike Smith 	}
46215e32d5dSMike Smith     }
46315e32d5dSMike Smith     return(retval);
46415e32d5dSMike Smith }
46515e32d5dSMike Smith 
46615e32d5dSMike Smith static int
46715e32d5dSMike Smith acpi_print_child(device_t bus, device_t child)
46815e32d5dSMike Smith {
46915e32d5dSMike Smith     struct acpi_device		*adev = device_get_ivars(child);
47015e32d5dSMike Smith     struct resource_list	*rl = &adev->ad_rl;
47115e32d5dSMike Smith     int retval = 0;
47215e32d5dSMike Smith 
47315e32d5dSMike Smith     retval += bus_print_child_header(bus, child);
47415e32d5dSMike Smith     retval += acpi_print_resources(rl, "port",  SYS_RES_IOPORT, "%#lx");
47515e32d5dSMike Smith     retval += acpi_print_resources(rl, "iomem", SYS_RES_MEMORY, "%#lx");
47615e32d5dSMike Smith     retval += acpi_print_resources(rl, "irq",   SYS_RES_IRQ,    "%ld");
47715e32d5dSMike Smith     retval += bus_print_child_footer(bus, child);
47815e32d5dSMike Smith 
47915e32d5dSMike Smith     return(retval);
48015e32d5dSMike Smith }
48115e32d5dSMike Smith 
48215e32d5dSMike Smith 
48315e32d5dSMike Smith /*
48415e32d5dSMike Smith  * Handle per-device ivars
48515e32d5dSMike Smith  */
48615e32d5dSMike Smith static int
48715e32d5dSMike Smith acpi_read_ivar(device_t dev, device_t child, int index, uintptr_t *result)
48815e32d5dSMike Smith {
48915e32d5dSMike Smith     struct acpi_device	*ad;
49015e32d5dSMike Smith 
49115e32d5dSMike Smith     if ((ad = device_get_ivars(child)) == NULL) {
49215e32d5dSMike Smith 	printf("device has no ivars\n");
49315e32d5dSMike Smith 	return(ENOENT);
49415e32d5dSMike Smith     }
49515e32d5dSMike Smith 
49615e32d5dSMike Smith     switch(index) {
49715e32d5dSMike Smith 	/* ACPI ivars */
49815e32d5dSMike Smith     case ACPI_IVAR_HANDLE:
49915e32d5dSMike Smith 	*(ACPI_HANDLE *)result = ad->ad_handle;
50015e32d5dSMike Smith 	break;
50115e32d5dSMike Smith     case ACPI_IVAR_MAGIC:
50215e32d5dSMike Smith 	*(int *)result = ad->ad_magic;
50315e32d5dSMike Smith 	break;
50415e32d5dSMike Smith     case ACPI_IVAR_PRIVATE:
50515e32d5dSMike Smith 	*(void **)result = ad->ad_private;
50615e32d5dSMike Smith 	break;
50715e32d5dSMike Smith 
50815e32d5dSMike Smith     default:
50915e32d5dSMike Smith 	panic("bad ivar read request (%d)\n", index);
51015e32d5dSMike Smith 	return(ENOENT);
51115e32d5dSMike Smith     }
51215e32d5dSMike Smith     return(0);
51315e32d5dSMike Smith }
51415e32d5dSMike Smith 
51515e32d5dSMike Smith static int
51615e32d5dSMike Smith acpi_write_ivar(device_t dev, device_t child, int index, uintptr_t value)
51715e32d5dSMike Smith {
51815e32d5dSMike Smith     struct acpi_device	*ad;
51915e32d5dSMike Smith 
52015e32d5dSMike Smith     if ((ad = device_get_ivars(child)) == NULL) {
52115e32d5dSMike Smith 	printf("device has no ivars\n");
52215e32d5dSMike Smith 	return(ENOENT);
52315e32d5dSMike Smith     }
52415e32d5dSMike Smith 
52515e32d5dSMike Smith     switch(index) {
52615e32d5dSMike Smith 	/* ACPI ivars */
52715e32d5dSMike Smith     case ACPI_IVAR_HANDLE:
52815e32d5dSMike Smith 	ad->ad_handle = (ACPI_HANDLE)value;
52915e32d5dSMike Smith 	break;
53015e32d5dSMike Smith     case ACPI_IVAR_MAGIC:
53115e32d5dSMike Smith 	ad->ad_magic = (int )value;
53215e32d5dSMike Smith 	break;
53315e32d5dSMike Smith     case ACPI_IVAR_PRIVATE:
53415e32d5dSMike Smith 	ad->ad_private = (void *)value;
53515e32d5dSMike Smith 	break;
53615e32d5dSMike Smith 
53715e32d5dSMike Smith     default:
53815e32d5dSMike Smith 	panic("bad ivar write request (%d)\n", index);
53915e32d5dSMike Smith 	return(ENOENT);
54015e32d5dSMike Smith     }
54115e32d5dSMike Smith     return(0);
54215e32d5dSMike Smith }
54315e32d5dSMike Smith 
54415e32d5dSMike Smith /*
54515e32d5dSMike Smith  * Handle child resource allocation/removal
54615e32d5dSMike Smith  */
54715e32d5dSMike Smith static int
54815e32d5dSMike Smith acpi_set_resource(device_t dev, device_t child, int type, int rid, u_long start, u_long count)
54915e32d5dSMike Smith {
55015e32d5dSMike Smith     struct acpi_device		*ad = device_get_ivars(child);
55115e32d5dSMike Smith     struct resource_list	*rl = &ad->ad_rl;
55215e32d5dSMike Smith 
55315e32d5dSMike Smith     resource_list_add(rl, type, rid, start, start + count -1, count);
55415e32d5dSMike Smith 
55515e32d5dSMike Smith     return(0);
55615e32d5dSMike Smith }
55715e32d5dSMike Smith 
55815e32d5dSMike Smith static int
55915e32d5dSMike Smith acpi_get_resource(device_t dev, device_t child, int type, int rid, u_long *startp, u_long *countp)
56015e32d5dSMike Smith {
56115e32d5dSMike Smith     struct acpi_device		*ad = device_get_ivars(child);
56215e32d5dSMike Smith     struct resource_list	*rl = &ad->ad_rl;
56315e32d5dSMike Smith     struct resource_list_entry	*rle;
56415e32d5dSMike Smith 
56515e32d5dSMike Smith     rle = resource_list_find(rl, type, rid);
56615e32d5dSMike Smith     if (!rle)
56715e32d5dSMike Smith 	return(ENOENT);
56815e32d5dSMike Smith 
56915e32d5dSMike Smith     if (startp)
57015e32d5dSMike Smith 	*startp = rle->start;
57115e32d5dSMike Smith     if (countp)
57215e32d5dSMike Smith 	*countp = rle->count;
57315e32d5dSMike Smith 
57415e32d5dSMike Smith     return(0);
57515e32d5dSMike Smith }
57615e32d5dSMike Smith 
57715e32d5dSMike Smith static struct resource *
57815e32d5dSMike Smith acpi_alloc_resource(device_t bus, device_t child, int type, int *rid,
57915e32d5dSMike Smith 		    u_long start, u_long end, u_long count, u_int flags)
58015e32d5dSMike Smith {
58115e32d5dSMike Smith     struct acpi_device *ad = device_get_ivars(child);
58215e32d5dSMike Smith     struct resource_list *rl = &ad->ad_rl;
58315e32d5dSMike Smith 
58415e32d5dSMike Smith     return(resource_list_alloc(rl, bus, child, type, rid, start, end, count, flags));
58515e32d5dSMike Smith }
58615e32d5dSMike Smith 
58715e32d5dSMike Smith static int
58815e32d5dSMike Smith acpi_release_resource(device_t bus, device_t child, int type, int rid, struct resource *r)
58915e32d5dSMike Smith {
59015e32d5dSMike Smith     struct acpi_device *ad = device_get_ivars(child);
59115e32d5dSMike Smith     struct resource_list *rl = &ad->ad_rl;
59215e32d5dSMike Smith 
59315e32d5dSMike Smith     return(resource_list_release(rl, bus, child, type, rid, r));
59415e32d5dSMike Smith }
59515e32d5dSMike Smith 
59615e32d5dSMike Smith /*
59715e32d5dSMike Smith  * Scan relevant portions of the ACPI namespace and attach child devices.
59815e32d5dSMike Smith  *
5997d3bcec9SMike Smith  * Note that we only expect to find devices in the \_PR_, \_TZ_, \_SI_ and \_SB_ scopes,
6007d3bcec9SMike Smith  * and \_PR_ and \_TZ_ become obsolete in the ACPI 2.0 spec.
60115e32d5dSMike Smith  */
60215e32d5dSMike Smith static void
60315e32d5dSMike Smith acpi_probe_children(device_t bus)
60415e32d5dSMike Smith {
60515e32d5dSMike Smith     ACPI_HANDLE		parent;
6067d3bcec9SMike Smith     static char		*scopes[] = {"\\_PR_", "\\_TZ_", "\\_SI", "\\_SB_", NULL};
60715e32d5dSMike Smith     int			i;
60815e32d5dSMike Smith 
6092a4ac806SMike Smith     FUNCTION_TRACE(__func__);
610cb9b0d80SMike Smith     ACPI_ASSERTLOCK;
6110ae55423SMike Smith 
61215e32d5dSMike Smith     /*
61315e32d5dSMike Smith      * Create any static children by calling device identify methods.
61415e32d5dSMike Smith      */
6154c1cdee6SMike Smith     ACPI_DEBUG_PRINT((ACPI_DB_OBJECTS, "device identify routines\n"));
61615e32d5dSMike Smith     bus_generic_probe(bus);
61715e32d5dSMike Smith 
61815e32d5dSMike Smith     /*
61915e32d5dSMike Smith      * Scan the namespace and insert placeholders for all the devices that
62015e32d5dSMike Smith      * we find.
62115e32d5dSMike Smith      *
62215e32d5dSMike Smith      * Note that we use AcpiWalkNamespace rather than AcpiGetDevices because
62315e32d5dSMike Smith      * we want to create nodes for all devices, not just those that are currently
62415e32d5dSMike Smith      * present. (This assumes that we don't want to create/remove devices as they
62515e32d5dSMike Smith      * appear, which might be smarter.)
62615e32d5dSMike Smith      */
6274c1cdee6SMike Smith     ACPI_DEBUG_PRINT((ACPI_DB_OBJECTS, "namespace scan\n"));
62815e32d5dSMike Smith     for (i = 0; scopes[i] != NULL; i++)
62915e32d5dSMike Smith 	if ((AcpiGetHandle(ACPI_ROOT_OBJECT, scopes[i], &parent)) == AE_OK)
63015e32d5dSMike Smith 	    AcpiWalkNamespace(ACPI_TYPE_ANY, parent, 100, acpi_probe_child, bus, NULL);
63115e32d5dSMike Smith 
63215e32d5dSMike Smith     /*
63315e32d5dSMike Smith      * Scan all of the child devices we have created and let them probe/attach.
63415e32d5dSMike Smith      */
6354c1cdee6SMike Smith     ACPI_DEBUG_PRINT((ACPI_DB_OBJECTS, "first bus_generic_attach\n"));
63615e32d5dSMike Smith     bus_generic_attach(bus);
63715e32d5dSMike Smith 
63815e32d5dSMike Smith     /*
63915e32d5dSMike Smith      * Some of these children may have attached others as part of their attach
64015e32d5dSMike Smith      * process (eg. the root PCI bus driver), so rescan.
64115e32d5dSMike Smith      */
6424c1cdee6SMike Smith     ACPI_DEBUG_PRINT((ACPI_DB_OBJECTS, "second bus_generic_attach\n"));
64315e32d5dSMike Smith     bus_generic_attach(bus);
6440ae55423SMike Smith 
6450ae55423SMike Smith     return_VOID;
64615e32d5dSMike Smith }
64715e32d5dSMike Smith 
64815e32d5dSMike Smith /*
64915e32d5dSMike Smith  * Evaluate a child device and determine whether we might attach a device to
65015e32d5dSMike Smith  * it.
65115e32d5dSMike Smith  */
65215e32d5dSMike Smith static ACPI_STATUS
65315e32d5dSMike Smith acpi_probe_child(ACPI_HANDLE handle, UINT32 level, void *context, void **status)
65415e32d5dSMike Smith {
65515e32d5dSMike Smith     ACPI_OBJECT_TYPE	type;
65615e32d5dSMike Smith     device_t		child, bus = (device_t)context;
65715e32d5dSMike Smith 
6582a4ac806SMike Smith     FUNCTION_TRACE(__func__);
6590ae55423SMike Smith 
6600ae55423SMike Smith     /*
6610ae55423SMike Smith      * Skip this device if we think we'll have trouble with it.
6620ae55423SMike Smith      */
6630ae55423SMike Smith     if (acpi_avoid(handle))
6640ae55423SMike Smith 	return_ACPI_STATUS(AE_OK);
6650ae55423SMike Smith 
66615e32d5dSMike Smith     if (AcpiGetType(handle, &type) == AE_OK) {
66715e32d5dSMike Smith 	switch(type) {
66815e32d5dSMike Smith 	case ACPI_TYPE_DEVICE:
66915e32d5dSMike Smith 	case ACPI_TYPE_PROCESSOR:
67015e32d5dSMike Smith 	case ACPI_TYPE_THERMAL:
67115e32d5dSMike Smith 	case ACPI_TYPE_POWER:
6720ae55423SMike Smith 	    if (acpi_disabled("children"))
6730ae55423SMike Smith 		break;
67415e32d5dSMike Smith 	    /*
67515e32d5dSMike Smith 	     * Create a placeholder device for this node.  Sort the placeholder
67615e32d5dSMike Smith 	     * so that the probe/attach passes will run breadth-first.
67715e32d5dSMike Smith 	     */
6784c1cdee6SMike Smith 	    ACPI_DEBUG_PRINT((ACPI_DB_OBJECTS, "scanning '%s'\n", acpi_name(handle)));
67915e32d5dSMike Smith 	    child = BUS_ADD_CHILD(bus, level * 10, NULL, -1);
68015e32d5dSMike Smith 	    acpi_set_handle(child, handle);
6810ae55423SMike Smith 	    DEBUG_EXEC(device_probe_and_attach(child));
6820ae55423SMike Smith 	    break;
68315e32d5dSMike Smith 	}
68415e32d5dSMike Smith     }
6850ae55423SMike Smith     return_ACPI_STATUS(AE_OK);
68615e32d5dSMike Smith }
68715e32d5dSMike Smith 
68815e32d5dSMike Smith static void
68915e32d5dSMike Smith acpi_shutdown_pre_sync(void *arg, int howto)
69015e32d5dSMike Smith {
691cb9b0d80SMike Smith 
692cb9b0d80SMike Smith     ACPI_ASSERTLOCK;
693cb9b0d80SMike Smith 
69415e32d5dSMike Smith     /*
6950ae55423SMike Smith      * Disable all ACPI events before soft off, otherwise the system
69615e32d5dSMike Smith      * will be turned on again on some laptops.
69715e32d5dSMike Smith      *
69815e32d5dSMike Smith      * XXX this should probably be restricted to masking some events just
69915e32d5dSMike Smith      *     before powering down, since we may still need ACPI during the
70015e32d5dSMike Smith      *     shutdown process.
70115e32d5dSMike Smith      */
70215e32d5dSMike Smith     acpi_Disable((struct acpi_softc *)arg);
70315e32d5dSMike Smith }
70415e32d5dSMike Smith 
70515e32d5dSMike Smith static void
70615e32d5dSMike Smith acpi_shutdown_final(void *arg, int howto)
70715e32d5dSMike Smith {
70815e32d5dSMike Smith     ACPI_STATUS	status;
70915e32d5dSMike Smith 
710cb9b0d80SMike Smith     ACPI_ASSERTLOCK;
711cb9b0d80SMike Smith 
7125f3e4175SMitsuru IWASAKI     if (howto & RB_POWEROFF) {
71315e32d5dSMike Smith 	printf("Power system off using ACPI...\n");
7142a4ac806SMike Smith 	if ((status = AcpiEnterSleepState(acpi_off_state)) != AE_OK) {
715bfae45aaSMike Smith 	    printf("ACPI power-off failed - %s\n", AcpiFormatException(status));
71615e32d5dSMike Smith 	} else {
71715e32d5dSMike Smith 	    DELAY(1000000);
71815e32d5dSMike Smith 	    printf("ACPI power-off failed - timeout\n");
71915e32d5dSMike Smith 	}
72015e32d5dSMike Smith     }
72115e32d5dSMike Smith }
72215e32d5dSMike Smith 
72313d4f7baSMitsuru IWASAKI static void
72413d4f7baSMitsuru IWASAKI acpi_enable_fixed_events(struct acpi_softc *sc)
72513d4f7baSMitsuru IWASAKI {
72613d4f7baSMitsuru IWASAKI     static int	first_time = 1;
72713d4f7baSMitsuru IWASAKI #define MSGFORMAT "%s button is handled as a fixed feature programming model.\n"
72813d4f7baSMitsuru IWASAKI 
729cb9b0d80SMike Smith     ACPI_ASSERTLOCK;
730cb9b0d80SMike Smith 
73113d4f7baSMitsuru IWASAKI     /* Enable and clear fixed events and install handlers. */
732cb9b0d80SMike Smith     if ((AcpiGbl_FADT != NULL) && (AcpiGbl_FADT->PwrButton == 0)) {
73313d4f7baSMitsuru IWASAKI 	AcpiEnableEvent(ACPI_EVENT_POWER_BUTTON, ACPI_EVENT_FIXED);
73413d4f7baSMitsuru IWASAKI 	AcpiClearEvent(ACPI_EVENT_POWER_BUTTON, ACPI_EVENT_FIXED);
73513d4f7baSMitsuru IWASAKI 	AcpiInstallFixedEventHandler(ACPI_EVENT_POWER_BUTTON,
73613d4f7baSMitsuru IWASAKI 				     acpi_eventhandler_power_button_for_sleep, sc);
73713d4f7baSMitsuru IWASAKI 	if (first_time) {
73813d4f7baSMitsuru IWASAKI 	    device_printf(sc->acpi_dev, MSGFORMAT, "power");
73913d4f7baSMitsuru IWASAKI 	}
74013d4f7baSMitsuru IWASAKI     }
741cb9b0d80SMike Smith     if ((AcpiGbl_FADT != NULL) && (AcpiGbl_FADT->SleepButton == 0)) {
74213d4f7baSMitsuru IWASAKI 	AcpiEnableEvent(ACPI_EVENT_SLEEP_BUTTON, ACPI_EVENT_FIXED);
74313d4f7baSMitsuru IWASAKI 	AcpiClearEvent(ACPI_EVENT_SLEEP_BUTTON, ACPI_EVENT_FIXED);
74413d4f7baSMitsuru IWASAKI 	AcpiInstallFixedEventHandler(ACPI_EVENT_SLEEP_BUTTON,
74513d4f7baSMitsuru IWASAKI 				     acpi_eventhandler_sleep_button_for_sleep, sc);
74613d4f7baSMitsuru IWASAKI 	if (first_time) {
74713d4f7baSMitsuru IWASAKI 	    device_printf(sc->acpi_dev, MSGFORMAT, "sleep");
74813d4f7baSMitsuru IWASAKI 	}
74913d4f7baSMitsuru IWASAKI     }
75013d4f7baSMitsuru IWASAKI 
75113d4f7baSMitsuru IWASAKI     first_time = 0;
75213d4f7baSMitsuru IWASAKI }
75313d4f7baSMitsuru IWASAKI 
75415e32d5dSMike Smith /*
755c5ba0be4SMike Smith  * Returns true if the device is actually present and should
756c5ba0be4SMike Smith  * be attached to.  This requires the present, enabled, UI-visible
757c5ba0be4SMike Smith  * and diagnostics-passed bits to be set.
758c5ba0be4SMike Smith  */
759c5ba0be4SMike Smith BOOLEAN
760c5ba0be4SMike Smith acpi_DeviceIsPresent(device_t dev)
761c5ba0be4SMike Smith {
762c5ba0be4SMike Smith     ACPI_HANDLE		h;
763c5ba0be4SMike Smith     ACPI_DEVICE_INFO	devinfo;
764c5ba0be4SMike Smith     ACPI_STATUS		error;
765c5ba0be4SMike Smith 
766cb9b0d80SMike Smith     ACPI_ASSERTLOCK;
767cb9b0d80SMike Smith 
768c5ba0be4SMike Smith     if ((h = acpi_get_handle(dev)) == NULL)
769c5ba0be4SMike Smith 	return(FALSE);
770c5ba0be4SMike Smith     if ((error = AcpiGetObjectInfo(h, &devinfo)) != AE_OK)
771c5ba0be4SMike Smith 	return(FALSE);
7726f69255bSMike Smith     /* XXX 0xf is probably not appropriate */
773c5ba0be4SMike Smith     if ((devinfo.Valid & ACPI_VALID_HID) && (devinfo.CurrentStatus & 0xf))
774c5ba0be4SMike Smith 	return(TRUE);
775c5ba0be4SMike Smith     return(FALSE);
776c5ba0be4SMike Smith }
777c5ba0be4SMike Smith 
778c5ba0be4SMike Smith /*
77915e32d5dSMike Smith  * Match a HID string against a device
78015e32d5dSMike Smith  */
78115e32d5dSMike Smith BOOLEAN
78215e32d5dSMike Smith acpi_MatchHid(device_t dev, char *hid)
78315e32d5dSMike Smith {
78415e32d5dSMike Smith     ACPI_HANDLE		h;
78515e32d5dSMike Smith     ACPI_DEVICE_INFO	devinfo;
78615e32d5dSMike Smith     ACPI_STATUS		error;
78715e32d5dSMike Smith 
788cb9b0d80SMike Smith     ACPI_ASSERTLOCK;
789cb9b0d80SMike Smith 
7904d332989SMike Smith     if (hid == NULL)
79115e32d5dSMike Smith 	return(FALSE);
79215e32d5dSMike Smith     if ((h = acpi_get_handle(dev)) == NULL)
79315e32d5dSMike Smith 	return(FALSE);
79415e32d5dSMike Smith     if ((error = AcpiGetObjectInfo(h, &devinfo)) != AE_OK)
79515e32d5dSMike Smith 	return(FALSE);
7964d332989SMike Smith     if ((devinfo.Valid & ACPI_VALID_HID) && !strcmp(hid, devinfo.HardwareId))
79715e32d5dSMike Smith 	return(TRUE);
79815e32d5dSMike Smith     return(FALSE);
79915e32d5dSMike Smith }
80015e32d5dSMike Smith 
80115e32d5dSMike Smith /*
802c5ba0be4SMike Smith  * Return the handle of a named object within our scope, ie. that of (parent)
803c5ba0be4SMike Smith  * or one if its parents.
804c5ba0be4SMike Smith  */
805c5ba0be4SMike Smith ACPI_STATUS
806c5ba0be4SMike Smith acpi_GetHandleInScope(ACPI_HANDLE parent, char *path, ACPI_HANDLE *result)
807c5ba0be4SMike Smith {
808c5ba0be4SMike Smith     ACPI_HANDLE		r;
809c5ba0be4SMike Smith     ACPI_STATUS		status;
810c5ba0be4SMike Smith 
811cb9b0d80SMike Smith     ACPI_ASSERTLOCK;
812cb9b0d80SMike Smith 
813c5ba0be4SMike Smith     /* walk back up the tree to the root */
814c5ba0be4SMike Smith     for (;;) {
815c5ba0be4SMike Smith 	status = AcpiGetHandle(parent, path, &r);
816c5ba0be4SMike Smith 	if (status == AE_OK) {
817c5ba0be4SMike Smith 	    *result = r;
818c5ba0be4SMike Smith 	    return(AE_OK);
819c5ba0be4SMike Smith 	}
820c5ba0be4SMike Smith 	if (status != AE_NOT_FOUND)
821c5ba0be4SMike Smith 	    return(AE_OK);
822c5ba0be4SMike Smith 	if (AcpiGetParent(parent, &r) != AE_OK)
823c5ba0be4SMike Smith 	    return(AE_NOT_FOUND);
824c5ba0be4SMike Smith 	parent = r;
825c5ba0be4SMike Smith     }
826c5ba0be4SMike Smith }
827c5ba0be4SMike Smith 
828c5ba0be4SMike Smith /*
829c5ba0be4SMike Smith  * Allocate a buffer with a preset data size.
830c5ba0be4SMike Smith  */
831c5ba0be4SMike Smith ACPI_BUFFER *
832c5ba0be4SMike Smith acpi_AllocBuffer(int size)
833c5ba0be4SMike Smith {
834c5ba0be4SMike Smith     ACPI_BUFFER	*buf;
835c5ba0be4SMike Smith 
836c5ba0be4SMike Smith     if ((buf = malloc(size + sizeof(*buf), M_ACPIDEV, M_NOWAIT)) == NULL)
837c5ba0be4SMike Smith 	return(NULL);
838c5ba0be4SMike Smith     buf->Length = size;
839c5ba0be4SMike Smith     buf->Pointer = (void *)(buf + 1);
840c5ba0be4SMike Smith     return(buf);
841c5ba0be4SMike Smith }
842c5ba0be4SMike Smith 
843c5ba0be4SMike Smith /*
84415e32d5dSMike Smith  * Perform the tedious double-get procedure required for fetching something into
84515e32d5dSMike Smith  * an ACPI_BUFFER that has not been initialised.
84615e32d5dSMike Smith  */
84715e32d5dSMike Smith ACPI_STATUS
84815e32d5dSMike Smith acpi_GetIntoBuffer(ACPI_HANDLE handle, ACPI_STATUS (*func)(ACPI_HANDLE, ACPI_BUFFER *), ACPI_BUFFER *buf)
84915e32d5dSMike Smith {
85015e32d5dSMike Smith     ACPI_STATUS	status;
85115e32d5dSMike Smith 
852cb9b0d80SMike Smith     ACPI_ASSERTLOCK;
853cb9b0d80SMike Smith 
85415e32d5dSMike Smith     buf->Length = 0;
85515e32d5dSMike Smith     buf->Pointer = NULL;
85615e32d5dSMike Smith 
85715e32d5dSMike Smith     if ((status = func(handle, buf)) != AE_BUFFER_OVERFLOW)
85815e32d5dSMike Smith 	return(status);
85915e32d5dSMike Smith     if ((buf->Pointer = AcpiOsCallocate(buf->Length)) == NULL)
86015e32d5dSMike Smith 	return(AE_NO_MEMORY);
86115e32d5dSMike Smith     return(func(handle, buf));
86215e32d5dSMike Smith }
86315e32d5dSMike Smith 
86415e32d5dSMike Smith /*
8657d3bcec9SMike Smith  * Perform the tedious double-get procedure required for fetching a table into
8667d3bcec9SMike Smith  * an ACPI_BUFFER that has not been initialised.
8677d3bcec9SMike Smith  */
8687d3bcec9SMike Smith ACPI_STATUS
8697d3bcec9SMike Smith acpi_GetTableIntoBuffer(ACPI_TABLE_TYPE table, UINT32 instance, ACPI_BUFFER *buf)
8707d3bcec9SMike Smith {
8717d3bcec9SMike Smith     ACPI_STATUS	status;
8727d3bcec9SMike Smith 
8737d3bcec9SMike Smith     ACPI_ASSERTLOCK;
8747d3bcec9SMike Smith 
8757d3bcec9SMike Smith     buf->Length = 0;
8767d3bcec9SMike Smith     buf->Pointer = NULL;
8777d3bcec9SMike Smith 
8787d3bcec9SMike Smith     if ((status = AcpiGetTable(table, instance, buf)) != AE_BUFFER_OVERFLOW)
8797d3bcec9SMike Smith 	return(status);
8807d3bcec9SMike Smith     if ((buf->Pointer = AcpiOsCallocate(buf->Length)) == NULL)
8817d3bcec9SMike Smith 	return(AE_NO_MEMORY);
8827d3bcec9SMike Smith     return(AcpiGetTable(table, instance, buf));
8837d3bcec9SMike Smith }
8847d3bcec9SMike Smith 
8857d3bcec9SMike Smith /*
886c5ba0be4SMike Smith  * Perform the tedious double-evaluate procedure for evaluating something into
887c5ba0be4SMike Smith  * an ACPI_BUFFER that has not been initialised.  Note that this evaluates
888c5ba0be4SMike Smith  * twice, so avoid applying this to things that may have side-effects.
889c5ba0be4SMike Smith  *
890c5ba0be4SMike Smith  * This is like AcpiEvaluateObject with automatic buffer allocation.
89115e32d5dSMike Smith  */
892c5ba0be4SMike Smith ACPI_STATUS
893c5ba0be4SMike Smith acpi_EvaluateIntoBuffer(ACPI_HANDLE object, ACPI_STRING pathname, ACPI_OBJECT_LIST *params,
894c5ba0be4SMike Smith 			ACPI_BUFFER *buf)
89515e32d5dSMike Smith {
896c5ba0be4SMike Smith     ACPI_STATUS	status;
89715e32d5dSMike Smith 
898cb9b0d80SMike Smith     ACPI_ASSERTLOCK;
899cb9b0d80SMike Smith 
900c5ba0be4SMike Smith     buf->Length = 0;
901c5ba0be4SMike Smith     buf->Pointer = NULL;
902c5ba0be4SMike Smith 
903c5ba0be4SMike Smith     if ((status = AcpiEvaluateObject(object, pathname, params, buf)) != AE_BUFFER_OVERFLOW)
904c5ba0be4SMike Smith 	return(status);
905c5ba0be4SMike Smith     if ((buf->Pointer = AcpiOsCallocate(buf->Length)) == NULL)
906c5ba0be4SMike Smith 	return(AE_NO_MEMORY);
907c5ba0be4SMike Smith     return(AcpiEvaluateObject(object, pathname, params, buf));
90815e32d5dSMike Smith }
90915e32d5dSMike Smith 
910c5ba0be4SMike Smith /*
911c5ba0be4SMike Smith  * Evaluate a path that should return an integer.
912c5ba0be4SMike Smith  */
913c5ba0be4SMike Smith ACPI_STATUS
914c5ba0be4SMike Smith acpi_EvaluateInteger(ACPI_HANDLE handle, char *path, int *number)
915c5ba0be4SMike Smith {
916c5ba0be4SMike Smith     ACPI_STATUS	error;
917c5ba0be4SMike Smith     ACPI_BUFFER	buf;
918c5ba0be4SMike Smith     ACPI_OBJECT	param;
919c5ba0be4SMike Smith 
920cb9b0d80SMike Smith     ACPI_ASSERTLOCK;
921cb9b0d80SMike Smith 
922c5ba0be4SMike Smith     if (handle == NULL)
923c5ba0be4SMike Smith 	handle = ACPI_ROOT_OBJECT;
924c5ba0be4SMike Smith     buf.Pointer = &param;
925c5ba0be4SMike Smith     buf.Length = sizeof(param);
926c5ba0be4SMike Smith     if ((error = AcpiEvaluateObject(handle, path, NULL, &buf)) == AE_OK) {
927c5ba0be4SMike Smith 	if (param.Type == ACPI_TYPE_INTEGER) {
928c5ba0be4SMike Smith 	    *number = param.Integer.Value;
929c5ba0be4SMike Smith 	} else {
930c5ba0be4SMike Smith 	    error = AE_TYPE;
931c5ba0be4SMike Smith 	}
932c5ba0be4SMike Smith     }
933c5ba0be4SMike Smith     return(error);
934c5ba0be4SMike Smith }
935c5ba0be4SMike Smith 
936c5ba0be4SMike Smith /*
937c5ba0be4SMike Smith  * Iterate over the elements of an a package object, calling the supplied
938c5ba0be4SMike Smith  * function for each element.
939c5ba0be4SMike Smith  *
940c5ba0be4SMike Smith  * XXX possible enhancement might be to abort traversal on error.
941c5ba0be4SMike Smith  */
942c5ba0be4SMike Smith ACPI_STATUS
943c5ba0be4SMike Smith acpi_ForeachPackageObject(ACPI_OBJECT *pkg, void (* func)(ACPI_OBJECT *comp, void *arg), void *arg)
944c5ba0be4SMike Smith {
945c5ba0be4SMike Smith     ACPI_OBJECT	*comp;
946c5ba0be4SMike Smith     int		i;
947c5ba0be4SMike Smith 
948c5ba0be4SMike Smith     if ((pkg == NULL) || (pkg->Type != ACPI_TYPE_PACKAGE))
949c5ba0be4SMike Smith 	return(AE_BAD_PARAMETER);
950c5ba0be4SMike Smith 
951c5ba0be4SMike Smith     /* iterate over components */
952c5ba0be4SMike Smith     for (i = 0, comp = pkg->Package.Elements; i < pkg->Package.Count; i++, comp++)
953c5ba0be4SMike Smith 	func(comp, arg);
954c5ba0be4SMike Smith 
955c5ba0be4SMike Smith     return(AE_OK);
956c5ba0be4SMike Smith }
957c5ba0be4SMike Smith 
9586f69255bSMike Smith /*
9596f69255bSMike Smith  * Find the (index)th resource object in a set.
9606f69255bSMike Smith  */
9616f69255bSMike Smith ACPI_STATUS
9626d63101aSMike Smith acpi_FindIndexedResource(ACPI_BUFFER *buf, int index, ACPI_RESOURCE **resp)
9636f69255bSMike Smith {
9646d63101aSMike Smith     ACPI_RESOURCE	*rp;
9656f69255bSMike Smith     int			i;
9666f69255bSMike Smith 
9676d63101aSMike Smith     rp = (ACPI_RESOURCE *)buf->Pointer;
9686f69255bSMike Smith     i = index;
9696d63101aSMike Smith     while (i-- > 0) {
9706f69255bSMike Smith 	/* range check */
9716d63101aSMike Smith 	if (rp > (ACPI_RESOURCE *)((u_int8_t *)buf->Pointer + buf->Length))
9726f69255bSMike Smith 	    return(AE_BAD_PARAMETER);
9736d63101aSMike Smith 	/* check for terminator */
9746d63101aSMike Smith 	if ((rp->Id == ACPI_RSTYPE_END_TAG) ||
9756d63101aSMike Smith 	    (rp->Length == 0))
9766d63101aSMike Smith 	    return(AE_NOT_FOUND);
9776d63101aSMike Smith 	rp = ACPI_RESOURCE_NEXT(rp);
9786f69255bSMike Smith     }
9796f69255bSMike Smith     if (resp != NULL)
9806d63101aSMike Smith 	*resp = rp;
9816d63101aSMike Smith     return(AE_OK);
9826d63101aSMike Smith }
9836d63101aSMike Smith 
9846d63101aSMike Smith /*
9856d63101aSMike Smith  * Append an ACPI_RESOURCE to an ACPI_BUFFER.
9866d63101aSMike Smith  *
9876d63101aSMike Smith  * Given a pointer to an ACPI_RESOURCE structure, expand the ACPI_BUFFER
9886d63101aSMike Smith  * provided to contain it.  If the ACPI_BUFFER is empty, allocate a sensible
9896d63101aSMike Smith  * backing block.  If the ACPI_RESOURCE is NULL, return an empty set of
9906d63101aSMike Smith  * resources.
9916d63101aSMike Smith  */
9926d63101aSMike Smith #define ACPI_INITIAL_RESOURCE_BUFFER_SIZE	512
9936d63101aSMike Smith 
9946d63101aSMike Smith ACPI_STATUS
9956d63101aSMike Smith acpi_AppendBufferResource(ACPI_BUFFER *buf, ACPI_RESOURCE *res)
9966d63101aSMike Smith {
9976d63101aSMike Smith     ACPI_RESOURCE	*rp;
9986d63101aSMike Smith     void		*newp;
9996d63101aSMike Smith 
10006d63101aSMike Smith     /*
10016d63101aSMike Smith      * Initialise the buffer if necessary.
10026d63101aSMike Smith      */
10036d63101aSMike Smith     if (buf->Pointer == NULL) {
10046d63101aSMike Smith 	buf->Length = ACPI_INITIAL_RESOURCE_BUFFER_SIZE;
10056d63101aSMike Smith 	if ((buf->Pointer = AcpiOsAllocate(buf->Length)) == NULL)
10066d63101aSMike Smith 	    return(AE_NO_MEMORY);
10076d63101aSMike Smith 	rp = (ACPI_RESOURCE *)buf->Pointer;
10086d63101aSMike Smith 	rp->Id = ACPI_RSTYPE_END_TAG;
10096d63101aSMike Smith 	rp->Length = 0;
10106d63101aSMike Smith     }
10116d63101aSMike Smith     if (res == NULL)
10126d63101aSMike Smith 	return(AE_OK);
10136d63101aSMike Smith 
10146d63101aSMike Smith     /*
10156d63101aSMike Smith      * Scan the current buffer looking for the terminator.
10166d63101aSMike Smith      * This will either find the terminator or hit the end
10176d63101aSMike Smith      * of the buffer and return an error.
10186d63101aSMike Smith      */
10196d63101aSMike Smith     rp = (ACPI_RESOURCE *)buf->Pointer;
10206d63101aSMike Smith     for (;;) {
10216d63101aSMike Smith 	/* range check, don't go outside the buffer */
10226d63101aSMike Smith 	if (rp >= (ACPI_RESOURCE *)((u_int8_t *)buf->Pointer + buf->Length))
10236d63101aSMike Smith 	    return(AE_BAD_PARAMETER);
10246d63101aSMike Smith 	if ((rp->Id == ACPI_RSTYPE_END_TAG) ||
10256d63101aSMike Smith 	    (rp->Length == 0)) {
10266d63101aSMike Smith 	    break;
10276d63101aSMike Smith 	}
10286d63101aSMike Smith 	rp = ACPI_RESOURCE_NEXT(rp);
10296d63101aSMike Smith     }
10306d63101aSMike Smith 
10316d63101aSMike Smith     /*
10326d63101aSMike Smith      * Check the size of the buffer and expand if required.
10336d63101aSMike Smith      *
10346d63101aSMike Smith      * Required size is:
10356d63101aSMike Smith      *	size of existing resources before terminator +
10366d63101aSMike Smith      *	size of new resource and header +
10376d63101aSMike Smith      * 	size of terminator.
10386d63101aSMike Smith      *
10396d63101aSMike Smith      * Note that this loop should really only run once, unless
10406d63101aSMike Smith      * for some reason we are stuffing a *really* huge resource.
10416d63101aSMike Smith      */
10426d63101aSMike Smith     while ((((u_int8_t *)rp - (u_int8_t *)buf->Pointer) +
10436d63101aSMike Smith 	    res->Length + ACPI_RESOURCE_LENGTH_NO_DATA +
10446d63101aSMike Smith 	    ACPI_RESOURCE_LENGTH) >= buf->Length) {
10456d63101aSMike Smith 	if ((newp = AcpiOsAllocate(buf->Length * 2)) == NULL)
10466d63101aSMike Smith 	    return(AE_NO_MEMORY);
10476d63101aSMike Smith 	bcopy(buf->Pointer, newp, buf->Length);
1048a692219dSMike Smith         rp = (ACPI_RESOURCE *)((u_int8_t *)newp +
1049a692219dSMike Smith 			       ((u_int8_t *)rp - (u_int8_t *)buf->Pointer));
10506d63101aSMike Smith 	AcpiOsFree(buf->Pointer);
10516d63101aSMike Smith 	buf->Pointer = newp;
10526d63101aSMike Smith 	buf->Length += buf->Length;
10536d63101aSMike Smith     }
10546d63101aSMike Smith 
10556d63101aSMike Smith     /*
10566d63101aSMike Smith      * Insert the new resource.
10576d63101aSMike Smith      */
10586d63101aSMike Smith     bcopy(res, rp, res->Length + ACPI_RESOURCE_LENGTH_NO_DATA);
10596d63101aSMike Smith 
10606d63101aSMike Smith     /*
10616d63101aSMike Smith      * And add the terminator.
10626d63101aSMike Smith      */
10636d63101aSMike Smith     rp = ACPI_RESOURCE_NEXT(rp);
10646d63101aSMike Smith     rp->Id = ACPI_RSTYPE_END_TAG;
10656d63101aSMike Smith     rp->Length = 0;
10666d63101aSMike Smith 
10676f69255bSMike Smith     return(AE_OK);
10686f69255bSMike Smith }
1069c5ba0be4SMike Smith 
1070c30382dfSMitsuru IWASAKI static ACPI_STATUS __inline
1071c30382dfSMitsuru IWASAKI acpi_wakeup(UINT8 state)
1072c30382dfSMitsuru IWASAKI {
1073c30382dfSMitsuru IWASAKI     ACPI_STATUS		Status;
1074c30382dfSMitsuru IWASAKI     ACPI_OBJECT_LIST	Arg_list;
1075c30382dfSMitsuru IWASAKI     ACPI_OBJECT		Arg;
1076c30382dfSMitsuru IWASAKI     ACPI_OBJECT		Objects[3]; /* package plus 2 number objects */
1077c30382dfSMitsuru IWASAKI     ACPI_BUFFER		ReturnBuffer;
1078c30382dfSMitsuru IWASAKI 
10792a4ac806SMike Smith     FUNCTION_TRACE_U32(__func__, state);
1080cb9b0d80SMike Smith     ACPI_ASSERTLOCK;
1081c30382dfSMitsuru IWASAKI 
1082c30382dfSMitsuru IWASAKI     /*
1083c30382dfSMitsuru IWASAKI      * Evaluate the _WAK method
1084c30382dfSMitsuru IWASAKI      */
1085cb9b0d80SMike Smith     bzero(&Arg_list, sizeof(Arg_list));
1086c30382dfSMitsuru IWASAKI     Arg_list.Count = 1;
1087c30382dfSMitsuru IWASAKI     Arg_list.Pointer = &Arg;
1088c30382dfSMitsuru IWASAKI 
1089cb9b0d80SMike Smith     bzero(&Arg, sizeof(Arg));
1090c30382dfSMitsuru IWASAKI     Arg.Type = ACPI_TYPE_INTEGER;
1091c30382dfSMitsuru IWASAKI     Arg.Integer.Value = state;
1092c30382dfSMitsuru IWASAKI 
1093cb9b0d80SMike Smith     /*
1094cb9b0d80SMike Smith      * Set up _WAK result code buffer.
1095cb9b0d80SMike Smith      *
1096cb9b0d80SMike Smith      * XXX should use acpi_EvaluateIntoBuffer
1097cb9b0d80SMike Smith      */
1098cb9b0d80SMike Smith     bzero(Objects, sizeof(Objects));
1099c30382dfSMitsuru IWASAKI     ReturnBuffer.Length = sizeof(Objects);
1100c30382dfSMitsuru IWASAKI     ReturnBuffer.Pointer = Objects;
1101c30382dfSMitsuru IWASAKI     AcpiEvaluateObject (NULL, "\\_WAK", &Arg_list, &ReturnBuffer);
1102c30382dfSMitsuru IWASAKI 
1103c30382dfSMitsuru IWASAKI     Status = AE_OK;
1104cb9b0d80SMike Smith 
1105c30382dfSMitsuru IWASAKI     /* Check result code for _WAK */
1106c30382dfSMitsuru IWASAKI     if (Objects[0].Type != ACPI_TYPE_PACKAGE ||
1107c30382dfSMitsuru IWASAKI 	Objects[1].Type != ACPI_TYPE_INTEGER  ||
1108c30382dfSMitsuru IWASAKI 	Objects[2].Type != ACPI_TYPE_INTEGER) {
1109c30382dfSMitsuru IWASAKI 	/*
1110c30382dfSMitsuru IWASAKI 	 * In many BIOSes, _WAK doesn't return a result code.
1111c30382dfSMitsuru IWASAKI 	 * We don't need to worry about it too much :-).
1112c30382dfSMitsuru IWASAKI 	 */
11134c1cdee6SMike Smith 	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
11144c1cdee6SMike Smith 			  "acpi_wakeup: _WAK result code is corrupted, "
1115c30382dfSMitsuru IWASAKI 			  "but should be OK.\n"));
1116c30382dfSMitsuru IWASAKI     } else {
1117c30382dfSMitsuru IWASAKI 	/* evaluate status code */
1118c30382dfSMitsuru IWASAKI 	switch (Objects[1].Integer.Value) {
1119c30382dfSMitsuru IWASAKI 	case 0x00000001:
11204c1cdee6SMike Smith 	    ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
11214c1cdee6SMike Smith 			      "acpi_wakeup: Wake was signaled "
1122c30382dfSMitsuru IWASAKI 			      "but failed due to lack of power.\n"));
1123c30382dfSMitsuru IWASAKI 	    Status = AE_ERROR;
1124c30382dfSMitsuru IWASAKI 	    break;
1125c30382dfSMitsuru IWASAKI 
1126c30382dfSMitsuru IWASAKI 	case 0x00000002:
11274c1cdee6SMike Smith 	    ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
11284c1cdee6SMike Smith 			      "acpi_wakeup: Wake was signaled "
1129c30382dfSMitsuru IWASAKI 			      "but failed due to thermal condition.\n"));
1130c30382dfSMitsuru IWASAKI 	    Status = AE_ERROR;
1131c30382dfSMitsuru IWASAKI 	    break;
1132c30382dfSMitsuru IWASAKI 	}
1133c30382dfSMitsuru IWASAKI 	/* evaluate PSS code */
1134c30382dfSMitsuru IWASAKI 	if (Objects[2].Integer.Value == 0) {
11354c1cdee6SMike Smith 	    ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
11364c1cdee6SMike Smith 			      "acpi_wakeup: The targeted S-state "
1137c30382dfSMitsuru IWASAKI 			      "was not entered because of too much current "
1138c30382dfSMitsuru IWASAKI 			      "being drawn from the power supply.\n"));
1139c30382dfSMitsuru IWASAKI 	    Status = AE_ERROR;
1140c30382dfSMitsuru IWASAKI 	}
1141c30382dfSMitsuru IWASAKI     }
1142c30382dfSMitsuru IWASAKI     return_ACPI_STATUS(Status);
1143c30382dfSMitsuru IWASAKI }
1144c30382dfSMitsuru IWASAKI 
114515e32d5dSMike Smith /*
114615e32d5dSMike Smith  * Set the system sleep state
114715e32d5dSMike Smith  *
114815e32d5dSMike Smith  * Currently we only support S1 and S5
114915e32d5dSMike Smith  */
115015e32d5dSMike Smith ACPI_STATUS
115115e32d5dSMike Smith acpi_SetSleepState(struct acpi_softc *sc, int state)
115215e32d5dSMike Smith {
115315e32d5dSMike Smith     ACPI_STATUS	status = AE_OK;
11546161544cSTakanori Watanabe     UINT16	Count;
115556d8cb57SMitsuru IWASAKI     UINT8	TypeA;
115656d8cb57SMitsuru IWASAKI     UINT8	TypeB;
115715e32d5dSMike Smith 
11582a4ac806SMike Smith     FUNCTION_TRACE_U32(__func__, state);
1159cb9b0d80SMike Smith     ACPI_ASSERTLOCK;
11600ae55423SMike Smith 
116115e32d5dSMike Smith     switch (state) {
116215e32d5dSMike Smith     case ACPI_STATE_S0:	/* XXX only for testing */
116391467fc6SMike Smith 	status = AcpiEnterSleepState((UINT8)state);
116415e32d5dSMike Smith 	if (status != AE_OK) {
1165bfae45aaSMike Smith 	    device_printf(sc->acpi_dev, "AcpiEnterSleepState failed - %s\n", AcpiFormatException(status));
116615e32d5dSMike Smith 	}
116715e32d5dSMike Smith 	break;
116815e32d5dSMike Smith 
116915e32d5dSMike Smith     case ACPI_STATE_S1:
11706161544cSTakanori Watanabe     case ACPI_STATE_S2:
11716161544cSTakanori Watanabe     case ACPI_STATE_S3:
11726161544cSTakanori Watanabe     case ACPI_STATE_S4:
117356d8cb57SMitsuru IWASAKI 	status = AcpiHwObtainSleepTypeRegisterData((UINT8)state, &TypeA, &TypeB);
117456d8cb57SMitsuru IWASAKI 	if (status != AE_OK) {
117556d8cb57SMitsuru IWASAKI 	    device_printf(sc->acpi_dev, "AcpiHwObtainSleepTypeRegisterData failed - %s\n", AcpiFormatException(status));
117656d8cb57SMitsuru IWASAKI 	    break;
117756d8cb57SMitsuru IWASAKI 	}
117856d8cb57SMitsuru IWASAKI 
117915e32d5dSMike Smith 	/*
118015e32d5dSMike Smith 	 * Inform all devices that we are going to sleep.
118115e32d5dSMike Smith 	 */
118215e32d5dSMike Smith 	if (DEVICE_SUSPEND(root_bus) != 0) {
118315e32d5dSMike Smith 	    /*
118415e32d5dSMike Smith 	     * Re-wake the system.
118515e32d5dSMike Smith 	     *
118615e32d5dSMike Smith 	     * XXX note that a better two-pass approach with a 'veto' pass
118715e32d5dSMike Smith 	     *     followed by a "real thing" pass would be better, but the
118815e32d5dSMike Smith 	     *     current bus interface does not provide for this.
118915e32d5dSMike Smith 	     */
119015e32d5dSMike Smith 	    DEVICE_RESUME(root_bus);
11910ae55423SMike Smith 	    return_ACPI_STATUS(AE_ERROR);
119215e32d5dSMike Smith 	}
119315e32d5dSMike Smith 	sc->acpi_sstate = state;
11946161544cSTakanori Watanabe 
11956161544cSTakanori Watanabe 	if (state != ACPI_STATE_S1) {
11966161544cSTakanori Watanabe 	    acpi_sleep_machdep(sc, state);
11976161544cSTakanori Watanabe 
11986161544cSTakanori Watanabe 	    /* AcpiEnterSleepState() maybe incompleted, unlock here. */
11996161544cSTakanori Watanabe 	    AcpiUtReleaseMutex(ACPI_MTX_HARDWARE);
12006161544cSTakanori Watanabe 
12016161544cSTakanori Watanabe 	    /* Re-enable ACPI hardware on wakeup from sleep state 4. */
12026161544cSTakanori Watanabe 	    if (state >= ACPI_STATE_S4) {
12036161544cSTakanori Watanabe 		acpi_Disable(sc);
12046161544cSTakanori Watanabe 		acpi_Enable(sc);
12056161544cSTakanori Watanabe 	    }
12066161544cSTakanori Watanabe 	} else {
120791467fc6SMike Smith 	    status = AcpiEnterSleepState((UINT8)state);
120815e32d5dSMike Smith 	    if (status != AE_OK) {
1209bfae45aaSMike Smith 		device_printf(sc->acpi_dev, "AcpiEnterSleepState failed - %s\n", AcpiFormatException(status));
1210c30382dfSMitsuru IWASAKI 		break;
121115e32d5dSMike Smith 	    }
12126161544cSTakanori Watanabe 	    /* wait for the WAK_STS bit */
12136161544cSTakanori Watanabe 	    Count = 0;
12146161544cSTakanori Watanabe 	    while (!(AcpiHwRegisterBitAccess(ACPI_READ, ACPI_MTX_LOCK, WAK_STS))) {
1215acf72ef4SMike Smith 		AcpiOsSleep(0, 1);
12166161544cSTakanori Watanabe 		/*
12176161544cSTakanori Watanabe 		 * Some BIOSes don't set WAK_STS at all,
12186161544cSTakanori Watanabe 		 * give up waiting for wakeup if we time out.
12196161544cSTakanori Watanabe 		 */
12206161544cSTakanori Watanabe 		if (Count > 1000) {
12216161544cSTakanori Watanabe 		    break;	/* giving up */
12226161544cSTakanori Watanabe 		}
12236161544cSTakanori Watanabe 		Count++;
12246161544cSTakanori Watanabe 	    }
12256161544cSTakanori Watanabe 	}
1226c30382dfSMitsuru IWASAKI 	acpi_wakeup((UINT8)state);
122715e32d5dSMike Smith 	DEVICE_RESUME(root_bus);
122815e32d5dSMike Smith 	sc->acpi_sstate = ACPI_STATE_S0;
122913d4f7baSMitsuru IWASAKI 	acpi_enable_fixed_events(sc);
123015e32d5dSMike Smith 	break;
123115e32d5dSMike Smith 
123215e32d5dSMike Smith     case ACPI_STATE_S5:
123315e32d5dSMike Smith 	/*
123415e32d5dSMike Smith 	 * Shut down cleanly and power off.  This will call us back through the
123515e32d5dSMike Smith 	 * shutdown handlers.
123615e32d5dSMike Smith 	 */
123715e32d5dSMike Smith 	shutdown_nice(RB_POWEROFF);
123815e32d5dSMike Smith 	break;
123915e32d5dSMike Smith 
124015e32d5dSMike Smith     default:
124115e32d5dSMike Smith 	status = AE_BAD_PARAMETER;
124215e32d5dSMike Smith 	break;
124315e32d5dSMike Smith     }
12440ae55423SMike Smith     return_ACPI_STATUS(status);
124515e32d5dSMike Smith }
124615e32d5dSMike Smith 
124715e32d5dSMike Smith /*
124815e32d5dSMike Smith  * Enable/Disable ACPI
124915e32d5dSMike Smith  */
125015e32d5dSMike Smith ACPI_STATUS
125115e32d5dSMike Smith acpi_Enable(struct acpi_softc *sc)
125215e32d5dSMike Smith {
125315e32d5dSMike Smith     ACPI_STATUS	status;
125415e32d5dSMike Smith     u_int32_t	flags;
125515e32d5dSMike Smith 
12562a4ac806SMike Smith     FUNCTION_TRACE(__func__);
1257cb9b0d80SMike Smith     ACPI_ASSERTLOCK;
12580ae55423SMike Smith 
125915e32d5dSMike Smith     flags = ACPI_NO_ADDRESS_SPACE_INIT | ACPI_NO_HARDWARE_INIT |
126015e32d5dSMike Smith             ACPI_NO_DEVICE_INIT | ACPI_NO_OBJECT_INIT;
126115e32d5dSMike Smith     if (!sc->acpi_enabled) {
126215e32d5dSMike Smith 	status = AcpiEnableSubsystem(flags);
126315e32d5dSMike Smith     } else {
126415e32d5dSMike Smith 	status = AE_OK;
126515e32d5dSMike Smith     }
126615e32d5dSMike Smith     if (status == AE_OK)
126715e32d5dSMike Smith 	sc->acpi_enabled = 1;
12680ae55423SMike Smith     return_ACPI_STATUS(status);
126915e32d5dSMike Smith }
127015e32d5dSMike Smith 
127115e32d5dSMike Smith ACPI_STATUS
127215e32d5dSMike Smith acpi_Disable(struct acpi_softc *sc)
127315e32d5dSMike Smith {
127415e32d5dSMike Smith     ACPI_STATUS	status;
127515e32d5dSMike Smith 
12762a4ac806SMike Smith     FUNCTION_TRACE(__func__);
1277cb9b0d80SMike Smith     ACPI_ASSERTLOCK;
12780ae55423SMike Smith 
127915e32d5dSMike Smith     if (sc->acpi_enabled) {
128015e32d5dSMike Smith 	status = AcpiDisable();
128115e32d5dSMike Smith     } else {
128215e32d5dSMike Smith 	status = AE_OK;
128315e32d5dSMike Smith     }
128415e32d5dSMike Smith     if (status == AE_OK)
128515e32d5dSMike Smith 	sc->acpi_enabled = 0;
12860ae55423SMike Smith     return_ACPI_STATUS(status);
128715e32d5dSMike Smith }
128815e32d5dSMike Smith 
128915e32d5dSMike Smith /*
129015e32d5dSMike Smith  * ACPI Event Handlers
129115e32d5dSMike Smith  */
129215e32d5dSMike Smith 
129315e32d5dSMike Smith /* System Event Handlers (registered by EVENTHANDLER_REGISTER) */
129415e32d5dSMike Smith 
129515e32d5dSMike Smith static void
129615e32d5dSMike Smith acpi_system_eventhandler_sleep(void *arg, int state)
129715e32d5dSMike Smith {
12982a4ac806SMike Smith     FUNCTION_TRACE_U32(__func__, state);
129915e32d5dSMike Smith 
1300cb9b0d80SMike Smith     ACPI_LOCK;
1301a5d1879bSMitsuru IWASAKI     if (state >= ACPI_STATE_S0 && state <= ACPI_S_STATES_MAX)
130215e32d5dSMike Smith 	acpi_SetSleepState((struct acpi_softc *)arg, state);
1303cb9b0d80SMike Smith     ACPI_UNLOCK;
13040ae55423SMike Smith     return_VOID;
130515e32d5dSMike Smith }
130615e32d5dSMike Smith 
130715e32d5dSMike Smith static void
130815e32d5dSMike Smith acpi_system_eventhandler_wakeup(void *arg, int state)
130915e32d5dSMike Smith {
13102a4ac806SMike Smith     FUNCTION_TRACE_U32(__func__, state);
13110ae55423SMike Smith 
131215e32d5dSMike Smith     /* Well, what to do? :-) */
13130ae55423SMike Smith 
1314cb9b0d80SMike Smith     ACPI_LOCK;
1315cb9b0d80SMike Smith     ACPI_UNLOCK;
1316cb9b0d80SMike Smith 
13170ae55423SMike Smith     return_VOID;
131815e32d5dSMike Smith }
131915e32d5dSMike Smith 
132015e32d5dSMike Smith /*
132115e32d5dSMike Smith  * ACPICA Event Handlers (FixedEvent, also called from button notify handler)
132215e32d5dSMike Smith  */
132315e32d5dSMike Smith UINT32
132415e32d5dSMike Smith acpi_eventhandler_power_button_for_sleep(void *context)
132515e32d5dSMike Smith {
132615e32d5dSMike Smith     struct acpi_softc	*sc = (struct acpi_softc *)context;
132715e32d5dSMike Smith 
13282a4ac806SMike Smith     FUNCTION_TRACE(__func__);
13290ae55423SMike Smith 
133015e32d5dSMike Smith     EVENTHANDLER_INVOKE(acpi_sleep_event, sc->acpi_power_button_sx);
13310ae55423SMike Smith 
13320ae55423SMike Smith     return_VALUE(INTERRUPT_HANDLED);
133315e32d5dSMike Smith }
133415e32d5dSMike Smith 
133515e32d5dSMike Smith UINT32
133615e32d5dSMike Smith acpi_eventhandler_power_button_for_wakeup(void *context)
133715e32d5dSMike Smith {
133815e32d5dSMike Smith     struct acpi_softc	*sc = (struct acpi_softc *)context;
133915e32d5dSMike Smith 
13402a4ac806SMike Smith     FUNCTION_TRACE(__func__);
13410ae55423SMike Smith 
134215e32d5dSMike Smith     EVENTHANDLER_INVOKE(acpi_wakeup_event, sc->acpi_power_button_sx);
13430ae55423SMike Smith 
13440ae55423SMike Smith     return_VALUE(INTERRUPT_HANDLED);
134515e32d5dSMike Smith }
134615e32d5dSMike Smith 
134715e32d5dSMike Smith UINT32
134815e32d5dSMike Smith acpi_eventhandler_sleep_button_for_sleep(void *context)
134915e32d5dSMike Smith {
135015e32d5dSMike Smith     struct acpi_softc	*sc = (struct acpi_softc *)context;
135115e32d5dSMike Smith 
13522a4ac806SMike Smith     FUNCTION_TRACE(__func__);
13530ae55423SMike Smith 
135415e32d5dSMike Smith     EVENTHANDLER_INVOKE(acpi_sleep_event, sc->acpi_sleep_button_sx);
13550ae55423SMike Smith 
13560ae55423SMike Smith     return_VALUE(INTERRUPT_HANDLED);
135715e32d5dSMike Smith }
135815e32d5dSMike Smith 
135915e32d5dSMike Smith UINT32
136015e32d5dSMike Smith acpi_eventhandler_sleep_button_for_wakeup(void *context)
136115e32d5dSMike Smith {
136215e32d5dSMike Smith     struct acpi_softc	*sc = (struct acpi_softc *)context;
136315e32d5dSMike Smith 
13642a4ac806SMike Smith     FUNCTION_TRACE(__func__);
13650ae55423SMike Smith 
136615e32d5dSMike Smith     EVENTHANDLER_INVOKE(acpi_wakeup_event, sc->acpi_sleep_button_sx);
13670ae55423SMike Smith 
13680ae55423SMike Smith     return_VALUE(INTERRUPT_HANDLED);
136915e32d5dSMike Smith }
137015e32d5dSMike Smith 
137115e32d5dSMike Smith /*
137215e32d5dSMike Smith  * XXX This is kinda ugly, and should not be here.
137315e32d5dSMike Smith  */
137415e32d5dSMike Smith struct acpi_staticbuf {
137515e32d5dSMike Smith     ACPI_BUFFER	buffer;
137615e32d5dSMike Smith     char	data[512];
137715e32d5dSMike Smith };
137815e32d5dSMike Smith 
137915e32d5dSMike Smith char *
138015e32d5dSMike Smith acpi_name(ACPI_HANDLE handle)
138115e32d5dSMike Smith {
138215e32d5dSMike Smith     static struct acpi_staticbuf	buf;
138315e32d5dSMike Smith 
1384cb9b0d80SMike Smith     ACPI_ASSERTLOCK;
1385cb9b0d80SMike Smith 
138615e32d5dSMike Smith     buf.buffer.Length = 512;
138715e32d5dSMike Smith     buf.buffer.Pointer = &buf.data[0];
138815e32d5dSMike Smith 
138915e32d5dSMike Smith     if (AcpiGetName(handle, ACPI_FULL_PATHNAME, &buf.buffer) == AE_OK)
139015e32d5dSMike Smith 	return(buf.buffer.Pointer);
139115e32d5dSMike Smith     return("(unknown path)");
139215e32d5dSMike Smith }
139315e32d5dSMike Smith 
139415e32d5dSMike Smith /*
139515e32d5dSMike Smith  * Debugging/bug-avoidance.  Avoid trying to fetch info on various
139615e32d5dSMike Smith  * parts of the namespace.
139715e32d5dSMike Smith  */
139815e32d5dSMike Smith int
139915e32d5dSMike Smith acpi_avoid(ACPI_HANDLE handle)
140015e32d5dSMike Smith {
140115e32d5dSMike Smith     char	*cp, *np;
140215e32d5dSMike Smith     int		len;
140315e32d5dSMike Smith 
140415e32d5dSMike Smith     np = acpi_name(handle);
140515e32d5dSMike Smith     if (*np == '\\')
140615e32d5dSMike Smith 	np++;
140715e32d5dSMike Smith     if ((cp = getenv("debug.acpi.avoid")) == NULL)
140815e32d5dSMike Smith 	return(0);
140915e32d5dSMike Smith 
141015e32d5dSMike Smith     /* scan the avoid list checking for a match */
141115e32d5dSMike Smith     for (;;) {
141215e32d5dSMike Smith 	while ((*cp != 0) && isspace(*cp))
141315e32d5dSMike Smith 	    cp++;
141415e32d5dSMike Smith 	if (*cp == 0)
141515e32d5dSMike Smith 	    break;
141615e32d5dSMike Smith 	len = 0;
141715e32d5dSMike Smith 	while ((cp[len] != 0) && !isspace(cp[len]))
141815e32d5dSMike Smith 	    len++;
14194c1cdee6SMike Smith 	if (!strncmp(cp, np, len))
14200ae55423SMike Smith 	    return(1);
14210ae55423SMike Smith 	cp += len;
14220ae55423SMike Smith     }
14230ae55423SMike Smith     return(0);
14240ae55423SMike Smith }
14250ae55423SMike Smith 
14260ae55423SMike Smith /*
14270ae55423SMike Smith  * Debugging/bug-avoidance.  Disable ACPI subsystem components.
14280ae55423SMike Smith  */
14290ae55423SMike Smith int
14300ae55423SMike Smith acpi_disabled(char *subsys)
14310ae55423SMike Smith {
14320ae55423SMike Smith     char	*cp;
14330ae55423SMike Smith     int		len;
14340ae55423SMike Smith 
14350ae55423SMike Smith     if ((cp = getenv("debug.acpi.disable")) == NULL)
14360ae55423SMike Smith 	return(0);
14370ae55423SMike Smith     if (!strcmp(cp, "all"))
14380ae55423SMike Smith 	return(1);
14390ae55423SMike Smith 
14400ae55423SMike Smith     /* scan the disable list checking for a match */
14410ae55423SMike Smith     for (;;) {
14420ae55423SMike Smith 	while ((*cp != 0) && isspace(*cp))
14430ae55423SMike Smith 	    cp++;
14440ae55423SMike Smith 	if (*cp == 0)
14450ae55423SMike Smith 	    break;
14460ae55423SMike Smith 	len = 0;
14470ae55423SMike Smith 	while ((cp[len] != 0) && !isspace(cp[len]))
14480ae55423SMike Smith 	    len++;
14494c1cdee6SMike Smith 	if (!strncmp(cp, subsys, len))
145015e32d5dSMike Smith 	    return(1);
145115e32d5dSMike Smith 	cp += len;
145215e32d5dSMike Smith     }
145315e32d5dSMike Smith     return(0);
145415e32d5dSMike Smith }
145515e32d5dSMike Smith 
145615e32d5dSMike Smith /*
145715e32d5dSMike Smith  * Control interface.
145815e32d5dSMike Smith  *
14590ae55423SMike Smith  * We multiplex ioctls for all participating ACPI devices here.  Individual
14600ae55423SMike Smith  * drivers wanting to be accessible via /dev/acpi should use the register/deregister
14610ae55423SMike Smith  * interface to make their handlers visible.
146215e32d5dSMike Smith  */
14630ae55423SMike Smith struct acpi_ioctl_hook
14640ae55423SMike Smith {
14650ae55423SMike Smith     TAILQ_ENTRY(acpi_ioctl_hook)	link;
14660ae55423SMike Smith     u_long				cmd;
14670ae55423SMike Smith     int					(* fn)(u_long cmd, caddr_t addr, void *arg);
14680ae55423SMike Smith     void				*arg;
14690ae55423SMike Smith };
14700ae55423SMike Smith 
14710ae55423SMike Smith static TAILQ_HEAD(,acpi_ioctl_hook)	acpi_ioctl_hooks;
14720ae55423SMike Smith static int				acpi_ioctl_hooks_initted;
14730ae55423SMike Smith 
14740ae55423SMike Smith /*
14750ae55423SMike Smith  * Register an ioctl handler.
14760ae55423SMike Smith  */
14770ae55423SMike Smith int
14780ae55423SMike Smith acpi_register_ioctl(u_long cmd, int (* fn)(u_long cmd, caddr_t addr, void *arg), void *arg)
14790ae55423SMike Smith {
14800ae55423SMike Smith     struct acpi_ioctl_hook	*hp;
14810ae55423SMike Smith 
14820ae55423SMike Smith     if ((hp = malloc(sizeof(*hp), M_ACPIDEV, M_NOWAIT)) == NULL)
14830ae55423SMike Smith 	return(ENOMEM);
14840ae55423SMike Smith     hp->cmd = cmd;
14850ae55423SMike Smith     hp->fn = fn;
14860ae55423SMike Smith     hp->arg = arg;
14870ae55423SMike Smith     if (acpi_ioctl_hooks_initted == 0) {
14880ae55423SMike Smith 	TAILQ_INIT(&acpi_ioctl_hooks);
14890ae55423SMike Smith 	acpi_ioctl_hooks_initted = 1;
14900ae55423SMike Smith     }
14910ae55423SMike Smith     TAILQ_INSERT_TAIL(&acpi_ioctl_hooks, hp, link);
14920ae55423SMike Smith     return(0);
14930ae55423SMike Smith }
14940ae55423SMike Smith 
14950ae55423SMike Smith /*
14960ae55423SMike Smith  * Deregister an ioctl handler.
14970ae55423SMike Smith  */
14980ae55423SMike Smith void
14990ae55423SMike Smith acpi_deregister_ioctl(u_long cmd, int (* fn)(u_long cmd, caddr_t addr, void *arg))
15000ae55423SMike Smith {
15010ae55423SMike Smith     struct acpi_ioctl_hook	*hp;
15020ae55423SMike Smith 
15030ae55423SMike Smith     TAILQ_FOREACH(hp, &acpi_ioctl_hooks, link)
15040ae55423SMike Smith 	if ((hp->cmd == cmd) && (hp->fn == fn))
15050ae55423SMike Smith 	    break;
15060ae55423SMike Smith 
15070ae55423SMike Smith     if (hp != NULL) {
15080ae55423SMike Smith 	TAILQ_REMOVE(&acpi_ioctl_hooks, hp, link);
15090ae55423SMike Smith 	free(hp, M_ACPIDEV);
15100ae55423SMike Smith     }
15110ae55423SMike Smith }
15120ae55423SMike Smith 
151315e32d5dSMike Smith static int
151415e32d5dSMike Smith acpiopen(dev_t dev, int flag, int fmt, struct proc *p)
151515e32d5dSMike Smith {
151615e32d5dSMike Smith     return(0);
151715e32d5dSMike Smith }
151815e32d5dSMike Smith 
151915e32d5dSMike Smith static int
152015e32d5dSMike Smith acpiclose(dev_t dev, int flag, int fmt, struct proc *p)
152115e32d5dSMike Smith {
152215e32d5dSMike Smith     return(0);
152315e32d5dSMike Smith }
152415e32d5dSMike Smith 
152515e32d5dSMike Smith static int
152615e32d5dSMike Smith acpiioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p)
152715e32d5dSMike Smith {
152815e32d5dSMike Smith     struct acpi_softc		*sc;
15290ae55423SMike Smith     struct acpi_ioctl_hook	*hp;
15300ae55423SMike Smith     int				error, xerror, state;
153115e32d5dSMike Smith 
1532cb9b0d80SMike Smith     ACPI_LOCK;
1533cb9b0d80SMike Smith 
153415e32d5dSMike Smith     error = state = 0;
153515e32d5dSMike Smith     sc = dev->si_drv1;
153615e32d5dSMike Smith 
15370ae55423SMike Smith     /*
15380ae55423SMike Smith      * Scan the list of registered ioctls, looking for handlers.
15390ae55423SMike Smith      */
15400ae55423SMike Smith     if (acpi_ioctl_hooks_initted) {
15410ae55423SMike Smith 	TAILQ_FOREACH(hp, &acpi_ioctl_hooks, link) {
15420ae55423SMike Smith 	    if (hp->cmd == cmd) {
15430ae55423SMike Smith 		xerror = hp->fn(cmd, addr, hp->arg);
15440ae55423SMike Smith 		if (xerror != 0)
15450ae55423SMike Smith 		    error = xerror;
1546917d44c8SMitsuru IWASAKI 		goto out;
15470ae55423SMike Smith 	    }
15480ae55423SMike Smith 	}
15490ae55423SMike Smith     }
15500ae55423SMike Smith 
15510ae55423SMike Smith     /*
15520ae55423SMike Smith      * Core system ioctls.
15530ae55423SMike Smith      */
155415e32d5dSMike Smith     switch (cmd) {
155515e32d5dSMike Smith     case ACPIIO_ENABLE:
15560ae55423SMike Smith 	if (ACPI_FAILURE(acpi_Enable(sc)))
155715e32d5dSMike Smith 	    error = ENXIO;
155815e32d5dSMike Smith 	break;
155915e32d5dSMike Smith 
156015e32d5dSMike Smith     case ACPIIO_DISABLE:
15610ae55423SMike Smith 	if (ACPI_FAILURE(acpi_Disable(sc)))
156215e32d5dSMike Smith 	    error = ENXIO;
156315e32d5dSMike Smith 	break;
156415e32d5dSMike Smith 
156515e32d5dSMike Smith     case ACPIIO_SETSLPSTATE:
156615e32d5dSMike Smith 	if (!sc->acpi_enabled) {
156715e32d5dSMike Smith 	    error = ENXIO;
156815e32d5dSMike Smith 	    break;
156915e32d5dSMike Smith 	}
157015e32d5dSMike Smith 	state = *(int *)addr;
1571a5d1879bSMitsuru IWASAKI 	if (state >= ACPI_STATE_S0  && state <= ACPI_S_STATES_MAX) {
157215e32d5dSMike Smith 	    acpi_SetSleepState(sc, state);
157315e32d5dSMike Smith 	} else {
157415e32d5dSMike Smith 	    error = EINVAL;
157515e32d5dSMike Smith 	}
157615e32d5dSMike Smith 	break;
157715e32d5dSMike Smith 
157815e32d5dSMike Smith     default:
15790ae55423SMike Smith 	if (error == 0)
158015e32d5dSMike Smith 	    error = EINVAL;
158115e32d5dSMike Smith 	break;
158215e32d5dSMike Smith     }
1583917d44c8SMitsuru IWASAKI 
1584917d44c8SMitsuru IWASAKI out:
1585cb9b0d80SMike Smith     ACPI_UNLOCK;
158615e32d5dSMike Smith     return(error);
158715e32d5dSMike Smith }
158815e32d5dSMike Smith 
15891d073b1dSJohn Baldwin static int
15901d073b1dSJohn Baldwin acpi_sleep_state_sysctl(SYSCTL_HANDLER_ARGS)
15911d073b1dSJohn Baldwin {
15921d073b1dSJohn Baldwin     char sleep_state[10];
15931d073b1dSJohn Baldwin     int error;
15941d073b1dSJohn Baldwin     u_int new_state, old_state;
15951d073b1dSJohn Baldwin 
15961d073b1dSJohn Baldwin     old_state = *(u_int *)oidp->oid_arg1;
1597cb9b0d80SMike Smith     if (old_state > ACPI_S_STATES_MAX) {
15981d073b1dSJohn Baldwin 	strcpy(sleep_state, "unknown");
1599cb9b0d80SMike Smith     } else {
16001d073b1dSJohn Baldwin 	strncpy(sleep_state, sleep_state_names[old_state],
16011d073b1dSJohn Baldwin 		sizeof(sleep_state_names[old_state]));
1602cb9b0d80SMike Smith     }
16031d073b1dSJohn Baldwin     error = sysctl_handle_string(oidp, sleep_state, sizeof(sleep_state), req);
16041d073b1dSJohn Baldwin     if (error == 0 && req->newptr != NULL) {
1605cb9b0d80SMike Smith 	for (new_state = ACPI_STATE_S0; new_state <= ACPI_S_STATES_MAX; new_state++) {
16061d073b1dSJohn Baldwin 	    if (strncmp(sleep_state, sleep_state_names[new_state],
16071d073b1dSJohn Baldwin 			sizeof(sleep_state)) == 0)
16081d073b1dSJohn Baldwin 		break;
1609cb9b0d80SMike Smith 	}
1610cb9b0d80SMike Smith 	if ((new_state != old_state) && (new_state <= ACPI_S_STATES_MAX)) {
16111d073b1dSJohn Baldwin 	    *(u_int *)oidp->oid_arg1 = new_state;
1612cb9b0d80SMike Smith 	} else {
16131d073b1dSJohn Baldwin 	    error = EINVAL;
16141d073b1dSJohn Baldwin 	}
1615cb9b0d80SMike Smith     }
16161d073b1dSJohn Baldwin     return(error);
16171d073b1dSJohn Baldwin }
16181d073b1dSJohn Baldwin 
161915e32d5dSMike Smith #ifdef ACPI_DEBUG
16200ae55423SMike Smith /*
16210ae55423SMike Smith  * Support for parsing debug options from the kernel environment.
16220ae55423SMike Smith  *
16230ae55423SMike Smith  * Bits may be set in the AcpiDbgLayer and AcpiDbgLevel debug registers
16240ae55423SMike Smith  * by specifying the names of the bits in the debug.acpi.layer and
16250ae55423SMike Smith  * debug.acpi.level environment variables.  Bits may be unset by
16260ae55423SMike Smith  * prefixing the bit name with !.
16270ae55423SMike Smith  */
162815e32d5dSMike Smith struct debugtag
162915e32d5dSMike Smith {
163015e32d5dSMike Smith     char	*name;
163115e32d5dSMike Smith     UINT32	value;
163215e32d5dSMike Smith };
163315e32d5dSMike Smith 
163415e32d5dSMike Smith static struct debugtag	dbg_layer[] = {
1635c5ba0be4SMike Smith     {"ACPI_UTILITIES",		ACPI_UTILITIES},
1636c5ba0be4SMike Smith     {"ACPI_HARDWARE",		ACPI_HARDWARE},
1637c5ba0be4SMike Smith     {"ACPI_EVENTS",		ACPI_EVENTS},
1638c5ba0be4SMike Smith     {"ACPI_TABLES",		ACPI_TABLES},
1639c5ba0be4SMike Smith     {"ACPI_NAMESPACE",		ACPI_NAMESPACE},
1640c5ba0be4SMike Smith     {"ACPI_PARSER",		ACPI_PARSER},
1641c5ba0be4SMike Smith     {"ACPI_DISPATCHER",		ACPI_DISPATCHER},
1642c5ba0be4SMike Smith     {"ACPI_EXECUTER",		ACPI_EXECUTER},
1643c5ba0be4SMike Smith     {"ACPI_RESOURCES",		ACPI_RESOURCES},
16444c1cdee6SMike Smith     {"ACPI_DEBUGGER",		ACPI_DEBUGGER},
16454c1cdee6SMike Smith     {"ACPI_OS_SERVICES",	ACPI_OS_SERVICES},
16464c1cdee6SMike Smith 
1647cb9b0d80SMike Smith     {"ACPI_BUS",		ACPI_BUS},
16484c1cdee6SMike Smith     {"ACPI_SYSTEM",		ACPI_SYSTEM},
1649cb9b0d80SMike Smith     {"ACPI_POWER",		ACPI_POWER},
1650cb9b0d80SMike Smith     {"ACPI_EC", 		ACPI_EC},
1651c5ba0be4SMike Smith     {"ACPI_AC_ADAPTER",		ACPI_AC_ADAPTER},
1652c5ba0be4SMike Smith     {"ACPI_BATTERY",		ACPI_BATTERY},
1653c5ba0be4SMike Smith     {"ACPI_BUTTON",		ACPI_BUTTON},
16544c1cdee6SMike Smith     {"ACPI_PROCESSOR",		ACPI_PROCESSOR},
1655cb9b0d80SMike Smith     {"ACPI_THERMAL",		ACPI_THERMAL},
16564c1cdee6SMike Smith     {"ACPI_FAN",		ACPI_FAN},
16574c1cdee6SMike Smith 
1658c5ba0be4SMike Smith     {"ACPI_ALL_COMPONENTS",	ACPI_ALL_COMPONENTS},
165915e32d5dSMike Smith     {NULL, 0}
166015e32d5dSMike Smith };
166115e32d5dSMike Smith 
166215e32d5dSMike Smith static struct debugtag dbg_level[] = {
16634c1cdee6SMike Smith     {"ACPI_LV_OK",		ACPI_LV_OK},
16644c1cdee6SMike Smith     {"ACPI_LV_INFO",		ACPI_LV_INFO},
16654c1cdee6SMike Smith     {"ACPI_LV_WARN",		ACPI_LV_WARN},
16664c1cdee6SMike Smith     {"ACPI_LV_ERROR",		ACPI_LV_ERROR},
16674c1cdee6SMike Smith     {"ACPI_LV_FATAL",		ACPI_LV_FATAL},
16684c1cdee6SMike Smith     {"ACPI_LV_DEBUG_OBJECT",	ACPI_LV_DEBUG_OBJECT},
16694c1cdee6SMike Smith     {"ACPI_LV_ALL_EXCEPTIONS",	ACPI_LV_ALL_EXCEPTIONS},
16704c1cdee6SMike Smith     {"ACPI_LV_THREADS",		ACPI_LV_THREADS},
16714c1cdee6SMike Smith     {"ACPI_LV_PARSE",		ACPI_LV_PARSE},
16724c1cdee6SMike Smith     {"ACPI_LV_DISPATCH",	ACPI_LV_DISPATCH},
16734c1cdee6SMike Smith     {"ACPI_LV_LOAD",		ACPI_LV_LOAD},
16744c1cdee6SMike Smith     {"ACPI_LV_EXEC",		ACPI_LV_EXEC},
16754c1cdee6SMike Smith     {"ACPI_LV_NAMES",		ACPI_LV_NAMES},
16764c1cdee6SMike Smith     {"ACPI_LV_OPREGION",	ACPI_LV_OPREGION},
16774c1cdee6SMike Smith     {"ACPI_LV_BFIELD",		ACPI_LV_BFIELD},
16784c1cdee6SMike Smith     {"ACPI_LV_TRASH",		ACPI_LV_TRASH},
16794c1cdee6SMike Smith     {"ACPI_LV_TABLES",		ACPI_LV_TABLES},
16804c1cdee6SMike Smith     {"ACPI_LV_FUNCTIONS",	ACPI_LV_FUNCTIONS},
16814c1cdee6SMike Smith     {"ACPI_LV_VALUES",		ACPI_LV_VALUES},
16824c1cdee6SMike Smith     {"ACPI_LV_OBJECTS",		ACPI_LV_OBJECTS},
16834c1cdee6SMike Smith     {"ACPI_LV_ALLOCATIONS",	ACPI_LV_ALLOCATIONS},
16844c1cdee6SMike Smith     {"ACPI_LV_RESOURCES",	ACPI_LV_RESOURCES},
16854c1cdee6SMike Smith     {"ACPI_LV_IO",		ACPI_LV_IO},
16864c1cdee6SMike Smith     {"ACPI_LV_INTERRUPTS",	ACPI_LV_INTERRUPTS},
16874c1cdee6SMike Smith     {"ACPI_LV_USER_REQUESTS",	ACPI_LV_USER_REQUESTS},
16884c1cdee6SMike Smith     {"ACPI_LV_PACKAGE",		ACPI_LV_PACKAGE},
16894c1cdee6SMike Smith     {"ACPI_LV_MUTEX",		ACPI_LV_MUTEX},
16904c1cdee6SMike Smith     {"ACPI_LV_INIT",		ACPI_LV_INIT},
16914c1cdee6SMike Smith     {"ACPI_LV_ALL",		ACPI_LV_ALL},
16924c1cdee6SMike Smith     {"ACPI_DB_AML_DISASSEMBLE",	ACPI_DB_AML_DISASSEMBLE},
16934c1cdee6SMike Smith     {"ACPI_DB_VERBOSE_INFO",	ACPI_DB_VERBOSE_INFO},
16944c1cdee6SMike Smith     {"ACPI_DB_FULL_TABLES",	ACPI_DB_FULL_TABLES},
16954c1cdee6SMike Smith     {"ACPI_DB_EVENTS",		ACPI_DB_EVENTS},
16964c1cdee6SMike Smith     {"ACPI_DB_VERBOSE",		ACPI_DB_VERBOSE},
169715e32d5dSMike Smith     {NULL, 0}
169815e32d5dSMike Smith };
169915e32d5dSMike Smith 
170015e32d5dSMike Smith static void
170115e32d5dSMike Smith acpi_parse_debug(char *cp, struct debugtag *tag, UINT32 *flag)
170215e32d5dSMike Smith {
170315e32d5dSMike Smith     char	*ep;
170415e32d5dSMike Smith     int		i, l;
17050ae55423SMike Smith     int		set;
170615e32d5dSMike Smith 
170715e32d5dSMike Smith     while (*cp) {
170815e32d5dSMike Smith 	if (isspace(*cp)) {
170915e32d5dSMike Smith 	    cp++;
171015e32d5dSMike Smith 	    continue;
171115e32d5dSMike Smith 	}
171215e32d5dSMike Smith 	ep = cp;
171315e32d5dSMike Smith 	while (*ep && !isspace(*ep))
171415e32d5dSMike Smith 	    ep++;
17150ae55423SMike Smith 	if (*cp == '!') {
17160ae55423SMike Smith 	    set = 0;
17170ae55423SMike Smith 	    cp++;
17180ae55423SMike Smith 	    if (cp == ep)
17190ae55423SMike Smith 		continue;
17200ae55423SMike Smith 	} else {
17210ae55423SMike Smith 	    set = 1;
17220ae55423SMike Smith 	}
172315e32d5dSMike Smith 	l = ep - cp;
172415e32d5dSMike Smith 	for (i = 0; tag[i].name != NULL; i++) {
172515e32d5dSMike Smith 	    if (!strncmp(cp, tag[i].name, l)) {
17260ae55423SMike Smith 		if (set) {
172715e32d5dSMike Smith 		    *flag |= tag[i].value;
17280ae55423SMike Smith 		} else {
17290ae55423SMike Smith 		    *flag &= ~tag[i].value;
17300ae55423SMike Smith 		}
173115e32d5dSMike Smith 		printf("ACPI_DEBUG: set '%s'\n", tag[i].name);
173215e32d5dSMike Smith 	    }
173315e32d5dSMike Smith 	}
173415e32d5dSMike Smith 	cp = ep;
173515e32d5dSMike Smith     }
173615e32d5dSMike Smith }
173715e32d5dSMike Smith 
173815e32d5dSMike Smith static void
17392a4ac806SMike Smith acpi_set_debugging(void *junk)
174015e32d5dSMike Smith {
174115e32d5dSMike Smith     char	*cp;
174215e32d5dSMike Smith 
17430ae55423SMike Smith     AcpiDbgLayer = 0;
17440ae55423SMike Smith     AcpiDbgLevel = 0;
174515e32d5dSMike Smith     if ((cp = getenv("debug.acpi.layer")) != NULL)
174615e32d5dSMike Smith 	acpi_parse_debug(cp, &dbg_layer[0], &AcpiDbgLayer);
174715e32d5dSMike Smith     if ((cp = getenv("debug.acpi.level")) != NULL)
174815e32d5dSMike Smith 	acpi_parse_debug(cp, &dbg_level[0], &AcpiDbgLevel);
17490ae55423SMike Smith 
17500ae55423SMike Smith     printf("ACPI debug layer 0x%x  debug level 0x%x\n", AcpiDbgLayer, AcpiDbgLevel);
175115e32d5dSMike Smith }
17522a4ac806SMike Smith SYSINIT(acpi_debugging, SI_SUB_TUNABLES, SI_ORDER_ANY, acpi_set_debugging, NULL);
175315e32d5dSMike Smith #endif
1754