pcib0: device has no interrupts wi0: No irq?!

From: Daniel Papasian <dpapasia_at_andrew.cmu.edu>
Date: Mon, 31 May 2004 15:16:18 -0400 (EDT)
I've been trying, to no avail, to get this wireless card working on
FreeBSD 5.2.1-RELEASE.  If I boot with ACPI disabled, the driver seems to
attach and everything is probably working (won't be around a wireless
network for a couple weeks) - booting with ACPI enabled, however, and the
ACPI Host-PCI bridge doesn't seem to assign the driver an irq for the
chipset, and it complains and dies.

Attached is dmesg from a verbose booting with ACPI enabled, the output of
acpiconf -d, and my kernel config.

It's rather long and no doubt contains undeeded information, but better
too much information than too little, eh?

Anyhow, I'm wondering if there is anything I should be trying on my end,
and if not, where in the kernel sources I should be looking.

-Dan

Copyright (c) 1992-2004 The FreeBSD Project.
Copyright (c) 1979, 1980, 1983, 1986, 1988, 1989, 1991, 1992, 1993, 1994
	The Regents of the University of California. All rights reserved.
FreeBSD 5.2.1-RELEASE #1: Mon May 31 13:35:33 EDT 2004
    dpapasia_at_proudhon:/usr/src/sys/i386/compile/PROUDHON
Preloaded elf kernel "/boot/kernel/kernel" at 0xc088b000.
Preloaded elf module "/boot/kernel/acpi.ko" at 0xc088b21c.
Calibrating clock(s) ... i8254 clock: 1193138 Hz
CLK_USE_I8254_CALIBRATION not specified - using default frequency
Timecounter "i8254" frequency 1193182 Hz quality 0
Calibrating TSC clock ... TSC clock: 1640070132 Hz
CPU: Intel(R) Pentium(R) 4 CPU 2.00GHz (1640.07-MHz 686-class CPU)
  Origin = "GenuineIntel"  Id = 0xf24  Stepping = 4
  Features=0x3febf9ff<FPU,VME,DE,PSE,TSC,MSR,PAE,MCE,CX8,SEP,MTRR,PGE,MCA,CMOV,PAT,PSE36,CLFLUSH,DTS,ACPI,MMX,FXSR,SSE,SSE2,SS,HTT,TM>
real memory  = 535756800 (510 MB)
Physical memory chunk(s):
0x0000000000001000 - 0x000000000009efff, 647168 bytes (158 pages)
0x0000000000100000 - 0x00000000003fffff, 3145728 bytes (768 pages)
0x0000000000c29000 - 0x000000001f5cdfff, 513429504 bytes (125349 pages)
avail memory = 510750720 (487 MB)
bios32: Found BIOS32 Service Directory header at 0xc00f6c50
bios32: Entry = 0xfd750 (c00fd750)  Rev = 0  Len = 1
pcibios: PCI BIOS entry at 0xfd750+0x14b
pnpbios: Found PnP BIOS data at 0xc00f6cb0
pnpbios: Entry = f0000:98bb  Rev = 1.0
Other BIOS signatures found:
wlan: <802.11 Link Layer>
null: <null device, zero device>
random: <entropy source>
mem: <memory & I/O>
Pentium Pro MTRR support enabled
npx0: [FAST]
npx0: <math processor> on motherboard
npx0: INT 16 interface
acpi0: <PTLTD    RSDT  > on motherboard
pci_open(1):	mode 1 addr port (0x0cf8) is 0x80008004
pci_open(1a):	mode1res=0x80000000 (0x80000000)
pci_cfgcheck:	device 0 [class=060000] [hdr=00] is there (id=167110b9)
pcibios: BIOS version 2.10
Using $PIR table, 9 entries at 0xc00fdf30
PCI-Only Interrupts: none
Location  Bus Device Pin  Link  IRQs
embedded    0    1    A   0x01  3 4 5 6 7 9 10 11 12 14 15
embedded    0    1    B   0x02  3 4 5 6 7 9 10 11 12 14 15
embedded    0    2    A   0x09  10
embedded    0   15    A   0x05  10
embedded    0    8    A   0x07  10
embedded    0    6    A   0x08  5 7
embedded    0    9    A   0x04  10
embedded    0    9    B   0x03  10
embedded    0   10    A   0x06  5 7
embedded    0   18    A   0x02  7 11
embedded    0   12    A   0x03  10
AcpiOsDerivePciId: bus 0 dev 17 func 0
AcpiOsDerivePciId: bus 0 dev 7 func 0
AcpiOsDerivePciId: bus 0 dev 7 func 0
AcpiOsDerivePciId: bus 0 dev 7 func 0
acpi0: Power Button (fixed)
ACPI timer looks BAD  min = 3, max = 9, width = 6
ACPI timer looks BAD  min = 3, max = 9, width = 6
ACPI timer looks BAD  min = 3, max = 9, width = 6
ACPI timer looks BAD  min = 3, max = 9, width = 6
ACPI timer looks BAD  min = 3, max = 10, width = 7
ACPI timer looks BAD  min = 3, max = 9, width = 6
ACPI timer looks BAD  min = 3, max = 9, width = 6
ACPI timer looks BAD  min = 3, max = 9, width = 6
ACPI timer looks BAD  min = 3, max = 9, width = 6
ACPI timer looks BAD  min = 3, max = 9, width = 6
Timecounter "ACPI-safe" frequency 3579545 Hz quality 1000
AcpiOsDerivePciId: bus 0 dev 0 func 0
acpi_timer0: <32-bit timer at 3.579545MHz> port 0x8008-0x800b on acpi0
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
acpi_cpu0: <CPU> port 0x530-0x537 on acpi0
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
acpi_tz0: <Thermal Zone> port 0x530-0x537 on acpi0
pcib0: <ACPI Host-PCI bridge> port 0xcf8-0xcff on acpi0
---- initial configuration ------------------------
\\_SB_.PCI0.ISA_.LNKA irq   9: [  9] low,level,sharable 0.1.0
\\_SB_.PCI0.ISA_.LNKU irq  10: [ 10] low,level,sharable 0.2.0
\\_SB_.PCI0.ISA_.LNKE irq  10: [ 10] low,level,sharable 0.15.0
\\_SB_.PCI0.ISA_.LNKH irq   5: [  5] low,level,sharable 0.6.0
\\_SB_.PCI0.ISA_.LNKB irq  11: [ 11] low,level,sharable 0.18.0
---- before setting priority for links ------------
---- before fixup boot-disabled links -------------
---- after fixup boot-disabled links --------------
---- arbitrated configuration ---------------------
\\_SB_.PCI0.ISA_.LNKA irq   9: [  9] low,level,sharable 0.1.0
\\_SB_.PCI0.ISA_.LNKU irq  10: [ 10] low,level,sharable 0.2.0
\\_SB_.PCI0.ISA_.LNKE irq  10: [ 10] low,level,sharable 0.15.0
\\_SB_.PCI0.ISA_.LNKH irq   5: [  5] low,level,sharable 0.6.0
\\_SB_.PCI0.ISA_.LNKB irq  11: [ 11] low,level,sharable 0.18.0
pci0: <ACPI PCI bus> on pcib0
pci0: physical bus=0
	map[10]: type 3, range 32, base f0000000, size 27, enabled
found->	vendor=0x10b9, dev=0x1671, revid=0x02
	bus=0, slot=0, func=0
	class=06-00-00, hdrtype=0x00, mfdev=0
	cmdreg=0x0007, statreg=0xa210, cachelnsz=0 (dwords)
	lattimer=0x00 (0 ns), mingnt=0x00 (0 ns), maxlat=0x00 (0 ns)
	powerspec 1  supports D0 D3  current D0
found->	vendor=0x10b9, dev=0x5247, revid=0x00
	bus=0, slot=1, func=0
	class=06-04-00, hdrtype=0x01, mfdev=0
	cmdreg=0x001f, statreg=0x0400, cachelnsz=0 (dwords)
	lattimer=0x00 (0 ns), mingnt=0x0c (3000 ns), maxlat=0x00 (0 ns)
	map[10]: type 1, range 32, base e0000000, size 12, enabled
pcib0: matched entry for 0.2.INTA (source \\_SB_.PCI0.ISA_.LNKU)
pcib0: slot 2 INTA is routed to irq 10
found->	vendor=0x10b9, dev=0x5237, revid=0x03
	bus=0, slot=2, func=0
	class=0c-03-10, hdrtype=0x00, mfdev=0
	cmdreg=0x0017, statreg=0x0290, cachelnsz=8 (dwords)
	lattimer=0x40 (1920 ns), mingnt=0x00 (0 ns), maxlat=0x50 (20000 ns)
	intpin=a, irq=10
	powerspec 2  supports D0 D3  current D0
	map[10]: type 4, range 32, base 00001000, size  8, enabled
	map[14]: type 1, range 32, base e0001000, size 12, memory disabled
pcib0: matched entry for 0.6.INTA (source \\_SB_.PCI0.ISA_.LNKH)
pcib0: slot 6 INTA is routed to irq 5
found->	vendor=0x10b9, dev=0x5451, revid=0x02
	bus=0, slot=6, func=0
	class=04-01-00, hdrtype=0x00, mfdev=0
	cmdreg=0x0005, statreg=0xc290, cachelnsz=0 (dwords)
	lattimer=0x40 (1920 ns), mingnt=0x02 (500 ns), maxlat=0x18 (6000 ns)
	intpin=a, irq=5
	powerspec 2  supports D0 D1 D2 D3  current D0
found->	vendor=0x10b9, dev=0x1533, revid=0x00
	bus=0, slot=7, func=0
	class=06-01-00, hdrtype=0x00, mfdev=0
	cmdreg=0x000f, statreg=0x0210, cachelnsz=0 (dwords)
	lattimer=0x00 (0 ns), mingnt=0x00 (0 ns), maxlat=0x00 (0 ns)
	powerspec 1  supports D0 D3  current D0
	map[10]: type 1, range 32, base e0002000, size 12, memory disabled
	map[14]: type 4, range 32, base 00001400, size  8, port disabled
found->	vendor=0x10b9, dev=0x5457, revid=0x00
	bus=0, slot=8, func=0
	class=07-03-00, hdrtype=0x00, mfdev=0
	cmdreg=0x0000, statreg=0x0290, cachelnsz=0 (dwords)
	lattimer=0x40 (1920 ns), mingnt=0x00 (0 ns), maxlat=0x00 (0 ns)
	intpin=a, irq=255
	powerspec 2  supports D0 D3  current D0
	map[10]: type 3, range 32, base e0005000, size 12, memory disabled
found->	vendor=0x1260, dev=0x3873, revid=0x01
	bus=0, slot=9, func=0
	class=02-80-00, hdrtype=0x00, mfdev=0
	cmdreg=0x0010, statreg=0x0290, cachelnsz=8 (dwords)
	lattimer=0x40 (1920 ns), mingnt=0x00 (0 ns), maxlat=0x00 (0 ns)
	intpin=a, irq=255
	powerspec 2  supports D0 D1 D2 D3  current D0
found->	vendor=0x104c, dev=0xac55, revid=0x01
	bus=0, slot=10, func=0
	class=06-07-00, hdrtype=0x02, mfdev=1
	cmdreg=0x0000, statreg=0x0210, cachelnsz=0 (dwords)
	lattimer=0x40 (1920 ns), mingnt=0x40 (16000 ns), maxlat=0x03 (750 ns)
	intpin=a, irq=255
	powerspec 2  supports D0 D1 D2 D3  current D0
found->	vendor=0x104c, dev=0xac55, revid=0x01
	bus=0, slot=10, func=1
	class=06-07-00, hdrtype=0x02, mfdev=1
	cmdreg=0x0000, statreg=0x0210, cachelnsz=0 (dwords)
	lattimer=0x40 (1920 ns), mingnt=0x40 (16000 ns), maxlat=0x03 (750 ns)
	intpin=a, irq=255
	powerspec 2  supports D0 D1 D2 D3  current D0
	map[10]: type 1, range 32, base e0003000, size 12, enabled
pcib0: matched entry for 0.15.INTA (source \\_SB_.PCI0.ISA_.LNKE)
pcib0: slot 15 INTA is routed to irq 10
found->	vendor=0x10b9, dev=0x5237, revid=0x03
	bus=0, slot=15, func=0
	class=0c-03-10, hdrtype=0x00, mfdev=0
	cmdreg=0x0017, statreg=0x0290, cachelnsz=8 (dwords)
	lattimer=0x40 (1920 ns), mingnt=0x00 (0 ns), maxlat=0x50 (20000 ns)
	intpin=a, irq=10
	powerspec 2  supports D0 D3  current D0
	map[20]: type 4, range 32, base 00001800, size  4, enabled
found->	vendor=0x10b9, dev=0x5229, revid=0xc4
	bus=0, slot=16, func=0
	class=01-01-b0, hdrtype=0x00, mfdev=0
	cmdreg=0x0005, statreg=0x0290, cachelnsz=0 (dwords)
	lattimer=0x20 (960 ns), mingnt=0x02 (500 ns), maxlat=0x04 (1000 ns)
	intpin=a, irq=255
	powerspec 2  supports D0 D3  current D0
found->	vendor=0x10b9, dev=0x7101, revid=0x00
	bus=0, slot=17, func=0
	class=06-80-00, hdrtype=0x00, mfdev=0
	cmdreg=0x0000, statreg=0x0200, cachelnsz=0 (dwords)
	lattimer=0x00 (0 ns), mingnt=0x00 (0 ns), maxlat=0x00 (0 ns)
	map[10]: type 4, range 32, base 00001c00, size  8, enabled
	map[14]: type 1, range 32, base e0004000, size 12, enabled
pcib0: matched entry for 0.18.INTA (source \\_SB_.PCI0.ISA_.LNKB)
pcib0: slot 18 INTA is routed to irq 11
found->	vendor=0x100b, dev=0x0020, revid=0x00
	bus=0, slot=18, func=0
	class=02-00-00, hdrtype=0x00, mfdev=0
	cmdreg=0x0003, statreg=0x0290, cachelnsz=0 (dwords)
	lattimer=0x5a (2700 ns), mingnt=0x0b (2750 ns), maxlat=0x34 (13000 ns)
	intpin=a, irq=11
	powerspec 2  supports D0 D1 D2 D3  current D0
agp0: <Ali Generic host to PCI bridge> mem 0xf0000000-0xf7ffffff at device 0.0 on pci0
agp0: allocating GATT for aperture of size 128M
pcib1: <ACPI PCI-PCI bridge> at device 1.0 on pci0
pcib1:   secondary bus     1
pcib1:   subordinate bus   1
pcib1:   I/O decode        0x9000-0x9fff
pcib1:   memory decode     0xe0100000-0xe01fffff
pcib1:   prefetched decode 0xe8000000-0xefffffff
pcib1: could not get PCI interrupt routing table for \\_SB_.PCI0.AGPB - AE_NOT_FOUND
pci1: <ACPI PCI bus> on pcib1
pci1: physical bus=1
	map[10]: type 3, range 32, base e8000000, size 27, enabled
	map[14]: type 4, range 32, base 00009000, size  8, enabled
	map[18]: type 1, range 32, base e0100000, size 16, enabled
found->	vendor=0x1002, dev=0x4c59, revid=0x00
	bus=1, slot=0, func=0
	class=03-00-00, hdrtype=0x00, mfdev=0
	cmdreg=0x0283, statreg=0x02b0, cachelnsz=8 (dwords)
	lattimer=0x42 (1980 ns), mingnt=0x08 (2000 ns), maxlat=0x00 (0 ns)
	intpin=a, irq=9
	powerspec 2  supports D0 D1 D2 D3  current D0
pci1: <display, VGA> at device 0.0 (no driver attached)
ohci0: <AcerLabs M5237 (Aladdin-V) USB controller> mem 0xe0000000-0xe0000fff irq 10 at device 2.0 on pci0
usb0: OHCI version 1.0, legacy support
usb0: SMM does not respond, resetting
usb0: <AcerLabs M5237 (Aladdin-V) USB controller> on ohci0
usb0: USB revision 1.0
uhub0: AcerLabs OHCI root hub, class 9/0, rev 1.00/1.00, addr 1
uhub0: 3 ports with 3 removable, self powered
pcm0: <Acer Labs M5451> port 0x1000-0x10ff mem 0xe0001000-0xe0001fff irq 5 at device 6.0 on pci0
pcm0: <Conexant CX20468 AC97 Codec (id = 0x43585429)>
pcm0: Codec features reserved, headphone, 18 bit DAC, 18 bit ADC, 5 bit master volume, no 3D Stereo Enhancement
pcm0: Primary codec extended features variable rate PCM, AMAP
pcm0: sndbuf_setmap 26f000, 1000; 0xc47bb000 -> 26f000
pcm0: sndbuf_setmap 24c000, 1000; 0xc47b8000 -> 24c000
pcm0: sndbuf_setmap 300000, 1000; 0xc47cc000 -> 300000
pcm0: sndbuf_setmap 2fe000, 1000; 0xc47ca000 -> 2fe000
pcm0: sndbuf_setmap 29c000, 1000; 0xc47c8000 -> 29c000
isab0: <PCI-ISA bridge> at device 7.0 on pci0
isa0: <ISA bus> on isab0
pci0: <simple comms> at device 8.0 (no driver attached)
wi0: <Intersil Prism2.5> mem 0xe0005000-0xe0005fff at device 9.0 on pci0
pcib0: matched entry for 0.9.INTA (source \\_SB_.PCI0.ISA_.LNKD)
pcib0: device has no interrupts
wi0: No irq?!
device_probe_and_attach: wi0 attach returned 6
cbb0: <TI1520 PCI-CardBus Bridge> at device 10.0 on pci0
cardbus0: <CardBus bus> on cbb0
pccard0: <16-bit PCCard bus> on cbb0
pcib0: matched entry for 0.10.INTA (source \\_SB_.PCI0.ISA_.LNKF)
pcib0: device has no interrupts
cbb: Unable to map IRQ...
device_probe_and_attach: cbb0 attach returned 12
cbb0: <TI1520 PCI-CardBus Bridge> at device 10.1 on pci0
cardbus1: <CardBus bus> on cbb0
pccard1: <16-bit PCCard bus> on cbb0
pcib0: matched entry for 0.10.INTA (source \\_SB_.PCI0.ISA_.LNKF)
pcib0: device has no interrupts
cbb: Unable to map IRQ...
device_probe_and_attach: cbb0 attach returned 12
ohci1: <AcerLabs M5237 (Aladdin-V) USB controller> mem 0xe0003000-0xe0003fff irq 10 at device 15.0 on pci0
usb1: OHCI version 1.0, legacy support
usb1: SMM does not respond, resetting
usb1: <AcerLabs M5237 (Aladdin-V) USB controller> on ohci1
usb1: USB revision 1.0
uhub1: AcerLabs OHCI root hub, class 9/0, rev 1.00/1.00, addr 1
uhub1: 3 ports with 3 removable, self powered
atapci0: <AcerLabs Aladdin UDMA100 controller> port 0x1800-0x180f at device 16.0 on pci0
ata0: reset tp1 mask=03 ostat0=50 ostat1=00
ata0-master: stat=0x50 err=0x01 lsb=0x00 msb=0x00
ata0-slave:  stat=0x00 err=0x01 lsb=0x00 msb=0x00
ata0: reset tp2 mask=03 stat0=50 stat1=00 devices=0x1<ATA_MASTER>
ata0: at 0x1f0 irq 14 on atapci0
ata0: [MPSAFE]
ata1: reset tp1 mask=03 ostat0=51 ostat1=00
ata1-master: stat=0x10 err=0x01 lsb=0x14 msb=0xeb
ata1-slave:  stat=0x01 err=0x01 lsb=0x00 msb=0x00
ata1: reset tp2 mask=03 stat0=10 stat1=01 devices=0x4<ATAPI_MASTER>
ata1: at 0x170 irq 15 on atapci0
ata1: [MPSAFE]
pci0: <bridge, PCI-unknown> at device 17.0 (no driver attached)
sis0: <NatSemi DP8381[56] 10/100BaseTX> port 0x1c00-0x1cff mem 0xe0004000-0xe0004fff irq 11 at device 18.0 on pci0
sis0: Silicon Revision: DP83815D
sis0: Ethernet address: 00:c0:9f:0d:4f:58
miibus0: <MII bus> on sis0
ukphy0: <Generic IEEE 802.3u media interface> on miibus0
ukphy0: OUI 0x080017, model 0x0002, rev. 1
ukphy0:  10baseT, 10baseT-FDX, 100baseTX, 100baseTX-FDX, auto
sis0: bpf attached
acpi_button0: <Power Button> on acpi0
acpi_lid0: <Control Method Lid Switch> on acpi0
acpi_acad0: <AC Adapter> on acpi0
acpi_cmbat0: <Control Method Battery> on acpi0
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
atkbdc0: <Keyboard controller (i8042)> port 0x64,0x60 irq 1 on acpi0
atkbd0: <AT Keyboard> flags 0x1 irq 1 on atkbdc0
atkbd: the current kbd controller command byte 0047
atkbd: keyboard ID 0x41ab (2)
kbd0 at atkbd0
kbd0: atkbd0, AT 101/102 (2), config:0x1, flags:0x1d0000
psm0: unable to allocate IRQ
psmcpnp0 irq 12 on acpi0
psm0: current command byte:0047
psm0: <PS/2 Mouse> irq 12 on atkbdc0
psm0: model IntelliMouse, device ID 3-00, 3 buttons
psm0: config:00000000, flags:00000000, packet size:4
psm0: syncmask:08, syncbits:08
acpi_ec0: <Embedded Controller: GPE 0x18> port 0x66,0x62 on acpi0
acpi_ec0: info: new max delay is 3 us
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
unknown: not probed (disabled)
sio0: irq maps: 0x201 0x209 0x201 0x201
sio0 port 0x2f8-0x2ff irq 3 drq 0 on acpi0
sio0: type 16550A
unknown: not probed (disabled)
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
unknown: not probed (disabled)
unknown: not probed (disabled)
ata: ata0 already exists; skipping it
ata: ata1 already exists; skipping it
atkbdc: atkbdc0 already exists; skipping it
sio: sio0 already exists; skipping it
Trying Read_Port at 203
Trying Read_Port at 243
Trying Read_Port at 283
Trying Read_Port at 2c3
Trying Read_Port at 303
Trying Read_Port at 343
Trying Read_Port at 383
Trying Read_Port at 3c3
sc: sc0 already exists; skipping it
vga: vga0 already exists; skipping it
isa_probe_children: disabling PnP devices
isa_probe_children: probing non-PnP devices
orm0: <Option ROMs> at iomem 0xe4000-0xe4fff,0xe0000-0xe3fff,0xcf000-0xcffff,0xc0000-0xcefff on isa0
pmtimer0 on isa0
adv0: not probed (disabled)
aha0: not probed (disabled)
aic0: not probed (disabled)
bt0: not probed (disabled)
cs0: not probed (disabled)
ed0: not probed (disabled)
fdc0 failed to probe at port 0x3f0 irq 6 drq 2 on isa0
fe0: not probed (disabled)
ie0: not probed (disabled)
le0: not probed (disabled)
lnc0: not probed (disabled)
pcic0 failed to probe at port 0x3e0 iomem 0xd0000 on isa0
pcic1: not probed (disabled)
ppc0 failed to probe at irq 7 on isa0
sc0: <System console> at flags 0x100 on isa0
sc0: VGA <16 virtual consoles, flags=0x300>
sc0: fb0, kbd0, terminal emulator: sc (syscons terminal)
sio1 failed to probe at port 0x2f8 irq 3 on isa0
sio2: not probed (disabled)
sio3: not probed (disabled)
sn0: not probed (disabled)
vga0: <Generic ISA VGA> at port 0x3c0-0x3df iomem 0xa0000-0xbffff on isa0
fb0: vga0, vga, type:VGA (5), flags:0x7007f
fb0: port:0x3c0-0x3df, crtc:0x3d4, mem:0xa0000 0x20000
fb0: init mode:24, bios mode:3, current mode:24
fb0: window:0xc00b8000 size:32k gran:32k, buf:0 size:32k
vga0: vga: WARNING: video mode switching is not fully supported on this adapter
VGA parameters upon power-up
50 18 10 00 00 00 03 00 02 e7 a3 4f 67 8f 6a 1b
24 b3 00 6f 0d 0e 00 00 07 80 49 8f 8f 28 1f 47
6d a3 ff 00 01 02 03 04 05 14 07 38 39 3a 3b 3c
3d 3e 3f 0c 00 0f 08 00 00 00 00 00 10 0e 00 ff
VGA parameters in BIOS for mode 24
50 18 10 00 10 00 03 00 02 67 5f 4f 50 82 55 81
bf 1f 00 4f 0d 0e 00 00 00 00 9c 8e 8f 28 1f 96
b9 a3 ff 00 01 02 03 04 05 14 07 38 39 3a 3b 3c
3d 3e 3f 0c 00 0f 08 00 00 00 00 00 10 0e 00 ff
EGA/VGA parameters to be used for mode 24
50 18 10 00 00 00 03 00 02 e7 a3 4f 67 8f 6a 1b
24 b3 00 6f 0d 0e 00 00 07 80 49 8f 8f 28 1f 47
6d a3 ff 00 01 02 03 04 05 14 07 38 39 3a 3b 3c
3d 3e 3f 0c 00 0f 08 00 00 00 00 00 10 0e 00 ff
vt0: not probed (disabled)
isa_probe_children: probing PnP devices
Device configuration finished.
procfs registered
Timecounter "TSC" frequency 1640070132 Hz quality 800
Timecounters tick every 10.000 msec
lo0: bpf attached
acpi_ec0: info: new max delay is 229 us
acpi_acad0: acline initialization start
acpi_ec0: info: new max delay is 560 us
acpi_acad0: On Line
acpi_acad0: acline initialization done, tried 1 times
acpi_cmbat0: battery initialization start
ata0-master: pio=0x0c wdma=0x22 udma=0x45 cable=80pin
ata0-master: setting PIO4 on AcerLabs Aladdin chip
acpi_lid0: Lid closed
acpi0: Sleep state S1 not supported by BIOS
ata0-master: setting UDMA100 on AcerLabs Aladdin chip
GEOM: create disk ad0 dp=0xc489c260
ad0: <IC25N040ATCS04-0/CA4OA71A> ATA-5 disk at ata0-master
ad0: 38154MB (78140160 sectors), 77520 C, 16 H, 63 S, 512 B
ad0: 16 secs/int, 1 depth queue, UDMA100
GEOM: new disk ad0
ata1-master: pio=0x0c wdma=0x22 udma=0x42 cable=40pin
ata1-master: setting PIO4 on AcerLabs Aladdin chip
acd0: <QSI CD-RW/DVD-ROM SBW-081/NH02> CDRW drive at ata1 as master
acd0: read 4125KB/s (4125KB/s) write 1378KB/s (1378KB/s), 2048KB buffer, PIO4
acd0: Reads: CDR, CDRW, CDDA stream, DVDROM, DVDR, packet
acd0: Writes: CDR, CDRW, test write, burnproof
acd0: Audio: play, 256 volume levels
acd0: Mechanism: ejectable tray, unlocked
acd0: Medium: no/blank disc
[0] f:00 typ:4 s(CHS):0/1/1 e(CHS):2/254/63 s:63 l:48132
[1] f:00 typ:7 s(CHS):3/0/1 e(CHS):1023/254/63 s:48195 l:40965750
[2] f:80 typ:165 s(CHS):1023/255/63 e(CHS):1023/254/63 s:41013945 l:37126215
[3] f:00 typ:0 s(CHS):0/0/0 e(CHS):0/0/0 s:0 l:0
GEOM: Configure ad0s1, start 32256 length 24643584 end 24675839
GEOM: Configure ad0s2, start 24675840 length 20974464000 end 20999139839
GEOM: Configure ad0s3, start 20999139840 length 19008622080 end 40007761919
GEOM: Configure ad0s3a, start 0 length 268435456 end 268435455
GEOM: Configure ad0s3b, start 268435456 length 1053597696 end 1322033151
GEOM: Configure ad0s3c, start 0 length 19008622080 end 19008622079
GEOM: Configure ad0s3d, start 1322033152 length 268435456 end 1590468607
GEOM: Configure ad0s3e, start 1590468608 length 268435456 end 1858904063
GEOM: Configure ad0s3f, start 1858904064 length 17149718016 end 19008622079
acpi_ec0: info: new max delay is 11000 us
Mounting root from ufs:/dev/ad0s3a

/*
 * Intel ACPI Component Architecture
 * AML Disassembler version 20030619
 *
 * Disassembly of /tmp/acpidump.Qz02H4, Mon May 31 14:54:11 2004
 */
DefinitionBlock ("DSDT.aml", "DSDT", 1, "ALI", "M1533", 100925440)
{
    Name (GPIC, 0x00)
    Method (\PIC, 1, NotSerialized)
    {
        Store (Arg0, GPIC)
    }

    OperationRegion (DBG, SystemIO, 0x80, 0x01)
    Field (DBG, ByteAcc, NoLock, Preserve)
    {
        P80H,   8
    }

    OperationRegion (PMIO, SystemIO, 0x8000, 0x30)
    Field (PMIO, ByteAcc, NoLock, Preserve)
    {
        PMS1,   16,
        PME1,   16,
        PMC1,   16,
        Offset (0x10),
            ,   1,
        TRDC,   3,
        TREN,   1
    }

    Name (\_S0, Package (0x02)
    {
        0x00,
        0x00
    })
    Name (\_S3, Package (0x02)
    {
        0x03,
        0x03
    })
    Name (\_S4, Package (0x02)
    {
        0x04,
        0x04
    })
    Name (\_S5, Package (0x02)
    {
        0x05,
        0x05
    })
    Scope (\_PR)
    {
        Processor (CPU0, 0x01, 0x00008010, 0x06)
        {
            Method (_CST, 0, NotSerialized)
            {
                If (\_SB.PCI0.ISA.HPCI.Z000)
                {
                    Return (Package (0x04)
                    {
                        0x03,
                        Package (0x04)
                        {
                            Buffer (0x11)
                            {
                                0x82, 0x0C, 0x00, 0x7F, 0x08, 0x00, 0x00, 0x00,
                                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x79,
                                0x00
                            },

                            0x01,
                            0x01,
                            0x03E8
                        },

                        Package (0x04)
                        {
                            Buffer (0x11)
                            {
                                0x82, 0x0C, 0x00, 0x01, 0x08, 0x00, 0x00, 0x14,
                                0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x79,
                                0x00
                            },

                            0x02,
                            0x63,
                            0x01F4
                        },

                        Package (0x04)
                        {
                            Buffer (0x11)
                            {
                                0x82, 0x0C, 0x00, 0x01, 0x08, 0x00, 0x00, 0x15,
                                0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x79,
                                0x00
                            },

                            0x03,
                            0x0120,
                            0xFA
                        }
                    })
                }
                Else
                {
                    Return (Package (0x03)
                    {
                        0x02,
                        Package (0x04)
                        {
                            Buffer (0x11)
                            {
                                0x82, 0x0C, 0x00, 0x7F, 0x08, 0x00, 0x00, 0x00,
                                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x79,
                                0x00
                            },

                            0x01,
                            0x01,
                            0x03E8
                        },

                        Package (0x04)
                        {
                            Buffer (0x11)
                            {
                                0x82, 0x0C, 0x00, 0x01, 0x08, 0x00, 0x00, 0x14,
                                0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x79,
                                0x00
                            },

                            0x02,
                            0x63,
                            0x01F4
                        }
                    })
                }
            }

            Name (XPCT, Package (0x02)
            {
                Buffer (0x11)
                {
                    0x82, 0x0C, 0x00, 0x01, 0x08, 0x00, 0x00, 0xB1,
                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x79,
                    0x00
                },

                Buffer (0x11)
                {
                    0x82, 0x0C, 0x00, 0x01, 0x08, 0x00, 0x00, 0xB3,
                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x79,
                    0x00
                }
            })
            Name (XPSS, Package (0x02)
            {
                Package (0x06)
                {
                    0x270F,
                    0x0001869F,
                    0x03E7,
                    0x03E7,
                    0x99,
                    0x99
                },

                Package (0x06)
                {
                    0x270F,
                    0x0001869F,
                    0x03E7,
                    0x03E7,
                    0x99,
                    0x99
                }
            })
            Method (XPPC, 0, NotSerialized)
            {
                Return (0x00)
            }
        }
    }

    Method (VTOB, 1, NotSerialized)
    {
        Store (0x01, Local0)
        ShiftLeft (Local0, Arg0, Local0)
        Return (Local0)
    }

    Method (BTOV, 1, NotSerialized)
    {
        ShiftRight (Arg0, 0x01, Local0)
        Store (0x00, Local1)
        While (Local0)
        {
            Increment (Local1)
            ShiftRight (Local0, 0x01, Local0)
        }

        Return (Local1)
    }

    Method (MKWD, 2, NotSerialized)
    {
        If (And (Arg1, 0x80))
        {
            Store (0xFFFF0000, Local0)
        }
        Else
        {
            Store (Zero, Local0)
        }

        Or (Local0, Arg0, Local0)
        Or (Local0, ShiftLeft (Arg1, 0x08), Local0)
        Return (Local0)
    }

    Method (GBFE, 3, NotSerialized)
    {
        CreateByteField (Arg0, Arg1, TIDX)
        Store (TIDX, Arg2)
    }

    Method (PBFE, 3, NotSerialized)
    {
        CreateByteField (Arg0, Arg1, TIDX)
        Store (Arg2, TIDX)
    }

    Method (ITOS, 1, NotSerialized)
    {
        Store (Buffer (0x09)
            {
                0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                0x00
            }, Local0)
        Store (Buffer (0x11)
            {
                "0123456789ABCDEF"
            }, Local7)
        Store (0x08, Local1)
        Store (0x00, Local2)
        Store (0x00, Local3)
        While (Local1)
        {
            Decrement (Local1)
            And (ShiftRight (Arg0, ShiftLeft (Local1, 0x02)), 0x0F, Local4)
            If (Local4)
            {
                Store (Ones, Local3)
            }

            If (Local3)
            {
                GBFE (Local7, Local4, RefOf (Local5))
                PBFE (Local0, Local2, Local5)
                Increment (Local2)
            }
        }

        Return (Local0)
    }

    Scope (\_SB)
    {
        Name (ECEN, 0x00)
        Name (KT6F, 0x00)
        Name (WLMF, 0x00)
        Name (ACCG, 0x00)
        Name (PRCT, 0x00)
        Name (S4WF, 0x00)
        Method (ECOK, 0, NotSerialized)
        {
            If (ECEN)
            {
                Return (0x01)
            }
            Else
            {
                Return (0x00)
            }
        }

        Method (_INI, 0, NotSerialized)
        {
            Store (\_SB.PCI0.PMU.PDID, KT6F)
            Store (\_SB.PCI0.ISA.CPTY, WLMF)
            If (KT6F)
            {
                If (WLMF)
                {
                    Store (\_TZ.TPW0, \_TZ.TPA0)
                    Store (\_TZ.TPW1, \_TZ.TPA1)
                    Store (\_TZ.TPW2, \_TZ.TPA2)
                    Store (\_TZ.TPW3, \_TZ.TPA3)
                    Store (\_TZ.TPWC, \_TZ.TPAC)
                }
                Else
                {
                    Store (\_TZ.TPN0, \_TZ.TPA0)
                    Store (\_TZ.TPN1, \_TZ.TPA1)
                    Store (\_TZ.TPN2, \_TZ.TPA2)
                    Store (\_TZ.TPN3, \_TZ.TPA3)
                    Store (\_TZ.TPNC, \_TZ.TPAC)
                }
            }

            If (CondRefOf (_OSI, Local0))
            {
                If (\_OSI ("Windows 2001"))
                {
                    Store (0x04, \_SB.PCI0.ISA.TOOS)
                }
            }
            Else
            {
                Store (SizeOf (\_OS), Local0)
                If (LEqual (Local0, 0x14))
                {
                    Store (0x03, \_SB.PCI0.ISA.TOOS)
                }

                If (LEqual (Local0, 0x26))
                {
                    Store (0x02, \_SB.PCI0.ISA.TOOS)
                }

                If (LEqual (Local0, 0x11))
                {
                    Store (0x01, \_SB.PCI0.ISA.TOOS)
                }
            }
        }

        Device (PCI0)
        {
            Name (_PRW, Package (0x02)
            {
                0x09,
                0x05
            })
            Name (_PRT, Package (0x0A)
            {
                Package (0x04)
                {
                    0x0001FFFF,
                    0x00,
                    \_SB.PCI0.ISA.LNKA,
                    0x00
                },

                Package (0x04)
                {
                    0x0002FFFF,
                    0x00,
                    \_SB.PCI0.ISA.LNKU,
                    0x00
                },

                Package (0x04)
                {
                    0x000FFFFF,
                    0x00,
                    \_SB.PCI0.ISA.LNKE,
                    0x00
                },

                Package (0x04)
                {
                    0x0008FFFF,
                    0x00,
                    \_SB.PCI0.ISA.LNKG,
                    0x00
                },

                Package (0x04)
                {
                    0x0006FFFF,
                    0x00,
                    \_SB.PCI0.ISA.LNKH,
                    0x00
                },

                Package (0x04)
                {
                    0x0012FFFF,
                    0x00,
                    \_SB.PCI0.ISA.LNKB,
                    0x00
                },

                Package (0x04)
                {
                    0x0009FFFF,
                    0x00,
                    \_SB.PCI0.ISA.LNKD,
                    0x00
                },

                Package (0x04)
                {
                    0x0009FFFF,
                    0x01,
                    \_SB.PCI0.ISA.LNKC,
                    0x00
                },

                Package (0x04)
                {
                    0x000CFFFF,
                    0x00,
                    \_SB.PCI0.ISA.LNKC,
                    0x00
                },

                Package (0x04)
                {
                    0x000AFFFF,
                    0x00,
                    \_SB.PCI0.ISA.LNKF,
                    0x00
                }
            })
            Name (_HID, EisaId ("PNP0A03"))
            Name (_ADR, 0x00)
            Name (_BBN, 0x00)
            OperationRegion (REGS, PCI_Config, 0x90, 0x70)
            Field (REGS, ByteAcc, NoLock, Preserve)
            {
                SR90,   8,
                SR91,   8,
                SR92,   8,
                SR93,   8,
                Offset (0x6E),
                SRFE,   8,
                SRFF,   8
            }

            Name (RSRC, Buffer (0x01B7)
            {
                0x88, 0x0E, 0x00, 0x02, 0x0E, 0x00, 0x00, 0x00,
                0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x01,
                0x00, 0x87, 0x18, 0x00, 0x00, 0x0E, 0x01, 0x00,
                0x00, 0x00, 0x00, 0x00, 0x00, 0x0A, 0x00, 0xFF,
                0xFF, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                0x00, 0x02, 0x00, 0x00, 0x87, 0x18, 0x00, 0x00,
                0x0E, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                0x0C, 0x00, 0xFF, 0x3F, 0x0C, 0x00, 0x00, 0x00,
                0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x87,
                0x18, 0x00, 0x00, 0x0E, 0x01, 0x00, 0x00, 0x00,
                0x00, 0x00, 0x40, 0x0C, 0x00, 0xFF, 0x7F, 0x0C,
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00,
                0x00, 0x00, 0x87, 0x18, 0x00, 0x00, 0x0E, 0x01,
                0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x0C, 0x00,
                0xFF, 0xBF, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00,
                0x00, 0x40, 0x00, 0x00, 0x00, 0x87, 0x18, 0x00,
                0x00, 0x0E, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
                0xC0, 0x0C, 0x00, 0xFF, 0xFF, 0x0C, 0x00, 0x00,
                0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
                0x87, 0x18, 0x00, 0x00, 0x0E, 0x01, 0x00, 0x00,
                0x00, 0x00, 0x00, 0x00, 0x0D, 0x00, 0xFF, 0x3F,
                0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40,
                0x00, 0x00, 0x00, 0x87, 0x18, 0x00, 0x00, 0x0E,
                0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x0D,
                0x00, 0xFF, 0x7F, 0x0D, 0x00, 0x00, 0x00, 0x00,
                0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x87, 0x18,
                0x00, 0x00, 0x0E, 0x01, 0x00, 0x00, 0x00, 0x00,
                0x00, 0x80, 0x0D, 0x00, 0xFF, 0xBF, 0x0D, 0x00,
                0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00,
                0x00, 0x87, 0x18, 0x00, 0x00, 0x0E, 0x01, 0x00,
                0x00, 0x00, 0x00, 0x00, 0xC0, 0x0D, 0x00, 0xFF,
                0xFF, 0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                0x40, 0x00, 0x00, 0x00, 0x87, 0x18, 0x00, 0x00,
                0x0E, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                0x0E, 0x00, 0xFF, 0x3F, 0x0E, 0x00, 0x00, 0x00,
                0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x87,
                0x18, 0x00, 0x00, 0x0E, 0x01, 0x00, 0x00, 0x00,
                0x00, 0x00, 0x40, 0x0E, 0x00, 0xFF, 0x7F, 0x0E,
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00,
                0x00, 0x00, 0x87, 0x18, 0x00, 0x00, 0x0E, 0x01,
                0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x0E, 0x00,
                0xFF, 0xBF, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00,
                0x00, 0x40, 0x00, 0x00, 0x00, 0x87, 0x18, 0x00,
                0x00, 0x0E, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
                0xC0, 0x0E, 0x00, 0xFF, 0xFF, 0x0E, 0x00, 0x00,
                0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
                0x87, 0x18, 0x00, 0x00, 0x0E, 0x01, 0x00, 0x00,
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF,
                0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                0x00, 0x00, 0x00, 0x47, 0x01, 0xF8, 0x0C, 0xF8,
                0x0C, 0x01, 0x08, 0x88, 0x0E, 0x00, 0x01, 0x0C,
                0x03, 0x00, 0x00, 0x00, 0x00, 0xF7, 0x0C, 0x00,
                0x00, 0xF8, 0x0C, 0x00, 0x88, 0x0E, 0x00, 0x01,
                0x0C, 0x03, 0x00, 0x00, 0x00, 0x0D, 0xFF, 0xFF,
                0x00, 0x00, 0x00, 0xF3, 0x00, 0x79, 0x00
            })
            Method (_CRS, 0, Serialized)
            {
                CreateBitField (RSRC, 0x0188, C0RW)
                CreateDWordField (RSRC, 0x42, C0LN)
                Store (One, C0RW)
                Store (0x4000, C0LN)
                If (And (SR90, 0x01))
                {
                    Store (0x00, C0LN)
                }

                CreateBitField (RSRC, 0x0260, C4RW)
                CreateDWordField (RSRC, 0x5D, C4LN)
                Store (One, C4RW)
                Store (0x4000, C4LN)
                If (And (SR90, 0x04))
                {
                    Store (0x00, C4LN)
                }

                CreateBitField (RSRC, 0x0338, C8RW)
                CreateDWordField (RSRC, 0x78, C8LN)
                Store (One, C8RW)
                Store (0x4000, C8LN)
                If (And (SR90, 0x10))
                {
                    Store (0x00, C8LN)
                }

                CreateBitField (RSRC, 0x0410, CCRW)
                CreateDWordField (RSRC, 0x93, CCLN)
                Store (One, CCRW)
                Store (0x4000, CCLN)
                If (And (SR90, 0x40))
                {
                    Store (0x00, CCLN)
                }

                CreateBitField (RSRC, 0x04E8, D0RW)
                CreateDWordField (RSRC, 0xAE, D0LN)
                Store (One, D0RW)
                Store (0x4000, D0LN)
                If (And (SR91, 0x01))
                {
                    Store (0x00, D0LN)
                }

                CreateBitField (RSRC, 0x05C0, D4RW)
                CreateDWordField (RSRC, 0xC9, D4LN)
                Store (One, D4RW)
                Store (0x4000, D4LN)
                If (And (SR91, 0x04))
                {
                    Store (0x00, D4LN)
                }

                CreateBitField (RSRC, 0x0698, D8RW)
                CreateDWordField (RSRC, 0xE4, D8LN)
                Store (One, D8RW)
                Store (0x4000, D8LN)
                If (And (SR91, 0x10))
                {
                    Store (0x00, D8LN)
                }

                CreateBitField (RSRC, 0x0770, DCRW)
                CreateDWordField (RSRC, 0xFF, DCLN)
                Store (One, DCRW)
                Store (0x4000, DCLN)
                If (And (SR91, 0x40))
                {
                    Store (0x00, DCLN)
                }

                CreateBitField (RSRC, 0x0848, E0RW)
                CreateDWordField (RSRC, 0x011A, E0LN)
                Store (One, E0RW)
                Store (0x4000, E0LN)
                If (And (SR92, 0x01))
                {
                    Store (0x00, E0LN)
                }

                CreateBitField (RSRC, 0x0920, E4RW)
                CreateDWordField (RSRC, 0x0135, E4LN)
                Store (One, E4RW)
                Store (0x4000, E4LN)
                If (And (SR92, 0x04))
                {
                    Store (0x00, E4LN)
                }

                CreateBitField (RSRC, 0x09F8, E8RW)
                CreateDWordField (RSRC, 0x0150, E8LN)
                Store (One, E8RW)
                Store (0x4000, E8LN)
                If (And (SR92, 0x10))
                {
                    Store (0x00, E8LN)
                }

                CreateBitField (RSRC, 0x0AD0, ECRW)
                CreateDWordField (RSRC, 0x016B, ECLN)
                Store (One, ECRW)
                Store (0x4000, ECLN)
                If (And (SR92, 0x40))
                {
                    Store (0x00, ECLN)
                }

                CreateDWordField (RSRC, 0x017A, BTMN)
                CreateDWordField (RSRC, 0x0186, BTLN)
                Multiply (SRFE, 0x00100000, Local0)
                Multiply (SRFF, 0x10000000, Local1)
                Add (Local0, Local1, BTMN)
                Add (Not (BTMN), 0x01, BTLN)
                Return (RSRC)
            }

            Device (AGPB)
            {
                Name (_ADR, 0x00010000)
                Device (VGA)
                {
                    Name (_ADR, 0x00)
                    Method (_STA, 0, NotSerialized)
                    {
                        Return (0x0F)
                    }

                    Name (_PSC, 0x00)
                    Method (_PS0, 0, NotSerialized)
                    {
                        Store (0x00, _PSC)
                    }

                    Method (_PS1, 0, NotSerialized)
                    {
                        Store (0x01, _PSC)
                    }

                    Method (_PS2, 0, NotSerialized)
                    {
                        Store (0x02, _PSC)
                    }

                    Method (_PS3, 0, NotSerialized)
                    {
                        Store (0x03, _PSC)
                    }

                    Name (DISW, 0x01)
                    Name (NDSP, 0x00)
                    Name (VRSM, 0x00)
                    Name (TGLT, Package (0x04)
                    {
                        Package (0x08)
                        {
                            0x01,
                            0x01,
                            0x01,
                            0x01,
                            0x01,
                            0x01,
                            0x01,
                            0x01
                        },

                        Package (0x08)
                        {
                            0x01,
                            0x02,
                            0x03,
                            0x01,
                            0x01,
                            0x01,
                            0x01,
                            0x01
                        },

                        Package (0x08)
                        {
                            0x01,
                            0x01,
                            0x01,
                            0x01,
                            0x01,
                            0x01,
                            0x01,
                            0x01
                        },

                        Package (0x08)
                        {
                            0x01,
                            0x02,
                            0x03,
                            0x01,
                            0x01,
                            0x01,
                            0x01,
                            0x01
                        }
                    })
                    Name (TGLP, 0x00)
                    Method (NDGS, 0, NotSerialized)
                    {
                        And (^LCD._DGS, 0x01, Local0)
                        Or (Local0, ShiftLeft (And (^CRT._DGS, 0x01), 0x01), Local0)
                        Or (Local0, ShiftLeft (And (^TV._DGS, 0x01), 0x02), Local0)
                        Store (DerefOf (Index (DerefOf (Index (TGLT, TGLP)), Local0)), Local1)
                        And (Local1, 0x01, ^LCD._DGS)
                        ShiftRight (And (Local1, 0x02), 0x01, ^CRT._DGS)
                        ShiftRight (And (Local1, 0x04), 0x02, ^TV._DGS)
                    }

                    Method (USTS, 1, NotSerialized)
                    {
                        Store (\_SB.PCI0.ISA.HPSS (0x0F, 0x00), Local0)
                        And (Local0, 0x0F, Local1)
                        If (LEqual (Local1, 0x03))
                        {
                            Store (0x01, TGLP)
                        }
                        Else
                        {
                            If (LEqual (Local1, 0x05))
                            {
                                Store (0x02, TGLP)
                            }
                            Else
                            {
                                If (LEqual (Local1, 0x07))
                                {
                                    Store (0x03, TGLP)
                                }
                                Else
                                {
                                    Store (0x00, TGLP)
                                }
                            }
                        }

                        Return (Local0)
                    }

                    Method (_INI, 0, NotSerialized)
                    {
                        Store (USTS (0x00), Local1)
                        Or (ShiftRight (And (Local1, 0x10), 0x03), 0x1D, ^LCD._DCS)
                        Or (Or (ShiftLeft (And (Local1, 0x02), 0x03), ShiftRight (And (Local1, 0x20), 0x04)), 0x0D, ^CRT._DCS)
                        Or (Or (ShiftLeft (And (Local1, 0x04), 0x02), ShiftRight (And (Local1, 0x40), 0x05)), 0x0D, ^TV._DCS)
                        ShiftRight (Local1, 0x04, NDSP)
                        Store (ShiftRight (And (^LCD._DCS, 0x02), 0x01), ^LCD._DGS)
                        Store (ShiftRight (And (^CRT._DCS, 0x02), 0x01), ^CRT._DGS)
                        Store (ShiftRight (And (^TV._DCS, 0x02), 0x01), ^TV._DGS)
                        NDGS ()
                    }

                    Method (_DOS, 1, NotSerialized)
                    {
                        If (LAnd (LEqual (And (Arg0, 0x03), 0x00), LEqual (And (DISW, 0x03), 0x02)))
                        {
                            Notify (\_SB.PCI0.ISA.HPCI, 0x89)
                        }

                        Store (Arg0, DISW)
                    }

                    Method (_DOD, 0, NotSerialized)
                    {
                        Return (Package (0x03)
                        {
                            0x00010100,
                            0x00010110,
                            0x00010200
                        })
                    }

                    Method (DRUL, 1, NotSerialized)
                    {
                        If (LEqual (Arg0, 0x01))
                        {
                            Store (USTS (0x01), Local2)
                        }
                        Else
                        {
                            Store (USTS (0x00), Local2)
                        }

                        Store (^CRT._DCS, Local1)
                        Or (ShiftLeft (And (Local2, 0x02), 0x03), And (^CRT._DCS, 0x0F), ^CRT._DCS)
                        Store (^TV._DCS, Local3)
                        Or (Or (ShiftLeft (And (Local2, 0x04), 0x02), ShiftRight (And (Local2, 0x40), 0x05)), And (Local3, 0x0D), ^TV._DCS)
                        If (LEqual (Arg0, 0x01))
                        {
                            If (LOr (LAnd (^CRT._DGS, LNot (And (^CRT._DCS, 0x10))), LAnd (^TV._DGS, LNot (And (^TV._DCS, 0x10)))))
                            {
                                NDGS ()
                                Return (0x00)
                            }
                            Else
                            {
                                Notify (VGA, 0x80)
                                Return (0x00)
                            }
                        }

                        If (LEqual (Arg0, 0x02))
                        {
                            If (And (Local2, 0x02))
                            {
                                Store (0x01, ^CRT._DGS)
                                If (\_SB.PCI0.ISA.DISB)
                                {
                                    Store (0x01, ^LCD._DGS)
                                }
                                Else
                                {
                                    Store (0x00, ^LCD._DGS)
                                }

                                Store ("CRT Connected VGA.DRUL(2) called", Debug)
                            }
                            Else
                            {
                                Store (0x00, ^CRT._DGS)
                                Store (0x01, ^LCD._DGS)
                                Store ("CRT DisConnected VGA.DRUL(2) called", Debug)
                            }

                            Notify (VGA, 0x80)
                        }

                        If (LEqual (Arg0, 0x04))
                        {
                            Store (0x00, ^CRT._DGS)
                            Store (0x01, ^LCD._DGS)
                            Notify (VGA, 0x80)
                        }

                        If (LEqual (Arg0, 0x03))
                        {
                            If (LNot (LEqual (ShiftRight (And (Local1, 0x10), 0x03), And (Local2, 0x02))))
                            {
                                If (And (Local2, 0x02))
                                {
                                    Store (0x01, ^CRT._DGS)
                                    If (\_SB.PCI0.ISA.DISB)
                                    {
                                        Store (0x01, ^LCD._DGS)
                                    }
                                    Else
                                    {
                                        Store (0x00, ^LCD._DGS)
                                    }
                                }
                                Else
                                {
                                    Store (0x00, ^CRT._DGS)
                                    Store (0x01, ^LCD._DGS)
                                }

                                Store ("Resume VGA.DRUL(3) called", Debug)
                                Notify (VGA, 0x80)
                            }
                        }
                    }

                    Device (LCD)
                    {
                        Name (_ADR, 0x0110)
                        Name (_PSC, 0x00)
                        Name (_S3D, 0x03)
                        Method (_PS0, 0, NotSerialized)
                        {
                            If (LAnd (LAnd (VRSM, LNot (^^CRT._PSC)), LNot (^^TV._PSC)))
                            {
                                If (_PSC)
                                {
                                    DRUL (0x03)
                                }

                                Store (0x00, VRSM)
                            }

                            Store (0x00, _PSC)
                        }

                        Method (_PS1, 0, NotSerialized)
                        {
                            Store (0x01, _PSC)
                        }

                        Method (_PS3, 0, NotSerialized)
                        {
                            Store (0x03, _PSC)
                        }

                        Name (_DCS, 0x1B)
                        Method (_DSS, 1, NotSerialized)
                        {
                            Store (Arg0, Local0)
                            If (And (Local0, 0x01))
                            {
                                Store ("LCD._DSS(1) called", Debug)
                                Or (NDSP, 0x01, NDSP)
                            }
                            Else
                            {
                                Store ("LCD._DSS(0) called", Debug)
                                And (NDSP, 0xFE, NDSP)
                            }

                            And (Local0, 0xC0000000, Local0)
                            If (LEqual (Local0, 0x80000000))
                            {
                                Store ("LCD._DSS(8000000x) called", Debug)
                                \_SB.PCI0.ISA.HPSS (0x01, NDSP)
                            }

                            And (Local0, 0x80000000, Local0)
                            If (LNot (LEqual (Local0, 0x00)))
                            {
                                Store ("LCD._DSS, update next _DGS", Debug)
                                Or (And (^^LCD._DCS, 0xFD), ShiftLeft (And (NDSP, 0x01), 0x01), ^^LCD._DCS)
                                Or (And (^^CRT._DCS, 0xFD), And (NDSP, 0x02), ^^CRT._DCS)
                                Or (And (^^TV._DCS, 0xFD), ShiftRight (And (NDSP, 0x04), 0x01), ^^TV._DCS)
                                USTS (0x00)
                                NDGS ()
                            }
                        }

                        Name (_DGS, 0x00)
                    }

                    Device (CRT)
                    {
                        Name (_ADR, 0x0100)
                        Name (_PSC, 0x00)
                        Method (_PS0, 0, NotSerialized)
                        {
                            If (LAnd (LAnd (VRSM, LNot (^^LCD._PSC)), LNot (^^TV._PSC)))
                            {
                                If (_PSC)
                                {
                                    DRUL (0x03)
                                }

                                Store (0x00, VRSM)
                            }

                            Store (0x00, _PSC)
                        }

                        Method (_PS1, 0, NotSerialized)
                        {
                            Store (0x01, _PSC)
                        }

                        Method (_PS3, 0, NotSerialized)
                        {
                            Store (0x03, _PSC)
                        }

                        Name (_DCS, 0x1B)
                        Method (_DSS, 1, NotSerialized)
                        {
                            Store (Arg0, Local0)
                            If (And (Local0, 0x01))
                            {
                                Store ("CRT._DSS(1) called", Debug)
                                Or (NDSP, 0x02, NDSP)
                            }
                            Else
                            {
                                Store ("CRT._DSS(0) called", Debug)
                                And (NDSP, 0xFD, NDSP)
                            }

                            And (Local0, 0xC0000000, Local0)
                            If (LEqual (Local0, 0x80000000))
                            {
                                Store ("CRT._DSS(8000000x) called", Debug)
                                \_SB.PCI0.ISA.HPSS (0x01, NDSP)
                            }

                            And (Local0, 0x80000000, Local0)
                            If (LNot (LEqual (Local0, 0x00)))
                            {
                                Store ("CRT._DSS, update next _DGS", Debug)
                                Or (And (^^LCD._DCS, 0xFD), ShiftLeft (And (NDSP, 0x01), 0x01), ^^LCD._DCS)
                                Or (And (^^CRT._DCS, 0xFD), And (NDSP, 0x02), ^^CRT._DCS)
                                Or (And (^^TV._DCS, 0xFD), ShiftRight (And (NDSP, 0x04), 0x01), ^^TV._DCS)
                                USTS (0x00)
                                NDGS ()
                            }
                        }

                        Name (_DGS, 0x00)
                    }

                    Device (TV)
                    {
                        Name (_ADR, 0x0200)
                        Name (_PSC, 0x00)
                        Method (_PS0, 0, NotSerialized)
                        {
                            If (LAnd (LAnd (VRSM, LNot (^^CRT._PSC)), LNot (^^LCD._PSC)))
                            {
                                If (_PSC)
                                {
                                    DRUL (0x03)
                                }

                                Store (0x00, VRSM)
                            }

                            Store (0x00, _PSC)
                        }

                        Method (_PS1, 0, NotSerialized)
                        {
                            Store (0x01, _PSC)
                        }

                        Method (_PS3, 0, NotSerialized)
                        {
                            Store (0x03, _PSC)
                        }

                        Name (_DCS, 0x1B)
                        Method (_DSS, 1, NotSerialized)
                        {
                            Store (Arg0, Local0)
                            If (And (Local0, 0x01))
                            {
                                Store ("TV_._DSS(1) called", Debug)
                                Or (NDSP, 0x04, NDSP)
                            }
                            Else
                            {
                                Store ("TV_._DSS(0) called", Debug)
                                And (NDSP, 0xFB, NDSP)
                            }

                            And (Local0, 0xC0000000, Local0)
                            If (LEqual (Local0, 0x80000000))
                            {
                                Store ("TV_._DSS(8000000x) called", Debug)
                                \_SB.PCI0.ISA.HPSS (0x01, NDSP)
                            }

                            And (Local0, 0x80000000, Local0)
                            If (LNot (LEqual (Local0, 0x00)))
                            {
                                Store ("TV_._DSS, update next _DGS", Debug)
                                Or (And (^^LCD._DCS, 0xFD), ShiftLeft (And (NDSP, 0x01), 0x01), ^^LCD._DCS)
                                Or (And (^^CRT._DCS, 0xFD), And (NDSP, 0x02), ^^CRT._DCS)
                                Or (And (^^TV._DCS, 0xFD), ShiftRight (And (NDSP, 0x04), 0x01), ^^TV._DCS)
                                USTS (0x00)
                                NDGS ()
                            }
                        }

                        Name (_DGS, 0x00)
                    }
                }
            }

            Device (IDE)
            {
                Name (_ADR, 0x00100000)
                Name (UDMT, Package (0x08)
                {
                    0x1E,
                    0x2D,
                    0x3C,
                    0x5A,
                    0x78,
                    0x78,
                    0x78,
                    0x14
                })
                Name (PIOT, Package (0x05)
                {
                    0x78,
                    0xB4,
                    0xF0,
                    0x017F,
                    0x0258
                })
                Name (PIOC, Package (0x05)
                {
                    0x04,
                    0x06,
                    0x08,
                    0x0D,
                    0x10
                })
                Name (CBCT, Package (0x05)
                {
                    0x31,
                    0x33,
                    0x01,
                    0x03,
                    0x0A
                })
                Name (DACT, Package (0x05)
                {
                    0x03,
                    0x03,
                    0x04,
                    0x05,
                    0x08
                })
                Name (DRCT, Package (0x05)
                {
                    0x01,
                    0x03,
                    0x04,
                    0x08,
                    0x08
                })
                Name (PXLM, Package (0x05)
                {
                    0x02,
                    0x01,
                    0x00,
                    0x00,
                    0x00
                })
                OperationRegion (PCI, PCI_Config, 0x00, 0x60)
                Field (PCI, ByteAcc, NoLock, Preserve)
                {
                    Offset (0x09),
                        ,   4,
                    SCHE,   1,
                    PCHE,   1,
                    Offset (0x0A),
                    Offset (0x0D),
                    Offset (0x4B),
                    U66E,   1,
                    Offset (0x4C),
                    Offset (0x53),
                    CDFI,   1,
                    CDUD,   1,
                    Offset (0x54),
                    PFTH,   8,
                    SFTH,   8,
                    PUDC,   8,
                    SUDC,   8,
                    PAST,   8,
                    PCBT,   8,
                    PTM0,   8,
                    PTM1,   8,
                    SAST,   8,
                    SCBT,   8,
                    STM0,   8,
                    STM1,   8
                }

                Method (STM, 3, NotSerialized)
                {
                    Name (A100, 0x00)
                    Store (Buffer (0x06)
                        {
                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00
                        }, Local7)
                    CreateByteField (Local7, 0x00, TM0)
                    CreateByteField (Local7, 0x01, TM1)
                    CreateByteField (Local7, 0x02, UDC)
                    CreateByteField (Local7, 0x03, AST)
                    CreateByteField (Local7, 0x04, CBT)
                    CreateByteField (Local7, 0x05, U66)
                    CreateDWordField (Arg0, 0x00, PIO0)
                    CreateDWordField (Arg0, 0x04, DMA0)
                    CreateDWordField (Arg0, 0x08, PIO1)
                    CreateDWordField (Arg0, 0x0C, DMA1)
                    CreateDWordField (Arg0, 0x10, FLAG)
                    Store (FLAG, Local6)
                    Name (W49M, 0x00)
                    Name (W53M, 0x00)
                    Name (W62M, 0x00)
                    Name (W64M, 0x00)
                    Name (W88M, 0x00)
                    If (LEqual (SizeOf (Arg1), 0x0200))
                    {
                        CreateDWordField (Arg1, 0x62, W49A)
                        CreateDWordField (Arg1, 0x6A, W53A)
                        CreateDWordField (Arg1, 0x7C, W62A)
                        CreateDWordField (Arg1, 0x80, W64A)
                        CreateDWordField (Arg1, 0xB0, W88A)
                        Store (W49A, W49M)
                        Store (W53A, W53M)
                        Store (W62A, W62M)
                        Store (W64A, W64M)
                        Store (W88A, W88M)
                    }
                    Else
                    {
                        Store (0x00, W49M)
                        Store (0x00, W53M)
                        Store (0x00, W62M)
                        Store (0x00, W64M)
                        Store (0x00, W88M)
                    }

                    If (LAnd (And (0x38, W88M), Ones))
                    {
                        Or (0x01, Local6, Local6)
                        If (And (0x20, W88M))
                        {
                            Store (0x08, DMA0)
                            Or (A100, 0x00100010, A100)
                        }
                        Else
                        {
                            If (And (0x10, W88M))
                            {
                                Store (0x1E, DMA0)
                                Or (A100, 0x10, A100)
                            }
                            Else
                            {
                                Store (0x2D, DMA0)
                            }
                        }
                    }
                    Else
                    {
                        If (And (0x07, W88M))
                        {
                            Or (0x0100, A100, A100)
                            If (And (0x04, W88M))
                            {
                                Store (0x3C, DMA0)
                            }
                            Else
                            {
                                If (And (0x02, W88M))
                                {
                                    Store (0x5A, DMA0)
                                }
                                Else
                                {
                                    Store (0x78, DMA0)
                                }
                            }
                        }
                    }

                    Store (Ones, Local4)
                    If (LOr (DMA0, PIO0))
                    {
                        If (LAnd (DMA0, LNot (PIO0)))
                        {
                            If (And (Local6, 0x01))
                            {
                                If (LLess (DMA0, 0x1E))
                                {
                                    Store (0x07, Local0)
                                }
                                Else
                                {
                                    Store (Match (^UDMT, MGE, DMA0, MTR, 0x00, 0x00), Local0)
                                }

                                Or (Local0, 0x08, UDC)
                                If (LLess (DMA0, 0x3C))
                                {
                                    Store (One, U66)
                                }
                            }

                            Store (Match (^PIOT, MGE, DMA0, MTR, 0x00, 0x00), Local0)
                            Store (DerefOf (Index (^DACT, Local0)), Local2)
                            Store (DerefOf (Index (^DRCT, Local0)), Local3)
                            Add (Local3, ShiftLeft (Local2, 0x04), TM0)
                            Store (Local0, Local4)
                        }

                        If (LAnd (LNot (DMA0), PIO0))
                        {
                            Store (Match (^PIOT, MGE, PIO0, MTR, 0x00, 0x00), Local0)
                            Store (DerefOf (Index (^DACT, Local0)), Local2)
                            Store (DerefOf (Index (^DRCT, Local0)), Local3)
                            Add (Local3, ShiftLeft (Local2, 0x04), TM0)
                            Store (Local0, Local4)
                        }

                        If (LAnd (DMA0, PIO0))
                        {
                            If (And (Local6, 0x01))
                            {
                                If (LLess (DMA0, 0x1E))
                                {
                                    Store (0x07, Local0)
                                }
                                Else
                                {
                                    Store (Match (^UDMT, MGE, DMA0, MTR, 0x00, 0x00), Local0)
                                }

                                Or (Local0, 0x08, UDC)
                                If (LLess (DMA0, 0x3C))
                                {
                                    Store (One, U66)
                                }
                            }

                            If (LNot (LLess (PIO0, DMA0)))
                            {
                                Store (Match (^PIOT, MGE, PIO0, MTR, 0x00, 0x00), Local0)
                                Store (Local0, Local4)
                            }
                            Else
                            {
                                Store (Match (^PIOT, MGE, DMA0, MTR, 0x00, 0x00), Local0)
                                Store (Local0, Local4)
                            }

                            Store (DerefOf (Index (^DACT, Local0)), Local2)
                            Store (DerefOf (Index (^DRCT, Local0)), Local3)
                            Add (Local3, ShiftLeft (Local2, 0x04), TM0)
                        }
                    }

                    Store (Ones, Local5)
                    If (LEqual (Local4, Ones))
                    {
                        If (LEqual (Local5, Ones))
                        {
                            Store (Zero, CBT)
                        }
                        Else
                        {
                            Store (DerefOf (Index (^CBCT, Local5)), CBT)
                        }
                    }
                    Else
                    {
                        If (LEqual (Local5, Ones))
                        {
                            Store (DerefOf (Index (^CBCT, Local4)), CBT)
                        }
                        Else
                        {
                            If (LNot (LLess (Local4, Local5)))
                            {
                                Store (DerefOf (Index (^CBCT, Local4)), CBT)
                            }
                            Else
                            {
                                Store (DerefOf (Index (^CBCT, Local5)), CBT)
                            }
                        }
                    }

                    Store (0x02, AST)
                    Return (Local7)
                }

                Method (GTF0, 3, NotSerialized)
                {
                    Store (Buffer (0x07)
                        {
                            0x03, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF
                        }, Local7)
                    CreateByteField (Local7, 0x01, MODE)
                    If (And (Arg1, 0x08))
                    {
                        And (Arg1, 0x07, Local0)
                        If (LEqual (Local0, 0x07))
                        {
                            Store (0x05, MODE)
                        }
                        Else
                        {
                            Subtract (0x04, Local0, MODE)
                        }

                        Or (MODE, 0x40, MODE)
                    }
                    Else
                    {
                        And (Arg2, 0x0F, Local0)
                        Store (Match (^DRCT, MEQ, Local0, MTR, 0x00, 0x00), Local1)
                        Store (DerefOf (Index (^PXLM, Local1)), MODE)
                        Or (MODE, 0x20, MODE)
                    }

                    Concatenate (Local7, Local7, Local6)
                    And (Arg2, 0x0F, Local0)
                    Store (Match (^DRCT, MEQ, Local0, MTR, 0x00, 0x00), Local1)
                    Subtract (0x04, Local1, MODE)
                    Or (MODE, 0x08, MODE)
                    Concatenate (Local6, Local7, Local5)
                    Return (Local5)
                }

                Device (PRIM)
                {
                    Name (_ADR, 0x00)
                    Name (_PSC, 0x00)
                    OperationRegion (HDIO, SystemIO, 0x01F0, 0x08)
                    Field (HDIO, ByteAcc, NoLock, Preserve)
                    {
                        Offset (0x01),
                        Offset (0x02),
                        Offset (0x03),
                        Offset (0x04),
                        Offset (0x05),
                        Offset (0x06),
                        HDSL,   8,
                        HDCM,   8
                    }

                    Method (_PS0, 0, NotSerialized)
                    {
                        Store (0x00, _PSC)
                    }

                    Method (_PS3, 0, NotSerialized)
                    {
                        Store (0x03, _PSC)
                    }

                    Method (_GTM, 0, NotSerialized)
                    {
                        Store ("GTM - Primary Controller", Debug)
                        Return (Buffer (0x14)
                        {
                            0x78, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
                            0x78, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
                            0x1F, 0x00, 0x00, 0x00
                        })
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        Store ("STM - Primary Controller", Debug)
                        Store (^^STM (Arg0, Arg1, Arg2), Local0)
                        CreateByteField (Local0, 0x00, TM0)
                        CreateByteField (Local0, 0x01, TM1)
                        CreateByteField (Local0, 0x02, UDC)
                        CreateByteField (Local0, 0x03, AST)
                        CreateByteField (Local0, 0x04, CBT)
                        CreateByteField (Local0, 0x05, U66)
                        Store (TM0, ^^PTM0)
                        Store (TM1, ^^PTM1)
                        Store (UDC, ^^PUDC)
                        Store (AST, ^^PAST)
                        Store (CBT, ^^PCBT)
                        If (U66)
                        {
                            Store (U66, ^^U66E)
                        }

                        Store (0x55, ^^PFTH)
                    }

                    Device (MAST)
                    {
                        Name (_ADR, 0x00)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Store ("GTF - Primary Master", Debug)
                            Store (^^^GTF0 (^^^PCHE, ^^^PUDC, ^^^PTM0), Local0)
                            Return (Local0)
                        }

                        Name (_PSC, 0x00)
                        Method (_PS0, 0, NotSerialized)
                        {
                            If (LEqual (\_SB.PCI0.ISA.TOOS, 0x04))
                            {
                                Store (0xA0, HDSL)
                                While (And (HDCM, 0x80))
                                {
                                    Sleep (0x05)
                                }
                            }

                            Store (0x00, _PSC)
                        }

                        Method (_PS3, 0, NotSerialized)
                        {
                            Store (0x03, _PSC)
                        }
                    }
                }

                Device (SECN)
                {
                    Name (_ADR, 0x01)
                    Name (_PSC, 0x00)
                    Method (_PS0, 0, NotSerialized)
                    {
                        Store (0x00, _PSC)
                    }

                    Method (_PS3, 0, NotSerialized)
                    {
                        Store (0x03, _PSC)
                    }

                    Method (_GTM, 0, NotSerialized)
                    {
                        Store ("GTM - Secondary Controller", Debug)
                        Return (Buffer (0x14)
                        {
                            0x78, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
                            0x78, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
                            0x1F, 0x00, 0x00, 0x00
                        })
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        Store ("STM - Secondary Controller", Debug)
                        Store (^^STM (Arg0, Arg1, Arg2), Local0)
                        CreateByteField (Local0, 0x00, TM0)
                        CreateByteField (Local0, 0x01, TM1)
                        CreateByteField (Local0, 0x02, UDC)
                        CreateByteField (Local0, 0x03, AST)
                        CreateByteField (Local0, 0x04, CBT)
                        CreateByteField (Local0, 0x05, U66)
                        Store (TM0, ^^STM0)
                        Store (TM1, ^^STM1)
                        Store (UDC, ^^SUDC)
                        Store (AST, ^^SAST)
                        Store (CBT, ^^SCBT)
                        If (U66)
                        {
                            Store (U66, ^^U66E)
                        }

                        Store (0x55, ^^SFTH)
                    }

                    Device (MAST)
                    {
                        Name (_ADR, 0x00)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Store ("GTF - Secondary Master", Debug)
                            Store (^^^GTF0 (^^^SCHE, ^^^SUDC, ^^^STM0), Local0)
                            Return (Local0)
                        }

                        Method (_PS0, 0, NotSerialized)
                        {
                            Store (0x00, _PSC)
                        }

                        Method (_PS3, 0, NotSerialized)
                        {
                            Store (0x03, _PSC)
                        }

                        Name (_PSC, 0x00)
                    }
                }
            }

            Device (USB1)
            {
                Name (_ADR, 0x00020000)
                Name (_PRW, Package (0x02)
                {
                    0x0B,
                    0x03
                })
                Name (_S3D, 0x02)
            }

            Device (USB2)
            {
                Name (_ADR, 0x000F0000)
                Name (_PRW, Package (0x02)
                {
                    0x0D,
                    0x03
                })
                Name (_S3D, 0x02)
                Method (_STA, 0, NotSerialized)
                {
                    If (\_SB.PCI0.ISA.USB2)
                    {
                        Return (0x0F)
                    }
                    Else
                    {
                        Return (0x00)
                    }
                }
            }

            Device (MDEM)
            {
                Name (_ADR, 0x00080000)
                Name (_PRW, Package (0x02)
                {
                    0x09,
                    0x04
                })
            }

            Device (AUDI)
            {
                Name (_ADR, 0x00060000)
            }

            Device (LAN)
            {
                Name (_ADR, 0x00120000)
                Name (_PRW, Package (0x02)
                {
                    0x09,
                    0x05
                })
                Method (_PSW, 1, NotSerialized)
                {
                    If (\_SB.ECOK ())
                    {
                        Acquire (\_SB.PCI0.ISA.EC0.MUT1, 0xFFFF)
                        If (Arg0)
                        {
                            Store (0x01, \_SB.PCI0.ISA.EC0.WOLE)
                        }
                        Else
                        {
                            Store (0x00, \_SB.PCI0.ISA.EC0.WOLE)
                        }

                        Release (\_SB.PCI0.ISA.EC0.MUT1)
                    }
                }
            }

            Device (IEEE)
            {
                Name (_ADR, 0x000C0000)
            }

            Device (CBUS)
            {
                Name (_ADR, 0x000A0000)
            }

            Device (MINI)
            {
                Name (_ADR, 0x00090000)
            }

            Device (ISA)
            {
                Name (_ADR, 0x00070000)
                OperationRegion (ISAR, PCI_Config, 0x00, 0x9F)
                Field (ISAR, ByteAcc, NoLock, Preserve)
                {
                    Offset (0x77),
                        ,   6,
                    MDNE,   1,
                    Offset (0x7E),
                        ,   7,
                    USB2,   1
                }

                OperationRegion (MNVS, SystemMemory, 0x1FEFFE1D, 0x10)
                Field (MNVS, AnyAcc, Lock, Preserve)
                {
                    TOOS,   8,
                    LIDS,   8,
                    ACST,   8,
                    TV,     1,
                    FIR,    1,
                    COMM,   1,
                    LPT,    1
                }

                OperationRegion (SMI0, SystemIO, 0x0000FE00, 0x00000002)
                Field (SMI0, AnyAcc, NoLock, Preserve)
                {
                    SMIC,   8
                }

                OperationRegion (SMI1, SystemMemory, 0x1FEFFE2D, 0x00000120)
                Field (SMI1, AnyAcc, NoLock, Preserve)
                {
                    BCMD,   8,
                    DID,    32,
                    INFO,   2048
                }

                Field (SMI1, AnyAcc, NoLock, Preserve)
                {
                    AccessAs (ByteAcc, 0x00),
                    Offset (0x05),
                    INF,    8
                }

                Field (SMI1, AnyAcc, NoLock, Preserve)
                {
                    AccessAs (ByteAcc, 0x00),
                    Offset (0x05),
                    STSB,   8
                }

                Field (SMI1, AnyAcc, NoLock, Preserve)
                {
                    Offset (0x05),
                    PNLR,   32
                }

                Field (SMI1, AnyAcc, NoLock, Preserve)
                {
                    Offset (0x105),
                    BDST,   8
                }

                Field (SMI1, AnyAcc, NoLock, Preserve)
                {
                    Offset (0x106),
                    DKSN,   32
                }

                Field (SMI1, AnyAcc, NoLock, Preserve)
                {
                    Offset (0x10A),
                    DKTP,   8
                }

                Field (SMI1, AnyAcc, NoLock, Preserve)
                {
                    Offset (0x10B),
                    VGAB,   32
                }

                Field (SMI1, AnyAcc, NoLock, Preserve)
                {
                    Offset (0x10F),
                    WOLE,   1,
                    DISB,   1,
                    CPTY,   1,
                    FDDS,   1
                }

                Mutex (PSMX, 0x00)
                Method (HPSS, 2, NotSerialized)
                {
                    Acquire (\_SB.PCI0.ISA.PSMX, 0xFFFF)
                    Store (Arg1, STSB)
                    Store (0x80, BCMD)
                    Store (Arg0, DID)
                    Store (Zero, SMIC)
                    Store (STSB, Local0)
                    Release (\_SB.PCI0.ISA.PSMX)
                    Return (Local0)
                }

                Method (Z001, 1, NotSerialized)
                {
                    Acquire (\_SB.PCI0.ISA.PSMX, 0xFFFF)
                    Store (0x90, BCMD)
                    Store (Arg0, DID)
                    Store (Zero, SMIC)
                    Release (\_SB.PCI0.ISA.PSMX)
                }

                OperationRegion (PUSB, PCI_Config, 0x74, 0x01)
                Field (PUSB, ByteAcc, NoLock, Preserve)
                {
                    PIRU,   4,
                    Offset (0x01)
                }

                OperationRegion (PIRX, PCI_Config, 0x48, 0x04)
                Field (PIRX, ByteAcc, NoLock, Preserve)
                {
                    PIRA,   4,
                    PIRB,   4,
                    PIRC,   4,
                    PIRD,   4,
                    PIRE,   4,
                    PIRF,   4,
                    PIRG,   4,
                    PIRH,   4
                }

                Name (IPRS, Buffer (0x06)
                {
                    0x23, 0x00, 0x04, 0x18, 0x79, 0x00
                })
                Name (Z002, Buffer (0x06)
                {
                    0x23, 0xA0, 0x00, 0x18, 0x79, 0x00
                })
                Name (Z003, Buffer (0x06)
                {
                    0x23, 0x80, 0x08, 0x18, 0x79, 0x00
                })
                Name (IXLT, Package (0x10)
                {
                    0x00,
                    0x0200,
                    0x08,
                    0x0400,
                    0x10,
                    0x20,
                    0x80,
                    0x40,
                    0x02,
                    0x0800,
                    0x00,
                    0x1000,
                    0x00,
                    0x4000,
                    0x00,
                    0x8000
                })
                Device (LNKA)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x01)
                    Method (_STA, 0, NotSerialized)
                    {
                        If (PIRA)
                        {
                            Return (0x0B)
                        }
                        Else
                        {
                            Return (0x09)
                        }
                    }

                    Method (_PRS, 0, NotSerialized)
                    {
                        Return (IPRS)
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (0x00, PIRA)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Store (IPRS, Local0)
                        CreateWordField (Local0, 0x01, IRA0)
                        Store (PIRA, Local1)
                        Store (DerefOf (Index (IXLT, Local1)), IRA0)
                        Return (Local0)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRA0)
                        Store (Match (IXLT, MEQ, IRA0, MGT, 0x00, 0x00), PIRA)
                    }
                }

                Device (LNKB)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x02)
                    Method (_STA, 0, NotSerialized)
                    {
                        If (PIRB)
                        {
                            Return (0x0B)
                        }
                        Else
                        {
                            Return (0x09)
                        }
                    }

                    Method (_PRS, 0, NotSerialized)
                    {
                        Return (Z003)
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (0x00, PIRB)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Store (Z003, Local0)
                        CreateWordField (Local0, 0x01, IRA0)
                        Store (PIRB, Local1)
                        Store (DerefOf (Index (IXLT, Local1)), IRA0)
                        Return (Local0)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRA0)
                        Store (Match (IXLT, MEQ, IRA0, MGT, 0x00, 0x00), PIRB)
                    }
                }

                Device (LNKC)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x03)
                    Method (_STA, 0, NotSerialized)
                    {
                        If (PIRC)
                        {
                            Return (0x0B)
                        }
                        Else
                        {
                            Return (0x09)
                        }
                    }

                    Method (_PRS, 0, NotSerialized)
                    {
                        Return (IPRS)
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (0x00, PIRC)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Store (IPRS, Local0)
                        CreateWordField (Local0, 0x01, IRA0)
                        Store (PIRC, Local1)
                        Store (DerefOf (Index (IXLT, Local1)), IRA0)
                        Return (Local0)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRA0)
                        Store (Match (IXLT, MEQ, IRA0, MGT, 0x00, 0x00), PIRC)
                    }
                }

                Device (LNKD)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x04)
                    Method (_STA, 0, NotSerialized)
                    {
                        If (PIRD)
                        {
                            Return (0x0B)
                        }
                        Else
                        {
                            Return (0x09)
                        }
                    }

                    Method (_PRS, 0, NotSerialized)
                    {
                        Return (IPRS)
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (0x00, PIRD)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Store (IPRS, Local0)
                        CreateWordField (Local0, 0x01, IRA0)
                        Store (PIRD, Local1)
                        Store (DerefOf (Index (IXLT, Local1)), IRA0)
                        Return (Local0)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRA0)
                        Store (Match (IXLT, MEQ, IRA0, MGT, 0x00, 0x00), PIRD)
                    }
                }

                Device (LNKE)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x05)
                    Method (_STA, 0, NotSerialized)
                    {
                        If (PIRE)
                        {
                            Return (0x0B)
                        }
                        Else
                        {
                            Return (0x09)
                        }
                    }

                    Method (_PRS, 0, NotSerialized)
                    {
                        Return (IPRS)
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (0x00, PIRE)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Store (IPRS, Local0)
                        CreateWordField (Local0, 0x01, IRA0)
                        Store (PIRE, Local1)
                        Store (DerefOf (Index (IXLT, Local1)), IRA0)
                        Return (Local0)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRA0)
                        Store (Match (IXLT, MEQ, IRA0, MGT, 0x00, 0x00), PIRE)
                    }
                }

                Device (LNKF)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x06)
                    Method (_STA, 0, NotSerialized)
                    {
                        If (PIRF)
                        {
                            Return (0x0B)
                        }
                        Else
                        {
                            Return (0x09)
                        }
                    }

                    Method (_PRS, 0, NotSerialized)
                    {
                        Return (Z002)
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (0x00, PIRF)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Store (Z002, Local0)
                        CreateWordField (Local0, 0x01, IRA0)
                        Store (PIRF, Local1)
                        Store (DerefOf (Index (IXLT, Local1)), IRA0)
                        Return (Local0)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRA0)
                        Store (Match (IXLT, MEQ, IRA0, MGT, 0x00, 0x00), PIRF)
                    }
                }

                Device (LNKG)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x07)
                    Method (_STA, 0, NotSerialized)
                    {
                        If (PIRG)
                        {
                            Return (0x0B)
                        }
                        Else
                        {
                            Return (0x09)
                        }
                    }

                    Method (_PRS, 0, NotSerialized)
                    {
                        Return (IPRS)
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (0x00, PIRG)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Store (IPRS, Local0)
                        CreateWordField (Local0, 0x01, IRA0)
                        Store (PIRG, Local1)
                        Store (DerefOf (Index (IXLT, Local1)), IRA0)
                        Return (Local0)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRA0)
                        Store (Match (IXLT, MEQ, IRA0, MGT, 0x00, 0x00), PIRG)
                    }
                }

                Device (LNKH)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x08)
                    Method (_STA, 0, NotSerialized)
                    {
                        If (PIRH)
                        {
                            Return (0x0B)
                        }
                        Else
                        {
                            Return (0x09)
                        }
                    }

                    Method (_PRS, 0, NotSerialized)
                    {
                        Return (Z002)
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (0x00, PIRH)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Store (Z002, Local0)
                        CreateWordField (Local0, 0x01, IRA0)
                        Store (PIRH, Local1)
                        Store (DerefOf (Index (IXLT, Local1)), IRA0)
                        Return (Local0)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRA0)
                        Store (Match (IXLT, MEQ, IRA0, MGT, 0x00, 0x00), PIRH)
                    }
                }

                Device (LNKU)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x09)
                    Method (_STA, 0, NotSerialized)
                    {
                        If (PIRU)
                        {
                            Return (0x0B)
                        }
                        Else
                        {
                            Return (0x09)
                        }
                    }

                    Method (_PRS, 0, NotSerialized)
                    {
                        Return (IPRS)
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (0x00, PIRU)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Store (IPRS, Local0)
                        CreateWordField (Local0, 0x01, IRA0)
                        Store (PIRU, Local1)
                        Store (DerefOf (Index (IXLT, Local1)), IRA0)
                        Return (Local0)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRA0)
                        Store (Match (IXLT, MEQ, IRA0, MGT, 0x00, 0x00), PIRU)
                    }
                }

                Device (DMAC)
                {
                    Name (_HID, EisaId ("PNP0200"))
                    Name (_CRS, Buffer (0x1D)
                    {
                        0x47, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x10,
                        0x47, 0x01, 0x81, 0x00, 0x81, 0x00, 0x01, 0x0F,
                        0x47, 0x01, 0xC0, 0x00, 0xC0, 0x00, 0x01, 0x20,
                        0x2A, 0x10, 0x02, 0x79, 0x00
                    })
                }

                Device (PIC)
                {
                    Name (_HID, EisaId ("PNP0000"))
                    Name (_CRS, Buffer (0x16)
                    {
                        0x47, 0x01, 0x20, 0x00, 0x20, 0x00, 0x01, 0x02,
                        0x47, 0x01, 0xA0, 0x00, 0xA0, 0x00, 0x01, 0x02,
                        0x23, 0x04, 0x00, 0x01, 0x79, 0x00
                    })
                }

                Device (TIME)
                {
                    Name (_HID, EisaId ("PNP0100"))
                    Name (_CRS, Buffer (0x0E)
                    {
                        0x47, 0x01, 0x40, 0x00, 0x40, 0x00, 0x01, 0x04,
                        0x23, 0x01, 0x00, 0x01, 0x79, 0x00
                    })
                }

                Device (RTC)
                {
                    Name (_HID, EisaId ("PNP0B00"))
                    Name (_CRS, Buffer (0x0E)
                    {
                        0x47, 0x01, 0x70, 0x00, 0x70, 0x00, 0x01, 0x02,
                        0x23, 0x00, 0x01, 0x01, 0x79, 0x00
                    })
                }

                Device (MATH)
                {
                    Name (_HID, EisaId ("PNP0C04"))
                    Name (_CRS, Buffer (0x0E)
                    {
                        0x47, 0x01, 0xF0, 0x00, 0xF0, 0x00, 0x01, 0x0F,
                        0x23, 0x00, 0x20, 0x01, 0x79, 0x00
                    })
                }

                Device (SPKR)
                {
                    Name (_HID, EisaId ("PNP0800"))
                    Name (_CRS, Buffer (0x0A)
                    {
                        0x47, 0x01, 0x61, 0x00, 0x61, 0x00, 0x01, 0x01,
                        0x79, 0x00
                    })
                }

                Device (KBC0)
                {
                    Name (_HID, EisaId ("PNP0303"))
                    Name (_CRS, Buffer (0x16)
                    {
                        0x47, 0x01, 0x60, 0x00, 0x60, 0x00, 0x01, 0x01,
                        0x47, 0x01, 0x64, 0x00, 0x64, 0x00, 0x01, 0x01,
                        0x23, 0x02, 0x00, 0x01, 0x79, 0x00
                    })
                }

                Device (MSE0)
                {
                    Name (_HID, EisaId ("PNP0F13"))
                    Name (_CRS, Buffer (0x06)
                    {
                        0x23, 0x00, 0x10, 0x01, 0x79, 0x00
                    })
                }

                Device (SYSR)
                {
                    Name (_HID, EisaId ("PNP0C02"))
                    Name (_CRS, Buffer (0x7A)
                    {
                        0x47, 0x01, 0x80, 0x00, 0x80, 0x00, 0x01, 0x01,
                        0x47, 0x01, 0x22, 0x00, 0x22, 0x00, 0x01, 0x01,
                        0x47, 0x01, 0xB1, 0x00, 0xB1, 0x00, 0x01, 0x01,
                        0x47, 0x01, 0x92, 0x00, 0x92, 0x00, 0x01, 0x01,
                        0x47, 0x01, 0x10, 0x38, 0x10, 0x38, 0x01, 0x10,
                        0x47, 0x01, 0xD0, 0x04, 0xD0, 0x04, 0x01, 0x02,
                        0x47, 0x01, 0x00, 0x80, 0x00, 0x80, 0x01, 0x60,
                        0x47, 0x01, 0xD6, 0x04, 0xD6, 0x04, 0x01, 0x01,
                        0x47, 0x01, 0x80, 0x04, 0x80, 0x04, 0x01, 0x10,
                        0x47, 0x01, 0x0B, 0x04, 0x0B, 0x04, 0x01, 0x01,
                        0x47, 0x01, 0x04, 0x80, 0x04, 0x80, 0x01, 0x02,
                        0x47, 0x01, 0x00, 0xFE, 0x00, 0xFE, 0x01, 0xFF,
                        0x86, 0x09, 0x00, 0x00, 0x00, 0x00, 0xFC, 0xFF,
                        0x00, 0x00, 0x04, 0x00, 0x86, 0x09, 0x00, 0x00,
                        0x00, 0x00, 0xC0, 0xFE, 0x00, 0x10, 0x00, 0x00,
                        0x79, 0x00
                    })
                }

                Device (SIOD)
                {
                    Name (_HID, EisaId ("PNP0A05"))
                    OperationRegion (SIIO, SystemIO, 0x03F0, 0x02)
                    Field (SIIO, ByteAcc, NoLock, Preserve)
                    {
                        INDX,   8,
                        DATA,   8
                    }

                    IndexField (INDX, DATA, ByteAcc, NoLock, Preserve)
                    {
                        Offset (0x22),
                        CR22,   8,
                        Offset (0x30),
                        CR30,   8,
                        Offset (0x60),
                        CR60,   8,
                        CR61,   8,
                        Offset (0x70),
                        CR70,   8,
                        Offset (0x74),
                        CR74,   8,
                        Offset (0xF0),
                        CRF0,   8,
                        CRF1,   8,
                        CRF2,   8,
                        Offset (0xF4),
                        CRF4,   8,
                        CRF5,   8
                    }

                    Method (ENFG, 1, NotSerialized)
                    {
                        Acquire (MTIO, 0xFFFF)
                        Store (0x51, INDX)
                        Store (0x23, INDX)
                        Store (0x07, INDX)
                        Store (Arg0, DATA)
                    }

                    Method (EXFG, 0, NotSerialized)
                    {
                        Store (0xBB, INDX)
                        Release (MTIO)
                    }

                    Device (FDC)
                    {
                        Name (_HID, EisaId ("PNP0700"))
                        Method (_STA, 0, NotSerialized)
                        {
                            ENFG (0x00)
                            And (CR30, 0x01, Local0)
                            And (CR60, 0x03, Local1)
                            EXFG ()
                            If (And (LEqual (\_SB.PCI0.ISA.FDDS, 0x00), LEqual (\_SB.KT6F, 0x01)))
                            {
                                Return (0x00)
                            }

                            If (LAnd (Local0, Local1))
                            {
                                Return (0x0F)
                            }
                            Else
                            {
                                Return (0x0D)
                            }
                        }

                        Method (_DIS, 0, NotSerialized)
                        {
                            ENFG (0x00)
                            Store (0x00, CR30)
                            Store (0x00, CR60)
                            Store (0x00, CR61)
                            Store (0x04, CR74)
                            Store (0x00, CR70)
                            EXFG ()
                        }

                        Name (RSRC, Buffer (0x18)
                        {
                            0x47, 0x01, 0xF0, 0x03, 0xF0, 0x03, 0x01, 0x06,
                            0x47, 0x01, 0xF7, 0x03, 0xF7, 0x03, 0x01, 0x01,
                            0x22, 0x40, 0x00, 0x2A, 0x04, 0x00, 0x79, 0x00
                        })
                        Method (_CRS, 0, NotSerialized)
                        {
                            CreateWordField (RSRC, 0x02, IO1L)
                            CreateWordField (RSRC, 0x04, IO1H)
                            CreateWordField (RSRC, 0x0A, IO2L)
                            CreateWordField (RSRC, 0x0C, IO2H)
                            CreateWordField (RSRC, 0x11, IRQX)
                            CreateByteField (RSRC, 0x14, DMAX)
                            Store (Zero, IO1L)
                            Store (Zero, IO1H)
                            Store (Zero, IO2L)
                            Store (Zero, IO2H)
                            Store (Zero, IRQX)
                            Store (Zero, DMAX)
                            ENFG (0x00)
                            Store (CR30, Local0)
                            Store (CR60, Local1)
                            If (LAnd (Local0, Local1))
                            {
                                Store (_PRS, RSRC)
                            }

                            EXFG ()
                            Return (RSRC)
                        }

                        Name (_PRS, Buffer (0x18)
                        {
                            0x47, 0x01, 0xF0, 0x03, 0xF0, 0x03, 0x01, 0x06,
                            0x47, 0x01, 0xF7, 0x03, 0xF7, 0x03, 0x01, 0x01,
                            0x22, 0x40, 0x00, 0x2A, 0x04, 0x00, 0x79, 0x00
                        })
                        Method (_SRS, 1, NotSerialized)
                        {
                            Store (Arg0, RSRC)
                            CreateWordField (RSRC, 0x02, IOX)
                            CreateWordField (RSRC, 0x11, IRQX)
                            CreateByteField (RSRC, 0x14, DMAX)
                            ENFG (0x00)
                            And (IOX, 0xFF, CR61)
                            ShiftRight (IOX, 0x08, CR60)
                            FindSetRightBit (IRQX, Local0)
                            If (Local0)
                            {
                                Decrement (Local0)
                            }

                            Store (Local0, CR70)
                            FindSetRightBit (DMAX, Local0)
                            If (Local0)
                            {
                                Decrement (Local0)
                            }

                            Store (Local0, CR74)
                            Store (0x01, CR30)
                            EXFG ()
                        }
                    }

                    Device (LPT)
                    {
                        Method (_HID, 0, NotSerialized)
                        {
                            ENFG (0x03)
                            And (CRF0, 0x02, Local0)
                            EXFG ()
                            If (Local0)
                            {
                                Return (0x0104D041)
                            }
                            Else
                            {
                                Return (0x0004D041)
                            }
                        }

                        Method (_STA, 0, NotSerialized)
                        {
                            ENFG (0x03)
                            And (CR30, 0x01, Local0)
                            And (CR61, 0xFC, Local1)
                            EXFG ()
                            If (LAnd (Local0, Local1))
                            {
                                Return (0x0F)
                            }
                            Else
                            {
                                Return (0x0D)
                            }
                        }

                        Method (_DIS, 0, NotSerialized)
                        {
                            ENFG (0x03)
                            Store (0x00, CR30)
                            Store (0x00, CR60)
                            Store (0x00, CR61)
                            Store (0x00, CR70)
                            Store (0x04, CR70)
                            EXFG ()
                        }

                        Name (CRSA, Buffer (0x0D)
                        {
                            0x47, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x08,
                            0x22, 0x00, 0x00, 0x79, 0x00
                        })
                        Name (CRSB, Buffer (0x18)
                        {
                            0x47, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x08,
                            0x47, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x08,
                            0x22, 0x00, 0x00, 0x2A, 0x00, 0x00, 0x79, 0x00
                        })
                        Method (_CRS, 0, NotSerialized)
                        {
                            CreateWordField (CRSA, 0x02, IOAL)
                            CreateWordField (CRSA, 0x04, IOAH)
                            CreateByteField (CRSA, 0x07, LENA)
                            CreateWordField (CRSA, 0x09, IRAX)
                            Store (Zero, IOAL)
                            Store (Zero, IOAH)
                            Store (Zero, LENA)
                            Store (Zero, IRAX)
                            CreateWordField (CRSB, 0x02, IOBL)
                            CreateWordField (CRSB, 0x04, IOBH)
                            CreateByteField (CRSB, 0x07, LENB)
                            CreateWordField (CRSB, 0x0A, IOCL)
                            CreateWordField (CRSB, 0x0C, IOCH)
                            CreateByteField (CRSB, 0x0F, LENC)
                            CreateWordField (CRSB, 0x11, IRBX)
                            CreateByteField (CRSB, 0x14, DMAX)
                            Store (Zero, IOBL)
                            Store (Zero, IOBH)
                            Store (Zero, LENB)
                            Store (Zero, IOCL)
                            Store (Zero, IOCH)
                            Store (Zero, LENC)
                            Store (Zero, IRBX)
                            Store (Zero, DMAX)
                            ENFG (0x03)
                            Store (CR60, IOAL)
                            ShiftLeft (IOAL, 0x08, Local1)
                            Or (CR61, Local1, Local2)
                            Store (Local2, IOAL)
                            Store (Local2, IOAH)
                            Store (Local2, IOBL)
                            Store (Local2, IOBH)
                            And (CRF0, 0x02, Local0)
                            If (Local0)
                            {
                                Add (Local2, 0x0400, IOCL)
                                Add (Local2, 0x0400, IOCH)
                                If (LEqual (Local2, 0x03BC))
                                {
                                    Store (0x04, LENA)
                                    Store (0x04, LENB)
                                    Store (0x04, LENC)
                                }
                                Else
                                {
                                    Store (0x08, LENA)
                                    Store (0x08, LENB)
                                    Store (0x08, LENC)
                                }
                            }

                            Store (CR70, Local1)
                            ShiftLeft (One, Local1, IRAX)
                            ShiftLeft (One, Local1, IRBX)
                            Store (CR74, Local1)
                            ShiftLeft (One, Local1, DMAX)
                            EXFG ()
                            If (Local0)
                            {
                                Return (CRSB)
                            }
                            Else
                            {
                                Return (CRSA)
                            }
                        }

                        Name (PRSA, Buffer (0x51)
                        {
                            0x31, 0x04, 0x47, 0x01, 0x78, 0x03, 0x78, 0x03,
                            0x01, 0x08, 0x22, 0x80, 0x00, 0x31, 0x04, 0x47,
                            0x01, 0x78, 0x02, 0x78, 0x02, 0x01, 0x08, 0x22,
                            0x80, 0x00, 0x31, 0x04, 0x47, 0x01, 0xBC, 0x03,
                            0xBC, 0x03, 0x01, 0x04, 0x22, 0x80, 0x00, 0x31,
                            0x04, 0x47, 0x01, 0x78, 0x03, 0x78, 0x03, 0x01,
                            0x08, 0x22, 0x20, 0x00, 0x31, 0x04, 0x47, 0x01,
                            0x78, 0x02, 0x78, 0x02, 0x01, 0x08, 0x22, 0x20,
                            0x00, 0x31, 0x04, 0x47, 0x01, 0xBC, 0x03, 0xBC,
                            0x03, 0x01, 0x04, 0x22, 0x20, 0x00, 0x38, 0x79,
                            0x00
                        })
                        Name (PRSB, Buffer (0x0243)
                        {
                            0x31, 0x04, 0x47, 0x01, 0x78, 0x03, 0x78, 0x03,
                            0x01, 0x08, 0x47, 0x01, 0x78, 0x07, 0x78, 0x07,
                            0x01, 0x08, 0x22, 0x20, 0x00, 0x2A, 0x01, 0x00,
                            0x31, 0x04, 0x47, 0x01, 0x78, 0x02, 0x78, 0x02,
                            0x01, 0x08, 0x47, 0x01, 0x78, 0x06, 0x78, 0x06,
                            0x01, 0x08, 0x22, 0x20, 0x00, 0x2A, 0x01, 0x00,
                            0x31, 0x04, 0x47, 0x01, 0xBC, 0x03, 0xBC, 0x03,
                            0x01, 0x04, 0x47, 0x01, 0xBC, 0x07, 0xBC, 0x07,
                            0x01, 0x04, 0x22, 0x20, 0x00, 0x2A, 0x01, 0x00,
                            0x31, 0x04, 0x47, 0x01, 0x78, 0x03, 0x78, 0x03,
                            0x01, 0x08, 0x47, 0x01, 0x78, 0x07, 0x78, 0x07,
                            0x01, 0x08, 0x22, 0x80, 0x00, 0x2A, 0x01, 0x00,
                            0x31, 0x04, 0x47, 0x01, 0x78, 0x02, 0x78, 0x02,
                            0x01, 0x08, 0x47, 0x01, 0x78, 0x06, 0x78, 0x06,
                            0x01, 0x08, 0x22, 0x80, 0x00, 0x2A, 0x01, 0x00,
                            0x31, 0x04, 0x47, 0x01, 0xBC, 0x03, 0xBC, 0x03,
                            0x01, 0x04, 0x47, 0x01, 0xBC, 0x07, 0xBC, 0x07,
                            0x01, 0x04, 0x22, 0x80, 0x00, 0x2A, 0x01, 0x00,
                            0x31, 0x04, 0x47, 0x01, 0x78, 0x03, 0x78, 0x03,
                            0x01, 0x08, 0x47, 0x01, 0x78, 0x07, 0x78, 0x07,
                            0x01, 0x08, 0x22, 0x20, 0x00, 0x2A, 0x02, 0x00,
                            0x31, 0x04, 0x47, 0x01, 0x78, 0x02, 0x78, 0x02,
                            0x01, 0x08, 0x47, 0x01, 0x78, 0x06, 0x78, 0x06,
                            0x01, 0x08, 0x22, 0x20, 0x00, 0x2A, 0x02, 0x00,
                            0x31, 0x04, 0x47, 0x01, 0xBC, 0x03, 0xBC, 0x03,
                            0x01, 0x04, 0x47, 0x01, 0xBC, 0x07, 0xBC, 0x07,
                            0x01, 0x04, 0x22, 0x20, 0x00, 0x2A, 0x02, 0x00,
                            0x31, 0x04, 0x47, 0x01, 0x78, 0x03, 0x78, 0x03,
                            0x01, 0x08, 0x47, 0x01, 0x78, 0x07, 0x78, 0x07,
                            0x01, 0x08, 0x22, 0x80, 0x00, 0x2A, 0x02, 0x00,
                            0x31, 0x04, 0x47, 0x01, 0x78, 0x02, 0x78, 0x02,
                            0x01, 0x08, 0x47, 0x01, 0x78, 0x06, 0x78, 0x06,
                            0x01, 0x08, 0x22, 0x80, 0x00, 0x2A, 0x02, 0x00,
                            0x31, 0x04, 0x47, 0x01, 0xBC, 0x03, 0xBC, 0x03,
                            0x01, 0x04, 0x47, 0x01, 0xBC, 0x07, 0xBC, 0x07,
                            0x01, 0x04, 0x22, 0x80, 0x00, 0x2A, 0x02, 0x00,
                            0x31, 0x04, 0x47, 0x01, 0x78, 0x03, 0x78, 0x03,
                            0x01, 0x08, 0x47, 0x01, 0x78, 0x07, 0x78, 0x07,
                            0x01, 0x08, 0x22, 0x20, 0x00, 0x2A, 0x04, 0x00,
                            0x31, 0x04, 0x47, 0x01, 0x78, 0x02, 0x78, 0x02,
                            0x01, 0x08, 0x47, 0x01, 0x78, 0x06, 0x78, 0x06,
                            0x01, 0x08, 0x22, 0x20, 0x00, 0x2A, 0x04, 0x00,
                            0x31, 0x04, 0x47, 0x01, 0xBC, 0x03, 0xBC, 0x03,
                            0x01, 0x04, 0x47, 0x01, 0xBC, 0x07, 0xBC, 0x07,
                            0x01, 0x04, 0x22, 0x20, 0x00, 0x2A, 0x04, 0x00,
                            0x31, 0x04, 0x47, 0x01, 0x78, 0x03, 0x78, 0x03,
                            0x01, 0x08, 0x47, 0x01, 0x78, 0x07, 0x78, 0x07,
                            0x01, 0x08, 0x22, 0x80, 0x00, 0x2A, 0x04, 0x00,
                            0x31, 0x04, 0x47, 0x01, 0x78, 0x02, 0x78, 0x02,
                            0x01, 0x08, 0x47, 0x01, 0x78, 0x06, 0x78, 0x06,
                            0x01, 0x08, 0x22, 0x80, 0x00, 0x2A, 0x04, 0x00,
                            0x31, 0x04, 0x47, 0x01, 0xBC, 0x03, 0xBC, 0x03,
                            0x01, 0x04, 0x47, 0x01, 0xBC, 0x07, 0xBC, 0x07,
                            0x01, 0x04, 0x22, 0x80, 0x00, 0x2A, 0x04, 0x00,
                            0x31, 0x04, 0x47, 0x01, 0x78, 0x03, 0x78, 0x03,
                            0x01, 0x08, 0x47, 0x01, 0x78, 0x07, 0x78, 0x07,
                            0x01, 0x08, 0x22, 0x20, 0x00, 0x2A, 0x08, 0x00,
                            0x31, 0x04, 0x47, 0x01, 0x78, 0x02, 0x78, 0x02,
                            0x01, 0x08, 0x47, 0x01, 0x78, 0x06, 0x78, 0x06,
                            0x01, 0x08, 0x22, 0x20, 0x00, 0x2A, 0x08, 0x00,
                            0x31, 0x04, 0x47, 0x01, 0xBC, 0x03, 0xBC, 0x03,
                            0x01, 0x04, 0x47, 0x01, 0xBC, 0x07, 0xBC, 0x07,
                            0x01, 0x04, 0x22, 0x20, 0x00, 0x2A, 0x08, 0x00,
                            0x31, 0x04, 0x47, 0x01, 0x78, 0x03, 0x78, 0x03,
                            0x01, 0x08, 0x47, 0x01, 0x78, 0x07, 0x78, 0x07,
                            0x01, 0x08, 0x22, 0x80, 0x00, 0x2A, 0x08, 0x00,
                            0x31, 0x04, 0x47, 0x01, 0x78, 0x02, 0x78, 0x02,
                            0x01, 0x08, 0x47, 0x01, 0x78, 0x06, 0x78, 0x06,
                            0x01, 0x08, 0x22, 0x80, 0x00, 0x2A, 0x08, 0x00,
                            0x31, 0x04, 0x47, 0x01, 0xBC, 0x03, 0xBC, 0x03,
                            0x01, 0x04, 0x47, 0x01, 0xBC, 0x07, 0xBC, 0x07,
                            0x01, 0x04, 0x22, 0x80, 0x00, 0x2A, 0x08, 0x00,
                            0x38, 0x79, 0x00
                        })
                        Method (_PRS, 0, NotSerialized)
                        {
                            ENFG (0x03)
                            And (CRF0, 0x02, Local0)
                            EXFG ()
                            If (Local0)
                            {
                                Return (PRSB)
                            }
                            Else
                            {
                                Return (PRSA)
                            }
                        }

                        Method (_SRS, 1, NotSerialized)
                        {
                            ENFG (0x03)
                            And (CRF0, 0x02, Local0)
                            If (Local0)
                            {
                                Store (Arg0, CRSB)
                                CreateWordField (CRSB, 0x02, IOB)
                                CreateWordField (CRSB, 0x11, IRQB)
                                CreateByteField (CRSB, 0x14, DMAX)
                                And (IOB, 0xFF, CR61)
                                ShiftRight (IOB, 0x08, CR60)
                                FindSetRightBit (IRQB, Local0)
                                If (Local0)
                                {
                                    Decrement (Local0)
                                }

                                Store (Local0, CR70)
                                FindSetRightBit (DMAX, Local0)
                                If (Local0)
                                {
                                    Decrement (Local0)
                                }

                                Store (Local0, CR74)
                            }
                            Else
                            {
                                Store (Arg0, CRSA)
                                CreateWordField (CRSA, 0x02, IOA)
                                CreateWordField (CRSA, 0x09, IRQA)
                                And (IOA, 0xFF, CR61)
                                ShiftRight (IOA, 0x08, CR60)
                                FindSetRightBit (IRQA, Local0)
                                If (Local0)
                                {
                                    Decrement (Local0)
                                }

                                Store (Local0, CR70)
                            }

                            Store (0x01, CR30)
                            EXFG ()
                        }
                    }

                    Device (COM1)
                    {
                        Name (_HID, EisaId ("PNP0501"))
                        Name (_UID, 0x01)
                        Name (_RMV, 0x01)
                        Method (_STA, 0, NotSerialized)
                        {
                            If (LEqual (\_SB.PCI0.PMU.PDID, 0x00))
                            {
                                Return (0x00)
                            }

                            ENFG (0x04)
                            And (CR22, 0x10, Local0)
                            And (CR30, 0x01, Local1)
                            And (CRF1, 0x18, Local2)
                            EXFG ()
                            If (Local0)
                            {
                                Return (0x00)
                            }
                            Else
                            {
                                If (And (LEqual (\_SB.PRCT, 0x00), LEqual (\_SB.KT6F, 0x01)))
                                {
                                    Return (0x00)
                                }

                                If (LEqual (Local2, 0x00))
                                {
                                    If (And (Local1, 0x01))
                                    {
                                        Return (0x0F)
                                    }
                                    Else
                                    {
                                        Return (0x0D)
                                    }
                                }
                                Else
                                {
                                    Return (0x00)
                                }
                            }
                        }

                        Method (_DIS, 0, NotSerialized)
                        {
                            ENFG (0x04)
                            Store (0x00, CR30)
                            Store (0x00, CR60)
                            Store (0x00, CR61)
                            Store (0x00, CR70)
                            EXFG ()
                        }

                        Name (RSRC, Buffer (0x0D)
                        {
                            0x47, 0x01, 0xF8, 0x03, 0xF8, 0x03, 0x01, 0x08,
                            0x22, 0x10, 0x00, 0x79, 0x00
                        })
                        Method (_CRS, 0, NotSerialized)
                        {
                            CreateWordField (RSRC, 0x02, IO1L)
                            CreateWordField (RSRC, 0x04, IO1H)
                            CreateWordField (RSRC, 0x09, IRQX)
                            Store (Zero, IO1L)
                            Store (Zero, IO1H)
                            Store (Zero, IRQX)
                            ENFG (0x04)
                            And (CR30, 0x01, Local0)
                            If (Local0)
                            {
                                Store (CR60, IO1L)
                                ShiftLeft (IO1L, 0x08, Local1)
                                Or (CR61, Local1, Local2)
                                Store (Local2, IO1L)
                                Store (Local2, IO1H)
                                Store (CR70, Local1)
                                ShiftLeft (One, Local1, IRQX)
                            }
                            Else
                            {
                                Store (Zero, IO1L)
                                Store (Zero, IO1H)
                                Store (Zero, IRQX)
                            }

                            EXFG ()
                            Return (RSRC)
                        }

                        Name (_PRS, Buffer (0x37)
                        {
                            0x31, 0x04, 0x47, 0x01, 0xF8, 0x03, 0xF8, 0x03,
                            0x01, 0x08, 0x22, 0x10, 0x00, 0x31, 0x04, 0x47,
                            0x01, 0xF8, 0x02, 0xF8, 0x02, 0x01, 0x08, 0x22,
                            0x08, 0x00, 0x31, 0x04, 0x47, 0x01, 0xE8, 0x03,
                            0xE8, 0x03, 0x01, 0x08, 0x22, 0x10, 0x00, 0x31,
                            0x04, 0x47, 0x01, 0xE8, 0x02, 0xE8, 0x02, 0x01,
                            0x08, 0x22, 0x08, 0x00, 0x38, 0x79, 0x00
                        })
                        Method (_SRS, 1, NotSerialized)
                        {
                            Store (Arg0, RSRC)
                            CreateWordField (RSRC, 0x02, IO1L)
                            CreateWordField (RSRC, 0x09, IRQX)
                            ENFG (0x04)
                            And (IO1L, 0xFF, CR61)
                            ShiftRight (IO1L, 0x08, CR60)
                            FindSetRightBit (IRQX, Local0)
                            If (Local0)
                            {
                                Decrement (Local0)
                            }

                            Store (Local0, CR70)
                            Store (0x01, CR30)
                            EXFG ()
                        }

                        Name (_PRW, Package (0x02)
                        {
                            0x0A,
                            0x04
                        })
                        Name (SV60, 0x00)
                        Name (SV61, 0x00)
                        Name (IRQV, 0x00)
                        Method (SAVE, 0, NotSerialized)
                        {
                            ENFG (0x04)
                            And (CR30, 0x01, Local0)
                            If (Local0)
                            {
                                Store (CR60, SV60)
                                Store (CR61, SV61)
                                Store (CR70, IRQV)
                            }

                            EXFG ()
                        }

                        Method (REST, 0, NotSerialized)
                        {
                            If (LNot (LEqual (SV60, Zero)))
                            {
                                ENFG (0x04)
                                Or (CR30, 0x01, CR30)
                                Store (SV60, CR60)
                                Store (SV61, CR61)
                                Store (IRQV, CR70)
                                EXFG ()
                            }
                        }
                    }

                    Device (FIR)
                    {
                        Name (_HID, EisaId ("ALI5123"))
                        Name (_CID, 0x1005D041)
                        Method (_STA, 0, NotSerialized)
                        {
                            ENFG (0x05)
                            And (CR22, 0x20, Local0)
                            And (CR30, 0x81, Local1)
                            EXFG ()
                            If (Local0)
                            {
                                Return (0x00)
                            }
                            Else
                            {
                                If (And (Local1, 0x80))
                                {
                                    If (And (Local1, 0x01))
                                    {
                                        Return (0x0F)
                                    }
                                    Else
                                    {
                                        Return (0x0D)
                                    }
                                }
                                Else
                                {
                                    Return (0x00)
                                }
                            }
                        }

                        Method (_DIS, 0, NotSerialized)
                        {
                            ENFG (0x05)
                            And (CR30, 0xFE, CR30)
                            EXFG ()
                        }

                        Name (RSRC, Buffer (0x10)
                        {
                            0x47, 0x01, 0x00, 0x01, 0x00, 0x01, 0x01, 0x08,
                            0x22, 0x00, 0x00, 0x2A, 0x00, 0x00, 0x79, 0x00
                        })
                        Method (_CRS, 0, NotSerialized)
                        {
                            CreateWordField (RSRC, 0x02, IO1L)
                            CreateWordField (RSRC, 0x04, IO1H)
                            CreateWordField (RSRC, 0x09, IRQX)
                            CreateWordField (RSRC, 0x0C, DMAX)
                            ENFG (0x05)
                            And (CR30, 0x01, Local0)
                            If (Local0)
                            {
                                Store (CR60, IO1L)
                                ShiftLeft (IO1L, 0x08, Local1)
                                Or (CR61, Local1, Local2)
                                Store (Local2, IO1L)
                                Store (Local2, IO1H)
                                Store (CR70, Local1)
                                ShiftLeft (One, Local1, IRQX)
                                Store (CR74, Local2)
                                ShiftLeft (One, Local2, DMAX)
                            }
                            Else
                            {
                                Store (Zero, IO1L)
                                Store (Zero, IO1H)
                                Store (Zero, IRQX)
                                Store (0x04, DMAX)
                            }

                            EXFG ()
                            Return (RSRC)
                        }

                        Name (_PRS, Buffer (0x93)
                        {
                            0x31, 0x04, 0x47, 0x01, 0xF8, 0x02, 0xF8, 0x02,
                            0x01, 0x08, 0x22, 0x08, 0x00, 0x2A, 0x01, 0x00,
                            0x31, 0x04, 0x47, 0x01, 0xE8, 0x02, 0xE8, 0x02,
                            0x01, 0x08, 0x22, 0x08, 0x00, 0x2A, 0x01, 0x00,
                            0x31, 0x04, 0x47, 0x01, 0xE8, 0x03, 0xE8, 0x03,
                            0x01, 0x08, 0x22, 0x10, 0x00, 0x2A, 0x01, 0x00,
                            0x31, 0x04, 0x47, 0x01, 0xF8, 0x02, 0xF8, 0x02,
                            0x01, 0x08, 0x22, 0x08, 0x00, 0x2A, 0x02, 0x00,
                            0x31, 0x04, 0x47, 0x01, 0xE8, 0x02, 0xE8, 0x02,
                            0x01, 0x08, 0x22, 0x08, 0x00, 0x2A, 0x02, 0x00,
                            0x31, 0x04, 0x47, 0x01, 0xE8, 0x03, 0xE8, 0x03,
                            0x01, 0x08, 0x22, 0x10, 0x00, 0x2A, 0x02, 0x00,
                            0x31, 0x04, 0x47, 0x01, 0xF8, 0x02, 0xF8, 0x02,
                            0x01, 0x08, 0x22, 0x08, 0x00, 0x2A, 0x08, 0x00,
                            0x31, 0x04, 0x47, 0x01, 0xE8, 0x02, 0xE8, 0x02,
                            0x01, 0x08, 0x22, 0x08, 0x00, 0x2A, 0x08, 0x00,
                            0x31, 0x04, 0x47, 0x01, 0xE8, 0x03, 0xE8, 0x03,
                            0x01, 0x08, 0x22, 0x10, 0x00, 0x2A, 0x08, 0x00,
                            0x38, 0x79, 0x00
                        })
                        Method (_SRS, 1, NotSerialized)
                        {
                            Store (Arg0, RSRC)
                            CreateWordField (RSRC, 0x02, IO1L)
                            CreateWordField (RSRC, 0x09, IRQX)
                            CreateWordField (RSRC, 0x0C, DMAX)
                            ENFG (0x05)
                            And (IO1L, 0xFF, CR61)
                            ShiftRight (IO1L, 0x08, CR60)
                            FindSetRightBit (IRQX, Local0)
                            If (Local0)
                            {
                                Decrement (Local0)
                            }

                            Store (Local0, CR70)
                            FindSetRightBit (DMAX, Local1)
                            If (Local1)
                            {
                                Decrement (Local1)
                            }

                            Store (Local1, CR74)
                            Or (CR30, 0x01, CR30)
                            EXFG ()
                        }
                    }

                    Device (COM5)
                    {
                        Name (_HID, EisaId ("PNP0501"))
                        Name (_UID, 0x02)
                        Method (_STA, 0, NotSerialized)
                        {
                            If (\_SB.PCI0.PMU.PDID)
                            {
                                Return (0x00)
                            }

                            ENFG (0x04)
                            And (CR22, 0x10, Local0)
                            And (CR30, 0x01, Local1)
                            And (CRF1, 0x18, Local2)
                            EXFG ()
                            If (Local0)
                            {
                                Return (0x00)
                            }
                            Else
                            {
                                If (LEqual (Local2, 0x00))
                                {
                                    If (And (Local1, 0x01))
                                    {
                                        Return (0x0F)
                                    }
                                    Else
                                    {
                                        Return (0x0D)
                                    }
                                }
                                Else
                                {
                                    Return (0x00)
                                }
                            }
                        }

                        Method (_DIS, 0, NotSerialized)
                        {
                            ENFG (0x04)
                            Store (0x00, CR30)
                            Store (0x00, CR60)
                            Store (0x00, CR61)
                            Store (0x00, CR70)
                            EXFG ()
                        }

                        Name (RSRC, Buffer (0x0D)
                        {
                            0x47, 0x01, 0xF8, 0x03, 0xF8, 0x03, 0x01, 0x08,
                            0x22, 0x10, 0x00, 0x79, 0x00
                        })
                        Method (_CRS, 0, NotSerialized)
                        {
                            CreateWordField (RSRC, 0x02, IO1L)
                            CreateWordField (RSRC, 0x04, IO1H)
                            CreateWordField (RSRC, 0x09, IRQX)
                            Store (Zero, IO1L)
                            Store (Zero, IO1H)
                            Store (Zero, IRQX)
                            ENFG (0x04)
                            And (CR30, 0x01, Local0)
                            If (Local0)
                            {
                                Store (CR60, IO1L)
                                ShiftLeft (IO1L, 0x08, Local1)
                                Or (CR61, Local1, Local2)
                                Store (Local2, IO1L)
                                Store (Local2, IO1H)
                                Store (CR70, Local1)
                                ShiftLeft (One, Local1, IRQX)
                            }
                            Else
                            {
                                Store (Zero, IO1L)
                                Store (Zero, IO1H)
                                Store (Zero, IRQX)
                            }

                            EXFG ()
                            Return (RSRC)
                        }

                        Name (_PRS, Buffer (0x37)
                        {
                            0x31, 0x04, 0x47, 0x01, 0xF8, 0x03, 0xF8, 0x03,
                            0x01, 0x08, 0x22, 0x10, 0x00, 0x31, 0x04, 0x47,
                            0x01, 0xF8, 0x02, 0xF8, 0x02, 0x01, 0x08, 0x22,
                            0x08, 0x00, 0x31, 0x04, 0x47, 0x01, 0xE8, 0x03,
                            0xE8, 0x03, 0x01, 0x08, 0x22, 0x10, 0x00, 0x31,
                            0x04, 0x47, 0x01, 0xE8, 0x02, 0xE8, 0x02, 0x01,
                            0x08, 0x22, 0x08, 0x00, 0x38, 0x79, 0x00
                        })
                        Method (_SRS, 1, NotSerialized)
                        {
                            Store (Arg0, RSRC)
                            CreateWordField (RSRC, 0x02, IO1L)
                            CreateWordField (RSRC, 0x09, IRQX)
                            ENFG (0x04)
                            And (IO1L, 0xFF, CR61)
                            ShiftRight (IO1L, 0x08, CR60)
                            FindSetRightBit (IRQX, Local0)
                            If (Local0)
                            {
                                Decrement (Local0)
                            }

                            Store (Local0, CR70)
                            Store (0x01, CR30)
                            EXFG ()
                        }

                        Name (_PRW, Package (0x02)
                        {
                            0x0A,
                            0x04
                        })
                        Name (SV60, 0x00)
                        Name (SV61, 0x00)
                        Name (IRQV, 0x00)
                        Method (SAVE, 0, NotSerialized)
                        {
                            ENFG (0x04)
                            And (CR30, 0x01, Local0)
                            If (Local0)
                            {
                                Store (CR60, SV60)
                                Store (CR61, SV61)
                                Store (CR70, IRQV)
                            }

                            EXFG ()
                        }

                        Method (REST, 0, NotSerialized)
                        {
                            If (LNot (LEqual (SV60, Zero)))
                            {
                                ENFG (0x04)
                                Or (CR30, 0x01, CR30)
                                Store (SV60, CR60)
                                Store (SV61, CR61)
                                Store (IRQV, CR70)
                                EXFG ()
                            }
                        }
                    }

                    Mutex (MTIO, 0x00)
                }

                Device (EC0)
                {
                    Name (_HID, EisaId ("PNP0C09"))
                    Name (_CRS, Buffer (0x12)
                    {
                        0x47, 0x01, 0x62, 0x00, 0x62, 0x00, 0x01, 0x01,
                        0x47, 0x01, 0x66, 0x00, 0x66, 0x00, 0x01, 0x01,
                        0x79, 0x00
                    })
                    Name (_GPE, 0x18)
                    Name (SEL0, 0xF0)
                    Name (BFLG, 0x00)
                    Method (_REG, 2, NotSerialized)
                    {
                        If (LEqual (Arg0, 0x03))
                        {
                            Store (Arg1, ECEN)
                            Acquire (MUT1, 0xFFFF)
                            Store (ADP, Local0)
                            Release (MUT1)
                            If (Local0)
                            {
                                Store (0x00, \_SB.PCI0.PMU.CRUN)
                                If (KT6F)
                                {
                                    Store (0x00, TREN)
                                }
                            }
                            Else
                            {
                                Store (0x01, \_SB.PCI0.PMU.CRUN)
                                If (KT6F)
                                {
                                    Store (0x04, TRDC)
                                    Store (0x01, TREN)
                                }
                            }
                        }
                    }

                    OperationRegion (ERAM, EmbeddedControl, 0x00, 0xFF)
                    Field (ERAM, ByteAcc, Lock, Preserve)
                    {
                        Offset (0x04),
                        CMCM,   8,
                        CMD1,   8,
                        CMD2,   8,
                        CMD3,   8,
                        Offset (0x18),
                        SMPR,   8,
                        SMST,   8,
                        SMAD,   8,
                        SMCM,   8,
                        SMD0,   256,
                        BCNT,   8,
                        SMAA,   8,
                        S1D0,   8,
                        S1D1,   8,
                        SM2A,   8,
                        S2D0,   8,
                        S2D1,   8,
                        SM3A,   8,
                        LIDS,   1,
                        DV1S,   1,
                        EXFD,   1,
                        RFSW,   1,
                            ,   1,
                        CRTS,   1,
                        SLPS,   1,
                        DCKS,   1,
                        EJBS,   1,
                            ,   1,
                            ,   1,
                            ,   1,
                            ,   1,
                            ,   1,
                        DV2S,   1,
                        DV3S,   1,
                        WK10,   16,
                        EVTP,   16,
                        BTM3,   8,
                        DCID,   8,
                        DPWR,   1,
                        UDR0,   1,
                        UDR5,   1,
                        EQBF,   1,
                        LDDS,   1,
                        CRST,   1,
                        DCWT,   1,
                        QVCC,   1,
                        HP4D,   8,
                        WAKP,   16,
                        POLL,   1,
                        ADP,    1,
                        ALRT,   1,
                        B1WE,   1,
                        B1WS,   1,
                        B2WE,   1,
                        B2WS,   1,
                        BWAK,   1,
                        PWRE,   1,
                        ALLB,   1,
                        AUXB,   1,
                        S2DR,   1,
                        F1B4,   1,
                        F1B5,   1,
                        F1B6,   1,
                        RSMA,   1,
                        S1LD,   1,
                        S2LD,   1,
                        ACWR,   1,
                        PTSV,   3,
                        PMEE,   1,
                        ENCB,   1,
                        F3B0,   1,
                        F3B1,   1,
                        RFLD,   1,
                        F3B3,   1,
                        F3B4,   1,
                        WOLE,   1,
                        WORE,   1,
                        S4FG,   1,
                        TMSS,   2,
                        OSMD,   1,
                        F4B3,   1,
                        BANK,   4,
                        CTMP,   8,
                        S2DC,   8,
                        BPD,    8,
                        BT1I,   16,
                        BT1C,   16,
                        BT1V,   16,
                        BT1S,   8,
                        BT2I,   16,
                        BT2C,   16,
                        BT2V,   16,
                        BT2S,   8,
                        Q8CF,   1,
                            ,   3,
                        KLED,   1,
                        Offset (0x67),
                        TTMP,   8,
                        HPCB,   8,
                        R69F,   2,
                            ,   1,
                        Offset (0x6A),
                        BTEC,   8,
                        UBDM,   4,
                        UBPC,   3,
                        Offset (0x6C),
                        BTCS,   8,
                        BMDL,   8,
                        CBDM,   4,
                        CBPC,   3,
                        Offset (0x6F),
                        HP6F,   8,
                        HP70,   8,
                        TRDV,   8,
                        RSMT,   16,
                        PWSL,   8,
                        PWSM,   8,
                            ,   1,
                            ,   1,
                        PREF,   1,
                        UPP1,   1,
                        UPP2,   1,
                            ,   1,
                            ,   1,
                        BTOF,   1,
                        SUSB,   1,
                        SUSC,   1,
                        CPWR,   1,
                        CBTN,   1,
                        FAN,    1,
                            ,   1,
                            ,   1,
                        S4IN,   1,
                        FANL,   16,
                        QU7A,   8,
                        QU7B,   8,
                        QU7C,   8,
                        QU7D,   8,
                        QU7E,   8,
                        QU7F,   8
                    }

                    Field (ERAM, ByteAcc, NoLock, Preserve)
                    {
                        Offset (0x1C),
                        SMW0,   16
                    }

                    Field (ERAM, ByteAcc, NoLock, Preserve)
                    {
                        Offset (0x1C),
                        SMB0,   8
                    }

                    Field (ERAM, ByteAcc, NoLock, Preserve)
                    {
                        Offset (0x1C),
                        FLD0,   64
                    }

                    Field (ERAM, ByteAcc, NoLock, Preserve)
                    {
                        Offset (0x1C),
                        FLD1,   128
                    }

                    Field (ERAM, ByteAcc, NoLock, Preserve)
                    {
                        Offset (0x1C),
                        FLD2,   192
                    }

                    Field (ERAM, ByteAcc, NoLock, Preserve)
                    {
                        Offset (0x1C),
                        FLD3,   256
                    }

                    Mutex (CMUT, 0x00)
                    Method (CMC2, 3, NotSerialized)
                    {
                        Acquire (CMUT, 0xFFFF)
                        Store (Arg2, CMD2)
                        Store (Arg1, CMD1)
                        Store (Arg0, CMCM)
                        While (CMCM) {}
                        Release (CMUT)
                    }

                    Mutex (MUT0, 0x00)
                    Mutex (MUT1, 0x00)
                    Method (SMRD, 4, NotSerialized)
                    {
                        If (LNot (ECOK ()))
                        {
                            Return (0xFF)
                        }

                        If (LNot (LEqual (Arg0, 0x07)))
                        {
                            If (LNot (LEqual (Arg0, 0x09)))
                            {
                                If (LNot (LEqual (Arg0, 0x0B)))
                                {
                                    Return (0x19)
                                }
                            }
                        }

                        Acquire (MUT0, 0xFFFF)
                        Store (0x04, Local0)
                        While (LGreater (Local0, 0x01))
                        {
                            And (SMST, 0x40, SMST)
                            Store (Arg2, SMCM)
                            Store (Arg1, SMAD)
                            Store (Arg0, SMPR)
                            While (LNot (And (SMST, 0xBF, Local1)))
                            {
                                Sleep (0x02)
                            }

                            If (LEqual (Local1, 0x80))
                            {
                                Store (0x00, Local0)
                            }
                            Else
                            {
                                Decrement (Local0)
                            }
                        }

                        If (Local0)
                        {
                            Store (And (Local1, 0x1F), Local0)
                        }
                        Else
                        {
                            If (LEqual (Arg0, 0x07))
                            {
                                Store (SMB0, Arg3)
                            }

                            If (LEqual (Arg0, 0x09))
                            {
                                Store (SMW0, Arg3)
                            }

                            If (LEqual (Arg0, 0x0B))
                            {
                                Store (BCNT, Local3)
                                ShiftRight (0x0100, 0x03, Local2)
                                If (LGreater (Local3, Local2))
                                {
                                    Store (Local2, Local3)
                                }

                                If (LLess (Local3, 0x09))
                                {
                                    Store (FLD0, Local2)
                                }
                                Else
                                {
                                    If (LLess (Local3, 0x11))
                                    {
                                        Store (FLD1, Local2)
                                    }
                                    Else
                                    {
                                        If (LLess (Local3, 0x19))
                                        {
                                            Store (FLD2, Local2)
                                        }
                                        Else
                                        {
                                            Store (FLD3, Local2)
                                        }
                                    }
                                }

                                Increment (Local3)
                                Store (Buffer (Local3) {}, Local4)
                                Decrement (Local3)
                                Store (Zero, Local5)
                                While (LGreater (Local3, Local5))
                                {
                                    GBFE (Local2, Local5, RefOf (Local6))
                                    PBFE (Local4, Local5, Local6)
                                    Increment (Local5)
                                }

                                PBFE (Local4, Local5, 0x00)
                                Store (Local4, Arg3)
                            }
                        }

                        Release (MUT0)
                        Return (Local0)
                    }

                    Method (SMWR, 4, NotSerialized)
                    {
                        If (LNot (ECOK ()))
                        {
                            Return (0xFF)
                        }

                        If (LNot (LEqual (Arg0, 0x06)))
                        {
                            If (LNot (LEqual (Arg0, 0x08)))
                            {
                                If (LNot (LEqual (Arg0, 0x0A)))
                                {
                                    Return (0x19)
                                }
                            }
                        }

                        Acquire (MUT0, 0xFFFF)
                        Store (0x04, Local0)
                        While (LGreater (Local0, 0x01))
                        {
                            If (LEqual (Arg0, 0x06))
                            {
                                Store (Arg3, SMB0)
                            }

                            If (LEqual (Arg0, 0x08))
                            {
                                Store (Arg3, SMW0)
                            }

                            If (LEqual (Arg0, 0x0A))
                            {
                                Store (Arg3, SMD0)
                            }

                            And (SMST, 0x40, SMST)
                            Store (Arg2, SMCM)
                            Store (Arg1, SMAD)
                            Store (Arg0, SMPR)
                            While (LNot (And (SMST, 0xBF, Local1)))
                            {
                                Sleep (0x02)
                            }

                            If (LEqual (Local1, 0x80))
                            {
                                Store (0x00, Local0)
                            }
                            Else
                            {
                                Decrement (Local0)
                            }
                        }

                        If (Local0)
                        {
                            Store (And (Local1, 0x1F), Local0)
                        }

                        Release (MUT0)
                        Return (Local0)
                    }

                    Name (ACFL, 0x00)
                    Method (SMSL, 0, NotSerialized)
                    {
                        Store ("CMBatt - SMSL", Debug)
                        If (LNot (ECOK ()))
                        {
                            Return (0xFF)
                        }

                        Acquire (\_SB.PCI0.ISA.EC0.MUT1, 0xFFFF)
                        If (LNot (\_SB.PCI0.ISA.EC0.SMRD (0x09, 0x14, 0x01, RefOf (Local0))))
                        {
                            Store (Local0, SEL0)
                            Store (SEL0, Debug)
                            If (LEqual (ALRT, 0x01))
                            {
                                \_SB.BAT1.IVBI ()
                                \_SB.BAT1.IVBS ()
                                Store (0x00, ALRT)
                            }

                            Store (\_SB.ACAD.CHAC (SEL0), Local1)
                            Store (\_SB.BAT1.CHBP (SEL0), Local2)
                            Or (SEL0, 0x0FFF, Local0)
                            SMWR (0x08, 0x14, 0x01, Local0)
                            If (LAnd (Local1, \_SB.ACAD.ACP))
                            {
                                Store ("CMBatt - Notify(ACAD,0x80): AC_Inserted", Debug)
                                Store (0x00, \_SB.PCI0.PMU.CRUN)
                                Store (0x00, TRDC)
                                Store (0x00, TREN)
                                Notify (\_SB.ACAD, 0x80)
                                Store (0x02, ACFL)
                            }

                            If (And (0x04, Local2))
                            {
                                \_SB.BAT1.B1CK ()
                            }

                            If (And (0x02, Local2))
                            {
                                \_SB.BAT1.B1ST ()
                            }

                            If (And (0x01, Local2))
                            {
                                \_SB.BAT1.B1IF ()
                            }

                            If (LAnd (Local1, LNot (\_SB.ACAD.ACP)))
                            {
                                Store ("CMBatt - Notify(ACAD, 0x80): AC_Removed", Debug)
                                Store (0x01, \_SB.PCI0.PMU.CRUN)
                                If (KT6F)
                                {
                                    Store (0x04, TRDC)
                                    Store ("AC remove! Set Throttle Duty Cycle ---: ", Debug)
                                    Store (TRDC, Debug)
                                    Store (0x01, TREN)
                                }

                                Notify (\_SB.ACAD, 0x80)
                                Store (0x01, ACFL)
                            }
                        }

                        Store (0x3C, Local4)
                        If (\_SB.BAT1.REPT)
                        {
                            Store (0x02, Local4)
                        }

                        If (BFLG)
                        {
                            Store (0x01, Local5)
                            While (LNot (And (BFLG, 0x01)))
                            {
                                Increment (Local5)
                                ShiftRight (BFLG, 0x01, BFLG)
                            }

                            ShiftRight (BFLG, 0x01, BFLG)
                            If (LGreater (Local4, Local5))
                            {
                                Store (Local5, Local4)
                            }
                        }

                        Store (Local4, BPD)
                        BPOL ()
                        Release (\_SB.PCI0.ISA.EC0.MUT1)
                        If (ACFL)
                        {
                            Decrement (ACFL)
                            Store (\_SB.PCI0.ISA.HPSS (0x12, ACFL), Local0)
                            CMC2 (0xC4, Local0, 0x82)
                            Notify (HPCI, 0x8A)
                            Store (0x00, ACFL)
                            Store (0x01, \_SB.ACCG)
                            Notify (\_TZ.THRM, 0x80)
                        }
                    }

                    Name (PSTA, 0x00)
                    Method (CPOL, 0, NotSerialized)
                    {
                        If (LEqual (PSTA, 0x00))
                        {
                            If (ECOK ())
                            {
                                BPOL ()
                                Store (0x01, PSTA)
                            }
                        }
                    }

                    Method (BPOL, 0, NotSerialized)
                    {
                        Store (0x01, POLL)
                    }

                    Method (_Q09, 0, NotSerialized)
                    {
                        Store ("QUERY_09", Debug)
                        SMSL ()
                        If (\_SB.S4WF)
                        {
                            Store (0x00, \_SB.S4WF)
                            \_SB.PCI0.ISA.EC0._Q8D ()
                        }
                    }

                    Method (_Q10, 0, NotSerialized)
                    {
                        Notify (\_SB.PCI0.ISA.HPCI, 0x90)
                    }

                    Method (_Q11, 0, NotSerialized)
                    {
                        If (ACWR)
                        {
                            Notify (\_SB.PCI0.ISA.HPCI, 0x91)
                        }
                        Else
                        {
                            Notify (\_SB.PCI0.ISA.HPCI, 0x93)
                        }
                    }

                    Method (_Q12, 0, NotSerialized)
                    {
                        Notify (\_SB.PCI0.ISA.HPCI, 0x92)
                    }

                    Method (_Q20, 0, NotSerialized)
                    {
                        Store ("QUERY_20", Debug)
                        If (And (SMST, 0x40))
                        {
                            Store (SMAA, Local0)
                            If (LEqual (Local0, 0x14))
                            {
                                And (SMST, 0xBF, SMST)
                                If (PWRE)
                                {
                                    Store ("CMBatt - PwrEvent", Debug)
                                    Store (0x00, PWRE)
                                    Store (0x12, BFLG)
                                    Store (0x00, BPD)
                                    BPOL ()
                                }
                            }
                        }
                    }

                    Method (_Q03, 0, NotSerialized)
                    {
                        If (LEqual (\_SB.PCI0.AGPB.VGA.DISW, 0x00))
                        {
                            \_SB.PCI0.AGPB.VGA.DRUL (0x01)
                        }
                        Else
                        {
                            If (LEqual (\_SB.PCI0.AGPB.VGA.DISW, 0x01))
                            {
                                \_SB.PCI0.ISA.HPSS (0x01, 0x00)
                            }
                        }
                    }

                    Method (_Q04, 0, NotSerialized)
                    {
                        Store ("Q04 - Fn+F12 Pressed! --- Hibernation ---", Debug)
                        Notify (\_SB.PCI0.ISA.HPCI, 0x86)
                    }

                    Method (_Q0A, 0, NotSerialized)
                    {
                        Store ("Brightness Down: _Q0A", Debug)
                        Store (\_SB.PCI0.ISA.HPSS (0x08, 0x00), Local0)
                        CMC2 (0xC4, Local0, 0x82)
                        Notify (HPCI, 0x8A)
                    }

                    Method (_Q0B, 0, NotSerialized)
                    {
                        Store ("Brightness Up: _Q0B", Debug)
                        Store (\_SB.PCI0.ISA.HPSS (0x08, 0x01), Local0)
                        CMC2 (0xC4, Local0, 0x82)
                        Notify (HPCI, 0x8A)
                    }

                    Method (_Q0C, 0, NotSerialized)
                    {
                        Store ("Brightness Up: _Q0C", Debug)
                        Store (\_SB.PCI0.ISA.HPCI.GFPR (), Local0)
                        Store (Local0, Debug)
                    }

                    Method (_Q80, 0, NotSerialized)
                    {
                        Store ("THERM: _Q80 - Thermal Change", Debug)
                        Store ("Notify _TZ.THRM , 0x80", Debug)
                        Notify (\_TZ.THRM, 0x80)
                    }

                    Method (_Q8B, 0, NotSerialized)
                    {
                        Notify (\_SB.PCI0.ISA.HPCI, 0x8B)
                    }

                    Method (_Q8C, 0, NotSerialized)
                    {
                        If (KT6F)
                        {
                            If (ECOK ())
                            {
                                Acquire (\_SB.PCI0.ISA.EC0.MUT1, 0xFFFF)
                                Store (TRDV, Local0)
                                Store (PWSM, Local1)
                                Release (\_SB.PCI0.ISA.EC0.MUT1)
                                Store ("_Q8C:Throttle Duty Cycle :", Debug)
                                Store (Local0, Debug)
                                Store ("Power Consumption Value :", Debug)
                                Store (Local1, Debug)
                                Store (Local0, TRDC)
                                If (LNot (Local0))
                                {
                                    Store (0x00, TREN)
                                }
                                Else
                                {
                                    Store (0x01, TREN)
                                }

                                Store (0x00, Q8CF)
                                Store (0x01, ACCG)
                                Notify (\_TZ.THRM, 0x80)
                            }
                        }
                    }

                    Method (_Q8D, 0, NotSerialized)
                    {
                        Store ("_Q8D:Port Replicator Event :", Debug)
                        Acquire (\_SB.PCI0.ISA.EC0.MUT1, 0xFFFF)
                        Store (PREF, Local0)
                        Release (\_SB.PCI0.ISA.EC0.MUT1)
                        If (Not (LEqual (\_SB.PRCT, Local0)))
                        {
                            Store (Local0, \_SB.PRCT)
                            If (\_SB.KT6F)
                            {
                                Notify (\_SB.PCI0.ISA.SIOD.COM1, 0x01)
                            }

                            If (LEqual (\_SB.PRCT, 0x01))
                            {
                                Store (">>> Docking Plug In ! <<<", Debug)
                            }
                            Else
                            {
                                Store (">>> Docking Plug Out ! <<<", Debug)
                            }
                        }
                    }

                    Method (_Q8E, 0, NotSerialized)
                    {
                        SMSL ()
                        Notify (\_SB.BAT1, 0x80)
                    }
                }

                Device (HPCI)
                {
                    Name (_HID, EisaId ("HWPC209"))
                    Name (Z004, 0x00)
                    Name (Z000, 0x00)
                    Method (_STA, 0, NotSerialized)
                    {
                        Return (0x0F)
                    }

                    Method (STAT, 1, NotSerialized)
                    {
                        Store (Arg0, Z004)
                        If (LEqual (\_SB.KT6F, 0x00))
                        {
                            If (LEqual (Z000, 0x00))
                            {
                                Store (0x01, Z000)
                                Notify (\_PR.CPU0, 0x81)
                            }
                        }
                    }

                    Method (GKBL, 0, NotSerialized)
                    {
                        Return (0x1B)
                    }

                    Method (GDCP, 0, NotSerialized)
                    {
                        Return (0x0033000F)
                    }

                    Method (GDBT, 0, NotSerialized)
                    {
                        Return (\_SB.PCI0.ISA.HPSS (0x08, 0x10))
                    }

                    Method (SDBT, 1, NotSerialized)
                    {
                        If (ECOK ())
                        {
                            Store (\_SB.PCI0.ISA.HPSS (0x08, Or (0x20, And (Arg0, 0x0F))), Local0)
                            \_SB.PCI0.ISA.EC0.CMC2 (0xC4, Local0, 0x82)
                        }
                    }

                    Method (GADP, 0, NotSerialized)
                    {
                        Return (\_SB.PCI0.ISA.HPSS (0x0F, 0x00))
                    }

                    Method (SADP, 1, NotSerialized)
                    {
                        And (Arg0, 0x01, \_SB.PCI0.AGPB.VGA.LCD._DGS)
                        ShiftRight (And (Arg0, 0x02), 0x01, \_SB.PCI0.AGPB.VGA.CRT._DGS)
                        ShiftRight (And (Arg0, 0x04), 0x02, \_SB.PCI0.AGPB.VGA.TV._DGS)
                        If (LEqual (\_SB.PCI0.AGPB.VGA.DISW, 0x00))
                        {
                            \_SB.PCI0.AGPB.VGA.DRUL (0x01)
                        }
                        Else
                        {
                            If (LEqual (\_SB.PCI0.AGPB.VGA.DISW, 0x01))
                            {
                                HPSS (0x01, 0x00)
                            }
                        }
                    }

                    Method (TGAD, 0, NotSerialized)
                    {
                        \_SB.PCI0.ISA.EC0._Q03 ()
                    }

                    Method (GFPR, 0, NotSerialized)
                    {
                        Acquire (\_SB.PCI0.ISA.PSMX, 0xFFFF)
                        Store (0x80, \_SB.PCI0.ISA.BCMD)
                        Store (0x14, \_SB.PCI0.ISA.DID)
                        Store (Zero, \_SB.PCI0.ISA.SMIC)
                        Store (\_SB.PCI0.ISA.PNLR, Local0)
                        Release (\_SB.PCI0.ISA.PSMX)
                        Return (Local0)
                    }

                    Method (GTVR, 0, NotSerialized)
                    {
                        Store (\_SB.PCI0.ISA.HPSS (0x10, 0x00), Local1)
                        If (Local1)
                        {
                            Store (0x02580320, Local0)
                        }
                        Else
                        {
                            Store (0x01E00280, Local0)
                        }

                        Return (Local0)
                    }

                    Method (SRFL, 1, NotSerialized)
                    {
                        If (Arg0)
                        {
                            Store (One, \_SB.PCI0.ISA.EC0.RFLD)
                        }
                        Else
                        {
                            Store (Zero, \_SB.PCI0.ISA.EC0.RFLD)
                        }
                    }

                    Name (MDLS, 0x03)
                    Name (DEVS, Package (0x09)
                    {
                        "01KT",
                        "BQ2060",
                        "4x2",
                        "02KT",
                        "BQ2060",
                        "4x2",
                        "04KT",
                        "BQ2060",
                        "4x2"
                    })
                    Method (GBID, 1, NotSerialized)
                    {
                        Store (0x00, Local0)
                        While (LGreater (MDLS, Local0))
                        {
                            Add (ShiftLeft (Local0, 0x01), Local0, Local1)
                            Store (S2BF (DerefOf (Index (DEVS, Local1))), Local2)
                            If (BCMP (Arg0, Local2))
                            {
                                Return (Local0)
                            }

                            Increment (Local0)
                        }

                        Return (0xFF)
                    }

                    Method (BCMP, 2, NotSerialized)
                    {
                        Store (SizeOf (Arg0), Local0)
                        If (LNot (LEqual (SizeOf (Arg1), Local0)))
                        {
                            Return (Zero)
                        }

                        Store (0x00, Local1)
                        While (LGreater (Local0, Local1))
                        {
                            Store (DerefOf (Index (Arg0, Local1)), Local2)
                            Store (DerefOf (Index (Arg1, Local1)), Local3)
                            If (LNot (LEqual (Local2, Local3)))
                            {
                                Return (Zero)
                            }

                            Increment (Local1)
                        }

                        Return (Ones)
                    }

                    Method (SBDN, 1, NotSerialized)
                    {
                        If (LNot (ECOK ()))
                        {
                            Store (0xFF, \_SB.PCI0.ISA.EC0.BMDL)
                            Store (0x06, \_SB.PCI0.ISA.EC0.BTEC)
                        }
                        Else
                        {
                            Store (Arg0, \_SB.PCI0.ISA.EC0.UBDM)
                            Store (DerefOf (Index (\_SB.BAT1.PBIF, 0x09)), Local0)
                            Store (\_SB.PCI0.ISA.HPCI.GBID (Local0), Local1)
                            Store (Local1, \_SB.PCI0.ISA.EC0.BMDL)
                            If (LEqual (Local1, 0xFF))
                            {
                                Store (0x06, \_SB.PCI0.ISA.EC0.BTEC)
                            }
                        }
                    }

                    Method (GBDN, 0, NotSerialized)
                    {
                        If (LNot (ECOK ()))
                        {
                            Return (0xFF)
                        }

                        Store (\_SB.PCI0.ISA.EC0.CBDM, Local0)
                        Store (Local0, Debug)
                        Return (Local0)
                    }

                    Method (GBPN, 0, NotSerialized)
                    {
                        If (LNot (ECOK ()))
                        {
                            Return (0xFF)
                        }

                        Store (And (0x0F, \_SB.PCI0.ISA.EC0.SEL0), Local0)
                        Store (Local0, Debug)
                        Return (Local0)
                    }

                    Method (SBPC, 1, NotSerialized)
                    {
                        If (ECOK ())
                        {
                            Store (Arg0, \_SB.PCI0.ISA.EC0.UBPC)
                        }
                    }

                    Method (GBPC, 0, NotSerialized)
                    {
                        If (LNot (ECOK ()))
                        {
                            Return (0xFF)
                        }

                        Store (\_SB.PCI0.ISA.EC0.CBPC, Local0)
                        Store (Local0, Debug)
                        Return (Local0)
                    }

                    Method (GBEC, 0, NotSerialized)
                    {
                        If (LNot (ECOK ()))
                        {
                            Return (0xFF)
                        }

                        Store (\_SB.PCI0.ISA.EC0.BTEC, Local0)
                        Store (0x00, \_SB.PCI0.ISA.EC0.BTEC)
                        Store (Local0, Debug)
                        Return (Local0)
                    }

                    Method (GBCS, 0, NotSerialized)
                    {
                        If (LNot (ECOK ()))
                        {
                            Return (0xFF)
                        }

                        Store (\_SB.PCI0.ISA.EC0.BTCS, Debug)
                        Return (\_SB.PCI0.ISA.EC0.BTCS)
                    }

                    Method (GBSD, 0, NotSerialized)
                    {
                        Name (PBSD, Package (0x08)
                        {
                            "",
                            "",
                            "",
                            "",
                            "",
                            0xFFFF,
                            0xFFFF,
                            0xFFFF
                        })
                        If (LNot (ECOK ()))
                        {
                            Return (PBSD)
                        }

                        Store (\_SB.PCI0.ISA.EC0.BMDL, Local0)
                        If (LNot (LLess (Local0, MDLS)))
                        {
                            Return (PBSD)
                        }

                        Add (ShiftLeft (Local0, 0x01), Local0, Local0)
                        Store (\_SB.BAT1.PBIF, Local1)
                        Store (DerefOf (Index (Local1, 0x0C)), Index (PBSD, 0x00))
                        Store (DerefOf (Index (DEVS, Add (Local0, 0x01))), Local2)
                        Store (Local2, Index (PBSD, 0x01))
                        Store (DerefOf (Index (DEVS, Local0)), Local2)
                        Store (Local2, Index (PBSD, 0x02))
                        Store (DerefOf (Index (Local1, 0x0B)), Index (PBSD, 0x03))
                        Store (DerefOf (Index (DEVS, Add (Local0, 0x02))), Local2)
                        Store (Local2, Index (PBSD, 0x04))
                        Store (\_SB.BAT1.BATS, Index (PBSD, 0x05))
                        Store (DerefOf (Index (Local1, 0x04)), Index (PBSD, 0x06))
                        Store (DerefOf (Index (Local1, 0x01)), Index (PBSD, 0x07))
                        Store (PBSD, Debug)
                        Return (PBSD)
                    }

                    Method (GBHD, 0, NotSerialized)
                    {
                        Name (DBHD, Package (0x03)
                        {
                            0xFFFF,
                            0xFFFF,
                            0xFFFF
                        })
                        If (LNot (ECOK ()))
                        {
                            Return (DBHD)
                        }

                        Store (\_SB.BAT1.PBHD, Local0)
                        Store (Local0, Debug)
                        Return (Local0)
                    }

                    Name (DCNT, 0x00)
                    Method (GBDD, 0, NotSerialized)
                    {
                        Name (PBDD, Package (0x03)
                        {
                            0xFFFF,
                            0xFFFF,
                            0xFFFF
                        })
                        If (LNot (ECOK ()))
                        {
                            Return (PBDD)
                        }

                        Increment (DCNT)
                        If (LEqual (DCNT, 0x14))
                        {
                            Store (0x00, DCNT)
                        }

                        Store (\_SB.BAT1.BATI, Index (PBDD, 0x00))
                        If (LNot (\_SB.PCI0.ISA.EC0.SMRD (0x09, 0x16, 0x0F, RefOf (Local5))))
                        {
                            Store (Local5, Index (PBDD, 0x01))
                        }
                        Else
                        {
                            Store (\_SB.BAT1.BATC, Index (PBDD, 0x01))
                        }

                        Store (\_SB.BAT1.BATV, Index (PBDD, 0x02))
                        If (LEqual (DCNT, 0x00))
                        {
                            Store (0x00, \_SB.BAT1.UBHD)
                        }

                        Store (PBDD, Debug)
                        Return (PBDD)
                    }

                    Method (S2BF, 1, Serialized)
                    {
                        Add (SizeOf (Arg0), One, Local0)
                        Name (BUFF, Buffer (Local0) {})
                        Store (Arg0, BUFF)
                        Return (BUFF)
                    }

                    Name (DDA0, Ones)
                    Name (DDA1, Ones)
                    Name (DDA2, Ones)
                    Name (DDA3, Ones)
                    Name (DDA4, Ones)
                    Name (DDA5, Ones)
                    Name (DDA6, Ones)
                    Name (DDA7, Ones)
                    Name (DDA8, Ones)
                    Name (DDA9, Ones)
                }
            }

            Device (PMU)
            {
                Name (_ADR, 0x00110000)
                OperationRegion (PMUR, PCI_Config, 0x00, 0xFF)
                Field (PMUR, DWordAcc, NoLock, Preserve)
                {
                    Offset (0x85),
                        ,   4,
                        ,   1,
                    LLOW,   1,
                    LHGH,   1,
                    Offset (0x88),
                        ,   3,
                    LIDS,   1,
                    Offset (0x91),
                        ,   1,
                    CRTF,   1,
                    CRTR,   1,
                    Offset (0x97),
                        ,   1,
                    TVC,    1,
                    FIRC,   1,
                    COMC,   1,
                    Offset (0x98),
                    Z005,   1,
                    LPTC,   1,
                        ,   2,
                    CRTI,   1,
                    Offset (0xB1),
                        ,   3,
                    CRUN,   1,
                    Offset (0xB5),
                    PDID,   1
                }
            }
        }

        Device (PWRB)
        {
            Name (_HID, EisaId ("PNP0C0C"))
        }

        Device (LID)
        {
            Name (_HID, EisaId ("PNP0C0D"))
            Name (_PRW, Package (0x02)
            {
                0x03,
                0x03
            })
            Method (_LID, 0, NotSerialized)
            {
                If (\_SB.ECOK ())
                {
                    If (\_SB.PCI0.PMU.LIDS)
                    {
                        Store (0x00, \_SB.PCI0.PMU.LHGH)
                        Store (0x01, \_SB.PCI0.PMU.LLOW)
                        Acquire (\_SB.PCI0.ISA.EC0.MUT1, 0xFFFF)
                        Store (0x00, \_SB.PCI0.ISA.EC0.KLED)
                        Release (\_SB.PCI0.ISA.EC0.MUT1)
                        Return (0x01)
                    }
                    Else
                    {
                        Store (0x00, \_SB.PCI0.PMU.LLOW)
                        Store (0x01, \_SB.PCI0.PMU.LHGH)
                        Acquire (\_SB.PCI0.ISA.EC0.MUT1, 0xFFFF)
                        Store (0x01, \_SB.PCI0.ISA.EC0.KLED)
                        Release (\_SB.PCI0.ISA.EC0.MUT1)
                        Return (0x00)
                    }
                }
                Else
                {
                    If (\_SB.PCI0.PMU.LIDS)
                    {
                        Store (0x00, \_SB.PCI0.PMU.LHGH)
                        Store (0x01, \_SB.PCI0.PMU.LLOW)
                        Return (0x01)
                    }
                    Else
                    {
                        Store (0x00, \_SB.PCI0.PMU.LLOW)
                        Store (0x01, \_SB.PCI0.PMU.LHGH)
                        Return (0x00)
                    }
                }
            }
        }

        Device (ACAD)
        {
            Name (_HID, "ACPI0003")
            Name (_PCL, Package (0x01)
            {
                \_SB
            })
            Name (ACP, Ones)
            Method (_PSR, 0, NotSerialized)
            {
                Acquire (\_SB.PCI0.ISA.EC0.MUT1, 0xFFFF)
                Store ("CMBatt - _PSR", Debug)
                \_SB.PCI0.ISA.EC0.CPOL ()
                Store (ACP, Local0)
                If (Local0)
                {
                    Store (0x01, Local1)
                }
                Else
                {
                    Store (0x00, Local1)
                }

                Release (\_SB.PCI0.ISA.EC0.MUT1)
                Store (Local1, \_SB.PCI0.ISA.ACST)
                Return (Local1)
            }

            Method (CHAC, 1, NotSerialized)
            {
                Store (LGreater (And (Arg0, 0xF0), 0x80), Local0)
                If (LNot (LEqual (Local0, ACP)))
                {
                    Store (Local0, ACP)
                    Return (Ones)
                }
                Else
                {
                    Return (Zero)
                }
            }
        }

        Scope (\_TZ)
        {
            Name (TPTM, 0x0CA0)
            Name (TBSE, 0x0AAC)
            Name (TPC, 0x0E94)
            Name (PLCY, 0x00)
            Name (TOFF, 0xB4)
            Name (TPN0, 0x0CF0)
            Name (TPN1, 0x0D22)
            Name (TPN2, 0x0D40)
            Name (TPN3, 0x0D5E)
            Name (TPNC, 0x0D7C)
            Name (TPW0, 0x0D22)
            Name (TPW1, 0x0D54)
            Name (TPW2, 0x0D72)
            Name (TPW3, 0x0D90)
            Name (TPWC, 0x0DB8)
            Name (TPA0, 0x00)
            Name (TPA1, 0x00)
            Name (TPA2, 0x00)
            Name (TPA3, 0x00)
            Name (TPAC, 0x00)
            Name (TPAS, 0x0D68)
            Name (K6TA, 0x06)
            Name (K6TB, 0x03)
            Name (TRSG, 0x00)
            ThermalZone (THRM)
            {
                Method (_TMP, 0, NotSerialized)
                {
                    If (\_SB.ECOK ())
                    {
                        Acquire (\_SB.PCI0.ISA.EC0.MUT1, 0xFFFF)
                        Store (\_SB.PCI0.ISA.EC0.CTMP, Local0)
                        Release (\_SB.PCI0.ISA.EC0.MUT1)
                        Store ("Current Temperature C is ----------- ", Debug)
                        Store (Local0, Debug)
                        Store (Local0, Local2)
                        Multiply (Local0, 0x0A, Local1)
                        Add (Local1, TBSE, Local0)
                        If (\_SB.KT6F)
                        {
                            CHTL (Local0)
                        }

                        Return (Local0)
                    }
                    Else
                    {
                        Return (TPTM)
                    }
                }

                Method (CHTL, 1, NotSerialized)
                {
                    Store (Arg0, Local0)
                    If (LNot (LGreater (Local0, TPA0)))
                    {
                        If (LGreater (TRSG, 0x00))
                        {
                            If (\_SB.ACAD.ACP)
                            {
                                Store (0x00, TRDC)
                                Store (0x00, TREN)
                            }
                            Else
                            {
                                Store (0x04, TRDC)
                                Store (0x01, TREN)
                            }

                            Store (0x00, TRSG)
                        }
                    }
                    Else
                    {
                        Store (K6TB, Local1)
                        If (\_SB.ACAD.ACP)
                        {
                            Store (K6TA, Local1)
                        }

                        If (LNot (LLess (Local0, TPA1)))
                        {
                            If (LNot (LLess (Local0, TPA3)))
                            {
                                Subtract (Local1, 0x02, Local1)
                                Store (Local1, TRDC)
                                Store (0x01, TREN)
                                Store (0x03, TRSG)
                                Store ("Throttle Stage is >= Stage3 ", Debug)
                                Store (TRSG, Debug)
                                Store (Local1, Debug)
                            }
                            Else
                            {
                                If (LNot (LLess (Local0, TPA2)))
                                {
                                    If (LOr (LNot (LGreater (TRSG, 0x01)), \_SB.ACCG))
                                    {
                                        Subtract (Local1, 0x01, Local1)
                                        Store (Local1, TRDC)
                                        Store (0x01, TREN)
                                        Store (0x02, TRSG)
                                    }

                                    Store ("Throttle Stage is >= Stage2 ", Debug)
                                    Store (TRSG, Debug)
                                    Store (Local1, Debug)
                                }
                                Else
                                {
                                    If (LOr (LEqual (TRSG, 0x00), \_SB.ACCG))
                                    {
                                        Store (Local1, TRDC)
                                        Store (0x01, TREN)
                                        Store (0x01, TRSG)
                                    }

                                    Store ("Throttle Stage is >= Stage1 ", Debug)
                                    Store (TRSG, Debug)
                                    Store (Local1, Debug)
                                }
                            }
                        }
                    }

                    Store (0x00, \_SB.ACCG)
                }

                Name (_PSL, Package (0x01)
                {
                    \_PR.CPU0
                })
                Name (_TC1, 0x04)
                Name (_TC2, 0x03)
                Name (_TSP, 0x28)
                Method (_CRT, 0, NotSerialized)
                {
                    Store (TPAC, Local0)
                    If (LNot (\_SB.KT6F))
                    {
                        Store (TOFF, Local1)
                        ShiftRight (Local1, 0x01, Local1)
                        Subtract (TPC, Local1, Local0)
                    }

                    Return (Local0)
                }

                Method (_PSV, 0, NotSerialized)
                {
                    Return (TPAS)
                }

                Method (_SCP, 1, NotSerialized)
                {
                    Store (Arg0, PLCY)
                }
            }
        }

        Device (BAT1)
        {
            Name (_HID, EisaId ("PNP0C0A"))
            Name (_UID, 0x01)
            Name (_PCL, Package (0x01)
            {
                \_SB
            })
            Name (UBHD, 0x00)
            Name (PBHD, Package (0x03)
            {
                0xFFFF,
                0xFFFF,
                0xFFFF
            })
            Name (BATI, 0xFFFF)
            Name (BATC, 0xFFFF)
            Name (BATV, 0xFFFF)
            Name (BATS, 0xFFFF)
            Name (PBIF, Package (0x0D)
            {
                0x01,
                0x0B40,
                0x0B40,
                0x01,
                0x39D0,
                0x012C,
                0xC8,
                0x20,
                0x20,
                "BAT1",
                " ",
                " ",
                " "
            })
            Name (PBST, Package (0x04)
            {
                0x00,
                0xFFFFFFFF,
                0xFFFFFFFF,
                0x2710
            })
            Name (UBIF, 0x01E9)
            Name (BP, 0x00)
            Name (REPT, 0x00)
            Name (ERRC, 0x00)
            Method (_STA, 0, NotSerialized)
            {
                Acquire (\_SB.PCI0.ISA.EC0.MUT1, 0xFFFF)
                Store ("CMBatt - _STA.BAT1", Debug)
                \_SB.PCI0.ISA.EC0.CPOL ()
                If (BP)
                {
                    Store (0x1F, Local1)
                }
                Else
                {
                    Store (0x0F, Local1)
                }

                Release (\_SB.PCI0.ISA.EC0.MUT1)
                Return (Local1)
            }

            Method (_BIF, 0, NotSerialized)
            {
                Acquire (\_SB.PCI0.ISA.EC0.MUT1, 0xFFFF)
                Store ("CMBatt - _BIF.BAT1", Debug)
                \_SB.PCI0.ISA.EC0.CPOL ()
                Release (\_SB.PCI0.ISA.EC0.MUT1)
                Return (PBIF)
            }

            Method (_BST, 0, NotSerialized)
            {
                Acquire (\_SB.PCI0.ISA.EC0.MUT1, 0xFFFF)
                Store ("CMBatt - _BST.BAT1", Debug)
                \_SB.PCI0.ISA.EC0.CPOL ()
                Release (\_SB.PCI0.ISA.EC0.MUT1)
                Return (PBST)
            }

            Method (B1CK, 0, NotSerialized)
            {
                Store ("CMBatt - Notify(BAT1,0x81): B1CK", Debug)
                Notify (\_SB.BAT1, 0x81)
            }

            Method (B1ST, 0, NotSerialized)
            {
                Store ("CMBatt - Notify(BAT1,0x80): B1ST", Debug)
                Notify (\_SB.BAT1, 0x80)
            }

            Method (B1IF, 0, NotSerialized)
            {
                Store ("CMBatt - Notify(BAT1,0x81): B1IF", Debug)
                Notify (\_SB.BAT1, 0x81)
            }

            Method (UPBI, 0, NotSerialized)
            {
                Store ("CMBatt - UPBI.BAT1", Debug)
                Store (Zero, Local0)
                If (LNot (ECOK ()))
                {
                    Return (Local0)
                }

                Store (0x0C, Local1)
                Store (Buffer (0x0D)
                    {
                        0x00, 0x18, 0x10, 0x00, 0x19, 0x00, 0x00, 0x00,
                        0x00, 0x21, 0x00, 0x22, 0x20
                    }, Local2)
                While (LGreater (Local1, 0x08))
                {
                    If (LNot (And (UBIF, VTOB (Local1))))
                    {
                        GBFE (Local2, Local1, RefOf (Local3))
                        If (Local3)
                        {
                            If (LNot (\_SB.PCI0.ISA.EC0.SMRD (0x0B, 0x16, Local3, RefOf (Local4))))
                            {
                                Store (\_SB.PCI0.ISA.EC0.BCNT, Local5)
                                Store (Zero, Local3)
                                Store (Zero, ERRC)
                                While (LGreater (Local5, Local3))
                                {
                                    GBFE (Local4, Local3, RefOf (Local6))
                                    Increment (Local3)
                                    If (And (Local6, 0x80))
                                    {
                                        Increment (ERRC)
                                    }
                                }

                                If (LEqual (ERRC, 0x00))
                                {
                                    Store (Local4, Index (PBIF, Local1))
                                    Or (UBIF, VTOB (Local1), UBIF)
                                    Store (Ones, Local0)
                                }
                            }
                        }
                    }

                    Decrement (Local1)
                }

                While (LGreater (Local1, 0x00))
                {
                    If (LNot (And (UBIF, VTOB (Local1))))
                    {
                        GBFE (Local2, Local1, RefOf (Local3))
                        If (Local3)
                        {
                            If (LNot (\_SB.PCI0.ISA.EC0.SMRD (0x09, 0x16, Local3, RefOf (Local5))))
                            {
                                If (LAnd (Local5, LNot (And (Local5, 0x8000))))
                                {
                                    If (LEqual (Local1, 0x02))
                                    {
                                        ShiftRight (Local5, 0x05, Local5)
                                        ShiftLeft (Local5, 0x05, Local5)
                                    }

                                    Store (Local5, Index (PBIF, Local1))
                                    Or (UBIF, VTOB (Local1), UBIF)
                                    Store (Ones, Local0)
                                }
                            }
                        }
                    }

                    Decrement (Local1)
                }

                Store (0x0A, Local1)
                If (LNot (And (UBIF, VTOB (Local1))))
                {
                    If (LNot (\_SB.PCI0.ISA.EC0.SMRD (0x09, 0x16, 0x1C, RefOf (Local5))))
                    {
                        Store (Local5, BATS)
                        Store (ITOS (ToBCD (Local5)), Index (PBIF, Local1))
                        Or (UBIF, VTOB (Local1), UBIF)
                        Store (Ones, Local0)
                    }
                }

                Store (PBIF, Debug)
                Return (Local0)
            }

            Method (UPBS, 0, NotSerialized)
            {
                Store ("CMBatt - UPBS.BAT1", Debug)
                Store (Zero, Local0)
                If (LNot (ECOK ()))
                {
                    Return (Local0)
                }

                Store (\_SB.PCI0.ISA.EC0.BT1S, Local5)
                Store (Local5, Local1)
                And (Local5, 0x07, Local5)
                If (LNot (LEqual (Local5, DerefOf (Index (PBST, 0x00)))))
                {
                    Store ("CMBatt - BAT1 STATE CHANGE", Debug)
                    Store (Local1, Debug)
                    Store (Local5, Index (PBST, 0x00))
                    Store (Ones, Local0)
                }

                Store (\_SB.PCI0.ISA.EC0.BT1C, Local5)
                If (LNot (And (Local5, 0x8000)))
                {
                    Store (Local5, BATC)
                    ShiftRight (Local5, 0x05, Local5)
                    ShiftLeft (Local5, 0x05, Local5)
                    If (LNot (LEqual (Local5, DerefOf (Index (PBST, 0x02)))))
                    {
                        Store (Local5, Index (PBST, 0x02))
                        Store (Ones, Local0)
                    }
                }

                Store (\_SB.PCI0.ISA.EC0.BT1V, Local5)
                If (LNot (And (Local5, 0x8000)))
                {
                    Store (Local5, BATV)
                    ShiftRight (Local5, 0x05, Local5)
                    ShiftLeft (Local5, 0x05, Local5)
                    If (LNot (LEqual (Local5, DerefOf (Index (PBST, 0x03)))))
                    {
                        Store (Local5, Index (PBST, 0x03))
                        Store (Ones, Local0)
                    }
                }

                Store (\_SB.PCI0.ISA.EC0.BT1I, Local5)
                Store (Local5, BATI)
                If (And (BATI, 0x8000))
                {
                    Or (BATI, 0xFFFF0000, BATI)
                }

                If (And (Local1, 0x01))
                {
                    Store (\_SB.PCI0.ISA.EC0.BT1V, Local2)
                    If (LEqual (Local2, Zero))
                    {
                        Store (0x39D0, Local2)
                    }

                    Divide (0x01036640, Local2, , Local3)
                    If (And (Local5, 0x8000))
                    {
                        Or (Local5, 0xFFFF0000, Local5)
                        Add (Not (Local5), 0x01, Local5)
                        If (LGreater (Local3, Local5))
                        {
                            Store (Local3, Local5)
                        }
                    }
                    Else
                    {
                        Store (Local3, Local5)
                    }
                }

                If (And (Local1, 0x02))
                {
                    If (And (Local5, 0x8000))
                    {
                        Store (0x00, Local5)
                    }

                    If (LGreater (0x64, Local5))
                    {
                        Store (0x64, Local5)
                    }
                }

                If (LEqual (And (Local1, 0x03), 0x00))
                {
                    Store (0x00, Local5)
                }

                ShiftRight (Local5, 0x05, Local5)
                ShiftLeft (Local5, 0x05, Local5)
                If (LNot (LEqual (Local5, DerefOf (Index (PBST, 0x01)))))
                {
                    Store (Local5, Index (PBST, 0x01))
                    Store (Ones, Local0)
                }

                If (Local0)
                {
                    Store ("CMBATT - PBST Changed", Debug)
                }

                Store (PBST, Debug)
                Return (Local0)
            }

            Method (UPBH, 0, NotSerialized)
            {
                Store ("CMBatt - UPBH.BAT1", Debug)
                Store (Zero, Local0)
                If (LNot (ECOK ()))
                {
                    Return (Local0)
                }

                Store (0x00, Local1)
                Store (Buffer (0x03)
                    {
                        0x17, 0x0C, 0x10
                    }, Local2)
                While (LLess (Local1, 0x03))
                {
                    If (LNot (And (UBHD, VTOB (Local1))))
                    {
                        GBFE (Local2, Local1, RefOf (Local3))
                        If (LNot (\_SB.PCI0.ISA.EC0.SMRD (0x09, 0x16, Local3, RefOf (Local5))))
                        {
                            Store (Local5, Index (PBHD, Local1))
                            Or (UBHD, VTOB (Local1), UBHD)
                            Store (Ones, Local0)
                        }
                    }

                    Increment (Local1)
                }

                Store (PBHD, Debug)
                Return (Local0)
            }

            Method (IVBI, 0, NotSerialized)
            {
                Store (0x01E9, UBIF)
                Store (0x0B40, Index (PBIF, 0x01))
                Store (0x0B40, Index (PBIF, 0x02))
                Store (0x39D0, Index (PBIF, 0x04))
                Store ("Bad", Index (PBIF, 0x09))
                Store ("Bad", Index (PBIF, 0x0A))
                Store ("Bad", Index (PBIF, 0x0B))
                Store ("Bad", Index (PBIF, 0x0C))
            }

            Method (IVBS, 0, NotSerialized)
            {
                Store (0x00, Index (PBST, 0x00))
                Store (0xFFFFFFFF, Index (PBST, 0x01))
                Store (0xFFFFFFFF, Index (PBST, 0x02))
                Store (0x39D0, Index (PBST, 0x03))
            }

            Method (IVBH, 0, NotSerialized)
            {
                Store (0x00, UBHD)
                Store (0xFFFF, Index (PBHD, 0x00))
                Store (0xFFFF, Index (PBHD, 0x01))
                Store (0xFFFF, Index (PBHD, 0x02))
            }

            Method (CHBP, 1, NotSerialized)
            {
                Store ("CMBatt - CHBP.BAT1", Debug)
                Store (Zero, Local0)
                If (LNot (ECOK ()))
                {
                    Return (Local0)
                }

                Store (VTOB (Subtract (_UID, 0x01)), Local1)
                Or (ShiftLeft (Local1, 0x0C), 0x0FFF, Local2)
                Store (Zero, Local3)
                If (And (Arg0, Local1))
                {
                    If (BP)
                    {
                        Store ("CMBatt - BAT1 still present", Debug)
                        \_SB.PCI0.ISA.EC0.SMWR (0x08, 0x14, 0x01, Local2)
                        \_SB.PCI0.ISA.EC0.SMRD (0x09, 0x14, 0x01, RefOf (Local3))
                        If (LEqual (Local2, Or (Local3, 0x0FFF)))
                        {
                            If (UPBI ())
                            {
                                Or (0x01, Local0, Local0)
                            }

                            If (UPBS ())
                            {
                                Or (0x02, Local0, Local0)
                            }

                            UPBH ()
                        }
                    }
                    Else
                    {
                        Store ("CMBatt - BAT1 connected", Debug)
                        \_SB.PCI0.ISA.EC0.SMWR (0x08, 0x14, 0x01, Local2)
                        \_SB.PCI0.ISA.EC0.SMRD (0x09, 0x14, 0x01, RefOf (Local3))
                        If (LEqual (Local2, Or (Local3, 0x0FFF)))
                        {
                            UPBI ()
                            UPBS ()
                            UPBH ()
                        }

                        Store (0x01, BP)
                        Or (0x05, Local0, Local0)
                    }
                }
                Else
                {
                    If (BP)
                    {
                        Store ("CMBatt - BAT1 disconnected", Debug)
                        Store (0x00, BP)
                        IVBI ()
                        IVBS ()
                        IVBH ()
                        Or (0x04, Local0, Local0)
                    }
                }

                If (LAnd (And (Arg0, Local1), LNot (LEqual (UBIF, 0x1FFF))))
                {
                    Store (0x01, REPT)
                }
                Else
                {
                    Store (0x00, REPT)
                }

                Return (Local0)
            }
        }
    }

    Method (_PTS, 1, NotSerialized)
    {
        If (LEqual (Arg0, 0x01)) {}
        If (LEqual (Arg0, 0x03))
        {
            Store (0x01, \_SB.PCI0.ISA.EC0.WORE)
            Store (0x00, \_SB.PCI0.PMU.LLOW)
            Store (0x01, \_SB.PCI0.PMU.LHGH)
        }

        If (LEqual (Arg0, 0x04))
        {
            Store (0x01, \_SB.PCI0.ISA.EC0.S4FG)
            Store (0x00, \_SB.PCI0.ISA.EC0.WORE)
        }

        If (LEqual (Arg0, 0x05))
        {
            Store (0x00, \_SB.PCI0.ISA.EC0.WORE)
            If (\_SB.PCI0.ISA.WOLE)
            {
                Store (0x01, \_SB.PCI0.ISA.EC0.WOLE)
            }
            Else
            {
                Store (0x00, \_SB.PCI0.ISA.EC0.WOLE)
            }
        }
    }

    Method (_WAK, 1, NotSerialized)
    {
        If (\_SB.ECOK ())
        {
            If (\_SB.PCI0.ISA.EC0.ADP)
            {
                Store (0x00, \_SB.PCI0.PMU.CRUN)
            }
            Else
            {
                Store (0x01, \_SB.PCI0.PMU.CRUN)
            }
        }

        If (\_SB.ECOK ())
        {
            Store (\_SB.PCI0.ISA.HPSS (0x08, 0x11), Local0)
            \_SB.PCI0.ISA.EC0.CMC2 (0xC4, Local0, 0x82)
        }

        If (LEqual (Arg0, 0x01)) {}
        If (LEqual (Arg0, 0x03))
        {
            If (\_SB.PCI0.PMU.LIDS)
            {
                Store (0x00, \_SB.PCI0.PMU.LHGH)
                Store (0x01, \_SB.PCI0.PMU.LLOW)
            }
            Else
            {
                Store (0x00, \_SB.PCI0.PMU.LLOW)
                Store (0x01, \_SB.PCI0.PMU.LHGH)
            }

            If (\_SB.ECOK ())
            {
                If (\_SB.KT6F)
                {
                    Store (0x01, \_SB.S4WF)
                }

                Store (0x12, \_SB.PCI0.ISA.EC0.BFLG)
                Store (0x08, \_SB.PCI0.ISA.EC0.BPD)
                Acquire (\_SB.PCI0.ISA.EC0.MUT1, 0xFFFF)
                \_SB.PCI0.ISA.EC0.BPOL ()
                Release (\_SB.PCI0.ISA.EC0.MUT1)
            }
        }

        If (LEqual (Arg0, 0x04))
        {
            If (\_SB.ECOK ())
            {
                Acquire (\_SB.PCI0.ISA.EC0.MUT1, 0xFFFF)
                Store (\_SB.PCI0.ISA.EC0.ADP, Local0)
                Release (\_SB.PCI0.ISA.EC0.MUT1)
                If (\_SB.KT6F)
                {
                    If (Local0)
                    {
                        Store (0x00, TRDC)
                        Store (0x00, TREN)
                    }
                    Else
                    {
                        Store (0x04, TRDC)
                        Store (0x01, TREN)
                    }
                }
            }

            If (And (\_SB.ECOK (), \_SB.KT6F))
            {
                Store (0x01, \_SB.S4WF)
                Store (0x08, \_SB.PCI0.ISA.EC0.BPD)
                Acquire (\_SB.PCI0.ISA.EC0.MUT1, 0xFFFF)
                \_SB.PCI0.ISA.EC0.BPOL ()
                Release (\_SB.PCI0.ISA.EC0.MUT1)
            }
        }

        If (LEqual (Arg0, 0x05)) {}
    }

    Scope (_SI)
    {
        Method (_SST, 1, NotSerialized)
        {
            If (LEqual (Arg0, 0x01)) {}
            If (LEqual (Arg0, 0x02)) {}
            If (LEqual (Arg0, 0x03)) {}
            If (LEqual (Arg0, 0x04)) {}
        }
    }

    Scope (_GPE)
    {
        Method (_L03, 0, NotSerialized)
        {
            Notify (\_SB.LID, 0x80)
        }

        Method (_L08, 0, NotSerialized)
        {
            Notify (\_SB.PWRB, 0x02)
        }

        Method (_L09, 0, NotSerialized)
        {
            Notify (\_SB.PCI0, 0x02)
            Sleep (0x01F4)
            Notify (\_SB.PCI0.AGPB.VGA, 0x00)
        }

        Method (_L0A, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.MDEM, 0x02)
        }

        Method (_L0B, 0, NotSerialized)
        {
            Notify (\_SB.PWRB, 0x02)
        }

        Method (_L0D, 0, NotSerialized)
        {
            Notify (\_SB.PWRB, 0x02)
        }

        Method (_L23, 0, NotSerialized)
        {
            Notify (\_TZ.THRM, 0x80)
        }

        Method (_L24, 0, NotSerialized)
        {
            Sleep (0x01F4)
            If (\_SB.PCI0.PMU.CRTI)
            {
                Store (0x00, \_SB.PCI0.PMU.CRTR)
                Store (0x01, \_SB.PCI0.PMU.CRTF)
            }
            Else
            {
                Store (0x00, \_SB.PCI0.PMU.CRTF)
                Store (0x01, \_SB.PCI0.PMU.CRTR)
            }

            \_SB.PCI0.AGPB.VGA.DRUL (0x02)
        }
    }
}

machine		i386
cpu		I686_CPU
ident		PROUDHON
options 	SCHED_4BSD		#4BSD scheduler
options 	INET			#InterNETworking
options 	INET6			#IPv6 communications protocols
options 	FFS			#Berkeley Fast Filesystem
options 	SOFTUPDATES		#Enable FFS soft updates support
options 	UFS_ACL			#Support for access control lists
options 	UFS_DIRHASH		#Improve performance on big directories
options 	MD_ROOT			#MD is a potential root device
options 	NFSCLIENT		#Network Filesystem Client
options 	NFSSERVER		#Network Filesystem Server
options 	NFS_ROOT		#NFS usable as /, requires NFSCLIENT
options 	MSDOSFS			#MSDOS Filesystem
options 	CD9660			#ISO 9660 Filesystem
options 	PROCFS			#Process filesystem (requires PSEUDOFS)
options 	PSEUDOFS		#Pseudo-filesystem framework
options 	COMPAT_43		#Compatible with BSD 4.3 [KEEP THIS!]
options 	COMPAT_FREEBSD4		#Compatible with FreeBSD4
options 	KTRACE			#ktrace(1) support
options 	SYSVSHM			#SYSV-style shared memory
options 	SYSVMSG			#SYSV-style message queues
options 	SYSVSEM			#SYSV-style semaphores
options 	_KPOSIX_PRIORITY_SCHEDULING #Posix P1003_1B real-time extensions
options 	KBD_INSTALL_CDEV	# install a CDEV entry in /dev
options 	AHC_REG_PRETTY_PRINT	# Print register bitfields in debug
					# output.  Adds ~128k to driver.
options 	AHD_REG_PRETTY_PRINT	# Print register bitfields in debug
					# output.  Adds ~215k to driver.
options 	PFIL_HOOKS		# pfil(9) framework
options 	SMP			# Symmetric MultiProcessor Kernel
device		apic			# I/O APIC
device		isa
device		eisa
device		pci
device		ata
device		atadisk			# ATA disk drives
device		atapicd			# ATAPI CDROM drives
device		atapifd			# ATAPI floppy drives
device		atapist			# ATAPI tape drives
options 	ATA_STATIC_ID		#Static device numbering
device		scbus		# SCSI bus (required for SCSI)
device		pass		# Passthrough device (direct SCSI access)
device		atkbdc		# AT keyboard controller
device		atkbd		# AT keyboard
device		psm		# PS/2 mouse
device		vga		# VGA video card driver
device		splash		# Splash screen and screen saver support
device		sc
device		agp		# support several AGP chipsets
device		npx
device		pmtimer
device		cbb			# cardbus (yenta) bridge
device		pccard			# PC Card (16-bit) bus
device		cardbus			# CardBus (32-bit) bus
device		sio		# 8250, 16[45]50 based serial ports
device		sis		# Silicon Integrated Systems SiS 900/SiS 7016
device		wlan		# 802.11 support
device		wi		# WaveLAN/Intersil/Symbol 802.11 wireless NICs.
device		random		# Entropy device
device		loop		# Network loopback
device		ether		# Ethernet support
device		sl		# Kernel SLIP
device		ppp		# Kernel PPP
device		tun		# Packet tunnel.
device		pty		# Pseudo-ttys (telnet etc)
device		md		# Memory "disks"
device		gif		# IPv6 and IPv4 tunneling
device		faith		# IPv6-to-IPv4 relaying (translation)
device		bpf		# Berkeley packet filter
device		uhci		# UHCI PCI->USB interface
device		ohci		# OHCI PCI->USB interface
device		usb		# USB Bus (required)
device		ugen		# Generic
device		uhid		# "Human Interface Devices"
device		ukbd		# Keyboard
device		ulpt		# Printer
device		umass		# Disks/Mass storage - Requires scbus and da
device		ums		# Mouse
device		urio		# Diamond Rio 500 MP3 player
device		uscanner	# Scanners
device		miibus
device		aue		# ADMtek USB ethernet
device		axe		# ASIX Electronics USB ethernet
device		cue		# CATC USB ethernet
device		kue		# Kawasaki LSI USB ethernet
device		pcm
Received on Mon May 31 2004 - 10:16:53 UTC

This archive was generated by hypermail 2.4.0 : Wed May 19 2021 - 11:37:55 UTC