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

Bug Summary

File:	dev/acpi/acpi.c
Warning:	line 1637, column 34 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.4 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name acpi.c -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 -ffp-contract=on -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 -target-feature +retpoline-external-thunk -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/llvm16/lib/clang/16 -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/legacy-dpm -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/inc -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/swsmu/smu13 -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/inc -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/pm/swsmu/inc -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/inc/pmfw_if -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 SUSPEND -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 -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 -fcf-protection=branch -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 /home/ben/Projects/scan/2024-01-11-110808-61670-1 -x c /usr/src/sys/dev/acpi/acpi.c
1/* $OpenBSD: acpi.c,v 1.426 2024/01/08 19:52:29 kettenis 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/device.h>
22#include <sys/malloc.h>
23#include <sys/pool.h>
24#include <sys/fcntl.h>
25#include <sys/event.h>
26#include <sys/signalvar.h>
27#include <sys/proc.h>
28#include <sys/kthread.h>
29#include <sys/sched.h>

31#include <machine/conf.h>
32#include <machine/cpufunc.h>

34#include <dev/pci/pcivar.h>
35#include <dev/acpi/acpireg.h>
36#include <dev/acpi/acpivar.h>
37#include <dev/acpi/amltypes.h>
38#include <dev/acpi/acpidev.h>
39#include <dev/acpi/dsdt.h>

41#include <dev/pci/pcidevs.h>
42#include <dev/pci/ppbreg.h>
43#include <dev/pci/pciidevar.h>

45#include <machine/apmvar.h>

47#include "wd.h"

49#ifdef ACPI_DEBUG
50int	acpi_debug = 16;
51#endif

53int	acpi_poll_enabled;
54int	acpi_hasprocfvs;
55int	acpi_haspci;

57struct pool acpiwqpool;

59#define ACPIEN_RETRIES15 15

61struct aml_node *acpi_pci_match(struct device *, struct pci_attach_args *);
62pcireg_t acpi_pci_min_powerstate(pci_chipset_tag_t, pcitag_t);
63void	 acpi_pci_set_powerstate(pci_chipset_tag_t, pcitag_t, int, int);
64int	acpi_pci_notify(struct aml_node *, int, void *);

66int	acpi_submatch(struct device *, void *, void *);
67int	acpi_print(void *, const char *);

69void	acpi_map_pmregs(struct acpi_softc *);
70void	acpi_unmap_pmregs(struct acpi_softc *);

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

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

76int	acpi_inidev(struct aml_node *, void *);
77int	acpi_foundprt(struct aml_node *, void *);

79int	acpi_enable(struct acpi_softc *);
80void	acpi_init_states(struct acpi_softc *);

82void 	acpi_gpe_task(void *, int);
83void	acpi_sbtn_task(void *, int);
84void	acpi_pbtn_task(void *, int);

86int	acpi_enabled;

88void	acpi_init_gpes(struct acpi_softc *);
89void	acpi_disable_allgpes(struct acpi_softc *);
90struct gpe_block *acpi_find_gpe(struct acpi_softc *, int);
91void	acpi_enable_onegpe(struct acpi_softc *, int);
92int	acpi_gpe(struct acpi_softc *, int, void *);

94void	acpi_enable_rungpes(struct acpi_softc *);

96int	acpi_foundec(struct aml_node *, void *);
97int	acpi_foundsony(struct aml_node *node, void *arg);
98int	acpi_foundhid(struct aml_node *, void *);
99int	acpi_add_device(struct aml_node *node, void *arg);

101void	acpi_thread(void *);
102void	acpi_create_thread(void *);

104#ifndef SMALL_KERNEL

106void	acpi_init_pm(struct acpi_softc *);

108int	acpi_founddock(struct aml_node *, void *);
109int	acpi_foundpss(struct aml_node *, void *);
110int	acpi_foundtmp(struct aml_node *, void *);
111int	acpi_foundprw(struct aml_node *, void *);
112int	acpi_foundvideo(struct aml_node *, void *);
113int	acpi_foundsbs(struct aml_node *node, void *);

115int	acpi_foundide(struct aml_node *node, void *arg);
116int	acpiide_notify(struct aml_node *, int, void *);
117void	wdcattach(struct channel_softc *);
118int	wdcdetach(struct channel_softc *, int);
119int	is_ejectable_bay(struct aml_node *node);
120int	is_ata(struct aml_node *node);
121int	is_ejectable(struct aml_node *node);

123struct idechnl {
struct acpi_softc *sc;
int64_t		addr;
int64_t		chnl;
int64_t		sta;
128};

130/*
* 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
*/
137static 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",
171};

173int	mouse_has_softbtn;
174#endif /* SMALL_KERNEL */

176struct acpi_softc *acpi_softc;

178extern struct aml_node aml_root;

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

184uint8_t
185acpi_pci_conf_read_1(pci_chipset_tag_t pc, pcitag_t tag, int reg)
186{
uint32_t val = pci_conf_read(pc, tag, reg & ~0x3);
return (val >> ((reg & 0x3) << 3));
189}

191uint16_t
192acpi_pci_conf_read_2(pci_chipset_tag_t pc, pcitag_t tag, int reg)
193{
uint32_t val = pci_conf_read(pc, tag, reg & ~0x2);
return (val >> ((reg & 0x2) << 3));
196}

198uint32_t
199acpi_pci_conf_read_4(pci_chipset_tag_t pc, pcitag_t tag, int reg)
200{
return pci_conf_read(pc, tag, reg);
202}

204void
205acpi_pci_conf_write_1(pci_chipset_tag_t pc, pcitag_t tag, int reg, uint8_t val)
206{
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);
211}

213void
214acpi_pci_conf_write_2(pci_chipset_tag_t pc, pcitag_t tag, int reg, uint16_t val)
215{
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);
220}

222void
223acpi_pci_conf_write_4(pci_chipset_tag_t pc, pcitag_t tag, int reg, uint32_t val)
224{
pci_conf_write(pc, tag, reg, val);
226}

228int
229acpi_gasio(struct acpi_softc *sc, int iodir, int iospace, uint64_t address,
  int access_size, int len, void *buffer)
231{
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", 242, "(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);
385}

387int
388acpi_inidev(struct aml_node *node, void *arg)
389{
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;
416}

418int
419acpi_foundprt(struct aml_node *node, void *arg)
420{
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;
450}

452TAILQ_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 };
454TAILQ_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 };

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

460int
461acpi_getminbus(int crsidx, union acpi_resource *crs, void *arg)
462{
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;
474}

476int
477acpi_matchcls(struct acpi_attach_args *aaa, int class, int subclass,
  int interface)
479{
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);
501}

503int
504_acpi_matchhids(const char *hid, const char *hids[])
505{
int i;

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

514int
515acpi_matchhids(struct acpi_attach_args *aa, const char *hids[],
  const char *driver)
517{
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);
531}

533int64_t
534acpi_getsta(struct acpi_softc *sc, struct aml_node *node)
535{
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;
543}

545/* Map ACPI device node to PCI */
546int
547acpi_getpci(struct aml_node *node, void *arg)
548{
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);
665}

667struct aml_node *
668acpi_find_pci(pci_chipset_tag_t pc, pcitag_t tag)
669{
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);
680}

682struct aml_node *
683acpi_pci_match(struct device *dev, struct pci_attach_args *pa)
684{
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);
713}

715pcireg_t
716acpi_pci_min_powerstate(pci_chipset_tag_t pc, pcitag_t tag)
717{
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;
745}

747void
748acpi_pci_set_powerstate(pci_chipset_tag_t pc, pcitag_t tag, int state, int pre)
749{
750#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;
}

}
804#endif /* NACPIPWRRES > 0 */
805}

807int
808acpi_pci_notify(struct aml_node *node, int ntype, void *arg)
809{
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);
829}

831void
832acpi_pciroots_attach(struct device *dev, void *aux, cfprint_t pr)
833{
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", 837, "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));
}
846}

848/* GPIO support */

850struct acpi_gpio_event {
struct aml_node *node;
uint16_t tflags;
uint16_t pin;
854};

856void
857acpi_gpio_event_task(void *arg0, int arg1)
858{
struct acpi_softc *sc = acpi_softc;
struct acpi_gpio_event *ev = arg0;
struct acpi_gpio *gpio = ev->node->gpio;
struct aml_value evt;
uint16_t pin = arg1;
char name[5];

if (pin < 256) {
if ((ev->tflags & LR_GPIO_MODE(1L << 0)) == LR_GPIO_LEVEL(0L << 0)) {
	snprintf(name, sizeof(name), "_L%.2X", pin);
	if (aml_evalname(sc, ev->node, name, 0, NULL((void *)0), NULL((void *)0))) {
		if (gpio->intr_enable)
			gpio->intr_enable(gpio->cookie, pin);
		return;
	}
} else {
	snprintf(name, sizeof(name), "_E%.2X", pin);
	if (aml_evalname(sc, ev->node, name, 0, NULL((void *)0), NULL((void *)0))) {
		if (gpio->intr_enable)
			gpio->intr_enable(gpio->cookie, pin);
		return;
	}
}
}

memset(&evt, 0, sizeof(evt))__builtin_memset((&evt), (0), (sizeof(evt)));
evt.v_integer_.vinteger = pin;
evt.type = AML_OBJTYPE_INTEGER;
aml_evalname(sc, ev->node, "_EVT", 1, &evt, NULL((void *)0));
if ((ev->tflags & LR_GPIO_MODE(1L << 0)) == LR_GPIO_LEVEL(0L << 0)) {
if (gpio->intr_enable)
	gpio->intr_enable(gpio->cookie, pin);
}
892}

894int
895acpi_gpio_event(void *arg)
896{
struct acpi_gpio_event *ev = arg;
struct acpi_gpio *gpio = ev->node->gpio;

if ((ev->tflags & LR_GPIO_MODE(1L << 0)) == LR_GPIO_LEVEL(0L << 0)) {
if(gpio->intr_disable)
	gpio->intr_disable(gpio->cookie, ev->pin);
}
acpi_addtask(acpi_softc, acpi_gpio_event_task, ev, ev->pin);
acpi_wakeup(acpi_softc);
return 1;
907}

909int
910acpi_gpio_parse_events(int crsidx, union acpi_resource *crs, void *arg)
911{
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 &&
    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->tflags = crs->lr_gpio.tflags;
	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;
940}

942void
943acpi_register_gpio(struct acpi_softc *sc, struct aml_node *devnode)
944{
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);
963}

965#ifndef SMALL_KERNEL

967void
968acpi_register_gsb(struct acpi_softc *sc, struct aml_node *devnode)
969{
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);
982}

984#endif

986void
987acpi_attach_common(struct acpi_softc *sc, paddr_t base)
988{
struct acpi_mem_map handle;
struct acpi_rsdp *rsdp;
struct acpi_q *entry;
struct acpi_dsdt *p_dsdt;
993#ifndef SMALL_KERNEL
int wakeup_dev_ct;
struct acpi_wakeq *wentry;
struct device *dev;
997#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;
sc->sc_root = &aml_root;

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;

pool_init(&acpiwqpool, sizeof(struct acpi_taskq), 0, IPL_BIO0x3, 0,
   "acpiwqpl", NULL((void *)0));
pool_setlowat(&acpiwqpool, 16);

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→
1019#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→
1021#endif /* NACPIPWRRES > 0 */

if (acpi_loadtables(sc, rsdp)) {
6
←
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)) {
7
←
Loop condition is false. Execution continues on line 1041→
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)) {
8
←
Assuming field 'sc_fadt' is not equal to NULL→
9
←
Taking false branch→
printf(": no FADT\n");
return;
}

sc->sc_major = sc->sc_fadt->hdr.revision;
if (sc->sc_major > 4)
10
←
Assuming field 'sc_major' is <= 4→
11
←
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);
12
←
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, NULL((void *)0), 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, NULL((void *)0), p_dsdt->aml,
	    p_dsdt->hdr_lengthhdr.length - sizeof(p_dsdt->hdr));
}
}

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


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

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

/* Initialize GPE handlers */
s = splbio()splraise(0x3);
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");

1164#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");

1178#ifdef SUSPEND1
if (wakeup_dev_ct > 0)
device_register_wakeup(&sc->sc_dev);
1181#endif

/*
* 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));
}
1196#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(sc->sc_root, "_INI", acpi_inidev, sc);

/* Get PCI mapping */
aml_walknodes(sc->sc_root, AML_WALK_PRE0x00, acpi_getpci, sc);

1218#if defined (__amd64__1) || defined(__i386__)
/* attach pci interrupt routing tables */
aml_find_node(sc->sc_root, "_PRT", acpi_foundprt, sc);
1221#endif

aml_find_node(sc->sc_root, "_HID", acpi_foundec, sc);

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

1228#ifndef SMALL_KERNEL
/* try to find smart battery first */
aml_find_node(sc->sc_root, "_HID", acpi_foundsbs, sc);
1231#endif /* SMALL_KERNEL */

/* attach battery, power supply and button devices */
aml_find_node(sc->sc_root, "_HID", acpi_foundhid, sc);

aml_walknodes(sc->sc_root, AML_WALK_PRE0x00, acpi_add_device, sc);

1238#ifndef SMALL_KERNEL
1239#if NWD1 > 0
/* Attach IDE bay */
aml_walknodes(sc->sc_root, AML_WALK_PRE0x00, acpi_foundide, sc);
1242#endif

/* attach docks */
aml_find_node(sc->sc_root, "_DCK", acpi_founddock, sc);

/* attach video */
aml_find_node(sc->sc_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);
}
}

1275#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);
1288}

1290int
1291acpi_submatch(struct device *parent, void *match, void *aux)
1292{
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));
1299}

1301int
1302acpi_print(void *aux, const char *pnp)
1303{
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);
1316}

1318struct acpi_q *
1319acpi_maptable(struct acpi_softc *sc, paddr_t addr, const char *sig,
  const char *oem, const char *tbl, int flag)
1321{
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;
1368}

1370int
1371acpi_loadtables(struct acpi_softc *sc, struct acpi_rsdp *rsdp)
1372{
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);
1418}

1420/* Read from power management register */
1421int
1422acpi_read_pmreg(struct acpi_softc *sc, int reg, int offset)
1423{
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"
, 1433, "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"
, 1445, "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);
1507}

1509/* Write to power management register */
1510void
1511acpi_write_pmreg(struct acpi_softc *sc, int reg, int offset, int regval)
1512{
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"
, 1524, "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"
, 1541, "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);
1605}

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

for (reg = 0; reg < ACPIREG_MAXREG0x0D; reg++) {
14
←
Loop condition is true.  Entering loop body→
20
←
Loop condition is true.  Entering loop body→
size = 0;
access = 0;
switch (reg) {
15
←
Control jumps to 'case 0:'  at line 1626→
21
←
Control jumps to 'case 1:'  at line 1627→
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_blk21.1
Field 'pm1a_evt_blk' is 0
) {
16
←
Assuming field 'pm1a_evt_blk' is 0→
17
←
Taking false branch→
22
←
Taking false branch→
		addr = fadt->pm1a_evt_blk;
		access = 2;
	} else if (fadt->hdr_revisionhdr.revision >= 3) {
18
←
Assuming field 'revision' is < 3→
		addr = fadt->x_pm1a_evt_blk.address;
		access = 1 << fadt->x_pm1a_evt_blk.access_size;
	}
	if (reg18.1
'reg' is not equal to ACPIREG_PM1A_EN
2
'reg' is equal to ACPIREG_PM1A_EN
 == ACPIREG_PM1A_EN0x01 && addr) {
23
←
Branch condition evaluates to a garbage value
		addr += size;
		name = "pm1a_en";
	}
	break;
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;
1691#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;
1704#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) {
19
←
Assuming 'size' is 0→
	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);
}
}
1762}

1764void
1765acpi_unmap_pmregs(struct acpi_softc *sc)
1766{
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);
}
1774}

1776int
1777acpi_enable(struct acpi_softc *sc)
1778{
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;
1790}

1792/* ACPI Workqueue support */
1793SIMPLEQ_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 };

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

wq = pool_get(&acpiwqpool, PR_ZERO0x0008 | PR_NOWAIT0x0002);
if (wq == NULL((void *)0)) {
printf("unable to create task");
return;
}
wq->handler = handler;
wq->arg0 = arg0;
wq->arg1 = arg1;

s = splbio()splraise(0x3);
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);
1815}

1817int
1818acpi_dotask(struct acpi_softc *sc)
1819{
struct acpi_taskq *wq;
int s;

s = splbio()splraise(0x3);
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);

pool_put(&acpiwqpool, wq);

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

1842#ifndef SMALL_KERNEL

1844int
1845is_ata(struct aml_node *node)
1846{
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));
1851}

1853int
1854is_ejectable(struct aml_node *node)
1855{
return (aml_searchname(node, "_EJ0") != NULL((void *)0));
1857}

1859int
1860is_ejectable_bay(struct aml_node *node)
1861{
return ((is_ata(node) || is_ata(node->parent)) && is_ejectable(node));
1863}

1865#if NWD1 > 0
1866int
1867acpiide_notify(struct aml_node *node, int ntype, void *arg)
1868{
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);
1905}

1907int
1908acpi_foundide(struct aml_node *node, void *arg)
1909{
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);
1951}
1952#endif /* NWD > 0 */

1954void
1955acpi_sleep_task(void *arg0, int sleepmode)
1956{
struct acpi_softc *sc = arg0;

1959#ifdef SUSPEND1
sleep_state(sc, sleepmode);
1961#endif
/* Tell userland to recheck A/C and battery status */
acpi_record_event(sc, APM_POWER_CHANGE0x0006);
1964}

1966#endif /* SMALL_KERNEL */

1968void
1969acpi_reset(void)
1970{
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);
2002}

2004void
2005acpi_gpe_task(void *arg0, int gpe)
2006{
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);
}
2015}

2017void
2018acpi_pbtn_task(void *arg0, int dummy)
2019{
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(0x3);
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;
2040#ifndef SMALL_KERNEL
case 2:
acpi_addtask(sc, acpi_sleep_task, sc, SLEEP_SUSPEND0x01);
break;
2044#endif
}
2046}

2048void
2049acpi_sbtn_task(void *arg0, int dummy)
2050{
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(0x3);
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);
2064}

2066void
2067acpi_powerdown_task(void *arg0, int dummy)
2068{
extern int allowpowerdown;

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

2077int
2078acpi_interrupt(void *arg)
2079{
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;
		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);
2158}

2160int
2161acpi_add_device(struct aml_node *node, void *arg)
2162{
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;
2211}

2213void
2214acpi_enable_onegpe(struct acpi_softc *sc, int gpe)
2215{
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);
2224}

2226/* Clear all GPEs */
2227void
2228acpi_disable_allgpes(struct acpi_softc *sc)
2229{
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);
}
2236}

2238/* Enable runtime GPEs */
2239void
2240acpi_enable_rungpes(struct acpi_softc *sc)
2241{
int idx;

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

2249/* Enable wakeup GPEs */
2250void
2251acpi_enable_wakegpes(struct acpi_softc *sc, int state)
2252{
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 (wentry->q_enabled && state <= wentry->q_state)
	acpi_enable_onegpe(sc, wentry->q_gpe);
}
2262}

2264int
2265acpi_set_gpehandler(struct acpi_softc *sc, int gpe, int (*handler)
  (struct acpi_softc *, int, void *), void *arg, int flags)
2267{
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))
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);
2287}

2289int
2290acpi_gpe(struct acpi_softc *sc, int gpe, void *arg)
2291{
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);
2304}

2306/* 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
*/
2316int
2317acpi_foundprw(struct aml_node *node, void *arg)
2318{
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;
wq->q_enabled = 0;
}
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;
2353}

2355int
2356acpi_toggle_wakedev(struct acpi_softc *sc, struct aml_node *node, int enable)
2357{
struct acpi_wakeq *wentry;
int ret = -1;

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 (wentry->q_node == node) {
	wentry->q_enabled = enable ? 1 : 0;
	dnprintf(10, "%.4s(S%d) gpe %.2x %sabled\n",
	    wentry->q_node->name, wentry->q_state,
	    wentry->q_gpe, enable ? "en" : "dis");
	ret = 0;
	break;
}
}

return ret;
2373}

2375struct gpe_block *
2376acpi_find_gpe(struct acpi_softc *sc, int gpe)
2377{
if (gpe >= sc->sc_lastgpe)
return NULL((void *)0);
return &sc->gpe_table[gpe];
2381}

2383void
2384acpi_init_gpes(struct acpi_softc *sc)
2385{
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(sc->sc_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(sc->sc_root, name);
	if (gpe != NULL((void *)0))
		acpi_set_gpehandler(sc, idx, acpi_gpe, gpe,
		    GPE_EDGE0x02);
}
}
aml_find_node(sc->sc_root, "_PRW", acpi_foundprw, sc);
2415}

2417void
2418acpi_init_pm(struct acpi_softc *sc)
2419{
sc->sc_tts = aml_searchname(sc->sc_root, "_TTS");
sc->sc_pts = aml_searchname(sc->sc_root, "_PTS");
sc->sc_wak = aml_searchname(sc->sc_root, "_WAK");
sc->sc_bfs = aml_searchname(sc->sc_root, "_BFS");
sc->sc_gts = aml_searchname(sc->sc_root, "_GTS");
sc->sc_sst = aml_searchname(sc->sc_root, "_SI_._SST");
2426}

2428#ifndef SMALL_KERNEL

2430void
2431acpi_init_states(struct acpi_softc *sc)
2432{
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, sc->sc_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);
}
}
2453}

2455void
2456acpi_sleep_pm(struct acpi_softc *sc, int state)
2457{
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;
}
2497}

2499uint32_t acpi_force_bm;

2501void
2502acpi_resume_pm(struct acpi_softc *sc, int fromstate)
2503{
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);
}
2555}

2557/* Set the indicator light to some state */
2558void
2559acpi_indicator(struct acpi_softc *sc, int led_state)
2560{
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;
}
2567}

2569/* 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.
*/
2574void
2575acpi_powerdown(void)
2576{
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)
;
2600}

2602#endif /* SMALL_KERNEL */

2604int
2605acpi_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)
2607{
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;
2629}

2631void
2632acpi_wakeup(void *arg)
2633{
struct acpi_softc  *sc = (struct acpi_softc *)arg;

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


2641void
2642acpi_thread(void *arg)
2643{
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(0x3);
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(0x3);
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);
2704}

2706void
2707acpi_create_thread(void *arg)
2708{
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));
2715}

2717int
2718acpi_foundec(struct aml_node *node, void *arg)
2719{
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;
2758}

2760int
2761acpi_foundsony(struct aml_node *node, void *arg)
2762{
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;
2776}

2778/* Support for _DSD Device Properties. */

2780int
2781acpi_getprop(struct aml_node *node, const char *prop, void *buf, int buflen)
2782{
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;
2833}

2835uint64_t
2836acpi_getpropint(struct aml_node *node, const char *prop, uint64_t defval)
2837{
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;
2880}

2882int
2883acpi_parsehid(struct aml_node *node, void *arg, char *outcdev, char *outdev,
  size_t devlen)
2885{
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);
2933}

2935/* Devices for which we don't want to attach a driver */
2936const 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)
2951};

2953/* ISA devices for which we attach a driver later */
2954const 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)
2962};

2964void
2965acpi_attach_deps(struct acpi_softc *sc, struct aml_node *node)
2966{
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_NAMEREF) {
	node = aml_searchrel(node,
	    aml_getname(val->v_nameref_.vbuffer));
	if (node)
		val = node->value;
}
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);
2998}

3000int
3001acpi_parse_resources(int crsidx, union acpi_resource *crs, void *arg)
3002{
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;
3116}

3118void
3119acpi_parse_crs(struct acpi_softc *sc, struct acpi_attach_args *aaa)
3120{
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);
3127}

3129int
3130acpi_foundhid(struct aml_node *node, void *arg)
3131{
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;
3139#ifndef SMALL_KERNEL
int			 i;
3141#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) | STA_ENABLED(1L << 1))) != (STA_PRESENT(1L << 0) | STA_ENABLED(1L << 1)))
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);

3164#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;
	}
}
}
3173#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);
3187}

3189#ifndef SMALL_KERNEL
3190int
3191acpi_founddock(struct aml_node *node, void *arg)
3192{
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;
3208}

3210int
3211acpi_foundvideo(struct aml_node *node, void *arg)
3212{
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);
3226}

3228int
3229acpi_foundsbs(struct aml_node *node, void *arg)
3230{
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);
3263}

3265int
3266acpi_batcount(struct acpi_softc *sc)
3267{
struct acpi_bat *bat;
int count = 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))
count++;
return count;
3274}

3276int
3277acpi_apminfo(struct apm_power_info *pi)
3278{
struct acpi_softc *sc = acpi_softc;
struct acpi_ac *ac;
struct acpi_bat *bat;
struct acpi_sbs *sbs;
int bats;
unsigned int capacity, remaining, minutes, rate;

/* A/C */
pi->ac_state = APM_AC_UNKNOWN0xff;
3288// 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_state & BST_CHARGE0x02)
	pi->battery_state = APM_BATT_CHARGING0x03;

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;
return 0;
}

if (rate == 0)
pi->minutes_left = (unsigned int)-1;
else if (pi->battery_state == APM_BATT_CHARGING0x03)
pi->minutes_left = 60 * (capacity - remaining) / rate;
else
pi->minutes_left = 60 * minutes / rate;

pi->battery_life = remaining * 100 / capacity;

if (pi->battery_state == APM_BATT_CHARGING0x03)
return 0;

/* running on battery */
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;

return 0;
3377}

3379int acpi_evindex;

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

acpi_evindex++;
knote_locked(&sc->sc_note, APM_EVENT_COMPOSE(type, acpi_evindex)((((acpi_evindex) & 0x7fff) << 16)|((type) & 0xffff
)));
return (0);
3390}

3392#endif /* SMALL_KERNEL */