acpi_video on SONY VAIO PCG-Z1 [was: acpi_video users needed]

From: Vladimir Grebenschikov <vova_at_sw.ru>
Date: Mon, 30 Aug 2004 11:58:47 +0400
Hi

Is any chance to make acpi_video work on SONY VAIO PCG-Z1 ?
acpi_video.ko loads well, but does not report anything, and does not add
hw.acpi.video subtree.

Please advise.

kernel is latest HEAD (cvsup 28 Aug).

acpidump -dt and devinfo -v in attachment.

dmesg:
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 6.0-CURRENT #1: Sat Aug 28 14:39:19 MSD 2004
    root_at_vbook.fbsd.ru:/usr/obj/usr/src/sys/VBOOK
Timecounter "i8254" frequency 1193182 Hz quality 0
CPU: Intel(R) Pentium(R) M processor 1700MHz (1686.97-MHz 686-class CPU)
  Origin = "GenuineIntel"  Id = 0x695  Stepping = 5

Features=0xa7e9f9bf<FPU,VME,DE,PSE,TSC,MSR,MCE,CX8,SEP,MTRR,PGE,MCA,CMOV,PAT,CLFLUSH,DTS,ACPI,MMX,FXSR,SSE,SSE2,TM,PBE>
real memory  = 536281088 (511 MB)
avail memory = 515035136 (491 MB)
netsmb_dev: loaded
acpi0: <SONY> on motherboard
acpi_ec0: <Embedded Controller: GPE 0x1c> port 0x66,0x62 on acpi0
Timecounter "ACPI-safe" frequency 3579545 Hz quality 1000
acpi_timer0: <24-bit timer at 3.579545MHz> port 0x1008-0x100b on acpi0
cpu0: <ACPI CPU (2 Cx states)> on acpi0
acpi_tz0: <Thermal Zone> on acpi0
acpi_lid0: <Control Method Lid Switch> on acpi0
acpi_button0: <Power Button> on acpi0
pcib0: <ACPI Host-PCI bridge> port 0xcf8-0xcff on acpi0
pci0: <ACPI PCI bus> on pcib0
pcib1: <ACPI PCI-PCI bridge> at device 1.0 on pci0
pci1: <ACPI PCI bus> on pcib1
pci1: <display, VGA> at device 0.0 (no driver attached)
uhci0: <Intel 82801DB (ICH4) USB controller USB-A> port 0x1800-0x181f
irq 9 at device 29.0 on pci0
uhci0: [GIANT-LOCKED]
usb0: <Intel 82801DB (ICH4) USB controller USB-A> on uhci0
usb0: USB revision 1.0
uhub0: Intel UHCI root hub, class 9/0, rev 1.00/1.00, addr 1
uhub0: 2 ports with 2 removable, self powered
uhci1: <Intel 82801DB (ICH4) USB controller USB-B> port 0x1820-0x183f
irq 9 at device 29.1 on pci0
uhci1: [GIANT-LOCKED]
usb1: <Intel 82801DB (ICH4) USB controller USB-B> on uhci1
usb1: USB revision 1.0
uhub1: Intel UHCI root hub, class 9/0, rev 1.00/1.00, addr 1
uhub1: 2 ports with 2 removable, self powered
uhub2: Texas Instruments UT-USB41 hub, class 9/0, rev 1.10/1.10, addr 2
uhub2: 4 ports with 4 removable, self powered
ukbd0: BTC USB KMp, rev 1.00/1.00, addr 3, iclass 3/1
kbd1 at ukbd0
ums0: BTC USB KMp, rev 1.00/1.00, addr 3, iclass 3/1
ums0: 3 buttons
ums1: Microsoft Microsoft IntelliMouse\M-. Explorer, rev 1.10/1.14, addr
4, iclass 3/1
ums1: 5 buttons and Z dir.
uhci2: <Intel 82801DB (ICH4) USB controller USB-C> port 0x1840-0x185f at
device 29.2 on pci0
uhci2: [GIANT-LOCKED]
usb2: <Intel 82801DB (ICH4) USB controller USB-C> on uhci2
usb2: USB revision 1.0
uhub3: Intel UHCI root hub, class 9/0, rev 1.00/1.00, addr 1
uhub3: 2 ports with 2 removable, self powered
umass0: Sony USB Memory Stick Slot, rev 2.00/1.10, addr 2
umass0: Get Max Lun not supported (STALLED)
ehci0: <EHCI (generic) USB 2.0 controller> mem 0xd0000000-0xd00003ff at
device 29.7 on pci0
ehci0: [GIANT-LOCKED]
ehci_pci_attach: companion usb0
ehci_pci_attach: companion usb1
ehci_pci_attach: companion usb2
usb3: EHCI version 1.0
usb3: companion controllers, 2 ports each: usb0 usb1 usb2
usb3: <EHCI (generic) USB 2.0 controller> on ehci0
usb3: USB revision 2.0
uhub4: Intel EHCI root hub, class 9/0, rev 2.00/1.00, addr 1
uhub4: 6 ports with 6 removable, self powered
umass1: Sony USB Memory Stick Slot, rev 2.00/1.10, addr 2
ehci_idone: need toggle update status=80018d40 nstatus=80008c80
ehci_idone: need toggle update status=80028d40 nstatus=80008c80
umass1: Get Max Lun not supported (STALLED)
pcib2: <ACPI PCI-PCI bridge> at device 30.0 on pci0
ACPI link \\_SB_.PCI0.LPCB.LNKF has invalid initial irq 3, ignoring
pci2: <ACPI PCI bus> on pcib2
cbb0: <RF5C475 PCI-CardBus Bridge> irq 9 at device 5.0 on pci2
cardbus0: <CardBus bus> on cbb0
fwohci0: <Ricoh R5C551> mem 0xd0202000-0xd02027ff at device 5.1 on pci2
fwohci0: [GIANT-LOCKED]
fwohci0: OHCI version 1.0 (ROM=1)
fwohci0: No. of Isochronous channels is 4.
fwohci0: EUI64 08:00:46:03:01:8d:e0:3c
fwohci0: Phy 1394a available S400, 2 ports.
fwohci0: Link S400, max_rec 2048 bytes.
firewire0: <IEEE1394(FireWire) bus> on fwohci0
sbp0: <SBP-2/SCSI over FireWire> on firewire0
fwohci0: Initiate bus reset
fwohci0: node_id=0xc800ffc0, gen=1, CYCLEMASTER mode
firewire0: 1 nodes, maxhop <= 0, cable IRM = 0 (me)
firewire0: bus manager 0 (me)
pci2: <network, ethernet> at device 8.0 (no driver attached)
ndis0: <Intel(R) PRO/Wireless 2200BG Network Connection> mem
0xd0201000-0xd0201fff irq 9 at device 11.0 on pci2
ndis0: [GIANT-LOCKED]
ndis0: NDIS API version: 5.1
ndis0: NDIS ERROR: c000138d (unknown error)
ndis0: NDIS NUMERRORS: 0
ndis0: init handler failed
device_attach: ndis0 attach returned 6
isab0: <PCI-ISA bridge> at device 31.0 on pci0
isa0: <ISA bus> on isab0
atapci0: <Intel ICH4 UDMA100 controller> port
0x1860-0x186f,0x376,0x170-0x177,0x3f6,0x1f0-0x1f7 at device 31.1 on pci0
ata0: channel #0 on atapci0
ata1: channel #1 on atapci0
pci0: <serial bus, SMBus> at device 31.3 (no driver attached)
pcm0: <Intel ICH4 (82801DB)> port 0x18c0-0x18ff,0x1c00-0x1cff mem
0xd0000800-0xd00008ff,0xd0000c00-0xd0000dff irq 9 at device 31.5 on pci0
pcm0: [GIANT-LOCKED]
pcm0: <Yamaha YMF753 AC97 Codec>
pci0: <simple comms> at device 31.6 (no driver attached)
atkbdc0: <Keyboard controller (i8042)> port 0x64,0x60 irq 1 on acpi0
atkbd0: <AT Keyboard> irq 1 on atkbdc0
kbd0 at atkbd0
atkbd0: [GIANT-LOCKED]
psm0: <PS/2 Mouse> irq 12 on atkbdc0
psm0: [GIANT-LOCKED]
psm0: model GlidePoint, device ID 0
acpi_cmbat0: <Control Method Battery> on acpi0
acpi_acad0: <AC Adapter> on acpi0
npx0: [FAST]
npx0: <math processor> on motherboard
npx0: INT 16 interface
pmtimer0 on isa0
orm0: <ISA Option ROMs> at iomem
0xdc000-0xdffff,0xd8000-0xdbfff,0xc0000-0xcffff on isa0
sc0: <System console> on isa0
sc0: VGA <16 virtual consoles, flags=0x200>
vga0: <Generic ISA VGA> at port 0x3c0-0x3df iomem 0xa0000-0xbffff on
isa0
Timecounter "TSC" frequency 1686966203 Hz quality 800
Timecounters tick every 10.000 msec
ipfw2 initialized, divert enabled, rule-based forwarding disabled,
default to deny, logging unlimited
acpi_cpu: throttling enabled, 8 steps (100% to 12.5%), currently 100.0%
ad0: 57231MB <TOSHIBA MK6021GAS/GA024A> [116280/16/63] at ata0-master
UDMA100
uhub2: at uhub1 port 1 (addr 2) disconnected
umass0: at uhub3 port 1 (addr 2) disconnected
umass0: detached
ukbd0: detached
ums0: detached
ums1: detached
uhub2: detached
uhub2: Texas Instruments UT-USB41 hub, class 9/0, rev 1.10/1.10, addr 2
uhub2: 4 ports with 4 removable, self powered
ukbd0: BTC USB KMp, rev 1.00/1.00, addr 3, iclass 3/1
kbd1 at ukbd0
ums0: BTC USB KMp, rev 1.00/1.00, addr 3, iclass 3/1
ums0: 3 buttons
ums1: Microsoft Microsoft IntelliMouse\M-. Explorer, rev 1.10/1.14, addr
4, iclass 3/1
ums1: 5 buttons and Z dir.
ata1-slave: FAILURE - ATAPI_IDENTIFY no interrupt
ata1-slave: FAILURE - ATAPI_IDENTIFY no interrupt
ATAPI_RESET time = 180us
acd0: CDRW <UJDA755 DVD/CDRW/1.00> at ata1-master UDMA33
da0 at umass-sim1 bus 1 target 0 lun 0
da0: <Sony MSC-U04 3.00> Removable Direct Access SCSI-0 device 
da0: 1.000MB/s transfers
da0: 3MB (7904 512 byte sectors: 64H 32S/T 3C)
Mounting root from ufs:/dev/ad0s3a
fxp0: <Intel 82801DB (ICH4) Pro/100 VE Ethernet> port 0x4000-0x403f mem
0xd0200000-0xd0200fff irq 9 at device 8.0 on pci2
fxp0: Ethernet address: 08:00:46:c8:45:b3
fxp0: [GIANT-LOCKED]
ndis0: <Intel(R) PRO/Wireless 2200BG Network Connection> mem
0xd0201000-0xd0201fff irq 9 at device 11.0 on pci2
ndis0: [GIANT-LOCKED]
ndis0: NDIS API version: 5.1
ndis0: Ethernet address: 00:0e:35:03:82:74
ndis0: 11b rates: 1Mbps 2Mbps 5.5Mbps 11Mbps 5.5Mbps 11Mbps
ndis0: 11g rates: 6Mbps 9Mbps 12Mbps 18Mbps 24Mbps 36Mbps 48Mbps 54Mbps
miibus0: <MII bus> on fxp0
inphy0: <i82562ET 10/100 media interface> on miibus0
inphy0:  10baseT, 10baseT-FDX, 100baseTX, 100baseTX-FDX, auto


-- 
Vladimir B. Grebenschikov
SWsoft Inc. vova_at_sw-soft.com

/*
  RSD PTR: OEM=PTLTD, ACPI_Rev=1.0x (0)
	RSDT=0x1ff7806b, cksum=56
 */
/*
  RSDT: Length=48, Revision=1, Checksum=249,
	OEMID=SONY, OEM Table ID=G0, OEM Revision=0x20031121,
	Creator ID=PTL, Creator Revision=0x0
	Entries={ 0x1ff7bec2, 0x1ff7bfd8, 0x1ff7809b }
 */
/*
  FACP: Length=132, Revision=2, Checksum=123,
	OEMID=SONY, OEM Table ID=G0, OEM Revision=0x20031121,
	Creator ID=PTL, Creator Revision=0x50
 	FACS=0x1ff7cfc0, DSDT=0x1ff78507
	INT_MODEL=PIC
	Preferred_PM_Profile=Unspecified (0)
	SCI_INT=9
	SMI_CMD=0xb2, ACPI_ENABLE=0xf0, ACPI_DISABLE=0xf1, S4BIOS_REQ=0x0
	PSTATE_CNT=0x80
	PM1a_EVT_BLK=0x1000-0x1003
	PM1a_CNT_BLK=0x1004-0x1005
	PM2_CNT_BLK=0x1020-0x1020
	PM_TMR_BLK=0x1008-0x100b
	GPE0_BLK=0x1028-0x102f
	P_LVL2_LAT=1 us, P_LVL3_LAT=1001 us
	FLUSH_SIZE=0, FLUSH_STRIDE=0
	DUTY_OFFSET=1, DUTY_WIDTH=3
	DAY_ALRM=13, MON_ALRM=0, CENTURY=50
	IAPC_BOOT_ARCH={8042}
	Flags={WBINVD,PROC_C1,PWR_BUTTON,SLP_BUTTON,RTC_S4,RESET_REG}
	RESET_REG=0x64:0[8] (IO), RESET_VALUE=0xfe
 */
/*
  FACS:	Length=64, HwSig=0x00000000, Firm_Wake_Vec=0x00000000
	Global_Lock=
	Flags=
	Version=0
 */
/*
  DSDT: Length=14779, Revision=1, Checksum=101,
	OEMID=SONY, OEM Table ID=G0, OEM Revision=0x20031121,
	Creator ID=PTL, Creator Revision=0x100000d
 */
/*
  BOOT: Length=40, Revision=1, Checksum=71,
	OEMID=SONY, OEM Table ID=G0, OEM Revision=0x20031121,
	Creator ID=PTL, Creator Revision=0x1
 */
/*
  SSDT: Length=728, Revision=1, Checksum=237,
	OEMID=SONY, OEM Table ID=G0, OEM Revision=0x20031121,
	Creator ID=PTL, Creator Revision=0x0
 */
/*
 * Intel ACPI Component Architecture
 * AML Disassembler version 20040527
 *
 * Disassembly of /tmp/acpidump.QDyspP, Mon Aug 30 11:56:06 2004
 */
DefinitionBlock ("DSDT.aml", "DSDT", 1, "SONY", "G0", 537071905)
{
    OperationRegion (PORT, SystemIO, 0x80, 0x01)
    Field (PORT, ByteAcc, NoLock, Preserve)
    {
        P80H,   8
    }

    OperationRegion (IO_T, SystemIO, 0x0800, 0x08)
    Field (IO_T, ByteAcc, NoLock, Preserve)
    {
        TRP0,   8
    }

    OperationRegion (GPIO, SystemIO, 0x1180, 0x3C)
    Field (GPIO, ByteAcc, NoLock, Preserve)
    {
        GU00,   8, 
        GU01,   8, 
        GU02,   8, 
        GU03,   8, 
        GIO0,   8, 
        GIO1,   8, 
        GIO2,   8, 
        GIO3,   8, 
        Offset (0x0C), 
        GL00,   8, 
        GL01,   8, 
        GL02,   8, 
        GL03,   8, 
        Offset (0x18), 
        GB00,   8, 
        GB01,   8, 
        GB02,   8, 
        GB03,   8, 
        Offset (0x2C), 
        GIV0,   8, 
        GIV1,   8, 
        GIV2,   8, 
        GIV3,   8, 
        GU04,   8, 
        GU05,   8, 
        GU06,   8, 
        GU07,   8, 
        GIO4,   8, 
        GIO5,   8, 
        GIO6,   8, 
        GIO7,   8, 
            ,   1, 
            ,   1, 
        CPEN,   1, 
        Offset (0x39), 
        GL05,   8, 
        GL06,   8, 
        GL07,   8
    }

    OperationRegion (MNVS, SystemMemory, 0x1FF7CAB7, 0x40)
    Field (MNVS, AnyAcc, Lock, Preserve)
    {
        PSAC,   8, 
        PSDC,   8
    }

    Mutex (MUTX, 0x00)
    Name (_S0, Package (0x03)
    {
        0x00, 
        0x00, 
        0x00
    })
    Name (_S3, Package (0x03)
    {
        0x05, 
        0x05, 
        0x00
    })
    Name (_S4, Package (0x03)
    {
        0x06, 
        0x06, 
        0x00
    })
    Name (_S5, Package (0x03)
    {
        0x07, 
        0x07, 
        0x00
    })
    Scope (\_PR)
    {
        Processor (CPU0, 0x00, 0x00001010, 0x06)
        {
            Scope (\)
            {
                Name (GVSS, One)
            }

            Scope (\_PR.CPU0)
            {
                Method (_CST, 0, NotSerialized)
                {
                    If (\_SB.PCI0.LPCB.EC0.ECOK)
                    {
                        Store (\_SB.PCI0.LPCB.EC0.ACAT, Local0)
                    }
                    Else
                    {
                        And (PHSD (0xD4, 0x80), 0x0400, Local0)
                    }

                    If (Local0)
                    {
                        Return (ACST)
                    }
                    Else
                    {
                        If (GVSS)
                        {
                            Return (DCST)
                        }
                        Else
                        {
                            Return (DDST)
                        }
                    }
                }

                Name (ACST, Package (0x03)
                {
                    0x02, 
                    Package (0x04)
                    {
                        ResourceTemplate ()
                        {
                            Register (FFixedHW, 0x08, 0x00, 0x0000000000000000)
                        }, 

                        0x01, 
                        0x01, 
                        0x03E8
                    }, 

                    Package (0x04)
                    {
                        ResourceTemplate ()
                        {
                            Register (SystemIO, 0x08, 0x00, 0x0000000000001014)
                        }, 

                        0x02, 
                        0x01, 
                        0x01F4
                    }
                })
                Name (DCST, Package (0x05)
                {
                    0x04, 
                    Package (0x04)
                    {
                        ResourceTemplate ()
                        {
                            Register (FFixedHW, 0x08, 0x00, 0x0000000000000000)
                        }, 

                        0x01, 
                        0x01, 
                        0x03E8
                    }, 

                    Package (0x04)
                    {
                        ResourceTemplate ()
                        {
                            Register (SystemIO, 0x08, 0x00, 0x0000000000001014)
                        }, 

                        0x02, 
                        0x01, 
                        0x01F4
                    }, 

                    Package (0x04)
                    {
                        ResourceTemplate ()
                        {
                            Register (SystemIO, 0x08, 0x00, 0x0000000000001015)
                        }, 

                        0x03, 
                        0x55, 
                        0xFA
                    }, 

                    Package (0x04)
                    {
                        ResourceTemplate ()
                        {
                            Register (SystemIO, 0x08, 0x00, 0x0000000000001016)
                        }, 

                        0x03, 
                        0xB9, 
                        0x64
                    }
                })
                Name (DDST, Package (0x04)
                {
                    0x03, 
                    Package (0x04)
                    {
                        ResourceTemplate ()
                        {
                            Register (FFixedHW, 0x08, 0x00, 0x0000000000000000)
                        }, 

                        0x01, 
                        0x01, 
                        0x03E8
                    }, 

                    Package (0x04)
                    {
                        ResourceTemplate ()
                        {
                            Register (SystemIO, 0x08, 0x00, 0x0000000000001014)
                        }, 

                        0x02, 
                        0x01, 
                        0x01F4
                    }, 

                    Package (0x04)
                    {
                        ResourceTemplate ()
                        {
                            Register (SystemIO, 0x08, 0x00, 0x0000000000001015)
                        }, 

                        0x03, 
                        0x55, 
                        0xFA
                    }
                })
            }
        }
    }

    Name (\CTYP, 0x00)
    Name (\ECON, 0x00)
    Method (_PTS, 1, NotSerialized)
    {
        Store (Arg0, P80H)
        If (LEqual (Arg0, 0x03))
        {
            Store (\_SB.PCI0.LPCB.SPIC._CRS (), \_SB.PCI0.LPCB.SPIC.SSRC)
        }

        If (LEqual (Arg0, 0x04))
        {
            Store (\_SB.PCI0.LPCB.SPIC._CRS (), \_SB.PCI0.LPCB.SPIC.SSRC)
            PHSB (0xA2, \_SB.OSTB)
        }
    }

    Method (_WAK, 1, NotSerialized)
    {
        Store (0x00, P80H)
        \_SB.NCPU ()
        If (LEqual (Arg0, 0x03))
        {
            \_SB.PCI0.LPCB.SPIC._SRS (\_SB.PCI0.LPCB.SPIC.SSRC)
            If (LNot (\_SB.PCI0.LPCB.EC0.WAKI))
            {
                Notify (\_SB.PWRB, 0x02)
            }
        }

        If (LEqual (Arg0, 0x04))
        {
            \_SB.PCI0.LPCB.SPIC._SRS (\_SB.PCI0.LPCB.SPIC.SSRC)
            PHSB (0xA3, \_SB.OSTB)
            Notify (\_SB.PWRB, 0x02)
        }

        Return (Zero)
    }

    Scope (\_SB)
    {
        Name (OSTB, Ones)
        OperationRegion (OSTY, SystemMemory, 0x1FF7CAF7, 0x00000001)
        Field (OSTY, AnyAcc, NoLock, Preserve)
        {
            TPOS,   8
        }

        Method (OSTP, 0, NotSerialized)
        {
            If (LEqual (^OSTB, Ones))
            {
                If (CondRefOf (\_OSI, Local0))
                {
                    If (\_OSI ("Windows 2001.1"))
                    {
                        Store (0x20, ^OSTB)
                        Store (0x20, ^TPOS)
                    }
                    Else
                    {
                        If (\_OSI ("Windows 2001 SP1"))
                        {
                            Store (0x10, ^OSTB)
                            Store (0x10, ^TPOS)
                        }
                        Else
                        {
                            If (\_OSI ("Windows 2001"))
                            {
                                Store (0x08, ^OSTB)
                                Store (0x08, ^TPOS)
                            }
                            Else
                            {
                                Store (0x00, ^OSTB)
                                Store (0x00, ^TPOS)
                            }
                        }
                    }
                }
                Else
                {
                    If (CondRefOf (\_OS, Local0))
                    {
                        If (^SEQL (\_OS, "Microsoft Windows"))
                        {
                            Store (0x01, ^OSTB)
                            Store (0x01, ^TPOS)
                        }
                        Else
                        {
                            If (^SEQL (\_OS, "Microsoft WindowsME: Millennium Edition"))
                            {
                                Store (0x02, ^OSTB)
                                Store (0x02, ^TPOS)
                            }
                            Else
                            {
                                If (^SEQL (\_OS, "Microsoft Windows NT"))
                                {
                                    Store (0x04, ^OSTB)
                                    Store (0x04, ^TPOS)
                                }
                                Else
                                {
                                    Store (0x00, ^OSTB)
                                    Store (0x00, ^TPOS)
                                }
                            }
                        }
                    }
                    Else
                    {
                        Store (0x00, ^OSTB)
                        Store (0x00, ^TPOS)
                    }
                }
            }

            Return (^OSTB)
        }

        Method (SEQL, 2, Serialized)
        {
            Store (SizeOf (Arg0), Local0)
            Store (SizeOf (Arg1), Local1)
            If (LNot (LEqual (Local0, Local1)))
            {
                Return (Zero)
            }

            Name (BUF0, Buffer (Local0) {})
            Store (Arg0, BUF0)
            Name (BUF1, Buffer (Local0) {})
            Store (Arg1, BUF1)
            Store (Zero, Local2)
            While (LLess (Local2, Local0))
            {
                Store (DerefOf (Index (BUF0, Local2)), Local3)
                Store (DerefOf (Index (BUF1, Local2)), Local4)
                If (LNot (LEqual (Local3, Local4)))
                {
                    Return (Zero)
                }

                Increment (Local2)
            }

            Return (One)
        }
    }

    Scope (\_GPE)
    {
        Mutex (GLOK, 0x00)
        Method (_L03, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.USB0, 0x02)
        }

        Method (_L04, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.USB1, 0x02)
        }

        Method (_L05, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.MODM, 0x02)
        }

        Method (_L0C, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.USB2, 0x02)
        }

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

        Method (_L0B, 0, NotSerialized)
        {
            If (LNot (LLess (\_SB.OSTB, 0x08)))
            {
                Acquire (GLOK, 0xFFFF)
                Sleep (0x64)
                Notify (\_SB.PCI0.PCIB.CRD0, 0x02)
                Sleep (0x64)
                Release (GLOK)
                Notify (\_SB.PCI0.PCIB, 0x02)
            }
            Else
            {
                Notify (\_SB.PCI0.PCIB, 0x02)
            }
        }

        Method (_L1D, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.LPCB.EC0, 0x02)
        }
    }

    OperationRegion (SMI0, SystemMemory, 0x1FF7CAF8, 0x00000415)
    Field (SMI0, AnyAcc, NoLock, Preserve)
    {
        BCMD,   8, 
        DID,    32, 
        INFO,   4096
    }

    Field (SMI0, AnyAcc, NoLock, Preserve)
    {
        Offset (0x05), 
        INFB,   8
    }

    Field (SMI0, AnyAcc, NoLock, Preserve)
    {
        Offset (0x05), 
        INFD,   32
    }

    Field (SMI0, AnyAcc, NoLock, Preserve)
    {
        Offset (0x05), 
        SXBF,   8320
    }

    Field (SMI0, AnyAcc, NoLock, Preserve)
    {
        Offset (0x05), 
        INF1,   8, 
        INF2,   8
    }

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

    Mutex (MPHS, 0x00)
    Method (PHS0, 1, NotSerialized)
    {
        Store (Arg0, BCMD)
        Store (Zero, SMIC)
        While (LEqual (BCMD, Arg0)) {}
        Store (0x00, BCMD)
    }

    Method (PHS, 1, Serialized)
    {
        Acquire (MPHS, 0xFFFF)
        Store (0x00, DID)
        PHS0 (Arg0)
        Store (INFD, Local0)
        Release (MPHS)
        Return (Local0)
    }

    Method (PHSD, 2, Serialized)
    {
        Acquire (MPHS, 0xFFFF)
        Store (0x00, DID)
        Store (Arg1, INFD)
        PHS0 (Arg0)
        Store (INFD, Local0)
        Release (MPHS)
        Return (Local0)
    }

    Method (PHSW, 3, Serialized)
    {
        Acquire (MPHS, 0xFFFF)
        Store (0x00, DID)
        Store (Arg1, INF1)
        Store (Arg2, INF2)
        PHS0 (Arg0)
        Store (INFB, Local0)
        Release (MPHS)
        Return (Local0)
    }

    Method (PHSB, 2, Serialized)
    {
        Acquire (MPHS, 0xFFFF)
        Store (0x00, DID)
        Store (Arg1, INFB)
        PHS0 (Arg0)
        Store (INFB, Local0)
        Release (MPHS)
        Return (Local0)
    }

    Method (PSCS, 1, Serialized)
    {
        Acquire (MPHS, 0xFFFF)
        Store (Arg0, DID)
        PHS0 (0x00)
        Store (INFO, Local0)
        Release (MPHS)
        Return (Local0)
    }

    Method (PSSS, 2, Serialized)
    {
        Acquire (MPHS, 0xFFFF)
        Store (Arg0, DID)
        Store (Arg1, INFO)
        PHS0 (0x01)
        Release (MPHS)
    }

    Method (PSPS, 1, Serialized)
    {
        Acquire (MPHS, 0xFFFF)
        Store (Arg0, DID)
        PHS0 (0x02)
        Store (INFO, Local0)
        Release (MPHS)
        Return (Local0)
    }

    Method (PSDI, 1, Serialized)
    {
        Acquire (MPHS, 0xFFFF)
        Store (Arg0, DID)
        PHS0 (0x03)
        Release (MPHS)
    }

    Method (PSST, 1, Serialized)
    {
        Acquire (MPHS, 0xFFFF)
        Store (Arg0, DID)
        PHS0 (0x04)
        Store (INFB, Local0)
        Release (MPHS)
        Return (Local0)
    }

    Scope (\_TZ)
    {
        ThermalZone (ATF0)
        {
            Method (KELV, 1, NotSerialized)
            {
                Store (Arg0, Local0)
                Multiply (Local0, 0x0A, Local0)
                Add (Local0, 0x0AAB, Local0)
                Return (Local0)
            }

            Method (_TMP, 0, NotSerialized)
            {
                If (LEqual (\_SB.PCI0.LPCB.EC0.ECOK, 0x00))
                {
                    Store (PHSD (0xD4, 0xC0), Local1)
                }
                Else
                {
                    Store (\_SB.PCI0.LPCB.EC0.A1TP, Local1)
                }

                ShiftRight (Local1, 0x08, Local0)
                If (LGreater (Local0, 0x80))
                {
                    Sleep (0x32)
                    If (LEqual (\_SB.PCI0.LPCB.EC0.ECOK, 0x00))
                    {
                        Store (PHSD (0xD4, 0xC0), Local1)
                    }
                    Else
                    {
                        Store (\_SB.PCI0.LPCB.EC0.A1TP, Local1)
                    }

                    ShiftRight (Local1, 0x08, Local0)
                }

                Return (KELV (Local0))
            }

            Method (_PSV, 0, NotSerialized)
            {
                If (LEqual (\_SB.PCI0.LPCB.EC0.ECOK, 0x00))
                {
                    Store (PHSD (0xD4, 0xC4), Local1)
                }
                Else
                {
                    Store (\_SB.PCI0.LPCB.EC0.A1PT, Local1)
                }

                ShiftRight (Local1, 0x08, Local0)
                Return (KELV (Local0))
            }

            Name (_PSL, Package (0x01)
            {
                \_PR.CPU0
            })
            Method (_CRT, 0, NotSerialized)
            {
                If (LEqual (\_SB.PCI0.LPCB.EC0.ECOK, 0x00))
                {
                    Store (PHSD (0xD4, 0xC6), Local1)
                }
                Else
                {
                    Store (\_SB.PCI0.LPCB.EC0.A1CT, Local1)
                }

                ShiftRight (Local1, 0x08, Local0)
                Return (KELV (Local0))
            }

            Name (_TC1, 0x01)
            Name (_TC2, 0x02)
            Name (_TSP, 0x32)
        }
    }

    Scope (\_SB)
    {
        Device (LID0)
        {
            Name (_HID, EisaId ("PNP0C0D"))
            Method (_LID, 0, NotSerialized)
            {
                If (LEqual (\_SB.PCI0.LPCB.EC0.ECOK, 0x00))
                {
                    And (PHSB (0xD4, 0x82), 0x04, Local0)
                }
                Else
                {
                    Store (\_SB.PCI0.LPCB.EC0.LIDS, Local0)
                }

                Return (Local0)
            }
        }

        Device (PWRB)
        {
            Name (_HID, EisaId ("PNP0C0C"))
            Name (_PRW, Package (0x02)
            {
                0x1D, 
                0x04
            })
        }

        Mutex (PLOK, 0x00)
        Method (NCPU, 0, NotSerialized)
        {
            Acquire (PLOK, 0xFFFF)
            Notify (\_PR.CPU0, 0x80)
            Sleep (0x64)
            Notify (\_PR.CPU0, 0x81)
            Release (PLOK)
        }

        Device (PCI0)
        {
            Method (_INI, 0, NotSerialized)
            {
                \_SB.OSTP ()
            }

            Method (_S1D, 0, NotSerialized)
            {
                Return (0x02)
            }

            Method (_S3D, 0, NotSerialized)
            {
                Return (0x02)
            }

            Method (_S4D, 0, NotSerialized)
            {
                Return (0x02)
            }

            Name (_HID, EisaId ("PNP0A03"))
            Name (_ADR, 0x00)
            Name (_BBN, 0x00)
            OperationRegion (HBUS, PCI_Config, 0x40, 0xC0)
            Field (HBUS, DWordAcc, NoLock, Preserve)
            {
                Offset (0x20), 
                DRB0,   8, 
                DRB1,   8, 
                DRB2,   8, 
                DRB3,   8, 
                Offset (0x50), 
                    ,   4, 
                PM0H,   2, 
                Offset (0x51), 
                PM1L,   2, 
                    ,   2, 
                PM1H,   2, 
                Offset (0x52), 
                PM2L,   2, 
                    ,   2, 
                PM2H,   2, 
                Offset (0x53), 
                PM3L,   2, 
                    ,   2, 
                PM3H,   2, 
                Offset (0x54), 
                PM4L,   2, 
                    ,   2, 
                PM4H,   2, 
                Offset (0x55), 
                PM5L,   2, 
                    ,   2, 
                PM5H,   2, 
                Offset (0x56), 
                PM6L,   2, 
                    ,   2, 
                PM6H,   2, 
                Offset (0x57), 
                FDHC,   8
            }

            Name (BUF0, ResourceTemplate ()
            {
                WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode,
                    0x0000,
                    0x0000,
                    0x00FF,
                    0x0000,
                    0x0100, 0x00)
                DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                    0x00000000,
                    0x00000000,
                    0x00000CF7,
                    0x00000000,
                    0x00000CF8, 0x00)
                IO (Decode16, 0x0CF8, 0x0CF8, 0x01, 0x08)
                DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                    0x00000000,
                    0x00000D00,
                    0x0000FFFF,
                    0x00000000,
                    0x0000F300, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000A0000,
                    0x000BFFFF,
                    0x00000000,
                    0x00020000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000C0000,
                    0x000C3FFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000C4000,
                    0x000C7FFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000C8000,
                    0x000CBFFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000CC000,
                    0x000CFFFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000D0000,
                    0x000D3FFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000D4000,
                    0x000D7FFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000D8000,
                    0x000DBFFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000DC000,
                    0x000DFFFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000E0000,
                    0x000E3FFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000E4000,
                    0x000E7FFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000E8000,
                    0x000EBFFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000EC000,
                    0x000EFFFF,
                    0x00000000,
                    0x00004000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x000F0000,
                    0x000FFFFF,
                    0x00000000,
                    0x00010000, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x00000000,
                    0xFEBFFFFF,
                    0x00000000,
                    0x00000000, 0x00)
            })
            Method (_CRS, 0, Serialized)
            {
                If (PM1L)
                {
                    CreateDWordField (BUF0, 0x80, C0LN)
                    Store (Zero, C0LN)
                }

                If (LEqual (PM1L, 0x01))
                {
                    CreateBitField (BUF0, 0x0378, C0RW)
                    Store (Zero, C0RW)
                }

                If (PM1H)
                {
                    CreateDWordField (BUF0, 0x9B, C4LN)
                    Store (Zero, C4LN)
                }

                If (LEqual (PM1H, 0x01))
                {
                    CreateBitField (BUF0, 0x0450, C4RW)
                    Store (Zero, C4RW)
                }

                If (PM2L)
                {
                    CreateDWordField (BUF0, 0xB6, C8LN)
                    Store (Zero, C8LN)
                }

                If (LEqual (PM2L, 0x01))
                {
                    CreateBitField (BUF0, 0x0528, C8RW)
                    Store (Zero, C8RW)
                }

                If (PM2H)
                {
                    CreateDWordField (BUF0, 0xD1, CCLN)
                    Store (Zero, CCLN)
                }

                If (LEqual (PM2H, 0x01))
                {
                    CreateBitField (BUF0, 0x0600, CCRW)
                    Store (Zero, CCRW)
                }

                If (PM3L)
                {
                    CreateDWordField (BUF0, 0xEC, D0LN)
                    Store (Zero, D0LN)
                }

                If (LEqual (PM3L, 0x01))
                {
                    CreateBitField (BUF0, 0x06D8, D0RW)
                    Store (Zero, D0RW)
                }

                If (PM3H)
                {
                    CreateDWordField (BUF0, 0x0107, D4LN)
                    Store (Zero, D4LN)
                }

                If (LEqual (PM3H, 0x01))
                {
                    CreateBitField (BUF0, 0x07B0, D4RW)
                    Store (Zero, D4RW)
                }

                If (PM4L)
                {
                    CreateDWordField (BUF0, 0x0122, D8LN)
                    Store (Zero, D8LN)
                }

                If (LEqual (PM4L, 0x01))
                {
                    CreateBitField (BUF0, 0x0888, D8RW)
                    Store (Zero, D8RW)
                }

                If (PM4H)
                {
                    CreateDWordField (BUF0, 0x013D, DCLN)
                    Store (Zero, DCLN)
                }

                If (LEqual (PM4H, 0x01))
                {
                    CreateBitField (BUF0, 0x0960, DCRW)
                    Store (Zero, DCRW)
                }

                If (PM5L)
                {
                    CreateDWordField (BUF0, 0x0158, E0LN)
                    Store (Zero, E0LN)
                }

                If (LEqual (PM5L, 0x01))
                {
                    CreateBitField (BUF0, 0x0A38, E0RW)
                    Store (Zero, E0RW)
                }

                If (PM5H)
                {
                    CreateDWordField (BUF0, 0x0173, E4LN)
                    Store (Zero, E4LN)
                }

                If (LEqual (PM5H, 0x01))
                {
                    CreateBitField (BUF0, 0x0B10, E4RW)
                    Store (Zero, E4RW)
                }

                If (PM6L)
                {
                    CreateDWordField (BUF0, 0x018E, E8LN)
                    Store (Zero, E8LN)
                }

                If (LEqual (PM6L, 0x01))
                {
                    CreateBitField (BUF0, 0x0BE8, E8RW)
                    Store (Zero, E8RW)
                }

                If (PM6H)
                {
                    CreateDWordField (BUF0, 0x01A9, ECLN)
                    Store (Zero, ECLN)
                }

                If (LEqual (PM6H, 0x01))
                {
                    CreateBitField (BUF0, 0x0CC0, ECRW)
                    Store (Zero, ECRW)
                }

                If (PM0H)
                {
                    CreateDWordField (BUF0, 0x01C4, F0LN)
                    Store (Zero, F0LN)
                }

                If (LEqual (PM0H, 0x01))
                {
                    CreateBitField (BUF0, 0x0D98, F0RW)
                    Store (Zero, F0RW)
                }

                CreateDWordField (BUF0, 0x01D3, M1MN)
                CreateDWordField (BUF0, 0x01D7, M1MX)
                CreateDWordField (BUF0, 0x01DF, M1LN)
                Multiply (0x02000000, DRB3, M1MN)
                Add (Subtract (M1MX, M1MN), 0x01, M1LN)
                Return (BUF0)
            }

            Method (_PRT, 0, NotSerialized)
            {
                Return (Package (0x09)
                {
                    Package (0x04)
                    {
                        0x0001FFFF, 
                        0x00, 
                        \_SB.PCI0.LPCB.LNKA, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0001FFFF, 
                        0x01, 
                        \_SB.PCI0.LPCB.LNKB, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0001FFFF, 
                        0x02, 
                        \_SB.PCI0.LPCB.LNKC, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0001FFFF, 
                        0x03, 
                        \_SB.PCI0.LPCB.LNKD, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x001DFFFF, 
                        0x00, 
                        \_SB.PCI0.LPCB.LNKA, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x001DFFFF, 
                        0x01, 
                        \_SB.PCI0.LPCB.LNKD, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x001DFFFF, 
                        0x02, 
                        \_SB.PCI0.LPCB.LNKC, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x001DFFFF, 
                        0x03, 
                        \_SB.PCI0.LPCB.LNKH, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x001FFFFF, 
                        0x01, 
                        \_SB.PCI0.LPCB.LNKB, 
                        0x00
                    }
                })
            }

            Device (AGPB)
            {
                Name (_ADR, 0x00010000)
                Method (_PRT, 0, NotSerialized)
                {
                    Return (Package (0x01)
                    {
                        Package (0x04)
                        {
                            0xFFFF, 
                            0x00, 
                            \_SB.PCI0.LPCB.LNKA, 
                            0x00
                        }
                    })
                }

                Device (VID0)
                {
                    Name (_ADR, 0x00)
                    OperationRegion (VIDR, PCI_Config, 0x4C, 0x04)
                    Field (VIDR, ByteAcc, NoLock, Preserve)
                    {
                        SSID,   32
                    }

                    Device (CRT)
                    {
                        Name (_ADR, 0x0100)
                    }

                    Device (LCD)
                    {
                        Name (_ADR, 0x0110)
                    }

                    Device (TV)
                    {
                        Name (_ADR, 0x0200)
                    }
                }
            }

            Device (PCIB)
            {
                Name (_ADR, 0x001E0000)
                Device (LANC)
                {
                    Name (_ADR, 0x00080000)
                    Name (_PRW, Package (0x02)
                    {
                        0x0B, 
                        0x03
                    })
                }

                Device (WLAN)
                {
                    Name (_ADR, 0x000B0000)
                    Name (_PSC, 0x00)
                    Method (_PS0, 0, NotSerialized)
                    {
                        Store (0x00, _PSC)
                    }

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

                    Method (_STA, 0, NotSerialized)
                    {
                        Return (0x0F)
                    }
                }

                Device (CRD0)
                {
                    Name (_ADR, 0x00050000)
                    OperationRegion (CCRD, PCI_Config, 0x00, 0xE4)
                    Field (CCRD, DWordAcc, NoLock, Preserve)
                    {
                        Offset (0x04), 
                        CD04,   32, 
                        Offset (0x3E), 
                        CD3E,   32, 
                        Offset (0x44), 
                        CD44,   32, 
                        Offset (0xE0), 
                        CDE0,   8, 
                        CDE1,   8
                    }

                    Method (_INI, 0, NotSerialized)
                    {
                        Store (Zero, CD44)
                    }

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

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

                    Method (_STA, 0, NotSerialized)
                    {
                        Return (0x0F)
                    }

                    Name (_PRW, Package (0x02)
                    {
                        0x0B, 
                        0x03
                    })
                }

                Device (SD94)
                {
                    Name (_ADR, 0x00050001)
                }

                Method (_PRT, 0, NotSerialized)
                {
                    Return (Package (0x05)
                    {
                        Package (0x04)
                        {
                            0x0005FFFF, 
                            0x00, 
                            \_SB.PCI0.LPCB.LNKF, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x0005FFFF, 
                            0x01, 
                            \_SB.PCI0.LPCB.LNKG, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x000BFFFF, 
                            0x00, 
                            \_SB.PCI0.LPCB.LNKD, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x0004FFFF, 
                            0x00, 
                            \_SB.PCI0.LPCB.LNKE, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x0008FFFF, 
                            0x00, 
                            \_SB.PCI0.LPCB.LNKE, 
                            0x00
                        }
                    })
                }
            }

            Device (LPCB)
            {
                Name (_ADR, 0x001F0000)
                OperationRegion (LPC0, PCI_Config, 0x40, 0xC0)
                Field (LPC0, AnyAcc, NoLock, Preserve)
                {
                    Offset (0x20), 
                    PIRA,   8, 
                    PIRB,   8, 
                    PIRC,   8, 
                    PIRD,   8, 
                    Offset (0x28), 
                    PIRE,   8, 
                    PIRF,   8, 
                    PIRG,   8, 
                    PIRH,   8, 
                    Offset (0x90), 
                    HPTE,   32, 
                    Offset (0xA0), 
                    LDE0,   8, 
                    LDE1,   8
                }

                Device (LNKA)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x01)
                    Method (_DIS, 0, Serialized)
                    {
                        Store (0x80, PIRA)
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {9}
                    })
                    Method (_CRS, 0, Serialized)
                    {
                        Name (RTLA, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared) {}
                        })
                        CreateWordField (RTLA, 0x01, IRQ0)
                        Store (Zero, IRQ0)
                        ShiftLeft (0x01, And (PIRA, 0x0F), IRQ0)
                        Return (RTLA)
                    }

                    Method (_SRS, 1, Serialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        FindSetRightBit (IRQ0, Local0)
                        Decrement (Local0)
                        Store (Local0, PIRA)
                    }

                    Method (_STA, 0, Serialized)
                    {
                        If (And (PIRA, 0x80))
                        {
                            Return (0x09)
                        }
                        Else
                        {
                            Return (0x0B)
                        }
                    }
                }

                Device (LNKB)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x02)
                    Method (_DIS, 0, Serialized)
                    {
                        Store (0x80, PIRB)
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {9}
                    })
                    Method (_CRS, 0, Serialized)
                    {
                        Name (RTLB, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared) {}
                        })
                        CreateWordField (RTLB, 0x01, IRQ0)
                        Store (Zero, IRQ0)
                        ShiftLeft (0x01, And (PIRB, 0x0F), IRQ0)
                        Return (RTLB)
                    }

                    Method (_SRS, 1, Serialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        FindSetRightBit (IRQ0, Local0)
                        Decrement (Local0)
                        Store (Local0, PIRB)
                    }

                    Method (_STA, 0, Serialized)
                    {
                        If (And (PIRB, 0x80))
                        {
                            Return (0x09)
                        }
                        Else
                        {
                            Return (0x0B)
                        }
                    }
                }

                Device (LNKC)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x03)
                    Method (_DIS, 0, Serialized)
                    {
                        Store (0x80, PIRC)
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {9}
                    })
                    Method (_CRS, 0, Serialized)
                    {
                        Name (RTLC, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared) {}
                        })
                        CreateWordField (RTLC, 0x01, IRQ0)
                        Store (Zero, IRQ0)
                        ShiftLeft (0x01, And (PIRC, 0x0F), IRQ0)
                        Return (RTLC)
                    }

                    Method (_SRS, 1, Serialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        FindSetRightBit (IRQ0, Local0)
                        Decrement (Local0)
                        Store (Local0, PIRC)
                    }

                    Method (_STA, 0, Serialized)
                    {
                        If (And (PIRC, 0x80))
                        {
                            Return (0x09)
                        }
                        Else
                        {
                            Return (0x0B)
                        }
                    }
                }

                Device (LNKD)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x04)
                    Method (_DIS, 0, Serialized)
                    {
                        Store (0x80, PIRD)
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {9}
                    })
                    Method (_CRS, 0, Serialized)
                    {
                        Name (RTLD, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared) {}
                        })
                        CreateWordField (RTLD, 0x01, IRQ0)
                        Store (Zero, IRQ0)
                        ShiftLeft (0x01, And (PIRD, 0x0F), IRQ0)
                        Return (RTLD)
                    }

                    Method (_SRS, 1, Serialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        FindSetRightBit (IRQ0, Local0)
                        Decrement (Local0)
                        Store (Local0, PIRD)
                    }

                    Method (_STA, 0, Serialized)
                    {
                        If (And (PIRD, 0x80))
                        {
                            Return (0x09)
                        }
                        Else
                        {
                            Return (0x0B)
                        }
                    }
                }

                Device (LNKE)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x05)
                    Method (_DIS, 0, Serialized)
                    {
                        Store (0x80, PIRE)
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {9}
                    })
                    Method (_CRS, 0, Serialized)
                    {
                        Name (RTLE, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared) {}
                        })
                        CreateWordField (RTLE, 0x01, IRQ0)
                        Store (Zero, IRQ0)
                        ShiftLeft (0x01, And (PIRE, 0x0F), IRQ0)
                        Return (RTLE)
                    }

                    Method (_SRS, 1, Serialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        FindSetRightBit (IRQ0, Local0)
                        Decrement (Local0)
                        Store (Local0, PIRE)
                    }

                    Method (_STA, 0, Serialized)
                    {
                        If (And (PIRE, 0x80))
                        {
                            Return (0x09)
                        }
                        Else
                        {
                            Return (0x0B)
                        }
                    }
                }

                Device (LNKF)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x06)
                    Method (_DIS, 0, Serialized)
                    {
                        Store (0x80, PIRF)
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {9}
                    })
                    Method (_CRS, 0, Serialized)
                    {
                        Name (RTLF, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared) {}
                        })
                        CreateWordField (RTLF, 0x01, IRQ0)
                        Store (Zero, IRQ0)
                        ShiftLeft (0x01, And (PIRF, 0x0F), IRQ0)
                        Return (RTLF)
                    }

                    Method (_SRS, 1, Serialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        FindSetRightBit (IRQ0, Local0)
                        Decrement (Local0)
                        Store (Local0, PIRF)
                    }

                    Method (_STA, 0, Serialized)
                    {
                        If (And (PIRF, 0x80))
                        {
                            Return (0x09)
                        }
                        Else
                        {
                            Return (0x0B)
                        }
                    }
                }

                Device (LNKG)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x07)
                    Method (_DIS, 0, Serialized)
                    {
                        Store (0x80, PIRG)
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {9}
                    })
                    Method (_CRS, 0, Serialized)
                    {
                        Name (RTLG, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared) {}
                        })
                        CreateWordField (RTLG, 0x01, IRQ0)
                        Store (Zero, IRQ0)
                        ShiftLeft (0x01, And (PIRG, 0x0F), IRQ0)
                        Return (RTLG)
                    }

                    Method (_SRS, 1, Serialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        FindSetRightBit (IRQ0, Local0)
                        Decrement (Local0)
                        Store (Local0, PIRG)
                    }

                    Method (_STA, 0, Serialized)
                    {
                        If (And (PIRG, 0x80))
                        {
                            Return (0x09)
                        }
                        Else
                        {
                            Return (0x0B)
                        }
                    }
                }

                Device (LNKH)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x08)
                    Method (_DIS, 0, Serialized)
                    {
                        Store (0x80, PIRH)
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {9}
                    })
                    Method (_CRS, 0, Serialized)
                    {
                        Name (RTLH, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared) {}
                        })
                        CreateWordField (RTLH, 0x01, IRQ0)
                        Store (Zero, IRQ0)
                        ShiftLeft (0x01, And (PIRH, 0x0F), IRQ0)
                        Return (RTLH)
                    }

                    Method (_SRS, 1, Serialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        FindSetRightBit (IRQ0, Local0)
                        Decrement (Local0)
                        Store (Local0, PIRH)
                    }

                    Method (_STA, 0, Serialized)
                    {
                        If (And (PIRH, 0x80))
                        {
                            Return (0x09)
                        }
                        Else
                        {
                            Return (0x0B)
                        }
                    }
                }

                Device (TIMR)
                {
                    Name (_HID, EisaId ("PNP0100"))
                    Name (BUF0, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0040, 0x0040, 0x01, 0x04)
                        IO (Decode16, 0x0050, 0x0050, 0x10, 0x04)
                    })
                    Name (BUF1, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0040, 0x0040, 0x01, 0x04)
                        IO (Decode16, 0x0050, 0x0050, 0x10, 0x04)
                        IRQNoFlags () {0}
                    })
                    Method (_CRS, 0, Serialized)
                    {
                        If (And (HPTE, 0x00020000))
                        {
                            Return (BUF0)
                        }

                        Return (BUF1)
                    }
                }

                Device (IPIC)
                {
                    Name (_HID, EisaId ("PNP0000"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0020, 0x0020, 0x01, 0x02)
                        IO (Decode16, 0x0024, 0x0024, 0x01, 0x02)
                        IO (Decode16, 0x0028, 0x0028, 0x01, 0x02)
                        IO (Decode16, 0x002C, 0x002C, 0x01, 0x02)
                        IO (Decode16, 0x0030, 0x0030, 0x01, 0x02)
                        IO (Decode16, 0x0034, 0x0034, 0x01, 0x02)
                        IO (Decode16, 0x0038, 0x0038, 0x01, 0x02)
                        IO (Decode16, 0x003C, 0x003C, 0x01, 0x02)
                        IO (Decode16, 0x00A0, 0x00A0, 0x01, 0x02)
                        IO (Decode16, 0x00A4, 0x00A4, 0x01, 0x02)
                        IO (Decode16, 0x00A8, 0x00A8, 0x01, 0x02)
                        IO (Decode16, 0x00AC, 0x00AC, 0x01, 0x02)
                        IO (Decode16, 0x00B0, 0x00B0, 0x01, 0x02)
                        IO (Decode16, 0x00B4, 0x00B4, 0x01, 0x02)
                        IO (Decode16, 0x00B8, 0x00B8, 0x01, 0x02)
                        IO (Decode16, 0x00BC, 0x00BC, 0x01, 0x02)
                        IO (Decode16, 0x04D0, 0x04D0, 0x01, 0x02)
                        IRQNoFlags () {2}
                    })
                }

                Device (RTC)
                {
                    Name (_HID, EisaId ("PNP0B00"))
                    Name (BUF0, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0070, 0x0070, 0x01, 0x08)
                    })
                    Name (BUF1, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0070, 0x0070, 0x01, 0x08)
                        IRQNoFlags () {8}
                    })
                    Method (_CRS, 0, Serialized)
                    {
                        If (And (HPTE, 0x00020000))
                        {
                            Return (BUF0)
                        }

                        Return (BUF1)
                    }
                }

                Device (MATH)
                {
                    Name (_HID, EisaId ("PNP0C04"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x00F0, 0x00F0, 0x01, 0x01)
                        IRQNoFlags () {13}
                    })
                }

                Device (DMAC)
                {
                    Name (_HID, EisaId ("PNP0200"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0000, 0x0000, 0x01, 0x20)
                        IO (Decode16, 0x0081, 0x0081, 0x01, 0x0F)
                        IO (Decode16, 0x0090, 0x0090, 0x01, 0x02)
                        IO (Decode16, 0x0093, 0x0093, 0x01, 0x0D)
                        IO (Decode16, 0x00C0, 0x00C0, 0x01, 0x20)
                        DMA (Compatibility, NotBusMaster, Transfer8_16) {4}
                    })
                }

                Device (MBRD)
                {
                    Name (_HID, EisaId ("PNP0C02"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x002E, 0x002E, 0x01, 0x02)
                        IO (Decode16, 0x0061, 0x0061, 0x01, 0x01)
                        IO (Decode16, 0x0063, 0x0063, 0x01, 0x01)
                        IO (Decode16, 0x0065, 0x0065, 0x01, 0x01)
                        IO (Decode16, 0x0067, 0x0067, 0x01, 0x01)
                        IO (Decode16, 0x0080, 0x0080, 0x01, 0x01)
                        IO (Decode16, 0x0092, 0x0092, 0x01, 0x01)
                        IO (Decode16, 0x00B2, 0x00B2, 0x01, 0x02)
                        IO (Decode16, 0x0600, 0x0600, 0x01, 0x10)
                        IO (Decode16, 0x0700, 0x0700, 0x01, 0x10)
                        IO (Decode16, 0x1000, 0x1000, 0x01, 0x80)
                        IO (Decode16, 0x1180, 0x1180, 0x01, 0x40)
                        IO (Decode16, 0xFE00, 0xFE00, 0x01, 0x02)
                        IO (Decode16, 0xFE10, 0xFE10, 0x01, 0x08)
                        Memory32Fixed (ReadWrite, 0xFEBFE000, 0x00001000)
                        Memory32Fixed (ReadWrite, 0xFEBFF000, 0x00001000)
                        Memory32Fixed (ReadWrite, 0xFEC00000, 0x00001000)
                    })
                }

                Device (FWHD)
                {
                    Name (_HID, EisaId ("INT0800"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        Memory32Fixed (ReadOnly, 0xFF800000, 0x00800000)
                    })
                }

                Device (EC0)
                {
                    Name (_HID, EisaId ("PNP0C09"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0062, 0x0062, 0x01, 0x01)
                        IO (Decode16, 0x0066, 0x0066, 0x01, 0x01)
                    })
                    Name (_GPE, 0x1C)
                    Name (ECOK, 0x00)
                    Method (_REG, 2, NotSerialized)
                    {
                        If (LEqual (Arg0, 0x03))
                        {
                            Store (Arg1, ECOK)
                        }
                    }

                    Name (_PRW, Package (0x02)
                    {
                        0x1D, 
                        0x05
                    })
                    OperationRegion (ECR, EmbeddedControl, 0x00, 0xFF)
                    Field (ECR, ByteAcc, Lock, Preserve)
                    {
                        Offset (0x80), 
                        MPBP,   1, 
                        MPBD,   1, 
                        DOKD,   1, 
                        DFBP,   1, 
                        Offset (0x81), 
                        BT1A,   1, 
                        BT2A,   1, 
                        ACAT,   1, 
                        Offset (0x82), 
                        PWRB,   1, 
                        JOGB,   1, 
                        LIDS,   1, 
                        Offset (0x83), 
                        BT1P,   1, 
                        BT2P,   1, 
                        Offset (0x84), 
                        B1ST,   8, 
                        B2ST,   8, 
                        Offset (0x90), 
                        MASK,   8, 
                        BT1S,   1, 
                        BT2S,   1, 
                        Offset (0x92), 
                        BT1W,   1, 
                        BT2W,   1, 
                        Offset (0x93), 
                        FAN0,   8, 
                        CB0S,   1, 
                        CB1S,   1, 
                        Offset (0x95), 
                        PHYO,   1, 
                        Offset (0x96), 
                        BRIT,   8, 
                        CONT,   8, 
                        SNDU,   1, 
                        SNDD,   1, 
                        Offset (0x99), 
                        SMDM,   1, 
                        Offset (0x9A), 
                        Offset (0x9B), 
                        SIRQ,   8, 
                        SLOB,   8, 
                        SHIB,   8, 
                        MPWR,   1, 
                        WAKI,   1, 
                        Offset (0x9F), 
                        Offset (0xA0), 
                        B1RC,   16, 
                        B1AB,   16, 
                        B1AC,   16, 
                        B1VO,   16, 
                        B2RC,   16, 
                        B2AB,   16, 
                        B2AC,   16, 
                        B2VO,   16, 
                        B1DC,   16, 
                        B1LF,   16, 
                        B1DV,   16, 
                        B1DL,   16, 
                        B2DC,   16, 
                        B2LF,   16, 
                        B2DV,   16, 
                        B2DL,   16, 
                        A1TP,   16, 
                        A1AT,   16, 
                        A1PT,   16, 
                        A1CT,   16, 
                        A2TP,   16, 
                        A2AT,   16, 
                        A2PT,   16, 
                        A2CT,   16
                    }

                    Method (_Q50, 0, NotSerialized)
                    {
                        Notify (ACAD, 0x80)
                        \_SB.NCPU ()
                    }

                    Method (_Q51, 0, NotSerialized)
                    {
                        If (BT1A)
                        {
                            Notify (BAT1, 0x00)
                        }
                        Else
                        {
                            Notify (BAT1, 0x01)
                        }

                        Notify (BAT1, 0x80)
                    }

                    Method (_Q53, 0, NotSerialized)
                    {
                        Store ("_Q53:Battery Selection", Debug)
                    }

                    Method (_Q58, 0, NotSerialized)
                    {
                        Store ("_Q58:ATF temperature trip point changd", Debug)
                        Notify (\_TZ.ATF0, 0x81)
                    }

                    Method (_Q5F, 0, NotSerialized)
                    {
                        Store ("_Q5F:ATF temperature reaches trip point", Debug)
                        Notify (\_TZ.ATF0, 0x80)
                    }

                    Method (_Q60, 0, NotSerialized)
                    {
                        Notify (\_SB.PWRB, 0x80)
                    }

                    Method (_Q66, 0, NotSerialized)
                    {
                        Notify (\_SB.LID0, 0x80)
                    }

                    Device (BAT1)
                    {
                        Name (_HID, EisaId ("PNP0C0A"))
                        Name (_UID, 0x01)
                        Name (_PCL, Package (0x01)
                        {
                            \_SB
                        })
                        Name (BATI, Package (0x0D)
                        {
                            0x00, 
                            0x9650, 
                            0x9650, 
                            0x00, 
                            0x39D0, 
                            0x00, 
                            0x78, 
                            0x00, 
                            0x0A, 
                            "", 
                            "", 
                            "LION", 
                            "Sony Corp."
                        })
                        Name (BATS, Package (0x04)
                        {
                            0x02, 
                            0xFFFFFFFF, 
                            0x0D7A, 
                            0x3840
                        })
                        Method (_STA, 0, NotSerialized)
                        {
                            If (LEqual (\_SB.PCI0.LPCB.EC0.ECOK, 0x00))
                            {
                                And (PHSD (0xD4, 0x80), 0x0100, Local1)
                            }
                            Else
                            {
                                Store (BT1A, Local1)
                            }

                            If (Local1)
                            {
                                Store (0x1F, Local0)
                            }
                            Else
                            {
                                Store (0x0F, Local0)
                            }

                            Return (Local0)
                        }

                        Method (_BIF, 0, NotSerialized)
                        {
                            If (LEqual (\_SB.PCI0.LPCB.EC0.ECOK, 0x00))
                            {
                                Store (PHSD (0xD4, 0xB0), Local0)
                                Store (PHSD (0xD4, 0xB2), Local1)
                                Store (PHSD (0xD4, 0xB6), Local2)
                            }
                            Else
                            {
                                Store (B1DC, Local0)
                                Store (B1LF, Local1)
                                Store (B1DV, Local2)
                            }

                            Multiply (Local0, 0x0A, Index (BATI, 0x01))
                            Multiply (Local1, 0x0A, Index (BATI, 0x02))
                            Store (Local2, Index (BATI, 0x04))
                            Return (BATI)
                        }

                        Method (_BST, 0, NotSerialized)
                        {
                            If (LEqual (\_SB.PCI0.LPCB.EC0.ECOK, 0x00))
                            {
                                Store (And (PHSD (0xD4, 0x84), 0xFF, Local0), Index (BATS, 0x00))
                                Store (PHSD (0xD4, 0xA6), Local0)
                                Store (PHSD (0xD4, 0xA4), Local1)
                                Store (PHSD (0xD4, 0xA2), Local2)
                            }
                            Else
                            {
                                Store (B1ST, Index (BATS, 0x00))
                                Store (B1VO, Local0)
                                Store (B1AC, Local1)
                                Store (B1AB, Local2)
                            }

                            If (LEqual (Local1, 0xFFFF))
                            {
                                Store (0xFFFFFFFF, Local1)
                            }
                            Else
                            {
                                If (LNot (LLess (Local1, 0x8000)))
                                {
                                    XOr (Local1, 0xFFFF, Local1)
                                    Increment (Local1)
                                }

                                Multiply (Local0, Local1, Local1)
                                Divide (Local1, 0x03E8, , Local1)
                            }

                            Store (Local1, Index (BATS, 0x01))
                            Multiply (Local2, 0x0A, Index (BATS, 0x02))
                            Store (Local0, Index (BATS, 0x03))
                            Return (BATS)
                        }
                    }

                    Scope (\)
                    {
                        Name (PWRS, Ones)
                    }

                    Device (ACAD)
                    {
                        Name (_HID, "ACPI0003")
                        Name (_PCL, Package (0x01)
                        {
                            \_SB
                        })
                        Method (_PSR, 0, NotSerialized)
                        {
                            If (LEqual (\_SB.PCI0.LPCB.EC0.ECOK, 0x00))
                            {
                                And (PHSD (0xD4, 0x80), 0x0400, Local1)
                            }
                            Else
                            {
                                Store (ACAT, Local1)
                            }

                            Store (Local1, PWRS)
                            If (Local1)
                            {
                                Return (One)
                            }
                            Else
                            {
                                Return (Zero)
                            }
                        }

                        Method (_STA, 0, NotSerialized)
                        {
                            Return (0x0F)
                        }
                    }
                }

                Device (SPIC)
                {
                    Name (_HID, EisaId ("SNY6001"))
                    Name (RSRC, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0000, 0x0000, 0x01, 0x20)
                        IRQNoFlags () {}
                    })
                    Name (SSRC, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0000, 0x0000, 0x01, 0x20)
                        IRQNoFlags () {}
                    })
                    Name (SIRT, Package (0x04)
                    {
                        0x06, 
                        0x09, 
                        0x0A, 
                        0x0B
                    })
                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateByteField (RSRC, 0x02, IOM1)
                        CreateByteField (RSRC, 0x03, IOM2)
                        CreateWordField (RSRC, 0x02, IO1I)
                        CreateWordField (RSRC, 0x04, IO1A)
                        CreateWordField (RSRC, 0x09, IRQV)
                        If (LEqual (\_SB.PCI0.LPCB.EC0.ECOK, 0x00))
                        {
                            Store (PHSB (0xD4, 0x9C), IOM1)
                            Store (PHSB (0xD4, 0x9D), IOM2)
                        }
                        Else
                        {
                            Store (\_SB.PCI0.LPCB.EC0.SLOB, IOM1)
                            Store (\_SB.PCI0.LPCB.EC0.SHIB, IOM2)
                        }

                        Store (IO1I, IO1A)
                        If (LEqual (\_SB.PCI0.LPCB.EC0.ECOK, 0x00))
                        {
                            ShiftRight (PHSB (0xD4, 0x9B), 0x04, Local0)
                        }
                        Else
                        {
                            ShiftRight (\_SB.PCI0.LPCB.EC0.SIRQ, 0x04, Local0)
                        }

                        FindSetRightBit (Local0, Local1)
                        If (Local1)
                        {
                            Decrement (Local1)
                            Store (DerefOf (Index (SIRT, Local1)), Local0)
                            ShiftLeft (0x01, Local0, IRQV)
                        }

                        Return (RSRC)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateByteField (Arg0, 0x02, IOA1)
                        CreateByteField (Arg0, 0x03, IOA2)
                        CreateWordField (Arg0, 0x09, IRQV)
                        FindSetRightBit (IRQV, Local0)
                        If (Local0)
                        {
                            Decrement (Local0)
                            Store (Match (SIRT, MEQ, Local0, MTR, 0x00, 0x00), Local1)
                            ShiftLeft (0x10, Local1, Local2)
                        }
                        Else
                        {
                            Store (0x00, Local2)
                        }

                        If (LEqual (\_SB.PCI0.LPCB.EC0.ECOK, 0x00))
                        {
                            PHSW (0xD5, 0x9B, Local2)
                        }
                        Else
                        {
                            Store (Local2, \_SB.PCI0.LPCB.EC0.SIRQ)
                        }

                        If (LEqual (\_SB.PCI0.LPCB.EC0.ECOK, 0x00))
                        {
                            PHSW (0xD5, 0x9D, IOA2)
                            PHSW (0xD5, 0x9C, IOA1)
                        }
                        Else
                        {
                            Store (IOA2, \_SB.PCI0.LPCB.EC0.SHIB)
                            Store (IOA1, \_SB.PCI0.LPCB.EC0.SLOB)
                        }

                        Sleep (0x01)
                    }

                    Name (_PRS, ResourceTemplate ()
                    {
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16, 0x1080, 0x1080, 0x01, 0x20)
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16, 0x10A0, 0x10A0, 0x01, 0x20)
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16, 0x10C0, 0x10C0, 0x01, 0x20)
                        }
                        StartDependentFnNoPri ()
                        {
                            IO (Decode16, 0x10E0, 0x10E0, 0x01, 0x20)
                        }
                        EndDependentFn ()
                        IRQNoFlags () {6,9,10,11}
                    })
                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (_CRS (), SSRC)
                        If (LEqual (\_SB.PCI0.LPCB.EC0.ECOK, 0x00))
                        {
                            PHSW (0xD5, 0x9B, 0x00)
                            PHSW (0xD5, 0x9D, 0x00)
                            PHSW (0xD5, 0x9C, 0x00)
                        }
                        Else
                        {
                            Store (0x00, \_SB.PCI0.LPCB.EC0.SIRQ)
                            Store (0x00, \_SB.PCI0.LPCB.EC0.SHIB)
                            Store (0x00, \_SB.PCI0.LPCB.EC0.SLOB)
                        }

                        Sleep (0x01)
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        If (LEqual (\_SB.PCI0.LPCB.EC0.ECOK, 0x00))
                        {
                            ShiftRight (PHSB (0xD4, 0x9B), 0x04, Local0)
                        }
                        Else
                        {
                            ShiftRight (\_SB.PCI0.LPCB.EC0.SIRQ, 0x04, Local0)
                        }

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

                Device (SNC)
                {
                    Name (_HID, EisaId ("SNY5001"))
                    Method (GPID, 0, NotSerialized)
                    {
                        Return (PHSB (0xC0, 0x00))
                    }

                    Method (GBRT, 0, NotSerialized)
                    {
                        If (LEqual (\_SB.PCI0.LPCB.EC0.ECOK, 0x00))
                        {
                            Store (PHSD (0xD4, 0x96), Local0)
                        }
                        Else
                        {
                            Store (\_SB.PCI0.LPCB.EC0.BRIT, Local0)
                        }

                        Return (PHSB (0xCF, Local0))
                    }

                    Method (SBRT, 1, NotSerialized)
                    {
                        Store (PHSB (0xCD, Arg0), Local0)
                        If (LEqual (\_SB.PCI0.LPCB.EC0.ECOK, 0x00))
                        {
                            PHSB (0xC3, Local0)
                        }
                        Else
                        {
                            Store (Local0, \_SB.PCI0.LPCB.EC0.BRIT)
                        }

                        Return (Zero)
                    }

                    Method (GPBR, 0, NotSerialized)
                    {
                        Return (PHSB (0xC1, 0x00))
                    }

                    Method (SPBR, 1, NotSerialized)
                    {
                        PHSB (0xC2, Arg0)
                        Return (Zero)
                    }

                    Method (GCTR, 0, NotSerialized)
                    {
                        If (LEqual (\_SB.PCI0.LPCB.EC0.ECOK, 0x00))
                        {
                            Store (PHSD (0xD4, 0x97), Local0)
                        }
                        Else
                        {
                            Store (\_SB.PCI0.LPCB.EC0.CONT, Local0)
                        }

                        Return (PHSB (0xD0, Local0))
                    }

                    Method (SCTR, 1, NotSerialized)
                    {
                        Store (PHSB (0xCE, Arg0), Local0)
                        If (LEqual (\_SB.PCI0.LPCB.EC0.ECOK, 0x00))
                        {
                            PHSB (0xC6, Local0)
                        }
                        Else
                        {
                            Store (Local0, \_SB.PCI0.LPCB.EC0.CONT)
                        }

                        Return (Zero)
                    }

                    Method (GPCR, 0, NotSerialized)
                    {
                        Return (PHSB (0xC4, 0x00))
                    }

                    Method (SPCR, 1, NotSerialized)
                    {
                        PHSB (0xC5, Arg0)
                        Return (Zero)
                    }

                    Method (GCMI, 1, NotSerialized)
                    {
                        Return (PHSD (0xCA, Arg0))
                    }

                    Method (SCMI, 1, NotSerialized)
                    {
                        Return (PHSD (0xCB, Arg0))
                    }

                    Method (PWAK, 0, NotSerialized)
                    {
                        Acquire (PLOK, 0xFFFF)
                        Notify (\_PR.CPU0, 0x80)
                        Release (PLOK)
                        Return (Zero)
                    }

                    Method (PWRN, 0, NotSerialized)
                    {
                        Notify (\_SB.PWRB, 0x80)
                    }

                    Method (CSXB, 1, NotSerialized)
                    {
                        Acquire (MPHS, 0xFFFF)
                        Store (Arg0, SXBF)
                        PHS0 (0xCC)
                        Store (SXBF, Local0)
                        Release (MPHS)
                        Return (Local0)
                    }

                    Name (BSIT, 0xFFFF)
                    Method (CDPW, 1, Serialized)
                    {
                        If (Arg0)
                        {
                            If (LNot (And (\GL03, 0x08)))
                            {
                                Or (And (\_SB.PCI0.IDEC.ICR4, 0x03), 0x04, \_SB.PCI0.IDEC.ICR4)
                                Sleep (0x0A)
                                Or (\GL03, 0x08, \GL03)
                                Sleep (0x01F4)
                                And (\_SB.PCI0.IDEC.ICR4, 0x03, \_SB.PCI0.IDEC.ICR4)
                                Store (BSIT, \_SB.PCI0.IDEC.SECT)
                            }
                        }
                        Else
                        {
                            If (And (\GL03, 0x08))
                            {
                                Store (\_SB.PCI0.IDEC.SECT, BSIT)
                                Store (0x8000, \_SB.PCI0.IDEC.SECT)
                                Or (And (\_SB.PCI0.IDEC.ICR4, 0x03), 0x04, \_SB.PCI0.IDEC.ICR4)
                                Sleep (0x0A)
                                And (\GL03, 0xF7, \GL03)
                                Sleep (0x01F4)
                            }
                        }
                    }

                    Method (GCDP, 0, NotSerialized)
                    {
                        Return (ShiftRight (And (\GL03, 0x08), 0x03))
                    }

                    Method (GWDP, 0, NotSerialized)
                    {
                        Return (PHS (0xDF))
                    }

                    Method (NPPC, 1, NotSerialized)
                    {
                        Noop
                    }
                }

                Device (PS2K)
                {
                    Name (_HID, EisaId ("PNP0303"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0060, 0x0060, 0x01, 0x01)
                        IO (Decode16, 0x0064, 0x0064, 0x01, 0x01)
                        IRQ (Edge, ActiveHigh, Exclusive) {1}
                    })
                }

                Device (PS2M)
                {
                    Name (_HID, EisaId ("SNY9006"))
                    Name (_CID, 0x130FD041)
                    Name (_CRS, ResourceTemplate ()
                    {
                        IRQ (Edge, ActiveHigh, Exclusive) {12}
                    })
                }
            }

            Device (USB0)
            {
                Name (_ADR, 0x001D0000)
                OperationRegion (U0CS, PCI_Config, 0xC4, 0x04)
                Field (U0CS, DWordAcc, NoLock, Preserve)
                {
                    U0EN,   2
                }

                Name (_PRW, Package (0x02)
                {
                    0x03, 
                    0x03
                })
                Method (_PSW, 1, NotSerialized)
                {
                    If (Arg0)
                    {
                        Store (0x03, U0EN)
                    }
                    Else
                    {
                        Store (0x00, U0EN)
                    }
                }

                Method (_S1D, 0, NotSerialized)
                {
                    Return (0x02)
                }

                Method (_S3D, 0, NotSerialized)
                {
                    Return (0x02)
                }

                Method (_S4D, 0, NotSerialized)
                {
                    Return (0x02)
                }
            }

            Device (USB1)
            {
                Name (_ADR, 0x001D0001)
                OperationRegion (U1CS, PCI_Config, 0xC4, 0x04)
                Field (U1CS, DWordAcc, NoLock, Preserve)
                {
                    U1EN,   2
                }

                Name (_PRW, Package (0x02)
                {
                    0x04, 
                    0x03
                })
                Method (_PSW, 1, NotSerialized)
                {
                    If (Arg0)
                    {
                        Store (0x03, U1EN)
                    }
                    Else
                    {
                        Store (0x00, U1EN)
                    }
                }

                Method (_S1D, 0, NotSerialized)
                {
                    Return (0x02)
                }

                Method (_S3D, 0, NotSerialized)
                {
                    Return (0x02)
                }

                Method (_S4D, 0, NotSerialized)
                {
                    Return (0x02)
                }
            }

            Device (USB2)
            {
                Name (_ADR, 0x001D0002)
                OperationRegion (U2CS, PCI_Config, 0xC4, 0x04)
                Field (U2CS, DWordAcc, NoLock, Preserve)
                {
                    U2EN,   2
                }

                Name (_PRW, Package (0x02)
                {
                    0x0C, 
                    0x03
                })
                Method (_PSW, 1, NotSerialized)
                {
                    If (Arg0)
                    {
                        Store (0x03, U2EN)
                    }
                    Else
                    {
                        Store (0x00, U2EN)
                    }
                }

                Method (_S1D, 0, NotSerialized)
                {
                    Return (0x02)
                }

                Method (_S3D, 0, NotSerialized)
                {
                    Return (0x02)
                }

                Method (_S4D, 0, NotSerialized)
                {
                    Return (0x02)
                }
            }

            Device (USB7)
            {
                Name (_ADR, 0x001D0007)
                Name (_PRW, Package (0x02)
                {
                    0x0D, 
                    0x03
                })
            }

            Name (NATA, Package (0x01)
            {
                0x001F0001
            })
            Device (IDEC)
            {
                Name (_ADR, 0x001F0001)
                OperationRegion (IDEC, PCI_Config, 0x40, 0x18)
                Field (IDEC, DWordAcc, NoLock, Preserve)
                {
                    PRIT,   16, 
                    SECT,   16, 
                    PSIT,   4, 
                    SSIT,   4, 
                    Offset (0x08), 
                    SYNC,   4, 
                    Offset (0x0A), 
                    SDT0,   2, 
                        ,   2, 
                    SDT1,   2, 
                    Offset (0x0B), 
                    SDT2,   2, 
                        ,   2, 
                    SDT3,   2, 
                    Offset (0x14), 
                    ICR0,   4, 
                    ICR1,   4, 
                    ICR2,   4, 
                    ICR3,   4, 
                    ICR4,   4, 
                    ICR5,   4
                }

                Device (PRID)
                {
                    Name (_ADR, 0x00)
                    Method (_GTM, 0, NotSerialized)
                    {
                        Name (PBUF, Buffer (0x14)
                        {
                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                            0x00, 0x00, 0x00, 0x00
                        })
                        CreateDWordField (PBUF, 0x00, PIO0)
                        CreateDWordField (PBUF, 0x04, DMA0)
                        CreateDWordField (PBUF, 0x08, PIO1)
                        CreateDWordField (PBUF, 0x0C, DMA1)
                        CreateDWordField (PBUF, 0x10, FLAG)
                        Store (GETP (PRIT), PIO0)
                        Store (GDMA (And (SYNC, 0x01), And (ICR3, 0x01), And (ICR0, 0x01), SDT0, And (ICR1, 0x01)), DMA0)
                        If (LEqual (DMA0, 0xFFFFFFFF))
                        {
                            Store (PIO0, DMA0)
                        }

                        If (And (PRIT, 0x4000))
                        {
                            If (LEqual (And (PRIT, 0x90), 0x80))
                            {
                                Store (0x0384, PIO1)
                            }
                            Else
                            {
                                Store (GETT (PSIT), PIO1)
                            }
                        }
                        Else
                        {
                            Store (0xFFFFFFFF, PIO1)
                        }

                        Store (GDMA (And (SYNC, 0x02), And (ICR3, 0x02), And (ICR0, 0x02), SDT1, And (ICR1, 0x02)), DMA1)
                        If (LEqual (DMA1, 0xFFFFFFFF))
                        {
                            Store (PIO1, DMA1)
                        }

                        Store (GETF (And (SYNC, 0x01), And (SYNC, 0x02), PRIT), FLAG)
                        Return (PBUF)
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        CreateDWordField (Arg0, 0x00, PIO0)
                        CreateDWordField (Arg0, 0x04, DMA0)
                        CreateDWordField (Arg0, 0x08, PIO1)
                        CreateDWordField (Arg0, 0x0C, DMA1)
                        CreateDWordField (Arg0, 0x10, FLAG)
                        Or (ICR2, 0x04, ICR2)
                        If (LEqual (SizeOf (Arg1), 0x0200))
                        {
                            And (PRIT, 0x40F0, PRIT)
                            And (SYNC, 0x0E, SYNC)
                            Store (0x00, SDT0)
                            And (ICR0, 0x0E, ICR0)
                            And (ICR1, 0x0E, ICR1)
                            And (ICR3, 0x0E, ICR3)
                            And (ICR5, 0x0E, ICR5)
                            CreateWordField (Arg1, 0x62, W490)
                            CreateWordField (Arg1, 0x6A, W530)
                            CreateWordField (Arg1, 0x7E, W630)
                            CreateWordField (Arg1, 0x80, W640)
                            CreateWordField (Arg1, 0xB0, W880)
                            CreateWordField (Arg1, 0xBA, W930)
                            Or (PRIT, 0x8004, PRIT)
                            If (LAnd (And (FLAG, 0x02), And (W490, 0x0800)))
                            {
                                Or (PRIT, 0x02, PRIT)
                            }

                            Or (PRIT, SETP (PIO0, W530, W640), PRIT)
                            If (And (FLAG, 0x01))
                            {
                                Or (SYNC, 0x01, SYNC)
                                Store (SDMA (DMA0), SDT0)
                                If (LLess (DMA0, 0x1E))
                                {
                                    Or (ICR3, 0x01, ICR3)
                                }

                                If (LLess (DMA0, 0x3C))
                                {
                                    Or (ICR0, 0x01, ICR0)
                                }

                                If (And (W930, 0x2000))
                                {
                                    Or (ICR1, 0x01, ICR1)
                                }
                            }
                        }

                        If (LEqual (SizeOf (Arg2), 0x0200))
                        {
                            And (PRIT, 0x3F0F, PRIT)
                            Store (0x00, PSIT)
                            And (SYNC, 0x0D, SYNC)
                            Store (0x00, SDT1)
                            And (ICR0, 0x0D, ICR0)
                            And (ICR1, 0x0D, ICR1)
                            And (ICR3, 0x0D, ICR3)
                            And (ICR5, 0x0D, ICR5)
                            CreateWordField (Arg2, 0x62, W491)
                            CreateWordField (Arg2, 0x6A, W531)
                            CreateWordField (Arg2, 0x7E, W631)
                            CreateWordField (Arg2, 0x80, W641)
                            CreateWordField (Arg2, 0xB0, W881)
                            CreateWordField (Arg2, 0xBA, W931)
                            Or (PRIT, 0x8040, PRIT)
                            If (LAnd (And (FLAG, 0x08), And (W491, 0x0800)))
                            {
                                Or (PRIT, 0x20, PRIT)
                            }

                            If (And (FLAG, 0x10))
                            {
                                Or (PRIT, 0x4000, PRIT)
                                If (LGreater (PIO1, 0xF0))
                                {
                                    Or (PRIT, 0x80, PRIT)
                                }
                                Else
                                {
                                    Or (PRIT, 0x10, PRIT)
                                    Store (SETT (PIO1, W531, W641), PSIT)
                                }
                            }

                            If (And (FLAG, 0x04))
                            {
                                Or (SYNC, 0x02, SYNC)
                                Store (SDMA (DMA1), SDT1)
                                If (LLess (DMA0, 0x1E))
                                {
                                    Or (ICR3, 0x02, ICR3)
                                }

                                If (LLess (DMA0, 0x3C))
                                {
                                    Or (ICR0, 0x02, ICR0)
                                }

                                If (And (W931, 0x2000))
                                {
                                    Or (ICR1, 0x02, ICR1)
                                }
                            }
                        }
                    }

                    Device (P_D0)
                    {
                        Name (_ADR, 0x00)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Name (PIB0, Buffer (0x0E)
                            {
                                0x03, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x03, 
                                0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF
                            })
                            CreateByteField (PIB0, 0x01, PMD0)
                            CreateByteField (PIB0, 0x08, DMD0)
                            If (And (PRIT, 0x02))
                            {
                                If (LEqual (And (PRIT, 0x09), 0x08))
                                {
                                    Store (0x08, PMD0)
                                }
                                Else
                                {
                                    Store (0x0A, PMD0)
                                    ShiftRight (And (PRIT, 0x0300), 0x08, Local0)
                                    ShiftRight (And (PRIT, 0x3000), 0x0C, Local1)
                                    Add (Local0, Local1, Local2)
                                    If (LEqual (0x03, Local2))
                                    {
                                        Store (0x0B, PMD0)
                                    }

                                    If (LEqual (0x05, Local2))
                                    {
                                        Store (0x0C, PMD0)
                                    }
                                }
                            }
                            Else
                            {
                                Store (0x01, PMD0)
                            }

                            If (And (SYNC, 0x01))
                            {
                                Store (Or (SDT0, 0x40), DMD0)
                                If (And (ICR1, 0x01))
                                {
                                    If (And (ICR0, 0x01))
                                    {
                                        Add (DMD0, 0x02, DMD0)
                                    }

                                    If (And (ICR3, 0x01))
                                    {
                                        Store (0x45, DMD0)
                                    }
                                }
                            }
                            Else
                            {
                                Or (Subtract (And (PMD0, 0x07), 0x02), 0x20, DMD0)
                            }

                            Return (PIB0)
                        }
                    }

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

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

                Device (SECD)
                {
                    Name (_ADR, 0x01)
                    Method (_GTM, 0, NotSerialized)
                    {
                        Name (SBUF, Buffer (0x14)
                        {
                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                            0x00, 0x00, 0x00, 0x00
                        })
                        CreateDWordField (SBUF, 0x00, PIO0)
                        CreateDWordField (SBUF, 0x04, DMA0)
                        CreateDWordField (SBUF, 0x08, PIO1)
                        CreateDWordField (SBUF, 0x0C, DMA1)
                        CreateDWordField (SBUF, 0x10, FLAG)
                        Store (GETP (SECT), PIO0)
                        Store (GDMA (And (SYNC, 0x04), And (ICR3, 0x04), And (ICR0, 0x04), SDT2, And (ICR1, 0x04)), DMA0)
                        If (LEqual (DMA0, 0xFFFFFFFF))
                        {
                            Store (PIO0, DMA0)
                        }

                        If (And (SECT, 0x4000))
                        {
                            If (LEqual (And (SECT, 0x90), 0x80))
                            {
                                Store (0x0384, PIO1)
                            }
                            Else
                            {
                                Store (GETT (SSIT), PIO1)
                            }
                        }
                        Else
                        {
                            Store (0xFFFFFFFF, PIO1)
                        }

                        Store (GDMA (And (SYNC, 0x08), And (ICR3, 0x08), And (ICR0, 0x08), SDT3, And (ICR1, 0x08)), DMA1)
                        If (LEqual (DMA1, 0xFFFFFFFF))
                        {
                            Store (PIO1, DMA1)
                        }

                        Store (GETF (And (SYNC, 0x04), And (SYNC, 0x08), SECT), FLAG)
                        Return (SBUF)
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        CreateDWordField (Arg0, 0x00, PIO0)
                        CreateDWordField (Arg0, 0x04, DMA0)
                        CreateDWordField (Arg0, 0x08, PIO1)
                        CreateDWordField (Arg0, 0x0C, DMA1)
                        CreateDWordField (Arg0, 0x10, FLAG)
                        Or (ICR2, 0x04, ICR2)
                        If (LEqual (SizeOf (Arg1), 0x0200))
                        {
                            And (SECT, 0x40F0, SECT)
                            And (SYNC, 0x0B, SYNC)
                            Store (0x00, SDT2)
                            And (ICR0, 0x0B, ICR0)
                            And (ICR1, 0x0B, ICR1)
                            And (ICR3, 0x0B, ICR3)
                            And (ICR5, 0x0B, ICR5)
                            CreateWordField (Arg1, 0x62, W490)
                            CreateWordField (Arg1, 0x6A, W530)
                            CreateWordField (Arg1, 0x7E, W630)
                            CreateWordField (Arg1, 0x80, W640)
                            CreateWordField (Arg1, 0xB0, W880)
                            CreateWordField (Arg1, 0xBA, W930)
                            Or (SECT, 0x8004, SECT)
                            If (LAnd (And (FLAG, 0x02), And (W490, 0x0800)))
                            {
                                Or (SECT, 0x02, SECT)
                            }

                            Or (SECT, SETP (PIO0, W530, W640), SECT)
                            If (And (FLAG, 0x01))
                            {
                                Or (SYNC, 0x04, SYNC)
                                Store (SDMA (DMA0), SDT2)
                                If (LLess (DMA0, 0x1E))
                                {
                                    Or (ICR3, 0x04, ICR3)
                                }

                                If (LLess (DMA0, 0x3C))
                                {
                                    Or (ICR0, 0x04, ICR0)
                                }

                                If (And (W930, 0x2000))
                                {
                                    Or (ICR1, 0x04, ICR1)
                                }
                            }
                        }

                        If (LEqual (SizeOf (Arg2), 0x0200))
                        {
                            And (SECT, 0x3F0F, SECT)
                            Store (0x00, SSIT)
                            And (SYNC, 0x07, SYNC)
                            Store (0x00, SDT3)
                            And (ICR0, 0x07, ICR0)
                            And (ICR1, 0x07, ICR1)
                            And (ICR3, 0x07, ICR3)
                            And (ICR5, 0x07, ICR5)
                            CreateWordField (Arg2, 0x62, W491)
                            CreateWordField (Arg2, 0x6A, W531)
                            CreateWordField (Arg2, 0x7E, W631)
                            CreateWordField (Arg2, 0x80, W641)
                            CreateWordField (Arg2, 0xB0, W881)
                            CreateWordField (Arg2, 0xBA, W931)
                            Or (SECT, 0x8040, SECT)
                            If (LAnd (And (FLAG, 0x08), And (W491, 0x0800)))
                            {
                                Or (SECT, 0x20, SECT)
                            }

                            If (And (FLAG, 0x10))
                            {
                                Or (SECT, 0x4000, SECT)
                                If (LGreater (PIO1, 0xF0))
                                {
                                    Or (SECT, 0x80, SECT)
                                }
                                Else
                                {
                                    Or (SECT, 0x10, SECT)
                                    Store (SETT (PIO1, W531, W641), SSIT)
                                }
                            }

                            If (And (FLAG, 0x04))
                            {
                                Or (SYNC, 0x08, SYNC)
                                Store (SDMA (DMA1), SDT3)
                                If (LLess (DMA0, 0x1E))
                                {
                                    Or (ICR3, 0x08, ICR3)
                                }

                                If (LLess (DMA0, 0x3C))
                                {
                                    Or (ICR0, 0x08, ICR0)
                                }

                                If (And (W931, 0x2000))
                                {
                                    Or (ICR1, 0x08, ICR1)
                                }
                            }
                        }
                    }

                    Device (S_D0)
                    {
                        Name (_ADR, 0x00)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Name (SIB0, Buffer (0x0E)
                            {
                                0x03, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x03, 
                                0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF
                            })
                            CreateByteField (SIB0, 0x01, PMD0)
                            CreateByteField (SIB0, 0x08, DMD0)
                            If (And (SECT, 0x02))
                            {
                                If (LEqual (And (SECT, 0x09), 0x08))
                                {
                                    Store (0x08, PMD0)
                                }
                                Else
                                {
                                    Store (0x0A, PMD0)
                                    ShiftRight (And (SECT, 0x0300), 0x08, Local0)
                                    ShiftRight (And (SECT, 0x3000), 0x0C, Local1)
                                    Add (Local0, Local1, Local2)
                                    If (LEqual (0x03, Local2))
                                    {
                                        Store (0x0B, PMD0)
                                    }

                                    If (LEqual (0x05, Local2))
                                    {
                                        Store (0x0C, PMD0)
                                    }
                                }
                            }
                            Else
                            {
                                Store (0x01, PMD0)
                            }

                            If (And (SYNC, 0x04))
                            {
                                Store (Or (SDT2, 0x40), DMD0)
                                If (And (ICR1, 0x04))
                                {
                                    If (And (ICR0, 0x04))
                                    {
                                        Add (DMD0, 0x02, DMD0)
                                    }

                                    If (And (ICR3, 0x04))
                                    {
                                        Store (0x45, DMD0)
                                    }
                                }
                            }
                            Else
                            {
                                Or (Subtract (And (PMD0, 0x07), 0x02), 0x20, DMD0)
                            }

                            Return (SIB0)
                        }
                    }

                    Method (_PS0, 0, NotSerialized)
                    {
                    }

                    Method (_PS3, 0, NotSerialized)
                    {
                    }
                }

                Method (GETP, 1, Serialized)
                {
                    If (LEqual (And (Arg0, 0x09), 0x00))
                    {
                        Return (0xFFFFFFFF)
                    }

                    If (LEqual (And (Arg0, 0x09), 0x08))
                    {
                        Return (0x0384)
                    }

                    ShiftRight (And (Arg0, 0x0300), 0x08, Local0)
                    ShiftRight (And (Arg0, 0x3000), 0x0C, Local1)
                    Return (Multiply (0x1E, Subtract (0x09, Add (Local0, Local1))))
                }

                Method (GDMA, 5, Serialized)
                {
                    If (Arg0)
                    {
                        If (LAnd (Arg1, Arg4))
                        {
                            Return (0x14)
                        }

                        If (LAnd (Arg2, Arg4))
                        {
                            Return (Multiply (Subtract (0x04, Arg3), 0x0F))
                        }

                        Return (Multiply (Subtract (0x04, Arg3), 0x1E))
                    }

                    Return (0xFFFFFFFF)
                }

                Method (GETT, 1, Serialized)
                {
                    Return (Multiply (0x1E, Subtract (0x09, Add (And (ShiftRight (Arg0, 0x02), 0x03), And (Arg0, 0x03)))))
                }

                Method (GETF, 3, Serialized)
                {
                    Name (TMPF, 0x00)
                    If (Arg0)
                    {
                        Or (TMPF, 0x01, TMPF)
                    }

                    If (And (Arg2, 0x02))
                    {
                        Or (TMPF, 0x02, TMPF)
                    }

                    If (Arg1)
                    {
                        Or (TMPF, 0x04, TMPF)
                    }

                    If (And (Arg2, 0x20))
                    {
                        Or (TMPF, 0x08, TMPF)
                    }

                    If (And (Arg2, 0x4000))
                    {
                        Or (TMPF, 0x10, TMPF)
                    }

                    Return (TMPF)
                }

                Method (SETP, 3, Serialized)
                {
                    If (LGreater (Arg0, 0xF0))
                    {
                        Return (0x08)
                    }
                    Else
                    {
                        If (And (Arg1, 0x02))
                        {
                            If (LAnd (LNot (LGreater (Arg0, 0x78)), And (Arg2, 0x02)))
                            {
                                Return (0x2301)
                            }

                            If (LAnd (LNot (LGreater (Arg0, 0xB4)), And (Arg2, 0x01)))
                            {
                                Return (0x2101)
                            }
                        }

                        Return (0x1001)
                    }
                }

                Method (SDMA, 1, Serialized)
                {
                    If (LNot (LGreater (Arg0, 0x14)))
                    {
                        Return (0x01)
                    }

                    If (LNot (LGreater (Arg0, 0x1E)))
                    {
                        Return (0x02)
                    }

                    If (LNot (LGreater (Arg0, 0x2D)))
                    {
                        Return (0x01)
                    }

                    If (LNot (LGreater (Arg0, 0x3C)))
                    {
                        Return (0x02)
                    }

                    If (LNot (LGreater (Arg0, 0x5A)))
                    {
                        Return (0x01)
                    }

                    Return (0x00)
                }

                Method (SETT, 3, Serialized)
                {
                    If (And (Arg1, 0x02))
                    {
                        If (LAnd (LNot (LGreater (Arg0, 0x78)), And (Arg2, 0x02)))
                        {
                            Return (0x0B)
                        }

                        If (LAnd (LNot (LGreater (Arg0, 0xB4)), And (Arg2, 0x01)))
                        {
                            Return (0x09)
                        }
                    }

                    Return (0x04)
                }
            }

            Device (SBUS)
            {
                Name (_ADR, 0x001F0003)
                OperationRegion (SBUS, SystemIO, 0x1880, 0x10)
                Field (SBUS, ByteAcc, NoLock, Preserve)
                {
                    HSTS,   8, 
                    Offset (0x02), 
                    HCON,   8, 
                    HCOM,   8, 
                    TXSA,   8, 
                    DAT0,   8, 
                    DAT1,   8, 
                    BDBR,   8, 
                    Offset (0x09), 
                    RXSA,   8, 
                    SDAT,   16
                }

                Method (SBWB, 3, NotSerialized)
                {
                    Store (0x0A, Local0)
                    While (LAnd (And (HSTS, 0x01), Local0))
                    {
                        Sleep (0x64)
                        Decrement (Local0)
                    }

                    Store (0xFF, HSTS)
                    Store (Arg0, TXSA)
                    Store (Arg1, HCOM)
                    Store (Arg2, DAT0)
                    Store (0x00, DAT1)
                    Store (0x08, HCON)
                    Sleep (0x64)
                    Store (0x48, HCON)
                }

                Method (SBRB, 2, NotSerialized)
                {
                    Store (0x0A, Local0)
                    While (LAnd (And (HSTS, 0x01), Local0))
                    {
                        Sleep (0x64)
                        Decrement (Local0)
                    }

                    Store (0xFF, HSTS)
                    Store (Or (Arg0, 0x01), TXSA)
                    Store (Arg1, HCOM)
                    Store (0x08, HCON)
                    Sleep (0x64)
                    Store (0x48, HCON)
                    Store (0x0A, Local0)
                    While (LAnd (And (HSTS, 0x02), Local0))
                    {
                        Sleep (0x64)
                        Decrement (Local0)
                    }

                    Return (DAT0)
                }
            }

            Device (AUD0)
            {
                Name (_ADR, 0x001F0005)
            }

            Device (MODM)
            {
                Name (_ADR, 0x001F0006)
                Name (_PRW, Package (0x02)
                {
                    0x05, 
                    0x03
                })
            }
        }
    }

    Scope (_PR.CPU0)
    {
        Method (_PPC, 0, NotSerialized)
        {
            If (\_SB.PCI0.LPCB.EC0.ECOK)
            {
                Store (\_SB.PCI0.LPCB.EC0.ACAT, Local0)
            }
            Else
            {
                And (\PHSD (0xD4, 0x80), 0x0400, Local0)
            }

            If (Local0)
            {
                Return (PSAC)
            }
            Else
            {
                Return (PSDC)
            }
        }

        Name (PDC0, 0xF0000000)
        Method (_PDC, 1, NotSerialized)
        {
            CreateDWordField (Arg0, 0x08, CAP0)
            Store (CAP0, PDC0)
        }

        Method (_PCT, 0, NotSerialized)
        {
            If (LEqual (And (PDC0, One), One))
            {
                Return (Package (0x02)
                {
                    ResourceTemplate ()
                    {
                        Register (FFixedHW, 0x00, 0x00, 0x0000000000000000)
                    }, 

                    ResourceTemplate ()
                    {
                        Register (FFixedHW, 0x00, 0x00, 0x0000000000000000)
                    }
                })
            }
            Else
            {
                Return (Package (0x02)
                {
                    ResourceTemplate ()
                    {
                        Register (SystemIO, 0x10, 0x00, 0x00000000000000B2)
                    }, 

                    ResourceTemplate ()
                    {
                        Register (SystemIO, 0x08, 0x00, 0x00000000000000B3)
                    }
                })
            }
        }

        Method (_PSS, 0, NotSerialized)
        {
            If (LEqual (And (PDC0, One), One))
            {
                Return (NPSS)
            }
            Else
            {
                Return (SPSS)
            }
        }

        Name (NPSS, Package (0x06)
        {
            Package (0x06)
            {
                0x000006A4, 
                0x00005FB4, 
                0x0000000A, 
                0x0000000A, 
                0x00001131, 
                0x00001131
            }, 

            Package (0x06)
            {
                0x00000578, 
                0x00004C2C, 
                0x0000000A, 
                0x0000000A, 
                0x00000E26, 
                0x00000E26
            }, 

            Package (0x06)
            {
                0x000004B0, 
                0x00003E80, 
                0x0000000A, 
                0x0000000A, 
                0x00000C21, 
                0x00000C21
            }, 

            Package (0x06)
            {
                0x000003E8, 
                0x000032C8, 
                0x0000000A, 
                0x0000000A, 
                0x00000A1A, 
                0x00000A1A
            }, 

            Package (0x06)
            {
                0x00000320, 
                0x0000251C, 
                0x0000000A, 
                0x0000000A, 
                0x00000813, 
                0x00000813
            }, 

            Package (0x06)
            {
                0x00000258, 
                0x00001770, 
                0x0000000A, 
                0x0000000A, 
                0x00000610, 
                0x00000610
            }
        })
        Name (SPSS, Package (0x06)
        {
            Package (0x06)
            {
                0x000006A4, 
                0x00005FB4, 
                0x00000064, 
                0x0000006E, 
                0x00000083, 
                0x00000000
            }, 

            Package (0x06)
            {
                0x00000578, 
                0x00004C2C, 
                0x00000064, 
                0x0000006E, 
                0x00000183, 
                0x00000001
            }, 

            Package (0x06)
            {
                0x000004B0, 
                0x00003E80, 
                0x00000064, 
                0x0000006E, 
                0x00000283, 
                0x00000002
            }, 

            Package (0x06)
            {
                0x000003E8, 
                0x000032C8, 
                0x00000064, 
                0x0000006E, 
                0x00000383, 
                0x00000003
            }, 

            Package (0x06)
            {
                0x00000320, 
                0x0000251C, 
                0x00000064, 
                0x0000006E, 
                0x00000483, 
                0x00000004
            }, 

            Package (0x06)
            {
                0x00000258, 
                0x00001770, 
                0x00000064, 
                0x0000006E, 
                0x00000583, 
                0x00000005
            }
        })
    }
}

nexus0
  acpi0
    cpu0 pnpinfo _HID=none _UID=0 at handle=\_PR_.CPU0
    acpi_tz0 pnpinfo _HID=none _UID=0 at handle=\_TZ_.ATF0
    acpi_lid0 pnpinfo _HID=PNP0C0D _UID=0 at handle=\_SB_.LID0
    acpi_button0 pnpinfo _HID=PNP0C0C _UID=0 at handle=\_SB_.PWRB
    pcib0 pnpinfo _HID=PNP0A03 _UID=0 at handle=\_SB_.PCI0
      pci0
        hostb0 pnpinfo vendor=0x8086 device=0x3340 subvendor=0x104d subdevice=0x8140 class=0x060000 at slot=0 function=0
        pcib1 pnpinfo vendor=0x8086 device=0x3341 subvendor=0x0000 subdevice=0x0000 class=0x060400 at slot=1 function=0 handle=\_SB_.PCI0.AGPB
          pci1
            unknown pnpinfo vendor=0x1002 device=0x4c59 subvendor=0x104d subdevice=0x8140 class=0x030000 at slot=0 function=0 handle=\_SB_.PCI0.AGPB.VID0
        uhci0 pnpinfo vendor=0x8086 device=0x24c2 subvendor=0x104d subdevice=0x8140 class=0x0c0300 at slot=29 function=0 handle=\_SB_.PCI0.USB0
          usb0
            uhub0
        uhci1 pnpinfo vendor=0x8086 device=0x24c4 subvendor=0x104d subdevice=0x8140 class=0x0c0300 at slot=29 function=1 handle=\_SB_.PCI0.USB1
          usb1
            uhub1
              uhub2 pnpinfo vendor=0x0451 product=0x1446 devclass=0x09 devsubclass=0x00 sernum="" at port=0
                ukbd0 pnpinfo vendor=0x046e product=0x6782 devclass=0x00 devsubclass=0x00 sernum="" intclass=0x03 intsubclass=0x01 at port=2 interface=0
                ums0 pnpinfo vendor=0x046e product=0x6782 devclass=0x00 devsubclass=0x00 sernum="" intclass=0x03 intsubclass=0x01 at port=2 interface=1
                ums1 pnpinfo vendor=0x045e product=0x001e devclass=0x00 devsubclass=0x00 sernum="" intclass=0x03 intsubclass=0x01 at port=3 interface=0
        uhci2 pnpinfo vendor=0x8086 device=0x24c7 subvendor=0x104d subdevice=0x8140 class=0x0c0300 at slot=29 function=2 handle=\_SB_.PCI0.USB2
          usb2
            uhub3
        ehci0 pnpinfo vendor=0x8086 device=0x24cd subvendor=0x104d subdevice=0x8140 class=0x0c0320 at slot=29 function=7 handle=\_SB_.PCI0.USB7
          usb3
            uhub4
              umass1 pnpinfo vendor=0x054c product=0x014d devclass=0x00 devsubclass=0x00 sernum="0052449677492224" intclass=0x08 intsubclass=0x05 at port=4 interface=0
        pcib2 pnpinfo vendor=0x8086 device=0x2448 subvendor=0x0000 subdevice=0x0000 class=0x060400 at slot=30 function=0 handle=\_SB_.PCI0.PCIB
          pci2
            cbb0 pnpinfo vendor=0x1180 device=0x0475 subvendor=0x104d subdevice=0x8140 class=0x060700 at slot=5 function=0 handle=\_SB_.PCI0.PCIB.CRD0
              cardbus0
              pccard0
            fwohci0 pnpinfo vendor=0x1180 device=0x0551 subvendor=0x104d subdevice=0x8140 class=0x0c0010 at slot=5 function=1 handle=\_SB_.PCI0.PCIB.SD94
              firewire0
                sbp0
            fxp0 pnpinfo vendor=0x8086 device=0x103d subvendor=0x104d subdevice=0x8140 class=0x020000 at slot=8 function=0 handle=\_SB_.PCI0.PCIB.LANC
              miibus0
                inphy0
            ndis0 pnpinfo vendor=0x8086 device=0x4220 subvendor=0x8086 subdevice=0x2751 class=0x028000 at slot=11 function=0 handle=\_SB_.PCI0.PCIB.WLAN
        isab0 pnpinfo vendor=0x8086 device=0x24cc subvendor=0x0000 subdevice=0x0000 class=0x060100 at slot=31 function=0 handle=\_SB_.PCI0.LPCB
          isa0
            pmtimer0
            sc0
            vga0
            adv0
            aha0
            aic0
            bt0
            cs0
            ed0
            fdc0
            fe0
            ie0
            lnc0
            pcic0
            pcic1
            ppc0
            sio0
            sio1
            sio2
            sio3
            sn0
            vt0
            orm0
        atapci0 pnpinfo vendor=0x8086 device=0x24ca subvendor=0x104d subdevice=0x8140 class=0x01018a at slot=31 function=1 handle=\_SB_.PCI0.IDEC
          ata0
          ata1
        unknown pnpinfo vendor=0x8086 device=0x24c3 subvendor=0x104d subdevice=0x8140 class=0x0c0500 at slot=31 function=3 handle=\_SB_.PCI0.SBUS
        pcm0 pnpinfo vendor=0x8086 device=0x24c5 subvendor=0x104d subdevice=0x8140 class=0x040100 at slot=31 function=5 handle=\_SB_.PCI0.AUD0
        unknown pnpinfo vendor=0x8086 device=0x24c6 subvendor=0x104d subdevice=0x8140 class=0x070300 at slot=31 function=6 handle=\_SB_.PCI0.MODM
    unknown pnpinfo _HID=none _UID=0 at handle=\_SB_.PCI0.AGPB.VID0.CRT_
    unknown pnpinfo _HID=none _UID=0 at handle=\_SB_.PCI0.AGPB.VID0.LCD_
    unknown pnpinfo _HID=none _UID=0 at handle=\_SB_.PCI0.AGPB.VID0.TV__
    unknown pnpinfo _HID=PNP0C0F _UID=1 at handle=\_SB_.PCI0.LPCB.LNKA
    unknown pnpinfo _HID=PNP0C0F _UID=2 at handle=\_SB_.PCI0.LPCB.LNKB
    unknown pnpinfo _HID=PNP0C0F _UID=3 at handle=\_SB_.PCI0.LPCB.LNKC
    unknown pnpinfo _HID=PNP0C0F _UID=4 at handle=\_SB_.PCI0.LPCB.LNKD
    unknown pnpinfo _HID=PNP0C0F _UID=5 at handle=\_SB_.PCI0.LPCB.LNKE
    unknown pnpinfo _HID=PNP0C0F _UID=6 at handle=\_SB_.PCI0.LPCB.LNKF
    unknown pnpinfo _HID=PNP0C0F _UID=7 at handle=\_SB_.PCI0.LPCB.LNKG
    unknown pnpinfo _HID=PNP0C0F _UID=8 at handle=\_SB_.PCI0.LPCB.LNKH
    attimer0 pnpinfo _HID=PNP0100 _UID=0 at handle=\_SB_.PCI0.LPCB.TIMR
    atpic0 pnpinfo _HID=PNP0000 _UID=0 at handle=\_SB_.PCI0.LPCB.IPIC
    attimer1 pnpinfo _HID=PNP0B00 _UID=0 at handle=\_SB_.PCI0.LPCB.RTC_
    npxisa0 pnpinfo _HID=PNP0C04 _UID=0 at handle=\_SB_.PCI0.LPCB.MATH
    atdma0 pnpinfo _HID=PNP0200 _UID=0 at handle=\_SB_.PCI0.LPCB.DMAC
    acpi_sysresource0 pnpinfo _HID=PNP0C02 _UID=0 at handle=\_SB_.PCI0.LPCB.MBRD
    unknown pnpinfo _HID=INT0800 _UID=0 at handle=\_SB_.PCI0.LPCB.FWHD
    acpi_ec0 pnpinfo _HID=PNP0C09 _UID=0 at handle=\_SB_.PCI0.LPCB.EC0_
    acpi_cmbat0 pnpinfo _HID=PNP0C0A _UID=1 at handle=\_SB_.PCI0.LPCB.EC0_.BAT1
    acpi_acad0 pnpinfo _HID=ACPI0003 _UID=0 at handle=\_SB_.PCI0.LPCB.EC0_.ACAD
    unknown pnpinfo _HID=SNY6001 _UID=0 at handle=\_SB_.PCI0.LPCB.SPIC
    unknown pnpinfo _HID=SNY5001 _UID=0 at handle=\_SB_.PCI0.LPCB.SNC_
    atkbdc0 pnpinfo _HID=PNP0303 _UID=0 at handle=\_SB_.PCI0.LPCB.PS2K
      atkbd0
      psm0
    psmcpnp0 pnpinfo _HID=SNY9006 _UID=0 at handle=\_SB_.PCI0.LPCB.PS2M
    unknown pnpinfo _HID=none _UID=0 at handle=\_SB_.PCI0.IDEC.PRID
    unknown pnpinfo _HID=none _UID=0 at handle=\_SB_.PCI0.IDEC.PRID.P_D0
    unknown pnpinfo _HID=none _UID=0 at handle=\_SB_.PCI0.IDEC.SECD
    unknown pnpinfo _HID=none _UID=0 at handle=\_SB_.PCI0.IDEC.SECD.S_D0
    acpi_timer0 pnpinfo unknown at unknown
  legacy0
  npx0
Received on Mon Aug 30 2004 - 05:58:56 UTC

This archive was generated by hypermail 2.4.0 : Wed May 19 2021 - 11:38:09 UTC