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 30dad97feeSDavid E. O'Brien #include <sys/cdefs.h> 31dad97feeSDavid E. O'Brien __FBSDID("$FreeBSD$"); 32dad97feeSDavid E. O'Brien 3315e32d5dSMike Smith #include "opt_acpi.h" 3415e32d5dSMike Smith #include <sys/param.h> 3515e32d5dSMike Smith #include <sys/kernel.h> 36fb919e4dSMark Murray #include <sys/proc.h> 37a89fcf28STakanori Watanabe #include <sys/fcntl.h> 3815e32d5dSMike Smith #include <sys/malloc.h> 39fe12f24bSPoul-Henning Kamp #include <sys/module.h> 4015e32d5dSMike Smith #include <sys/bus.h> 4115e32d5dSMike Smith #include <sys/conf.h> 4215e32d5dSMike Smith #include <sys/ioccom.h> 4315e32d5dSMike Smith #include <sys/reboot.h> 4415e32d5dSMike Smith #include <sys/sysctl.h> 4515e32d5dSMike Smith #include <sys/ctype.h> 461611ea87SMitsuru IWASAKI #include <sys/linker.h> 47f9390180SMitsuru IWASAKI #include <sys/power.h> 4854f6bca0SNate Lawson #include <sys/sbuf.h> 49eeb3a05fSNate Lawson #include <sys/smp.h> 5015e32d5dSMike Smith 5115e32d5dSMike Smith #include <machine/clock.h> 5215e32d5dSMike Smith #include <machine/resource.h> 53dc750869SNate Lawson #include <machine/bus.h> 54dc750869SNate Lawson #include <sys/rman.h> 55bc0f2195SMike Smith #include <isa/isavar.h> 56c796e27bSNate Lawson #include <isa/pnpvar.h> 57bc0f2195SMike Smith 5815e32d5dSMike Smith #include "acpi.h" 5915e32d5dSMike Smith #include <dev/acpica/acpivar.h> 6015e32d5dSMike Smith #include <dev/acpica/acpiio.h> 619b937d48SNate Lawson #include <contrib/dev/acpica/acnamesp.h> 6215e32d5dSMike Smith 6310ce62b9SNate Lawson #include "pci_if.h" 6410ce62b9SNate Lawson #include <dev/pci/pcivar.h> 6510ce62b9SNate Lawson #include <dev/pci/pci_private.h> 6610ce62b9SNate Lawson 6715e32d5dSMike Smith MALLOC_DEFINE(M_ACPIDEV, "acpidev", "ACPI devices"); 6815e32d5dSMike Smith 69be2b1797SNate Lawson /* Hooks for the ACPI CA debugging infrastructure */ 70cb9b0d80SMike Smith #define _COMPONENT ACPI_BUS 71b53f2771SMike Smith ACPI_MODULE_NAME("ACPI") 720ae55423SMike Smith 7315e32d5dSMike Smith static d_open_t acpiopen; 7415e32d5dSMike Smith static d_close_t acpiclose; 7515e32d5dSMike Smith static d_ioctl_t acpiioctl; 7615e32d5dSMike Smith 7715e32d5dSMike Smith static struct cdevsw acpi_cdevsw = { 78dc08ffecSPoul-Henning Kamp .d_version = D_VERSION, 797ac40f5fSPoul-Henning Kamp .d_open = acpiopen, 807ac40f5fSPoul-Henning Kamp .d_close = acpiclose, 817ac40f5fSPoul-Henning Kamp .d_ioctl = acpiioctl, 827ac40f5fSPoul-Henning Kamp .d_name = "acpi", 8315e32d5dSMike Smith }; 8415e32d5dSMike Smith 85346eda4fSNate Lawson /* Global mutex for locking access to the ACPI subsystem. */ 86cb9b0d80SMike Smith struct mtx acpi_mutex; 87cb9b0d80SMike Smith 8889fb5af8SNate Lawson /* Bitmap of device quirks. */ 8989fb5af8SNate Lawson int acpi_quirks; 9089fb5af8SNate Lawson 916d63101aSMike Smith static int acpi_modevent(struct module *mod, int event, void *junk); 9215e32d5dSMike Smith static void acpi_identify(driver_t *driver, device_t parent); 9315e32d5dSMike Smith static int acpi_probe(device_t dev); 9415e32d5dSMike Smith static int acpi_attach(device_t dev); 9510ce62b9SNate Lawson static int acpi_suspend(device_t dev); 9610ce62b9SNate Lawson static int acpi_resume(device_t dev); 97169b539aSNate Lawson static int acpi_shutdown(device_t dev); 98be2b1797SNate Lawson static device_t acpi_add_child(device_t bus, int order, const char *name, 99be2b1797SNate Lawson int unit); 10015e32d5dSMike Smith static int acpi_print_child(device_t bus, device_t child); 10110ce62b9SNate Lawson static void acpi_probe_nomatch(device_t bus, device_t child); 10210ce62b9SNate Lawson static void acpi_driver_added(device_t dev, driver_t *driver); 103be2b1797SNate Lawson static int acpi_read_ivar(device_t dev, device_t child, int index, 104be2b1797SNate Lawson uintptr_t *result); 105be2b1797SNate Lawson static int acpi_write_ivar(device_t dev, device_t child, int index, 106be2b1797SNate Lawson uintptr_t value); 10791233413SNate Lawson static struct resource_list *acpi_get_rlist(device_t dev, device_t child); 108adad4744SNate Lawson static int acpi_sysres_alloc(device_t dev); 109adad4744SNate Lawson static struct resource_list_entry *acpi_sysres_find(device_t dev, int type, 110adad4744SNate Lawson u_long addr); 111be2b1797SNate Lawson static struct resource *acpi_alloc_resource(device_t bus, device_t child, 112be2b1797SNate Lawson int type, int *rid, u_long start, u_long end, 113be2b1797SNate Lawson u_long count, u_int flags); 114be2b1797SNate Lawson static int acpi_release_resource(device_t bus, device_t child, int type, 115be2b1797SNate Lawson int rid, struct resource *r); 1161e4925e8SNate Lawson static uint32_t acpi_isa_get_logicalid(device_t dev); 1171e4925e8SNate Lawson static int acpi_isa_get_compatid(device_t dev, uint32_t *cids, int count); 118ce619b2eSNate Lawson static char *acpi_device_id_probe(device_t bus, device_t dev, char **ids); 119ce619b2eSNate Lawson static ACPI_STATUS acpi_device_eval_obj(device_t bus, device_t dev, 120ce619b2eSNate Lawson ACPI_STRING pathname, ACPI_OBJECT_LIST *parameters, 121ce619b2eSNate Lawson ACPI_BUFFER *ret); 12210ce62b9SNate Lawson static int acpi_device_pwr_for_sleep(device_t bus, device_t dev, 12310ce62b9SNate Lawson int *dstate); 124df8d2a32SNate Lawson static ACPI_STATUS acpi_device_scan_cb(ACPI_HANDLE h, UINT32 level, 125df8d2a32SNate Lawson void *context, void **retval); 126df8d2a32SNate Lawson static ACPI_STATUS acpi_device_scan_children(device_t bus, device_t dev, 127df8d2a32SNate Lawson int max_depth, acpi_scan_cb_t user_fn, void *arg); 12810ce62b9SNate Lawson static int acpi_set_powerstate_method(device_t bus, device_t child, 12910ce62b9SNate Lawson int state); 130be2b1797SNate Lawson static int acpi_isa_pnp_probe(device_t bus, device_t child, 131be2b1797SNate Lawson struct isa_pnp_id *ids); 13215e32d5dSMike Smith static void acpi_probe_children(device_t bus); 133b82ca9a9SNate Lawson static int acpi_probe_order(ACPI_HANDLE handle, int *order); 134be2b1797SNate Lawson static ACPI_STATUS acpi_probe_child(ACPI_HANDLE handle, UINT32 level, 135be2b1797SNate Lawson void *context, void **status); 136ce619b2eSNate Lawson static BOOLEAN acpi_MatchHid(ACPI_HANDLE h, const char *hid); 13715e32d5dSMike Smith static void acpi_shutdown_final(void *arg, int howto); 13813d4f7baSMitsuru IWASAKI static void acpi_enable_fixed_events(struct acpi_softc *sc); 139d4b9ff91SNate Lawson static int acpi_wake_sleep_prep(ACPI_HANDLE handle, int sstate); 140d4b9ff91SNate Lawson static int acpi_wake_run_prep(ACPI_HANDLE handle, int sstate); 141d4b9ff91SNate Lawson static int acpi_wake_prep_walk(int sstate); 14288a79fc0SNate Lawson static int acpi_wake_sysctl_walk(device_t dev); 14388a79fc0SNate Lawson static int acpi_wake_set_sysctl(SYSCTL_HANDLER_ARGS); 14415e32d5dSMike Smith static void acpi_system_eventhandler_sleep(void *arg, int state); 14515e32d5dSMike Smith static void acpi_system_eventhandler_wakeup(void *arg, int state); 146d75de536SMitsuru IWASAKI static int acpi_supported_sleep_state_sysctl(SYSCTL_HANDLER_ARGS); 1471d073b1dSJohn Baldwin static int acpi_sleep_state_sysctl(SYSCTL_HANDLER_ARGS); 148f9390180SMitsuru IWASAKI static int acpi_pm_func(u_long cmd, void *arg, ...); 149879d6c23STakanori Watanabe static int acpi_child_location_str_method(device_t acdev, device_t child, 150879d6c23STakanori Watanabe char *buf, size_t buflen); 151879d6c23STakanori Watanabe static int acpi_child_pnpinfo_str_method(device_t acdev, device_t child, 152879d6c23STakanori Watanabe char *buf, size_t buflen); 153879d6c23STakanori Watanabe 15415e32d5dSMike Smith static device_method_t acpi_methods[] = { 15515e32d5dSMike Smith /* Device interface */ 15615e32d5dSMike Smith DEVMETHOD(device_identify, acpi_identify), 15715e32d5dSMike Smith DEVMETHOD(device_probe, acpi_probe), 15815e32d5dSMike Smith DEVMETHOD(device_attach, acpi_attach), 159169b539aSNate Lawson DEVMETHOD(device_shutdown, acpi_shutdown), 16056a70eadSNate Lawson DEVMETHOD(device_detach, bus_generic_detach), 16110ce62b9SNate Lawson DEVMETHOD(device_suspend, acpi_suspend), 16210ce62b9SNate Lawson DEVMETHOD(device_resume, acpi_resume), 16315e32d5dSMike Smith 16415e32d5dSMike Smith /* Bus interface */ 16515e32d5dSMike Smith DEVMETHOD(bus_add_child, acpi_add_child), 16615e32d5dSMike Smith DEVMETHOD(bus_print_child, acpi_print_child), 16710ce62b9SNate Lawson DEVMETHOD(bus_probe_nomatch, acpi_probe_nomatch), 16810ce62b9SNate Lawson DEVMETHOD(bus_driver_added, acpi_driver_added), 16915e32d5dSMike Smith DEVMETHOD(bus_read_ivar, acpi_read_ivar), 17015e32d5dSMike Smith DEVMETHOD(bus_write_ivar, acpi_write_ivar), 17191233413SNate Lawson DEVMETHOD(bus_get_resource_list, acpi_get_rlist), 17291233413SNate Lawson DEVMETHOD(bus_set_resource, bus_generic_rl_set_resource), 17391233413SNate Lawson DEVMETHOD(bus_get_resource, bus_generic_rl_get_resource), 17415e32d5dSMike Smith DEVMETHOD(bus_alloc_resource, acpi_alloc_resource), 17515e32d5dSMike Smith DEVMETHOD(bus_release_resource, acpi_release_resource), 176879d6c23STakanori Watanabe DEVMETHOD(bus_child_pnpinfo_str, acpi_child_pnpinfo_str_method), 177879d6c23STakanori Watanabe DEVMETHOD(bus_child_location_str, acpi_child_location_str_method), 17815e32d5dSMike Smith DEVMETHOD(bus_activate_resource, bus_generic_activate_resource), 17915e32d5dSMike Smith DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource), 18015e32d5dSMike Smith DEVMETHOD(bus_setup_intr, bus_generic_setup_intr), 18115e32d5dSMike Smith DEVMETHOD(bus_teardown_intr, bus_generic_teardown_intr), 18215e32d5dSMike Smith 183ce619b2eSNate Lawson /* ACPI bus */ 184ce619b2eSNate Lawson DEVMETHOD(acpi_id_probe, acpi_device_id_probe), 185ce619b2eSNate Lawson DEVMETHOD(acpi_evaluate_object, acpi_device_eval_obj), 18610ce62b9SNate Lawson DEVMETHOD(acpi_pwr_for_sleep, acpi_device_pwr_for_sleep), 187df8d2a32SNate Lawson DEVMETHOD(acpi_scan_children, acpi_device_scan_children), 188ce619b2eSNate Lawson 18910ce62b9SNate Lawson /* PCI emulation */ 19010ce62b9SNate Lawson DEVMETHOD(pci_set_powerstate, acpi_set_powerstate_method), 19110ce62b9SNate Lawson 192bc0f2195SMike Smith /* ISA emulation */ 193bc0f2195SMike Smith DEVMETHOD(isa_pnp_probe, acpi_isa_pnp_probe), 194bc0f2195SMike Smith 19515e32d5dSMike Smith {0, 0} 19615e32d5dSMike Smith }; 19715e32d5dSMike Smith 19815e32d5dSMike Smith static driver_t acpi_driver = { 19915e32d5dSMike Smith "acpi", 20015e32d5dSMike Smith acpi_methods, 20115e32d5dSMike Smith sizeof(struct acpi_softc), 20215e32d5dSMike Smith }; 20315e32d5dSMike Smith 2043273b005SMike Smith static devclass_t acpi_devclass; 2056d63101aSMike Smith DRIVER_MODULE(acpi, nexus, acpi_driver, acpi_devclass, acpi_modevent, 0); 206a4ecd543SNate Lawson MODULE_VERSION(acpi, 1); 20715e32d5dSMike Smith 20815e2f34fSNate Lawson ACPI_SERIAL_DECL(acpi, "ACPI root bus"); 20915e2f34fSNate Lawson 210adad4744SNate Lawson /* Local pools for managing system resources for ACPI child devices. */ 211adad4744SNate Lawson static struct rman acpi_rman_io, acpi_rman_mem; 212adad4744SNate Lawson 213bee4aa4aSNate Lawson #define ACPI_MINIMUM_AWAKETIME 5 214bee4aa4aSNate Lawson 215865b8d0bSNate Lawson static const char* sleep_state_names[] = { 216865b8d0bSNate Lawson "S0", "S1", "S2", "S3", "S4", "S5", "NONE"}; 217865b8d0bSNate Lawson 2181d7b121cSNate Lawson SYSCTL_NODE(_debug, OID_AUTO, acpi, CTLFLAG_RW, NULL, "ACPI debugging"); 2191d7b121cSNate Lawson static char acpi_ca_version[12]; 2201d7b121cSNate Lawson SYSCTL_STRING(_debug_acpi, OID_AUTO, acpi_ca_version, CTLFLAG_RD, 2211d7b121cSNate Lawson acpi_ca_version, 0, "Version of Intel ACPI-CA"); 22215e32d5dSMike Smith 22315e32d5dSMike Smith /* 224413081d7SNate Lawson * Allow override of whether methods execute in parallel or not. 225c9b8d77dSNate Lawson * Enable this for serial behavior, which fixes "AE_ALREADY_EXISTS" 226c9b8d77dSNate Lawson * errors for AML that really can't handle parallel method execution. 227c9b8d77dSNate Lawson * It is off by default since this breaks recursive methods and 228c9b8d77dSNate Lawson * some IBMs use such code. 229413081d7SNate Lawson */ 230c9b8d77dSNate Lawson static int acpi_serialize_methods; 231413081d7SNate Lawson TUNABLE_INT("hw.acpi.serialize_methods", &acpi_serialize_methods); 232413081d7SNate Lawson 23310ce62b9SNate Lawson /* Power devices off and on in suspend and resume. XXX Remove once tested. */ 23410ce62b9SNate Lawson static int acpi_do_powerstate = 1; 23510ce62b9SNate Lawson TUNABLE_INT("debug.acpi.do_powerstate", &acpi_do_powerstate); 23610ce62b9SNate Lawson SYSCTL_INT(_debug_acpi, OID_AUTO, do_powerstate, CTLFLAG_RW, 23710ce62b9SNate Lawson &acpi_do_powerstate, 1, "Turn off devices when suspending."); 23810ce62b9SNate Lawson 23939da3eb3SNate Lawson /* Allow users to override quirks. */ 24039da3eb3SNate Lawson TUNABLE_INT("debug.acpi.quirks", &acpi_quirks); 24139da3eb3SNate Lawson 242c9b8d77dSNate Lawson /* 2436d63101aSMike Smith * ACPI can only be loaded as a module by the loader; activating it after 2446d63101aSMike Smith * system bootstrap time is not useful, and can be fatal to the system. 245be2b1797SNate Lawson * It also cannot be unloaded, since the entire system bus heirarchy hangs 246be2b1797SNate Lawson * off it. 2476d63101aSMike Smith */ 2486d63101aSMike Smith static int 2496d63101aSMike Smith acpi_modevent(struct module *mod, int event, void *junk) 2506d63101aSMike Smith { 2516d63101aSMike Smith switch (event) { 2526d63101aSMike Smith case MOD_LOAD: 25387b45ed5SMitsuru IWASAKI if (!cold) { 25487b45ed5SMitsuru IWASAKI printf("The ACPI driver cannot be loaded after boot.\n"); 2556d63101aSMike Smith return (EPERM); 25687b45ed5SMitsuru IWASAKI } 2576d63101aSMike Smith break; 2586d63101aSMike Smith case MOD_UNLOAD: 259f9390180SMitsuru IWASAKI if (!cold && power_pm_get_type() == POWER_PM_TYPE_ACPI) 2606d63101aSMike Smith return (EBUSY); 261f9390180SMitsuru IWASAKI break; 2626d63101aSMike Smith default: 2636d63101aSMike Smith break; 2646d63101aSMike Smith } 2656d63101aSMike Smith return (0); 2666d63101aSMike Smith } 2676d63101aSMike Smith 2686d63101aSMike Smith /* 269bbc2815cSJohn Baldwin * Perform early initialization. 27015e32d5dSMike Smith */ 271bbc2815cSJohn Baldwin ACPI_STATUS 272bbc2815cSJohn Baldwin acpi_Startup(void) 27315e32d5dSMike Smith { 27489fb5af8SNate Lawson static int started = 0; 27589fb5af8SNate Lawson int error, val; 27615e32d5dSMike Smith 2771b8c233dSPeter Pentchev ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 2781b8c233dSPeter Pentchev 279bee4aa4aSNate Lawson /* Only run the startup code once. The MADT driver also calls this. */ 280bbc2815cSJohn Baldwin if (started) 28189fb5af8SNate Lawson return_VALUE (0); 282bbc2815cSJohn Baldwin started = 1; 28315e32d5dSMike Smith 284be2b1797SNate Lawson /* Initialise the ACPI mutex */ 2856008862bSJohn Baldwin mtx_init(&acpi_mutex, "ACPI global lock", NULL, MTX_DEF); 286cb9b0d80SMike Smith 287413081d7SNate Lawson /* 288413081d7SNate Lawson * Set the globals from our tunables. This is needed because ACPI-CA 289f3fc4f8bSNate Lawson * uses UINT8 for some values and we have no tunable_byte. 290413081d7SNate Lawson */ 291834a79deSNate Lawson AcpiGbl_AllMethodsSerialized = acpi_serialize_methods; 292834a79deSNate Lawson AcpiGbl_EnableInterpreterSlack = TRUE; 293413081d7SNate Lawson 294be2b1797SNate Lawson /* Start up the ACPI CA subsystem. */ 295b53f2771SMike Smith if (ACPI_FAILURE(error = AcpiInitializeSubsystem())) { 296bfae45aaSMike Smith printf("ACPI: initialisation failed: %s\n", AcpiFormatException(error)); 297bbc2815cSJohn Baldwin return_VALUE (error); 29815e32d5dSMike Smith } 2991611ea87SMitsuru IWASAKI 300b53f2771SMike Smith if (ACPI_FAILURE(error = AcpiLoadTables())) { 301bfae45aaSMike Smith printf("ACPI: table load failed: %s\n", AcpiFormatException(error)); 30289fb5af8SNate Lawson AcpiTerminate(); 303bbc2815cSJohn Baldwin return_VALUE (error); 30415e32d5dSMike Smith } 3053184cf5aSNate Lawson 30689fb5af8SNate Lawson /* Set up any quirks we have for this system. */ 30739da3eb3SNate Lawson if (acpi_quirks == 0) 30889fb5af8SNate Lawson acpi_table_quirks(&acpi_quirks); 30989fb5af8SNate Lawson 31039da3eb3SNate Lawson /* If the user manually set the disabled hint to 0, force-enable ACPI. */ 31189fb5af8SNate Lawson if (resource_int_value("acpi", 0, "disabled", &val) == 0 && val == 0) 31289fb5af8SNate Lawson acpi_quirks &= ~ACPI_Q_BROKEN; 31389fb5af8SNate Lawson if (acpi_quirks & ACPI_Q_BROKEN) { 31489fb5af8SNate Lawson printf("ACPI disabled by blacklist. Contact your BIOS vendor.\n"); 31589fb5af8SNate Lawson AcpiTerminate(); 3164e376d58SNate Lawson return_VALUE (AE_ERROR); 31789fb5af8SNate Lawson } 3183184cf5aSNate Lawson 319bbc2815cSJohn Baldwin return_VALUE (AE_OK); 320bbc2815cSJohn Baldwin } 321bbc2815cSJohn Baldwin 322bbc2815cSJohn Baldwin /* 323bbc2815cSJohn Baldwin * Detect ACPI, perform early initialisation 324bbc2815cSJohn Baldwin */ 325bbc2815cSJohn Baldwin static void 326bbc2815cSJohn Baldwin acpi_identify(driver_t *driver, device_t parent) 327bbc2815cSJohn Baldwin { 328bbc2815cSJohn Baldwin device_t child; 329bbc2815cSJohn Baldwin 330bbc2815cSJohn Baldwin ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 331bbc2815cSJohn Baldwin 332bbc2815cSJohn Baldwin if (!cold) 333bbc2815cSJohn Baldwin return_VOID; 334bbc2815cSJohn Baldwin 335bbc2815cSJohn Baldwin /* Check that we haven't been disabled with a hint. */ 336bbc2815cSJohn Baldwin if (resource_disabled("acpi", 0)) 337bbc2815cSJohn Baldwin return_VOID; 338bbc2815cSJohn Baldwin 339bbc2815cSJohn Baldwin /* Make sure we're not being doubly invoked. */ 340bbc2815cSJohn Baldwin if (device_find_child(parent, "acpi", 0) != NULL) 341bbc2815cSJohn Baldwin return_VOID; 342bbc2815cSJohn Baldwin 343bbc2815cSJohn Baldwin /* Initialize ACPI-CA. */ 344bbc2815cSJohn Baldwin if (ACPI_FAILURE(acpi_Startup())) 345bbc2815cSJohn Baldwin return_VOID; 34615e32d5dSMike Smith 3474e376d58SNate Lawson snprintf(acpi_ca_version, sizeof(acpi_ca_version), "%#x", ACPI_CA_VERSION); 3484e376d58SNate Lawson 349be2b1797SNate Lawson /* Attach the actual ACPI device. */ 35015e32d5dSMike Smith if ((child = BUS_ADD_CHILD(parent, 0, "acpi", 0)) == NULL) { 351bee4aa4aSNate Lawson device_printf(parent, "device_identify failed\n"); 3520ae55423SMike Smith return_VOID; 35315e32d5dSMike Smith } 35415e32d5dSMike Smith } 35515e32d5dSMike Smith 35615e32d5dSMike Smith /* 357bee4aa4aSNate Lawson * Fetch some descriptive data from ACPI to put in our attach message. 35815e32d5dSMike Smith */ 35915e32d5dSMike Smith static int 36015e32d5dSMike Smith acpi_probe(device_t dev) 36115e32d5dSMike Smith { 36215e32d5dSMike Smith ACPI_TABLE_HEADER th; 36315e32d5dSMike Smith char buf[20]; 36415e32d5dSMike Smith int error; 3652ccd1cacSNate Lawson struct sbuf sb; 3662ccd1cacSNate Lawson ACPI_STATUS status; 36715e32d5dSMike Smith 368b4a05238SPeter Wemm ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 369f9390180SMitsuru IWASAKI 370f9390180SMitsuru IWASAKI if (power_pm_get_type() != POWER_PM_TYPE_NONE && 371f9390180SMitsuru IWASAKI power_pm_get_type() != POWER_PM_TYPE_ACPI) { 372bee4aa4aSNate Lawson device_printf(dev, "probe failed, other PM system enabled.\n"); 373f9390180SMitsuru IWASAKI return_VALUE (ENXIO); 374f9390180SMitsuru IWASAKI } 375f9390180SMitsuru IWASAKI 376b53f2771SMike Smith if (ACPI_FAILURE(status = AcpiGetTableHeader(ACPI_TABLE_XSDT, 1, &th))) { 377be2b1797SNate Lawson device_printf(dev, "couldn't get XSDT header: %s\n", 378be2b1797SNate Lawson AcpiFormatException(status)); 379cb9b0d80SMike Smith error = ENXIO; 380cb9b0d80SMike Smith } else { 3812ccd1cacSNate Lawson sbuf_new(&sb, buf, sizeof(buf), SBUF_FIXEDLEN); 3822ccd1cacSNate Lawson sbuf_bcat(&sb, th.OemId, 6); 3832ccd1cacSNate Lawson sbuf_trim(&sb); 3842ccd1cacSNate Lawson sbuf_putc(&sb, ' '); 3852ccd1cacSNate Lawson sbuf_bcat(&sb, th.OemTableId, 8); 3862ccd1cacSNate Lawson sbuf_trim(&sb); 3872ccd1cacSNate Lawson sbuf_finish(&sb); 3882ccd1cacSNate Lawson device_set_desc_copy(dev, sbuf_data(&sb)); 3892ccd1cacSNate Lawson sbuf_delete(&sb); 390cb9b0d80SMike Smith error = 0; 391cb9b0d80SMike Smith } 392bee4aa4aSNate Lawson 393cb9b0d80SMike Smith return_VALUE (error); 39415e32d5dSMike Smith } 39515e32d5dSMike Smith 39615e32d5dSMike Smith static int 39715e32d5dSMike Smith acpi_attach(device_t dev) 39815e32d5dSMike Smith { 39915e32d5dSMike Smith struct acpi_softc *sc; 400cb9b0d80SMike Smith ACPI_STATUS status; 401ea27c63eSNate Lawson int error, state; 40232d18aa5SMike Smith UINT32 flags; 403ea27c63eSNate Lawson UINT8 TypeA, TypeB; 404498d464fSMitsuru IWASAKI char *env; 40515e32d5dSMike Smith 406b4a05238SPeter Wemm ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 407bee4aa4aSNate Lawson 40815e32d5dSMike Smith sc = device_get_softc(dev); 40915e32d5dSMike Smith sc->acpi_dev = dev; 41015e32d5dSMike Smith 41191233413SNate Lawson /* Initialize resource manager. */ 41291233413SNate Lawson acpi_rman_io.rm_type = RMAN_ARRAY; 41391233413SNate Lawson acpi_rman_io.rm_start = 0; 41491233413SNate Lawson acpi_rman_io.rm_end = 0xffff; 41591233413SNate Lawson acpi_rman_io.rm_descr = "I/O ports"; 41691233413SNate Lawson if (rman_init(&acpi_rman_io) != 0) 41791233413SNate Lawson panic("acpi rman_init IO ports failed"); 41891233413SNate Lawson acpi_rman_mem.rm_type = RMAN_ARRAY; 41991233413SNate Lawson acpi_rman_mem.rm_start = 0; 42091233413SNate Lawson acpi_rman_mem.rm_end = ~0ul; 42191233413SNate Lawson acpi_rman_mem.rm_descr = "I/O memory addresses"; 42291233413SNate Lawson if (rman_init(&acpi_rman_mem) != 0) 42391233413SNate Lawson panic("acpi rman_init memory failed"); 42491233413SNate Lawson 425be2b1797SNate Lawson /* Install the default address space handlers. */ 426cb9b0d80SMike Smith error = ENXIO; 427be2b1797SNate Lawson status = AcpiInstallAddressSpaceHandler(ACPI_ROOT_OBJECT, 428be2b1797SNate Lawson ACPI_ADR_SPACE_SYSTEM_MEMORY, ACPI_DEFAULT_HANDLER, NULL, NULL); 429be2b1797SNate Lawson if (ACPI_FAILURE(status)) { 430be2b1797SNate Lawson device_printf(dev, "Could not initialise SystemMemory handler: %s\n", 431be2b1797SNate Lawson AcpiFormatException(status)); 432cb9b0d80SMike Smith goto out; 43315e32d5dSMike Smith } 434be2b1797SNate Lawson status = AcpiInstallAddressSpaceHandler(ACPI_ROOT_OBJECT, 435be2b1797SNate Lawson ACPI_ADR_SPACE_SYSTEM_IO, ACPI_DEFAULT_HANDLER, NULL, NULL); 436be2b1797SNate Lawson if (ACPI_FAILURE(status)) { 437be2b1797SNate Lawson device_printf(dev, "Could not initialise SystemIO handler: %s\n", 438be2b1797SNate Lawson AcpiFormatException(status)); 439cb9b0d80SMike Smith goto out; 44015e32d5dSMike Smith } 441be2b1797SNate Lawson status = AcpiInstallAddressSpaceHandler(ACPI_ROOT_OBJECT, 442be2b1797SNate Lawson ACPI_ADR_SPACE_PCI_CONFIG, ACPI_DEFAULT_HANDLER, NULL, NULL); 443be2b1797SNate Lawson if (ACPI_FAILURE(status)) { 444be2b1797SNate Lawson device_printf(dev, "could not initialise PciConfig handler: %s\n", 445be2b1797SNate Lawson AcpiFormatException(status)); 446cb9b0d80SMike Smith goto out; 44715e32d5dSMike Smith } 44815e32d5dSMike Smith 44915e32d5dSMike Smith /* 450be2b1797SNate Lawson * Note that some systems (specifically, those with namespace evaluation 451be2b1797SNate Lawson * issues that require the avoidance of parts of the namespace) must 452be2b1797SNate Lawson * avoid running _INI and _STA on everything, as well as dodging the final 453be2b1797SNate Lawson * object init pass. 45415e32d5dSMike Smith * 45532d18aa5SMike Smith * For these devices, we set ACPI_NO_DEVICE_INIT and ACPI_NO_OBJECT_INIT). 45632d18aa5SMike Smith * 457be2b1797SNate Lawson * XXX We should arrange for the object init pass after we have attached 458be2b1797SNate Lawson * all our child devices, but on many systems it works here. 45915e32d5dSMike Smith */ 46032d18aa5SMike Smith flags = 0; 461d786139cSMaxime Henrion if (testenv("debug.acpi.avoid")) 46232d18aa5SMike Smith flags = ACPI_NO_DEVICE_INIT | ACPI_NO_OBJECT_INIT; 463bee4aa4aSNate Lawson 464bee4aa4aSNate Lawson /* Bring the hardware and basic handlers online. */ 465b53f2771SMike Smith if (ACPI_FAILURE(status = AcpiEnableSubsystem(flags))) { 466be2b1797SNate Lawson device_printf(dev, "Could not enable ACPI: %s\n", 467be2b1797SNate Lawson AcpiFormatException(status)); 468cb9b0d80SMike Smith goto out; 46915e32d5dSMike Smith } 47015e32d5dSMike Smith 471f8335e3aSNate Lawson /* 472f8335e3aSNate Lawson * Call the ECDT probe function to provide EC functionality before 473f8335e3aSNate Lawson * the namespace has been evaluated. 474f8335e3aSNate Lawson */ 475f8335e3aSNate Lawson acpi_ec_ecdt_probe(dev); 476f8335e3aSNate Lawson 477bee4aa4aSNate Lawson /* Bring device objects and regions online. */ 478b69ed3f4SMitsuru IWASAKI if (ACPI_FAILURE(status = AcpiInitializeObjects(flags))) { 479be2b1797SNate Lawson device_printf(dev, "Could not initialize ACPI objects: %s\n", 480be2b1797SNate Lawson AcpiFormatException(status)); 481b69ed3f4SMitsuru IWASAKI goto out; 482b69ed3f4SMitsuru IWASAKI } 483b69ed3f4SMitsuru IWASAKI 48415e32d5dSMike Smith /* 4851d073b1dSJohn Baldwin * Setup our sysctl tree. 4861d073b1dSJohn Baldwin * 4871d073b1dSJohn Baldwin * XXX: This doesn't check to make sure that none of these fail. 4881d073b1dSJohn Baldwin */ 4891d073b1dSJohn Baldwin sysctl_ctx_init(&sc->acpi_sysctl_ctx); 4901d073b1dSJohn Baldwin sc->acpi_sysctl_tree = SYSCTL_ADD_NODE(&sc->acpi_sysctl_ctx, 4911d073b1dSJohn Baldwin SYSCTL_STATIC_CHILDREN(_hw), OID_AUTO, 4921d073b1dSJohn Baldwin device_get_name(dev), CTLFLAG_RD, 0, ""); 4931d073b1dSJohn Baldwin SYSCTL_ADD_PROC(&sc->acpi_sysctl_ctx, SYSCTL_CHILDREN(sc->acpi_sysctl_tree), 494d75de536SMitsuru IWASAKI OID_AUTO, "supported_sleep_state", CTLTYPE_STRING | CTLFLAG_RD, 495d75de536SMitsuru IWASAKI 0, 0, acpi_supported_sleep_state_sysctl, "A", ""); 496d75de536SMitsuru IWASAKI SYSCTL_ADD_PROC(&sc->acpi_sysctl_ctx, SYSCTL_CHILDREN(sc->acpi_sysctl_tree), 4971d073b1dSJohn Baldwin OID_AUTO, "power_button_state", CTLTYPE_STRING | CTLFLAG_RW, 4981d073b1dSJohn Baldwin &sc->acpi_power_button_sx, 0, acpi_sleep_state_sysctl, "A", ""); 4991d073b1dSJohn Baldwin SYSCTL_ADD_PROC(&sc->acpi_sysctl_ctx, SYSCTL_CHILDREN(sc->acpi_sysctl_tree), 5001d073b1dSJohn Baldwin OID_AUTO, "sleep_button_state", CTLTYPE_STRING | CTLFLAG_RW, 5011d073b1dSJohn Baldwin &sc->acpi_sleep_button_sx, 0, acpi_sleep_state_sysctl, "A", ""); 5021d073b1dSJohn Baldwin SYSCTL_ADD_PROC(&sc->acpi_sysctl_ctx, SYSCTL_CHILDREN(sc->acpi_sysctl_tree), 5031d073b1dSJohn Baldwin OID_AUTO, "lid_switch_state", CTLTYPE_STRING | CTLFLAG_RW, 5041d073b1dSJohn Baldwin &sc->acpi_lid_switch_sx, 0, acpi_sleep_state_sysctl, "A", ""); 505f86214b6SMitsuru IWASAKI SYSCTL_ADD_PROC(&sc->acpi_sysctl_ctx, SYSCTL_CHILDREN(sc->acpi_sysctl_tree), 506f86214b6SMitsuru IWASAKI OID_AUTO, "standby_state", CTLTYPE_STRING | CTLFLAG_RW, 507f86214b6SMitsuru IWASAKI &sc->acpi_standby_sx, 0, acpi_sleep_state_sysctl, "A", ""); 508f86214b6SMitsuru IWASAKI SYSCTL_ADD_PROC(&sc->acpi_sysctl_ctx, SYSCTL_CHILDREN(sc->acpi_sysctl_tree), 509f86214b6SMitsuru IWASAKI OID_AUTO, "suspend_state", CTLTYPE_STRING | CTLFLAG_RW, 510f86214b6SMitsuru IWASAKI &sc->acpi_suspend_sx, 0, acpi_sleep_state_sysctl, "A", ""); 5112d644607SMitsuru IWASAKI SYSCTL_ADD_INT(&sc->acpi_sysctl_ctx, SYSCTL_CHILDREN(sc->acpi_sysctl_tree), 512ff01efb5SMitsuru IWASAKI OID_AUTO, "sleep_delay", CTLFLAG_RD | CTLFLAG_RW, 513ff01efb5SMitsuru IWASAKI &sc->acpi_sleep_delay, 0, "sleep delay"); 514ff01efb5SMitsuru IWASAKI SYSCTL_ADD_INT(&sc->acpi_sysctl_ctx, SYSCTL_CHILDREN(sc->acpi_sysctl_tree), 5151611ea87SMitsuru IWASAKI OID_AUTO, "s4bios", CTLFLAG_RD | CTLFLAG_RW, 5161611ea87SMitsuru IWASAKI &sc->acpi_s4bios, 0, "S4BIOS mode"); 5171611ea87SMitsuru IWASAKI SYSCTL_ADD_INT(&sc->acpi_sysctl_ctx, SYSCTL_CHILDREN(sc->acpi_sysctl_tree), 5182d644607SMitsuru IWASAKI OID_AUTO, "verbose", CTLFLAG_RD | CTLFLAG_RW, 5192d644607SMitsuru IWASAKI &sc->acpi_verbose, 0, "verbose mode"); 520bf0c18ecSNate Lawson 521bf0c18ecSNate Lawson /* 5222b9609abSNate Lawson * Default to 1 second before sleeping to give some machines time to 523bf0c18ecSNate Lawson * stabilize. 524bf0c18ecSNate Lawson */ 5252b9609abSNate Lawson sc->acpi_sleep_delay = 1; 5262d644607SMitsuru IWASAKI if (bootverbose) 5272d644607SMitsuru IWASAKI sc->acpi_verbose = 1; 528498d464fSMitsuru IWASAKI if ((env = getenv("hw.acpi.verbose")) && strcmp(env, "0")) { 529498d464fSMitsuru IWASAKI sc->acpi_verbose = 1; 530498d464fSMitsuru IWASAKI freeenv(env); 531498d464fSMitsuru IWASAKI } 5321d073b1dSJohn Baldwin 5332d610c46SNate Lawson /* Only enable S4BIOS by default if the FACS says it is available. */ 5342d610c46SNate Lawson if (AcpiGbl_FACS->S4Bios_f != 0) 5352d610c46SNate Lawson sc->acpi_s4bios = 1; 5362d610c46SNate Lawson 5371d073b1dSJohn Baldwin /* 538ea27c63eSNate Lawson * Dispatch the default sleep state to devices. The lid switch is set 539ea27c63eSNate Lawson * to NONE by default to avoid surprising users. 54015e32d5dSMike Smith */ 541ea27c63eSNate Lawson sc->acpi_power_button_sx = ACPI_STATE_S5; 542ea27c63eSNate Lawson sc->acpi_lid_switch_sx = ACPI_S_STATES_MAX + 1; 543f86214b6SMitsuru IWASAKI sc->acpi_standby_sx = ACPI_STATE_S1; 544f86214b6SMitsuru IWASAKI sc->acpi_suspend_sx = ACPI_STATE_S3; 54515e32d5dSMike Smith 546ea27c63eSNate Lawson /* Pick the first valid sleep state for the sleep button default. */ 547ea27c63eSNate Lawson sc->acpi_sleep_button_sx = ACPI_S_STATES_MAX + 1; 548ea27c63eSNate Lawson for (state = ACPI_STATE_S1; state < ACPI_STATE_S5; state++) 549ea27c63eSNate Lawson if (ACPI_SUCCESS(AcpiGetSleepTypeData(state, &TypeA, &TypeB))) { 550ea27c63eSNate Lawson sc->acpi_sleep_button_sx = state; 551ea27c63eSNate Lawson break; 552ea27c63eSNate Lawson } 553ea27c63eSNate Lawson 55413d4f7baSMitsuru IWASAKI acpi_enable_fixed_events(sc); 55515e32d5dSMike Smith 55615e32d5dSMike Smith /* 55715e32d5dSMike Smith * Scan the namespace and attach/initialise children. 55815e32d5dSMike Smith */ 55915e32d5dSMike Smith 56059e472e9SNate Lawson /* Register our shutdown handler. */ 561be2b1797SNate Lawson EVENTHANDLER_REGISTER(shutdown_final, acpi_shutdown_final, sc, 562be2b1797SNate Lawson SHUTDOWN_PRI_LAST); 56315e32d5dSMike Smith 56415e32d5dSMike Smith /* 56515e32d5dSMike Smith * Register our acpi event handlers. 56615e32d5dSMike Smith * XXX should be configurable eg. via userland policy manager. 56715e32d5dSMike Smith */ 568be2b1797SNate Lawson EVENTHANDLER_REGISTER(acpi_sleep_event, acpi_system_eventhandler_sleep, 569be2b1797SNate Lawson sc, ACPI_EVENT_PRI_LAST); 570be2b1797SNate Lawson EVENTHANDLER_REGISTER(acpi_wakeup_event, acpi_system_eventhandler_wakeup, 571be2b1797SNate Lawson sc, ACPI_EVENT_PRI_LAST); 57215e32d5dSMike Smith 573be2b1797SNate Lawson /* Flag our initial states. */ 57415e32d5dSMike Smith sc->acpi_enabled = 1; 57515e32d5dSMike Smith sc->acpi_sstate = ACPI_STATE_S0; 576ece50487SMitsuru IWASAKI sc->acpi_sleep_disabled = 0; 57715e32d5dSMike Smith 578be2b1797SNate Lawson /* Create the control device */ 579a89fcf28STakanori Watanabe sc->acpi_dev_t = make_dev(&acpi_cdevsw, 0, UID_ROOT, GID_WHEEL, 0644, 5802a4689e8SRobert Watson "acpi"); 58115e32d5dSMike Smith sc->acpi_dev_t->si_drv1 = sc; 58215e32d5dSMike Smith 583be2b1797SNate Lawson if ((error = acpi_task_thread_init())) 584c573e654SMitsuru IWASAKI goto out; 585c573e654SMitsuru IWASAKI 586be2b1797SNate Lawson if ((error = acpi_machdep_init(dev))) 587f86214b6SMitsuru IWASAKI goto out; 588f86214b6SMitsuru IWASAKI 589f9390180SMitsuru IWASAKI /* Register ACPI again to pass the correct argument of pm_func. */ 590f9390180SMitsuru IWASAKI power_pm_register(POWER_PM_TYPE_ACPI, acpi_pm_func, sc); 591f9390180SMitsuru IWASAKI 592eeb6dba2SJohn Baldwin if (!acpi_disabled("bus")) 593eeb6dba2SJohn Baldwin acpi_probe_children(dev); 594eeb6dba2SJohn Baldwin 595cb9b0d80SMike Smith error = 0; 596cb9b0d80SMike Smith 597cb9b0d80SMike Smith out: 598cb9b0d80SMike Smith return_VALUE (error); 59915e32d5dSMike Smith } 60015e32d5dSMike Smith 601169b539aSNate Lawson static int 60210ce62b9SNate Lawson acpi_suspend(device_t dev) 60310ce62b9SNate Lawson { 60410ce62b9SNate Lawson device_t child, *devlist; 60510ce62b9SNate Lawson int error, i, numdevs, pstate; 60610ce62b9SNate Lawson 6075d3d03f1SNate Lawson GIANT_REQUIRED; 6085d3d03f1SNate Lawson 60910ce62b9SNate Lawson /* First give child devices a chance to suspend. */ 61010ce62b9SNate Lawson error = bus_generic_suspend(dev); 61110ce62b9SNate Lawson if (error) 61210ce62b9SNate Lawson return (error); 61310ce62b9SNate Lawson 61410ce62b9SNate Lawson /* 61510ce62b9SNate Lawson * Now, set them into the appropriate power state, usually D3. If the 61610ce62b9SNate Lawson * device has an _SxD method for the next sleep state, use that power 61710ce62b9SNate Lawson * state instead. 61810ce62b9SNate Lawson */ 61910ce62b9SNate Lawson device_get_children(dev, &devlist, &numdevs); 62010ce62b9SNate Lawson for (i = 0; i < numdevs; i++) { 62110ce62b9SNate Lawson /* If the device is not attached, we've powered it down elsewhere. */ 62210ce62b9SNate Lawson child = devlist[i]; 62310ce62b9SNate Lawson if (!device_is_attached(child)) 62410ce62b9SNate Lawson continue; 62510ce62b9SNate Lawson 62610ce62b9SNate Lawson /* 62710ce62b9SNate Lawson * Default to D3 for all sleep states. The _SxD method is optional 62810ce62b9SNate Lawson * so set the powerstate even if it's absent. 62910ce62b9SNate Lawson */ 63010ce62b9SNate Lawson pstate = PCI_POWERSTATE_D3; 63110ce62b9SNate Lawson error = acpi_device_pwr_for_sleep(device_get_parent(child), 63210ce62b9SNate Lawson child, &pstate); 63310ce62b9SNate Lawson if ((error == 0 || error == ESRCH) && acpi_do_powerstate) 63410ce62b9SNate Lawson pci_set_powerstate(child, pstate); 63510ce62b9SNate Lawson } 63610ce62b9SNate Lawson free(devlist, M_TEMP); 63710ce62b9SNate Lawson error = 0; 63810ce62b9SNate Lawson 63910ce62b9SNate Lawson return (error); 64010ce62b9SNate Lawson } 64110ce62b9SNate Lawson 64210ce62b9SNate Lawson static int 64310ce62b9SNate Lawson acpi_resume(device_t dev) 64410ce62b9SNate Lawson { 64510ce62b9SNate Lawson ACPI_HANDLE handle; 64610ce62b9SNate Lawson int i, numdevs; 64710ce62b9SNate Lawson device_t child, *devlist; 64810ce62b9SNate Lawson 6495d3d03f1SNate Lawson GIANT_REQUIRED; 6505d3d03f1SNate Lawson 65110ce62b9SNate Lawson /* 65210ce62b9SNate Lawson * Put all devices in D0 before resuming them. Call _S0D on each one 65310ce62b9SNate Lawson * since some systems expect this. 65410ce62b9SNate Lawson */ 65510ce62b9SNate Lawson device_get_children(dev, &devlist, &numdevs); 65610ce62b9SNate Lawson for (i = 0; i < numdevs; i++) { 65710ce62b9SNate Lawson child = devlist[i]; 65810ce62b9SNate Lawson handle = acpi_get_handle(child); 65910ce62b9SNate Lawson if (handle) 66010ce62b9SNate Lawson AcpiEvaluateObject(handle, "_S0D", NULL, NULL); 66110ce62b9SNate Lawson if (device_is_attached(child) && acpi_do_powerstate) 66210ce62b9SNate Lawson pci_set_powerstate(child, PCI_POWERSTATE_D0); 66310ce62b9SNate Lawson } 66410ce62b9SNate Lawson free(devlist, M_TEMP); 66510ce62b9SNate Lawson 66610ce62b9SNate Lawson return (bus_generic_resume(dev)); 66710ce62b9SNate Lawson } 66810ce62b9SNate Lawson 66910ce62b9SNate Lawson static int 670169b539aSNate Lawson acpi_shutdown(device_t dev) 671169b539aSNate Lawson { 672169b539aSNate Lawson 6735d3d03f1SNate Lawson GIANT_REQUIRED; 6745d3d03f1SNate Lawson 6750e414868SNate Lawson /* Allow children to shutdown first. */ 6760e414868SNate Lawson bus_generic_shutdown(dev); 6770e414868SNate Lawson 678bee4aa4aSNate Lawson /* 679bee4aa4aSNate Lawson * Enable any GPEs that are able to power-on the system (i.e., RTC). 680bee4aa4aSNate Lawson * Also, disable any that are not valid for this state (most). 681bee4aa4aSNate Lawson */ 682d4b9ff91SNate Lawson acpi_wake_prep_walk(ACPI_STATE_S5); 683d4b9ff91SNate Lawson 684169b539aSNate Lawson return (0); 685169b539aSNate Lawson } 686169b539aSNate Lawson 68715e32d5dSMike Smith /* 68815e32d5dSMike Smith * Handle a new device being added 68915e32d5dSMike Smith */ 69015e32d5dSMike Smith static device_t 69115e32d5dSMike Smith acpi_add_child(device_t bus, int order, const char *name, int unit) 69215e32d5dSMike Smith { 69315e32d5dSMike Smith struct acpi_device *ad; 69415e32d5dSMike Smith device_t child; 69515e32d5dSMike Smith 696be2b1797SNate Lawson if ((ad = malloc(sizeof(*ad), M_ACPIDEV, M_NOWAIT | M_ZERO)) == NULL) 69715e32d5dSMike Smith return (NULL); 69815e32d5dSMike Smith 69915e32d5dSMike Smith resource_list_init(&ad->ad_rl); 70015e32d5dSMike Smith 70115e32d5dSMike Smith child = device_add_child_ordered(bus, order, name, unit); 70215e32d5dSMike Smith if (child != NULL) 70315e32d5dSMike Smith device_set_ivars(child, ad); 70415e32d5dSMike Smith return (child); 70515e32d5dSMike Smith } 70615e32d5dSMike Smith 70715e32d5dSMike Smith static int 70815e32d5dSMike Smith acpi_print_child(device_t bus, device_t child) 70915e32d5dSMike Smith { 71015e32d5dSMike Smith struct acpi_device *adev = device_get_ivars(child); 71115e32d5dSMike Smith struct resource_list *rl = &adev->ad_rl; 71215e32d5dSMike Smith int retval = 0; 71315e32d5dSMike Smith 71415e32d5dSMike Smith retval += bus_print_child_header(bus, child); 7159ed79ecaSJohn Baldwin retval += resource_list_print_type(rl, "port", SYS_RES_IOPORT, "%#lx"); 7169ed79ecaSJohn Baldwin retval += resource_list_print_type(rl, "iomem", SYS_RES_MEMORY, "%#lx"); 7179ed79ecaSJohn Baldwin retval += resource_list_print_type(rl, "irq", SYS_RES_IRQ, "%ld"); 7189ed79ecaSJohn Baldwin retval += resource_list_print_type(rl, "drq", SYS_RES_DRQ, "%ld"); 719a91c5fa8SNate Lawson if (device_get_flags(child)) 720a91c5fa8SNate Lawson retval += printf(" flags %#x", device_get_flags(child)); 7212c8d3b23SNate Lawson retval += bus_print_child_footer(bus, child); 72215e32d5dSMike Smith 72315e32d5dSMike Smith return (retval); 72415e32d5dSMike Smith } 72515e32d5dSMike Smith 72610ce62b9SNate Lawson /* 72710ce62b9SNate Lawson * If this device is an ACPI child but no one claimed it, attempt 72810ce62b9SNate Lawson * to power it off. We'll power it back up when a driver is added. 72910ce62b9SNate Lawson * 73010ce62b9SNate Lawson * XXX Disabled for now since many necessary devices (like fdc and 73110ce62b9SNate Lawson * ATA) don't claim the devices we created for them but still expect 73210ce62b9SNate Lawson * them to be powered up. 73310ce62b9SNate Lawson */ 73410ce62b9SNate Lawson static void 73510ce62b9SNate Lawson acpi_probe_nomatch(device_t bus, device_t child) 73610ce62b9SNate Lawson { 73710ce62b9SNate Lawson 73810ce62b9SNate Lawson /* pci_set_powerstate(child, PCI_POWERSTATE_D3); */ 73910ce62b9SNate Lawson } 74010ce62b9SNate Lawson 74110ce62b9SNate Lawson /* 74210ce62b9SNate Lawson * If a new driver has a chance to probe a child, first power it up. 74310ce62b9SNate Lawson * 74410ce62b9SNate Lawson * XXX Disabled for now (see acpi_probe_nomatch for details). 74510ce62b9SNate Lawson */ 74610ce62b9SNate Lawson static void 74710ce62b9SNate Lawson acpi_driver_added(device_t dev, driver_t *driver) 74810ce62b9SNate Lawson { 74910ce62b9SNate Lawson device_t child, *devlist; 75010ce62b9SNate Lawson int i, numdevs; 75110ce62b9SNate Lawson 75210ce62b9SNate Lawson DEVICE_IDENTIFY(driver, dev); 75310ce62b9SNate Lawson device_get_children(dev, &devlist, &numdevs); 75410ce62b9SNate Lawson for (i = 0; i < numdevs; i++) { 75510ce62b9SNate Lawson child = devlist[i]; 75610ce62b9SNate Lawson if (device_get_state(child) == DS_NOTPRESENT) { 75710ce62b9SNate Lawson /* pci_set_powerstate(child, PCI_POWERSTATE_D0); */ 75810ce62b9SNate Lawson if (device_probe_and_attach(child) != 0) 75910ce62b9SNate Lawson ; /* pci_set_powerstate(child, PCI_POWERSTATE_D3); */ 76010ce62b9SNate Lawson } 76110ce62b9SNate Lawson } 76210ce62b9SNate Lawson free(devlist, M_TEMP); 76310ce62b9SNate Lawson } 76410ce62b9SNate Lawson 76563600cc3SNate Lawson /* Location hint for devctl(8) */ 76663600cc3SNate Lawson static int 767247648afSTakanori Watanabe acpi_child_location_str_method(device_t cbdev, device_t child, char *buf, 768247648afSTakanori Watanabe size_t buflen) 769247648afSTakanori Watanabe { 770247648afSTakanori Watanabe struct acpi_device *dinfo = device_get_ivars(child); 771247648afSTakanori Watanabe 772247648afSTakanori Watanabe if (dinfo->ad_handle) 773d40c0f53SNate Lawson snprintf(buf, buflen, "handle=%s", acpi_name(dinfo->ad_handle)); 774247648afSTakanori Watanabe else 775d40c0f53SNate Lawson snprintf(buf, buflen, "unknown"); 776247648afSTakanori Watanabe return (0); 777247648afSTakanori Watanabe } 778247648afSTakanori Watanabe 77963600cc3SNate Lawson /* PnP information for devctl(8) */ 78063600cc3SNate Lawson static int 781247648afSTakanori Watanabe acpi_child_pnpinfo_str_method(device_t cbdev, device_t child, char *buf, 782247648afSTakanori Watanabe size_t buflen) 783247648afSTakanori Watanabe { 784247648afSTakanori Watanabe ACPI_BUFFER adbuf = {ACPI_ALLOCATE_BUFFER, NULL}; 78563600cc3SNate Lawson ACPI_DEVICE_INFO *adinfo; 78663600cc3SNate Lawson struct acpi_device *dinfo = device_get_ivars(child); 787247648afSTakanori Watanabe char *end; 788247648afSTakanori Watanabe int error; 789247648afSTakanori Watanabe 790247648afSTakanori Watanabe error = AcpiGetObjectInfo(dinfo->ad_handle, &adbuf); 791247648afSTakanori Watanabe adinfo = (ACPI_DEVICE_INFO *) adbuf.Pointer; 792247648afSTakanori Watanabe if (error) 793d40c0f53SNate Lawson snprintf(buf, buflen, "unknown"); 794247648afSTakanori Watanabe else 795247648afSTakanori Watanabe snprintf(buf, buflen, "_HID=%s _UID=%lu", 796247648afSTakanori Watanabe (adinfo->Valid & ACPI_VALID_HID) ? 797d40c0f53SNate Lawson adinfo->HardwareId.Value : "none", 79863600cc3SNate Lawson (adinfo->Valid & ACPI_VALID_UID) ? 79963600cc3SNate Lawson strtoul(adinfo->UniqueId.Value, &end, 10) : 0); 800247648afSTakanori Watanabe if (adinfo) 801247648afSTakanori Watanabe AcpiOsFree(adinfo); 802247648afSTakanori Watanabe 803247648afSTakanori Watanabe return (0); 804247648afSTakanori Watanabe } 805247648afSTakanori Watanabe 806247648afSTakanori Watanabe /* 80715e32d5dSMike Smith * Handle per-device ivars 80815e32d5dSMike Smith */ 80915e32d5dSMike Smith static int 81015e32d5dSMike Smith acpi_read_ivar(device_t dev, device_t child, int index, uintptr_t *result) 81115e32d5dSMike Smith { 81215e32d5dSMike Smith struct acpi_device *ad; 81315e32d5dSMike Smith 81415e32d5dSMike Smith if ((ad = device_get_ivars(child)) == NULL) { 81515e32d5dSMike Smith printf("device has no ivars\n"); 81615e32d5dSMike Smith return (ENOENT); 81715e32d5dSMike Smith } 81815e32d5dSMike Smith 819be2b1797SNate Lawson /* ACPI and ISA compatibility ivars */ 82015e32d5dSMike Smith switch(index) { 82115e32d5dSMike Smith case ACPI_IVAR_HANDLE: 82215e32d5dSMike Smith *(ACPI_HANDLE *)result = ad->ad_handle; 82315e32d5dSMike Smith break; 82415e32d5dSMike Smith case ACPI_IVAR_MAGIC: 82515e32d5dSMike Smith *(int *)result = ad->ad_magic; 82615e32d5dSMike Smith break; 82715e32d5dSMike Smith case ACPI_IVAR_PRIVATE: 82815e32d5dSMike Smith *(void **)result = ad->ad_private; 82915e32d5dSMike Smith break; 830d4b9ff91SNate Lawson case ACPI_IVAR_FLAGS: 831d4b9ff91SNate Lawson *(int *)result = ad->ad_flags; 832d4b9ff91SNate Lawson break; 83332d18aa5SMike Smith case ISA_IVAR_VENDORID: 83432d18aa5SMike Smith case ISA_IVAR_SERIAL: 83532d18aa5SMike Smith case ISA_IVAR_COMPATID: 83632d18aa5SMike Smith *(int *)result = -1; 83732d18aa5SMike Smith break; 83832d18aa5SMike Smith case ISA_IVAR_LOGICALID: 83932d18aa5SMike Smith *(int *)result = acpi_isa_get_logicalid(child); 84032d18aa5SMike Smith break; 84115e32d5dSMike Smith default: 84215e32d5dSMike Smith return (ENOENT); 84315e32d5dSMike Smith } 844be2b1797SNate Lawson 84515e32d5dSMike Smith return (0); 84615e32d5dSMike Smith } 84715e32d5dSMike Smith 84815e32d5dSMike Smith static int 84915e32d5dSMike Smith acpi_write_ivar(device_t dev, device_t child, int index, uintptr_t value) 85015e32d5dSMike Smith { 85115e32d5dSMike Smith struct acpi_device *ad; 85215e32d5dSMike Smith 85315e32d5dSMike Smith if ((ad = device_get_ivars(child)) == NULL) { 85415e32d5dSMike Smith printf("device has no ivars\n"); 85515e32d5dSMike Smith return (ENOENT); 85615e32d5dSMike Smith } 85715e32d5dSMike Smith 85815e32d5dSMike Smith switch(index) { 85915e32d5dSMike Smith case ACPI_IVAR_HANDLE: 86015e32d5dSMike Smith ad->ad_handle = (ACPI_HANDLE)value; 86115e32d5dSMike Smith break; 86215e32d5dSMike Smith case ACPI_IVAR_MAGIC: 86315e32d5dSMike Smith ad->ad_magic = (int)value; 86415e32d5dSMike Smith break; 86515e32d5dSMike Smith case ACPI_IVAR_PRIVATE: 86615e32d5dSMike Smith ad->ad_private = (void *)value; 86715e32d5dSMike Smith break; 868d4b9ff91SNate Lawson case ACPI_IVAR_FLAGS: 869d4b9ff91SNate Lawson ad->ad_flags = (int)value; 870d4b9ff91SNate Lawson break; 87115e32d5dSMike Smith default: 8722ab060eeSWarner Losh panic("bad ivar write request (%d)", index); 87315e32d5dSMike Smith return (ENOENT); 87415e32d5dSMike Smith } 875be2b1797SNate Lawson 87615e32d5dSMike Smith return (0); 87715e32d5dSMike Smith } 87815e32d5dSMike Smith 87915e32d5dSMike Smith /* 88015e32d5dSMike Smith * Handle child resource allocation/removal 88115e32d5dSMike Smith */ 88291233413SNate Lawson static struct resource_list * 88391233413SNate Lawson acpi_get_rlist(device_t dev, device_t child) 88415e32d5dSMike Smith { 88591233413SNate Lawson struct acpi_device *ad; 88615e32d5dSMike Smith 88791233413SNate Lawson ad = device_get_ivars(child); 88891233413SNate Lawson return (&ad->ad_rl); 88915e32d5dSMike Smith } 89015e32d5dSMike Smith 891adad4744SNate Lawson /* 892adad4744SNate Lawson * Pre-allocate/manage all memory and IO resources. Since rman can't handle 893adad4744SNate Lawson * duplicates, we merge any in the sysresource attach routine. 894adad4744SNate Lawson */ 895adad4744SNate Lawson static int 896adad4744SNate Lawson acpi_sysres_alloc(device_t dev) 897adad4744SNate Lawson { 898adad4744SNate Lawson struct resource *res; 899adad4744SNate Lawson struct resource_list *rl; 900adad4744SNate Lawson struct resource_list_entry *rle; 901adad4744SNate Lawson struct rman *rm; 902adad4744SNate Lawson 903adad4744SNate Lawson rl = BUS_GET_RESOURCE_LIST(device_get_parent(dev), dev); 904adad4744SNate Lawson SLIST_FOREACH(rle, rl, link) { 905adad4744SNate Lawson if (rle->res != NULL) { 906adad4744SNate Lawson device_printf(dev, "duplicate resource for %lx\n", rle->start); 907adad4744SNate Lawson continue; 908adad4744SNate Lawson } 909adad4744SNate Lawson 910adad4744SNate Lawson /* Only memory and IO resources are valid here. */ 911adad4744SNate Lawson switch (rle->type) { 912adad4744SNate Lawson case SYS_RES_IOPORT: 913adad4744SNate Lawson rm = &acpi_rman_io; 914adad4744SNate Lawson break; 915adad4744SNate Lawson case SYS_RES_MEMORY: 916adad4744SNate Lawson rm = &acpi_rman_mem; 917adad4744SNate Lawson break; 918adad4744SNate Lawson default: 919adad4744SNate Lawson continue; 920adad4744SNate Lawson } 921adad4744SNate Lawson 922adad4744SNate Lawson /* Pre-allocate resource and add to our rman pool. */ 923adad4744SNate Lawson res = BUS_ALLOC_RESOURCE(device_get_parent(dev), dev, rle->type, 924adad4744SNate Lawson &rle->rid, rle->start, rle->start + rle->count - 1, rle->count, 0); 925adad4744SNate Lawson if (res != NULL) { 926adad4744SNate Lawson rman_manage_region(rm, rman_get_start(res), rman_get_end(res)); 927adad4744SNate Lawson rle->res = res; 928adad4744SNate Lawson } else 929adad4744SNate Lawson device_printf(dev, "reservation of %lx, %lx (%d) failed\n", 930adad4744SNate Lawson rle->start, rle->count, rle->type); 931adad4744SNate Lawson } 932adad4744SNate Lawson return (0); 933adad4744SNate Lawson } 934adad4744SNate Lawson 935adad4744SNate Lawson /* Find if we manage a given resource. */ 936adad4744SNate Lawson static struct resource_list_entry * 937adad4744SNate Lawson acpi_sysres_find(device_t dev, int type, u_long addr) 938adad4744SNate Lawson { 939adad4744SNate Lawson struct resource_list *rl; 940adad4744SNate Lawson struct resource_list_entry *rle; 941adad4744SNate Lawson 942adad4744SNate Lawson ACPI_SERIAL_ASSERT(acpi); 943adad4744SNate Lawson 944adad4744SNate Lawson /* We only consider IO and memory resources for our pool. */ 945adad4744SNate Lawson rle = NULL; 946adad4744SNate Lawson if (type != SYS_RES_IOPORT && type != SYS_RES_MEMORY) 947adad4744SNate Lawson goto out; 948adad4744SNate Lawson 949adad4744SNate Lawson rl = BUS_GET_RESOURCE_LIST(device_get_parent(dev), dev); 950adad4744SNate Lawson SLIST_FOREACH(rle, rl, link) { 951adad4744SNate Lawson if (type == rle->type && addr >= rle->start && 952adad4744SNate Lawson addr < rle->start + rle->count) 953adad4744SNate Lawson break; 954adad4744SNate Lawson } 955adad4744SNate Lawson 956adad4744SNate Lawson out: 957adad4744SNate Lawson return (rle); 958adad4744SNate Lawson } 959adad4744SNate Lawson 96015e32d5dSMike Smith static struct resource * 96115e32d5dSMike Smith acpi_alloc_resource(device_t bus, device_t child, int type, int *rid, 96215e32d5dSMike Smith u_long start, u_long end, u_long count, u_int flags) 96315e32d5dSMike Smith { 96495957f62SJohn Baldwin ACPI_RESOURCE ares; 96515e32d5dSMike Smith struct acpi_device *ad = device_get_ivars(child); 96615e32d5dSMike Smith struct resource_list *rl = &ad->ad_rl; 96791233413SNate Lawson struct resource_list_entry *rle; 96891233413SNate Lawson struct resource *res; 96991233413SNate Lawson struct rman *rm; 97015e32d5dSMike Smith 97115e2f34fSNate Lawson res = NULL; 97215e2f34fSNate Lawson ACPI_SERIAL_BEGIN(acpi); 97315e2f34fSNate Lawson 97491233413SNate Lawson /* 97591233413SNate Lawson * If this is an allocation of the "default" range for a given RID, and 97691233413SNate Lawson * we know what the resources for this device are (i.e., they're on the 97791233413SNate Lawson * child's resource list), use those start/end values. 97891233413SNate Lawson */ 97991233413SNate Lawson if (start == 0UL && end == ~0UL) { 98091233413SNate Lawson rle = resource_list_find(rl, type, *rid); 98191233413SNate Lawson if (rle == NULL) 98215e2f34fSNate Lawson goto out; 98391233413SNate Lawson start = rle->start; 98491233413SNate Lawson end = rle->end; 98591233413SNate Lawson count = rle->count; 98691233413SNate Lawson } 98791233413SNate Lawson 98891233413SNate Lawson /* If we don't manage this address, pass the request up to the parent. */ 989adad4744SNate Lawson rle = acpi_sysres_find(bus, type, start); 99091233413SNate Lawson if (rle == NULL) { 99195957f62SJohn Baldwin res = BUS_ALLOC_RESOURCE(device_get_parent(bus), child, type, rid, 99295957f62SJohn Baldwin start, end, count, flags); 99395957f62SJohn Baldwin } else { 99491233413SNate Lawson 99591233413SNate Lawson /* We only handle memory and IO resources through rman. */ 99691233413SNate Lawson switch (type) { 99791233413SNate Lawson case SYS_RES_IOPORT: 99891233413SNate Lawson rm = &acpi_rman_io; 99991233413SNate Lawson break; 100091233413SNate Lawson case SYS_RES_MEMORY: 100191233413SNate Lawson rm = &acpi_rman_mem; 100291233413SNate Lawson break; 100391233413SNate Lawson default: 100491233413SNate Lawson panic("acpi_alloc_resource: invalid res type %d", type); 100591233413SNate Lawson } 100691233413SNate Lawson 100791233413SNate Lawson /* If we do know it, allocate it from the local pool. */ 100895957f62SJohn Baldwin res = rman_reserve_resource(rm, start, end, count, flags & ~RF_ACTIVE, 100995957f62SJohn Baldwin child); 101091233413SNate Lawson if (res == NULL) 101115e2f34fSNate Lawson goto out; 101291233413SNate Lawson 1013a3236570SWarner Losh /* Copy the bus tag and handle from the pre-allocated resource. */ 101491233413SNate Lawson rman_set_bustag(res, rman_get_bustag(rle->res)); 1015ed67d9deSWarner Losh rman_set_bushandle(res, rman_get_start(res)); 101691233413SNate Lawson 101791233413SNate Lawson /* If requested, activate the resource using the parent's method. */ 101895957f62SJohn Baldwin if (flags & RF_ACTIVE) 101991233413SNate Lawson if (bus_activate_resource(child, type, *rid, res) != 0) { 102091233413SNate Lawson rman_release_resource(res); 102115e2f34fSNate Lawson res = NULL; 102215e2f34fSNate Lawson goto out; 102391233413SNate Lawson } 102495957f62SJohn Baldwin } 102591233413SNate Lawson 102695957f62SJohn Baldwin if (res != NULL && device_get_parent(child) == bus) 102795957f62SJohn Baldwin switch (type) { 102895957f62SJohn Baldwin case SYS_RES_IRQ: 102995957f62SJohn Baldwin /* 103095957f62SJohn Baldwin * Since bus_config_intr() takes immediate effect, we cannot 103195957f62SJohn Baldwin * configure the interrupt associated with a device when we 103295957f62SJohn Baldwin * parse the resources but have to defer it until a driver 103395957f62SJohn Baldwin * actually allocates the interrupt via bus_alloc_resource(). 103495957f62SJohn Baldwin * 103595957f62SJohn Baldwin * XXX: Should we handle the lookup failing? 103695957f62SJohn Baldwin */ 103795957f62SJohn Baldwin if (ACPI_SUCCESS(acpi_lookup_irq_resource(child, *rid, res, &ares))) 103895957f62SJohn Baldwin acpi_config_intr(child, &ares); 103995957f62SJohn Baldwin break; 104095957f62SJohn Baldwin } 104115e2f34fSNate Lawson 104215e2f34fSNate Lawson out: 104315e2f34fSNate Lawson ACPI_SERIAL_END(acpi); 104491233413SNate Lawson return (res); 104515e32d5dSMike Smith } 104615e32d5dSMike Smith 104715e32d5dSMike Smith static int 104891233413SNate Lawson acpi_release_resource(device_t bus, device_t child, int type, int rid, 104991233413SNate Lawson struct resource *r) 105015e32d5dSMike Smith { 105191233413SNate Lawson int ret; 105215e32d5dSMike Smith 105315e2f34fSNate Lawson ACPI_SERIAL_BEGIN(acpi); 105415e2f34fSNate Lawson 105591233413SNate Lawson /* 105691233413SNate Lawson * If we know about this address, deactivate it and release it to the 105791233413SNate Lawson * local pool. If we don't, pass this request up to the parent. 105891233413SNate Lawson */ 1059adad4744SNate Lawson if (acpi_sysres_find(bus, type, rman_get_start(r)) == NULL) { 106091233413SNate Lawson if (rman_get_flags(r) & RF_ACTIVE) { 106191233413SNate Lawson ret = bus_deactivate_resource(child, type, rid, r); 106291233413SNate Lawson if (ret != 0) 106315e2f34fSNate Lawson goto out; 106491233413SNate Lawson } 106591233413SNate Lawson ret = rman_release_resource(r); 106691233413SNate Lawson } else 106791233413SNate Lawson ret = BUS_RELEASE_RESOURCE(device_get_parent(bus), child, type, rid, r); 106891233413SNate Lawson 106915e2f34fSNate Lawson out: 107015e2f34fSNate Lawson ACPI_SERIAL_END(acpi); 107191233413SNate Lawson return (ret); 107215e32d5dSMike Smith } 107315e32d5dSMike Smith 1074dc750869SNate Lawson /* Allocate an IO port or memory resource, given its GAS. */ 1075e1c4bf3fSNate Lawson int 1076e1c4bf3fSNate Lawson acpi_bus_alloc_gas(device_t dev, int *type, int *rid, ACPI_GENERIC_ADDRESS *gas, 1077e1c4bf3fSNate Lawson struct resource **res) 1078dc750869SNate Lawson { 1079e1c4bf3fSNate Lawson int error, res_type; 1080dc750869SNate Lawson 1081e1c4bf3fSNate Lawson error = ENOMEM; 10828f118e25SNate Lawson if (type == NULL || rid == NULL || gas == NULL || res == NULL) 1083e1c4bf3fSNate Lawson return (EINVAL); 1084dc750869SNate Lawson 10858f118e25SNate Lawson /* We only support memory and IO spaces. */ 1086dc750869SNate Lawson switch (gas->AddressSpaceId) { 1087dc750869SNate Lawson case ACPI_ADR_SPACE_SYSTEM_MEMORY: 1088e1c4bf3fSNate Lawson res_type = SYS_RES_MEMORY; 1089dc750869SNate Lawson break; 1090dc750869SNate Lawson case ACPI_ADR_SPACE_SYSTEM_IO: 1091e1c4bf3fSNate Lawson res_type = SYS_RES_IOPORT; 1092dc750869SNate Lawson break; 1093dc750869SNate Lawson default: 1094e1c4bf3fSNate Lawson return (EOPNOTSUPP); 1095dc750869SNate Lawson } 1096dc750869SNate Lawson 10972fe912dfSNate Lawson /* 1098f45fc848SNate Lawson * If the register width is less than 8, assume the BIOS author means 1099f45fc848SNate Lawson * it is a bit field and just allocate a byte. 11002fe912dfSNate Lawson */ 1101f45fc848SNate Lawson if (gas->RegisterBitWidth && gas->RegisterBitWidth < 8) 1102f45fc848SNate Lawson gas->RegisterBitWidth = 8; 11032fe912dfSNate Lawson 11048f118e25SNate Lawson /* Validate the address after we're sure we support the space. */ 1105f45fc848SNate Lawson if (!ACPI_VALID_ADDRESS(gas->Address) || gas->RegisterBitWidth == 0) 11068f118e25SNate Lawson return (EINVAL); 11078f118e25SNate Lawson 1108e1c4bf3fSNate Lawson bus_set_resource(dev, res_type, *rid, gas->Address, 1109e1c4bf3fSNate Lawson gas->RegisterBitWidth / 8); 1110e1c4bf3fSNate Lawson *res = bus_alloc_resource_any(dev, res_type, rid, RF_ACTIVE); 1111e1c4bf3fSNate Lawson if (*res != NULL) { 1112e1c4bf3fSNate Lawson *type = res_type; 1113e1c4bf3fSNate Lawson error = 0; 1114e1c4bf3fSNate Lawson } 1115e1c4bf3fSNate Lawson return (error); 1116dc750869SNate Lawson } 1117dc750869SNate Lawson 1118c796e27bSNate Lawson /* Probe _HID and _CID for compatible ISA PNP ids. */ 11191e4925e8SNate Lawson static uint32_t 112032d18aa5SMike Smith acpi_isa_get_logicalid(device_t dev) 1121bc0f2195SMike Smith { 11221e4925e8SNate Lawson ACPI_DEVICE_INFO *devinfo; 11231e4925e8SNate Lawson ACPI_BUFFER buf; 1124bc0f2195SMike Smith ACPI_HANDLE h; 1125bc0f2195SMike Smith ACPI_STATUS error; 1126bc0f2195SMike Smith u_int32_t pnpid; 112732d18aa5SMike Smith 1128b4a05238SPeter Wemm ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 112932d18aa5SMike Smith 113032d18aa5SMike Smith pnpid = 0; 1131bd189fe7SNate Lawson buf.Pointer = NULL; 1132bd189fe7SNate Lawson buf.Length = ACPI_ALLOCATE_BUFFER; 1133bd189fe7SNate Lawson 11346fca9360SNate Lawson /* Fetch and validate the HID. */ 113532d18aa5SMike Smith if ((h = acpi_get_handle(dev)) == NULL) 1136bd189fe7SNate Lawson goto out; 11376fca9360SNate Lawson error = AcpiGetObjectInfo(h, &buf); 11386fca9360SNate Lawson if (ACPI_FAILURE(error)) 1139bd189fe7SNate Lawson goto out; 11401e4925e8SNate Lawson devinfo = (ACPI_DEVICE_INFO *)buf.Pointer; 114132d18aa5SMike Smith 11421e4925e8SNate Lawson if ((devinfo->Valid & ACPI_VALID_HID) != 0) 11431e4925e8SNate Lawson pnpid = PNP_EISAID(devinfo->HardwareId.Value); 1144be2b1797SNate Lawson 1145bd189fe7SNate Lawson out: 1146bd189fe7SNate Lawson if (buf.Pointer != NULL) 11471e4925e8SNate Lawson AcpiOsFree(buf.Pointer); 114832d18aa5SMike Smith return_VALUE (pnpid); 114932d18aa5SMike Smith } 115032d18aa5SMike Smith 11511e4925e8SNate Lawson static int 11521e4925e8SNate Lawson acpi_isa_get_compatid(device_t dev, uint32_t *cids, int count) 1153b2566207STakanori Watanabe { 11541e4925e8SNate Lawson ACPI_DEVICE_INFO *devinfo; 11551e4925e8SNate Lawson ACPI_BUFFER buf; 1156b2566207STakanori Watanabe ACPI_HANDLE h; 1157b2566207STakanori Watanabe ACPI_STATUS error; 11581e4925e8SNate Lawson uint32_t *pnpid; 11591e4925e8SNate Lawson int valid, i; 1160b2566207STakanori Watanabe 1161b2566207STakanori Watanabe ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 1162b2566207STakanori Watanabe 11631e4925e8SNate Lawson pnpid = cids; 11641e4925e8SNate Lawson valid = 0; 1165bd189fe7SNate Lawson buf.Pointer = NULL; 1166bd189fe7SNate Lawson buf.Length = ACPI_ALLOCATE_BUFFER; 1167bd189fe7SNate Lawson 11681e4925e8SNate Lawson /* Fetch and validate the CID */ 1169b2566207STakanori Watanabe if ((h = acpi_get_handle(dev)) == NULL) 1170bd189fe7SNate Lawson goto out; 11711e4925e8SNate Lawson error = AcpiGetObjectInfo(h, &buf); 11721e4925e8SNate Lawson if (ACPI_FAILURE(error)) 1173bd189fe7SNate Lawson goto out; 11741e4925e8SNate Lawson devinfo = (ACPI_DEVICE_INFO *)buf.Pointer; 11751e4925e8SNate Lawson if ((devinfo->Valid & ACPI_VALID_CID) == 0) 1176b2566207STakanori Watanabe goto out; 1177b2566207STakanori Watanabe 11781e4925e8SNate Lawson if (devinfo->CompatibilityId.Count < count) 11791e4925e8SNate Lawson count = devinfo->CompatibilityId.Count; 11801e4925e8SNate Lawson for (i = 0; i < count; i++) { 11811e4925e8SNate Lawson if (strncmp(devinfo->CompatibilityId.Id[i].Value, "PNP", 3) != 0) 11821e4925e8SNate Lawson continue; 11831e4925e8SNate Lawson *pnpid++ = PNP_EISAID(devinfo->CompatibilityId.Id[i].Value); 11841e4925e8SNate Lawson valid++; 1185b2566207STakanori Watanabe } 1186b2566207STakanori Watanabe 11871e4925e8SNate Lawson out: 1188bd189fe7SNate Lawson if (buf.Pointer != NULL) 11891e4925e8SNate Lawson AcpiOsFree(buf.Pointer); 11901e4925e8SNate Lawson return_VALUE (valid); 11911e4925e8SNate Lawson } 1192b2566207STakanori Watanabe 1193ce619b2eSNate Lawson static char * 1194ce619b2eSNate Lawson acpi_device_id_probe(device_t bus, device_t dev, char **ids) 1195ce619b2eSNate Lawson { 1196ce619b2eSNate Lawson ACPI_HANDLE h; 1197ce619b2eSNate Lawson int i; 1198ce619b2eSNate Lawson 1199ce619b2eSNate Lawson h = acpi_get_handle(dev); 1200ce619b2eSNate Lawson if (ids == NULL || h == NULL || acpi_get_type(dev) != ACPI_TYPE_DEVICE) 1201ce619b2eSNate Lawson return (NULL); 1202ce619b2eSNate Lawson 1203ce619b2eSNate Lawson /* Try to match one of the array of IDs with a HID or CID. */ 1204ce619b2eSNate Lawson for (i = 0; ids[i] != NULL; i++) { 1205ce619b2eSNate Lawson if (acpi_MatchHid(h, ids[i])) 1206ce619b2eSNate Lawson return (ids[i]); 1207ce619b2eSNate Lawson } 1208ce619b2eSNate Lawson return (NULL); 1209ce619b2eSNate Lawson } 1210ce619b2eSNate Lawson 1211ce619b2eSNate Lawson static ACPI_STATUS 1212ce619b2eSNate Lawson acpi_device_eval_obj(device_t bus, device_t dev, ACPI_STRING pathname, 1213ce619b2eSNate Lawson ACPI_OBJECT_LIST *parameters, ACPI_BUFFER *ret) 1214ce619b2eSNate Lawson { 1215ce619b2eSNate Lawson ACPI_HANDLE h; 1216ce619b2eSNate Lawson 1217df8d2a32SNate Lawson if (dev == NULL) 1218df8d2a32SNate Lawson h = ACPI_ROOT_OBJECT; 1219df8d2a32SNate Lawson else if ((h = acpi_get_handle(dev)) == NULL) 1220ce619b2eSNate Lawson return (AE_BAD_PARAMETER); 1221ce619b2eSNate Lawson return (AcpiEvaluateObject(h, pathname, parameters, ret)); 1222ce619b2eSNate Lawson } 1223ce619b2eSNate Lawson 122410ce62b9SNate Lawson static int 122510ce62b9SNate Lawson acpi_device_pwr_for_sleep(device_t bus, device_t dev, int *dstate) 122610ce62b9SNate Lawson { 122710ce62b9SNate Lawson struct acpi_softc *sc; 122810ce62b9SNate Lawson ACPI_HANDLE handle; 122910ce62b9SNate Lawson ACPI_STATUS status; 123010ce62b9SNate Lawson char sxd[8]; 123110ce62b9SNate Lawson int error; 123210ce62b9SNate Lawson 123310ce62b9SNate Lawson sc = device_get_softc(bus); 123410ce62b9SNate Lawson handle = acpi_get_handle(dev); 123510ce62b9SNate Lawson 123610ce62b9SNate Lawson /* 123710ce62b9SNate Lawson * XXX If we find these devices, don't try to power them down. 123810ce62b9SNate Lawson * The serial and IRDA ports on my T23 hang the system when 123910ce62b9SNate Lawson * set to D3 and it appears that such legacy devices may 124010ce62b9SNate Lawson * need special handling in their drivers. 124110ce62b9SNate Lawson */ 124210ce62b9SNate Lawson if (handle == NULL || 124310ce62b9SNate Lawson acpi_MatchHid(handle, "PNP0500") || 124410ce62b9SNate Lawson acpi_MatchHid(handle, "PNP0501") || 124510ce62b9SNate Lawson acpi_MatchHid(handle, "PNP0502") || 124610ce62b9SNate Lawson acpi_MatchHid(handle, "PNP0510") || 124710ce62b9SNate Lawson acpi_MatchHid(handle, "PNP0511")) 124810ce62b9SNate Lawson return (ENXIO); 124910ce62b9SNate Lawson 125010ce62b9SNate Lawson /* 125110ce62b9SNate Lawson * Override next state with the value from _SxD, if present. If no 125210ce62b9SNate Lawson * dstate argument was provided, don't fetch the return value. 125310ce62b9SNate Lawson */ 125410ce62b9SNate Lawson snprintf(sxd, sizeof(sxd), "_S%dD", sc->acpi_sstate); 125510ce62b9SNate Lawson if (dstate) 125610ce62b9SNate Lawson status = acpi_GetInteger(handle, sxd, dstate); 125710ce62b9SNate Lawson else 125810ce62b9SNate Lawson status = AcpiEvaluateObject(handle, sxd, NULL, NULL); 125910ce62b9SNate Lawson 126010ce62b9SNate Lawson switch (status) { 126110ce62b9SNate Lawson case AE_OK: 126210ce62b9SNate Lawson error = 0; 126310ce62b9SNate Lawson break; 126410ce62b9SNate Lawson case AE_NOT_FOUND: 126510ce62b9SNate Lawson error = ESRCH; 126610ce62b9SNate Lawson break; 126710ce62b9SNate Lawson default: 126810ce62b9SNate Lawson error = ENXIO; 126910ce62b9SNate Lawson break; 127010ce62b9SNate Lawson } 127110ce62b9SNate Lawson 127210ce62b9SNate Lawson return (error); 127310ce62b9SNate Lawson } 127410ce62b9SNate Lawson 1275df8d2a32SNate Lawson /* Callback arg for our implementation of walking the namespace. */ 1276df8d2a32SNate Lawson struct acpi_device_scan_ctx { 1277df8d2a32SNate Lawson acpi_scan_cb_t user_fn; 1278df8d2a32SNate Lawson void *arg; 1279df8d2a32SNate Lawson ACPI_HANDLE parent; 1280df8d2a32SNate Lawson }; 1281df8d2a32SNate Lawson 1282ce619b2eSNate Lawson static ACPI_STATUS 1283df8d2a32SNate Lawson acpi_device_scan_cb(ACPI_HANDLE h, UINT32 level, void *arg, void **retval) 1284df8d2a32SNate Lawson { 1285df8d2a32SNate Lawson struct acpi_device_scan_ctx *ctx; 1286df8d2a32SNate Lawson device_t dev, old_dev; 1287df8d2a32SNate Lawson ACPI_STATUS status; 1288df8d2a32SNate Lawson ACPI_OBJECT_TYPE type; 1289df8d2a32SNate Lawson 1290df8d2a32SNate Lawson /* 1291df8d2a32SNate Lawson * Skip this device if we think we'll have trouble with it or it is 1292df8d2a32SNate Lawson * the parent where the scan began. 1293df8d2a32SNate Lawson */ 1294df8d2a32SNate Lawson ctx = (struct acpi_device_scan_ctx *)arg; 1295df8d2a32SNate Lawson if (acpi_avoid(h) || h == ctx->parent) 1296df8d2a32SNate Lawson return (AE_OK); 1297df8d2a32SNate Lawson 1298df8d2a32SNate Lawson /* If this is not a valid device type (e.g., a method), skip it. */ 1299df8d2a32SNate Lawson if (ACPI_FAILURE(AcpiGetType(h, &type))) 1300df8d2a32SNate Lawson return (AE_OK); 1301df8d2a32SNate Lawson if (type != ACPI_TYPE_DEVICE && type != ACPI_TYPE_PROCESSOR && 1302df8d2a32SNate Lawson type != ACPI_TYPE_THERMAL && type != ACPI_TYPE_POWER) 1303df8d2a32SNate Lawson return (AE_OK); 1304df8d2a32SNate Lawson 1305df8d2a32SNate Lawson /* 1306df8d2a32SNate Lawson * Call the user function with the current device. If it is unchanged 1307df8d2a32SNate Lawson * afterwards, return. Otherwise, we update the handle to the new dev. 1308df8d2a32SNate Lawson */ 1309df8d2a32SNate Lawson old_dev = acpi_get_device(h); 1310df8d2a32SNate Lawson dev = old_dev; 1311df8d2a32SNate Lawson status = ctx->user_fn(h, &dev, level, ctx->arg); 1312df8d2a32SNate Lawson if (ACPI_FAILURE(status) || old_dev == dev) 1313df8d2a32SNate Lawson return (status); 1314df8d2a32SNate Lawson 1315df8d2a32SNate Lawson /* Remove the old child and its connection to the handle. */ 1316df8d2a32SNate Lawson if (old_dev != NULL) { 1317df8d2a32SNate Lawson device_delete_child(device_get_parent(old_dev), old_dev); 1318df8d2a32SNate Lawson AcpiDetachData(h, acpi_fake_objhandler); 1319df8d2a32SNate Lawson } 1320df8d2a32SNate Lawson 1321df8d2a32SNate Lawson /* Recreate the handle association if the user created a device. */ 1322df8d2a32SNate Lawson if (dev != NULL) 1323df8d2a32SNate Lawson AcpiAttachData(h, acpi_fake_objhandler, dev); 1324df8d2a32SNate Lawson 1325df8d2a32SNate Lawson return (AE_OK); 1326df8d2a32SNate Lawson } 1327df8d2a32SNate Lawson 1328df8d2a32SNate Lawson static ACPI_STATUS 1329df8d2a32SNate Lawson acpi_device_scan_children(device_t bus, device_t dev, int max_depth, 1330df8d2a32SNate Lawson acpi_scan_cb_t user_fn, void *arg) 1331ce619b2eSNate Lawson { 1332ce619b2eSNate Lawson ACPI_HANDLE h; 1333df8d2a32SNate Lawson struct acpi_device_scan_ctx ctx; 1334ce619b2eSNate Lawson 1335df8d2a32SNate Lawson if (acpi_disabled("children")) 1336df8d2a32SNate Lawson return (AE_OK); 1337df8d2a32SNate Lawson 1338df8d2a32SNate Lawson if (dev == NULL) 1339df8d2a32SNate Lawson h = ACPI_ROOT_OBJECT; 1340df8d2a32SNate Lawson else if ((h = acpi_get_handle(dev)) == NULL) 1341ce619b2eSNate Lawson return (AE_BAD_PARAMETER); 1342df8d2a32SNate Lawson ctx.user_fn = user_fn; 1343df8d2a32SNate Lawson ctx.arg = arg; 1344df8d2a32SNate Lawson ctx.parent = h; 1345df8d2a32SNate Lawson return (AcpiWalkNamespace(ACPI_TYPE_ANY, h, max_depth, 1346df8d2a32SNate Lawson acpi_device_scan_cb, &ctx, NULL)); 1347ce619b2eSNate Lawson } 1348ce619b2eSNate Lawson 134910ce62b9SNate Lawson /* 135010ce62b9SNate Lawson * Even though ACPI devices are not PCI, we use the PCI approach for setting 135110ce62b9SNate Lawson * device power states since it's close enough to ACPI. 135210ce62b9SNate Lawson */ 135310ce62b9SNate Lawson static int 135410ce62b9SNate Lawson acpi_set_powerstate_method(device_t bus, device_t child, int state) 135510ce62b9SNate Lawson { 135610ce62b9SNate Lawson ACPI_HANDLE h; 135710ce62b9SNate Lawson ACPI_STATUS status; 135810ce62b9SNate Lawson int error; 135910ce62b9SNate Lawson 136010ce62b9SNate Lawson error = 0; 136110ce62b9SNate Lawson h = acpi_get_handle(child); 136210ce62b9SNate Lawson if (state < ACPI_STATE_D0 || state > ACPI_STATE_D3) 136310ce62b9SNate Lawson return (EINVAL); 136410ce62b9SNate Lawson if (h == NULL) 136510ce62b9SNate Lawson return (0); 136610ce62b9SNate Lawson 136710ce62b9SNate Lawson /* Ignore errors if the power methods aren't present. */ 136810ce62b9SNate Lawson status = acpi_pwr_switch_consumer(h, state); 136910ce62b9SNate Lawson if (ACPI_FAILURE(status) && status != AE_NOT_FOUND 137010ce62b9SNate Lawson && status != AE_BAD_PARAMETER) 137110ce62b9SNate Lawson device_printf(bus, "failed to set ACPI power state D%d on %s: %s\n", 137210ce62b9SNate Lawson state, acpi_name(h), AcpiFormatException(status)); 137310ce62b9SNate Lawson 137410ce62b9SNate Lawson return (error); 137510ce62b9SNate Lawson } 137610ce62b9SNate Lawson 137732d18aa5SMike Smith static int 137832d18aa5SMike Smith acpi_isa_pnp_probe(device_t bus, device_t child, struct isa_pnp_id *ids) 137932d18aa5SMike Smith { 13801e4925e8SNate Lawson int result, cid_count, i; 13811e4925e8SNate Lawson uint32_t lid, cids[8]; 1382bc0f2195SMike Smith 1383b4a05238SPeter Wemm ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 1384bc0f2195SMike Smith 1385bc0f2195SMike Smith /* 1386bc0f2195SMike Smith * ISA-style drivers attached to ACPI may persist and 1387bc0f2195SMike Smith * probe manually if we return ENOENT. We never want 1388bc0f2195SMike Smith * that to happen, so don't ever return it. 1389bc0f2195SMike Smith */ 1390bc0f2195SMike Smith result = ENXIO; 1391bc0f2195SMike Smith 1392be2b1797SNate Lawson /* Scan the supplied IDs for a match */ 1393b2566207STakanori Watanabe lid = acpi_isa_get_logicalid(child); 13941e4925e8SNate Lawson cid_count = acpi_isa_get_compatid(child, cids, 8); 1395bc0f2195SMike Smith while (ids && ids->ip_id) { 13961e4925e8SNate Lawson if (lid == ids->ip_id) { 1397bc0f2195SMike Smith result = 0; 1398bc0f2195SMike Smith goto out; 1399bc0f2195SMike Smith } 14001e4925e8SNate Lawson for (i = 0; i < cid_count; i++) { 14011e4925e8SNate Lawson if (cids[i] == ids->ip_id) { 14021e4925e8SNate Lawson result = 0; 14031e4925e8SNate Lawson goto out; 14041e4925e8SNate Lawson } 14051e4925e8SNate Lawson } 1406bc0f2195SMike Smith ids++; 1407bc0f2195SMike Smith } 1408be2b1797SNate Lawson 1409bc0f2195SMike Smith out: 14109e0dd54fSNate Lawson if (result == 0 && ids->ip_desc) 14119e0dd54fSNate Lawson device_set_desc(child, ids->ip_desc); 14129e0dd54fSNate Lawson 1413bc0f2195SMike Smith return_VALUE (result); 1414bc0f2195SMike Smith } 1415bc0f2195SMike Smith 1416bc0f2195SMike Smith /* 141733332dc2SNate Lawson * Scan all of the ACPI namespace and attach child devices. 141815e32d5dSMike Smith * 141933332dc2SNate Lawson * We should only expect to find devices in the \_PR, \_TZ, \_SI, and 142033332dc2SNate Lawson * \_SB scopes, and \_PR and \_TZ became obsolete in the ACPI 2.0 spec. 142133332dc2SNate Lawson * However, in violation of the spec, some systems place their PCI link 142233332dc2SNate Lawson * devices in \, so we have to walk the whole namespace. We check the 142333332dc2SNate Lawson * type of namespace nodes, so this should be ok. 142415e32d5dSMike Smith */ 142515e32d5dSMike Smith static void 142615e32d5dSMike Smith acpi_probe_children(device_t bus) 142715e32d5dSMike Smith { 142815e32d5dSMike Smith 1429b4a05238SPeter Wemm ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 14300ae55423SMike Smith 143115e32d5dSMike Smith /* 143215e32d5dSMike Smith * Scan the namespace and insert placeholders for all the devices that 1433edc13633SNate Lawson * we find. We also probe/attach any early devices. 143415e32d5dSMike Smith * 143515e32d5dSMike Smith * Note that we use AcpiWalkNamespace rather than AcpiGetDevices because 1436be2b1797SNate Lawson * we want to create nodes for all devices, not just those that are 1437be2b1797SNate Lawson * currently present. (This assumes that we don't want to create/remove 1438be2b1797SNate Lawson * devices as they appear, which might be smarter.) 143915e32d5dSMike Smith */ 14404c1cdee6SMike Smith ACPI_DEBUG_PRINT((ACPI_DB_OBJECTS, "namespace scan\n")); 144133332dc2SNate Lawson AcpiWalkNamespace(ACPI_TYPE_ANY, ACPI_ROOT_OBJECT, 100, acpi_probe_child, 1442be2b1797SNate Lawson bus, NULL); 144315e32d5dSMike Smith 1444adad4744SNate Lawson /* Pre-allocate resources for our rman from any sysresource devices. */ 1445adad4744SNate Lawson acpi_sysres_alloc(bus); 1446adad4744SNate Lawson 1447edc13633SNate Lawson /* Create any static children by calling device identify methods. */ 1448edc13633SNate Lawson ACPI_DEBUG_PRINT((ACPI_DB_OBJECTS, "device identify routines\n")); 1449edc13633SNate Lawson bus_generic_probe(bus); 1450edc13633SNate Lawson 1451edc13633SNate Lawson /* Probe/attach all children, created staticly and from the namespace. */ 14524c1cdee6SMike Smith ACPI_DEBUG_PRINT((ACPI_DB_OBJECTS, "first bus_generic_attach\n")); 145315e32d5dSMike Smith bus_generic_attach(bus); 145415e32d5dSMike Smith 145515e32d5dSMike Smith /* 145615e32d5dSMike Smith * Some of these children may have attached others as part of their attach 145715e32d5dSMike Smith * process (eg. the root PCI bus driver), so rescan. 145815e32d5dSMike Smith */ 14594c1cdee6SMike Smith ACPI_DEBUG_PRINT((ACPI_DB_OBJECTS, "second bus_generic_attach\n")); 146015e32d5dSMike Smith bus_generic_attach(bus); 14610ae55423SMike Smith 146288a79fc0SNate Lawson /* Attach wake sysctls. */ 14635c9ea25eSNate Lawson acpi_wake_sysctl_walk(bus); 146488a79fc0SNate Lawson 1465bc0f2195SMike Smith ACPI_DEBUG_PRINT((ACPI_DB_OBJECTS, "done attaching children\n")); 14660ae55423SMike Smith return_VOID; 146715e32d5dSMike Smith } 146815e32d5dSMike Smith 1469b82ca9a9SNate Lawson /* 1470b82ca9a9SNate Lawson * Determine the probe order for a given device and return non-zero if it 1471b82ca9a9SNate Lawson * should be attached immediately. 1472b82ca9a9SNate Lawson */ 147391233413SNate Lawson static int 1474b82ca9a9SNate Lawson acpi_probe_order(ACPI_HANDLE handle, int *order) 147591233413SNate Lawson { 147691233413SNate Lawson int ret; 147791233413SNate Lawson 1478b82ca9a9SNate Lawson /* 1479b82ca9a9SNate Lawson * 1. I/O port and memory system resource holders 1480b82ca9a9SNate Lawson * 2. Embedded controllers (to handle early accesses) 1481b82ca9a9SNate Lawson */ 148291233413SNate Lawson ret = 0; 148391233413SNate Lawson if (acpi_MatchHid(handle, "PNP0C01") || acpi_MatchHid(handle, "PNP0C02")) { 148491233413SNate Lawson *order = 1; 148591233413SNate Lawson ret = 1; 1486b82ca9a9SNate Lawson } else if (acpi_MatchHid(handle, "PNP0C09")) { 148791233413SNate Lawson *order = 2; 148891233413SNate Lawson ret = 1; 148991233413SNate Lawson } 149091233413SNate Lawson 149191233413SNate Lawson return (ret); 149291233413SNate Lawson } 149391233413SNate Lawson 149415e32d5dSMike Smith /* 149515e32d5dSMike Smith * Evaluate a child device and determine whether we might attach a device to 149615e32d5dSMike Smith * it. 149715e32d5dSMike Smith */ 149815e32d5dSMike Smith static ACPI_STATUS 149915e32d5dSMike Smith acpi_probe_child(ACPI_HANDLE handle, UINT32 level, void *context, void **status) 150015e32d5dSMike Smith { 150115e32d5dSMike Smith ACPI_OBJECT_TYPE type; 150233332dc2SNate Lawson device_t bus, child; 150391233413SNate Lawson int order, probe_now; 150433332dc2SNate Lawson char *handle_str, **search; 150533332dc2SNate Lawson static char *scopes[] = {"\\_PR_", "\\_TZ_", "\\_SI_", "\\_SB_", NULL}; 150615e32d5dSMike Smith 1507b4a05238SPeter Wemm ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 15080ae55423SMike Smith 1509be2b1797SNate Lawson /* Skip this device if we think we'll have trouble with it. */ 15100ae55423SMike Smith if (acpi_avoid(handle)) 15110ae55423SMike Smith return_ACPI_STATUS (AE_OK); 15120ae55423SMike Smith 151391233413SNate Lawson bus = (device_t)context; 1514b53f2771SMike Smith if (ACPI_SUCCESS(AcpiGetType(handle, &type))) { 151515e32d5dSMike Smith switch (type) { 151615e32d5dSMike Smith case ACPI_TYPE_DEVICE: 151715e32d5dSMike Smith case ACPI_TYPE_PROCESSOR: 151815e32d5dSMike Smith case ACPI_TYPE_THERMAL: 151915e32d5dSMike Smith case ACPI_TYPE_POWER: 15200ae55423SMike Smith if (acpi_disabled("children")) 15210ae55423SMike Smith break; 1522be2b1797SNate Lawson 152315e32d5dSMike Smith /* 152433332dc2SNate Lawson * Since we scan from \, be sure to skip system scope objects. 152533332dc2SNate Lawson * At least \_SB and \_TZ are detected as devices (ACPI-CA bug?) 152633332dc2SNate Lawson */ 152733332dc2SNate Lawson handle_str = acpi_name(handle); 152833332dc2SNate Lawson for (search = scopes; *search != NULL; search++) { 152933332dc2SNate Lawson if (strcmp(handle_str, *search) == 0) 153033332dc2SNate Lawson break; 153133332dc2SNate Lawson } 153233332dc2SNate Lawson if (*search != NULL) 153333332dc2SNate Lawson break; 153433332dc2SNate Lawson 153533332dc2SNate Lawson /* 153615e32d5dSMike Smith * Create a placeholder device for this node. Sort the placeholder 1537b82ca9a9SNate Lawson * so that the probe/attach passes will run breadth-first. Orders 1538b82ca9a9SNate Lawson * less than 10 are reserved for special objects (i.e., system 1539b82ca9a9SNate Lawson * resources). Larger values are used for all other devices. 154015e32d5dSMike Smith */ 154133332dc2SNate Lawson ACPI_DEBUG_PRINT((ACPI_DB_OBJECTS, "scanning '%s'\n", handle_str)); 1542b82ca9a9SNate Lawson order = (level + 1) * 10; 1543b82ca9a9SNate Lawson probe_now = acpi_probe_order(handle, &order); 154491233413SNate Lawson child = BUS_ADD_CHILD(bus, order, NULL, -1); 1545bc0f2195SMike Smith if (child == NULL) 1546bc0f2195SMike Smith break; 154759a890e6SNate Lawson 154859a890e6SNate Lawson /* Associate the handle with the device_t and vice versa. */ 154915e32d5dSMike Smith acpi_set_handle(child, handle); 155059a890e6SNate Lawson AcpiAttachData(handle, acpi_fake_objhandler, child); 1551bc0f2195SMike Smith 1552bc0f2195SMike Smith /* 1553b519f9d6SMike Smith * Check that the device is present. If it's not present, 1554b519f9d6SMike Smith * leave it disabled (so that we have a device_t attached to 1555b519f9d6SMike Smith * the handle, but we don't probe it). 1556b519f9d6SMike Smith */ 1557be2b1797SNate Lawson if (type == ACPI_TYPE_DEVICE && !acpi_DeviceIsPresent(child)) { 1558b519f9d6SMike Smith device_disable(child); 1559b519f9d6SMike Smith break; 1560b519f9d6SMike Smith } 1561b519f9d6SMike Smith 1562b519f9d6SMike Smith /* 1563bc0f2195SMike Smith * Get the device's resource settings and attach them. 1564bc0f2195SMike Smith * Note that if the device has _PRS but no _CRS, we need 1565bc0f2195SMike Smith * to decide when it's appropriate to try to configure the 1566bc0f2195SMike Smith * device. Ignore the return value here; it's OK for the 1567bc0f2195SMike Smith * device not to have any resources. 1568bc0f2195SMike Smith */ 156972ad60adSNate Lawson acpi_parse_resources(child, handle, &acpi_res_parse_set, NULL); 1570bc0f2195SMike Smith 1571f504b607SNate Lawson /* If order was overridden, probe/attach now rather than later. */ 157291233413SNate Lawson if (probe_now) 157391233413SNate Lawson device_probe_and_attach(child); 15740ae55423SMike Smith break; 157515e32d5dSMike Smith } 157615e32d5dSMike Smith } 1577be2b1797SNate Lawson 15780ae55423SMike Smith return_ACPI_STATUS (AE_OK); 157915e32d5dSMike Smith } 158015e32d5dSMike Smith 158159a890e6SNate Lawson /* 158259a890e6SNate Lawson * AcpiAttachData() requires an object handler but never uses it. This is a 158359a890e6SNate Lawson * placeholder object handler so we can store a device_t in an ACPI_HANDLE. 158459a890e6SNate Lawson */ 158559a890e6SNate Lawson void 158659a890e6SNate Lawson acpi_fake_objhandler(ACPI_HANDLE h, UINT32 fn, void *data) 158759a890e6SNate Lawson { 158859a890e6SNate Lawson } 158959a890e6SNate Lawson 159015e32d5dSMike Smith static void 159115e32d5dSMike Smith acpi_shutdown_final(void *arg, int howto) 159215e32d5dSMike Smith { 1593d33f4987STakanori Watanabe ACPI_STATUS status; 1594eeb3a05fSNate Lawson 1595eeb3a05fSNate Lawson /* 159680f0e4c2SNate Lawson * XXX Shutdown code should only run on the BSP (cpuid 0). 159780f0e4c2SNate Lawson * Some chipsets do not power off the system correctly if called from 159880f0e4c2SNate Lawson * an AP. 1599eeb3a05fSNate Lawson */ 1600eeb3a05fSNate Lawson if ((howto & RB_POWEROFF) != 0) { 1601904bf0c2SNate Lawson status = AcpiEnterSleepStatePrep(ACPI_STATE_S5); 1602904bf0c2SNate Lawson if (ACPI_FAILURE(status)) { 1603904bf0c2SNate Lawson printf("AcpiEnterSleepStatePrep failed - %s\n", 1604904bf0c2SNate Lawson AcpiFormatException(status)); 1605904bf0c2SNate Lawson return; 1606904bf0c2SNate Lawson } 1607eeb3a05fSNate Lawson printf("Powering system off using ACPI\n"); 160855398047SNate Lawson ACPI_DISABLE_IRQS(); 1609865b8d0bSNate Lawson status = AcpiEnterSleepState(ACPI_STATE_S5); 1610be2b1797SNate Lawson if (ACPI_FAILURE(status)) { 1611bfae45aaSMike Smith printf("ACPI power-off failed - %s\n", AcpiFormatException(status)); 161215e32d5dSMike Smith } else { 161315e32d5dSMike Smith DELAY(1000000); 161415e32d5dSMike Smith printf("ACPI power-off failed - timeout\n"); 161515e32d5dSMike Smith } 1616ba36768bSNate Lawson } else if (panicstr == NULL) { 161780f0e4c2SNate Lawson printf("Shutting down ACPI\n"); 161880f0e4c2SNate Lawson AcpiTerminate(); 161980f0e4c2SNate Lawson } 162015e32d5dSMike Smith } 162115e32d5dSMike Smith 162213d4f7baSMitsuru IWASAKI static void 162313d4f7baSMitsuru IWASAKI acpi_enable_fixed_events(struct acpi_softc *sc) 162413d4f7baSMitsuru IWASAKI { 162513d4f7baSMitsuru IWASAKI static int first_time = 1; 162613d4f7baSMitsuru IWASAKI 162713d4f7baSMitsuru IWASAKI /* Enable and clear fixed events and install handlers. */ 1628be2b1797SNate Lawson if (AcpiGbl_FADT != NULL && AcpiGbl_FADT->PwrButton == 0) { 162959ddeb18SNate Lawson AcpiClearEvent(ACPI_EVENT_POWER_BUTTON); 163013d4f7baSMitsuru IWASAKI AcpiInstallFixedEventHandler(ACPI_EVENT_POWER_BUTTON, 163133febf93SNate Lawson acpi_event_power_button_sleep, sc); 1632be2b1797SNate Lawson if (first_time) 16336c0e8467SNate Lawson device_printf(sc->acpi_dev, "Power Button (fixed)\n"); 163413d4f7baSMitsuru IWASAKI } 1635be2b1797SNate Lawson if (AcpiGbl_FADT != NULL && AcpiGbl_FADT->SleepButton == 0) { 163659ddeb18SNate Lawson AcpiClearEvent(ACPI_EVENT_SLEEP_BUTTON); 163713d4f7baSMitsuru IWASAKI AcpiInstallFixedEventHandler(ACPI_EVENT_SLEEP_BUTTON, 163833febf93SNate Lawson acpi_event_sleep_button_sleep, sc); 1639be2b1797SNate Lawson if (first_time) 16406c0e8467SNate Lawson device_printf(sc->acpi_dev, "Sleep Button (fixed)\n"); 164113d4f7baSMitsuru IWASAKI } 164213d4f7baSMitsuru IWASAKI 164313d4f7baSMitsuru IWASAKI first_time = 0; 164413d4f7baSMitsuru IWASAKI } 164513d4f7baSMitsuru IWASAKI 164615e32d5dSMike Smith /* 1647c5ba0be4SMike Smith * Returns true if the device is actually present and should 1648c5ba0be4SMike Smith * be attached to. This requires the present, enabled, UI-visible 1649c5ba0be4SMike Smith * and diagnostics-passed bits to be set. 1650c5ba0be4SMike Smith */ 1651c5ba0be4SMike Smith BOOLEAN 1652c5ba0be4SMike Smith acpi_DeviceIsPresent(device_t dev) 1653c5ba0be4SMike Smith { 16541e4925e8SNate Lawson ACPI_DEVICE_INFO *devinfo; 1655c5ba0be4SMike Smith ACPI_HANDLE h; 16561e4925e8SNate Lawson ACPI_BUFFER buf; 1657c5ba0be4SMike Smith ACPI_STATUS error; 16581e4925e8SNate Lawson int ret; 1659c5ba0be4SMike Smith 16601e4925e8SNate Lawson ret = FALSE; 1661c5ba0be4SMike Smith if ((h = acpi_get_handle(dev)) == NULL) 1662c5ba0be4SMike Smith return (FALSE); 16631e4925e8SNate Lawson buf.Pointer = NULL; 16641e4925e8SNate Lawson buf.Length = ACPI_ALLOCATE_BUFFER; 16656fca9360SNate Lawson error = AcpiGetObjectInfo(h, &buf); 16666fca9360SNate Lawson if (ACPI_FAILURE(error)) 1667c5ba0be4SMike Smith return (FALSE); 16681e4925e8SNate Lawson devinfo = (ACPI_DEVICE_INFO *)buf.Pointer; 1669be2b1797SNate Lawson 1670be2b1797SNate Lawson /* If no _STA method, must be present */ 16711e4925e8SNate Lawson if ((devinfo->Valid & ACPI_VALID_STA) == 0) 16721e4925e8SNate Lawson ret = TRUE; 1673be2b1797SNate Lawson 1674be2b1797SNate Lawson /* Return true for 'present' and 'functioning' */ 167517dbe0f7SNate Lawson if (ACPI_DEVICE_PRESENT(devinfo->CurrentStatus)) 16761e4925e8SNate Lawson ret = TRUE; 1677be2b1797SNate Lawson 16781e4925e8SNate Lawson AcpiOsFree(buf.Pointer); 16791e4925e8SNate Lawson return (ret); 1680c5ba0be4SMike Smith } 1681c5ba0be4SMike Smith 1682c5ba0be4SMike Smith /* 1683b53f2771SMike Smith * Returns true if the battery is actually present and inserted. 1684b53f2771SMike Smith */ 1685b53f2771SMike Smith BOOLEAN 1686b53f2771SMike Smith acpi_BatteryIsPresent(device_t dev) 1687b53f2771SMike Smith { 16881e4925e8SNate Lawson ACPI_DEVICE_INFO *devinfo; 1689b53f2771SMike Smith ACPI_HANDLE h; 16901e4925e8SNate Lawson ACPI_BUFFER buf; 1691b53f2771SMike Smith ACPI_STATUS error; 16921e4925e8SNate Lawson int ret; 1693b53f2771SMike Smith 16941e4925e8SNate Lawson ret = FALSE; 1695b53f2771SMike Smith if ((h = acpi_get_handle(dev)) == NULL) 1696b53f2771SMike Smith return (FALSE); 16971e4925e8SNate Lawson buf.Pointer = NULL; 16981e4925e8SNate Lawson buf.Length = ACPI_ALLOCATE_BUFFER; 16996fca9360SNate Lawson error = AcpiGetObjectInfo(h, &buf); 17006fca9360SNate Lawson if (ACPI_FAILURE(error)) 1701b53f2771SMike Smith return (FALSE); 17021e4925e8SNate Lawson devinfo = (ACPI_DEVICE_INFO *)buf.Pointer; 1703be2b1797SNate Lawson 1704be2b1797SNate Lawson /* If no _STA method, must be present */ 17051e4925e8SNate Lawson if ((devinfo->Valid & ACPI_VALID_STA) == 0) 17061e4925e8SNate Lawson ret = TRUE; 1707be2b1797SNate Lawson 170817dbe0f7SNate Lawson /* Return true for 'present', 'battery present', and 'functioning' */ 170917dbe0f7SNate Lawson if (ACPI_BATTERY_PRESENT(devinfo->CurrentStatus)) 17101e4925e8SNate Lawson ret = TRUE; 1711be2b1797SNate Lawson 17121e4925e8SNate Lawson AcpiOsFree(buf.Pointer); 17131e4925e8SNate Lawson return (ret); 1714b53f2771SMike Smith } 1715b53f2771SMike Smith 1716b53f2771SMike Smith /* 171791233413SNate Lawson * Match a HID string against a handle 171815e32d5dSMike Smith */ 1719ce619b2eSNate Lawson static BOOLEAN 1720ce619b2eSNate Lawson acpi_MatchHid(ACPI_HANDLE h, const char *hid) 172115e32d5dSMike Smith { 17221e4925e8SNate Lawson ACPI_DEVICE_INFO *devinfo; 17231e4925e8SNate Lawson ACPI_BUFFER buf; 172415e32d5dSMike Smith ACPI_STATUS error; 17251e4925e8SNate Lawson int ret, i; 172615e32d5dSMike Smith 17271e4925e8SNate Lawson ret = FALSE; 172891233413SNate Lawson if (hid == NULL || h == NULL) 172991233413SNate Lawson return (ret); 17301e4925e8SNate Lawson buf.Pointer = NULL; 17311e4925e8SNate Lawson buf.Length = ACPI_ALLOCATE_BUFFER; 17326fca9360SNate Lawson error = AcpiGetObjectInfo(h, &buf); 17336fca9360SNate Lawson if (ACPI_FAILURE(error)) 173491233413SNate Lawson return (ret); 17351e4925e8SNate Lawson devinfo = (ACPI_DEVICE_INFO *)buf.Pointer; 1736be2b1797SNate Lawson 1737c59c9a8eSJohn Baldwin if ((devinfo->Valid & ACPI_VALID_HID) != 0 && 1738c59c9a8eSJohn Baldwin strcmp(hid, devinfo->HardwareId.Value) == 0) 17391e4925e8SNate Lawson ret = TRUE; 1740c59c9a8eSJohn Baldwin else if ((devinfo->Valid & ACPI_VALID_CID) != 0) { 17411e4925e8SNate Lawson for (i = 0; i < devinfo->CompatibilityId.Count; i++) { 17421e4925e8SNate Lawson if (strcmp(hid, devinfo->CompatibilityId.Id[i].Value) == 0) { 17431e4925e8SNate Lawson ret = TRUE; 17441e4925e8SNate Lawson break; 17451e4925e8SNate Lawson } 17461e4925e8SNate Lawson } 17471e4925e8SNate Lawson } 1748be2b1797SNate Lawson 17491e4925e8SNate Lawson AcpiOsFree(buf.Pointer); 17501e4925e8SNate Lawson return (ret); 175115e32d5dSMike Smith } 175215e32d5dSMike Smith 175315e32d5dSMike Smith /* 1754c5ba0be4SMike Smith * Return the handle of a named object within our scope, ie. that of (parent) 1755c5ba0be4SMike Smith * or one if its parents. 1756c5ba0be4SMike Smith */ 1757c5ba0be4SMike Smith ACPI_STATUS 1758c5ba0be4SMike Smith acpi_GetHandleInScope(ACPI_HANDLE parent, char *path, ACPI_HANDLE *result) 1759c5ba0be4SMike Smith { 1760c5ba0be4SMike Smith ACPI_HANDLE r; 1761c5ba0be4SMike Smith ACPI_STATUS status; 1762c5ba0be4SMike Smith 1763be2b1797SNate Lawson /* Walk back up the tree to the root */ 1764c5ba0be4SMike Smith for (;;) { 1765be2b1797SNate Lawson status = AcpiGetHandle(parent, path, &r); 1766be2b1797SNate Lawson if (ACPI_SUCCESS(status)) { 1767c5ba0be4SMike Smith *result = r; 1768c5ba0be4SMike Smith return (AE_OK); 1769c5ba0be4SMike Smith } 1770bee4aa4aSNate Lawson /* XXX Return error here? */ 1771c5ba0be4SMike Smith if (status != AE_NOT_FOUND) 1772c5ba0be4SMike Smith return (AE_OK); 1773b53f2771SMike Smith if (ACPI_FAILURE(AcpiGetParent(parent, &r))) 1774c5ba0be4SMike Smith return (AE_NOT_FOUND); 1775c5ba0be4SMike Smith parent = r; 1776c5ba0be4SMike Smith } 1777c5ba0be4SMike Smith } 1778c5ba0be4SMike Smith 1779eea17c34SNate Lawson /* Find the difference between two PM tick counts. */ 1780eea17c34SNate Lawson uint32_t 1781eea17c34SNate Lawson acpi_TimerDelta(uint32_t end, uint32_t start) 1782eea17c34SNate Lawson { 1783eea17c34SNate Lawson uint32_t delta; 1784eea17c34SNate Lawson 1785eea17c34SNate Lawson if (end >= start) 1786eea17c34SNate Lawson delta = end - start; 1787eea17c34SNate Lawson else if (AcpiGbl_FADT->TmrValExt == 0) 17888d01ceefSNate Lawson delta = ((0x00FFFFFF - start) + end + 1) & 0x00FFFFFF; 1789eea17c34SNate Lawson else 1790eea17c34SNate Lawson delta = ((0xFFFFFFFF - start) + end + 1); 1791eea17c34SNate Lawson return (delta); 1792eea17c34SNate Lawson } 1793eea17c34SNate Lawson 1794c5ba0be4SMike Smith /* 1795c5ba0be4SMike Smith * Allocate a buffer with a preset data size. 1796c5ba0be4SMike Smith */ 1797c5ba0be4SMike Smith ACPI_BUFFER * 1798c5ba0be4SMike Smith acpi_AllocBuffer(int size) 1799c5ba0be4SMike Smith { 1800c5ba0be4SMike Smith ACPI_BUFFER *buf; 1801c5ba0be4SMike Smith 1802c5ba0be4SMike Smith if ((buf = malloc(size + sizeof(*buf), M_ACPIDEV, M_NOWAIT)) == NULL) 1803c5ba0be4SMike Smith return (NULL); 1804c5ba0be4SMike Smith buf->Length = size; 1805c5ba0be4SMike Smith buf->Pointer = (void *)(buf + 1); 1806c5ba0be4SMike Smith return (buf); 1807c5ba0be4SMike Smith } 1808c5ba0be4SMike Smith 1809c310653eSNate Lawson ACPI_STATUS 1810cc58e4eeSNate Lawson acpi_SetInteger(ACPI_HANDLE handle, char *path, UINT32 number) 1811c310653eSNate Lawson { 1812c310653eSNate Lawson ACPI_OBJECT arg1; 1813c310653eSNate Lawson ACPI_OBJECT_LIST args; 1814c310653eSNate Lawson 1815c310653eSNate Lawson arg1.Type = ACPI_TYPE_INTEGER; 1816c310653eSNate Lawson arg1.Integer.Value = number; 1817c310653eSNate Lawson args.Count = 1; 1818c310653eSNate Lawson args.Pointer = &arg1; 1819c310653eSNate Lawson 1820c310653eSNate Lawson return (AcpiEvaluateObject(handle, path, &args, NULL)); 1821c310653eSNate Lawson } 1822c310653eSNate Lawson 1823c5ba0be4SMike Smith /* 1824c5ba0be4SMike Smith * Evaluate a path that should return an integer. 1825c5ba0be4SMike Smith */ 1826c5ba0be4SMike Smith ACPI_STATUS 1827cc58e4eeSNate Lawson acpi_GetInteger(ACPI_HANDLE handle, char *path, UINT32 *number) 1828c5ba0be4SMike Smith { 1829be2b1797SNate Lawson ACPI_STATUS status; 1830c5ba0be4SMike Smith ACPI_BUFFER buf; 1831c573e654SMitsuru IWASAKI ACPI_OBJECT param; 1832c5ba0be4SMike Smith 1833c5ba0be4SMike Smith if (handle == NULL) 1834c5ba0be4SMike Smith handle = ACPI_ROOT_OBJECT; 18350c7da7acSJohn Baldwin 18360c7da7acSJohn Baldwin /* 18370c7da7acSJohn Baldwin * Assume that what we've been pointed at is an Integer object, or 18380c7da7acSJohn Baldwin * a method that will return an Integer. 18390c7da7acSJohn Baldwin */ 1840c5ba0be4SMike Smith buf.Pointer = ¶m; 1841c5ba0be4SMike Smith buf.Length = sizeof(param); 1842be2b1797SNate Lawson status = AcpiEvaluateObject(handle, path, NULL, &buf); 1843be2b1797SNate Lawson if (ACPI_SUCCESS(status)) { 1844be2b1797SNate Lawson if (param.Type == ACPI_TYPE_INTEGER) 1845c5ba0be4SMike Smith *number = param.Integer.Value; 1846be2b1797SNate Lawson else 1847be2b1797SNate Lawson status = AE_TYPE; 1848c5ba0be4SMike Smith } 18490c7da7acSJohn Baldwin 18500c7da7acSJohn Baldwin /* 18510c7da7acSJohn Baldwin * In some applications, a method that's expected to return an Integer 18520c7da7acSJohn Baldwin * may instead return a Buffer (probably to simplify some internal 18530c7da7acSJohn Baldwin * arithmetic). We'll try to fetch whatever it is, and if it's a Buffer, 18540c7da7acSJohn Baldwin * convert it into an Integer as best we can. 18550c7da7acSJohn Baldwin * 18560c7da7acSJohn Baldwin * This is a hack. 18570c7da7acSJohn Baldwin */ 1858be2b1797SNate Lawson if (status == AE_BUFFER_OVERFLOW) { 1859b53f2771SMike Smith if ((buf.Pointer = AcpiOsAllocate(buf.Length)) == NULL) { 1860be2b1797SNate Lawson status = AE_NO_MEMORY; 18610c7da7acSJohn Baldwin } else { 1862be2b1797SNate Lawson status = AcpiEvaluateObject(handle, path, NULL, &buf); 1863be2b1797SNate Lawson if (ACPI_SUCCESS(status)) 1864be2b1797SNate Lawson status = acpi_ConvertBufferToInteger(&buf, number); 18650c7da7acSJohn Baldwin AcpiOsFree(buf.Pointer); 18660c7da7acSJohn Baldwin } 1867f97739daSNate Lawson } 1868be2b1797SNate Lawson return (status); 1869c5ba0be4SMike Smith } 1870c5ba0be4SMike Smith 1871c573e654SMitsuru IWASAKI ACPI_STATUS 1872cc58e4eeSNate Lawson acpi_ConvertBufferToInteger(ACPI_BUFFER *bufp, UINT32 *number) 1873c573e654SMitsuru IWASAKI { 1874c573e654SMitsuru IWASAKI ACPI_OBJECT *p; 1875dba55fa2SNate Lawson UINT8 *val; 1876c573e654SMitsuru IWASAKI int i; 1877c573e654SMitsuru IWASAKI 1878c573e654SMitsuru IWASAKI p = (ACPI_OBJECT *)bufp->Pointer; 1879c573e654SMitsuru IWASAKI if (p->Type == ACPI_TYPE_INTEGER) { 1880c573e654SMitsuru IWASAKI *number = p->Integer.Value; 1881c573e654SMitsuru IWASAKI return (AE_OK); 1882c573e654SMitsuru IWASAKI } 1883c573e654SMitsuru IWASAKI if (p->Type != ACPI_TYPE_BUFFER) 1884c573e654SMitsuru IWASAKI return (AE_TYPE); 1885c573e654SMitsuru IWASAKI if (p->Buffer.Length > sizeof(int)) 1886c573e654SMitsuru IWASAKI return (AE_BAD_DATA); 1887be2b1797SNate Lawson 1888c573e654SMitsuru IWASAKI *number = 0; 1889dba55fa2SNate Lawson val = p->Buffer.Pointer; 1890c573e654SMitsuru IWASAKI for (i = 0; i < p->Buffer.Length; i++) 1891dba55fa2SNate Lawson *number += val[i] << (i * 8); 1892c573e654SMitsuru IWASAKI return (AE_OK); 1893c573e654SMitsuru IWASAKI } 1894c573e654SMitsuru IWASAKI 1895c5ba0be4SMike Smith /* 1896c5ba0be4SMike Smith * Iterate over the elements of an a package object, calling the supplied 1897c5ba0be4SMike Smith * function for each element. 1898c5ba0be4SMike Smith * 1899c5ba0be4SMike Smith * XXX possible enhancement might be to abort traversal on error. 1900c5ba0be4SMike Smith */ 1901c5ba0be4SMike Smith ACPI_STATUS 1902be2b1797SNate Lawson acpi_ForeachPackageObject(ACPI_OBJECT *pkg, 1903be2b1797SNate Lawson void (*func)(ACPI_OBJECT *comp, void *arg), void *arg) 1904c5ba0be4SMike Smith { 1905c5ba0be4SMike Smith ACPI_OBJECT *comp; 1906c5ba0be4SMike Smith int i; 1907c5ba0be4SMike Smith 1908be2b1797SNate Lawson if (pkg == NULL || pkg->Type != ACPI_TYPE_PACKAGE) 1909c5ba0be4SMike Smith return (AE_BAD_PARAMETER); 1910c5ba0be4SMike Smith 1911be2b1797SNate Lawson /* Iterate over components */ 1912be2b1797SNate Lawson i = 0; 1913be2b1797SNate Lawson comp = pkg->Package.Elements; 1914be2b1797SNate Lawson for (; i < pkg->Package.Count; i++, comp++) 1915c5ba0be4SMike Smith func(comp, arg); 1916c5ba0be4SMike Smith 1917c5ba0be4SMike Smith return (AE_OK); 1918c5ba0be4SMike Smith } 1919c5ba0be4SMike Smith 19206f69255bSMike Smith /* 19216f69255bSMike Smith * Find the (index)th resource object in a set. 19226f69255bSMike Smith */ 19236f69255bSMike Smith ACPI_STATUS 19246d63101aSMike Smith acpi_FindIndexedResource(ACPI_BUFFER *buf, int index, ACPI_RESOURCE **resp) 19256f69255bSMike Smith { 19266d63101aSMike Smith ACPI_RESOURCE *rp; 19276f69255bSMike Smith int i; 19286f69255bSMike Smith 19296d63101aSMike Smith rp = (ACPI_RESOURCE *)buf->Pointer; 19306f69255bSMike Smith i = index; 19316d63101aSMike Smith while (i-- > 0) { 1932be2b1797SNate Lawson /* Range check */ 19336d63101aSMike Smith if (rp > (ACPI_RESOURCE *)((u_int8_t *)buf->Pointer + buf->Length)) 19346f69255bSMike Smith return (AE_BAD_PARAMETER); 1935be2b1797SNate Lawson 1936be2b1797SNate Lawson /* Check for terminator */ 1937be2b1797SNate Lawson if (rp->Id == ACPI_RSTYPE_END_TAG || rp->Length == 0) 19386d63101aSMike Smith return (AE_NOT_FOUND); 1939abcbc5bcSNate Lawson rp = ACPI_NEXT_RESOURCE(rp); 19406f69255bSMike Smith } 19416f69255bSMike Smith if (resp != NULL) 19426d63101aSMike Smith *resp = rp; 1943be2b1797SNate Lawson 19446d63101aSMike Smith return (AE_OK); 19456d63101aSMike Smith } 19466d63101aSMike Smith 19476d63101aSMike Smith /* 19486d63101aSMike Smith * Append an ACPI_RESOURCE to an ACPI_BUFFER. 19496d63101aSMike Smith * 19506d63101aSMike Smith * Given a pointer to an ACPI_RESOURCE structure, expand the ACPI_BUFFER 19516d63101aSMike Smith * provided to contain it. If the ACPI_BUFFER is empty, allocate a sensible 19526d63101aSMike Smith * backing block. If the ACPI_RESOURCE is NULL, return an empty set of 19536d63101aSMike Smith * resources. 19546d63101aSMike Smith */ 19556d63101aSMike Smith #define ACPI_INITIAL_RESOURCE_BUFFER_SIZE 512 19566d63101aSMike Smith 19576d63101aSMike Smith ACPI_STATUS 19586d63101aSMike Smith acpi_AppendBufferResource(ACPI_BUFFER *buf, ACPI_RESOURCE *res) 19596d63101aSMike Smith { 19606d63101aSMike Smith ACPI_RESOURCE *rp; 19616d63101aSMike Smith void *newp; 19626d63101aSMike Smith 1963be2b1797SNate Lawson /* Initialise the buffer if necessary. */ 19646d63101aSMike Smith if (buf->Pointer == NULL) { 19656d63101aSMike Smith buf->Length = ACPI_INITIAL_RESOURCE_BUFFER_SIZE; 19666d63101aSMike Smith if ((buf->Pointer = AcpiOsAllocate(buf->Length)) == NULL) 19676d63101aSMike Smith return (AE_NO_MEMORY); 19686d63101aSMike Smith rp = (ACPI_RESOURCE *)buf->Pointer; 19696d63101aSMike Smith rp->Id = ACPI_RSTYPE_END_TAG; 19706d63101aSMike Smith rp->Length = 0; 19716d63101aSMike Smith } 19726d63101aSMike Smith if (res == NULL) 19736d63101aSMike Smith return (AE_OK); 19746d63101aSMike Smith 19756d63101aSMike Smith /* 19766d63101aSMike Smith * Scan the current buffer looking for the terminator. 19776d63101aSMike Smith * This will either find the terminator or hit the end 19786d63101aSMike Smith * of the buffer and return an error. 19796d63101aSMike Smith */ 19806d63101aSMike Smith rp = (ACPI_RESOURCE *)buf->Pointer; 19816d63101aSMike Smith for (;;) { 1982be2b1797SNate Lawson /* Range check, don't go outside the buffer */ 19836d63101aSMike Smith if (rp >= (ACPI_RESOURCE *)((u_int8_t *)buf->Pointer + buf->Length)) 19846d63101aSMike Smith return (AE_BAD_PARAMETER); 1985be2b1797SNate Lawson if (rp->Id == ACPI_RSTYPE_END_TAG || rp->Length == 0) 19866d63101aSMike Smith break; 1987abcbc5bcSNate Lawson rp = ACPI_NEXT_RESOURCE(rp); 19886d63101aSMike Smith } 19896d63101aSMike Smith 19906d63101aSMike Smith /* 19916d63101aSMike Smith * Check the size of the buffer and expand if required. 19926d63101aSMike Smith * 19936d63101aSMike Smith * Required size is: 19946d63101aSMike Smith * size of existing resources before terminator + 19956d63101aSMike Smith * size of new resource and header + 19966d63101aSMike Smith * size of terminator. 19976d63101aSMike Smith * 19986d63101aSMike Smith * Note that this loop should really only run once, unless 19996d63101aSMike Smith * for some reason we are stuffing a *really* huge resource. 20006d63101aSMike Smith */ 20016d63101aSMike Smith while ((((u_int8_t *)rp - (u_int8_t *)buf->Pointer) + 20026d63101aSMike Smith res->Length + ACPI_RESOURCE_LENGTH_NO_DATA + 20036d63101aSMike Smith ACPI_RESOURCE_LENGTH) >= buf->Length) { 20046d63101aSMike Smith if ((newp = AcpiOsAllocate(buf->Length * 2)) == NULL) 20056d63101aSMike Smith return (AE_NO_MEMORY); 20066d63101aSMike Smith bcopy(buf->Pointer, newp, buf->Length); 2007a692219dSMike Smith rp = (ACPI_RESOURCE *)((u_int8_t *)newp + 2008a692219dSMike Smith ((u_int8_t *)rp - (u_int8_t *)buf->Pointer)); 20096d63101aSMike Smith AcpiOsFree(buf->Pointer); 20106d63101aSMike Smith buf->Pointer = newp; 20116d63101aSMike Smith buf->Length += buf->Length; 20126d63101aSMike Smith } 20136d63101aSMike Smith 2014be2b1797SNate Lawson /* Insert the new resource. */ 20156d63101aSMike Smith bcopy(res, rp, res->Length + ACPI_RESOURCE_LENGTH_NO_DATA); 20166d63101aSMike Smith 2017be2b1797SNate Lawson /* And add the terminator. */ 2018abcbc5bcSNate Lawson rp = ACPI_NEXT_RESOURCE(rp); 20196d63101aSMike Smith rp->Id = ACPI_RSTYPE_END_TAG; 20206d63101aSMike Smith rp->Length = 0; 20216d63101aSMike Smith 20226f69255bSMike Smith return (AE_OK); 20236f69255bSMike Smith } 2024c5ba0be4SMike Smith 2025da14ac9fSJohn Baldwin /* 2026da14ac9fSJohn Baldwin * Set interrupt model. 2027da14ac9fSJohn Baldwin */ 2028da14ac9fSJohn Baldwin ACPI_STATUS 2029da14ac9fSJohn Baldwin acpi_SetIntrModel(int model) 2030da14ac9fSJohn Baldwin { 2031da14ac9fSJohn Baldwin 2032c310653eSNate Lawson return (acpi_SetInteger(ACPI_ROOT_OBJECT, "_PIC", model)); 2033da14ac9fSJohn Baldwin } 2034da14ac9fSJohn Baldwin 2035ece50487SMitsuru IWASAKI static void 2036ece50487SMitsuru IWASAKI acpi_sleep_enable(void *arg) 2037ece50487SMitsuru IWASAKI { 2038bee4aa4aSNate Lawson 2039ece50487SMitsuru IWASAKI ((struct acpi_softc *)arg)->acpi_sleep_disabled = 0; 2040ece50487SMitsuru IWASAKI } 2041c30382dfSMitsuru IWASAKI 204215e2f34fSNate Lawson enum acpi_sleep_state { 204315e2f34fSNate Lawson ACPI_SS_NONE, 204415e2f34fSNate Lawson ACPI_SS_GPE_SET, 204515e2f34fSNate Lawson ACPI_SS_DEV_SUSPEND, 204615e2f34fSNate Lawson ACPI_SS_SLP_PREP, 204715e2f34fSNate Lawson ACPI_SS_SLEPT, 204815e2f34fSNate Lawson }; 204915e2f34fSNate Lawson 205015e32d5dSMike Smith /* 205115e32d5dSMike Smith * Set the system sleep state 205215e32d5dSMike Smith * 2053be2b1797SNate Lawson * Currently we support S1-S5 but S4 is only S4BIOS 205415e32d5dSMike Smith */ 205515e32d5dSMike Smith ACPI_STATUS 205615e32d5dSMike Smith acpi_SetSleepState(struct acpi_softc *sc, int state) 205715e32d5dSMike Smith { 205815e2f34fSNate Lawson ACPI_STATUS status; 205956d8cb57SMitsuru IWASAKI UINT8 TypeA; 206056d8cb57SMitsuru IWASAKI UINT8 TypeB; 206115e2f34fSNate Lawson enum acpi_sleep_state slp_state; 206215e32d5dSMike Smith 2063b4a05238SPeter Wemm ACPI_FUNCTION_TRACE_U32((char *)(uintptr_t)__func__, state); 20640ae55423SMike Smith 206515e2f34fSNate Lawson status = AE_OK; 206615e2f34fSNate Lawson ACPI_LOCK(acpi); 206715e2f34fSNate Lawson if (sc->acpi_sleep_disabled) { 20686397624dSMitsuru IWASAKI if (sc->acpi_sstate != ACPI_STATE_S0) 206915e2f34fSNate Lawson status = AE_ERROR; 207015e2f34fSNate Lawson ACPI_UNLOCK(acpi); 207115e2f34fSNate Lawson printf("acpi: suspend request ignored (not ready yet)\n"); 207215e2f34fSNate Lawson return (status); 207315e2f34fSNate Lawson } 207415e2f34fSNate Lawson sc->acpi_sleep_disabled = 1; 207515e2f34fSNate Lawson ACPI_UNLOCK(acpi); 20766397624dSMitsuru IWASAKI 20775d3d03f1SNate Lawson /* 20785d3d03f1SNate Lawson * Be sure to hold Giant across DEVICE_SUSPEND/RESUME since non-MPSAFE 20795d3d03f1SNate Lawson * drivers need this. 20805d3d03f1SNate Lawson */ 20815d3d03f1SNate Lawson mtx_lock(&Giant); 208215e2f34fSNate Lawson slp_state = ACPI_SS_NONE; 208315e32d5dSMike Smith switch (state) { 208415e32d5dSMike Smith case ACPI_STATE_S1: 20856161544cSTakanori Watanabe case ACPI_STATE_S2: 20866161544cSTakanori Watanabe case ACPI_STATE_S3: 20876161544cSTakanori Watanabe case ACPI_STATE_S4: 2088adad4744SNate Lawson status = AcpiGetSleepTypeData(state, &TypeA, &TypeB); 208998175614SNate Lawson if (status == AE_NOT_FOUND) { 209098175614SNate Lawson device_printf(sc->acpi_dev, 209198175614SNate Lawson "Sleep state S%d not supported by BIOS\n", state); 209298175614SNate Lawson break; 209398175614SNate Lawson } else if (ACPI_FAILURE(status)) { 2094be2b1797SNate Lawson device_printf(sc->acpi_dev, "AcpiGetSleepTypeData failed - %s\n", 2095be2b1797SNate Lawson AcpiFormatException(status)); 209656d8cb57SMitsuru IWASAKI break; 209756d8cb57SMitsuru IWASAKI } 209856d8cb57SMitsuru IWASAKI 2099a1fccb47SMitsuru IWASAKI sc->acpi_sstate = state; 2100a1fccb47SMitsuru IWASAKI 2101d4b9ff91SNate Lawson /* Enable any GPEs as appropriate and requested by the user. */ 2102d4b9ff91SNate Lawson acpi_wake_prep_walk(state); 210315e2f34fSNate Lawson slp_state = ACPI_SS_GPE_SET; 2104e8b4d56eSNate Lawson 210515e32d5dSMike Smith /* 2106c7f88fc3SNate Lawson * Inform all devices that we are going to sleep. If at least one 2107c7f88fc3SNate Lawson * device fails, DEVICE_SUSPEND() automatically resumes the tree. 210815e32d5dSMike Smith * 2109c7f88fc3SNate Lawson * XXX Note that a better two-pass approach with a 'veto' pass 2110c7f88fc3SNate Lawson * followed by a "real thing" pass would be better, but the current 2111c7f88fc3SNate Lawson * bus interface does not provide for this. 211215e32d5dSMike Smith */ 211315e2f34fSNate Lawson if (DEVICE_SUSPEND(root_bus) != 0) { 211415e2f34fSNate Lawson device_printf(sc->acpi_dev, "device_suspend failed\n"); 211515e2f34fSNate Lawson break; 211615e2f34fSNate Lawson } 211715e2f34fSNate Lawson slp_state = ACPI_SS_DEV_SUSPEND; 2118b9c780d6SMitsuru IWASAKI 2119be2b1797SNate Lawson status = AcpiEnterSleepStatePrep(state); 2120be2b1797SNate Lawson if (ACPI_FAILURE(status)) { 2121b9c780d6SMitsuru IWASAKI device_printf(sc->acpi_dev, "AcpiEnterSleepStatePrep failed - %s\n", 2122b9c780d6SMitsuru IWASAKI AcpiFormatException(status)); 2123b9c780d6SMitsuru IWASAKI break; 2124b9c780d6SMitsuru IWASAKI } 212515e2f34fSNate Lawson slp_state = ACPI_SS_SLP_PREP; 2126b9c780d6SMitsuru IWASAKI 2127be2b1797SNate Lawson if (sc->acpi_sleep_delay > 0) 2128ff01efb5SMitsuru IWASAKI DELAY(sc->acpi_sleep_delay * 1000000); 2129ff01efb5SMitsuru IWASAKI 21306161544cSTakanori Watanabe if (state != ACPI_STATE_S1) { 21316161544cSTakanori Watanabe acpi_sleep_machdep(sc, state); 21326161544cSTakanori Watanabe 21336161544cSTakanori Watanabe /* Re-enable ACPI hardware on wakeup from sleep state 4. */ 2134be2b1797SNate Lawson if (state == ACPI_STATE_S4) 2135964679ceSMitsuru IWASAKI AcpiEnable(); 21366161544cSTakanori Watanabe } else { 2137c7f88fc3SNate Lawson ACPI_DISABLE_IRQS(); 2138adad4744SNate Lawson status = AcpiEnterSleepState(state); 2139be2b1797SNate Lawson if (ACPI_FAILURE(status)) { 2140be2b1797SNate Lawson device_printf(sc->acpi_dev, "AcpiEnterSleepState failed - %s\n", 2141be2b1797SNate Lawson AcpiFormatException(status)); 2142c30382dfSMitsuru IWASAKI break; 214315e32d5dSMike Smith } 21446161544cSTakanori Watanabe } 214515e2f34fSNate Lawson slp_state = ACPI_SS_SLEPT; 214615e32d5dSMike Smith break; 214715e32d5dSMike Smith case ACPI_STATE_S5: 214815e32d5dSMike Smith /* 214915e32d5dSMike Smith * Shut down cleanly and power off. This will call us back through the 215015e32d5dSMike Smith * shutdown handlers. 215115e32d5dSMike Smith */ 215215e32d5dSMike Smith shutdown_nice(RB_POWEROFF); 215315e32d5dSMike Smith break; 215498175614SNate Lawson case ACPI_STATE_S0: 215515e32d5dSMike Smith default: 215615e32d5dSMike Smith status = AE_BAD_PARAMETER; 215715e32d5dSMike Smith break; 215815e32d5dSMike Smith } 2159ece50487SMitsuru IWASAKI 216015e2f34fSNate Lawson /* 216115e2f34fSNate Lawson * Back out state according to how far along we got in the suspend 216215e2f34fSNate Lawson * process. This handles both the error and success cases. 216315e2f34fSNate Lawson */ 216415e2f34fSNate Lawson if (slp_state >= ACPI_SS_GPE_SET) { 216515e2f34fSNate Lawson acpi_wake_prep_walk(state); 216615e2f34fSNate Lawson sc->acpi_sstate = ACPI_STATE_S0; 216715e2f34fSNate Lawson } 216815e2f34fSNate Lawson if (slp_state >= ACPI_SS_SLP_PREP) 216915e2f34fSNate Lawson AcpiLeaveSleepState(state); 2170071339e2SNate Lawson if (slp_state >= ACPI_SS_DEV_SUSPEND) 2171071339e2SNate Lawson DEVICE_RESUME(root_bus); 217215e2f34fSNate Lawson if (slp_state >= ACPI_SS_SLEPT) 217315e2f34fSNate Lawson acpi_enable_fixed_events(sc); 217415e2f34fSNate Lawson 217515e2f34fSNate Lawson /* Allow another sleep request after a while. */ 217615e2f34fSNate Lawson if (state != ACPI_STATE_S5) 2177ece50487SMitsuru IWASAKI timeout(acpi_sleep_enable, (caddr_t)sc, hz * ACPI_MINIMUM_AWAKETIME); 2178ece50487SMitsuru IWASAKI 21795d3d03f1SNate Lawson mtx_unlock(&Giant); 21800ae55423SMike Smith return_ACPI_STATUS (status); 218115e32d5dSMike Smith } 218215e32d5dSMike Smith 2183e8b4d56eSNate Lawson /* Initialize a device's wake GPE. */ 2184e8b4d56eSNate Lawson int 2185e8b4d56eSNate Lawson acpi_wake_init(device_t dev, int type) 2186e8b4d56eSNate Lawson { 2187e8b4d56eSNate Lawson struct acpi_prw_data prw; 2188e8b4d56eSNate Lawson 2189e8b4d56eSNate Lawson /* Evaluate _PRW to find the GPE. */ 2190e8b4d56eSNate Lawson if (acpi_parse_prw(acpi_get_handle(dev), &prw) != 0) 2191e8b4d56eSNate Lawson return (ENXIO); 2192e8b4d56eSNate Lawson 2193e8b4d56eSNate Lawson /* Set the requested type for the GPE (runtime, wake, or both). */ 2194e8b4d56eSNate Lawson if (ACPI_FAILURE(AcpiSetGpeType(prw.gpe_handle, prw.gpe_bit, type))) { 2195e8b4d56eSNate Lawson device_printf(dev, "set GPE type failed\n"); 2196e8b4d56eSNate Lawson return (ENXIO); 2197e8b4d56eSNate Lawson } 2198e8b4d56eSNate Lawson 2199e8b4d56eSNate Lawson return (0); 2200e8b4d56eSNate Lawson } 2201e8b4d56eSNate Lawson 2202e8b4d56eSNate Lawson /* Enable or disable the device's wake GPE. */ 2203e8b4d56eSNate Lawson int 2204e8b4d56eSNate Lawson acpi_wake_set_enable(device_t dev, int enable) 2205e8b4d56eSNate Lawson { 2206e8b4d56eSNate Lawson struct acpi_prw_data prw; 2207e8b4d56eSNate Lawson ACPI_HANDLE handle; 2208e8b4d56eSNate Lawson ACPI_STATUS status; 2209e8b4d56eSNate Lawson int flags; 2210e8b4d56eSNate Lawson 2211d4b9ff91SNate Lawson /* Make sure the device supports waking the system and get the GPE. */ 2212e8b4d56eSNate Lawson handle = acpi_get_handle(dev); 2213e8b4d56eSNate Lawson if (acpi_parse_prw(handle, &prw) != 0) 2214e8b4d56eSNate Lawson return (ENXIO); 2215e8b4d56eSNate Lawson 2216d4b9ff91SNate Lawson flags = acpi_get_flags(dev); 2217e8b4d56eSNate Lawson if (enable) { 2218e8b4d56eSNate Lawson status = AcpiEnableGpe(prw.gpe_handle, prw.gpe_bit, ACPI_NOT_ISR); 2219e8b4d56eSNate Lawson if (ACPI_FAILURE(status)) { 2220e8b4d56eSNate Lawson device_printf(dev, "enable wake failed\n"); 2221e8b4d56eSNate Lawson return (ENXIO); 2222e8b4d56eSNate Lawson } 2223d4b9ff91SNate Lawson acpi_set_flags(dev, flags | ACPI_FLAG_WAKE_ENABLED); 2224e8b4d56eSNate Lawson } else { 2225e8b4d56eSNate Lawson status = AcpiDisableGpe(prw.gpe_handle, prw.gpe_bit, ACPI_NOT_ISR); 2226e8b4d56eSNate Lawson if (ACPI_FAILURE(status)) { 2227e8b4d56eSNate Lawson device_printf(dev, "disable wake failed\n"); 2228e8b4d56eSNate Lawson return (ENXIO); 2229e8b4d56eSNate Lawson } 2230d4b9ff91SNate Lawson acpi_set_flags(dev, flags & ~ACPI_FLAG_WAKE_ENABLED); 2231e8b4d56eSNate Lawson } 2232e8b4d56eSNate Lawson 2233e8b4d56eSNate Lawson return (0); 2234e8b4d56eSNate Lawson } 2235e8b4d56eSNate Lawson 2236d4b9ff91SNate Lawson static int 2237d4b9ff91SNate Lawson acpi_wake_sleep_prep(ACPI_HANDLE handle, int sstate) 2238e8b4d56eSNate Lawson { 2239e8b4d56eSNate Lawson struct acpi_prw_data prw; 2240d4b9ff91SNate Lawson device_t dev; 2241e8b4d56eSNate Lawson 2242d4b9ff91SNate Lawson /* Check that this is a wake-capable device and get its GPE. */ 2243e8b4d56eSNate Lawson if (acpi_parse_prw(handle, &prw) != 0) 2244e8b4d56eSNate Lawson return (ENXIO); 2245d4b9ff91SNate Lawson dev = acpi_get_device(handle); 2246e8b4d56eSNate Lawson 2247e8b4d56eSNate Lawson /* 2248d4b9ff91SNate Lawson * The destination sleep state must be less than (i.e., higher power) 2249d4b9ff91SNate Lawson * or equal to the value specified by _PRW. If this GPE cannot be 2250d4b9ff91SNate Lawson * enabled for the next sleep state, then disable it. If it can and 2251d4b9ff91SNate Lawson * the user requested it be enabled, turn on any required power resources 2252d4b9ff91SNate Lawson * and set _PSW. 2253e8b4d56eSNate Lawson */ 2254d4b9ff91SNate Lawson if (sstate > prw.lowest_wake) { 2255cc85c78cSNate Lawson AcpiDisableGpe(prw.gpe_handle, prw.gpe_bit, ACPI_NOT_ISR); 2256e8b4d56eSNate Lawson if (bootverbose) 2257d4b9ff91SNate Lawson device_printf(dev, "wake_prep disabled wake for %s (S%d)\n", 2258d4b9ff91SNate Lawson acpi_name(handle), sstate); 2259d4b9ff91SNate Lawson } else if (dev && (acpi_get_flags(dev) & ACPI_FLAG_WAKE_ENABLED) != 0) { 2260d4b9ff91SNate Lawson acpi_pwr_wake_enable(handle, 1); 2261d4b9ff91SNate Lawson acpi_SetInteger(handle, "_PSW", 1); 2262d4b9ff91SNate Lawson if (bootverbose) 2263d4b9ff91SNate Lawson device_printf(dev, "wake_prep enabled for %s (S%d)\n", 2264d4b9ff91SNate Lawson acpi_name(handle), sstate); 2265d4b9ff91SNate Lawson } 2266cc85c78cSNate Lawson 2267cc85c78cSNate Lawson return (0); 2268e8b4d56eSNate Lawson } 2269e8b4d56eSNate Lawson 2270d4b9ff91SNate Lawson static int 2271d4b9ff91SNate Lawson acpi_wake_run_prep(ACPI_HANDLE handle, int sstate) 2272cc85c78cSNate Lawson { 2273cc85c78cSNate Lawson struct acpi_prw_data prw; 2274d4b9ff91SNate Lawson device_t dev; 2275cc85c78cSNate Lawson 2276cc85c78cSNate Lawson /* 2277d4b9ff91SNate Lawson * Check that this is a wake-capable device and get its GPE. Return 2278d4b9ff91SNate Lawson * now if the user didn't enable this device for wake. 2279cc85c78cSNate Lawson */ 2280d4b9ff91SNate Lawson if (acpi_parse_prw(handle, &prw) != 0) 2281d4b9ff91SNate Lawson return (ENXIO); 2282d4b9ff91SNate Lawson dev = acpi_get_device(handle); 2283d4b9ff91SNate Lawson if (dev == NULL || (acpi_get_flags(dev) & ACPI_FLAG_WAKE_ENABLED) == 0) 2284d4b9ff91SNate Lawson return (0); 2285cc85c78cSNate Lawson 2286d4b9ff91SNate Lawson /* 2287d4b9ff91SNate Lawson * If this GPE couldn't be enabled for the previous sleep state, it was 2288d4b9ff91SNate Lawson * disabled before going to sleep so re-enable it. If it was enabled, 2289d4b9ff91SNate Lawson * clear _PSW and turn off any power resources it used. 2290d4b9ff91SNate Lawson */ 2291d4b9ff91SNate Lawson if (sstate > prw.lowest_wake) { 2292cc85c78cSNate Lawson AcpiEnableGpe(prw.gpe_handle, prw.gpe_bit, ACPI_NOT_ISR); 2293d4b9ff91SNate Lawson if (bootverbose) 2294d4b9ff91SNate Lawson device_printf(dev, "run_prep re-enabled %s\n", acpi_name(handle)); 2295d4b9ff91SNate Lawson } else { 2296d4b9ff91SNate Lawson acpi_SetInteger(handle, "_PSW", 0); 2297d4b9ff91SNate Lawson acpi_pwr_wake_enable(handle, 0); 2298d4b9ff91SNate Lawson if (bootverbose) 2299d4b9ff91SNate Lawson device_printf(dev, "run_prep cleaned up for %s\n", 2300d4b9ff91SNate Lawson acpi_name(handle)); 2301d4b9ff91SNate Lawson } 2302d4b9ff91SNate Lawson 2303e8b4d56eSNate Lawson return (0); 2304e8b4d56eSNate Lawson } 2305e8b4d56eSNate Lawson 2306e8b4d56eSNate Lawson static ACPI_STATUS 2307d4b9ff91SNate Lawson acpi_wake_prep(ACPI_HANDLE handle, UINT32 level, void *context, void **status) 2308e8b4d56eSNate Lawson { 2309d4b9ff91SNate Lawson int sstate; 2310e8b4d56eSNate Lawson 2311d4b9ff91SNate Lawson /* If suspending, run the sleep prep function, otherwise wake. */ 2312d4b9ff91SNate Lawson sstate = *(int *)context; 2313d4b9ff91SNate Lawson if (AcpiGbl_SystemAwakeAndRunning) 2314d4b9ff91SNate Lawson acpi_wake_sleep_prep(handle, sstate); 2315d4b9ff91SNate Lawson else 2316d4b9ff91SNate Lawson acpi_wake_run_prep(handle, sstate); 2317e8b4d56eSNate Lawson return (AE_OK); 2318e8b4d56eSNate Lawson } 2319e8b4d56eSNate Lawson 2320d4b9ff91SNate Lawson /* Walk the tree rooted at acpi0 to prep devices for suspend/resume. */ 2321e8b4d56eSNate Lawson static int 2322d4b9ff91SNate Lawson acpi_wake_prep_walk(int sstate) 2323e8b4d56eSNate Lawson { 2324e8b4d56eSNate Lawson ACPI_HANDLE sb_handle; 2325e8b4d56eSNate Lawson 2326e8b4d56eSNate Lawson if (ACPI_SUCCESS(AcpiGetHandle(ACPI_ROOT_OBJECT, "\\_SB_", &sb_handle))) 2327d4b9ff91SNate Lawson AcpiWalkNamespace(ACPI_TYPE_DEVICE, sb_handle, 100, 2328d4b9ff91SNate Lawson acpi_wake_prep, &sstate, NULL); 2329e8b4d56eSNate Lawson return (0); 2330e8b4d56eSNate Lawson } 2331e8b4d56eSNate Lawson 233288a79fc0SNate Lawson /* Walk the tree rooted at acpi0 to attach per-device wake sysctls. */ 233388a79fc0SNate Lawson static int 233488a79fc0SNate Lawson acpi_wake_sysctl_walk(device_t dev) 233588a79fc0SNate Lawson { 233688a79fc0SNate Lawson int error, i, numdevs; 233788a79fc0SNate Lawson device_t *devlist; 233888a79fc0SNate Lawson device_t child; 2339d4b9ff91SNate Lawson ACPI_STATUS status; 234088a79fc0SNate Lawson 234188a79fc0SNate Lawson error = device_get_children(dev, &devlist, &numdevs); 234288a79fc0SNate Lawson if (error != 0 || numdevs == 0) 234388a79fc0SNate Lawson return (error); 234488a79fc0SNate Lawson for (i = 0; i < numdevs; i++) { 234588a79fc0SNate Lawson child = devlist[i]; 2346d4b9ff91SNate Lawson acpi_wake_sysctl_walk(child); 234788a79fc0SNate Lawson if (!device_is_attached(child)) 234888a79fc0SNate Lawson continue; 2349d4b9ff91SNate Lawson status = AcpiEvaluateObject(acpi_get_handle(child), "_PRW", NULL, NULL); 2350d4b9ff91SNate Lawson if (ACPI_SUCCESS(status)) { 235188a79fc0SNate Lawson SYSCTL_ADD_PROC(device_get_sysctl_ctx(child), 235288a79fc0SNate Lawson SYSCTL_CHILDREN(device_get_sysctl_tree(child)), OID_AUTO, 235388a79fc0SNate Lawson "wake", CTLTYPE_INT | CTLFLAG_RW, child, 0, 235488a79fc0SNate Lawson acpi_wake_set_sysctl, "I", "Device set to wake the system"); 235588a79fc0SNate Lawson } 235688a79fc0SNate Lawson } 235788a79fc0SNate Lawson free(devlist, M_TEMP); 235888a79fc0SNate Lawson 235988a79fc0SNate Lawson return (0); 236088a79fc0SNate Lawson } 236188a79fc0SNate Lawson 236288a79fc0SNate Lawson /* Enable or disable wake from userland. */ 236388a79fc0SNate Lawson static int 236488a79fc0SNate Lawson acpi_wake_set_sysctl(SYSCTL_HANDLER_ARGS) 236588a79fc0SNate Lawson { 236688a79fc0SNate Lawson int enable, error; 236788a79fc0SNate Lawson device_t dev; 236888a79fc0SNate Lawson 236988a79fc0SNate Lawson dev = (device_t)arg1; 2370d4b9ff91SNate Lawson enable = (acpi_get_flags(dev) & ACPI_FLAG_WAKE_ENABLED) ? 1 : 0; 237188a79fc0SNate Lawson 237288a79fc0SNate Lawson error = sysctl_handle_int(oidp, &enable, 0, req); 237388a79fc0SNate Lawson if (error != 0 || req->newptr == NULL) 237488a79fc0SNate Lawson return (error); 237588a79fc0SNate Lawson if (enable != 0 && enable != 1) 237688a79fc0SNate Lawson return (EINVAL); 237788a79fc0SNate Lawson 237888a79fc0SNate Lawson return (acpi_wake_set_enable(dev, enable)); 237988a79fc0SNate Lawson } 238088a79fc0SNate Lawson 2381e8b4d56eSNate Lawson /* Parse a device's _PRW into a structure. */ 2382d4b9ff91SNate Lawson int 2383e8b4d56eSNate Lawson acpi_parse_prw(ACPI_HANDLE h, struct acpi_prw_data *prw) 2384e8b4d56eSNate Lawson { 2385e8b4d56eSNate Lawson ACPI_STATUS status; 2386e8b4d56eSNate Lawson ACPI_BUFFER prw_buffer; 2387e8b4d56eSNate Lawson ACPI_OBJECT *res, *res2; 2388d4b9ff91SNate Lawson int error, i, power_count; 2389e8b4d56eSNate Lawson 2390e8b4d56eSNate Lawson if (h == NULL || prw == NULL) 2391e8b4d56eSNate Lawson return (EINVAL); 2392e8b4d56eSNate Lawson 2393e8b4d56eSNate Lawson /* 2394e8b4d56eSNate Lawson * The _PRW object (7.2.9) is only required for devices that have the 2395e8b4d56eSNate Lawson * ability to wake the system from a sleeping state. 2396e8b4d56eSNate Lawson */ 2397e8b4d56eSNate Lawson error = EINVAL; 2398e8b4d56eSNate Lawson prw_buffer.Pointer = NULL; 2399e8b4d56eSNate Lawson prw_buffer.Length = ACPI_ALLOCATE_BUFFER; 2400e8b4d56eSNate Lawson status = AcpiEvaluateObject(h, "_PRW", NULL, &prw_buffer); 2401e8b4d56eSNate Lawson if (ACPI_FAILURE(status)) 2402e8b4d56eSNate Lawson return (ENOENT); 2403e8b4d56eSNate Lawson res = (ACPI_OBJECT *)prw_buffer.Pointer; 2404e8b4d56eSNate Lawson if (res == NULL) 2405e8b4d56eSNate Lawson return (ENOENT); 2406e8b4d56eSNate Lawson if (!ACPI_PKG_VALID(res, 2)) 2407e8b4d56eSNate Lawson goto out; 2408e8b4d56eSNate Lawson 2409e8b4d56eSNate Lawson /* 2410e8b4d56eSNate Lawson * Element 1 of the _PRW object: 2411e8b4d56eSNate Lawson * The lowest power system sleeping state that can be entered while still 2412e8b4d56eSNate Lawson * providing wake functionality. The sleeping state being entered must 2413e8b4d56eSNate Lawson * be less than (i.e., higher power) or equal to this value. 2414e8b4d56eSNate Lawson */ 2415e8b4d56eSNate Lawson if (acpi_PkgInt32(res, 1, &prw->lowest_wake) != 0) 2416e8b4d56eSNate Lawson goto out; 2417e8b4d56eSNate Lawson 2418e8b4d56eSNate Lawson /* 2419e8b4d56eSNate Lawson * Element 0 of the _PRW object: 2420e8b4d56eSNate Lawson */ 2421e8b4d56eSNate Lawson switch (res->Package.Elements[0].Type) { 2422e8b4d56eSNate Lawson case ACPI_TYPE_INTEGER: 2423e8b4d56eSNate Lawson /* 2424e8b4d56eSNate Lawson * If the data type of this package element is numeric, then this 2425e8b4d56eSNate Lawson * _PRW package element is the bit index in the GPEx_EN, in the 2426e8b4d56eSNate Lawson * GPE blocks described in the FADT, of the enable bit that is 2427e8b4d56eSNate Lawson * enabled for the wake event. 2428e8b4d56eSNate Lawson */ 2429e8b4d56eSNate Lawson prw->gpe_handle = NULL; 2430e8b4d56eSNate Lawson prw->gpe_bit = res->Package.Elements[0].Integer.Value; 2431e8b4d56eSNate Lawson error = 0; 2432e8b4d56eSNate Lawson break; 2433e8b4d56eSNate Lawson case ACPI_TYPE_PACKAGE: 2434e8b4d56eSNate Lawson /* 2435e8b4d56eSNate Lawson * If the data type of this package element is a package, then this 2436e8b4d56eSNate Lawson * _PRW package element is itself a package containing two 2437e8b4d56eSNate Lawson * elements. The first is an object reference to the GPE Block 2438e8b4d56eSNate Lawson * device that contains the GPE that will be triggered by the wake 2439e8b4d56eSNate Lawson * event. The second element is numeric and it contains the bit 2440e8b4d56eSNate Lawson * index in the GPEx_EN, in the GPE Block referenced by the 2441e8b4d56eSNate Lawson * first element in the package, of the enable bit that is enabled for 2442e8b4d56eSNate Lawson * the wake event. 2443e8b4d56eSNate Lawson * 2444e8b4d56eSNate Lawson * For example, if this field is a package then it is of the form: 2445e8b4d56eSNate Lawson * Package() {\_SB.PCI0.ISA.GPE, 2} 2446e8b4d56eSNate Lawson */ 2447e8b4d56eSNate Lawson res2 = &res->Package.Elements[0]; 2448e8b4d56eSNate Lawson if (!ACPI_PKG_VALID(res2, 2)) 2449e8b4d56eSNate Lawson goto out; 2450e8b4d56eSNate Lawson prw->gpe_handle = acpi_GetReference(NULL, &res2->Package.Elements[0]); 2451e8b4d56eSNate Lawson if (prw->gpe_handle == NULL) 2452e8b4d56eSNate Lawson goto out; 2453e8b4d56eSNate Lawson if (acpi_PkgInt32(res2, 1, &prw->gpe_bit) != 0) 2454e8b4d56eSNate Lawson goto out; 2455e8b4d56eSNate Lawson error = 0; 2456e8b4d56eSNate Lawson break; 2457e8b4d56eSNate Lawson default: 2458e8b4d56eSNate Lawson goto out; 2459e8b4d56eSNate Lawson } 2460e8b4d56eSNate Lawson 2461d4b9ff91SNate Lawson /* Elements 2 to N of the _PRW object are power resources. */ 2462d4b9ff91SNate Lawson power_count = res->Package.Count - 2; 2463d4b9ff91SNate Lawson if (power_count > ACPI_PRW_MAX_POWERRES) { 2464d4b9ff91SNate Lawson printf("ACPI device %s has too many power resources\n", acpi_name(h)); 2465d4b9ff91SNate Lawson power_count = 0; 2466d4b9ff91SNate Lawson } 2467d4b9ff91SNate Lawson prw->power_res_count = power_count; 2468d4b9ff91SNate Lawson for (i = 0; i < power_count; i++) 2469d4b9ff91SNate Lawson prw->power_res[i] = res->Package.Elements[i]; 2470e8b4d56eSNate Lawson 2471e8b4d56eSNate Lawson out: 2472e8b4d56eSNate Lawson if (prw_buffer.Pointer != NULL) 2473e8b4d56eSNate Lawson AcpiOsFree(prw_buffer.Pointer); 2474e8b4d56eSNate Lawson return (error); 2475e8b4d56eSNate Lawson } 2476e8b4d56eSNate Lawson 247715e32d5dSMike Smith /* 247815e32d5dSMike Smith * ACPI Event Handlers 247915e32d5dSMike Smith */ 248015e32d5dSMike Smith 248115e32d5dSMike Smith /* System Event Handlers (registered by EVENTHANDLER_REGISTER) */ 248215e32d5dSMike Smith 248315e32d5dSMike Smith static void 248415e32d5dSMike Smith acpi_system_eventhandler_sleep(void *arg, int state) 248515e32d5dSMike Smith { 2486bee4aa4aSNate Lawson 2487b4a05238SPeter Wemm ACPI_FUNCTION_TRACE_U32((char *)(uintptr_t)__func__, state); 248815e32d5dSMike Smith 2489a5d1879bSMitsuru IWASAKI if (state >= ACPI_STATE_S0 && state <= ACPI_S_STATES_MAX) 249015e32d5dSMike Smith acpi_SetSleepState((struct acpi_softc *)arg, state); 2491bee4aa4aSNate Lawson 24920ae55423SMike Smith return_VOID; 249315e32d5dSMike Smith } 249415e32d5dSMike Smith 249515e32d5dSMike Smith static void 249615e32d5dSMike Smith acpi_system_eventhandler_wakeup(void *arg, int state) 249715e32d5dSMike Smith { 2498bee4aa4aSNate Lawson 2499b4a05238SPeter Wemm ACPI_FUNCTION_TRACE_U32((char *)(uintptr_t)__func__, state); 25000ae55423SMike Smith 2501bee4aa4aSNate Lawson /* Currently, nothing to do for wakeup. */ 2502cb9b0d80SMike Smith 25030ae55423SMike Smith return_VOID; 250415e32d5dSMike Smith } 250515e32d5dSMike Smith 250615e32d5dSMike Smith /* 250715e32d5dSMike Smith * ACPICA Event Handlers (FixedEvent, also called from button notify handler) 250815e32d5dSMike Smith */ 250915e32d5dSMike Smith UINT32 251033febf93SNate Lawson acpi_event_power_button_sleep(void *context) 251115e32d5dSMike Smith { 251215e32d5dSMike Smith struct acpi_softc *sc = (struct acpi_softc *)context; 251315e32d5dSMike Smith 2514b4a05238SPeter Wemm ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 25150ae55423SMike Smith 251615e32d5dSMike Smith EVENTHANDLER_INVOKE(acpi_sleep_event, sc->acpi_power_button_sx); 25170ae55423SMike Smith 2518b53f2771SMike Smith return_VALUE (ACPI_INTERRUPT_HANDLED); 251915e32d5dSMike Smith } 252015e32d5dSMike Smith 252115e32d5dSMike Smith UINT32 252233febf93SNate Lawson acpi_event_power_button_wake(void *context) 252315e32d5dSMike Smith { 252415e32d5dSMike Smith struct acpi_softc *sc = (struct acpi_softc *)context; 252515e32d5dSMike Smith 2526b4a05238SPeter Wemm ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 25270ae55423SMike Smith 252815e32d5dSMike Smith EVENTHANDLER_INVOKE(acpi_wakeup_event, sc->acpi_power_button_sx); 25290ae55423SMike Smith 2530b53f2771SMike Smith return_VALUE (ACPI_INTERRUPT_HANDLED); 253115e32d5dSMike Smith } 253215e32d5dSMike Smith 253315e32d5dSMike Smith UINT32 253433febf93SNate Lawson acpi_event_sleep_button_sleep(void *context) 253515e32d5dSMike Smith { 253615e32d5dSMike Smith struct acpi_softc *sc = (struct acpi_softc *)context; 253715e32d5dSMike Smith 2538b4a05238SPeter Wemm ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 25390ae55423SMike Smith 254015e32d5dSMike Smith EVENTHANDLER_INVOKE(acpi_sleep_event, sc->acpi_sleep_button_sx); 25410ae55423SMike Smith 2542b53f2771SMike Smith return_VALUE (ACPI_INTERRUPT_HANDLED); 254315e32d5dSMike Smith } 254415e32d5dSMike Smith 254515e32d5dSMike Smith UINT32 254633febf93SNate Lawson acpi_event_sleep_button_wake(void *context) 254715e32d5dSMike Smith { 254815e32d5dSMike Smith struct acpi_softc *sc = (struct acpi_softc *)context; 254915e32d5dSMike Smith 2550b4a05238SPeter Wemm ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 25510ae55423SMike Smith 255215e32d5dSMike Smith EVENTHANDLER_INVOKE(acpi_wakeup_event, sc->acpi_sleep_button_sx); 25530ae55423SMike Smith 2554b53f2771SMike Smith return_VALUE (ACPI_INTERRUPT_HANDLED); 255515e32d5dSMike Smith } 255615e32d5dSMike Smith 255715e32d5dSMike Smith /* 2558bee4aa4aSNate Lawson * XXX This static buffer is suboptimal. There is no locking so only 2559bee4aa4aSNate Lawson * use this for single-threaded callers. 256015e32d5dSMike Smith */ 256115e32d5dSMike Smith char * 256215e32d5dSMike Smith acpi_name(ACPI_HANDLE handle) 256315e32d5dSMike Smith { 2564bee4aa4aSNate Lawson ACPI_BUFFER buf; 2565bee4aa4aSNate Lawson static char data[256]; 256615e32d5dSMike Smith 2567bee4aa4aSNate Lawson buf.Length = sizeof(data); 2568bee4aa4aSNate Lawson buf.Pointer = data; 2569cb9b0d80SMike Smith 25700a9a1f44SNate Lawson if (handle && ACPI_SUCCESS(AcpiGetName(handle, ACPI_FULL_PATHNAME, &buf))) 2571bee4aa4aSNate Lawson return (data); 2572bee4aa4aSNate Lawson return ("(unknown)"); 257315e32d5dSMike Smith } 257415e32d5dSMike Smith 257515e32d5dSMike Smith /* 257615e32d5dSMike Smith * Debugging/bug-avoidance. Avoid trying to fetch info on various 257715e32d5dSMike Smith * parts of the namespace. 257815e32d5dSMike Smith */ 257915e32d5dSMike Smith int 258015e32d5dSMike Smith acpi_avoid(ACPI_HANDLE handle) 258115e32d5dSMike Smith { 25823c600cfbSJohn Baldwin char *cp, *env, *np; 258315e32d5dSMike Smith int len; 258415e32d5dSMike Smith 258515e32d5dSMike Smith np = acpi_name(handle); 258615e32d5dSMike Smith if (*np == '\\') 258715e32d5dSMike Smith np++; 25883c600cfbSJohn Baldwin if ((env = getenv("debug.acpi.avoid")) == NULL) 258915e32d5dSMike Smith return (0); 259015e32d5dSMike Smith 2591be2b1797SNate Lawson /* Scan the avoid list checking for a match */ 25923c600cfbSJohn Baldwin cp = env; 259315e32d5dSMike Smith for (;;) { 2594bee4aa4aSNate Lawson while (*cp != 0 && isspace(*cp)) 259515e32d5dSMike Smith cp++; 259615e32d5dSMike Smith if (*cp == 0) 259715e32d5dSMike Smith break; 259815e32d5dSMike Smith len = 0; 2599bee4aa4aSNate Lawson while (cp[len] != 0 && !isspace(cp[len])) 260015e32d5dSMike Smith len++; 2601d786139cSMaxime Henrion if (!strncmp(cp, np, len)) { 26023c600cfbSJohn Baldwin freeenv(env); 26030ae55423SMike Smith return(1); 2604d786139cSMaxime Henrion } 26050ae55423SMike Smith cp += len; 26060ae55423SMike Smith } 26073c600cfbSJohn Baldwin freeenv(env); 2608be2b1797SNate Lawson 26090ae55423SMike Smith return (0); 26100ae55423SMike Smith } 26110ae55423SMike Smith 26120ae55423SMike Smith /* 26130ae55423SMike Smith * Debugging/bug-avoidance. Disable ACPI subsystem components. 26140ae55423SMike Smith */ 26150ae55423SMike Smith int 26160ae55423SMike Smith acpi_disabled(char *subsys) 26170ae55423SMike Smith { 261878689b15SMaxime Henrion char *cp, *env; 26190ae55423SMike Smith int len; 26200ae55423SMike Smith 26213184cf5aSNate Lawson if ((env = getenv("debug.acpi.disabled")) == NULL) 26220ae55423SMike Smith return (0); 26233184cf5aSNate Lawson if (strcmp(env, "all") == 0) { 262478689b15SMaxime Henrion freeenv(env); 26250ae55423SMike Smith return (1); 2626d786139cSMaxime Henrion } 26270ae55423SMike Smith 26283184cf5aSNate Lawson /* Scan the disable list, checking for a match. */ 262978689b15SMaxime Henrion cp = env; 26300ae55423SMike Smith for (;;) { 26313184cf5aSNate Lawson while (*cp != '\0' && isspace(*cp)) 26320ae55423SMike Smith cp++; 26333184cf5aSNate Lawson if (*cp == '\0') 26340ae55423SMike Smith break; 26350ae55423SMike Smith len = 0; 26363184cf5aSNate Lawson while (cp[len] != '\0' && !isspace(cp[len])) 26370ae55423SMike Smith len++; 26383184cf5aSNate Lawson if (strncmp(cp, subsys, len) == 0) { 263978689b15SMaxime Henrion freeenv(env); 264015e32d5dSMike Smith return (1); 2641d786139cSMaxime Henrion } 264215e32d5dSMike Smith cp += len; 264315e32d5dSMike Smith } 264478689b15SMaxime Henrion freeenv(env); 2645be2b1797SNate Lawson 264615e32d5dSMike Smith return (0); 264715e32d5dSMike Smith } 264815e32d5dSMike Smith 264915e32d5dSMike Smith /* 265015e32d5dSMike Smith * Control interface. 265115e32d5dSMike Smith * 26520ae55423SMike Smith * We multiplex ioctls for all participating ACPI devices here. Individual 2653be2b1797SNate Lawson * drivers wanting to be accessible via /dev/acpi should use the 2654be2b1797SNate Lawson * register/deregister interface to make their handlers visible. 265515e32d5dSMike Smith */ 26560ae55423SMike Smith struct acpi_ioctl_hook 26570ae55423SMike Smith { 26580ae55423SMike Smith TAILQ_ENTRY(acpi_ioctl_hook) link; 26590ae55423SMike Smith u_long cmd; 2660be2b1797SNate Lawson acpi_ioctl_fn fn; 26610ae55423SMike Smith void *arg; 26620ae55423SMike Smith }; 26630ae55423SMike Smith 26640ae55423SMike Smith static TAILQ_HEAD(,acpi_ioctl_hook) acpi_ioctl_hooks; 26650ae55423SMike Smith static int acpi_ioctl_hooks_initted; 26660ae55423SMike Smith 26670ae55423SMike Smith int 2668be2b1797SNate Lawson acpi_register_ioctl(u_long cmd, acpi_ioctl_fn fn, void *arg) 26690ae55423SMike Smith { 26700ae55423SMike Smith struct acpi_ioctl_hook *hp; 26710ae55423SMike Smith 26720ae55423SMike Smith if ((hp = malloc(sizeof(*hp), M_ACPIDEV, M_NOWAIT)) == NULL) 26730ae55423SMike Smith return (ENOMEM); 26740ae55423SMike Smith hp->cmd = cmd; 26750ae55423SMike Smith hp->fn = fn; 26760ae55423SMike Smith hp->arg = arg; 267715e2f34fSNate Lawson 267815e2f34fSNate Lawson ACPI_LOCK(acpi); 26790ae55423SMike Smith if (acpi_ioctl_hooks_initted == 0) { 26800ae55423SMike Smith TAILQ_INIT(&acpi_ioctl_hooks); 26810ae55423SMike Smith acpi_ioctl_hooks_initted = 1; 26820ae55423SMike Smith } 26830ae55423SMike Smith TAILQ_INSERT_TAIL(&acpi_ioctl_hooks, hp, link); 268415e2f34fSNate Lawson ACPI_UNLOCK(acpi); 268515e2f34fSNate Lawson 26860ae55423SMike Smith return (0); 26870ae55423SMike Smith } 26880ae55423SMike Smith 26890ae55423SMike Smith void 2690be2b1797SNate Lawson acpi_deregister_ioctl(u_long cmd, acpi_ioctl_fn fn) 26910ae55423SMike Smith { 26920ae55423SMike Smith struct acpi_ioctl_hook *hp; 26930ae55423SMike Smith 269415e2f34fSNate Lawson ACPI_LOCK(acpi); 26950ae55423SMike Smith TAILQ_FOREACH(hp, &acpi_ioctl_hooks, link) 269615e2f34fSNate Lawson if (hp->cmd == cmd && hp->fn == fn) 26970ae55423SMike Smith break; 26980ae55423SMike Smith 26990ae55423SMike Smith if (hp != NULL) { 27000ae55423SMike Smith TAILQ_REMOVE(&acpi_ioctl_hooks, hp, link); 27010ae55423SMike Smith free(hp, M_ACPIDEV); 27020ae55423SMike Smith } 270315e2f34fSNate Lawson ACPI_UNLOCK(acpi); 27040ae55423SMike Smith } 27050ae55423SMike Smith 270615e32d5dSMike Smith static int 270789c9c53dSPoul-Henning Kamp acpiopen(struct cdev *dev, int flag, int fmt, d_thread_t *td) 270815e32d5dSMike Smith { 270915e32d5dSMike Smith return (0); 271015e32d5dSMike Smith } 271115e32d5dSMike Smith 271215e32d5dSMike Smith static int 271389c9c53dSPoul-Henning Kamp acpiclose(struct cdev *dev, int flag, int fmt, d_thread_t *td) 271415e32d5dSMike Smith { 271515e32d5dSMike Smith return (0); 271615e32d5dSMike Smith } 271715e32d5dSMike Smith 271815e32d5dSMike Smith static int 271989c9c53dSPoul-Henning Kamp acpiioctl(struct cdev *dev, u_long cmd, caddr_t addr, int flag, d_thread_t *td) 272015e32d5dSMike Smith { 272115e32d5dSMike Smith struct acpi_softc *sc; 27220ae55423SMike Smith struct acpi_ioctl_hook *hp; 2723bee4aa4aSNate Lawson int error, state; 272415e32d5dSMike Smith 2725a2e35898SDavid E. O'Brien error = 0; 2726a2e35898SDavid E. O'Brien hp = NULL; 272715e32d5dSMike Smith sc = dev->si_drv1; 272815e32d5dSMike Smith 27290ae55423SMike Smith /* 27300ae55423SMike Smith * Scan the list of registered ioctls, looking for handlers. 27310ae55423SMike Smith */ 273215e2f34fSNate Lawson ACPI_LOCK(acpi); 2733bee4aa4aSNate Lawson if (acpi_ioctl_hooks_initted) 27340ae55423SMike Smith TAILQ_FOREACH(hp, &acpi_ioctl_hooks, link) { 2735bee4aa4aSNate Lawson if (hp->cmd == cmd) 2736bee4aa4aSNate Lawson break; 27370ae55423SMike Smith } 273815e2f34fSNate Lawson ACPI_UNLOCK(acpi); 2739bee4aa4aSNate Lawson if (hp) 2740bee4aa4aSNate Lawson return (hp->fn(cmd, addr, hp->arg)); 27410ae55423SMike Smith 27420ae55423SMike Smith /* 2743a89fcf28STakanori Watanabe * Core ioctls are not permitted for non-writable user. 2744a89fcf28STakanori Watanabe * Currently, other ioctls just fetch information. 2745a89fcf28STakanori Watanabe * Not changing system behavior. 2746a89fcf28STakanori Watanabe */ 2747be2b1797SNate Lawson if ((flag & FWRITE) == 0) 2748be2b1797SNate Lawson return (EPERM); 2749a89fcf28STakanori Watanabe 2750be2b1797SNate Lawson /* Core system ioctls. */ 275115e32d5dSMike Smith switch (cmd) { 275215e32d5dSMike Smith case ACPIIO_SETSLPSTATE: 2753bee4aa4aSNate Lawson error = EINVAL; 275415e32d5dSMike Smith state = *(int *)addr; 2755bee4aa4aSNate Lawson if (state >= ACPI_STATE_S0 && state <= ACPI_S_STATES_MAX) 2756bee4aa4aSNate Lawson if (ACPI_SUCCESS(acpi_SetSleepState(sc, state))) 2757bee4aa4aSNate Lawson error = 0; 275815e32d5dSMike Smith break; 275915e32d5dSMike Smith default: 2760bee4aa4aSNate Lawson error = ENXIO; 276115e32d5dSMike Smith break; 276215e32d5dSMike Smith } 2763917d44c8SMitsuru IWASAKI 276415e32d5dSMike Smith return (error); 276515e32d5dSMike Smith } 276615e32d5dSMike Smith 27671d073b1dSJohn Baldwin static int 2768d75de536SMitsuru IWASAKI acpi_supported_sleep_state_sysctl(SYSCTL_HANDLER_ARGS) 2769d75de536SMitsuru IWASAKI { 2770d75de536SMitsuru IWASAKI int error; 2771bee4aa4aSNate Lawson struct sbuf sb; 2772d75de536SMitsuru IWASAKI UINT8 state, TypeA, TypeB; 2773d75de536SMitsuru IWASAKI 2774bee4aa4aSNate Lawson sbuf_new(&sb, NULL, 32, SBUF_AUTOEXTEND); 2775bee4aa4aSNate Lawson for (state = ACPI_STATE_S1; state < ACPI_S_STATES_MAX + 1; state++) 2776bee4aa4aSNate Lawson if (ACPI_SUCCESS(AcpiGetSleepTypeData(state, &TypeA, &TypeB))) 2777bee4aa4aSNate Lawson sbuf_printf(&sb, "S%d ", state); 2778bee4aa4aSNate Lawson sbuf_trim(&sb); 2779bee4aa4aSNate Lawson sbuf_finish(&sb); 2780bee4aa4aSNate Lawson error = sysctl_handle_string(oidp, sbuf_data(&sb), sbuf_len(&sb), req); 2781bee4aa4aSNate Lawson sbuf_delete(&sb); 2782d75de536SMitsuru IWASAKI return (error); 2783d75de536SMitsuru IWASAKI } 2784d75de536SMitsuru IWASAKI 2785d75de536SMitsuru IWASAKI static int 27861d073b1dSJohn Baldwin acpi_sleep_state_sysctl(SYSCTL_HANDLER_ARGS) 27871d073b1dSJohn Baldwin { 27881d073b1dSJohn Baldwin char sleep_state[10]; 27891d073b1dSJohn Baldwin int error; 27901d073b1dSJohn Baldwin u_int new_state, old_state; 27911d073b1dSJohn Baldwin 27921d073b1dSJohn Baldwin old_state = *(u_int *)oidp->oid_arg1; 2793bee4aa4aSNate Lawson if (old_state > ACPI_S_STATES_MAX + 1) 2794bee4aa4aSNate Lawson strlcpy(sleep_state, "unknown", sizeof(sleep_state)); 2795bee4aa4aSNate Lawson else 2796bee4aa4aSNate Lawson strlcpy(sleep_state, sleep_state_names[old_state], sizeof(sleep_state)); 27971d073b1dSJohn Baldwin error = sysctl_handle_string(oidp, sleep_state, sizeof(sleep_state), req); 27981d073b1dSJohn Baldwin if (error == 0 && req->newptr != NULL) { 2799be2b1797SNate Lawson new_state = ACPI_STATE_S0; 2800bee4aa4aSNate Lawson for (; new_state <= ACPI_S_STATES_MAX + 1; new_state++) 2801bee4aa4aSNate Lawson if (strcmp(sleep_state, sleep_state_names[new_state]) == 0) 28021d073b1dSJohn Baldwin break; 2803931a10c9SMitsuru IWASAKI if (new_state <= ACPI_S_STATES_MAX + 1) { 2804be2b1797SNate Lawson if (new_state != old_state) 28051d073b1dSJohn Baldwin *(u_int *)oidp->oid_arg1 = new_state; 2806bee4aa4aSNate Lawson } else 28071d073b1dSJohn Baldwin error = EINVAL; 28081d073b1dSJohn Baldwin } 2809be2b1797SNate Lawson 28101d073b1dSJohn Baldwin return (error); 28111d073b1dSJohn Baldwin } 28121d073b1dSJohn Baldwin 28139b937d48SNate Lawson /* Inform devctl(4) when we receive a Notify. */ 28149b937d48SNate Lawson void 28159b937d48SNate Lawson acpi_UserNotify(const char *subsystem, ACPI_HANDLE h, uint8_t notify) 28169b937d48SNate Lawson { 28179b937d48SNate Lawson char notify_buf[16]; 28189b937d48SNate Lawson ACPI_BUFFER handle_buf; 28199b937d48SNate Lawson ACPI_STATUS status; 28209b937d48SNate Lawson 28219b937d48SNate Lawson if (subsystem == NULL) 28229b937d48SNate Lawson return; 28239b937d48SNate Lawson 28249b937d48SNate Lawson handle_buf.Pointer = NULL; 28259b937d48SNate Lawson handle_buf.Length = ACPI_ALLOCATE_BUFFER; 28269b937d48SNate Lawson status = AcpiNsHandleToPathname(h, &handle_buf); 28279b937d48SNate Lawson if (ACPI_FAILURE(status)) 28289b937d48SNate Lawson return; 28299b937d48SNate Lawson snprintf(notify_buf, sizeof(notify_buf), "notify=0x%02x", notify); 28309b937d48SNate Lawson devctl_notify("ACPI", subsystem, handle_buf.Pointer, notify_buf); 28319b937d48SNate Lawson AcpiOsFree(handle_buf.Pointer); 28329b937d48SNate Lawson } 28339b937d48SNate Lawson 283415e32d5dSMike Smith #ifdef ACPI_DEBUG 28350ae55423SMike Smith /* 28360ae55423SMike Smith * Support for parsing debug options from the kernel environment. 28370ae55423SMike Smith * 28380ae55423SMike Smith * Bits may be set in the AcpiDbgLayer and AcpiDbgLevel debug registers 28390ae55423SMike Smith * by specifying the names of the bits in the debug.acpi.layer and 28400ae55423SMike Smith * debug.acpi.level environment variables. Bits may be unset by 28410ae55423SMike Smith * prefixing the bit name with !. 28420ae55423SMike Smith */ 284315e32d5dSMike Smith struct debugtag 284415e32d5dSMike Smith { 284515e32d5dSMike Smith char *name; 284615e32d5dSMike Smith UINT32 value; 284715e32d5dSMike Smith }; 284815e32d5dSMike Smith 284915e32d5dSMike Smith static struct debugtag dbg_layer[] = { 2850c5ba0be4SMike Smith {"ACPI_UTILITIES", ACPI_UTILITIES}, 2851c5ba0be4SMike Smith {"ACPI_HARDWARE", ACPI_HARDWARE}, 2852c5ba0be4SMike Smith {"ACPI_EVENTS", ACPI_EVENTS}, 2853c5ba0be4SMike Smith {"ACPI_TABLES", ACPI_TABLES}, 2854c5ba0be4SMike Smith {"ACPI_NAMESPACE", ACPI_NAMESPACE}, 2855c5ba0be4SMike Smith {"ACPI_PARSER", ACPI_PARSER}, 2856c5ba0be4SMike Smith {"ACPI_DISPATCHER", ACPI_DISPATCHER}, 2857c5ba0be4SMike Smith {"ACPI_EXECUTER", ACPI_EXECUTER}, 2858c5ba0be4SMike Smith {"ACPI_RESOURCES", ACPI_RESOURCES}, 2859d62ab2f4SMitsuru IWASAKI {"ACPI_CA_DEBUGGER", ACPI_CA_DEBUGGER}, 28604c1cdee6SMike Smith {"ACPI_OS_SERVICES", ACPI_OS_SERVICES}, 2861d62ab2f4SMitsuru IWASAKI {"ACPI_CA_DISASSEMBLER", ACPI_CA_DISASSEMBLER}, 2862297835bcSNate Lawson {"ACPI_ALL_COMPONENTS", ACPI_ALL_COMPONENTS}, 28634c1cdee6SMike Smith 2864c5ba0be4SMike Smith {"ACPI_AC_ADAPTER", ACPI_AC_ADAPTER}, 2865c5ba0be4SMike Smith {"ACPI_BATTERY", ACPI_BATTERY}, 28663184cf5aSNate Lawson {"ACPI_BUS", ACPI_BUS}, 2867c5ba0be4SMike Smith {"ACPI_BUTTON", ACPI_BUTTON}, 28683184cf5aSNate Lawson {"ACPI_EC", ACPI_EC}, 28693184cf5aSNate Lawson {"ACPI_FAN", ACPI_FAN}, 28703184cf5aSNate Lawson {"ACPI_POWERRES", ACPI_POWERRES}, 28714c1cdee6SMike Smith {"ACPI_PROCESSOR", ACPI_PROCESSOR}, 2872cb9b0d80SMike Smith {"ACPI_THERMAL", ACPI_THERMAL}, 28733184cf5aSNate Lawson {"ACPI_TIMER", ACPI_TIMER}, 2874b53f2771SMike Smith {"ACPI_ALL_DRIVERS", ACPI_ALL_DRIVERS}, 287515e32d5dSMike Smith {NULL, 0} 287615e32d5dSMike Smith }; 287715e32d5dSMike Smith 287815e32d5dSMike Smith static struct debugtag dbg_level[] = { 28794c1cdee6SMike Smith {"ACPI_LV_ERROR", ACPI_LV_ERROR}, 28809501b603SJohn Baldwin {"ACPI_LV_WARN", ACPI_LV_WARN}, 28819501b603SJohn Baldwin {"ACPI_LV_INIT", ACPI_LV_INIT}, 28824c1cdee6SMike Smith {"ACPI_LV_DEBUG_OBJECT", ACPI_LV_DEBUG_OBJECT}, 28839501b603SJohn Baldwin {"ACPI_LV_INFO", ACPI_LV_INFO}, 28844c1cdee6SMike Smith {"ACPI_LV_ALL_EXCEPTIONS", ACPI_LV_ALL_EXCEPTIONS}, 2885d62ab2f4SMitsuru IWASAKI 2886d62ab2f4SMitsuru IWASAKI /* Trace verbosity level 1 [Standard Trace Level] */ 2887297835bcSNate Lawson {"ACPI_LV_INIT_NAMES", ACPI_LV_INIT_NAMES}, 28884c1cdee6SMike Smith {"ACPI_LV_PARSE", ACPI_LV_PARSE}, 28894c1cdee6SMike Smith {"ACPI_LV_LOAD", ACPI_LV_LOAD}, 2890d62ab2f4SMitsuru IWASAKI {"ACPI_LV_DISPATCH", ACPI_LV_DISPATCH}, 28914c1cdee6SMike Smith {"ACPI_LV_EXEC", ACPI_LV_EXEC}, 28924c1cdee6SMike Smith {"ACPI_LV_NAMES", ACPI_LV_NAMES}, 28934c1cdee6SMike Smith {"ACPI_LV_OPREGION", ACPI_LV_OPREGION}, 28944c1cdee6SMike Smith {"ACPI_LV_BFIELD", ACPI_LV_BFIELD}, 28954c1cdee6SMike Smith {"ACPI_LV_TABLES", ACPI_LV_TABLES}, 28964c1cdee6SMike Smith {"ACPI_LV_VALUES", ACPI_LV_VALUES}, 28974c1cdee6SMike Smith {"ACPI_LV_OBJECTS", ACPI_LV_OBJECTS}, 28984c1cdee6SMike Smith {"ACPI_LV_RESOURCES", ACPI_LV_RESOURCES}, 28994c1cdee6SMike Smith {"ACPI_LV_USER_REQUESTS", ACPI_LV_USER_REQUESTS}, 29004c1cdee6SMike Smith {"ACPI_LV_PACKAGE", ACPI_LV_PACKAGE}, 2901d62ab2f4SMitsuru IWASAKI {"ACPI_LV_VERBOSITY1", ACPI_LV_VERBOSITY1}, 2902d62ab2f4SMitsuru IWASAKI 2903d62ab2f4SMitsuru IWASAKI /* Trace verbosity level 2 [Function tracing and memory allocation] */ 2904d62ab2f4SMitsuru IWASAKI {"ACPI_LV_ALLOCATIONS", ACPI_LV_ALLOCATIONS}, 2905d62ab2f4SMitsuru IWASAKI {"ACPI_LV_FUNCTIONS", ACPI_LV_FUNCTIONS}, 2906d62ab2f4SMitsuru IWASAKI {"ACPI_LV_OPTIMIZATIONS", ACPI_LV_OPTIMIZATIONS}, 2907d62ab2f4SMitsuru IWASAKI {"ACPI_LV_VERBOSITY2", ACPI_LV_VERBOSITY2}, 29084c1cdee6SMike Smith {"ACPI_LV_ALL", ACPI_LV_ALL}, 2909d62ab2f4SMitsuru IWASAKI 2910d62ab2f4SMitsuru IWASAKI /* Trace verbosity level 3 [Threading, I/O, and Interrupts] */ 2911d62ab2f4SMitsuru IWASAKI {"ACPI_LV_MUTEX", ACPI_LV_MUTEX}, 2912d62ab2f4SMitsuru IWASAKI {"ACPI_LV_THREADS", ACPI_LV_THREADS}, 2913d62ab2f4SMitsuru IWASAKI {"ACPI_LV_IO", ACPI_LV_IO}, 2914d62ab2f4SMitsuru IWASAKI {"ACPI_LV_INTERRUPTS", ACPI_LV_INTERRUPTS}, 2915d62ab2f4SMitsuru IWASAKI {"ACPI_LV_VERBOSITY3", ACPI_LV_VERBOSITY3}, 2916d62ab2f4SMitsuru IWASAKI 2917d62ab2f4SMitsuru IWASAKI /* Exceptionally verbose output -- also used in the global "DebugLevel" */ 291898479b04SMitsuru IWASAKI {"ACPI_LV_AML_DISASSEMBLE", ACPI_LV_AML_DISASSEMBLE}, 291998479b04SMitsuru IWASAKI {"ACPI_LV_VERBOSE_INFO", ACPI_LV_VERBOSE_INFO}, 292098479b04SMitsuru IWASAKI {"ACPI_LV_FULL_TABLES", ACPI_LV_FULL_TABLES}, 292198479b04SMitsuru IWASAKI {"ACPI_LV_EVENTS", ACPI_LV_EVENTS}, 292298479b04SMitsuru IWASAKI {"ACPI_LV_VERBOSE", ACPI_LV_VERBOSE}, 292315e32d5dSMike Smith {NULL, 0} 292415e32d5dSMike Smith }; 292515e32d5dSMike Smith 292615e32d5dSMike Smith static void 292715e32d5dSMike Smith acpi_parse_debug(char *cp, struct debugtag *tag, UINT32 *flag) 292815e32d5dSMike Smith { 292915e32d5dSMike Smith char *ep; 293015e32d5dSMike Smith int i, l; 29310ae55423SMike Smith int set; 293215e32d5dSMike Smith 293315e32d5dSMike Smith while (*cp) { 293415e32d5dSMike Smith if (isspace(*cp)) { 293515e32d5dSMike Smith cp++; 293615e32d5dSMike Smith continue; 293715e32d5dSMike Smith } 293815e32d5dSMike Smith ep = cp; 293915e32d5dSMike Smith while (*ep && !isspace(*ep)) 294015e32d5dSMike Smith ep++; 29410ae55423SMike Smith if (*cp == '!') { 29420ae55423SMike Smith set = 0; 29430ae55423SMike Smith cp++; 29440ae55423SMike Smith if (cp == ep) 29450ae55423SMike Smith continue; 29460ae55423SMike Smith } else { 29470ae55423SMike Smith set = 1; 29480ae55423SMike Smith } 294915e32d5dSMike Smith l = ep - cp; 295015e32d5dSMike Smith for (i = 0; tag[i].name != NULL; i++) { 295115e32d5dSMike Smith if (!strncmp(cp, tag[i].name, l)) { 2952be2b1797SNate Lawson if (set) 295315e32d5dSMike Smith *flag |= tag[i].value; 2954be2b1797SNate Lawson else 29550ae55423SMike Smith *flag &= ~tag[i].value; 295615e32d5dSMike Smith } 295715e32d5dSMike Smith } 295815e32d5dSMike Smith cp = ep; 295915e32d5dSMike Smith } 296015e32d5dSMike Smith } 296115e32d5dSMike Smith 296215e32d5dSMike Smith static void 29632a4ac806SMike Smith acpi_set_debugging(void *junk) 296415e32d5dSMike Smith { 29657e639165SNate Lawson char *layer, *level; 296615e32d5dSMike Smith 29671d7b121cSNate Lawson if (cold) { 29680ae55423SMike Smith AcpiDbgLayer = 0; 29690ae55423SMike Smith AcpiDbgLevel = 0; 29701d7b121cSNate Lawson } 29711d7b121cSNate Lawson 29727e639165SNate Lawson layer = getenv("debug.acpi.layer"); 29737e639165SNate Lawson level = getenv("debug.acpi.level"); 29747e639165SNate Lawson if (layer == NULL && level == NULL) 29757e639165SNate Lawson return; 29760ae55423SMike Smith 29777e639165SNate Lawson printf("ACPI set debug"); 29787e639165SNate Lawson if (layer != NULL) { 29797e639165SNate Lawson if (strcmp("NONE", layer) != 0) 29807e639165SNate Lawson printf(" layer '%s'", layer); 29817e639165SNate Lawson acpi_parse_debug(layer, &dbg_layer[0], &AcpiDbgLayer); 29827e639165SNate Lawson freeenv(layer); 29831d7b121cSNate Lawson } 29847e639165SNate Lawson if (level != NULL) { 29857e639165SNate Lawson if (strcmp("NONE", level) != 0) 29867e639165SNate Lawson printf(" level '%s'", level); 29877e639165SNate Lawson acpi_parse_debug(level, &dbg_level[0], &AcpiDbgLevel); 29887e639165SNate Lawson freeenv(level); 29897e639165SNate Lawson } 29907e639165SNate Lawson printf("\n"); 299115e32d5dSMike Smith } 2992bee4aa4aSNate Lawson 2993be2b1797SNate Lawson SYSINIT(acpi_debugging, SI_SUB_TUNABLES, SI_ORDER_ANY, acpi_set_debugging, 2994be2b1797SNate Lawson NULL); 29951d7b121cSNate Lawson 29961d7b121cSNate Lawson static int 29971d7b121cSNate Lawson acpi_debug_sysctl(SYSCTL_HANDLER_ARGS) 29981d7b121cSNate Lawson { 299954f6bca0SNate Lawson int error, *dbg; 30001d7b121cSNate Lawson struct debugtag *tag; 300154f6bca0SNate Lawson struct sbuf sb; 30021d7b121cSNate Lawson 300354f6bca0SNate Lawson if (sbuf_new(&sb, NULL, 128, SBUF_AUTOEXTEND) == NULL) 300454f6bca0SNate Lawson return (ENOMEM); 30051d7b121cSNate Lawson if (strcmp(oidp->oid_arg1, "debug.acpi.layer") == 0) { 30061d7b121cSNate Lawson tag = &dbg_layer[0]; 30071d7b121cSNate Lawson dbg = &AcpiDbgLayer; 30081d7b121cSNate Lawson } else { 30091d7b121cSNate Lawson tag = &dbg_level[0]; 30101d7b121cSNate Lawson dbg = &AcpiDbgLevel; 30111d7b121cSNate Lawson } 30121d7b121cSNate Lawson 30131d7b121cSNate Lawson /* Get old values if this is a get request. */ 301415e2f34fSNate Lawson ACPI_SERIAL_BEGIN(acpi); 30151d7b121cSNate Lawson if (*dbg == 0) { 301654f6bca0SNate Lawson sbuf_cpy(&sb, "NONE"); 30171d7b121cSNate Lawson } else if (req->newptr == NULL) { 30181d7b121cSNate Lawson for (; tag->name != NULL; tag++) { 301954f6bca0SNate Lawson if ((*dbg & tag->value) == tag->value) 302054f6bca0SNate Lawson sbuf_printf(&sb, "%s ", tag->name); 30211d7b121cSNate Lawson } 30221d7b121cSNate Lawson } 302354f6bca0SNate Lawson sbuf_trim(&sb); 302454f6bca0SNate Lawson sbuf_finish(&sb); 30251d7b121cSNate Lawson 30267e639165SNate Lawson /* Copy out the old values to the user. */ 30277e639165SNate Lawson error = SYSCTL_OUT(req, sbuf_data(&sb), sbuf_len(&sb)); 302854f6bca0SNate Lawson sbuf_delete(&sb); 30291d7b121cSNate Lawson 30301d7b121cSNate Lawson /* If the user is setting a string, parse it. */ 30311d7b121cSNate Lawson if (error == 0 && req->newptr != NULL) { 30321d7b121cSNate Lawson *dbg = 0; 30331d7b121cSNate Lawson setenv((char *)oidp->oid_arg1, (char *)req->newptr); 30341d7b121cSNate Lawson acpi_set_debugging(NULL); 30351d7b121cSNate Lawson } 303615e2f34fSNate Lawson ACPI_SERIAL_END(acpi); 30371d7b121cSNate Lawson 30381d7b121cSNate Lawson return (error); 30391d7b121cSNate Lawson } 3040bee4aa4aSNate Lawson 30411d7b121cSNate Lawson SYSCTL_PROC(_debug_acpi, OID_AUTO, layer, CTLFLAG_RW | CTLTYPE_STRING, 30421d7b121cSNate Lawson "debug.acpi.layer", 0, acpi_debug_sysctl, "A", ""); 30431d7b121cSNate Lawson SYSCTL_PROC(_debug_acpi, OID_AUTO, level, CTLFLAG_RW | CTLTYPE_STRING, 30441d7b121cSNate Lawson "debug.acpi.level", 0, acpi_debug_sysctl, "A", ""); 3045bee4aa4aSNate Lawson #endif /* ACPI_DEBUG */ 3046f9390180SMitsuru IWASAKI 3047f9390180SMitsuru IWASAKI static int 3048f9390180SMitsuru IWASAKI acpi_pm_func(u_long cmd, void *arg, ...) 3049f9390180SMitsuru IWASAKI { 3050f9390180SMitsuru IWASAKI int state, acpi_state; 3051f9390180SMitsuru IWASAKI int error; 3052f9390180SMitsuru IWASAKI struct acpi_softc *sc; 3053f9390180SMitsuru IWASAKI va_list ap; 3054f9390180SMitsuru IWASAKI 3055f9390180SMitsuru IWASAKI error = 0; 3056f9390180SMitsuru IWASAKI switch (cmd) { 3057f9390180SMitsuru IWASAKI case POWER_CMD_SUSPEND: 3058f9390180SMitsuru IWASAKI sc = (struct acpi_softc *)arg; 3059f9390180SMitsuru IWASAKI if (sc == NULL) { 3060f9390180SMitsuru IWASAKI error = EINVAL; 3061f9390180SMitsuru IWASAKI goto out; 3062f9390180SMitsuru IWASAKI } 3063f9390180SMitsuru IWASAKI 3064f9390180SMitsuru IWASAKI va_start(ap, arg); 3065f9390180SMitsuru IWASAKI state = va_arg(ap, int); 3066f9390180SMitsuru IWASAKI va_end(ap); 3067f9390180SMitsuru IWASAKI 3068f9390180SMitsuru IWASAKI switch (state) { 3069f9390180SMitsuru IWASAKI case POWER_SLEEP_STATE_STANDBY: 3070f9390180SMitsuru IWASAKI acpi_state = sc->acpi_standby_sx; 3071f9390180SMitsuru IWASAKI break; 3072f9390180SMitsuru IWASAKI case POWER_SLEEP_STATE_SUSPEND: 3073f9390180SMitsuru IWASAKI acpi_state = sc->acpi_suspend_sx; 3074f9390180SMitsuru IWASAKI break; 3075f9390180SMitsuru IWASAKI case POWER_SLEEP_STATE_HIBERNATE: 3076f9390180SMitsuru IWASAKI acpi_state = ACPI_STATE_S4; 3077f9390180SMitsuru IWASAKI break; 3078f9390180SMitsuru IWASAKI default: 3079f9390180SMitsuru IWASAKI error = EINVAL; 3080f9390180SMitsuru IWASAKI goto out; 3081f9390180SMitsuru IWASAKI } 3082f9390180SMitsuru IWASAKI 3083f9390180SMitsuru IWASAKI acpi_SetSleepState(sc, acpi_state); 3084f9390180SMitsuru IWASAKI break; 3085f9390180SMitsuru IWASAKI default: 3086f9390180SMitsuru IWASAKI error = EINVAL; 3087f9390180SMitsuru IWASAKI goto out; 3088f9390180SMitsuru IWASAKI } 3089f9390180SMitsuru IWASAKI 3090f9390180SMitsuru IWASAKI out: 3091f9390180SMitsuru IWASAKI return (error); 3092f9390180SMitsuru IWASAKI } 3093f9390180SMitsuru IWASAKI 3094f9390180SMitsuru IWASAKI static void 3095f9390180SMitsuru IWASAKI acpi_pm_register(void *arg) 3096f9390180SMitsuru IWASAKI { 3097be2b1797SNate Lawson if (!cold || resource_disabled("acpi", 0)) 30986c407052SMitsuru IWASAKI return; 3099f9390180SMitsuru IWASAKI 3100f9390180SMitsuru IWASAKI power_pm_register(POWER_PM_TYPE_ACPI, acpi_pm_func, NULL); 3101f9390180SMitsuru IWASAKI } 3102f9390180SMitsuru IWASAKI 3103f9390180SMitsuru IWASAKI SYSINIT(power, SI_SUB_KLD, SI_ORDER_ANY, acpi_pm_register, 0); 3104