/usr/src/sys/dev/acpi/acpi.c

Bug Summary

File:	dev/acpi/acpi.c
Warning:	line 1746, column 15 Branch condition evaluates to a garbage value
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name acpi.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -ffreestanding -mcmodel=kernel -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -target-feature -sse2 -target-feature -sse -target-feature -3dnow -target-feature -mmx -target-feature +save-args -disable-red-zone -no-implicit-float -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -nostdsysteminc -nobuiltininc -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/sys -I /usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -I /usr/src/sys/arch -I /usr/src/sys/dev/pci/drm/include -I /usr/src/sys/dev/pci/drm/include/uapi -I /usr/src/sys/dev/pci/drm/amd/include/asic_reg -I /usr/src/sys/dev/pci/drm/amd/include -I /usr/src/sys/dev/pci/drm/amd/amdgpu -I /usr/src/sys/dev/pci/drm/amd/display -I /usr/src/sys/dev/pci/drm/amd/display/include -I /usr/src/sys/dev/pci/drm/amd/display/dc -I /usr/src/sys/dev/pci/drm/amd/display/amdgpu_dm -I /usr/src/sys/dev/pci/drm/amd/pm/inc -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu11 -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu12 -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/hwmgr -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/smumgr -I /usr/src/sys/dev/pci/drm/amd/display/dc/inc -I /usr/src/sys/dev/pci/drm/amd/display/dc/inc/hw -I /usr/src/sys/dev/pci/drm/amd/display/dc/clk_mgr -I /usr/src/sys/dev/pci/drm/amd/display/modules/inc -I /usr/src/sys/dev/pci/drm/amd/display/modules/hdcp -I /usr/src/sys/dev/pci/drm/amd/display/dmub/inc -I /usr/src/sys/dev/pci/drm/i915 -D DDB -D DIAGNOSTIC -D KTRACE -D ACCOUNTING -D KMEMSTATS -D PTRACE -D POOL_DEBUG -D CRYPTO -D SYSVMSG -D SYSVSEM -D SYSVSHM -D UVM_SWAP_ENCRYPT -D FFS -D FFS2 -D FFS_SOFTUPDATES -D UFS_DIRHASH -D QUOTA -D EXT2FS -D MFS -D NFSCLIENT -D NFSSERVER -D CD9660 -D UDF -D MSDOSFS -D FIFO -D FUSE -D SOCKET_SPLICE -D TCP_ECN -D TCP_SIGNATURE -D INET6 -D IPSEC -D PPP_BSDCOMP -D PPP_DEFLATE -D PIPEX -D MROUTING -D MPLS -D BOOT_CONFIG -D USER_PCICONF -D APERTURE -D MTRR -D NTFS -D HIBERNATE -D PCIVERBOSE -D USBVERBOSE -D WSDISPLAY_COMPAT_USL -D WSDISPLAY_COMPAT_RAWKBD -D WSDISPLAY_DEFAULTSCREENS=6 -D X86EMU -D ONEWIREVERBOSE -D MULTIPROCESSOR -D MAXUSERS=80 -D _KERNEL -D CONFIG_DRM_AMD_DC_DCN3_0 -O2 -Wno-pointer-sign -Wno-address-of-packed-member -Wno-constant-conversion -Wno-unused-but-set-variable -Wno-gnu-folding-constant -fdebug-compilation-dir=/usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -o /usr/obj/sys/arch/amd64/compile/GENERIC.MP/scan-build/2022-01-12-131800-47421-1 -x c /usr/src/sys/dev/acpi/acpi.c
1/* $OpenBSD: acpi.c,v 1.404 2022/01/04 13:40:58 patrick Exp $ */
2/*
* Copyright (c) 2005 Thorsten Lockert <tholo@sigmasoft.com>
* Copyright (c) 2005 Jordan Hargrave <jordan@openbsd.org>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/

19#include <sys/param.h>
20#include <sys/systm.h>
21#include <sys/buf.h>
22#include <sys/device.h>
23#include <sys/malloc.h>
24#include <sys/fcntl.h>
25#include <sys/ioccom.h>
26#include <sys/event.h>
27#include <sys/signalvar.h>
28#include <sys/proc.h>
29#include <sys/kthread.h>
30#include <sys/sched.h>
31#include <sys/reboot.h>
32#include <sys/sysctl.h>
33#include <sys/mount.h>
34#include <sys/syscallargs.h>
35#include <sys/sensors.h>
36#include <sys/timetc.h>

38#ifdef HIBERNATE1
39#include <sys/hibernate.h>
40#endif

42#include <machine/conf.h>
43#include <machine/cpufunc.h>
44#include <machine/bus.h>

46#include <dev/pci/pcivar.h>
47#include <dev/acpi/acpireg.h>
48#include <dev/acpi/acpivar.h>
49#include <dev/acpi/amltypes.h>
50#include <dev/acpi/acpidev.h>
51#include <dev/acpi/dsdt.h>
52#include <dev/wscons/wsdisplayvar.h>

54#include <dev/pci/pcidevs.h>
55#include <dev/pci/ppbreg.h>

57#include <dev/pci/pciidevar.h>

59#include <machine/apmvar.h>
60#define APMUNIT(dev)(((unsigned)((dev) & 0xff) | (((dev) & 0xffff0000) >>
 8))&0xf0)	(minor(dev)((unsigned)((dev) & 0xff) | (((dev) & 0xffff0000) >>
 8))&0xf0)
61#define APMDEV(dev)(((unsigned)((dev) & 0xff) | (((dev) & 0xffff0000) >>
 8))&0x0f)	(minor(dev)((unsigned)((dev) & 0xff) | (((dev) & 0xffff0000) >>
 8))&0x0f)
62#define APMDEV_NORMAL0	0
63#define APMDEV_CTL8	8

65#include "wd.h"
66#include "wsdisplay.h"
67#include "softraid.h"

69#ifdef ACPI_DEBUG
70int	acpi_debug = 16;
71#endif

73int	acpi_poll_enabled;
74int	acpi_hasprocfvs;
75int	acpi_haspci;

77#define ACPIEN_RETRIES15 15

79struct aml_node *acpi_pci_match(struct device *, struct pci_attach_args *);
80pcireg_t acpi_pci_min_powerstate(pci_chipset_tag_t, pcitag_t);
81void	 acpi_pci_set_powerstate(pci_chipset_tag_t, pcitag_t, int, int);
82int	acpi_pci_notify(struct aml_node *, int, void *);

84int	acpi_submatch(struct device *, void *, void *);
85int	acpi_print(void *, const char *);

87void	acpi_map_pmregs(struct acpi_softc *);
88void	acpi_unmap_pmregs(struct acpi_softc *);

90int	acpi_loadtables(struct acpi_softc *, struct acpi_rsdp *);

92int	_acpi_matchhids(const char *, const char *[]);

94int	acpi_inidev(struct aml_node *, void *);
95int	acpi_foundprt(struct aml_node *, void *);

97int	acpi_enable(struct acpi_softc *);
98void	acpi_init_states(struct acpi_softc *);

100void 	acpi_gpe_task(void *, int);
101void	acpi_sbtn_task(void *, int);
102void	acpi_pbtn_task(void *, int);

104int	acpi_enabled;

106void	acpi_init_gpes(struct acpi_softc *);
107void	acpi_disable_allgpes(struct acpi_softc *);
108struct gpe_block *acpi_find_gpe(struct acpi_softc *, int);
109void	acpi_enable_onegpe(struct acpi_softc *, int);
110int	acpi_gpe(struct acpi_softc *, int, void *);

112void	acpi_enable_rungpes(struct acpi_softc *);
113void	acpi_enable_wakegpes(struct acpi_softc *, int);


116int	acpi_foundec(struct aml_node *, void *);
117int	acpi_foundsony(struct aml_node *node, void *arg);
118int	acpi_foundhid(struct aml_node *, void *);
119int	acpi_add_device(struct aml_node *node, void *arg);

121void	acpi_thread(void *);
122void	acpi_create_thread(void *);

124#ifndef SMALL_KERNEL

126void	acpi_indicator(struct acpi_softc *, int);

128void	acpi_init_pm(struct acpi_softc *);

130int	acpi_founddock(struct aml_node *, void *);
131int	acpi_foundpss(struct aml_node *, void *);
132int	acpi_foundtmp(struct aml_node *, void *);
133int	acpi_foundprw(struct aml_node *, void *);
134int	acpi_foundvideo(struct aml_node *, void *);
135int	acpi_foundsbs(struct aml_node *node, void *);

137int	acpi_foundide(struct aml_node *node, void *arg);
138int	acpiide_notify(struct aml_node *, int, void *);
139void	wdcattach(struct channel_softc *);
140int	wdcdetach(struct channel_softc *, int);
141int	is_ejectable_bay(struct aml_node *node);
142int	is_ata(struct aml_node *node);
143int	is_ejectable(struct aml_node *node);

145struct idechnl {
struct acpi_softc *sc;
int64_t		addr;
int64_t		chnl;
int64_t		sta;
150};

152/*
* This is a list of Synaptics devices with a 'top button area'
* based on the list in Linux supplied by Synaptics
* Synaptics clickpads with the following pnp ids will get a unique
* wscons mouse type that is used to define trackpad regions that will
* emulate mouse buttons
*/
159static const char *sbtn_pnp[] = {
"LEN0017",
"LEN0018",
"LEN0019",
"LEN0023",
"LEN002A",
"LEN002B",
"LEN002C",
"LEN002D",
"LEN002E",
"LEN0033",
"LEN0034",
"LEN0035",
"LEN0036",
"LEN0037",
"LEN0038",
"LEN0039",
"LEN0041",
"LEN0042",
"LEN0045",
"LEN0047",
"LEN0049",
"LEN2000",
"LEN2001",
"LEN2002",
"LEN2003",
"LEN2004",
"LEN2005",
"LEN2006",
"LEN2007",
"LEN2008",
"LEN2009",
"LEN200A",
"LEN200B",
193};

195int	mouse_has_softbtn;
196#endif /* SMALL_KERNEL */

198struct acpi_softc *acpi_softc;

200/* XXX move this into dsdt softc at some point */
201extern struct aml_node aml_root;

203struct cfdriver acpi_cd = {
NULL((void *)0), "acpi", DV_DULL
205};

207uint8_t
208acpi_pci_conf_read_1(pci_chipset_tag_t pc, pcitag_t tag, int reg)
209{
uint32_t val = pci_conf_read(pc, tag, reg & ~0x3);
return (val >> ((reg & 0x3) << 3));
212}

214uint16_t
215acpi_pci_conf_read_2(pci_chipset_tag_t pc, pcitag_t tag, int reg)
216{
uint32_t val = pci_conf_read(pc, tag, reg & ~0x2);
return (val >> ((reg & 0x2) << 3));
219}

221uint32_t
222acpi_pci_conf_read_4(pci_chipset_tag_t pc, pcitag_t tag, int reg)
223{
return pci_conf_read(pc, tag, reg);
225}

227void
228acpi_pci_conf_write_1(pci_chipset_tag_t pc, pcitag_t tag, int reg, uint8_t val)
229{
uint32_t tmp = pci_conf_read(pc, tag, reg & ~0x3);
tmp &= ~(0xff << ((reg & 0x3) << 3));
tmp |= (val << ((reg & 0x3) << 3));
pci_conf_write(pc, tag, reg & ~0x3, tmp);
234}

236void
237acpi_pci_conf_write_2(pci_chipset_tag_t pc, pcitag_t tag, int reg, uint16_t val)
238{
uint32_t tmp = pci_conf_read(pc, tag, reg & ~0x2);
tmp &= ~(0xffff << ((reg & 0x2) << 3));
tmp |= (val << ((reg & 0x2) << 3));
pci_conf_write(pc, tag, reg & ~0x2, tmp);
243}

245void
246acpi_pci_conf_write_4(pci_chipset_tag_t pc, pcitag_t tag, int reg, uint32_t val)
247{
pci_conf_write(pc, tag, reg, val);
249}

251int
252acpi_gasio(struct acpi_softc *sc, int iodir, int iospace, uint64_t address,
  int access_size, int len, void *buffer)
254{
uint8_t *pb;
bus_space_tag_t iot;
bus_space_handle_t ioh;
pci_chipset_tag_t pc;
pcitag_t tag;
int reg, idx;

dnprintf(50, "gasio: %.2x 0x%.8llx %s\n",
   iospace, address, (iodir == ACPI_IOWRITE) ? "write" : "read");

KASSERT((len % access_size) == 0)(((len % access_size) == 0) ? (void)0 : __assert("diagnostic "
, "/usr/src/sys/dev/acpi/acpi.c", 265, "(len % access_size) == 0"
));

pb = (uint8_t *)buffer;
switch (iospace) {
case GAS_SYSTEM_MEMORY0:
case GAS_SYSTEM_IOSPACE1:
if (iospace == GAS_SYSTEM_MEMORY0)
	iot = sc->sc_memt;
else
	iot = sc->sc_iot;

if (acpi_bus_space_map(iot, address, len, 0, &ioh) != 0) {
	printf("%s: unable to map iospace\n", DEVNAME(sc)((sc)->sc_dev.dv_xname));
	return (-1);
}
for (reg = 0; reg < len; reg += access_size) {
	if (iodir == ACPI_IOREAD0) {
		switch (access_size) {
		case 1:
			*(uint8_t *)(pb + reg) =
			    bus_space_read_1(iot, ioh, reg)((iot)->read_1((ioh), (reg)));
			dnprintf(80, "os_in8(%llx) = %x\n",
			    reg+address, *(uint8_t *)(pb+reg));
			break;
		case 2:
			*(uint16_t *)(pb + reg) =
			    bus_space_read_2(iot, ioh, reg)((iot)->read_2((ioh), (reg)));
			dnprintf(80, "os_in16(%llx) = %x\n",
			    reg+address, *(uint16_t *)(pb+reg));
			break;
		case 4:
			*(uint32_t *)(pb + reg) =
			    bus_space_read_4(iot, ioh, reg)((iot)->read_4((ioh), (reg)));
			break;
		default:
			printf("%s: rdio: invalid size %d\n",
			    DEVNAME(sc)((sc)->sc_dev.dv_xname), access_size);
			return (-1);
		}
	} else {
		switch (access_size) {
		case 1:
			bus_space_write_1(iot, ioh, reg,((iot)->write_1((ioh), (reg), (*(uint8_t *)(pb + reg))))
			    *(uint8_t *)(pb + reg))((iot)->write_1((ioh), (reg), (*(uint8_t *)(pb + reg))));
			dnprintf(80, "os_out8(%llx,%x)\n",
			    reg+address, *(uint8_t *)(pb+reg));
			break;
		case 2:
			bus_space_write_2(iot, ioh, reg,((iot)->write_2((ioh), (reg), (*(uint16_t *)(pb + reg))))
			    *(uint16_t *)(pb + reg))((iot)->write_2((ioh), (reg), (*(uint16_t *)(pb + reg))));
			dnprintf(80, "os_out16(%llx,%x)\n",
			    reg+address, *(uint16_t *)(pb+reg));
			break;
		case 4:
			bus_space_write_4(iot, ioh, reg,((iot)->write_4((ioh), (reg), (*(uint32_t *)(pb + reg))))
			    *(uint32_t *)(pb + reg))((iot)->write_4((ioh), (reg), (*(uint32_t *)(pb + reg))));
			break;
		default:
			printf("%s: wrio: invalid size %d\n",
			    DEVNAME(sc)((sc)->sc_dev.dv_xname), access_size);
			return (-1);
		}
	}
}
acpi_bus_space_unmap(iot, ioh, len);
break;

case GAS_PCI_CFG_SPACE2:
/*
 * The ACPI standard says that a function number of
 * FFFF can be used to refer to all functions on a
 * device.  This makes no sense though in the context
 * of accessing PCI config space.  Yet there is AML
 * out there that does this.  We simulate a read from
 * a nonexistent device here.  Writes will panic when
 * we try to construct the tag below.
 */
if (ACPI_PCI_FN(address)(uint16_t)((address) >> 16) == 0xffff && iodir == ACPI_IOREAD0) {
	memset(buffer, 0xff, len)__builtin_memset((buffer), (0xff), (len));
	return (0);
}

pc = pci_lookup_segment(ACPI_PCI_SEG(address)(uint16_t)((address) >> 48));
tag = pci_make_tag(pc,
    ACPI_PCI_BUS(address)(uint8_t)((address) >> 40), ACPI_PCI_DEV(address)(uint8_t)((address) >> 32),
    ACPI_PCI_FN(address)(uint16_t)((address) >> 16));

reg = ACPI_PCI_REG(address)(uint16_t)(address);
for (idx = 0; idx < len; idx += access_size) {
	if (iodir == ACPI_IOREAD0) {
		switch (access_size) {
		case 1:
			*(uint8_t *)(pb + idx) =
			    acpi_pci_conf_read_1(pc, tag, reg + idx);
			break;
		case 2:
			*(uint16_t *)(pb + idx) =
			    acpi_pci_conf_read_2(pc, tag, reg + idx);
			break;
		case 4:
			*(uint32_t *)(pb + idx) =
			    acpi_pci_conf_read_4(pc, tag, reg + idx);
			break;
		default:
			printf("%s: rdcfg: invalid size %d\n",
			    DEVNAME(sc)((sc)->sc_dev.dv_xname), access_size);
			return (-1);
		}
	} else {
		switch (access_size) {
		case 1:
			acpi_pci_conf_write_1(pc, tag, reg + idx,
			    *(uint8_t *)(pb + idx));
			break;
		case 2:
			acpi_pci_conf_write_2(pc, tag, reg + idx,
			    *(uint16_t *)(pb + idx));
			break;
		case 4:
			acpi_pci_conf_write_4(pc, tag, reg + idx,
			    *(uint32_t *)(pb + idx));
			break;
		default:
			printf("%s: wrcfg: invalid size %d\n",
			    DEVNAME(sc)((sc)->sc_dev.dv_xname), access_size);
			return (-1);
		}
	}
}
break;

case GAS_EMBEDDED3:
if (sc->sc_ec == NULL((void *)0)) {
	printf("%s: WARNING EC not initialized\n", DEVNAME(sc)((sc)->sc_dev.dv_xname));
	return (-1);
}
if (iodir == ACPI_IOREAD0)
	acpiec_read(sc->sc_ec, (uint8_t)address, len, buffer);
else
	acpiec_write(sc->sc_ec, (uint8_t)address, len, buffer);
break;
}
return (0);
408}

410int
411acpi_inidev(struct aml_node *node, void *arg)
412{
struct acpi_softc	*sc = (struct acpi_softc *)arg;
int64_t sta;

/*
* Per the ACPI spec 6.5.1, only run _INI when device is there or
* when there is no _STA.  We terminate the tree walk (with return 1)
* early if necessary.
*/

/* Evaluate _STA to decide _INI fate and walk fate */
sta = acpi_getsta(sc, node->parent);

/* Evaluate _INI if we are present */
if (sta & STA_PRESENT(1L << 0))
aml_evalnode(sc, node, 0, NULL((void *)0), NULL((void *)0));

/* If we are functioning, we walk/search our children */
if (sta & STA_DEV_OK(1L << 3))
return 0;

/* If we are not enabled, or not present, terminate search */
if (!(sta & (STA_PRESENT(1L << 0)|STA_ENABLED(1L << 1))))
return 1;

/* Default just continue search */
return 0;
439}

441int
442acpi_foundprt(struct aml_node *node, void *arg)
443{
struct acpi_softc	*sc = (struct acpi_softc *)arg;
struct device		*self = (struct device *)arg;
struct acpi_attach_args	aaa;
int64_t sta;

dnprintf(10, "found prt entry: %s\n", node->parent->name);

/* Evaluate _STA to decide _PRT fate and walk fate */
sta = acpi_getsta(sc, node->parent);
if (sta & STA_PRESENT(1L << 0)) {
memset(&aaa, 0, sizeof(aaa))__builtin_memset((&aaa), (0), (sizeof(aaa)));
aaa.aaa_iot = sc->sc_iot;
aaa.aaa_memt = sc->sc_memt;
aaa.aaa_node = node;
aaa.aaa_name = "acpiprt";

config_found(self, &aaa, acpi_print)config_found_sm((self), (&aaa), (acpi_print), ((void *)0)
);
}

/* If we are functioning, we walk/search our children */
if (sta & STA_DEV_OK(1L << 3))
return 0;

/* If we are not enabled, or not present, terminate search */
if (!(sta & (STA_PRESENT(1L << 0)|STA_ENABLED(1L << 1))))
return 1;

/* Default just continue search */
return 0;
473}

475TAILQ_HEAD(, acpi_pci)struct { struct acpi_pci *tqh_first; struct acpi_pci **tqh_last
; } acpi_pcidevs =
  TAILQ_HEAD_INITIALIZER(acpi_pcidevs){ ((void *)0), &(acpi_pcidevs).tqh_first };
477TAILQ_HEAD(, acpi_pci)struct { struct acpi_pci *tqh_first; struct acpi_pci **tqh_last
; } acpi_pcirootdevs =
  TAILQ_HEAD_INITIALIZER(acpi_pcirootdevs){ ((void *)0), &(acpi_pcirootdevs).tqh_first };

480int acpi_getpci(struct aml_node *node, void *arg);
481int acpi_getminbus(int crsidx, union acpi_resource *crs, void *arg);

483int
484acpi_getminbus(int crsidx, union acpi_resource *crs, void *arg)
485{
int *bbn = arg;
int typ = AML_CRSTYPE(crs)((crs)->hdr.typecode & 0x80 ? (crs)->hdr.typecode :
 (crs)->hdr.typecode >> 3);

/* Check for embedded bus number */
if (typ == LR_WORD0x88 && crs->lr_word.type == 2) {
/* If _MIN > _MAX, the resource is considered to be invalid. */
if (crs->lr_word._min > crs->lr_word._max)
	return -1;
*bbn = crs->lr_word._min;
}
return 0;
497}

499int
500acpi_matchcls(struct acpi_attach_args *aaa, int class, int subclass,
  int interface)
502{
struct acpi_softc *sc = acpi_softc;
struct aml_value res;

if (aaa->aaa_dev == NULL((void *)0) || aaa->aaa_node == NULL((void *)0))
return (0);

if (aml_evalname(sc, aaa->aaa_node, "_CLS", 0, NULL((void *)0), &res))
return (0);

if (res.type != AML_OBJTYPE_PACKAGE || res.length != 3 ||
   res.v_package_.vpackage[0]->type != AML_OBJTYPE_INTEGER ||
   res.v_package_.vpackage[1]->type != AML_OBJTYPE_INTEGER ||
   res.v_package_.vpackage[2]->type != AML_OBJTYPE_INTEGER)
return (0);

if (res.v_package_.vpackage[0]->v_integer_.vinteger == class &&
   res.v_package_.vpackage[1]->v_integer_.vinteger == subclass &&
   res.v_package_.vpackage[2]->v_integer_.vinteger == interface)
return (1);

return (0);
524}

526int
527_acpi_matchhids(const char *hid, const char *hids[])
528{
int i;

for (i = 0; hids[i]; i++)
if (!strcmp(hid, hids[i]))
	return (1);
return (0);
535}

537int
538acpi_matchhids(struct acpi_attach_args *aa, const char *hids[],
  const char *driver)
540{
if (aa->aaa_dev == NULL((void *)0) || aa->aaa_node == NULL((void *)0))
return (0);

if (_acpi_matchhids(aa->aaa_dev, hids)) {
dnprintf(5, "driver %s matches at least one hid\n", driver);
return (2);
}
if (aa->aaa_cdev && _acpi_matchhids(aa->aaa_cdev, hids)) {
dnprintf(5, "driver %s matches at least one cid\n", driver);
return (1);
}

return (0);
554}

556int64_t
557acpi_getsta(struct acpi_softc *sc, struct aml_node *node)
558{
int64_t sta;

if (aml_evalinteger(sc, node, "_STA", 0, NULL((void *)0), &sta))
sta = STA_PRESENT(1L << 0) | STA_ENABLED(1L << 1) | STA_SHOW_UI(1L << 2) |
    STA_DEV_OK(1L << 3) | STA_BATTERY(1L << 4);

return sta;
566}

568/* Map ACPI device node to PCI */
569int
570acpi_getpci(struct aml_node *node, void *arg)
571{
const char *pcihid[] = { ACPI_DEV_PCIB"PNP0A03", ACPI_DEV_PCIEB"PNP0A08", "HWP0002", 0 };
struct acpi_pci *pci, *ppci;
struct aml_value res;
struct acpi_softc *sc = arg;
pci_chipset_tag_t pc;
pcitag_t tag;
uint64_t val;
int64_t sta;
uint32_t reg;

sta = acpi_getsta(sc, node);
if ((sta & STA_PRESENT(1L << 0)) == 0)
return 0;

if (!node->value || node->value->type != AML_OBJTYPE_DEVICE)
return 0;
if (!aml_evalhid(node, &res)) {
/* Check if this is a PCI Root node */
if (_acpi_matchhids(res.v_string_.vstring, pcihid)) {
	aml_freevalue(&res);

	pci = malloc(sizeof(*pci), M_DEVBUF2, M_WAITOK0x0001|M_ZERO0x0008);

	pci->bus = -1;
	if (!aml_evalinteger(sc, node, "_SEG", 0, NULL((void *)0), &val))
		pci->seg = val;
	if (!aml_evalname(sc, node, "_CRS", 0, NULL((void *)0), &res)) {
		aml_parse_resource(&res, acpi_getminbus,
		    &pci->bus);
		dnprintf(10, "%s post-crs: %d\n",
		    aml_nodename(node), pci->bus);
	}
	if (!aml_evalinteger(sc, node, "_BBN", 0, NULL((void *)0), &val)) {
		dnprintf(10, "%s post-bbn: %d, %lld\n",
		    aml_nodename(node), pci->bus, val);
		if (pci->bus == -1)
			pci->bus = val;
	}
	pci->sub = pci->bus;
	node->pci = pci;
	dnprintf(10, "found PCI root: %s %d\n",
	    aml_nodename(node), pci->bus);
	TAILQ_INSERT_TAIL(&acpi_pcirootdevs, pci, next)do { (pci)->next.tqe_next = ((void *)0); (pci)->next.tqe_prev
 = (&acpi_pcirootdevs)->tqh_last; *(&acpi_pcirootdevs
)->tqh_last = (pci); (&acpi_pcirootdevs)->tqh_last =
 &(pci)->next.tqe_next; } while (0);
}
aml_freevalue(&res);
return 0;
}

/* If parent is not PCI, or device does not have _ADR, return */
if (!node->parent || (ppci = node->parent->pci) == NULL((void *)0))
return 0;
if (aml_evalinteger(sc, node, "_ADR", 0, NULL((void *)0), &val))
return 0;

pci = malloc(sizeof(*pci), M_DEVBUF2, M_WAITOK0x0001|M_ZERO0x0008);
pci->seg = ppci->seg;
pci->bus = ppci->sub;
pci->dev = ACPI_ADR_PCIDEV(val)(uint16_t)(val >> 16);
pci->fun = ACPI_ADR_PCIFUN(val)(uint16_t)(val & 0xFFFF);
pci->node = node;
pci->sub = -1;

dnprintf(10, "%.2x:%.2x.%x -> %s\n",
pci->bus, pci->dev, pci->fun,
aml_nodename(node));

/* Collect device power state information. */
if (aml_evalinteger(sc, node, "_S3D", 0, NULL((void *)0), &val) == 0)
pci->_s3d = val;
else
pci->_s3d = -1;
if (aml_evalinteger(sc, node, "_S3W", 0, NULL((void *)0), &val) == 0)
pci->_s3w = val;
else
pci->_s3w = -1;
if (aml_evalinteger(sc, node, "_S4D", 0, NULL((void *)0), &val) == 0)
pci->_s4d = val;
else
pci->_s4d = -1;
if (aml_evalinteger(sc, node, "_S4W", 0, NULL((void *)0), &val) == 0)
pci->_s4w = val;
else
pci->_s4w = -1;

/* Check if PCI device exists */
if (pci->dev > 0x1F || pci->fun > 7) {
free(pci, M_DEVBUF2, sizeof(*pci));
return (1);
}
pc = pci_lookup_segment(pci->seg);
tag = pci_make_tag(pc, pci->bus, pci->dev, pci->fun);
reg = pci_conf_read(pc, tag, PCI_ID_REG0x00);
if (PCI_VENDOR(reg)(((reg) >> 0) & 0xffff) == PCI_VENDOR_INVALID0xffff) {
free(pci, M_DEVBUF2, sizeof(*pci));
return (1);
}
node->pci = pci;

TAILQ_INSERT_TAIL(&acpi_pcidevs, pci, next)do { (pci)->next.tqe_next = ((void *)0); (pci)->next.tqe_prev
 = (&acpi_pcidevs)->tqh_last; *(&acpi_pcidevs)->
tqh_last = (pci); (&acpi_pcidevs)->tqh_last = &(pci
)->next.tqe_next; } while (0);

/* Check if this is a PCI bridge */
reg = pci_conf_read(pc, tag, PCI_CLASS_REG0x08);
if (PCI_CLASS(reg)(((reg) >> 24) & 0xff) == PCI_CLASS_BRIDGE0x06 &&
   PCI_SUBCLASS(reg)(((reg) >> 16) & 0xff) == PCI_SUBCLASS_BRIDGE_PCI0x04) {
reg = pci_conf_read(pc, tag, PPB_REG_BUSINFO0x18);
pci->sub = PPB_BUSINFO_SECONDARY(reg)((reg >> 8) & 0xff);

dnprintf(10, "found PCI bridge: %s %d\n",
    aml_nodename(node), pci->sub);

/* Continue scanning */
return (0);
}

/* Device does not have children, stop scanning */
return (1);
688}

690struct aml_node *
691acpi_find_pci(pci_chipset_tag_t pc, pcitag_t tag)
692{
struct acpi_pci *pdev;
int bus, dev, fun;

pci_decompose_tag(pc, tag, &bus, &dev, &fun);
TAILQ_FOREACH(pdev, &acpi_pcidevs, next)for((pdev) = ((&acpi_pcidevs)->tqh_first); (pdev) != (
(void *)0); (pdev) = ((pdev)->next.tqe_next)) {
if (pdev->bus == bus && pdev->dev == dev && pdev->fun == fun)
	return pdev->node;
}

return NULL((void *)0);
703}

705struct aml_node *
706acpi_pci_match(struct device *dev, struct pci_attach_args *pa)
707{
struct acpi_pci *pdev;
int state;

TAILQ_FOREACH(pdev, &acpi_pcidevs, next)for((pdev) = ((&acpi_pcidevs)->tqh_first); (pdev) != (
(void *)0); (pdev) = ((pdev)->next.tqe_next)) {
if (pdev->bus != pa->pa_bus ||
    pdev->dev != pa->pa_device ||
    pdev->fun != pa->pa_function)
	continue;

dnprintf(10,"%s at acpi0 %s\n", dev->dv_xname,
    aml_nodename(pdev->node));

pdev->device = dev;

/*
 * If some Power Resources are dependent on this device
 * initialize them.
 */
state = pci_get_powerstate(pa->pa_pc, pa->pa_tag);
acpi_pci_set_powerstate(pa->pa_pc, pa->pa_tag, state, 1);
acpi_pci_set_powerstate(pa->pa_pc, pa->pa_tag, state, 0);

aml_register_notify(pdev->node, NULL((void *)0), acpi_pci_notify, pdev, 0);

return pdev->node;
}

return NULL((void *)0);
736}

738pcireg_t
739acpi_pci_min_powerstate(pci_chipset_tag_t pc, pcitag_t tag)
740{
struct acpi_pci *pdev;
int bus, dev, fun;
int state = -1, defaultstate = pci_get_powerstate(pc, tag);

pci_decompose_tag(pc, tag, &bus, &dev, &fun);
TAILQ_FOREACH(pdev, &acpi_pcidevs, next)for((pdev) = ((&acpi_pcidevs)->tqh_first); (pdev) != (
(void *)0); (pdev) = ((pdev)->next.tqe_next)) {
if (pdev->bus == bus && pdev->dev == dev && pdev->fun == fun) {
	switch (acpi_softc->sc_state) {
	case ACPI_STATE_S33:
		defaultstate = PCI_PMCSR_STATE_D30x0003;
		state = MAX(pdev->_s3d, pdev->_s3w)(((pdev->_s3d)>(pdev->_s3w))?(pdev->_s3d):(pdev->
_s3w));
		break;
	case ACPI_STATE_S44:
		state = MAX(pdev->_s4d, pdev->_s4w)(((pdev->_s4d)>(pdev->_s4w))?(pdev->_s4d):(pdev->
_s4w));
		break;
	case ACPI_STATE_S55:
	default:
		break;
	}

	if (state >= PCI_PMCSR_STATE_D00x0000 &&
	    state <= PCI_PMCSR_STATE_D30x0003)
		return state;
}
}

return defaultstate;
768}

770void
771acpi_pci_set_powerstate(pci_chipset_tag_t pc, pcitag_t tag, int state, int pre)
772{
773#if NACPIPWRRES1 > 0
struct acpi_softc *sc = acpi_softc;
struct acpi_pwrres *pr;
struct acpi_pci *pdev;
int bus, dev, fun;
char name[5];

pci_decompose_tag(pc, tag, &bus, &dev, &fun);
TAILQ_FOREACH(pdev, &acpi_pcidevs, next)for((pdev) = ((&acpi_pcidevs)->tqh_first); (pdev) != (
(void *)0); (pdev) = ((pdev)->next.tqe_next)) {
if (pdev->bus == bus && pdev->dev == dev && pdev->fun == fun)
	break;
}

/* XXX Add a check to discard nodes without Power Resources? */
if (pdev == NULL((void *)0))
return;

SIMPLEQ_FOREACH(pr, &sc->sc_pwrresdevs, p_next)for((pr) = ((&sc->sc_pwrresdevs)->sqh_first); (pr) !=
 ((void *)0); (pr) = ((pr)->p_next.sqe_next)) {
if (pr->p_node != pdev->node)
	continue;

/*
 * If the firmware is already aware that the device
 * is in the given state, there's nothing to do.
 */
if (pr->p_state == state)
	continue;

if (pre) {
	/*
	 * If a Resource is dependent on this device for
	 * the given state, make sure it is turned "_ON".
	 */
	if (pr->p_res_state == state)
		acpipwrres_ref_incr(pr->p_res_sc, pr->p_node);
} else {
	/*
	 * If a Resource was referenced for the state we
	 * left, drop a reference and turn it "_OFF" if
	 * it was the last one.
	 */
	if (pr->p_res_state == pr->p_state)
		acpipwrres_ref_decr(pr->p_res_sc, pr->p_node);

	if (pr->p_res_state == state) {
		snprintf(name, sizeof(name), "_PS%d", state);
		aml_evalname(sc, pr->p_node, name, 0,
		    NULL((void *)0), NULL((void *)0));
	}

	pr->p_state = state;
}

}
827#endif /* NACPIPWRRES > 0 */
828}

830int
831acpi_pci_notify(struct aml_node *node, int ntype, void *arg)
832{
struct acpi_pci *pdev = arg;
pci_chipset_tag_t pc;
pcitag_t tag;
pcireg_t reg;
int offset;

/* We're only interested in Device Wake notifications. */
if (ntype != 2)
return (0);

pc = pci_lookup_segment(pdev->seg);
tag = pci_make_tag(pc, pdev->bus, pdev->dev, pdev->fun);
if (pci_get_capability(pc, tag, PCI_CAP_PWRMGMT0x01, &offset, 0)) {
/* Clear the PME Status bit if it is set. */
reg = pci_conf_read(pc, tag, offset + PCI_PMCSR0x04);
pci_conf_write(pc, tag, offset + PCI_PMCSR0x04, reg);
}

return (0);
852}

854void
855acpi_pciroots_attach(struct device *dev, void *aux, cfprint_t pr)
856{
struct acpi_pci			*pdev;
struct pcibus_attach_args	*pba = aux;

KASSERT(pba->pba_busex != NULL)((pba->pba_busex != ((void *)0)) ? (void)0 : __assert("diagnostic "
, "/usr/src/sys/dev/acpi/acpi.c", 860, "pba->pba_busex != NULL"
));

TAILQ_FOREACH(pdev, &acpi_pcirootdevs, next)for((pdev) = ((&acpi_pcirootdevs)->tqh_first); (pdev) !=
 ((void *)0); (pdev) = ((pdev)->next.tqe_next)) {
if (extent_alloc_region(pba->pba_busex, pdev->bus,
    1, EX_NOWAIT0x0000) != 0)
	continue;
pba->pba_bus = pdev->bus;
config_found(dev, pba, pr)config_found_sm((dev), (pba), (pr), ((void *)0));
}
869}

871/* GPIO support */

873struct acpi_gpio_event {
struct aml_node *node;
uint16_t pin;
876};

878void
879acpi_gpio_event_task(void *arg0, int arg1)
880{
struct aml_node *node = arg0;
struct aml_value evt;
uint16_t pin = arg1;
char name[5];

if (pin < 256) {
snprintf(name, sizeof(name), "_E%.2X", pin);
if (aml_evalname(acpi_softc, node, name, 0, NULL((void *)0), NULL((void *)0)) == 0)
	return;
}

memset(&evt, 0, sizeof(evt))__builtin_memset((&evt), (0), (sizeof(evt)));
evt.v_integer_.vinteger = pin;
evt.type = AML_OBJTYPE_INTEGER;
aml_evalname(acpi_softc, node, "_EVT", 1, &evt, NULL((void *)0));
896}

898int
899acpi_gpio_event(void *arg)
900{
struct acpi_gpio_event *ev = arg;

acpi_addtask(acpi_softc, acpi_gpio_event_task, ev->node, ev->pin);
acpi_wakeup(acpi_softc);
return 1;
906}

908int
909acpi_gpio_parse_events(int crsidx, union acpi_resource *crs, void *arg)
910{
struct aml_node *devnode = arg;
struct aml_node *node;
uint16_t pin;

switch (AML_CRSTYPE(crs)((crs)->hdr.typecode & 0x80 ? (crs)->hdr.typecode :
 (crs)->hdr.typecode >> 3)) {
case LR_GPIO0x8C:
node = aml_searchname(devnode,
    (char *)&crs->pad[crs->lr_gpio.res_off]);
pin = *(uint16_t *)&crs->pad[crs->lr_gpio.pin_off];
if (crs->lr_gpio.type == LR_GPIO_INT0x00 && pin < 256 &&
    node && node->gpio && node->gpio->intr_establish) {
	struct acpi_gpio *gpio = node->gpio;
	struct acpi_gpio_event *ev;

	ev = malloc(sizeof(*ev), M_DEVBUF2, M_WAITOK0x0001);
	ev->node = devnode;
	ev->pin = pin;
	gpio->intr_establish(gpio->cookie, pin,
	    crs->lr_gpio.tflags, acpi_gpio_event, ev);
}
break;
default:
printf("%s: unknown resource type %d\n", __func__,
    AML_CRSTYPE(crs)((crs)->hdr.typecode & 0x80 ? (crs)->hdr.typecode :
 (crs)->hdr.typecode >> 3));
}

return 0;
938}

940void
941acpi_register_gpio(struct acpi_softc *sc, struct aml_node *devnode)
942{
struct aml_value arg[2];
struct aml_node *node;
struct aml_value res;

/* Register GeneralPurposeIO address space. */
memset(&arg, 0, sizeof(arg))__builtin_memset((&arg), (0), (sizeof(arg)));
arg[0].type = AML_OBJTYPE_INTEGER;
arg[0].v_integer_.vinteger = ACPI_OPREG_GPIO8;
arg[1].type = AML_OBJTYPE_INTEGER;
arg[1].v_integer_.vinteger = 1;
node = aml_searchname(devnode, "_REG");
if (node && aml_evalnode(sc, node, 2, arg, NULL((void *)0)))
printf("%s: _REG failed\n", node->name);

/* Register GPIO signaled ACPI events. */
if (aml_evalname(sc, devnode, "_AEI", 0, NULL((void *)0), &res))
return;
aml_parse_resource(&res, acpi_gpio_parse_events, devnode);
961}

963#ifndef SMALL_KERNEL

965void
966acpi_register_gsb(struct acpi_softc *sc, struct aml_node *devnode)
967{
struct aml_value arg[2];
struct aml_node *node;

/* Register GenericSerialBus address space. */
memset(&arg, 0, sizeof(arg))__builtin_memset((&arg), (0), (sizeof(arg)));
arg[0].type = AML_OBJTYPE_INTEGER;
arg[0].v_integer_.vinteger = ACPI_OPREG_GSB9;
arg[1].type = AML_OBJTYPE_INTEGER;
arg[1].v_integer_.vinteger = 1;
node = aml_searchname(devnode, "_REG");
if (node && aml_evalnode(sc, node, 2, arg, NULL((void *)0)))
printf("%s: _REG failed\n", node->name);
980}

982#endif

984void
985acpi_attach_common(struct acpi_softc *sc, paddr_t base)
986{
struct acpi_mem_map handle;
struct acpi_rsdp *rsdp;
struct acpi_q *entry;
struct acpi_dsdt *p_dsdt;
991#ifndef SMALL_KERNEL
int wakeup_dev_ct;
struct acpi_wakeq *wentry;
struct device *dev;
995#endif /* SMALL_KERNEL */
paddr_t facspa;
uint16_t pm1;
int s;

rw_init(&sc->sc_lck, "acpilk")_rw_init_flags(&sc->sc_lck, "acpilk", 0, ((void *)0));

acpi_softc = sc;

if (acpi_map(base, sizeof(struct acpi_rsdp), &handle)) {
1
Assuming the condition is false→
2
←
Taking false branch→
printf(": can't map memory\n");
return;
}
rsdp = (struct acpi_rsdp *)handle.va;

SIMPLEQ_INIT(&sc->sc_tables)do { (&sc->sc_tables)->sqh_first = ((void *)0); (&
sc->sc_tables)->sqh_last = &(&sc->sc_tables)
->sqh_first; } while (0);
3
←
Loop condition is false.  Exiting loop→
SIMPLEQ_INIT(&sc->sc_wakedevs)do { (&sc->sc_wakedevs)->sqh_first = ((void *)0); (
&sc->sc_wakedevs)->sqh_last = &(&sc->sc_wakedevs
)->sqh_first; } while (0);
4
←
Loop condition is false.  Exiting loop→
1012#if NACPIPWRRES1 > 0
SIMPLEQ_INIT(&sc->sc_pwrresdevs)do { (&sc->sc_pwrresdevs)->sqh_first = ((void *)0);
 (&sc->sc_pwrresdevs)->sqh_last = &(&sc->
sc_pwrresdevs)->sqh_first; } while (0);
5
←
Loop condition is false.  Exiting loop→
1014#endif /* NACPIPWRRES > 0 */


1017#ifndef SMALL_KERNEL
sc->sc_note = malloc(sizeof(struct klist), M_DEVBUF2, M_NOWAIT0x0002 | M_ZERO0x0008);
if (sc->sc_note == NULL((void *)0)) {
6
←
Assuming field 'sc_note' is not equal to NULL→
7
←
Taking false branch→
printf(": can't allocate memory\n");
acpi_unmap(&handle);
return;
}
1024#endif /* SMALL_KERNEL */

if (acpi_loadtables(sc, rsdp)) {
8
←
Taking false branch→
printf(": can't load tables\n");
acpi_unmap(&handle);
return;
}

acpi_unmap(&handle);

/*
* Find the FADT
*/
SIMPLEQ_FOREACH(entry, &sc->sc_tables, q_next)for((entry) = ((&sc->sc_tables)->sqh_first); (entry
) != ((void *)0); (entry) = ((entry)->q_next.sqe_next)) {
9
←
Loop condition is false. Execution continues on line 1044→
if (memcmp(entry->q_table, FADT_SIG,__builtin_memcmp((entry->q_table), ("FACP"), (sizeof("FACP"
) - 1))
    sizeof(FADT_SIG) - 1)__builtin_memcmp((entry->q_table), ("FACP"), (sizeof("FACP"
) - 1)) == 0) {
	sc->sc_fadt = entry->q_table;
	break;
}
}
if (sc->sc_fadt == NULL((void *)0)) {
10
←
Assuming field 'sc_fadt' is not equal to NULL→
11
←
Taking false branch→
printf(": no FADT\n");
return;
}

sc->sc_major = sc->sc_fadt->hdr.revision;
if (sc->sc_major > 4)
12
←
Assuming field 'sc_major' is <= 4→
13
←
Taking false branch→
sc->sc_minor = sc->sc_fadt->fadt_minor;
printf(": ACPI %d.%d", sc->sc_major, sc->sc_minor);

/*
* A bunch of things need to be done differently for
* Hardware-reduced ACPI.
*/
if (sc->sc_fadt->hdr_revisionhdr.revision >= 5 &&
   sc->sc_fadt->flags & FADT_HW_REDUCED_ACPI0x00100000)
sc->sc_hw_reduced = 1;

/* Map Power Management registers */
acpi_map_pmregs(sc);
14
←
Calling 'acpi_map_pmregs'→

/*
* Check if we can and need to enable ACPI control.
*/
pm1 = acpi_read_pmreg(sc, ACPIREG_PM1_CNT0x10, 0);
if ((pm1 & ACPI_PM1_SCI_EN0x0001) == 0 && sc->sc_fadt->smi_cmd &&
   (!sc->sc_fadt->acpi_enable && !sc->sc_fadt->acpi_disable)) {
printf(", ACPI control unavailable\n");
acpi_unmap_pmregs(sc);
return;
}

/*
* Set up a pointer to the firmware control structure
*/
if (sc->sc_fadt->hdr_revisionhdr.revision < 3 || sc->sc_fadt->x_firmware_ctl == 0)
facspa = sc->sc_fadt->firmware_ctl;
else
facspa = sc->sc_fadt->x_firmware_ctl;

if (acpi_map(facspa, sizeof(struct acpi_facs), &handle))
printf(" !FACS");
else
sc->sc_facs = (struct acpi_facs *)handle.va;

/* Create opcode hashtable */
aml_hashopcodes();

/* Create Default AML objects */
aml_create_defaultobjects();

/*
* Load the DSDT from the FADT pointer -- use the
* extended (64-bit) pointer if it exists
*/
if (sc->sc_fadt->hdr_revisionhdr.revision < 3 || sc->sc_fadt->x_dsdt == 0)
entry = acpi_maptable(sc, sc->sc_fadt->dsdt, NULL((void *)0), NULL((void *)0), NULL((void *)0),
    -1);
else
entry = acpi_maptable(sc, sc->sc_fadt->x_dsdt, NULL((void *)0), NULL((void *)0), NULL((void *)0),
    -1);

if (entry == NULL((void *)0))
printf(" !DSDT");

p_dsdt = entry->q_table;
acpi_parse_aml(sc, p_dsdt->aml, p_dsdt->hdr_lengthhdr.length -
   sizeof(p_dsdt->hdr));

/* Load SSDT's */
SIMPLEQ_FOREACH(entry, &sc->sc_tables, q_next)for((entry) = ((&sc->sc_tables)->sqh_first); (entry
) != ((void *)0); (entry) = ((entry)->q_next.sqe_next)) {
if (memcmp(entry->q_table, SSDT_SIG,__builtin_memcmp((entry->q_table), ("SSDT"), (sizeof("SSDT"
) - 1))
    sizeof(SSDT_SIG) - 1)__builtin_memcmp((entry->q_table), ("SSDT"), (sizeof("SSDT"
) - 1)) == 0) {
	p_dsdt = entry->q_table;
	acpi_parse_aml(sc, p_dsdt->aml, p_dsdt->hdr_lengthhdr.length -
	    sizeof(p_dsdt->hdr));
}
}

/* Perform post-parsing fixups */
aml_postparse();


1127#ifndef SMALL_KERNEL
/* Find available sleeping states */
acpi_init_states(sc);

/* Find available sleep/resume related methods. */
acpi_init_pm(sc);
1133#endif /* SMALL_KERNEL */

/* Initialize GPE handlers */
s = splbio()splraise(0x6);
acpi_init_gpes(sc);
splx(s)spllower(s);

/* some devices require periodic polling */
timeout_set(&sc->sc_dev_timeout, acpi_poll, sc);

acpi_enabled = 1;

/*
* Take over ACPI control.  Note that once we do this, we
* effectively tell the system that we have ownership of
* the ACPI hardware registers, and that SMI should leave
* them alone
*
* This may prevent thermal control on some systems where
* that actually does work
*/
if ((pm1 & ACPI_PM1_SCI_EN0x0001) == 0 && sc->sc_fadt->smi_cmd) {
if (acpi_enable(sc)) {
	printf(", can't enable ACPI\n");
	return;
}
}

printf("\n%s: tables", DEVNAME(sc)((sc)->sc_dev.dv_xname));
SIMPLEQ_FOREACH(entry, &sc->sc_tables, q_next)for((entry) = ((&sc->sc_tables)->sqh_first); (entry
) != ((void *)0); (entry) = ((entry)->q_next.sqe_next)) {
printf(" %.4s", (char *)entry->q_table);
}
printf("\n");

1167#ifndef SMALL_KERNEL
/* Display wakeup devices and lowest S-state */
wakeup_dev_ct = 0;
printf("%s: wakeup devices", DEVNAME(sc)((sc)->sc_dev.dv_xname));
SIMPLEQ_FOREACH(wentry, &sc->sc_wakedevs, q_next)for((wentry) = ((&sc->sc_wakedevs)->sqh_first); (wentry
) != ((void *)0); (wentry) = ((wentry)->q_next.sqe_next)) {
if (wakeup_dev_ct < 16)
	printf(" %.4s(S%d)", wentry->q_node->name,
	    wentry->q_state);
else if (wakeup_dev_ct == 16)
	printf(" [...]");
wakeup_dev_ct++;
}
printf("\n");

/*
* ACPI is enabled now -- attach timer
*/
if (!sc->sc_hw_reduced &&
   (sc->sc_fadt->pm_tmr_blk || sc->sc_fadt->x_pm_tmr_blk.address)) {
struct acpi_attach_args aaa;

memset(&aaa, 0, sizeof(aaa))__builtin_memset((&aaa), (0), (sizeof(aaa)));
aaa.aaa_name = "acpitimer";
aaa.aaa_iot = sc->sc_iot;
aaa.aaa_memt = sc->sc_memt;
config_found(&sc->sc_dev, &aaa, acpi_print)config_found_sm((&sc->sc_dev), (&aaa), (acpi_print
), ((void *)0));
}
1194#endif /* SMALL_KERNEL */

/*
* Attach table-defined devices
*/
SIMPLEQ_FOREACH(entry, &sc->sc_tables, q_next)for((entry) = ((&sc->sc_tables)->sqh_first); (entry
) != ((void *)0); (entry) = ((entry)->q_next.sqe_next)) {
struct acpi_attach_args aaa;

memset(&aaa, 0, sizeof(aaa))__builtin_memset((&aaa), (0), (sizeof(aaa)));
aaa.aaa_iot = sc->sc_iot;
aaa.aaa_memt = sc->sc_memt;
aaa.aaa_dmat = sc->sc_ci_dmat;
aaa.aaa_table = entry->q_table;
config_found_sm(&sc->sc_dev, &aaa, acpi_print, acpi_submatch);
}

/* initialize runtime environment */
aml_find_node(&aml_root, "_INI", acpi_inidev, sc);

/* Get PCI mapping */
aml_walknodes(&aml_root, AML_WALK_PRE0x00, acpi_getpci, sc);

1216#if defined (__amd64__1) || defined(__i386__)
/* attach pci interrupt routing tables */
aml_find_node(&aml_root, "_PRT", acpi_foundprt, sc);
1219#endif

aml_find_node(&aml_root, "_HID", acpi_foundec, sc);

/* check if we're running on a sony */
aml_find_node(&aml_root, "GBRT", acpi_foundsony, sc);

1226#ifndef SMALL_KERNEL
/* try to find smart battery first */
aml_find_node(&aml_root, "_HID", acpi_foundsbs, sc);
1229#endif /* SMALL_KERNEL */

/* attach battery, power supply and button devices */
aml_find_node(&aml_root, "_HID", acpi_foundhid, sc);

aml_walknodes(&aml_root, AML_WALK_PRE0x00, acpi_add_device, sc);

1236#ifndef SMALL_KERNEL
1237#if NWD1 > 0
/* Attach IDE bay */
aml_walknodes(&aml_root, AML_WALK_PRE0x00, acpi_foundide, sc);
1240#endif

/* attach docks */
aml_find_node(&aml_root, "_DCK", acpi_founddock, sc);

/* attach video */
aml_find_node(&aml_root, "_DOS", acpi_foundvideo, sc);

/* create list of devices we want to query when APM comes in */
SLIST_INIT(&sc->sc_ac){ ((&sc->sc_ac)->slh_first) = ((void *)0); };
SLIST_INIT(&sc->sc_bat){ ((&sc->sc_bat)->slh_first) = ((void *)0); };
TAILQ_FOREACH(dev, &alldevs, dv_list)for((dev) = ((&alldevs)->tqh_first); (dev) != ((void *
)0); (dev) = ((dev)->dv_list.tqe_next)) {
if (!strcmp(dev->dv_cfdata->cf_driver->cd_name, "acpiac")) {
	struct acpi_ac *ac;

	ac = malloc(sizeof(*ac), M_DEVBUF2, M_WAITOK0x0001 | M_ZERO0x0008);
	ac->aac_softc = (struct acpiac_softc *)dev;
	SLIST_INSERT_HEAD(&sc->sc_ac, ac, aac_link)do { (ac)->aac_link.sle_next = (&sc->sc_ac)->slh_first
; (&sc->sc_ac)->slh_first = (ac); } while (0);
} else if (!strcmp(dev->dv_cfdata->cf_driver->cd_name, "acpibat")) {
	struct acpi_bat *bat;

	bat = malloc(sizeof(*bat), M_DEVBUF2, M_WAITOK0x0001 | M_ZERO0x0008);
	bat->aba_softc = (struct acpibat_softc *)dev;
	SLIST_INSERT_HEAD(&sc->sc_bat, bat, aba_link)do { (bat)->aba_link.sle_next = (&sc->sc_bat)->slh_first
; (&sc->sc_bat)->slh_first = (bat); } while (0);
} else if (!strcmp(dev->dv_cfdata->cf_driver->cd_name, "acpisbs")) {
	struct acpi_sbs *sbs;

	sbs = malloc(sizeof(*sbs), M_DEVBUF2, M_WAITOK0x0001 | M_ZERO0x0008);
	sbs->asbs_softc = (struct acpisbs_softc *)dev;
	SLIST_INSERT_HEAD(&sc->sc_sbs, sbs, asbs_link)do { (sbs)->asbs_link.sle_next = (&sc->sc_sbs)->
slh_first; (&sc->sc_sbs)->slh_first = (sbs); } while
 (0);
}
}

1273#endif /* SMALL_KERNEL */

/* Setup threads */
sc->sc_thread = malloc(sizeof(struct acpi_thread), M_DEVBUF2, M_WAITOK0x0001);
sc->sc_thread->sc = sc;
sc->sc_thread->running = 1;

/* Enable PCI Power Management. */
pci_dopm = 1;

acpi_attach_machdep(sc);

kthread_create_deferred(acpi_create_thread, sc);
1286}

1288int
1289acpi_submatch(struct device *parent, void *match, void *aux)
1290{
struct acpi_attach_args *aaa = (struct acpi_attach_args *)aux;
struct cfdata *cf = match;

if (aaa->aaa_table == NULL((void *)0))
return (0);
return ((*cf->cf_attach->ca_match)(parent, match, aux));
1297}

1299int
1300acpi_print(void *aux, const char *pnp)
1301{
struct acpi_attach_args *aa = aux;

if (pnp) {
if (aa->aaa_name)
	printf("%s at %s", aa->aaa_name, pnp);
else if (aa->aaa_dev)
	printf("\"%s\" at %s", aa->aaa_dev, pnp);
else
	return (QUIET0);
}

return (UNCONF1);
1314}

1316struct acpi_q *
1317acpi_maptable(struct acpi_softc *sc, paddr_t addr, const char *sig,
  const char *oem, const char *tbl, int flag)
1319{
static int tblid;
struct acpi_mem_map handle;
struct acpi_table_header *hdr;
struct acpi_q *entry;
size_t len;

/* Check if we can map address */
if (addr == 0)
return NULL((void *)0);
if (acpi_map(addr, sizeof(*hdr), &handle))
return NULL((void *)0);
hdr = (struct acpi_table_header *)handle.va;
len = hdr->length;
acpi_unmap(&handle);

/* Validate length/checksum */
if (acpi_map(addr, len, &handle))
return NULL((void *)0);
hdr = (struct acpi_table_header *)handle.va;
if (acpi_checksum(hdr, len))
printf("\n%s: %.4s checksum error",
    DEVNAME(sc)((sc)->sc_dev.dv_xname), hdr->signature);

if ((sig && memcmp(sig, hdr->signature, 4)__builtin_memcmp((sig), (hdr->signature), (4))) ||
   (oem && memcmp(oem, hdr->oemid, 6)__builtin_memcmp((oem), (hdr->oemid), (6))) ||
   (tbl && memcmp(tbl, hdr->oemtableid, 8)__builtin_memcmp((tbl), (hdr->oemtableid), (8)))) {
acpi_unmap(&handle);
return NULL((void *)0);
}

/* Allocate copy */
entry = malloc(sizeof(*entry) + len, M_DEVBUF2, M_NOWAIT0x0002);
if (entry != NULL((void *)0)) {
memcpy(entry->q_data, handle.va, len)__builtin_memcpy((entry->q_data), (handle.va), (len));
entry->q_table = entry->q_data;
entry->q_id = ++tblid;

if (flag < 0)
	SIMPLEQ_INSERT_HEAD(&sc->sc_tables, entry,do { if (((entry)->q_next.sqe_next = (&sc->sc_tables
)->sqh_first) == ((void *)0)) (&sc->sc_tables)->
sqh_last = &(entry)->q_next.sqe_next; (&sc->sc_tables
)->sqh_first = (entry); } while (0)
	    q_next)do { if (((entry)->q_next.sqe_next = (&sc->sc_tables
)->sqh_first) == ((void *)0)) (&sc->sc_tables)->
sqh_last = &(entry)->q_next.sqe_next; (&sc->sc_tables
)->sqh_first = (entry); } while (0);
else if (flag > 0)
	SIMPLEQ_INSERT_TAIL(&sc->sc_tables, entry,do { (entry)->q_next.sqe_next = ((void *)0); *(&sc->
sc_tables)->sqh_last = (entry); (&sc->sc_tables)->
sqh_last = &(entry)->q_next.sqe_next; } while (0)
	    q_next)do { (entry)->q_next.sqe_next = ((void *)0); *(&sc->
sc_tables)->sqh_last = (entry); (&sc->sc_tables)->
sqh_last = &(entry)->q_next.sqe_next; } while (0);
}
acpi_unmap(&handle);
return entry;
1366}

1368int
1369acpi_loadtables(struct acpi_softc *sc, struct acpi_rsdp *rsdp)
1370{
struct acpi_q *sdt;
int i, ntables;
size_t len;

if (rsdp->rsdp_revisionrsdp1.revision == 2 && rsdp->rsdp_xsdt) {
struct acpi_xsdt *xsdt;

sdt = acpi_maptable(sc, rsdp->rsdp_xsdt, NULL((void *)0), NULL((void *)0), NULL((void *)0), 0);
if (sdt == NULL((void *)0)) {
	printf("couldn't map xsdt\n");
	return (ENOMEM12);
}

xsdt = (struct acpi_xsdt *)sdt->q_data;
len  = xsdt->hdr.length;
ntables = (len - sizeof(struct acpi_table_header)) /
    sizeof(xsdt->table_offsets[0]);

for (i = 0; i < ntables; i++)
	acpi_maptable(sc, xsdt->table_offsets[i], NULL((void *)0), NULL((void *)0),
	    NULL((void *)0), 1);

free(sdt, M_DEVBUF2, sizeof(*sdt) + len);
} else {
struct acpi_rsdt *rsdt;

sdt = acpi_maptable(sc, rsdp->rsdp_rsdtrsdp1.rsdt, NULL((void *)0), NULL((void *)0), NULL((void *)0), 0);
if (sdt == NULL((void *)0)) {
	printf("couldn't map rsdt\n");
	return (ENOMEM12);
}

rsdt = (struct acpi_rsdt *)sdt->q_data;
len  = rsdt->hdr.length;
ntables = (len - sizeof(struct acpi_table_header)) /
    sizeof(rsdt->table_offsets[0]);

for (i = 0; i < ntables; i++)
	acpi_maptable(sc, rsdt->table_offsets[i], NULL((void *)0), NULL((void *)0),
	    NULL((void *)0), 1);

free(sdt, M_DEVBUF2, sizeof(*sdt) + len);
}

return (0);
1416}

1418/* Read from power management register */
1419int
1420acpi_read_pmreg(struct acpi_softc *sc, int reg, int offset)
1421{
bus_space_handle_t ioh;
bus_size_t size;
int regval;

/*
* For Hardware-reduced ACPI we emulate PM1B_CNT to reflect
* that the system is always in ACPI mode.
*/
if (sc->sc_hw_reduced && reg == ACPIREG_PM1B_CNT0x05) {
KASSERT(offset == 0)((offset == 0) ? (void)0 : __assert("diagnostic ", "/usr/src/sys/dev/acpi/acpi.c"
, 1431, "offset == 0"));
return ACPI_PM1_SCI_EN0x0001;
}

/*
* For Hardware-reduced ACPI we also emulate PM1A_STS using
* SLEEP_STATUS_REG.
*/
if (sc->sc_hw_reduced && reg == ACPIREG_PM1A_STS0x00 &&
   sc->sc_fadt->sleep_status_reg.register_bit_width > 0) {
uint8_t value;

KASSERT(offset == 0)((offset == 0) ? (void)0 : __assert("diagnostic ", "/usr/src/sys/dev/acpi/acpi.c"
, 1443, "offset == 0"));
acpi_gasio(sc, ACPI_IOREAD0,
    sc->sc_fadt->sleep_status_reg.address_space_id,
    sc->sc_fadt->sleep_status_reg.address,
    sc->sc_fadt->sleep_status_reg.register_bit_width / 8,
    sc->sc_fadt->sleep_status_reg.access_size, &value);
return ((int)value << 8);
}

/* Special cases: 1A/1B blocks can be OR'ed together */
switch (reg) {
case ACPIREG_PM1_EN0x0F:
return (acpi_read_pmreg(sc, ACPIREG_PM1A_EN0x01, offset) |
    acpi_read_pmreg(sc, ACPIREG_PM1B_EN0x04, offset));
case ACPIREG_PM1_STS0x0E:
return (acpi_read_pmreg(sc, ACPIREG_PM1A_STS0x00, offset) |
    acpi_read_pmreg(sc, ACPIREG_PM1B_STS0x03, offset));
case ACPIREG_PM1_CNT0x10:
return (acpi_read_pmreg(sc, ACPIREG_PM1A_CNT0x02, offset) |
    acpi_read_pmreg(sc, ACPIREG_PM1B_CNT0x05, offset));
case ACPIREG_GPE_STS0x11:
dnprintf(50, "read GPE_STS  offset: %.2x %.2x %.2x\n", offset,
    sc->sc_fadt->gpe0_blk_len>>1, sc->sc_fadt->gpe1_blk_len>>1);
if (offset < (sc->sc_fadt->gpe0_blk_len >> 1)) {
	reg = ACPIREG_GPE0_STS0x08;
}
break;
case ACPIREG_GPE_EN0x12:
dnprintf(50, "read GPE_EN   offset: %.2x %.2x %.2x\n",
    offset, sc->sc_fadt->gpe0_blk_len>>1,
    sc->sc_fadt->gpe1_blk_len>>1);
if (offset < (sc->sc_fadt->gpe0_blk_len >> 1)) {
	reg = ACPIREG_GPE0_EN0x09;
}
break;
}

if (reg >= ACPIREG_MAXREG0x0D || sc->sc_pmregs[reg].size == 0)
return (0);

regval = 0;
ioh = sc->sc_pmregs[reg].ioh;
size = sc->sc_pmregs[reg].size;
if (size > sc->sc_pmregs[reg].access)
size = sc->sc_pmregs[reg].access;

switch (size) {
case 1:
regval = bus_space_read_1(sc->sc_iot, ioh, offset)((sc->sc_iot)->read_1((ioh), (offset)));
break;
case 2:
regval = bus_space_read_2(sc->sc_iot, ioh, offset)((sc->sc_iot)->read_2((ioh), (offset)));
break;
case 4:
regval = bus_space_read_4(sc->sc_iot, ioh, offset)((sc->sc_iot)->read_4((ioh), (offset)));
break;
}

dnprintf(30, "acpi_readpm: %s = %.4x:%.4x %x\n",
   sc->sc_pmregs[reg].name,
   sc->sc_pmregs[reg].addr, offset, regval);
return (regval);
1505}

1507/* Write to power management register */
1508void
1509acpi_write_pmreg(struct acpi_softc *sc, int reg, int offset, int regval)
1510{
bus_space_handle_t ioh;
bus_size_t size;

/*
* For Hardware-reduced ACPI we also emulate PM1A_STS using
* SLEEP_STATUS_REG.
*/
if (sc->sc_hw_reduced && reg == ACPIREG_PM1A_STS0x00 &&
   sc->sc_fadt->sleep_status_reg.register_bit_width > 0) {
uint8_t value = (regval >> 8);

KASSERT(offset == 0)((offset == 0) ? (void)0 : __assert("diagnostic ", "/usr/src/sys/dev/acpi/acpi.c"
, 1522, "offset == 0"));
acpi_gasio(sc, ACPI_IOWRITE1,
    sc->sc_fadt->sleep_status_reg.address_space_id,
    sc->sc_fadt->sleep_status_reg.address,
    sc->sc_fadt->sleep_status_reg.register_bit_width / 8,
    sc->sc_fadt->sleep_status_reg.access_size, &value);
return;
}

/*
* For Hardware-reduced ACPI we also emulate PM1A_CNT using
* SLEEP_CONTROL_REG.
*/
if (sc->sc_hw_reduced && reg == ACPIREG_PM1A_CNT0x02 &&
   sc->sc_fadt->sleep_control_reg.register_bit_width > 0) {
uint8_t value = (regval >> 8);

KASSERT(offset == 0)((offset == 0) ? (void)0 : __assert("diagnostic ", "/usr/src/sys/dev/acpi/acpi.c"
, 1539, "offset == 0"));
acpi_gasio(sc, ACPI_IOWRITE1,
    sc->sc_fadt->sleep_control_reg.address_space_id,
    sc->sc_fadt->sleep_control_reg.address,
    sc->sc_fadt->sleep_control_reg.register_bit_width / 8,
    sc->sc_fadt->sleep_control_reg.access_size, &value);
return;
}

/* Special cases: 1A/1B blocks can be written with same value */
switch (reg) {
case ACPIREG_PM1_EN0x0F:
acpi_write_pmreg(sc, ACPIREG_PM1A_EN0x01, offset, regval);
acpi_write_pmreg(sc, ACPIREG_PM1B_EN0x04, offset, regval);
break;
case ACPIREG_PM1_STS0x0E:
acpi_write_pmreg(sc, ACPIREG_PM1A_STS0x00, offset, regval);
acpi_write_pmreg(sc, ACPIREG_PM1B_STS0x03, offset, regval);
break;
case ACPIREG_PM1_CNT0x10:
acpi_write_pmreg(sc, ACPIREG_PM1A_CNT0x02, offset, regval);
acpi_write_pmreg(sc, ACPIREG_PM1B_CNT0x05, offset, regval);
break;
case ACPIREG_GPE_STS0x11:
dnprintf(50, "write GPE_STS offset: %.2x %.2x %.2x %.2x\n",
    offset, sc->sc_fadt->gpe0_blk_len>>1,
    sc->sc_fadt->gpe1_blk_len>>1, regval);
if (offset < (sc->sc_fadt->gpe0_blk_len >> 1)) {
	reg = ACPIREG_GPE0_STS0x08;
}
break;
case ACPIREG_GPE_EN0x12:
dnprintf(50, "write GPE_EN  offset: %.2x %.2x %.2x %.2x\n",
    offset, sc->sc_fadt->gpe0_blk_len>>1,
    sc->sc_fadt->gpe1_blk_len>>1, regval);
if (offset < (sc->sc_fadt->gpe0_blk_len >> 1)) {
	reg = ACPIREG_GPE0_EN0x09;
}
break;
}

/* All special case return here */
if (reg >= ACPIREG_MAXREG0x0D)
return;

ioh = sc->sc_pmregs[reg].ioh;
size = sc->sc_pmregs[reg].size;
if (size > sc->sc_pmregs[reg].access)
size = sc->sc_pmregs[reg].access;

switch (size) {
case 1:
bus_space_write_1(sc->sc_iot, ioh, offset, regval)((sc->sc_iot)->write_1((ioh), (offset), (regval)));
break;
case 2:
bus_space_write_2(sc->sc_iot, ioh, offset, regval)((sc->sc_iot)->write_2((ioh), (offset), (regval)));
break;
case 4:
bus_space_write_4(sc->sc_iot, ioh, offset, regval)((sc->sc_iot)->write_4((ioh), (offset), (regval)));
break;
}

dnprintf(30, "acpi_writepm: %s = %.4x:%.4x %x\n",
   sc->sc_pmregs[reg].name, sc->sc_pmregs[reg].addr, offset, regval);
1603}

1605/* Map Power Management registers */
1606void
1607acpi_map_pmregs(struct acpi_softc *sc)
1608{
struct acpi_fadt *fadt = sc->sc_fadt;
bus_addr_t addr;
15
←
'addr' declared without an initial value→
bus_size_t size, access;
const char *name;
int reg;

for (reg = 0; reg < ACPIREG_MAXREG0x0D; reg++) {
16
←
Loop condition is true.  Entering loop body→
size = 0;
access = 0;
switch (reg) {
17
←
Control jumps to 'case 0:'  at line 1624→
case ACPIREG_SMICMD0x0C:
	name = "smi";
	size = access = 1;
	addr = fadt->smi_cmd;
	break;
case ACPIREG_PM1A_STS0x00:
case ACPIREG_PM1A_EN0x01:
	name = "pm1a_sts";
	size = fadt->pm1_evt_len >> 1;
	if (fadt->pm1a_evt_blk) {
18
←
Assuming field 'pm1a_evt_blk' is 0→
19
←
Taking false branch→
		addr = fadt->pm1a_evt_blk;
		access = 2;
	} else if (fadt->hdr_revisionhdr.revision >= 3) {
20
←
Assuming field 'revision' is < 3→
21
←
Taking false branch→
		addr = fadt->x_pm1a_evt_blk.address;
		access = 1 << fadt->x_pm1a_evt_blk.access_size;
	}
	if (reg21.1
'reg' is not equal to ACPIREG_PM1A_EN
 == ACPIREG_PM1A_EN0x01 && addr) {
		addr += size;
		name = "pm1a_en";
	}
	break;
22
←
 Execution continues on line 1746→
case ACPIREG_PM1A_CNT0x02:
	name = "pm1a_cnt";
	size = fadt->pm1_cnt_len;
	if (fadt->pm1a_cnt_blk) {
		addr = fadt->pm1a_cnt_blk;
		access = 2;
	} else if (fadt->hdr_revisionhdr.revision >= 3) {
		addr = fadt->x_pm1a_cnt_blk.address;
		access = 1 << fadt->x_pm1a_cnt_blk.access_size;
	}
	break;
case ACPIREG_PM1B_STS0x03:
case ACPIREG_PM1B_EN0x04:
	name = "pm1b_sts";
	size = fadt->pm1_evt_len >> 1;
	if (fadt->pm1b_evt_blk) {
		addr = fadt->pm1b_evt_blk;
		access = 2;
	} else if (fadt->hdr_revisionhdr.revision >= 3) {
		addr = fadt->x_pm1b_evt_blk.address;
		access = 1 << fadt->x_pm1b_evt_blk.access_size;
	}
	if (reg == ACPIREG_PM1B_EN0x04 && addr) {
		addr += size;
		name = "pm1b_en";
	}
	break;
case ACPIREG_PM1B_CNT0x05:
	name = "pm1b_cnt";
	size = fadt->pm1_cnt_len;
	if (fadt->pm1b_cnt_blk) {
		addr = fadt->pm1b_cnt_blk;
		access = 2;
	} else if (fadt->hdr_revisionhdr.revision >= 3) {
		addr = fadt->x_pm1b_cnt_blk.address;
		access = 1 << fadt->x_pm1b_cnt_blk.access_size;
	}
	break;
case ACPIREG_PM2_CNT0x06:
	name = "pm2_cnt";
	size = fadt->pm2_cnt_len;
	if (fadt->pm2_cnt_blk) {
		addr = fadt->pm2_cnt_blk;
		access = size;
	} else if (fadt->hdr_revisionhdr.revision >= 3) {
		addr = fadt->x_pm2_cnt_blk.address;
		access = 1 << fadt->x_pm2_cnt_blk.access_size;
	}
	break;
1689#if 0
case ACPIREG_PM_TMR0x07:
	/* Allocated in acpitimer */
	name = "pm_tmr";
	size = fadt->pm_tmr_len;
	if (fadt->pm_tmr_blk) {
		addr = fadt->pm_tmr_blk;
		access = 4;
	} else if (fadt->hdr_revisionhdr.revision >= 3) {
		addr = fadt->x_pm_tmr_blk.address;
		access = 1 << fadt->x_pm_tmr_blk.access_size;
	}
	break;
1702#endif
case ACPIREG_GPE0_STS0x08:
case ACPIREG_GPE0_EN0x09:
	name = "gpe0_sts";
	size = fadt->gpe0_blk_len >> 1;
	if (fadt->gpe0_blk) {
		addr = fadt->gpe0_blk;
		access = 1;
	} else if (fadt->hdr_revisionhdr.revision >= 3) {
		addr = fadt->x_gpe0_blk.address;
		access = 1 << fadt->x_gpe0_blk.access_size;
	}

	dnprintf(20, "gpe0 block len : %x\n",
	    fadt->gpe0_blk_len >> 1);
	dnprintf(20, "gpe0 block addr: %x\n",
	    fadt->gpe0_blk);
	if (reg == ACPIREG_GPE0_EN0x09 && addr) {
		addr += size;
		name = "gpe0_en";
	}
	break;
case ACPIREG_GPE1_STS0x0A:
case ACPIREG_GPE1_EN0x0B:
	name = "gpe1_sts";
	size = fadt->gpe1_blk_len >> 1;
	if (fadt->gpe1_blk) {
		addr = fadt->gpe1_blk;
		access = 1;
	} else if (fadt->hdr_revisionhdr.revision >= 3) {
		addr = fadt->x_gpe1_blk.address;
		access = 1 << fadt->x_gpe1_blk.access_size;
	}

	dnprintf(20, "gpe1 block len : %x\n",
	    fadt->gpe1_blk_len >> 1);
	dnprintf(20, "gpe1 block addr: %x\n",
	    fadt->gpe1_blk);
	if (reg == ACPIREG_GPE1_EN0x0B && addr) {
		addr += size;
		name = "gpe1_en";
	}
	break;
}
if (size && addr) {
23
←
Assuming 'size' is not equal to 0→
24
←
Branch condition evaluates to a garbage value
	dnprintf(50, "mapping: %.4lx %.4lx %s\n",
	    addr, size, name);

	/* Size and address exist; map register space */
	bus_space_map(sc->sc_iot, addr, size, 0,
	    &sc->sc_pmregs[reg].ioh);

	sc->sc_pmregs[reg].name = name;
	sc->sc_pmregs[reg].size = size;
	sc->sc_pmregs[reg].addr = addr;
	sc->sc_pmregs[reg].access = min(access, 4);
}
}
1760}

1762void
1763acpi_unmap_pmregs(struct acpi_softc *sc)
1764{
int reg;

for (reg = 0; reg < ACPIREG_MAXREG0x0D; reg++) {
if (sc->sc_pmregs[reg].size && sc->sc_pmregs[reg].addr)
	bus_space_unmap(sc->sc_iot, sc->sc_pmregs[reg].ioh,
	    sc->sc_pmregs[reg].size);
}
1772}

1774int
1775acpi_enable(struct acpi_softc *sc)
1776{
int idx;

acpi_write_pmreg(sc, ACPIREG_SMICMD0x0C, 0, sc->sc_fadt->acpi_enable);
idx = 0;
do {
if (idx++ > ACPIEN_RETRIES15) {
	return ETIMEDOUT60;
}
} while (!(acpi_read_pmreg(sc, ACPIREG_PM1_CNT0x10, 0) & ACPI_PM1_SCI_EN0x0001));

return 0;
1788}

1790/* ACPI Workqueue support */
1791SIMPLEQ_HEAD(,acpi_taskq)struct { struct acpi_taskq *sqh_first; struct acpi_taskq **sqh_last
; } acpi_taskq =
  SIMPLEQ_HEAD_INITIALIZER(acpi_taskq){ ((void *)0), &(acpi_taskq).sqh_first };

1794void
1795acpi_addtask(struct acpi_softc *sc, void (*handler)(void *, int),
  void *arg0, int arg1)
1797{
struct acpi_taskq *wq;
int s;

wq = malloc(sizeof(*wq), M_DEVBUF2, M_ZERO0x0008 | M_NOWAIT0x0002);
if (wq == NULL((void *)0))
return;
wq->handler = handler;
wq->arg0 = arg0;
wq->arg1 = arg1;

s = splbio()splraise(0x6);
SIMPLEQ_INSERT_TAIL(&acpi_taskq, wq, next)do { (wq)->next.sqe_next = ((void *)0); *(&acpi_taskq)
->sqh_last = (wq); (&acpi_taskq)->sqh_last = &(
wq)->next.sqe_next; } while (0);
splx(s)spllower(s);
1811}

1813int
1814acpi_dotask(struct acpi_softc *sc)
1815{
struct acpi_taskq *wq;
int s;

s = splbio()splraise(0x6);
if (SIMPLEQ_EMPTY(&acpi_taskq)(((&acpi_taskq)->sqh_first) == ((void *)0))) {
splx(s)spllower(s);

/* we don't have anything to do */
return (0);
}
wq = SIMPLEQ_FIRST(&acpi_taskq)((&acpi_taskq)->sqh_first);
SIMPLEQ_REMOVE_HEAD(&acpi_taskq, next)do { if (((&acpi_taskq)->sqh_first = (&acpi_taskq)
->sqh_first->next.sqe_next) == ((void *)0)) (&acpi_taskq
)->sqh_last = &(&acpi_taskq)->sqh_first; } while
 (0);
splx(s)spllower(s);

wq->handler(wq->arg0, wq->arg1);

free(wq, M_DEVBUF2, sizeof(*wq));

/* We did something */
return (1);
1836}

1838#ifndef SMALL_KERNEL

1840int
1841is_ata(struct aml_node *node)
1842{
return (aml_searchname(node, "_GTM") != NULL((void *)0) ||
   aml_searchname(node, "_GTF") != NULL((void *)0) ||
   aml_searchname(node, "_STM") != NULL((void *)0) ||
   aml_searchname(node, "_SDD") != NULL((void *)0));
1847}

1849int
1850is_ejectable(struct aml_node *node)
1851{
return (aml_searchname(node, "_EJ0") != NULL((void *)0));
1853}

1855int
1856is_ejectable_bay(struct aml_node *node)
1857{
return ((is_ata(node) || is_ata(node->parent)) && is_ejectable(node));
1859}

1861#if NWD1 > 0
1862int
1863acpiide_notify(struct aml_node *node, int ntype, void *arg)
1864{
struct idechnl 		*ide = arg;
struct acpi_softc 	*sc = ide->sc;
struct pciide_softc 	*wsc;
struct device 		*dev;
int 			b,d,f;
int64_t 		sta;

if (aml_evalinteger(sc, node, "_STA", 0, NULL((void *)0), &sta) != 0)
return (0);

dnprintf(10, "IDE notify! %s %d status:%llx\n", aml_nodename(node),
   ntype, sta);

/* Walk device list looking for IDE device match */
TAILQ_FOREACH(dev, &alldevs, dv_list)for((dev) = ((&alldevs)->tqh_first); (dev) != ((void *
)0); (dev) = ((dev)->dv_list.tqe_next)) {
if (strcmp(dev->dv_cfdata->cf_driver->cd_name, "pciide"))
	continue;

wsc = (struct pciide_softc *)dev;
pci_decompose_tag(NULL((void *)0), wsc->sc_tag, &b, &d, &f);
if (b != ACPI_PCI_BUS(ide->addr)(uint8_t)((ide->addr) >> 40) ||
    d != ACPI_PCI_DEV(ide->addr)(uint8_t)((ide->addr) >> 32) ||
    f != ACPI_PCI_FN(ide->addr)(uint16_t)((ide->addr) >> 16))
	continue;
dnprintf(10, "Found pciide: %s %x.%x.%x channel:%llx\n",
    dev->dv_xname, b,d,f, ide->chnl);

if (sta == 0 && ide->sta)
	wdcdetach(
	    &wsc->pciide_channels[ide->chnl].wdc_channel, 0);
else if (sta && !ide->sta)
	wdcattach(
	    &wsc->pciide_channels[ide->chnl].wdc_channel);
ide->sta = sta;
}
return (0);
1901}

1903int
1904acpi_foundide(struct aml_node *node, void *arg)
1905{
struct acpi_softc 	*sc = arg;
struct aml_node 	*pp;
struct idechnl 		*ide;
union amlpci_t 		pi;
int 			lvl;

/* Check if this is an ejectable bay */
if (!is_ejectable_bay(node))
return (0);

ide = malloc(sizeof(struct idechnl), M_DEVBUF2, M_NOWAIT0x0002 | M_ZERO0x0008);
ide->sc = sc;

/* GTM/GTF can be at 2/3 levels:  pciX.ideX.channelX[.driveX] */
lvl = 0;
for (pp=node->parent; pp; pp=pp->parent) {
lvl++;
if (aml_searchname(pp, "_HID"))
	break;
}

/* Get PCI address and channel */
if (lvl == 3) {
aml_evalinteger(sc, node->parent, "_ADR", 0, NULL((void *)0),
    &ide->chnl);
aml_rdpciaddr(node->parent->parent, &pi);
ide->addr = pi.addr;
} else if (lvl == 4) {
aml_evalinteger(sc, node->parent->parent, "_ADR", 0, NULL((void *)0),
    &ide->chnl);
aml_rdpciaddr(node->parent->parent->parent, &pi);
ide->addr = pi.addr;
}
dnprintf(10, "%s %llx channel:%llx\n",
   aml_nodename(node), ide->addr, ide->chnl);

aml_evalinteger(sc, node, "_STA", 0, NULL((void *)0), &ide->sta);
dnprintf(10, "Got Initial STA: %llx\n", ide->sta);

aml_register_notify(node, "acpiide", acpiide_notify, ide, 0);
return (0);
1947}
1948#endif /* NWD > 0 */

1950void
1951acpi_sleep_task(void *arg0, int sleepmode)
1952{
struct acpi_softc *sc = arg0;

/* System goes to sleep here.. */
acpi_sleep_state(sc, sleepmode);
/* Tell userland to recheck A/C and battery status */
acpi_record_event(sc, APM_POWER_CHANGE0x0006);
1959}

1961#endif /* SMALL_KERNEL */

1963void
1964acpi_reset(void)
1965{
uint32_t		 reset_as, reset_len;
uint32_t		 value;
struct acpi_softc	*sc = acpi_softc;
struct acpi_fadt	*fadt = sc->sc_fadt;

if (acpi_enabled == 0)
return;

/*
* RESET_REG_SUP is not properly set in some implementations,
* but not testing against it breaks more machines than it fixes
*/
if (fadt->hdr_revisionhdr.revision <= 1 ||
   !(fadt->flags & FADT_RESET_REG_SUP0x00000400) || fadt->reset_reg.address == 0)
return;

value = fadt->reset_value;

reset_as = fadt->reset_reg.register_bit_width / 8;
if (reset_as == 0)
reset_as = 1;

reset_len = fadt->reset_reg.access_size;
if (reset_len == 0)
reset_len = reset_as;

acpi_gasio(sc, ACPI_IOWRITE1,
   fadt->reset_reg.address_space_id,
   fadt->reset_reg.address, reset_as, reset_len, &value);

delay(100000)(*delay_func)(100000);
1997}

1999void
2000acpi_gpe_task(void *arg0, int gpe)
2001{
struct acpi_softc *sc = acpi_softc;
struct gpe_block *pgpe = &sc->gpe_table[gpe];

dnprintf(10, "handle gpe: %x\n", gpe);
if (pgpe->handler && pgpe->active) {
pgpe->active = 0;
pgpe->handler(sc, gpe, pgpe->arg);
}
2010}

2012void
2013acpi_pbtn_task(void *arg0, int dummy)
2014{
struct acpi_softc *sc = arg0;
extern int pwr_action;
uint16_t en;
int s;

dnprintf(1,"power button pressed\n");

/* Reset the latch and re-enable the GPE */
s = splbio()splraise(0x6);
en = acpi_read_pmreg(sc, ACPIREG_PM1_EN0x0F, 0);
acpi_write_pmreg(sc, ACPIREG_PM1_EN0x0F,  0,
   en | ACPI_PM1_PWRBTN_EN0x0100);
splx(s)spllower(s);

switch (pwr_action) {
case 0:
break;
case 1:
acpi_addtask(sc, acpi_powerdown_task, sc, 0);
break;
2035#ifndef SMALL_KERNEL
case 2:
acpi_addtask(sc, acpi_sleep_task, sc, ACPI_SLEEP_SUSPEND0x01);
break;
2039#endif
}
2041}

2043void
2044acpi_sbtn_task(void *arg0, int dummy)
2045{
struct acpi_softc *sc = arg0;
uint16_t en;
int s;

dnprintf(1,"sleep button pressed\n");
aml_notify_dev(ACPI_DEV_SBD"PNP0C0E", 0x80);

/* Reset the latch and re-enable the GPE */
s = splbio()splraise(0x6);
en = acpi_read_pmreg(sc, ACPIREG_PM1_EN0x0F, 0);
acpi_write_pmreg(sc, ACPIREG_PM1_EN0x0F,  0,
   en | ACPI_PM1_SLPBTN_EN0x0200);
splx(s)spllower(s);
2059}

2061void
2062acpi_powerdown_task(void *arg0, int dummy)
2063{
extern int allowpowerdown;

if (allowpowerdown == 1) {
allowpowerdown = 0;
prsignal(initprocess, SIGUSR2)ptsignal((initprocess)->ps_mainproc, (31), SPROCESS);
}
2070}

2072int
2073acpi_interrupt(void *arg)
2074{
struct acpi_softc *sc = (struct acpi_softc *)arg;
uint32_t processed = 0, idx, jdx;
uint16_t sts, en;
int gpe;

dnprintf(40, "ACPI Interrupt\n");
for (idx = 0; idx < sc->sc_lastgpe; idx += 8) {
sts = acpi_read_pmreg(sc, ACPIREG_GPE_STS0x11, idx>>3);
en  = acpi_read_pmreg(sc, ACPIREG_GPE_EN0x12,  idx>>3);
if (en & sts) {
	dnprintf(10, "GPE block: %.2x %.2x %.2x\n", idx, sts,
	    en);
	/* Mask the GPE until it is serviced */
	acpi_write_pmreg(sc, ACPIREG_GPE_EN0x12, idx>>3, en & ~sts);
	for (jdx = 0; jdx < 8; jdx++) {
		if (!(en & sts & (1L << jdx)))
			continue;

		/* Signal this GPE */
		gpe = idx + jdx;
		if (sc->gpe_table[gpe].flags & GPE_DIRECT0x04) {
			dnprintf(10, "directly handle gpe: %x\n",
			    gpe);
			sc->gpe_table[gpe].handler(sc, gpe,
			    sc->gpe_table[gpe].arg);
			if (sc->gpe_table[gpe].flags &
			    GPE_LEVEL0x01)
				acpi_gpe(sc, gpe,
				    sc->gpe_table[gpe].arg);
		} else {
			sc->gpe_table[gpe].active = 1;
			dnprintf(10, "queue gpe: %x\n", gpe);
			acpi_addtask(sc, acpi_gpe_task, NULL((void *)0),
			    gpe);
		}

		/*
		 * Edge interrupts need their STS bits cleared
		 * now.  Level interrupts will have their STS
		 * bits cleared just before they are
		 * re-enabled.
		 */
		if (sc->gpe_table[gpe].flags & GPE_EDGE0x02)
			acpi_write_pmreg(sc,
			    ACPIREG_GPE_STS0x11, idx>>3, 1L << jdx);

		processed = 1;
	}
}
}

sts = acpi_read_pmreg(sc, ACPIREG_PM1_STS0x0E, 0);
en  = acpi_read_pmreg(sc, ACPIREG_PM1_EN0x0F, 0);
if (sts & en) {
dnprintf(10,"GEN interrupt: %.4x\n", sts & en);
sts &= en;
if (sts & ACPI_PM1_PWRBTN_STS0x0100) {
	/* Mask and acknowledge */
	en &= ~ACPI_PM1_PWRBTN_EN0x0100;
	acpi_write_pmreg(sc, ACPIREG_PM1_EN0x0F, 0, en);
	acpi_write_pmreg(sc, ACPIREG_PM1_STS0x0E, 0,
	    ACPI_PM1_PWRBTN_STS0x0100);
	sts &= ~ACPI_PM1_PWRBTN_STS0x0100;

	acpi_addtask(sc, acpi_pbtn_task, sc, 0);
}
if (sts & ACPI_PM1_SLPBTN_STS0x0200) {
	/* Mask and acknowledge */
	en &= ~ACPI_PM1_SLPBTN_EN0x0200;
	acpi_write_pmreg(sc, ACPIREG_PM1_EN0x0F, 0, en);
	acpi_write_pmreg(sc, ACPIREG_PM1_STS0x0E, 0,
	    ACPI_PM1_SLPBTN_STS0x0200);
	sts &= ~ACPI_PM1_SLPBTN_STS0x0200;

	acpi_addtask(sc, acpi_sbtn_task, sc, 0);
}
if (sts) {
	printf("%s: PM1 stuck (en 0x%x st 0x%x), clearing\n",
	    sc->sc_dev.dv_xname, en, sts);
	acpi_write_pmreg(sc, ACPIREG_PM1_EN0x0F, 0, en & ~sts);
	acpi_write_pmreg(sc, ACPIREG_PM1_STS0x0E, 0, sts);
}
processed = 1;
}

if (processed) {
acpi_wakeup(sc);
}

return (processed);
2165}

2167int
2168acpi_add_device(struct aml_node *node, void *arg)
2169{
static int nacpicpus = 0;
struct device *self = arg;
struct acpi_softc *sc = arg;
struct acpi_attach_args aaa;
struct aml_value res;
CPU_INFO_ITERATORint cii;
struct cpu_info *ci;
int proc_id = -1;

memset(&aaa, 0, sizeof(aaa))__builtin_memset((&aaa), (0), (sizeof(aaa)));
aaa.aaa_node = node;
aaa.aaa_iot = sc->sc_iot;
aaa.aaa_memt = sc->sc_memt;
if (node == NULL((void *)0) || node->value == NULL((void *)0))
return 0;

switch (node->value->type) {
case AML_OBJTYPE_PROCESSOR:
if (sc->sc_skip_processor != 0)
	return 0;
if (nacpicpus >= ncpus)
	return 0;
if (aml_evalnode(sc, aaa.aaa_node, 0, NULL((void *)0), &res) == 0) {
	if (res.type == AML_OBJTYPE_PROCESSOR)
		proc_id = res.v_processor_.vprocessor.proc_id;
	aml_freevalue(&res);
}
CPU_INFO_FOREACH(cii, ci)for (cii = 0, ci = cpu_info_list; ci != ((void *)0); ci = ci->
ci_next) {
	if (ci->ci_acpi_proc_id == proc_id)
		break;
}
if (ci == NULL((void *)0))
	return 0;
nacpicpus++;

aaa.aaa_name = "acpicpu";
break;
case AML_OBJTYPE_THERMZONE:
aaa.aaa_name = "acpitz";
break;
case AML_OBJTYPE_POWERRSRC:
aaa.aaa_name = "acpipwrres";
break;
default:
return 0;
}
config_found(self, &aaa, acpi_print)config_found_sm((self), (&aaa), (acpi_print), ((void *)0)
);
return 0;
2218}

2220void
2221acpi_enable_onegpe(struct acpi_softc *sc, int gpe)
2222{
uint8_t mask, en;

/* Read enabled register */
mask = (1L << (gpe & 7));
en = acpi_read_pmreg(sc, ACPIREG_GPE_EN0x12, gpe>>3);
dnprintf(50, "enabling GPE %.2x (current: %sabled) %.2x\n",
   gpe, (en & mask) ? "en" : "dis", en);
acpi_write_pmreg(sc, ACPIREG_GPE_EN0x12, gpe>>3, en | mask);
2231}

2233/* Clear all GPEs */
2234void
2235acpi_disable_allgpes(struct acpi_softc *sc)
2236{
int idx;

for (idx = 0; idx < sc->sc_lastgpe; idx += 8) {
acpi_write_pmreg(sc, ACPIREG_GPE_EN0x12, idx >> 3, 0);
acpi_write_pmreg(sc, ACPIREG_GPE_STS0x11, idx >> 3, -1);
}
2243}

2245/* Enable runtime GPEs */
2246void
2247acpi_enable_rungpes(struct acpi_softc *sc)
2248{
int idx;

for (idx = 0; idx < sc->sc_lastgpe; idx++)
if (sc->gpe_table[idx].handler)
	acpi_enable_onegpe(sc, idx);
2254}

2256/* Enable wakeup GPEs */
2257void
2258acpi_enable_wakegpes(struct acpi_softc *sc, int state)
2259{
struct acpi_wakeq *wentry;

SIMPLEQ_FOREACH(wentry, &sc->sc_wakedevs, q_next)for((wentry) = ((&sc->sc_wakedevs)->sqh_first); (wentry
) != ((void *)0); (wentry) = ((wentry)->q_next.sqe_next)) {
dnprintf(10, "%.4s(S%d) gpe %.2x\n", wentry->q_node->name,
    wentry->q_state,
    wentry->q_gpe);
if (state <= wentry->q_state)
	acpi_enable_onegpe(sc, wentry->q_gpe);
}
2269}

2271int
2272acpi_set_gpehandler(struct acpi_softc *sc, int gpe, int (*handler)
  (struct acpi_softc *, int, void *), void *arg, int flags)
2274{
struct gpe_block *ptbl;

ptbl = acpi_find_gpe(sc, gpe);
if (ptbl == NULL((void *)0) || handler == NULL((void *)0))
return -EINVAL22;
if ((flags & GPE_LEVEL0x01) && (flags & GPE_EDGE0x02))
return -EINVAL22;
if (!(flags & (GPE_LEVEL0x01 | GPE_EDGE0x02)))
return -EINVAL22;
if (ptbl->handler != NULL((void *)0) && !(flags & GPE_DIRECT0x04))
printf("%s: GPE 0x%.2x already enabled\n", DEVNAME(sc)((sc)->sc_dev.dv_xname), gpe);

dnprintf(50, "Adding GPE handler 0x%.2x (%s)\n", gpe,
   (flags & GPE_EDGE ? "edge" : "level"));
ptbl->handler = handler;
ptbl->arg = arg;
ptbl->flags = flags;

return (0);
2294}

2296int
2297acpi_gpe(struct acpi_softc *sc, int gpe, void *arg)
2298{
struct aml_node *node = arg;
uint8_t mask, en;

dnprintf(10, "handling GPE %.2x\n", gpe);
aml_evalnode(sc, node, 0, NULL((void *)0), NULL((void *)0));

mask = (1L << (gpe & 7));
if (sc->gpe_table[gpe].flags & GPE_LEVEL0x01)
acpi_write_pmreg(sc, ACPIREG_GPE_STS0x11, gpe>>3, mask);
en = acpi_read_pmreg(sc, ACPIREG_GPE_EN0x12,  gpe>>3);
acpi_write_pmreg(sc, ACPIREG_GPE_EN0x12,  gpe>>3, en | mask);
return (0);
2311}

2313/* Discover Devices that can wakeup the system
* _PRW returns a package
*  pkg[0] = integer (FADT gpe bit) or package (gpe block,gpe bit)
*  pkg[1] = lowest sleep state
*  pkg[2+] = power resource devices (optional)
*
* To enable wakeup devices:
*    Evaluate _ON method in each power resource device
*    Evaluate _PSW method
*/
2323int
2324acpi_foundprw(struct aml_node *node, void *arg)
2325{
struct acpi_softc *sc = arg;
struct acpi_wakeq *wq;
int64_t sta;

sta = acpi_getsta(sc, node->parent);
if ((sta & STA_PRESENT(1L << 0)) == 0)
return 0;

wq = malloc(sizeof(struct acpi_wakeq), M_DEVBUF2, M_NOWAIT0x0002 | M_ZERO0x0008);
if (wq == NULL((void *)0))
return 0;

wq->q_wakepkg = malloc(sizeof(struct aml_value), M_DEVBUF2,
   M_NOWAIT0x0002 | M_ZERO0x0008);
if (wq->q_wakepkg == NULL((void *)0)) {
free(wq, M_DEVBUF2, sizeof(*wq));
return 0;
}
dnprintf(10, "Found _PRW (%s)\n", node->parent->name);
aml_evalnode(sc, node, 0, NULL((void *)0), wq->q_wakepkg);
wq->q_node = node->parent;
wq->q_gpe = -1;

/* Get GPE of wakeup device, and lowest sleep level */
if (wq->q_wakepkg->type == AML_OBJTYPE_PACKAGE &&
   wq->q_wakepkg->length >= 2) {
if (wq->q_wakepkg->v_package_.vpackage[0]->type == AML_OBJTYPE_INTEGER)
	wq->q_gpe = wq->q_wakepkg->v_package_.vpackage[0]->v_integer_.vinteger;
if (wq->q_wakepkg->v_package_.vpackage[1]->type == AML_OBJTYPE_INTEGER)
	wq->q_state = wq->q_wakepkg->v_package_.vpackage[1]->v_integer_.vinteger;
}
SIMPLEQ_INSERT_TAIL(&sc->sc_wakedevs, wq, q_next)do { (wq)->q_next.sqe_next = ((void *)0); *(&sc->sc_wakedevs
)->sqh_last = (wq); (&sc->sc_wakedevs)->sqh_last
 = &(wq)->q_next.sqe_next; } while (0);
return 0;
2359}

2361struct gpe_block *
2362acpi_find_gpe(struct acpi_softc *sc, int gpe)
2363{
if (gpe >= sc->sc_lastgpe)
return NULL((void *)0);
return &sc->gpe_table[gpe];
2367}

2369void
2370acpi_init_gpes(struct acpi_softc *sc)
2371{
struct aml_node *gpe;
char name[12];
int  idx;

sc->sc_lastgpe = sc->sc_fadt->gpe0_blk_len << 2;
dnprintf(50, "Last GPE: %.2x\n", sc->sc_lastgpe);

/* Allocate GPE table */
sc->gpe_table = mallocarray(sc->sc_lastgpe, sizeof(struct gpe_block),
   M_DEVBUF2, M_WAITOK0x0001 | M_ZERO0x0008);

/* Clear GPE status */
acpi_disable_allgpes(sc);
for (idx = 0; idx < sc->sc_lastgpe; idx++) {
/* Search Level-sensitive GPES */
snprintf(name, sizeof(name), "\\_GPE._L%.2X", idx);
gpe = aml_searchname(&aml_root, name);
if (gpe != NULL((void *)0))
	acpi_set_gpehandler(sc, idx, acpi_gpe, gpe, GPE_LEVEL0x01);
if (gpe == NULL((void *)0)) {
	/* Search Edge-sensitive GPES */
	snprintf(name, sizeof(name), "\\_GPE._E%.2X", idx);
	gpe = aml_searchname(&aml_root, name);
	if (gpe != NULL((void *)0))
		acpi_set_gpehandler(sc, idx, acpi_gpe, gpe,
		    GPE_EDGE0x02);
}
}
aml_find_node(&aml_root, "_PRW", acpi_foundprw, sc);
2401}

2403void
2404acpi_init_pm(struct acpi_softc *sc)
2405{
sc->sc_tts = aml_searchname(&aml_root, "_TTS");
sc->sc_pts = aml_searchname(&aml_root, "_PTS");
sc->sc_wak = aml_searchname(&aml_root, "_WAK");
sc->sc_bfs = aml_searchname(&aml_root, "_BFS");
sc->sc_gts = aml_searchname(&aml_root, "_GTS");
sc->sc_sst = aml_searchname(&aml_root, "_SI_._SST");
2412}

2414#ifndef SMALL_KERNEL

2416void
2417acpi_init_states(struct acpi_softc *sc)
2418{
struct aml_value res;
char name[8];
int i;

printf("\n%s: sleep states", DEVNAME(sc)((sc)->sc_dev.dv_xname));
for (i = ACPI_STATE_S00; i <= ACPI_STATE_S55; i++) {
snprintf(name, sizeof(name), "_S%d_", i);
sc->sc_sleeptype[i].slp_typa = -1;
sc->sc_sleeptype[i].slp_typb = -1;
if (aml_evalname(sc, &aml_root, name, 0, NULL((void *)0), &res) == 0) {
	if (res.type == AML_OBJTYPE_PACKAGE) {
		sc->sc_sleeptype[i].slp_typa =
		    aml_val2int(res.v_package_.vpackage[0]);
		sc->sc_sleeptype[i].slp_typb =
		    aml_val2int(res.v_package_.vpackage[1]);
		printf(" S%d", i);
	}
	aml_freevalue(&res);
}
}
2439}

2441void
2442acpi_sleep_pm(struct acpi_softc *sc, int state)
2443{
uint16_t rega, regb, regra, regrb;
int retry = 0;

intr_disable();

/* Clear WAK_STS bit */
acpi_write_pmreg(sc, ACPIREG_PM1_STS0x0E, 0, ACPI_PM1_WAK_STS0x8000);

/* Disable BM arbitration at deep sleep and beyond */
if (state >= ACPI_STATE_S33 &&
   sc->sc_fadt->pm2_cnt_blk && sc->sc_fadt->pm2_cnt_len)
acpi_write_pmreg(sc, ACPIREG_PM2_CNT0x06, 0, ACPI_PM2_ARB_DIS0x0001);

/* Write SLP_TYPx values */
rega = acpi_read_pmreg(sc, ACPIREG_PM1A_CNT0x02, 0);
regb = acpi_read_pmreg(sc, ACPIREG_PM1B_CNT0x05, 0);
rega &= ~(ACPI_PM1_SLP_TYPX_MASK0x1c00 | ACPI_PM1_SLP_EN0x2000);
regb &= ~(ACPI_PM1_SLP_TYPX_MASK0x1c00 | ACPI_PM1_SLP_EN0x2000);
rega |= ACPI_PM1_SLP_TYPX(sc->sc_sleeptype[state].slp_typa)((sc->sc_sleeptype[state].slp_typa) << 10);
regb |= ACPI_PM1_SLP_TYPX(sc->sc_sleeptype[state].slp_typb)((sc->sc_sleeptype[state].slp_typb) << 10);
acpi_write_pmreg(sc, ACPIREG_PM1A_CNT0x02, 0, rega);
acpi_write_pmreg(sc, ACPIREG_PM1B_CNT0x05, 0, regb);

/* Loop on WAK_STS, setting the SLP_EN bits once in a while */
rega |= ACPI_PM1_SLP_EN0x2000;
regb |= ACPI_PM1_SLP_EN0x2000;
while (1) {
if (retry == 0) {
	acpi_write_pmreg(sc, ACPIREG_PM1A_CNT0x02, 0, rega);
	acpi_write_pmreg(sc, ACPIREG_PM1B_CNT0x05, 0, regb);
}
retry = (retry + 1) % 100000;

regra = acpi_read_pmreg(sc, ACPIREG_PM1A_STS0x00, 0);
regrb = acpi_read_pmreg(sc, ACPIREG_PM1B_STS0x03, 0);
if ((regra & ACPI_PM1_WAK_STS0x8000) ||
    (regrb & ACPI_PM1_WAK_STS0x8000))
	break;
}
2483}

2485uint32_t acpi_force_bm;

2487void
2488acpi_resume_pm(struct acpi_softc *sc, int fromstate)
2489{
uint16_t rega, regb, en;

/* Write SLP_TYPx values */
rega = acpi_read_pmreg(sc, ACPIREG_PM1A_CNT0x02, 0);
regb = acpi_read_pmreg(sc, ACPIREG_PM1B_CNT0x05, 0);
rega &= ~(ACPI_PM1_SLP_TYPX_MASK0x1c00 | ACPI_PM1_SLP_EN0x2000);
regb &= ~(ACPI_PM1_SLP_TYPX_MASK0x1c00 | ACPI_PM1_SLP_EN0x2000);
rega |= ACPI_PM1_SLP_TYPX(sc->sc_sleeptype[ACPI_STATE_S0].slp_typa)((sc->sc_sleeptype[0].slp_typa) << 10);
regb |= ACPI_PM1_SLP_TYPX(sc->sc_sleeptype[ACPI_STATE_S0].slp_typb)((sc->sc_sleeptype[0].slp_typb) << 10);
acpi_write_pmreg(sc, ACPIREG_PM1A_CNT0x02, 0, rega);
acpi_write_pmreg(sc, ACPIREG_PM1B_CNT0x05, 0, regb);

/* Force SCI_EN on resume to fix horribly broken machines */
acpi_write_pmreg(sc, ACPIREG_PM1_CNT0x10, 0,
   ACPI_PM1_SCI_EN0x0001 | acpi_force_bm);

/* Clear fixed event status */
acpi_write_pmreg(sc, ACPIREG_PM1_STS0x0E, 0, ACPI_PM1_ALL_STS(0x0001 | 0x0010 | 0x0020 | 0x0100 | 0x0200 | 0x0400 | 0x4000
 | 0x8000 ));

/* acpica-reference.pdf page 148 says do not call _BFS */
/* 1st resume AML step: _BFS(fromstate) */
aml_node_setval(sc, sc->sc_bfs, fromstate);

/* Enable runtime GPEs */
acpi_disable_allgpes(sc);
acpi_enable_rungpes(sc);

acpi_indicator(sc, ACPI_SST_WAKING2);

/* 2nd resume AML step: _WAK(fromstate) */
aml_node_setval(sc, sc->sc_wak, fromstate);

/* Clear WAK_STS bit */
acpi_write_pmreg(sc, ACPIREG_PM1_STS0x0E, 0, ACPI_PM1_WAK_STS0x8000);

en = acpi_read_pmreg(sc, ACPIREG_PM1_EN0x0F, 0);
if (!(sc->sc_fadt->flags & FADT_PWR_BUTTON0x00000010))
en |= ACPI_PM1_PWRBTN_EN0x0100;
if (!(sc->sc_fadt->flags & FADT_SLP_BUTTON0x00000020))
en |= ACPI_PM1_SLPBTN_EN0x0200;
acpi_write_pmreg(sc, ACPIREG_PM1_EN0x0F, 0, en);

/*
* If PM2 exists, re-enable BM arbitration (reportedly some
* BIOS forget to)
*/
if (sc->sc_fadt->pm2_cnt_blk && sc->sc_fadt->pm2_cnt_len) {
rega = acpi_read_pmreg(sc, ACPIREG_PM2_CNT0x06, 0);
rega &= ~ACPI_PM2_ARB_DIS0x0001;
acpi_write_pmreg(sc, ACPIREG_PM2_CNT0x06, 0, rega);
}
2541}

2543/* Set the indicator light to some state */
2544void
2545acpi_indicator(struct acpi_softc *sc, int led_state)
2546{
static int save_led_state = -1;

if (save_led_state != led_state) {
aml_node_setval(sc, sc->sc_sst, led_state);
save_led_state = led_state;
}
2553}


2556int
2557acpi_sleep_state(struct acpi_softc *sc, int sleepmode)
2558{
extern int perflevel;
extern int lid_action;
int error = ENXIO6;
size_t rndbuflen = 0;
char *rndbuf = NULL((void *)0);
int state, s;
2565#if NSOFTRAID1 > 0
extern void sr_quiesce(void);
2567#endif

switch (sleepmode) {
case ACPI_SLEEP_SUSPEND0x01:
state = ACPI_STATE_S33;
break;
case ACPI_SLEEP_HIBERNATE0x02:
state = ACPI_STATE_S44;
break;
default:
return (EOPNOTSUPP45);
}

if (sc->sc_sleeptype[state].slp_typa == -1 ||
   sc->sc_sleeptype[state].slp_typb == -1) {
printf("%s: state S%d unavailable\n",
    sc->sc_dev.dv_xname, state);
return (EOPNOTSUPP45);
}

/* 1st suspend AML step: _TTS(tostate) */
if (aml_node_setval(sc, sc->sc_tts, state) != 0)
goto fail_tts;
acpi_indicator(sc, ACPI_SST_WAKING2);	/* blink */

2592#if NWSDISPLAY1 > 0
/*
* Temporarily release the lock to prevent the X server from
* blocking on setting the display brightness.
*/
rw_exit_write(&sc->sc_lck);
wsdisplay_suspend();
rw_enter_write(&sc->sc_lck);
2600#endif /* NWSDISPLAY > 0 */

stop_periodic_resettodr();

2604#ifdef HIBERNATE1
if (sleepmode == ACPI_SLEEP_HIBERNATE0x02) {
/*
 * Discard useless memory to reduce fragmentation,
 * and attempt to create a hibernate work area
 */
hibernate_suspend_bufcache();
uvmpd_hibernate();
if (hibernate_alloc()) {
	printf("%s: failed to allocate hibernate memory\n",
	    sc->sc_dev.dv_xname);
	goto fail_alloc;
}
}
2618#endif /* HIBERNATE */

sensor_quiesce();
if (config_suspend_all(DVACT_QUIESCE2))
goto fail_quiesce;

vfs_stall(curproc({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r"
 (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self)));
 __ci;})->ci_curproc, 1);
2625#if NSOFTRAID1 > 0
sr_quiesce();
2627#endif
bufq_quiesce();

2630#ifdef MULTIPROCESSOR1
acpi_sleep_mp();
2632#endif

2634#ifdef HIBERNATE1
if (sleepmode == ACPI_SLEEP_HIBERNATE0x02) {
/*
 * We've just done various forms of syncing to disk
 * churned lots of memory dirty.  We don't need to
 * save that dirty memory to hibernate, so release it.
 */
hibernate_suspend_bufcache();
uvmpd_hibernate();
}
2644#endif /* HIBERNATE */

resettodr();

s = splhigh()splraise(0xd);
intr_disable();	/* PSL_I for resume; PIC/APIC broken until repair */
cold = 2;	/* Force other code to delay() instead of tsleep() */

if (config_suspend_all(DVACT_SUSPEND3) != 0)
goto fail_suspend;
acpi_sleep_clocks(sc, state);

suspend_randomness();

/* 2nd suspend AML step: _PTS(tostate) */
if (aml_node_setval(sc, sc->sc_pts, state) != 0)
goto fail_pts;

acpibtn_enable_psw();	/* enable _LID for wakeup */
acpi_indicator(sc, ACPI_SST_SLEEPING3);

/* 3rd suspend AML step: _GTS(tostate) */
aml_node_setval(sc, sc->sc_gts, state);

/* Clear fixed event status */
acpi_write_pmreg(sc, ACPIREG_PM1_STS0x0E, 0, ACPI_PM1_ALL_STS(0x0001 | 0x0010 | 0x0020 | 0x0100 | 0x0200 | 0x0400 | 0x4000
 | 0x8000 ));

/* Enable wake GPEs */
acpi_disable_allgpes(sc);
acpi_enable_wakegpes(sc, state);

/* Sleep */
sc->sc_state = state;
error = acpi_sleep_cpu(sc, state);
sc->sc_state = ACPI_STATE_S00;
/* Resume */

2681#ifdef HIBERNATE1
if (sleepmode == ACPI_SLEEP_HIBERNATE0x02) {
uvm_pmr_dirty_everything();
hib_getentropy(&rndbuf, &rndbuflen);
}
2686#endif /* HIBERNATE */

acpi_resume_cpu(sc, state);

2690fail_pts:
config_suspend_all(DVACT_RESUME4);

2693fail_suspend:
cold = 0;
intr_enable();
splx(s)spllower(s);

acpibtn_disable_psw();		/* disable _LID for wakeup */

inittodr(gettime());

/* 3rd resume AML step: _TTS(runstate) */
aml_node_setval(sc, sc->sc_tts, sc->sc_state);

/* force RNG upper level reseed */
resume_randomness(rndbuf, rndbuflen);

2708#ifdef MULTIPROCESSOR1
acpi_resume_mp();
2710#endif

vfs_stall(curproc({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r"
 (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self)));
 __ci;})->ci_curproc, 0);
bufq_restart();

2715fail_quiesce:
config_suspend_all(DVACT_WAKEUP5);
sensor_restart();

2719#ifdef HIBERNATE1
if (sleepmode == ACPI_SLEEP_HIBERNATE0x02) {
hibernate_free();
2722fail_alloc:
hibernate_resume_bufcache();
}
2725#endif /* HIBERNATE */

start_periodic_resettodr();

2729#if NWSDISPLAY1 > 0
rw_exit_write(&sc->sc_lck);
wsdisplay_resume();
rw_enter_write(&sc->sc_lck);
2733#endif /* NWSDISPLAY > 0 */

sys_sync(curproc({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r"
 (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self)));
 __ci;})->ci_curproc, NULL((void *)0), NULL((void *)0));

/* Restore hw.setperf */
if (cpu_setperf != NULL((void *)0))
cpu_setperf(perflevel);

acpi_record_event(sc, APM_NORMAL_RESUME0x0003);
acpi_indicator(sc, ACPI_SST_WORKING1);

/* If we woke up but all the lids are closed, go back to sleep */
if (acpibtn_numopenlids() == 0 && lid_action != 0)
acpi_addtask(sc, acpi_sleep_task, sc, sleepmode);

2748fail_tts:
return (error);
2750}

2752/* XXX
* We are going to do AML execution but are not in the acpi thread.
* We do not know if the acpi thread is sleeping on acpiec in some
* intermediate context.  Wish us luck.
*/
2757void
2758acpi_powerdown(void)
2759{
int state = ACPI_STATE_S55, s;
struct acpi_softc *sc = acpi_softc;

if (acpi_enabled == 0)
return;

s = splhigh()splraise(0xd);
intr_disable();
cold = 1;

/* 1st powerdown AML step: _PTS(tostate) */
aml_node_setval(sc, sc->sc_pts, state);

acpi_disable_allgpes(sc);
acpi_enable_wakegpes(sc, state);

/* 2nd powerdown AML step: _GTS(tostate) */
aml_node_setval(sc, sc->sc_gts, state);

acpi_sleep_pm(sc, state);
panic("acpi S5 transition did not happen");
while (1)
;
2783}

2785#endif /* SMALL_KERNEL */

2787int
2788acpi_map_address(struct acpi_softc *sc, struct acpi_gas *gas, bus_addr_t base,
  bus_size_t size, bus_space_handle_t *pioh, bus_space_tag_t *piot)
2790{
int iospace = GAS_SYSTEM_IOSPACE1;

/* No GAS structure, default to I/O space */
if (gas != NULL((void *)0)) {
base += gas->address;
iospace = gas->address_space_id;
}
switch (iospace) {
case GAS_SYSTEM_MEMORY0:
*piot = sc->sc_memt;
break;
case GAS_SYSTEM_IOSPACE1:
*piot = sc->sc_iot;
break;
default:
return -1;
}
if (bus_space_map(*piot, base, size, 0, pioh))
return -1;

return 0;
2812}

2814void
2815acpi_wakeup(void *arg)
2816{
struct acpi_softc  *sc = (struct acpi_softc *)arg;

sc->sc_threadwaiting = 0;
wakeup(sc);
2821}


2824void
2825acpi_thread(void *arg)
2826{
struct acpi_thread *thread = arg;
struct acpi_softc  *sc = thread->sc;
extern int aml_busy;
int s;

/* AML/SMI cannot be trusted -- only run on the BSP */
sched_peg_curproc(&cpu_info_primary(*(struct cpu_info *)((char *)&cpu_info_full_primary + 4096
*2 - __builtin_offsetof(struct cpu_info, ci_dev))));

rw_enter_write(&sc->sc_lck);

/*
* If we have an interrupt handler, we can get notification
* when certain status bits changes in the ACPI registers,
* so let us enable some events we can forward to userland
*/
if (sc->sc_interrupt) {
int16_t en;

dnprintf(1,"slpbtn:%c  pwrbtn:%c\n",
    sc->sc_fadt->flags & FADT_SLP_BUTTON ? 'n' : 'y',
    sc->sc_fadt->flags & FADT_PWR_BUTTON ? 'n' : 'y');
dnprintf(10, "Enabling acpi interrupts...\n");
sc->sc_threadwaiting = 1;

/* Enable Sleep/Power buttons if they exist */
s = splbio()splraise(0x6);
en = acpi_read_pmreg(sc, ACPIREG_PM1_EN0x0F, 0);
if (!(sc->sc_fadt->flags & FADT_PWR_BUTTON0x00000010))
	en |= ACPI_PM1_PWRBTN_EN0x0100;
if (!(sc->sc_fadt->flags & FADT_SLP_BUTTON0x00000020))
	en |= ACPI_PM1_SLPBTN_EN0x0200;
acpi_write_pmreg(sc, ACPIREG_PM1_EN0x0F, 0, en);

/* Enable handled GPEs here */
acpi_enable_rungpes(sc);
splx(s)spllower(s);
}

while (thread->running) {
s = splbio()splraise(0x6);
while (sc->sc_threadwaiting) {
	dnprintf(10, "acpi thread going to sleep...\n");
	rw_exit_write(&sc->sc_lck);
	tsleep_nsec(sc, PWAIT32, "acpi0", INFSLP0xffffffffffffffffULL);
	rw_enter_write(&sc->sc_lck);
}
sc->sc_threadwaiting = 1;
splx(s)spllower(s);
if (aml_busy) {
	panic("thread woke up to find aml was busy");
	continue;
}

/* Run ACPI taskqueue */
while(acpi_dotask(acpi_softc))
	;
}
free(thread, M_DEVBUF2, sizeof(*thread));

kthread_exit(0);
2887}

2889void
2890acpi_create_thread(void *arg)
2891{
struct acpi_softc *sc = arg;

if (kthread_create(acpi_thread, sc->sc_thread, NULL((void *)0), DEVNAME(sc)((sc)->sc_dev.dv_xname))
   != 0)
printf("%s: unable to create isr thread, GPEs disabled\n",
    DEVNAME(sc)((sc)->sc_dev.dv_xname));
2898}

2900int
2901acpi_foundec(struct aml_node *node, void *arg)
2902{
struct acpi_softc	*sc = (struct acpi_softc *)arg;
struct device		*self = (struct device *)arg;
const char		*dev;
struct aml_value	 res;
struct acpi_attach_args	aaa;

if (aml_evalnode(sc, node, 0, NULL((void *)0), &res) != 0)
return 0;

switch (res.type) {
case AML_OBJTYPE_STRING:
dev = res.v_string_.vstring;
break;
case AML_OBJTYPE_INTEGER:
dev = aml_eisaid(aml_val2int(&res));
break;
default:
dev = "unknown";
break;
}

if (strcmp(dev, ACPI_DEV_ECD"PNP0C09"))
return 0;

/* Check if we're already attached */
if (sc->sc_ec && sc->sc_ec->sc_devnode == node->parent)
return 0;

memset(&aaa, 0, sizeof(aaa))__builtin_memset((&aaa), (0), (sizeof(aaa)));
aaa.aaa_iot = sc->sc_iot;
aaa.aaa_memt = sc->sc_memt;
aaa.aaa_node = node->parent;
aaa.aaa_dev = dev;
aaa.aaa_name = "acpiec";
config_found(self, &aaa, acpi_print)config_found_sm((self), (&aaa), (acpi_print), ((void *)0)
);
aml_freevalue(&res);

return 0;
2941}

2943int
2944acpi_foundsony(struct aml_node *node, void *arg)
2945{
struct acpi_softc *sc = (struct acpi_softc *)arg;
struct device *self = (struct device *)arg;
struct acpi_attach_args aaa;

memset(&aaa, 0, sizeof(aaa))__builtin_memset((&aaa), (0), (sizeof(aaa)));
aaa.aaa_iot = sc->sc_iot;
aaa.aaa_memt = sc->sc_memt;
aaa.aaa_node = node->parent;
aaa.aaa_name = "acpisony";

config_found(self, &aaa, acpi_print)config_found_sm((self), (&aaa), (acpi_print), ((void *)0)
);

return 0;
2959}

2961/* Support for _DSD Device Properties. */

2963int
2964acpi_getprop(struct aml_node *node, const char *prop, void *buf, int buflen)
2965{
struct aml_value dsd;
int i;

/* daffd814-6eba-4d8c-8a91-bc9bbf4aa301 */
static uint8_t prop_guid[] = {
0x14, 0xd8, 0xff, 0xda, 0xba, 0x6e, 0x8c, 0x4d,
0x8a, 0x91, 0xbc, 0x9b, 0xbf, 0x4a, 0xa3, 0x01,
};

if (aml_evalname(acpi_softc, node, "_DSD", 0, NULL((void *)0), &dsd))
return -1;

if (dsd.type != AML_OBJTYPE_PACKAGE || dsd.length != 2 ||
   dsd.v_package_.vpackage[0]->type != AML_OBJTYPE_BUFFER ||
   dsd.v_package_.vpackage[1]->type != AML_OBJTYPE_PACKAGE)
return -1;

/* Check UUID. */
if (dsd.v_package_.vpackage[0]->length != sizeof(prop_guid) ||
   memcmp(dsd.v_package[0]->v_buffer, prop_guid,__builtin_memcmp((dsd._.vpackage[0]->_.vbuffer), (prop_guid
), (sizeof(prop_guid)))
   sizeof(prop_guid))__builtin_memcmp((dsd._.vpackage[0]->_.vbuffer), (prop_guid
), (sizeof(prop_guid))) != 0)
return -1;

/* Check properties. */
for (i = 0; i < dsd.v_package_.vpackage[1]->length; i++) {
struct aml_value *res = dsd.v_package_.vpackage[1]->v_package_.vpackage[i];
struct aml_value *val;
int len;

if (res->type != AML_OBJTYPE_PACKAGE || res->length != 2 ||
    res->v_package_.vpackage[0]->type != AML_OBJTYPE_STRING ||
    strcmp(res->v_package_.vpackage[0]->v_string_.vstring, prop) != 0)
	continue;

val = res->v_package_.vpackage[1];
if (val->type == AML_OBJTYPE_OBJREF)
	val = val->v_objref_.vobjref.ref;

len = val->length;
switch (val->type) {
case AML_OBJTYPE_BUFFER:
	memcpy(buf, val->v_buffer, min(len, buflen))__builtin_memcpy((buf), (val->_.vbuffer), (min(len, buflen
)));
	return len;
case AML_OBJTYPE_STRING:
	memcpy(buf, val->v_string, min(len, buflen))__builtin_memcpy((buf), (val->_.vstring), (min(len, buflen
)));
	return len;
}
}

return -1;
3016}

3018uint32_t
3019acpi_getpropint(struct aml_node *node, const char *prop, uint32_t defval)
3020{
struct aml_value dsd;
int i;

/* daffd814-6eba-4d8c-8a91-bc9bbf4aa301 */
static uint8_t prop_guid[] = {
0x14, 0xd8, 0xff, 0xda, 0xba, 0x6e, 0x8c, 0x4d,
0x8a, 0x91, 0xbc, 0x9b, 0xbf, 0x4a, 0xa3, 0x01,
};

if (aml_evalname(acpi_softc, node, "_DSD", 0, NULL((void *)0), &dsd))
return defval;

if (dsd.type != AML_OBJTYPE_PACKAGE || dsd.length != 2 ||
   dsd.v_package_.vpackage[0]->type != AML_OBJTYPE_BUFFER ||
   dsd.v_package_.vpackage[1]->type != AML_OBJTYPE_PACKAGE)
return defval;

/* Check UUID. */
if (dsd.v_package_.vpackage[0]->length != sizeof(prop_guid) ||
   memcmp(dsd.v_package[0]->v_buffer, prop_guid,__builtin_memcmp((dsd._.vpackage[0]->_.vbuffer), (prop_guid
), (sizeof(prop_guid)))
   sizeof(prop_guid))__builtin_memcmp((dsd._.vpackage[0]->_.vbuffer), (prop_guid
), (sizeof(prop_guid))) != 0)
return defval;

/* Check properties. */
for (i = 0; i < dsd.v_package_.vpackage[1]->length; i++) {
struct aml_value *res = dsd.v_package_.vpackage[1]->v_package_.vpackage[i];
struct aml_value *val;

if (res->type != AML_OBJTYPE_PACKAGE || res->length != 2 ||
    res->v_package_.vpackage[0]->type != AML_OBJTYPE_STRING ||
    strcmp(res->v_package_.vpackage[0]->v_string_.vstring, prop) != 0)
	continue;

val = res->v_package_.vpackage[1];
if (val->type == AML_OBJTYPE_OBJREF)
	val = val->v_objref_.vobjref.ref;

if (val->type == AML_OBJTYPE_INTEGER)
	return val->v_integer_.vinteger;
}

return defval;
3063}

3065int
3066acpi_parsehid(struct aml_node *node, void *arg, char *outcdev, char *outdev,
  size_t devlen)
3068{
struct acpi_softc	*sc = (struct acpi_softc *)arg;
struct aml_value	 res;
const char		*dev;

/* NB aml_eisaid returns a static buffer, this must come first */
if (aml_evalname(acpi_softc, node->parent, "_CID", 0, NULL((void *)0), &res) == 0) {
switch (res.type) {
case AML_OBJTYPE_STRING:
	dev = res.v_string_.vstring;
	break;
case AML_OBJTYPE_INTEGER:
	dev = aml_eisaid(aml_val2int(&res));
	break;
default:
	dev = "unknown";
	break;
}
strlcpy(outcdev, dev, devlen);
aml_freevalue(&res);

dnprintf(10, "compatible with device: %s\n", outcdev);
} else {
outcdev[0] = '\0';
}

dnprintf(10, "found hid device: %s ", node->parent->name);
if (aml_evalnode(sc, node, 0, NULL((void *)0), &res) != 0)
return (1);

switch (res.type) {
case AML_OBJTYPE_STRING:
dev = res.v_string_.vstring;
break;
case AML_OBJTYPE_INTEGER:
dev = aml_eisaid(aml_val2int(&res));
break;
default:
dev = "unknown";
break;
}
dnprintf(10, "	device: %s\n", dev);

strlcpy(outdev, dev, devlen);

aml_freevalue(&res);

return (0);
3116}

3118/* Devices for which we don't want to attach a driver */
3119const char *acpi_skip_hids[] = {
"INT0800",	/* Intel 82802Firmware Hub Device */
"PNP0000",	/* 8259-compatible Programmable Interrupt Controller */
"PNP0001",	/* EISA Interrupt Controller */
"PNP0100",	/* PC-class System Timer */
"PNP0103",	/* HPET System Timer */
"PNP0200",	/* PC-class DMA Controller */
"PNP0201",	/* EISA DMA Controller */
"PNP0800",	/* Microsoft Sound System Compatible Device */
"PNP0C01",	/* System Board */
"PNP0C02",	/* PNP Motherboard Resources */
"PNP0C04",	/* x87-compatible Floating Point Processing Unit */
"PNP0C09",	/* Embedded Controller Device */
"PNP0C0F",	/* PCI Interrupt Link Device */
NULL((void *)0)
3134};

3136/* ISA devices for which we attach a driver later */
3137const char *acpi_isa_hids[] = {
"PNP0303",	/* IBM Enhanced Keyboard (101/102-key, PS/2 Mouse) */
"PNP0400",	/* Standard LPT Parallel Port */
"PNP0401",	/* ECP Parallel Port */
"PNP0700",	/* PC-class Floppy Disk Controller */
"PNP0F03",	/* Microsoft PS/2-style Mouse */
"PNP0F13",	/* PS/2 Mouse */
NULL((void *)0)
3145};

3147void
3148acpi_attach_deps(struct acpi_softc *sc, struct aml_node *node)
3149{
struct aml_value res, *val;
struct aml_node *dep;
int i;

if (aml_evalname(sc, node, "_DEP", 0, NULL((void *)0), &res))
return;

if (res.type != AML_OBJTYPE_PACKAGE)
return;

for (i = 0; i < res.length; i++) {
val = res.v_package_.vpackage[i];
if (val->type == AML_OBJTYPE_OBJREF)
	val = val->v_objref_.vobjref.ref;
if (val->type != AML_OBJTYPE_DEVICE)
	continue;
dep = val->node;
if (dep == NULL((void *)0) || dep->attached)
	continue;
dep = aml_searchname(dep, "_HID");
if (dep)
	acpi_foundhid(dep, sc);
}

aml_freevalue(&res);
3175}

3177int
3178acpi_parse_resources(int crsidx, union acpi_resource *crs, void *arg)
3179{
struct acpi_attach_args *aaa = arg;
int type = AML_CRSTYPE(crs)((crs)->hdr.typecode & 0x80 ? (crs)->hdr.typecode :
 (crs)->hdr.typecode >> 3);
uint8_t flags;

switch (type) {
case SR_IOPORT0x08:
case SR_FIXEDPORT0x09:
case LR_MEM240x81:
case LR_MEM320x85:
case LR_MEM32FIXED0x86:
case LR_WORD0x88:
case LR_DWORD0x87:
case LR_QWORD0x8A:
if (aaa->aaa_naddr >= nitems(aaa->aaa_addr)(sizeof((aaa->aaa_addr)) / sizeof((aaa->aaa_addr)[0])))
	return 0;
break;
case SR_IRQ0x04:
case LR_EXTIRQ0x89:
if (aaa->aaa_nirq >= nitems(aaa->aaa_irq)(sizeof((aaa->aaa_irq)) / sizeof((aaa->aaa_irq)[0])))
	return 0;
}

switch (type) {
case SR_IOPORT0x08:
case SR_FIXEDPORT0x09:
aaa->aaa_bst[aaa->aaa_naddr] = aaa->aaa_iot;
break;
case LR_MEM240x81:
case LR_MEM320x85:
case LR_MEM32FIXED0x86:
aaa->aaa_bst[aaa->aaa_naddr] = aaa->aaa_memt;
break;
case LR_WORD0x88:
case LR_DWORD0x87:
case LR_QWORD0x8A:
switch (crs->lr_word.type) {
case LR_TYPE_MEMORY0:
	aaa->aaa_bst[aaa->aaa_naddr] = aaa->aaa_memt;
	break;
case LR_TYPE_IO1:
	aaa->aaa_bst[aaa->aaa_naddr] = aaa->aaa_iot;
	break;
default:
	/* Bus number range or something else; skip. */
	return 0;
}
}

switch (type) {
case SR_IOPORT0x08:
aaa->aaa_addr[aaa->aaa_naddr] = crs->sr_ioport._min;
aaa->aaa_size[aaa->aaa_naddr] = crs->sr_ioport._len;
aaa->aaa_naddr++;
break;
case SR_FIXEDPORT0x09:
aaa->aaa_addr[aaa->aaa_naddr] = crs->sr_fioport._bas;
aaa->aaa_size[aaa->aaa_naddr] = crs->sr_fioport._len;
aaa->aaa_naddr++;
break;
case LR_MEM240x81:
aaa->aaa_addr[aaa->aaa_naddr] = crs->lr_m24._min;
aaa->aaa_size[aaa->aaa_naddr] = crs->lr_m24._len;
aaa->aaa_naddr++;
break;
case LR_MEM320x85:
aaa->aaa_addr[aaa->aaa_naddr] = crs->lr_m32._min;
aaa->aaa_size[aaa->aaa_naddr] = crs->lr_m32._len;
aaa->aaa_naddr++;
break;
case LR_MEM32FIXED0x86:
aaa->aaa_addr[aaa->aaa_naddr] = crs->lr_m32fixed._bas;
aaa->aaa_size[aaa->aaa_naddr] = crs->lr_m32fixed._len;
aaa->aaa_naddr++;
break;
case LR_WORD0x88:
aaa->aaa_addr[aaa->aaa_naddr] = crs->lr_word._min;
aaa->aaa_size[aaa->aaa_naddr] = crs->lr_word._len;
aaa->aaa_naddr++;
break;
case LR_DWORD0x87:
aaa->aaa_addr[aaa->aaa_naddr] = crs->lr_dword._min;
aaa->aaa_size[aaa->aaa_naddr] = crs->lr_dword._len;
aaa->aaa_naddr++;
break;
case LR_QWORD0x8A:
aaa->aaa_addr[aaa->aaa_naddr] = crs->lr_qword._min;
aaa->aaa_size[aaa->aaa_naddr] = crs->lr_qword._len;
aaa->aaa_naddr++;
break;
case SR_IRQ0x04:
aaa->aaa_irq[aaa->aaa_nirq] = ffs(crs->sr_irq.irq_mask) - 1;
/* Default is exclusive, active-high, edge triggered. */
if (AML_CRSLEN(crs)((crs)->hdr.typecode & 0x80 ? 3+(crs)->hdr.length :
 1+((crs)->hdr.typecode & 0x7)) < 4)
	flags = SR_IRQ_MODE(1L << 0);
else
	flags = crs->sr_irq.irq_flags;
/* Map flags to those of the extended interrupt descriptor. */
if (flags & SR_IRQ_SHR(1L << 4))
	aaa->aaa_irq_flags[aaa->aaa_nirq] |= LR_EXTIRQ_SHR(1L << 3);
if (flags & SR_IRQ_POLARITY(1L << 3))
	aaa->aaa_irq_flags[aaa->aaa_nirq] |= LR_EXTIRQ_POLARITY(1L << 2);
if (flags & SR_IRQ_MODE(1L << 0))
	aaa->aaa_irq_flags[aaa->aaa_nirq] |= LR_EXTIRQ_MODE(1L << 1);
aaa->aaa_nirq++;
break;
case LR_EXTIRQ0x89:
aaa->aaa_irq[aaa->aaa_nirq] = crs->lr_extirq.irq[0];
aaa->aaa_irq_flags[aaa->aaa_nirq] = crs->lr_extirq.flags;
aaa->aaa_nirq++;
break;
}

return 0;
3293}

3295void
3296acpi_parse_crs(struct acpi_softc *sc, struct acpi_attach_args *aaa)
3297{
struct aml_value res;

if (aml_evalname(sc, aaa->aaa_node, "_CRS", 0, NULL((void *)0), &res))
return;

aml_parse_resource(&res, acpi_parse_resources, aaa);
3304}

3306int
3307acpi_foundhid(struct aml_node *node, void *arg)
3308{
struct acpi_softc	*sc = (struct acpi_softc *)arg;
struct device		*self = (struct device *)arg;
char		 	 cdev[32];
char		 	 dev[32];
struct acpi_attach_args	 aaa;
int64_t			 sta;
int64_t			 cca;
3316#ifndef SMALL_KERNEL
int			 i;
3318#endif

if (acpi_parsehid(node, arg, cdev, dev, sizeof(dev)) != 0)
return (0);

sta = acpi_getsta(sc, node->parent);
if ((sta & STA_PRESENT(1L << 0)) == 0)
return (0);

if (aml_evalinteger(sc, node->parent, "_CCA", 0, NULL((void *)0), &cca))
cca = 1;

acpi_attach_deps(sc, node->parent);

memset(&aaa, 0, sizeof(aaa))__builtin_memset((&aaa), (0), (sizeof(aaa)));
aaa.aaa_iot = sc->sc_iot;
aaa.aaa_memt = sc->sc_memt;
aaa.aaa_dmat = cca ? sc->sc_cc_dmat : sc->sc_ci_dmat;
aaa.aaa_node = node->parent;
aaa.aaa_dev = dev;
aaa.aaa_cdev = cdev;
acpi_parse_crs(sc, &aaa);

3341#ifndef SMALL_KERNEL
if (!strcmp(cdev, ACPI_DEV_MOUSE"PNP0F13")) {
for (i = 0; i < nitems(sbtn_pnp)(sizeof((sbtn_pnp)) / sizeof((sbtn_pnp)[0])); i++) {
	if (!strcmp(dev, sbtn_pnp[i])) {
		mouse_has_softbtn = 1;
		break;
	}
}
}
3350#endif

if (acpi_matchhids(&aaa, acpi_skip_hids, "none") ||
   acpi_matchhids(&aaa, acpi_isa_hids, "none"))
return (0);

aaa.aaa_dmat = acpi_iommu_device_map(node->parent, aaa.aaa_dmat);

if (!node->parent->attached) {
node->parent->attached = 1;
config_found(self, &aaa, acpi_print)config_found_sm((self), (&aaa), (acpi_print), ((void *)0)
);
}

return (0);
3364}

3366#ifndef SMALL_KERNEL
3367int
3368acpi_founddock(struct aml_node *node, void *arg)
3369{
struct acpi_softc	*sc = (struct acpi_softc *)arg;
struct device		*self = (struct device *)arg;
struct acpi_attach_args	aaa;

dnprintf(10, "found dock entry: %s\n", node->parent->name);

memset(&aaa, 0, sizeof(aaa))__builtin_memset((&aaa), (0), (sizeof(aaa)));
aaa.aaa_iot = sc->sc_iot;
aaa.aaa_memt = sc->sc_memt;
aaa.aaa_node = node->parent;
aaa.aaa_name = "acpidock";

config_found(self, &aaa, acpi_print)config_found_sm((self), (&aaa), (acpi_print), ((void *)0)
);

return 0;
3385}

3387int
3388acpi_foundvideo(struct aml_node *node, void *arg)
3389{
struct acpi_softc *sc = (struct acpi_softc *)arg;
struct device *self = (struct device *)arg;
struct acpi_attach_args	aaa;

memset(&aaa, 0, sizeof(aaa))__builtin_memset((&aaa), (0), (sizeof(aaa)));
aaa.aaa_iot = sc->sc_iot;
aaa.aaa_memt = sc->sc_memt;
aaa.aaa_node = node->parent;
aaa.aaa_name = "acpivideo";

config_found(self, &aaa, acpi_print)config_found_sm((self), (&aaa), (acpi_print), ((void *)0)
);

return (0);
3403}

3405int
3406acpi_foundsbs(struct aml_node *node, void *arg)
3407{
struct acpi_softc	*sc = (struct acpi_softc *)arg;
struct device		*self = (struct device *)arg;
char		 	 cdev[32], dev[32];
struct acpi_attach_args	 aaa;
int64_t			 sta;

if (acpi_parsehid(node, arg, cdev, dev, sizeof(dev)) != 0)
return (0);

sta = acpi_getsta(sc, node->parent);
if ((sta & STA_PRESENT(1L << 0)) == 0)
return (0);

acpi_attach_deps(sc, node->parent);

if (strcmp(dev, ACPI_DEV_SBS"ACPI0002") != 0)
return (0);

if (node->parent->attached)
return (0);

memset(&aaa, 0, sizeof(aaa))__builtin_memset((&aaa), (0), (sizeof(aaa)));
aaa.aaa_iot = sc->sc_iot;
aaa.aaa_memt = sc->sc_memt;
aaa.aaa_node = node->parent;
aaa.aaa_dev = dev;
aaa.aaa_cdev = cdev;

config_found(self, &aaa, acpi_print)config_found_sm((self), (&aaa), (acpi_print), ((void *)0)
);
node->parent->attached = 1;

return (0);
3440}

3442int
3443acpiopen(dev_t dev, int flag, int mode, struct proc *p)
3444{
int error = 0;
struct acpi_softc *sc;
int s;

if (!acpi_cd.cd_ndevs || APMUNIT(dev)(((unsigned)((dev) & 0xff) | (((dev) & 0xffff0000) >>
 8))&0xf0) != 0 ||
   !(sc = acpi_cd.cd_devs[APMUNIT(dev)(((unsigned)((dev) & 0xff) | (((dev) & 0xffff0000) >>
 8))&0xf0)]))
return (ENXIO6);

s = splbio()splraise(0x6);
switch (APMDEV(dev)(((unsigned)((dev) & 0xff) | (((dev) & 0xffff0000) >>
 8))&0x0f)) {
case APMDEV_CTL8:
if (!(flag & FWRITE0x0002)) {
	error = EINVAL22;
	break;
}
if (sc->sc_flags & SCFLAG_OWRITE0x0000002) {
	error = EBUSY16;
	break;
}
sc->sc_flags |= SCFLAG_OWRITE0x0000002;
break;
case APMDEV_NORMAL0:
if (!(flag & FREAD0x0001) || (flag & FWRITE0x0002)) {
	error = EINVAL22;
	break;
}
sc->sc_flags |= SCFLAG_OREAD0x0000001;
break;
default:
error = ENXIO6;
break;
}
splx(s)spllower(s);
return (error);
3479}

3481int
3482acpiclose(dev_t dev, int flag, int mode, struct proc *p)
3483{
int error = 0;
struct acpi_softc *sc;
int s;

if (!acpi_cd.cd_ndevs || APMUNIT(dev)(((unsigned)((dev) & 0xff) | (((dev) & 0xffff0000) >>
 8))&0xf0) != 0 ||
   !(sc = acpi_cd.cd_devs[APMUNIT(dev)(((unsigned)((dev) & 0xff) | (((dev) & 0xffff0000) >>
 8))&0xf0)]))
return (ENXIO6);

s = splbio()splraise(0x6);
switch (APMDEV(dev)(((unsigned)((dev) & 0xff) | (((dev) & 0xffff0000) >>
 8))&0x0f)) {
case APMDEV_CTL8:
sc->sc_flags &= ~SCFLAG_OWRITE0x0000002;
break;
case APMDEV_NORMAL0:
sc->sc_flags &= ~SCFLAG_OREAD0x0000001;
break;
default:
error = ENXIO6;
break;
}
splx(s)spllower(s);
return (error);
3506}

3508int
3509acpiioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p)
3510{
int error = 0;
struct acpi_softc *sc;
struct acpi_ac *ac;
struct acpi_bat *bat;
struct acpi_sbs *sbs;
struct apm_power_info *pi = (struct apm_power_info *)data;
int bats;
unsigned int capacity, remaining, minutes, rate;
int s;

if (!acpi_cd.cd_ndevs || APMUNIT(dev)(((unsigned)((dev) & 0xff) | (((dev) & 0xffff0000) >>
 8))&0xf0) != 0 ||
   !(sc = acpi_cd.cd_devs[APMUNIT(dev)(((unsigned)((dev) & 0xff) | (((dev) & 0xffff0000) >>
 8))&0xf0)]))
return (ENXIO6);

s = splbio()splraise(0x6);
/* fake APM */
switch (cmd) {
case APM_IOC_SUSPEND((unsigned long)0x20000000 | ((0 & 0x1fff) << 16) |
 ((('A')) << 8) | ((2))):
case APM_IOC_STANDBY((unsigned long)0x20000000 | ((0 & 0x1fff) << 16) |
 ((('A')) << 8) | ((1))):
if ((flag & FWRITE0x0002) == 0) {
	error = EBADF9;
	break;
}
acpi_addtask(sc, acpi_sleep_task, sc, ACPI_SLEEP_SUSPEND0x01);
acpi_wakeup(sc);
break;
3537#ifdef HIBERNATE1
case APM_IOC_HIBERNATE((unsigned long)0x20000000 | ((0 & 0x1fff) << 16) |
 ((('A')) << 8) | ((9))):
if ((error = suser(p)) != 0)
	break;
if ((flag & FWRITE0x0002) == 0) {
	error = EBADF9;
	break;
}
if (get_hibernate_io_function(swdevt[0].sw_dev) == NULL((void *)0)) {
	error = EOPNOTSUPP45;
	break;
}
acpi_addtask(sc, acpi_sleep_task, sc, ACPI_SLEEP_HIBERNATE0x02);
acpi_wakeup(sc);
break;
3552#endif
case APM_IOC_GETPOWER((unsigned long)0x40000000 | ((sizeof(struct apm_power_info) &
 0x1fff) << 16) | ((('A')) << 8) | ((3))):
/* A/C */
pi->ac_state = APM_AC_UNKNOWN0xff;
3556// XXX replace with new power code
SLIST_FOREACH(ac, &sc->sc_ac, aac_link)for((ac) = ((&sc->sc_ac)->slh_first); (ac) != ((void
 *)0); (ac) = ((ac)->aac_link.sle_next)) {
	if (ac->aac_softc->sc_ac_stat == PSR_ONLINE0x01)
		pi->ac_state = APM_AC_ON0x01;
	else if (ac->aac_softc->sc_ac_stat == PSR_OFFLINE0x00)
		if (pi->ac_state == APM_AC_UNKNOWN0xff)
			pi->ac_state = APM_AC_OFF0x00;
}

/* battery */
pi->battery_state = APM_BATT_UNKNOWN0xff;
pi->battery_life = 0;
pi->minutes_left = 0;
bats = 0;
capacity = 0;
remaining = 0;
minutes = 0;
rate = 0;
SLIST_FOREACH(bat, &sc->sc_bat, aba_link)for((bat) = ((&sc->sc_bat)->slh_first); (bat) != ((
void *)0); (bat) = ((bat)->aba_link.sle_next)) {
	if (bat->aba_softc->sc_bat_present == 0)
		continue;

	if (bat->aba_softc->sc_bix.bix_last_capacity == 0)
		continue;

	bats++;
	capacity += bat->aba_softc->sc_bix.bix_last_capacity;
	remaining += min(bat->aba_softc->sc_bst.bst_capacity,
	    bat->aba_softc->sc_bix.bix_last_capacity);

	if (bat->aba_softc->sc_bst.bst_rate == BST_UNKNOWN0xffffffff)
		continue;
	else if (bat->aba_softc->sc_bst.bst_rate > 1)
		rate = bat->aba_softc->sc_bst.bst_rate;

	minutes += bat->aba_softc->sc_bst.bst_capacity;
}

SLIST_FOREACH(sbs, &sc->sc_sbs, asbs_link)for((sbs) = ((&sc->sc_sbs)->slh_first); (sbs) != ((
void *)0); (sbs) = ((sbs)->asbs_link.sle_next)) {
	if (sbs->asbs_softc->sc_batteries_present == 0)
		continue;

	if (sbs->asbs_softc->sc_battery.rel_charge == 0)
		continue;

	bats++;
	capacity += 100;
	remaining += min(100,
	    sbs->asbs_softc->sc_battery.rel_charge);

	if (sbs->asbs_softc->sc_battery.run_time ==
	    ACPISBS_VALUE_UNKNOWN65535)
		continue;

	rate = 60; /* XXX */
	minutes += sbs->asbs_softc->sc_battery.run_time;
}

if (bats == 0) {
	pi->battery_state = APM_BATTERY_ABSENT4;
	pi->battery_life = 0;
	pi->minutes_left = (unsigned int)-1;
	break;
}

if (pi->ac_state == APM_AC_ON0x01 || rate == 0)
	pi->minutes_left = (unsigned int)-1;
else
	pi->minutes_left = 60 * minutes / rate;

/* running on battery */
pi->battery_life = remaining * 100 / capacity;
if (pi->battery_life > 50)
	pi->battery_state = APM_BATT_HIGH0x00;
else if (pi->battery_life > 25)
	pi->battery_state = APM_BATT_LOW0x01;
else
	pi->battery_state = APM_BATT_CRITICAL0x02;

break;

default:
error = ENOTTY25;
}

splx(s)spllower(s);
return (error);
3643}

3645void	acpi_filtdetach(struct knote *);
3646int	acpi_filtread(struct knote *, long);

3648const struct filterops acpiread_filtops = {
.f_flags	= FILTEROP_ISFD0x00000001,
.f_attach	= NULL((void *)0),
.f_detach	= acpi_filtdetach,
.f_event	= acpi_filtread,
3653};

3655int acpi_evindex;

3657int
3658acpi_record_event(struct acpi_softc *sc, u_int type)
3659{
if ((sc->sc_flags & SCFLAG_OPEN(0x0000001|0x0000002)) == 0)
return (1);

acpi_evindex++;
KNOTE(sc->sc_note, APM_EVENT_COMPOSE(type, acpi_evindex))do { struct klist *__list = (sc->sc_note); if (__list != (
(void *)0)) knote(__list, ((((acpi_evindex) & 0x7fff) <<
 16)|((type) & 0xffff))); } while (0);
return (0);
3666}

3668void
3669acpi_filtdetach(struct knote *kn)
3670{
struct acpi_softc *sc = kn->kn_hook;
int s;

s = splbio()splraise(0x6);
klist_remove_locked(sc->sc_note, kn);
splx(s)spllower(s);
3677}

3679int
3680acpi_filtread(struct knote *kn, long hint)
3681{
/* XXX weird kqueue_scan() semantics */
if (hint && !kn->kn_datakn_kevent.data)
kn->kn_datakn_kevent.data = hint;
return (1);
3686}

3688int
3689acpikqfilter(dev_t dev, struct knote *kn)
3690{
struct acpi_softc *sc;
int s;

if (!acpi_cd.cd_ndevs || APMUNIT(dev)(((unsigned)((dev) & 0xff) | (((dev) & 0xffff0000) >>
 8))&0xf0) != 0 ||
   !(sc = acpi_cd.cd_devs[APMUNIT(dev)(((unsigned)((dev) & 0xff) | (((dev) & 0xffff0000) >>
 8))&0xf0)]))
return (ENXIO6);

switch (kn->kn_filterkn_kevent.filter) {
case EVFILT_READ(-1):
kn->kn_fop = &acpiread_filtops;
break;
default:
return (EINVAL22);
}

kn->kn_hook = sc;

s = splbio()splraise(0x6);
klist_insert_locked(sc->sc_note, kn);
splx(s)spllower(s);

return (0);
3713}

3715#else /* SMALL_KERNEL */

3717int
3718acpiopen(dev_t dev, int flag, int mode, struct proc *p)
3719{
return (ENXIO6);
3721}

3723int
3724acpiclose(dev_t dev, int flag, int mode, struct proc *p)
3725{
return (ENXIO6);
3727}

3729int
3730acpiioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p)
3731{
return (ENXIO6);
3733}

3735int
3736acpikqfilter(dev_t dev, struct knote *kn)
3737{
return (EOPNOTSUPP45);
3739}

3741#endif /* SMALL_KERNEL */