Skip site navigation (1)Skip section navigation (2)
Date:      Tue, 21 Aug 2007 10:58:25 -0700
From:      Sean Bruno <sbruno@miralink.com>
To:        Sean Bruno <sbruno@miralink.com>
Cc:        freebsd-acpi@freebsd.org
Subject:   Re: Supermicro Boot Lockup with ACPI enabled
Message-ID:  <46CB27C1.4090805@miralink.com>
In-Reply-To: <46C37FBF.50004@miralink.com>
References:  <46C37FBF.50004@miralink.com>

next in thread | previous in thread | raw e-mail | index | archive | help

[-- Attachment #1 --]
Sean Bruno wrote:
> I am using RELENG6_2 on a Supermicro 5015P-TR that has a model PDSMP-I 
> motherboard.  It currently locks up when booting the system with ACPI 
> enabled in the BIOS and at the same time a card(I've tried an Adaptec 
> 29160, 29320 and a Qlogic F/C 2342) in either PCI-X slot.
>
> If I deselect ACPI in the BIOS, the system boots and all is well.  If 
> I remove the expansion cards, I can boot with ACPI enabled and all is 
> well.  I can then dump the DSDT to look for errors.  I don't see 
> anything obvious and I'm not sure how to proceed.
>
> I'm looking to see how I can find the error in the DSDT and report it 
> to supermicro, but I can't see anything wrong with the tables that I 
> have attached to the email.  There doesn't appear to be any updates to 
> the BIOS for this system either.  Any ideas?
>
> Sean
> ------------------------------------------------------------------------
I was able to dump the ACPI tables with a pci card inserted by disabling 
the driver for that card(in my case, the ISP driver).  I still don't see 
any reason why FreeBSD 6.2 freezes when ACPI is enabled and a card is in 
the PCI-X slot.  I have attached the full DSDT dump, hopefully someone 
can give me a clue here so I can get SuperMicro to fix their box?

Sean

[-- Attachment #2 --]
/*
  RSD PTR: OEM=PTLTD, ACPI_Rev=1.0x (0)
	RSDT=0x1fee3fa0, cksum=77
 */
/*
  RSDT: Length=56, Revision=1, Checksum=132,
	OEMID=PTLTD, OEM Table ID=  RSDT, OEM Revision=0x6040000,
	Creator ID= LTP, Creator Revision=0x0
	Entries={ 0x1fee8ea8, 0x1fee8f1c, 0x1fee8f58, 0x1fee8fd8, 0x1fee3fd8 }
 */
/*
  FACP: Length=116, Revision=1, Checksum=94,
	OEMID=INTEL, OEM Table ID=, OEM Revision=0x6040000,
	Creator ID=PTL, Creator Revision=0x3
 	FACS=0x1fee9fc0, DSDT=0x1fee4392
	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=101 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=
	Flags={WBINVD,PROC_C1,SLP_BUTTON,RTC_S4}
 */
/*
  FACS:	Length=64, HwSig=0x00000000, Firm_Wake_Vec=0x00000000
	Global_Lock=
	Flags=
	Version=0
 */
/*
  DSDT: Length=19222, Revision=1, Checksum=11,
	OEMID=INTEL, OEM Table ID=GLENWOOD, OEM Revision=0x6040000,
	Creator ID=MSFT, Creator Revision=0x100000e
 */
/*
  MCFG: Length=60, Revision=1, Checksum=78,
	OEMID=PTLTD, OEM Table ID=  MCFG, OEM Revision=0x6040000,
	Creator ID= LTP, Creator Revision=0x0

	Base Address= 0x00000000f0000000
	Segment Group= 0x0000
	Start Bus= 0
	End Bus= 9
 */
/*
  APIC: Length=128, Revision=1, Checksum=2,
	OEMID=PTLTD, OEM Table ID=	 APIC, OEM Revision=0x6040000,
	Creator ID= LTP, Creator Revision=0x0
	Local APIC ADDR=0xfee00000
	Flags={PC-AT}

	Type=Local APIC
	ACPI CPU=0
	Flags={ENABLED}
	APIC ID=0

	Type=Local APIC
	ACPI CPU=1
	Flags={ENABLED}
	APIC ID=1

	Type=IO APIC
	APIC ID=2
	INT BASE=0
	ADDR=0x00000000fec00000

	Type=IO APIC
	APIC ID=3
	INT BASE=24
	ADDR=0x00000000fec80000

	Type=IO APIC
	APIC ID=4
	INT BASE=48
	ADDR=0x00000000fec80400

	Type=INT Override
	BUS=0
	IRQ=0
	INTR=2
	Flags={Polarity=active-hi, Trigger=edge}

	Type=INT Override
	BUS=0
	IRQ=9
	INTR=9
	Flags={Polarity=active-hi, Trigger=level}

	Type=Local NMI
	ACPI CPU=0
	LINT Pin=1
	Flags={Polarity=active-hi, Trigger=edge}

	Type=Local NMI
	ACPI CPU=1
	LINT Pin=1
	Flags={Polarity=active-hi, Trigger=edge}
 */
/*
  BOOT: Length=40, Revision=1, Checksum=164,
	OEMID=PTLTD, OEM Table ID=$SBFTBL$, OEM Revision=0x6040000,
	Creator ID= LTP, Creator Revision=0x1
 */
/*
  SSDT: Length=954, Revision=1, Checksum=118,
	OEMID=PmRef, OEM Table ID=CpuPm, OEM Revision=0x3000,
	Creator ID=INTL, Creator Revision=0x20030224
 */
/*
 * Intel ACPI Component Architecture
 * AML Disassembler version 20041119
 *
 * Disassembly of /tmp/acpidump.Jf3Z24, Tue Aug 21 10:53:01 2007
 */
DefinitionBlock ("DSDT.aml", "DSDT", 1, "INTEL", "GLENWOOD", 100925440)
{
    OperationRegion (RCRB, SystemMemory, 0xFED1C000, 0x00004000)
    Field (RCRB, DWordAcc, Lock, Preserve)
    {
        Offset (0x1000), 
        Offset (0x3000), 
        Offset (0x3404), 
        HPAS,   2, 
            ,   5, 
        HPAE,   1, 
        Offset (0x3418), 
            ,   1, 
        PATD,   1, 
        SATD,   1, 
        SMBD,   1, 
        AZAD,   1, 
        A97D,   1
    }

    Name (OSYS, 0x00)
    Scope (_GPE)
    {
        Method (_L03, 0, NotSerialized)
        {
            Store (0x03, DEBG)
            Notify (\_SB.PCI0.USB1, 0x02)
        }

        Method (_L04, 0, NotSerialized)
        {
            Store (0x04, DEBG)
            Notify (\_SB.PCI0.USB2, 0x02)
        }

        Method (_L08, 0, NotSerialized)
        {
            Store (0x08, DEBG)
            Notify (\_SB.PCI0.LPC0.SIO.COM1, 0x02)
            Notify (\_SB.PCI0.LPC0.SIO.COM2, 0x02)
            Notify (\_SB.PCI0.PWRB, 0x02)
        }

        Method (_L09, 0, NotSerialized)
        {
            Store (0x09, DEBG)
            Notify (\_SB.PCI0.EXP1, 0x02)
            Notify (\_SB.PCI0.EXP5, 0x02)
            Notify (\_SB.PCI0.EXP6, 0x02)
        }

        Method (_L0B, 0, NotSerialized)
        {
            Store (0x0B, DEBG)
            Notify (\_SB.PCI0.DEV1.PXHA, 0x02)
            Notify (\_SB.PCI0.DEV1.PXHB, 0x02)
            Notify (\_SB.PCI0.PCIB, 0x02)
        }

        Method (_L0C, 0, NotSerialized)
        {
            Store (0x0C, DEBG)
            Notify (\_SB.PCI0.USB3, 0x02)
        }

        Method (_L0D, 0, NotSerialized)
        {
            Store (0x0D, DEBG)
            Notify (\_SB.PCI0.EUSB, 0x02)
        }

        Method (_L0E, 0, NotSerialized)
        {
            Store (0x0E, DEBG)
            Notify (\_SB.PCI0.USB4, 0x02)
        }

        Method (_L1D, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.LPC0.SIO.KBC0, 0x02)
            Notify (\_SB.PCI0.LPC0.SIO.MSE0, 0x02)
        }
    }

    Scope (_PR)
    {
        Processor (CPU0, 0x00, 0x00001010, 0x06) {}
        Processor (CPU1, 0x01, 0x00001010, 0x06) {}
        Processor (CPU2, 0x02, 0x00001010, 0x06) {}
        Processor (CPU3, 0x03, 0x00001010, 0x06) {}
    }

    Scope (_SB)
    {
        Device (PCI0)
        {
            Method (_INI, 0, NotSerialized)
            {
            }

            Name (_HID, EisaId ("PNP0A03"))
            Name (_BBN, 0x00)
            Name (_ADR, 0x00)
            OperationRegion (REGS, PCI_Config, 0x40, 0xC0)
            Field (REGS, ByteAcc, NoLock, Preserve)
            {
                Offset (0x50), 
                PAM0,   8, 
                PAM1,   8, 
                PAM2,   8, 
                PAM3,   8, 
                PAM4,   8, 
                PAM5,   8, 
                PAM6,   8, 
                    ,   7, 
                HEN,    1, 
                Offset (0x5C), 
                Z000,   8
            }

            OperationRegion (DRBS, SystemMemory, 0xFED14000, 0x00004000)
            Field (DRBS, DWordAcc, Lock, Preserve)
            {
                Offset (0x100), 
                Z001,   8, 
                Z002,   8, 
                Z003,   8, 
                Z004,   8, 
                Offset (0x180), 
                Z005,   8, 
                Z006,   8, 
                Z007,   8, 
                Z008,   8
            }

            Name (RSRC, ResourceTemplate ()
            {
                WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode,
                    0x0000,
                    0x0000,
                    0x00FF,
                    0x0000,
                    0x0100, 0x00)
                IO (Decode16, 0x0CF8, 0x0CF8, 0x01, 0x08)
                DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                    0x00000000,
                    0x00000000,
                    0x00000CF7,
                    0x00000000,
                    0x00000CF8, 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,
                    0x00000000,
                    0x00000000,
                    0x00000000, 0x00)
                DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                    0x00000000,
                    0x00000D00,
                    0x0000FDFF,
                    0x00000000,
                    0x0000F100, 0x00)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,
                    0x00000000,
                    0x00000000,
                    0x00000000,
                    0x00000000, 0x00)
            })
            Method (_CRS, 0, Serialized)
            {
                Store (Zero, Local1)
                CreateDWordField (RSRC, 0x01B8, BTMN)
                CreateDWordField (RSRC, 0x01BC, BTMX)
                CreateDWordField (RSRC, 0x01C4, BTLN)
                ShiftLeft (And (Z000, 0xF8), 0x18, BTMN)
                Subtract (0xF0000000, BTMN, BTLN)
                Subtract (Add (BTMN, BTLN), 0x01, BTMX)
                CreateBitField (RSRC, 0x02A0, C0RW)
                CreateDWordField (RSRC, 0x59, C0MN)
                CreateDWordField (RSRC, 0x5D, C0MX)
                CreateDWordField (RSRC, 0x65, C0LN)
                Store (One, C0RW)
                If (LEqual (And (PAM1, 0x03), 0x01))
                {
                    Store (Zero, C0RW)
                }

                Store (Zero, C0LN)
                If (LNot (And (PAM1, 0x03)))
                {
                    Store (0x4000, C0LN)
                }

                CreateBitField (RSRC, 0x0378, C4RW)
                CreateDWordField (RSRC, 0x74, C4MN)
                CreateDWordField (RSRC, 0x78, C4MX)
                CreateDWordField (RSRC, 0x80, C4LN)
                Store (One, C4RW)
                If (LEqual (And (PAM1, 0x30), 0x10))
                {
                    Store (Zero, C4RW)
                }

                Store (Zero, C4LN)
                If (LNot (And (PAM1, 0x30)))
                {
                    Store (0x4000, C4LN)
                }

                CreateBitField (RSRC, 0x0450, C8RW)
                CreateDWordField (RSRC, 0x8F, C8MN)
                CreateDWordField (RSRC, 0x93, C8MX)
                CreateDWordField (RSRC, 0x9B, C8LN)
                Store (One, C8RW)
                If (LEqual (And (PAM2, 0x03), 0x01))
                {
                    Store (Zero, C8RW)
                }

                Store (Zero, C8LN)
                If (LNot (And (PAM2, 0x03)))
                {
                    Store (0x4000, C8LN)
                }

                CreateBitField (RSRC, 0x0528, CCRW)
                CreateDWordField (RSRC, 0xAA, CCMN)
                CreateDWordField (RSRC, 0xAE, CCMX)
                CreateDWordField (RSRC, 0xB6, CCLN)
                Store (One, CCRW)
                If (LEqual (And (PAM2, 0x30), 0x10))
                {
                    Store (Zero, CCRW)
                }

                Store (Zero, CCLN)
                If (LNot (And (PAM2, 0x30)))
                {
                    Store (0x4000, CCLN)
                }

                CreateBitField (RSRC, 0x0600, D0RW)
                CreateDWordField (RSRC, 0xC5, D0MN)
                CreateDWordField (RSRC, 0xC9, D0MX)
                CreateDWordField (RSRC, 0xD1, D0LN)
                Store (One, D0RW)
                If (LEqual (And (PAM3, 0x03), 0x01))
                {
                    Store (Zero, D0RW)
                }

                Store (Zero, D0LN)
                If (LNot (And (PAM3, 0x03)))
                {
                    Store (0x4000, D0LN)
                }

                CreateBitField (RSRC, 0x06D8, D4RW)
                CreateDWordField (RSRC, 0xE0, D4MN)
                CreateDWordField (RSRC, 0xE4, D4MX)
                CreateDWordField (RSRC, 0xEC, D4LN)
                Store (One, D4RW)
                If (LEqual (And (PAM3, 0x30), 0x10))
                {
                    Store (Zero, D4RW)
                }

                Store (Zero, D4LN)
                If (LNot (And (PAM3, 0x30)))
                {
                    Store (0x4000, D4LN)
                }

                CreateBitField (RSRC, 0x07B0, D8RW)
                CreateDWordField (RSRC, 0xFB, D8MN)
                CreateDWordField (RSRC, 0xFF, D8MX)
                CreateDWordField (RSRC, 0x0107, D8LN)
                Store (One, D8RW)
                If (LEqual (And (PAM4, 0x03), 0x01))
                {
                    Store (Zero, D8RW)
                }

                Store (Zero, D8LN)
                If (LNot (And (PAM4, 0x03)))
                {
                    Store (0x4000, D8LN)
                }

                CreateBitField (RSRC, 0x0888, DCRW)
                CreateDWordField (RSRC, 0x0116, DCMN)
                CreateDWordField (RSRC, 0x011A, DCMX)
                CreateDWordField (RSRC, 0x0122, DCLN)
                Store (One, DCRW)
                If (LEqual (And (PAM4, 0x30), 0x10))
                {
                    Store (Zero, DCRW)
                }

                Store (Zero, DCLN)
                If (LNot (And (PAM4, 0x30)))
                {
                    Store (0x4000, DCLN)
                }

                CreateBitField (RSRC, 0x0960, E0RW)
                CreateDWordField (RSRC, 0x0131, E0MN)
                CreateDWordField (RSRC, 0x0135, E0MX)
                CreateDWordField (RSRC, 0x013D, E0LN)
                Store (One, E0RW)
                If (LEqual (And (PAM5, 0x03), 0x01))
                {
                    Store (Zero, E0RW)
                }

                Store (Zero, E0LN)
                If (LNot (And (PAM5, 0x03)))
                {
                    Store (0x4000, E0LN)
                }

                CreateBitField (RSRC, 0x0A38, E4RW)
                CreateDWordField (RSRC, 0x014C, E4MN)
                CreateDWordField (RSRC, 0x0150, E4MX)
                CreateDWordField (RSRC, 0x0158, E4LN)
                Store (One, E4RW)
                If (LEqual (And (PAM5, 0x30), 0x10))
                {
                    Store (Zero, E4RW)
                }

                Store (Zero, E4LN)
                If (LNot (And (PAM5, 0x30)))
                {
                    Store (0x4000, E4LN)
                }

                CreateBitField (RSRC, 0x0B10, E8RW)
                CreateDWordField (RSRC, 0x0167, E8MN)
                CreateDWordField (RSRC, 0x016B, E8MX)
                CreateDWordField (RSRC, 0x0173, E8LN)
                Store (One, E8RW)
                If (LEqual (And (PAM6, 0x03), 0x01))
                {
                    Store (Zero, E8RW)
                }

                Store (Zero, E8LN)
                If (LNot (And (PAM6, 0x03)))
                {
                    Store (0x4000, E8LN)
                }

                CreateBitField (RSRC, 0x0BE8, ECRW)
                CreateDWordField (RSRC, 0x0182, ECMN)
                CreateDWordField (RSRC, 0x0186, ECMX)
                CreateDWordField (RSRC, 0x018E, ECLN)
                Store (One, ECRW)
                If (LEqual (And (PAM6, 0x30), 0x10))
                {
                    Store (Zero, ECRW)
                }

                Store (Zero, ECLN)
                If (LNot (And (PAM6, 0x30)))
                {
                    Store (0x4000, ECLN)
                }

                CreateBitField (RSRC, 0x0CC0, F0RW)
                CreateDWordField (RSRC, 0x019D, F0MN)
                CreateDWordField (RSRC, 0x01A1, F0MX)
                CreateDWordField (RSRC, 0x01A9, F0LN)
                Store (One, F0RW)
                If (LEqual (And (PAM0, 0x30), 0x10))
                {
                    Store (Zero, F0RW)
                }

                Store (Zero, F0LN)
                If (LNot (And (PAM0, 0x30)))
                {
                    Store (0x00010000, F0LN)
                }

                If (HPAE)
                {
                    CreateDWordField (RSRC, 0x01EE, M2MN)
                    CreateDWordField (RSRC, 0x01F2, M2MX)
                    CreateDWordField (RSRC, 0x01FA, M2LN)
                    Store (0xFED00000, M2MN)
                    Store (0xFED003FF, M2MX)
                    Store (0x0400, M2LN)
                    If (LEqual (HPAS, 0x01))
                    {
                        Store (0xFED01000, M2MN)
                        Store (0xFED013FF, M2MX)
                    }

                    If (LEqual (HPAS, 0x02))
                    {
                        Store (0xFED02000, M2MN)
                        Store (0xFED023FF, M2MX)
                    }

                    If (LEqual (HPAS, 0x03))
                    {
                        Store (0xFED03000, M2MN)
                        Store (0xFED033FF, M2MX)
                    }
                }

                Return (RSRC)
            }

            Method (_PRT, 0, NotSerialized)
            {
                If (LNot (\PICF))
                {
                    Return (Package (0x0C)
                    {
                        Package (0x04)
                        {
                            0x0001FFFF, 
                            0x00, 
                            \_SB.PCI0.LPC0.LNKA, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x001CFFFF, 
                            0x00, 
                            \_SB.PCI0.LPC0.LNKB, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x001CFFFF, 
                            0x01, 
                            \_SB.PCI0.LPC0.LNKA, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x001CFFFF, 
                            0x02, 
                            \_SB.PCI0.LPC0.LNKC, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x001CFFFF, 
                            0x03, 
                            \_SB.PCI0.LPC0.LNKD, 
                            0x00
                        }, 

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

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

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

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

                        Package (0x04)
                        {
                            0x001FFFFF, 
                            0x00, 
                            \_SB.PCI0.LPC0.LNKC, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x001FFFFF, 
                            0x01, 
                            \_SB.PCI0.LPC0.LNKD, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x001FFFFF, 
                            0x03, 
                            \_SB.PCI0.LPC0.LNKA, 
                            0x00
                        }
                    })
                }
                Else
                {
                    Return (Package (0x0C)
                    {
                        Package (0x04)
                        {
                            0x0001FFFF, 
                            0x00, 
                            0x00, 
                            0x10
                        }, 

                        Package (0x04)
                        {
                            0x001CFFFF, 
                            0x00, 
                            0x00, 
                            0x11
                        }, 

                        Package (0x04)
                        {
                            0x001CFFFF, 
                            0x01, 
                            0x00, 
                            0x10
                        }, 

                        Package (0x04)
                        {
                            0x001CFFFF, 
                            0x02, 
                            0x00, 
                            0x12
                        }, 

                        Package (0x04)
                        {
                            0x001CFFFF, 
                            0x03, 
                            0x00, 
                            0x13
                        }, 

                        Package (0x04)
                        {
                            0x001DFFFF, 
                            0x00, 
                            0x00, 
                            0x17
                        }, 

                        Package (0x04)
                        {
                            0x001DFFFF, 
                            0x01, 
                            0x00, 
                            0x13
                        }, 

                        Package (0x04)
                        {
                            0x001DFFFF, 
                            0x02, 
                            0x00, 
                            0x12
                        }, 

                        Package (0x04)
                        {
                            0x001DFFFF, 
                            0x03, 
                            0x00, 
                            0x10
                        }, 

                        Package (0x04)
                        {
                            0x001FFFFF, 
                            0x00, 
                            0x00, 
                            0x12
                        }, 

                        Package (0x04)
                        {
                            0x001FFFFF, 
                            0x01, 
                            0x00, 
                            0x13
                        }, 

                        Package (0x04)
                        {
                            0x001FFFFF, 
                            0x03, 
                            0x00, 
                            0x10
                        }
                    })
                }
            }

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

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

            Device (DEV1)
            {
                Name (_ADR, 0x00010000)
                Device (PXHA)
                {
                    Name (_ADR, 0x00)
                    Name (_PRW, Package (0x02)
                    {
                        0x0B, 
                        0x05
                    })
                    Method (_PRT, 0, NotSerialized)
                    {
                        If (LNot (\PICF))
                        {
                            Return (Package (0x06)
                            {
                                Package (0x04)
                                {
                                    0x0005FFFF, 
                                    0x00, 
                                    \_SB.PCI0.LPC0.LNKA, 
                                    0x00
                                }, 

                                Package (0x04)
                                {
                                    0x0005FFFF, 
                                    0x01, 
                                    \_SB.PCI0.LPC0.LNKB, 
                                    0x00
                                }, 

                                Package (0x04)
                                {
                                    0x0005FFFF, 
                                    0x02, 
                                    \_SB.PCI0.LPC0.LNKC, 
                                    0x00
                                }, 

                                Package (0x04)
                                {
                                    0x0005FFFF, 
                                    0x03, 
                                    \_SB.PCI0.LPC0.LNKD, 
                                    0x00
                                }, 

                                Package (0x04)
                                {
                                    0x0006FFFF, 
                                    0x00, 
                                    \_SB.PCI0.LPC0.LNKC, 
                                    0x00
                                }, 

                                Package (0x04)
                                {
                                    0x0006FFFF, 
                                    0x01, 
                                    \_SB.PCI0.LPC0.LNKD, 
                                    0x00
                                }
                            })
                        }
                        Else
                        {
                            Return (Package (0x06)
                            {
                                Package (0x04)
                                {
                                    0x0005FFFF, 
                                    0x00, 
                                    0x00, 
                                    0x18
                                }, 

                                Package (0x04)
                                {
                                    0x0005FFFF, 
                                    0x01, 
                                    0x00, 
                                    0x19
                                }, 

                                Package (0x04)
                                {
                                    0x0005FFFF, 
                                    0x02, 
                                    0x00, 
                                    0x1A
                                }, 

                                Package (0x04)
                                {
                                    0x0005FFFF, 
                                    0x03, 
                                    0x00, 
                                    0x1B
                                }, 

                                Package (0x04)
                                {
                                    0x0006FFFF, 
                                    0x00, 
                                    0x00, 
                                    0x1A
                                }, 

                                Package (0x04)
                                {
                                    0x0006FFFF, 
                                    0x01, 
                                    0x00, 
                                    0x1B
                                }
                            })
                        }
                    }
                }

                Device (PXHB)
                {
                    Name (_ADR, 0x02)
                    Name (_PRW, Package (0x02)
                    {
                        0x0B, 
                        0x05
                    })
                    Method (_PRT, 0, NotSerialized)
                    {
                        If (LNot (\PICF))
                        {
                            Return (Package (0x04)
                            {
                                Package (0x04)
                                {
                                    0x0002FFFF, 
                                    0x00, 
                                    \_SB.PCI0.LPC0.LNKA, 
                                    0x00
                                }, 

                                Package (0x04)
                                {
                                    0x0002FFFF, 
                                    0x01, 
                                    \_SB.PCI0.LPC0.LNKB, 
                                    0x00
                                }, 

                                Package (0x04)
                                {
                                    0x0002FFFF, 
                                    0x02, 
                                    \_SB.PCI0.LPC0.LNKC, 
                                    0x00
                                }, 

                                Package (0x04)
                                {
                                    0x0002FFFF, 
                                    0x03, 
                                    \_SB.PCI0.LPC0.LNKD, 
                                    0x00
                                }
                            })
                        }
                        Else
                        {
                            Return (Package (0x04)
                            {
                                Package (0x04)
                                {
                                    0x0002FFFF, 
                                    0x00, 
                                    0x00, 
                                    0x30
                                }, 

                                Package (0x04)
                                {
                                    0x0002FFFF, 
                                    0x01, 
                                    0x00, 
                                    0x31
                                }, 

                                Package (0x04)
                                {
                                    0x0002FFFF, 
                                    0x02, 
                                    0x00, 
                                    0x32
                                }, 

                                Package (0x04)
                                {
                                    0x0002FFFF, 
                                    0x03, 
                                    0x00, 
                                    0x33
                                }
                            })
                        }
                    }
                }
            }

            Device (EXP1)
            {
                Name (_ADR, 0x001C0000)
                Name (_PRW, Package (0x02)
                {
                    0x09, 
                    0x05
                })
                Method (_PRT, 0, NotSerialized)
                {
                    If (LNot (\PICF))
                    {
                        Return (Package (0x04)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                0x00, 
                                \_SB.PCI0.LPC0.LNKA, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x01, 
                                \_SB.PCI0.LPC0.LNKB, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x02, 
                                \_SB.PCI0.LPC0.LNKC, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x03, 
                                \_SB.PCI0.LPC0.LNKD, 
                                0x00
                            }
                        })
                    }
                    Else
                    {
                        Return (Package (0x04)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                0x00, 
                                0x00, 
                                0x10
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x01, 
                                0x00, 
                                0x11
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x02, 
                                0x00, 
                                0x12
                            }, 

                            Package (0x04)
                            {
                                0xFFFF, 
                                0x03, 
                                0x00, 
                                0x13
                            }
                        })
                    }
                }
            }

            Device (EXP5)
            {
                Name (_ADR, 0x001C0004)
                Name (_PRW, Package (0x02)
                {
                    0x09, 
                    0x05
                })
                Method (_PRT, 0, NotSerialized)
                {
                    If (LNot (\PICF))
                    {
                        Return (Package (0x01)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                0x00, 
                                \_SB.PCI0.LPC0.LNKA, 
                                0x00
                            }
                        })
                    }
                    Else
                    {
                        Return (Package (0x01)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                0x00, 
                                0x00, 
                                0x10
                            }
                        })
                    }
                }
            }

            Device (EXP6)
            {
                Name (_ADR, 0x001C0005)
                Name (_PRW, Package (0x02)
                {
                    0x09, 
                    0x05
                })
                Method (_PRT, 0, NotSerialized)
                {
                    If (LNot (\PICF))
                    {
                        Return (Package (0x01)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                0x00, 
                                \_SB.PCI0.LPC0.LNKB, 
                                0x00
                            }
                        })
                    }
                    Else
                    {
                        Return (Package (0x01)
                        {
                            Package (0x04)
                            {
                                0xFFFF, 
                                0x00, 
                                0x00, 
                                0x11
                            }
                        })
                    }
                }
            }

            Device (PCIB)
            {
                Name (_ADR, 0x001E0000)
                Name (_PRW, Package (0x02)
                {
                    0x0B, 
                    0x05
                })
                Method (_PRT, 0, NotSerialized)
                {
                    If (LNot (\PICF))
                    {
                        Return (Package (0x03)
                        {
                            Package (0x04)
                            {
                                0x0002FFFF, 
                                0x00, 
                                \_SB.PCI0.LPC0.LNKA, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0x0002FFFF, 
                                0x01, 
                                \_SB.PCI0.LPC0.LNKB, 
                                0x00
                            }, 

                            Package (0x04)
                            {
                                0x0001FFFF, 
                                0x00, 
                                \_SB.PCI0.LPC0.LNKC, 
                                0x00
                            }
                        })
                    }
                    Else
                    {
                        Return (Package (0x03)
                        {
                            Package (0x04)
                            {
                                0x0002FFFF, 
                                0x00, 
                                0x00, 
                                0x10
                            }, 

                            Package (0x04)
                            {
                                0x0002FFFF, 
                                0x01, 
                                0x00, 
                                0x11
                            }, 

                            Package (0x04)
                            {
                                0x0001FFFF, 
                                0x00, 
                                0x00, 
                                0x12
                            }
                        })
                    }
                }
            }

            Device (LPC0)
            {
                Name (_ADR, 0x001F0000)
                Name (DVEN, 0x00)
                Method (DECD, 4, Serialized)
                {
                    Store (Arg0, Debug)
                }

                Device (MBRD)
                {
                    Name (_HID, EisaId ("PNP0C02"))
                    Name (_UID, 0x1F)
                    Name (RSRC, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0010, 0x0010, 0x01, 0x10)
                        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, 0x0072, 0x0072, 0x01, 0x06)
                        IO (Decode16, 0x0080, 0x0080, 0x01, 0x01)
                        IO (Decode16, 0x0090, 0x0090, 0x01, 0x10)
                        IO (Decode16, 0x00A4, 0x00A4, 0x01, 0x02)
                        IO (Decode16, 0x00A8, 0x00A8, 0x01, 0x02)
                        IO (Decode16, 0x00AC, 0x00AC, 0x01, 0x02)
                        IO (Decode16, 0x00B0, 0x00B0, 0x01, 0x06)
                        IO (Decode16, 0x00B8, 0x00B8, 0x01, 0x02)
                        IO (Decode16, 0x00BC, 0x00BC, 0x01, 0x02)
                        IO (Decode16, 0x0295, 0x0295, 0x01, 0x02)
                        IO (Decode16, 0x0800, 0x0800, 0x01, 0x40)
                        IO (Decode16, 0x0900, 0x0900, 0x01, 0x10)
                        IO (Decode16, 0x1000, 0x1000, 0x01, 0x80)
                        IO (Decode16, 0x1180, 0x1180, 0x01, 0x40)
                        IO (Decode16, 0x002E, 0x002E, 0x01, 0x02)
                        IO (Decode16, 0x04D0, 0x04D0, 0x01, 0x02)
                        IO (Decode16, 0xFE00, 0xFE00, 0x01, 0x01)
                        Memory32Fixed (ReadWrite, 0xFED14000, 0x00004000)
                        Memory32Fixed (ReadWrite, 0xFED13000, 0x00001000)
                        Memory32Fixed (ReadWrite, 0xFED18000, 0x00004000)
                        Memory32Fixed (ReadWrite, 0xF0000000, 0x04000000)
                        Memory32Fixed (ReadWrite, 0xFED20000, 0x00070000)
                        Memory32Fixed (ReadWrite, 0xFEF00000, 0x00100000)
                    })
                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0xA2, PMMN)
                        CreateWordField (RSRC, 0xA4, PMMX)
                        And (^^PMBA, 0xFF80, PMMN)
                        Store (PMMN, PMMX)
                        CreateWordField (RSRC, 0xAA, GPMN)
                        CreateWordField (RSRC, 0xAC, GPMX)
                        And (^^GPBA, 0xFF80, GPMN)
                        Store (GPMN, GPMX)
                        Return (RSRC)
                    }
                }

                Device (DMAC)
                {
                    Name (_HID, EisaId ("PNP0200"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0000, 0x0000, 0x01, 0x10)
                        IO (Decode16, 0x0081, 0x0081, 0x01, 0x0F)
                        IO (Decode16, 0x00C0, 0x00C0, 0x01, 0x20)
                        DMA (Compatibility, NotBusMaster, Transfer16) {4}
                    })
                }

                Device (MATH)
                {
                    Name (_HID, EisaId ("PNP0C04"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x00F0, 0x00F0, 0x01, 0x0F)
                        IRQ (Edge, ActiveHigh, Exclusive) {13}
                    })
                }

                Device (PIC)
                {
                    Name (_HID, EisaId ("PNP0000"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0020, 0x0020, 0x01, 0x02)
                        IO (Decode16, 0x00A0, 0x00A0, 0x01, 0x02)
                        IRQ (Edge, ActiveHigh, Exclusive) {2}
                    })
                }

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

                        Return (BUF1)
                    }
                }

                Device (SPKR)
                {
                    Name (_HID, EisaId ("PNP0800"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0061, 0x0061, 0x01, 0x01)
                    })
                }

                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 (HPAE)
                        {
                            Return (BUF0)
                        }

                        Return (BUF1)
                    }
                }

                Device (MMTM)
                {
                    Name (_HID, EisaId ("PNP0103"))
                    Name (BUF0, ResourceTemplate ()
                    {
                        IRQNoFlags () {0}
                        IRQNoFlags () {8}
                        Memory32Fixed (ReadOnly, 0xFED00000, 0x00000400)
                    })
                    Method (_STA, 0, NotSerialized)
                    {
                        If (LNot (LLess (OSYS, 0x07D1)))
                        {
                            If (HPAE)
                            {
                                Return (0x0F)
                            }
                        }
                        Else
                        {
                            If (HPAE)
                            {
                                Return (0x0B)
                            }
                        }

                        Return (0x00)
                    }

                    Method (_CRS, 0, Serialized)
                    {
                        If (HPAE)
                        {
                            CreateDWordField (BUF0, 0x0A, HPT0)
                            If (LEqual (HPAS, 0x01))
                            {
                                Store (0xFED01000, HPT0)
                            }

                            If (LEqual (HPAS, 0x02))
                            {
                                Store (0xFED02000, HPT0)
                            }

                            If (LEqual (HPAS, 0x03))
                            {
                                Store (0xFED03000, HPT0)
                            }
                        }

                        Return (BUF0)
                    }
                }

                Device (LNKA)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x01)
                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {3,10,11,14,15}
                    })
                    Name (RSRC, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {}
                    })
                    Method (_DIS, 0, NotSerialized)
                    {
                        Or (PIRA, 0x80, PIRA)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x01, IRQ0)
                        And (PIRA, 0x0F, Local0)
                        ShiftLeft (0x01, Local0, IRQ0)
                        Store (RSRC, Debug)
                        Return (RSRC)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        Store (Arg0, Debug)
                        CreateWordField (Arg0, 0x01, IRQ0)
                        FindSetRightBit (IRQ0, Local0)
                        Decrement (Local0)
                        Or (Local0, And (PIRA, 0x70), PIRA)
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        If (And (PIRA, 0x80))
                        {
                            Return (0x09)
                        }

                        Return (0x0B)
                    }
                }

                Device (LNKB)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x02)
                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {3,10,11,14,15}
                    })
                    Name (RSRC, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {}
                    })
                    Method (_DIS, 0, NotSerialized)
                    {
                        Or (PIRB, 0x80, PIRB)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x01, IRQ0)
                        And (PIRB, 0x0F, Local0)
                        ShiftLeft (0x01, Local0, IRQ0)
                        Return (RSRC)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        FindSetRightBit (IRQ0, Local0)
                        Decrement (Local0)
                        Or (Local0, And (PIRB, 0x70), PIRB)
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        If (And (PIRB, 0x80))
                        {
                            Return (0x09)
                        }

                        Return (0x0B)
                    }
                }

                Device (LNKC)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x03)
                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {3,10,11,14,15}
                    })
                    Name (RSRC, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {}
                    })
                    Method (_DIS, 0, NotSerialized)
                    {
                        Or (PIRC, 0x80, PIRC)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x01, IRQ0)
                        And (PIRC, 0x0F, Local0)
                        ShiftLeft (0x01, Local0, IRQ0)
                        Return (RSRC)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        FindSetRightBit (IRQ0, Local0)
                        Decrement (Local0)
                        Or (Local0, And (PIRC, 0x70), PIRC)
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        If (And (PIRC, 0x80))
                        {
                            Return (0x09)
                        }

                        Return (0x0B)
                    }
                }

                Device (LNKD)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x04)
                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {3,10,11,14,15}
                    })
                    Name (RSRC, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {}
                    })
                    Method (_DIS, 0, NotSerialized)
                    {
                        Or (PIRD, 0x80, PIRD)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x01, IRQ0)
                        And (PIRD, 0x0F, Local0)
                        ShiftLeft (0x01, Local0, IRQ0)
                        Return (RSRC)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        FindSetRightBit (IRQ0, Local0)
                        Decrement (Local0)
                        Or (Local0, And (PIRD, 0x70), PIRD)
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        If (And (PIRD, 0x80))
                        {
                            Return (0x09)
                        }

                        Return (0x0B)
                    }
                }

                Device (LNKE)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x05)
                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {3,10,11,14,15}
                    })
                    Name (RSRC, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {}
                    })
                    Method (_DIS, 0, NotSerialized)
                    {
                        Or (PIRE, 0x80, PIRE)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x01, IRQ0)
                        And (PIRE, 0x0F, Local0)
                        ShiftLeft (0x01, Local0, IRQ0)
                        Store (RSRC, Debug)
                        Return (RSRC)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        Store (Arg0, Debug)
                        CreateWordField (Arg0, 0x01, IRQ0)
                        FindSetRightBit (IRQ0, Local0)
                        Decrement (Local0)
                        Or (Local0, And (PIRE, 0x70), PIRE)
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        If (And (PIRE, 0x80))
                        {
                            Return (0x09)
                        }

                        Return (0x0B)
                    }
                }

                Device (LNKF)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x06)
                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {3,10,11,14,15}
                    })
                    Name (RSRC, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {}
                    })
                    Method (_DIS, 0, NotSerialized)
                    {
                        Or (PIRF, 0x80, PIRF)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x01, IRQ0)
                        And (PIRF, 0x0F, Local0)
                        ShiftLeft (0x01, Local0, IRQ0)
                        Store (RSRC, Debug)
                        Return (RSRC)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        Store (Arg0, Debug)
                        CreateWordField (Arg0, 0x01, IRQ0)
                        FindSetRightBit (IRQ0, Local0)
                        Decrement (Local0)
                        Or (Local0, And (PIRF, 0x70), PIRF)
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        If (And (PIRF, 0x80))
                        {
                            Return (0x09)
                        }

                        Return (0x0B)
                    }
                }

                Device (LNKG)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x07)
                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {3,10,11,14,15}
                    })
                    Name (RSRC, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {}
                    })
                    Method (_DIS, 0, NotSerialized)
                    {
                        Or (PIRG, 0x80, PIRG)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x01, IRQ0)
                        And (PIRG, 0x0F, Local0)
                        ShiftLeft (0x01, Local0, IRQ0)
                        Store (RSRC, Debug)
                        Return (RSRC)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        Store (Arg0, Debug)
                        CreateWordField (Arg0, 0x01, IRQ0)
                        FindSetRightBit (IRQ0, Local0)
                        Decrement (Local0)
                        Or (Local0, And (PIRG, 0x70), PIRG)
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        If (And (PIRG, 0x80))
                        {
                            Return (0x09)
                        }

                        Return (0x0B)
                    }
                }

                Device (LNKH)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x08)
                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {3,10,11,14,15}
                    })
                    Name (RSRC, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {}
                    })
                    Method (_DIS, 0, NotSerialized)
                    {
                        Or (PIRH, 0x80, PIRH)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x01, IRQ0)
                        And (PIRH, 0x0F, Local0)
                        ShiftLeft (0x01, Local0, IRQ0)
                        Store (RSRC, Debug)
                        Return (RSRC)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        Store (Arg0, Debug)
                        CreateWordField (Arg0, 0x01, IRQ0)
                        FindSetRightBit (IRQ0, Local0)
                        Decrement (Local0)
                        Or (Local0, And (PIRH, 0x70), PIRH)
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        If (And (PIRH, 0x80))
                        {
                            Return (0x09)
                        }

                        Return (0x0B)
                    }
                }

                OperationRegion (GPOX, SystemIO, 0x1180, 0x30)
                Field (GPOX, DWordAcc, NoLock, Preserve)
                {
                    Offset (0x07), 
                        ,   3, 
                    IO27,   1, 
                    Offset (0x0F), 
                        ,   3, 
                    LV27,   1, 
                    Offset (0x1B), 
                        ,   3, 
                    BL27,   1
                }

                OperationRegion (PIRX, PCI_Config, 0x60, 0x04)
                Field (PIRX, DWordAcc, Lock, Preserve)
                {
                    AccessAs (ByteAcc, 0x00), 
                    PIRA,   8, 
                    PIRB,   8, 
                    PIRC,   8, 
                    PIRD,   8
                }

                OperationRegion (PIRY, PCI_Config, 0x68, 0x04)
                Field (PIRY, DWordAcc, Lock, Preserve)
                {
                    AccessAs (ByteAcc, 0x00), 
                    PIRE,   8, 
                    PIRF,   8, 
                    PIRG,   8, 
                    PIRH,   8
                }

                OperationRegion (ELR0, PCI_Config, 0xA0, 0x14)
                Field (ELR0, DWordAcc, Lock, Preserve)
                {
                        ,   9, 
                    PBLV,   1, 
                    Offset (0x10), 
                        ,   1, 
                    ELSS,   1, 
                        ,   1, 
                    ELST,   1, 
                    ELPB,   1, 
                    Offset (0x11), 
                        ,   1, 
                    ELLO,   1, 
                    ELGN,   2, 
                    ELYL,   2, 
                    ELBE,   1, 
                    ELIE,   1, 
                    ELSN,   1, 
                    ELOC,   1, 
                    Offset (0x13), 
                    ELSO,   1
                }

                OperationRegion (ROUT, SystemIO, 0xB8, 0x04)
                Field (ROUT, DWordAcc, Lock, Preserve)
                {
                    AccessAs (ByteAcc, 0x00), 
                    GPI0,   2, 
                    GPI1,   2, 
                    GPI2,   2, 
                    GPI3,   2, 
                    GPI4,   2, 
                    GPI5,   2, 
                    GPI6,   2, 
                    GPI7,   2, 
                    GPI8,   2, 
                    GPI9,   2, 
                    GP10,   2, 
                    GP11,   2, 
                    GP12,   2, 
                    GP13,   2, 
                    GP14,   2, 
                    GP15,   2
                }

                OperationRegion (PMIO, SystemIO, 0x1000, 0x30)
                Field (PMIO, WordAcc, NoLock, Preserve)
                {
                    AccessAs (DWordAcc, 0x00), 
                    Offset (0x2D), 
                        ,   4, 
                    GPES,   1, 
                    Offset (0x2F), 
                        ,   4, 
                    GPEE,   1
                }

                OperationRegion (REGS, PCI_Config, 0x40, 0x10)
                Field (REGS, DWordAcc, Lock, Preserve)
                {
                    PMBA,   16, 
                    Offset (0x08), 
                    GPBA,   16
                }

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

                Device (SIO)
                {
                    Name (_HID, EisaId ("PNP0A05"))
                    Mutex (W627, 0x00)
                    OperationRegion (SIBP, SystemIO, 0x2E, 0x02)
                    Field (SIBP, ByteAcc, NoLock, Preserve)
                    {
                        BPIO,   8
                    }

                    OperationRegion (SIIO, SystemIO, 0x2E, 0x02)
                    Field (SIIO, ByteAcc, NoLock, Preserve)
                    {
                        INDX,   8, 
                        DATA,   8
                    }

                    IndexField (INDX, DATA, ByteAcc, NoLock, Preserve)
                    {
                        Offset (0x07), 
                        LDN,    8, 
                        Offset (0x22), 
                        POW,    8, 
                        Offset (0x30), 
                        ACT,    1, 
                        Offset (0x60), 
                        IOBH,   8, 
                        IOBL,   8, 
                        IO2H,   8, 
                        IO2L,   8, 
                        Offset (0x70), 
                        INT,    4, 
                        Offset (0x74), 
                        DMAS,   3, 
                        Offset (0xE0), 
                        Z009,   8, 
                        Offset (0xE4), 
                        Z00A,   8, 
                        Offset (0xF0), 
                        MODE,   3, 
                        Offset (0xF1), 
                            ,   3, 
                        IRMD,   3, 
                        Offset (0xF3), 
                            ,   6, 
                        SLED,   2, 
                        Offset (0xF5), 
                            ,   6, 
                        PLED,   2
                    }

                    Method (CFG, 1, NotSerialized)
                    {
                        Store (0x87, BPIO)
                        Store (0x87, BPIO)
                        Store (Arg0, LDN)
                    }

                    Method (XCFG, 0, NotSerialized)
                    {
                        Store (0xAA, BPIO)
                    }

                    Method (STA, 1, NotSerialized)
                    {
                        Acquire (W627, 0x5000)
                        CFG (Arg0)
                        Store (0x00, Local1)
                        If (ACT)
                        {
                            Store (0x0F, Local1)
                        }
                        Else
                        {
                            If (LOr (IOBH, IOBL))
                            {
                                Store (0x0D, Local1)
                            }
                        }

                        XCFG ()
                        Release (W627)
                        Return (Local1)
                    }

                    Method (DIS, 1, NotSerialized)
                    {
                        Acquire (W627, 0x1388)
                        CFG (Arg0)
                        Store (0x00, ACT)
                        XCFG ()
                        Release (W627)
                        Return (0x00)
                    }

                    Method (PS0, 1, NotSerialized)
                    {
                        Acquire (W627, 0x1388)
                        CFG (Arg0)
                        Store (0x01, ACT)
                        XCFG ()
                        Release (W627)
                        Return (0x00)
                    }

                    Method (PS3, 1, NotSerialized)
                    {
                        Acquire (W627, 0x1388)
                        CFG (Arg0)
                        Store (0x00, ACT)
                        XCFG ()
                        Release (W627)
                        Return (0x00)
                    }

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

                    Device (MSE0)
                    {
                        Name (_HID, EisaId ("PNP0F13"))
                        Name (_CRS, ResourceTemplate ()
                        {
                            IRQ (Edge, ActiveHigh, Exclusive) {12}
                        })
                        Name (_PRW, Package (0x02)
                        {
                            0x1D, 
                            0x01
                        })
                    }

                    Device (COM1)
                    {
                        Name (_HID, EisaId ("PNP0501"))
                        Name (_UID, 0x01)
                        Method (_STA, 0, NotSerialized)
                        {
                            Store (STA (0x02), Local1)
                            Return (Local1)
                        }

                        Method (_DIS, 0, NotSerialized)
                        {
                            DIS (0x02)
                        }

                        Method (_CRS, 0, NotSerialized)
                        {
                            Name (RSRC, ResourceTemplate ()
                            {
                                IO (Decode16, 0x0000, 0x0000, 0x08, 0x08)
                                IRQNoFlags () {}
                            })
                            CreateByteField (RSRC, 0x02, IO1)
                            CreateByteField (RSRC, 0x03, IO2)
                            CreateByteField (RSRC, 0x04, IO3)
                            CreateByteField (RSRC, 0x05, IO4)
                            CreateWordField (RSRC, 0x09, IRQV)
                            Acquire (W627, 0x1388)
                            CFG (0x02)
                            If (ACT)
                            {
                                Store (IOBL, IO1)
                                Store (IOBH, IO2)
                                Store (IOBL, IO3)
                                Store (IOBH, IO4)
                                Store (0x01, Local0)
                                ShiftLeft (Local0, INT, IRQV)
                            }

                            XCFG ()
                            Release (W627)
                            Return (RSRC)
                        }

                        Name (_PRS, ResourceTemplate ()
                        {
                            StartDependentFn (0x00, 0x00)
                            {
                                IO (Decode16, 0x03F8, 0x03F8, 0x01, 0x08)
                                IRQ (Edge, ActiveHigh, Exclusive) {4}
                            }
                            StartDependentFnNoPri ()
                            {
                                IO (Decode16, 0x02F8, 0x02F8, 0x01, 0x08)
                                IRQ (Edge, ActiveHigh, Exclusive) {3}
                            }
                            StartDependentFnNoPri ()
                            {
                                IO (Decode16, 0x03E8, 0x03E8, 0x01, 0x08)
                                IRQ (Edge, ActiveHigh, Exclusive) {4}
                            }
                            StartDependentFnNoPri ()
                            {
                                IO (Decode16, 0x02E8, 0x02E8, 0x01, 0x08)
                                IRQ (Edge, ActiveHigh, Exclusive) {3}
                            }
                            StartDependentFn (0x02, 0x02)
                            {
                                IO (Decode16, 0x03F8, 0x03F8, 0x01, 0x08)
                                IRQ (Edge, ActiveHigh, Exclusive) {3}
                            }
                            StartDependentFn (0x02, 0x02)
                            {
                                IO (Decode16, 0x02F8, 0x02F8, 0x01, 0x08)
                                IRQ (Edge, ActiveHigh, Exclusive) {4}
                            }
                            StartDependentFn (0x02, 0x02)
                            {
                                IO (Decode16, 0x03E8, 0x03E8, 0x01, 0x08)
                                IRQ (Edge, ActiveHigh, Exclusive) {3}
                            }
                            StartDependentFn (0x02, 0x02)
                            {
                                IO (Decode16, 0x02E8, 0x02E8, 0x01, 0x08)
                                IRQ (Edge, ActiveHigh, Exclusive) {4}
                            }
                            EndDependentFn ()
                        })
                        Method (_SRS, 1, NotSerialized)
                        {
                            CreateByteField (Arg0, 0x02, IO1)
                            CreateByteField (Arg0, 0x03, IO2)
                            CreateWordField (Arg0, 0x09, IRQV)
                            Acquire (W627, 0x1388)
                            CFG (0x02)
                            Store (IO1, IOBL)
                            Store (IO2, IOBH)
                            FindSetRightBit (IRQV, Local0)
                            Subtract (Local0, 0x01, INT)
                            Store (0x01, ACT)
                            XCFG ()
                            Release (W627)
                        }

                        Method (_PS0, 0, NotSerialized)
                        {
                            PS0 (0x02)
                        }

                        Method (_PS3, 0, NotSerialized)
                        {
                            PS3 (0x02)
                        }
                    }

                    Device (COM2)
                    {
                        Method (_HID, 0, NotSerialized)
                        {
                            Acquire (W627, 0x1388)
                            CFG (0x03)
                            If (LAnd (IRMD, 0x38))
                            {
                                Store (0x1005D041, Local1)
                            }
                            Else
                            {
                                Store (0x0105D041, Local1)
                            }

                            XCFG ()
                            Release (W627)
                            Return (Local1)
                        }

                        Name (_UID, 0x02)
                        Method (_STA, 0, NotSerialized)
                        {
                            Store (STA (0x03), Local1)
                            Return (Local1)
                        }

                        Method (_DIS, 0, NotSerialized)
                        {
                            DIS (0x03)
                        }

                        Method (_CRS, 0, NotSerialized)
                        {
                            Name (RSRC, ResourceTemplate ()
                            {
                                IO (Decode16, 0x0000, 0x0000, 0x08, 0x08)
                                IRQNoFlags () {}
                            })
                            CreateByteField (RSRC, 0x02, IO1)
                            CreateByteField (RSRC, 0x03, IO2)
                            CreateByteField (RSRC, 0x04, IO3)
                            CreateByteField (RSRC, 0x05, IO4)
                            CreateWordField (RSRC, 0x09, IRQV)
                            Acquire (W627, 0x1388)
                            CFG (0x03)
                            If (ACT)
                            {
                                Store (IOBL, IO1)
                                Store (IOBH, IO2)
                                Store (IOBL, IO3)
                                Store (IOBH, IO4)
                                Store (0x01, Local0)
                                ShiftLeft (Local0, INT, IRQV)
                            }

                            XCFG ()
                            Release (W627)
                            Return (RSRC)
                        }

                        Name (_PRS, ResourceTemplate ()
                        {
                            StartDependentFnNoPri ()
                            {
                                IO (Decode16, 0x03F8, 0x03F8, 0x01, 0x08)
                                IRQ (Edge, ActiveHigh, Exclusive) {4}
                            }
                            StartDependentFn (0x00, 0x00)
                            {
                                IO (Decode16, 0x02F8, 0x02F8, 0x01, 0x08)
                                IRQ (Edge, ActiveHigh, Exclusive) {3}
                            }
                            StartDependentFnNoPri ()
                            {
                                IO (Decode16, 0x03E8, 0x03E8, 0x01, 0x08)
                                IRQ (Edge, ActiveHigh, Exclusive) {4}
                            }
                            StartDependentFnNoPri ()
                            {
                                IO (Decode16, 0x02E8, 0x02E8, 0x01, 0x08)
                                IRQ (Edge, ActiveHigh, Exclusive) {3}
                            }
                            StartDependentFn (0x02, 0x02)
                            {
                                IO (Decode16, 0x03F8, 0x03F8, 0x01, 0x08)
                                IRQ (Edge, ActiveHigh, Exclusive) {3}
                            }
                            StartDependentFn (0x02, 0x02)
                            {
                                IO (Decode16, 0x02F8, 0x02F8, 0x01, 0x08)
                                IRQ (Edge, ActiveHigh, Exclusive) {4}
                            }
                            StartDependentFn (0x02, 0x02)
                            {
                                IO (Decode16, 0x03E8, 0x03E8, 0x01, 0x08)
                                IRQ (Edge, ActiveHigh, Exclusive) {3}
                            }
                            StartDependentFn (0x02, 0x02)
                            {
                                IO (Decode16, 0x02E8, 0x02E8, 0x01, 0x08)
                                IRQ (Edge, ActiveHigh, Exclusive) {4}
                            }
                            EndDependentFn ()
                        })
                        Method (_SRS, 1, NotSerialized)
                        {
                            CreateByteField (Arg0, 0x02, IO1)
                            CreateByteField (Arg0, 0x03, IO2)
                            CreateWordField (Arg0, 0x09, IRQV)
                            Acquire (W627, 0x1388)
                            CFG (0x03)
                            Store (IO1, IOBL)
                            Store (IO2, IOBH)
                            FindSetRightBit (IRQV, Local0)
                            Subtract (Local0, 0x01, INT)
                            Store (0x01, ACT)
                            XCFG ()
                            Release (W627)
                        }

                        Method (_PS0, 0, NotSerialized)
                        {
                            PS0 (0x03)
                        }

                        Method (_PS3, 0, NotSerialized)
                        {
                            PS3 (0x03)
                        }
                    }

                    Device (FDC)
                    {
                        Name (_HID, EisaId ("PNP0700"))
                        Name (_UID, 0x01)
                        Method (_STA, 0, NotSerialized)
                        {
                            Store (STA (0x00), Local1)
                            Return (Local1)
                        }

                        Method (_DIS, 0, NotSerialized)
                        {
                            DIS (0x00)
                        }

                        Method (_CRS, 0, NotSerialized)
                        {
                            Name (RSRC, ResourceTemplate ()
                            {
                                IO (Decode16, 0x0000, 0x0000, 0x01, 0x06)
                                IO (Decode16, 0x0000, 0x0000, 0x01, 0x01)
                                IRQNoFlags () {}
                                DMA (Compatibility, NotBusMaster, Transfer8) {}
                            })
                            Acquire (W627, 0x1388)
                            CFG (0x00)
                            If (ACT)
                            {
                                CreateByteField (RSRC, 0x02, IO1)
                                CreateByteField (RSRC, 0x03, IO2)
                                CreateByteField (RSRC, 0x04, IO3)
                                CreateByteField (RSRC, 0x05, IO4)
                                CreateByteField (RSRC, 0x0A, IO5)
                                CreateByteField (RSRC, 0x0B, IO6)
                                CreateByteField (RSRC, 0x0C, IO7)
                                CreateByteField (RSRC, 0x0D, IO8)
                                CreateWordField (RSRC, 0x11, IRQV)
                                CreateByteField (RSRC, 0x14, DMAV)
                                Store (IOBL, IO1)
                                Store (IOBH, IO2)
                                Store (IOBL, IO3)
                                Store (IOBH, IO4)
                                Add (IOBL, 0x07, IO5)
                                Store (IOBH, IO6)
                                Add (IOBL, 0x07, IO7)
                                Store (IOBH, IO8)
                                Store (0x01, Local0)
                                ShiftLeft (Local0, INT, IRQV)
                                Store (0x01, Local0)
                                ShiftLeft (Local0, DMAS, DMAV)
                            }

                            XCFG ()
                            Release (W627)
                            Return (RSRC)
                        }

                        Name (_PRS, ResourceTemplate ()
                        {
                            StartDependentFn (0x00, 0x00)
                            {
                                IO (Decode16, 0x03F0, 0x03F0, 0x01, 0x06)
                                IO (Decode16, 0x03F7, 0x03F7, 0x01, 0x01)
                                IRQ (Edge, ActiveHigh, Exclusive) {6}
                                DMA (Compatibility, NotBusMaster, Transfer8) {2}
                            }
                            StartDependentFn (0x00, 0x00)
                            {
                                IO (Decode16, 0x0370, 0x0370, 0x01, 0x06)
                                IO (Decode16, 0x0377, 0x0377, 0x01, 0x01)
                                IRQ (Edge, ActiveHigh, Exclusive) {6}
                                DMA (Compatibility, NotBusMaster, Transfer8) {2}
                            }
                            EndDependentFn ()
                        })
                        Method (_SRS, 1, NotSerialized)
                        {
                            CreateByteField (Arg0, 0x02, IO1)
                            CreateByteField (Arg0, 0x03, IO2)
                            CreateWordField (Arg0, 0x11, IRQV)
                            CreateByteField (Arg0, 0x14, DMAV)
                            Acquire (W627, 0x1388)
                            CFG (0x00)
                            Store (IO1, IOBL)
                            Store (IO2, IOBH)
                            FindSetRightBit (IRQV, Local0)
                            Subtract (Local0, 0x01, INT)
                            FindSetRightBit (DMAV, Local0)
                            Subtract (Local0, 0x01, DMAS)
                            Store (0x01, ACT)
                            XCFG ()
                            Release (W627)
                        }

                        Method (_PS0, 0, NotSerialized)
                        {
                            PS0 (0x00)
                        }

                        Method (_PS3, 0, NotSerialized)
                        {
                            PS3 (0x00)
                        }
                    }

                    Device (PRT)
                    {
                        Method (_HID, 0, NotSerialized)
                        {
                            Acquire (W627, 0x1388)
                            CFG (0x01)
                            If (LEqual (MODE, 0x02))
                            {
                                Store (0x0104D041, Local1)
                            }
                            Else
                            {
                                Store (0x0004D041, Local1)
                            }

                            XCFG ()
                            Release (W627)
                            Return (Local1)
                        }

                        Name (_UID, 0x02)
                        Method (_STA, 0, NotSerialized)
                        {
                            Store (STA (0x01), Local1)
                            Return (Local1)
                        }

                        Method (_DIS, 0, NotSerialized)
                        {
                            DIS (0x01)
                        }

                        Method (_CRS, 0, NotSerialized)
                        {
                            Acquire (W627, 0x1388)
                            CFG (0x01)
                            Name (CRSA, ResourceTemplate ()
                            {
                                IO (Decode16, 0x0000, 0x0000, 0x01, 0x08)
                                IRQNoFlags () {}
                            })
                            CreateByteField (CRSA, 0x02, IOA1)
                            CreateByteField (CRSA, 0x03, IOA2)
                            CreateByteField (CRSA, 0x04, IOA3)
                            CreateByteField (CRSA, 0x05, IOA4)
                            CreateByteField (CRSA, 0x06, ALA1)
                            CreateByteField (CRSA, 0x07, LNA1)
                            CreateWordField (CRSA, 0x09, IRQA)
                            Name (CRSB, ResourceTemplate ()
                            {
                                IO (Decode16, 0x0000, 0x0000, 0x01, 0x08)
                                IO (Decode16, 0x0000, 0x0000, 0x01, 0x08)
                                IRQNoFlags () {}
                                DMA (Compatibility, NotBusMaster, Transfer16) {}
                            })
                            CreateByteField (CRSB, 0x02, IOB1)
                            CreateByteField (CRSB, 0x03, IOB2)
                            CreateByteField (CRSB, 0x04, IOB3)
                            CreateByteField (CRSB, 0x05, IOB4)
                            CreateByteField (CRSB, 0x06, ALB1)
                            CreateByteField (CRSB, 0x07, LNB1)
                            CreateByteField (CRSB, 0x0A, IOB5)
                            CreateByteField (CRSB, 0x0B, IOB6)
                            CreateByteField (CRSB, 0x0C, IOB7)
                            CreateByteField (CRSB, 0x0D, IOB8)
                            CreateByteField (CRSB, 0x0E, ALB2)
                            CreateByteField (CRSB, 0x0F, LNB2)
                            CreateWordField (CRSB, 0x11, IRQB)
                            CreateWordField (CRSB, 0x14, DMAV)
                            If (ACT)
                            {
                                If (LEqual (MODE, 0x02))
                                {
                                    Store (IOBL, IOB1)
                                    Store (IOBH, IOB2)
                                    Store (IOBL, IOB3)
                                    Store (IOBH, IOB4)
                                    Store (IOBL, IOB5)
                                    Add (IOBH, 0x04, IOB6)
                                    Store (IOBL, IOB7)
                                    Add (IOBH, 0x04, IOB8)
                                    If (LEqual (IOBL, 0xBC))
                                    {
                                        Store (0x01, ALB1)
                                        Store (0x04, LNB1)
                                        Store (0x01, ALB2)
                                        Store (0x04, LNB2)
                                    }

                                    Store (0x01, Local0)
                                    ShiftLeft (Local0, INT, IRQB)
                                    Store (0x01, Local0)
                                    ShiftLeft (Local0, DMAS, DMAV)
                                    Return (CRSB)
                                }
                                Else
                                {
                                    Store (IOBL, IOA1)
                                    Store (IOBH, IOA2)
                                    Store (IOBL, IOA3)
                                    Store (IOBH, IOA4)
                                    Store (0x01, Local0)
                                    ShiftLeft (Local0, INT, IRQA)
                                    If (LEqual (IOBL, 0xBC))
                                    {
                                        Store (0x01, ALA1)
                                        Store (0x04, LNA1)
                                    }

                                    Return (CRSA)
                                }
                            }
                            Else
                            {
                                If (LEqual (MODE, 0x02))
                                {
                                    Return (CRSB)
                                }
                                Else
                                {
                                    Return (CRSA)
                                }
                            }

                            XCFG ()
                            Release (W627)
                        }

                        Name (PRSA, ResourceTemplate ()
                        {
                            StartDependentFnNoPri ()
                            {
                                IO (Decode16, 0x0378, 0x0378, 0x01, 0x08)
                                IRQ (Edge, ActiveHigh, Exclusive) {7}
                            }
                            StartDependentFnNoPri ()
                            {
                                IO (Decode16, 0x0378, 0x0378, 0x01, 0x08)
                                IRQ (Edge, ActiveHigh, Exclusive) {5}
                            }
                            StartDependentFnNoPri ()
                            {
                                IO (Decode16, 0x0278, 0x0278, 0x01, 0x08)
                                IRQ (Edge, ActiveHigh, Exclusive) {7}
                            }
                            StartDependentFnNoPri ()
                            {
                                IO (Decode16, 0x0278, 0x0278, 0x01, 0x08)
                                IRQ (Edge, ActiveHigh, Exclusive) {5}
                            }
                            StartDependentFnNoPri ()
                            {
                                IO (Decode16, 0x03BC, 0x03BC, 0x01, 0x04)
                                IRQ (Edge, ActiveHigh, Exclusive) {7}
                            }
                            StartDependentFnNoPri ()
                            {
                                IO (Decode16, 0x03BC, 0x03BC, 0x01, 0x04)
                                IRQ (Edge, ActiveHigh, Exclusive) {5}
                            }
                            EndDependentFn ()
                        })
                        Name (PRSB, ResourceTemplate ()
                        {
                            StartDependentFnNoPri ()
                            {
                                IO (Decode16, 0x0378, 0x0378, 0x01, 0x08)
                                IO (Decode16, 0x0778, 0x0778, 0x01, 0x08)
                                IRQ (Edge, ActiveHigh, Exclusive) {7}
                                DMA (Compatibility, NotBusMaster, Transfer16) {0,1,3}
                            }
                            StartDependentFnNoPri ()
                            {
                                IO (Decode16, 0x0378, 0x0378, 0x01, 0x08)
                                IO (Decode16, 0x0778, 0x0778, 0x01, 0x08)
                                IRQ (Edge, ActiveHigh, Exclusive) {5}
                                DMA (Compatibility, NotBusMaster, Transfer16) {0,1,3}
                            }
                            StartDependentFnNoPri ()
                            {
                                IO (Decode16, 0x0278, 0x0278, 0x01, 0x08)
                                IO (Decode16, 0x0678, 0x0678, 0x01, 0x08)
                                IRQ (Edge, ActiveHigh, Exclusive) {7}
                                DMA (Compatibility, NotBusMaster, Transfer16) {0,1,3}
                            }
                            StartDependentFnNoPri ()
                            {
                                IO (Decode16, 0x0278, 0x0278, 0x01, 0x08)
                                IO (Decode16, 0x0678, 0x0678, 0x01, 0x08)
                                IRQ (Edge, ActiveHigh, Exclusive) {5}
                                DMA (Compatibility, NotBusMaster, Transfer16) {0,1,3}
                            }
                            StartDependentFnNoPri ()
                            {
                                IO (Decode16, 0x03BC, 0x03BC, 0x01, 0x04)
                                IO (Decode16, 0x07BC, 0x07BC, 0x01, 0x04)
                                IRQ (Edge, ActiveHigh, Exclusive) {7}
                                DMA (Compatibility, NotBusMaster, Transfer16) {0,1,3}
                            }
                            StartDependentFnNoPri ()
                            {
                                IO (Decode16, 0x03BC, 0x03BC, 0x01, 0x04)
                                IO (Decode16, 0x07BC, 0x07BC, 0x01, 0x04)
                                IRQ (Edge, ActiveHigh, Exclusive) {5}
                                DMA (Compatibility, NotBusMaster, Transfer16) {0,1,3}
                            }
                            EndDependentFn ()
                        })
                        Method (_PRS, 0, NotSerialized)
                        {
                            Acquire (W627, 0x1388)
                            CFG (0x01)
                            If (LEqual (MODE, 0x02))
                            {
                                Store (PRSB, Local0)
                            }
                            Else
                            {
                                Store (PRSA, Local0)
                            }

                            XCFG ()
                            Release (W627)
                            Return (Local0)
                        }

                        Method (_SRS, 1, NotSerialized)
                        {
                            Acquire (W627, 0x1388)
                            CFG (0x01)
                            If (LEqual (MODE, 0x02))
                            {
                                CreateByteField (Arg0, 0x02, IOB1)
                                CreateByteField (Arg0, 0x03, IOB2)
                                CreateByteField (Arg0, 0x04, IOB3)
                                CreateByteField (Arg0, 0x05, IOB4)
                                CreateByteField (Arg0, 0x06, ALB1)
                                CreateByteField (Arg0, 0x07, LNB1)
                                CreateByteField (Arg0, 0x0A, IOB5)
                                CreateByteField (Arg0, 0x0B, IOB6)
                                CreateByteField (Arg0, 0x0C, IOB7)
                                CreateByteField (Arg0, 0x0D, IOB8)
                                CreateByteField (Arg0, 0x0E, ALB2)
                                CreateByteField (Arg0, 0x0F, LNB2)
                                CreateWordField (Arg0, 0x11, IRQB)
                                CreateWordField (Arg0, 0x14, DMAV)
                                Store (IOB1, IOBL)
                                Store (IOB2, IOBH)
                                FindSetLeftBit (IRQB, Local0)
                                Subtract (Local0, 0x01, INT)
                                FindSetLeftBit (DMAV, Local0)
                                Subtract (Local0, 0x01, DMAS)
                            }
                            Else
                            {
                                CreateByteField (Arg0, 0x02, IOA1)
                                CreateByteField (Arg0, 0x03, IOA2)
                                CreateByteField (Arg0, 0x04, IOA3)
                                CreateByteField (Arg0, 0x05, IOA4)
                                CreateByteField (Arg0, 0x06, ALA1)
                                CreateByteField (Arg0, 0x07, LNA1)
                                CreateWordField (Arg0, 0x09, IRQA)
                                Store (IOA1, IOBL)
                                Store (IOA2, IOBH)
                                FindSetLeftBit (IRQA, Local0)
                                Subtract (Local0, 0x01, INT)
                            }

                            Store (0x01, ACT)
                            XCFG ()
                            Release (W627)
                        }

                        Method (_PS0, 0, NotSerialized)
                        {
                            PS0 (0x01)
                        }

                        Method (_PS3, 0, NotSerialized)
                        {
                            PS3 (0x01)
                        }
                    }

                    Method (ENWK, 0, NotSerialized)
                    {
                        Acquire (W627, 0x1388)
                        CFG (0x0A)
                        Store (0x00, ACT)
                        Store (0x01, ACT)
                        Store (0xF3, INDX)
                        Store (0x3F, DATA)
                        Store (0xF6, INDX)
                        Store (0x30, DATA)
                        Store (0xF9, INDX)
                        Store (0x05, DATA)
                        XCFG ()
                        Release (W627)
                    }

                    Method (DSWK, 0, NotSerialized)
                    {
                        Acquire (W627, 0x1388)
                        CFG (0x0A)
                        Store (0x00, ACT)
                        Store (0xF6, INDX)
                        Store (0x00, DATA)
                        Store (0xF9, INDX)
                        Store (0x00, DATA)
                        Store (0xF3, INDX)
                        Store (0x3F, DATA)
                        XCFG ()
                        Release (W627)
                    }

                    Method (CLED, 1, NotSerialized)
                    {
                        Acquire (W627, 0x1388)
                        CFG (0x09)
                        Store (Arg0, SLED)
                        XCFG ()
                        Release (W627)
                    }
                }
            }

            Name (NATA, Package (0x02)
            {
                0x001F0001, 
                0x001F0002
            })
            Method (GETP, 1, NotSerialized)
            {
                Noop
                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 (GETD, 4, NotSerialized)
            {
                Noop
                If (Arg0)
                {
                    If (Arg1)
                    {
                        Return (0x14)
                    }

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

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

                Return (0xFFFFFFFF)
            }

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

            Method (GETF, 3, NotSerialized)
            {
                Noop
                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, NotSerialized)
            {
                Noop
                If (LNot (LLess (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 (SETD, 1, NotSerialized)
            {
                Noop
                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, NotSerialized)
            {
                Noop
                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 (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), 
                    SDMA,   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)
                    {
                        Noop
                        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 (GETD (And (SDMA, 0x01), And (ICR3, 0x01), And (ICR0, 0x01), SDT0), 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 (GETD (And (SDMA, 0x02), And (ICR3, 0x02), And (ICR0, 0x02), SDT1), DMA1)
                        If (LEqual (DMA1, 0xFFFFFFFF))
                        {
                            Store (PIO1, DMA1)
                        }

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

                    Method (_STM, 3, NotSerialized)
                    {
                        Noop
                        CreateDWordField (Arg0, 0x00, PIO0)
                        CreateDWordField (Arg0, 0x04, DMA0)
                        CreateDWordField (Arg0, 0x08, PIO1)
                        CreateDWordField (Arg0, 0x0C, DMA1)
                        CreateDWordField (Arg0, 0x10, FLAG)
                        Store (0x04, ICR2)
                        If (LEqual (SizeOf (Arg1), 0x0200))
                        {
                            And (PRIT, 0x4CF0, PRIT)
                            And (SDMA, 0x0E, SDMA)
                            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)
                            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 (SDMA, 0x01, SDMA)
                                Store (SETD (DMA0), SDT0)
                                If (And (W880, 0x20))
                                {
                                    Or (ICR1, 0x01, ICR1)
                                    Or (ICR5, 0x01, ICR5)
                                }

                                If (And (W880, 0x10))
                                {
                                    Or (ICR1, 0x01, ICR1)
                                }

                                If (LLess (DMA0, 0x1E))
                                {
                                    Or (ICR3, 0x01, ICR3)
                                }

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

                        If (LEqual (SizeOf (Arg2), 0x0200))
                        {
                            And (PRIT, 0x3F0F, PRIT)
                            Store (0x00, PSIT)
                            And (SDMA, 0x0D, SDMA)
                            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)
                            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 (SDMA, 0x02, SDMA)
                                Store (SETD (DMA1), SDT1)
                                If (And (W881, 0x20))
                                {
                                    Or (ICR1, 0x02, ICR1)
                                    Or (ICR5, 0x02, ICR5)
                                }

                                If (And (W881, 0x10))
                                {
                                    Or (ICR1, 0x02, ICR1)
                                }

                                If (LLess (DMA0, 0x1E))
                                {
                                    Or (ICR3, 0x02, ICR3)
                                }

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

                    Method (_PS0, 0, NotSerialized)
                    {
                        Noop
                    }

                    Method (_PS3, 0, NotSerialized)
                    {
                        Noop
                    }

                    Device (P_D0)
                    {
                        Name (_ADR, 0x00)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Noop
                            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 (SDMA, 0x01))
                            {
                                Store (Or (SDT0, 0x40), DMD0)
                                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)
                        }
                    }

                    Device (P_D1)
                    {
                        Name (_ADR, 0x01)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Noop
                            Name (PIB1, Buffer (0x0E)
                            {
                                0x03, 0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF, 0x03, 
                                0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF
                            })
                            CreateByteField (PIB1, 0x01, PMD1)
                            CreateByteField (PIB1, 0x08, DMD1)
                            If (And (PRIT, 0x20))
                            {
                                If (LEqual (And (PRIT, 0x90), 0x80))
                                {
                                    Store (0x08, PMD1)
                                }
                                Else
                                {
                                    Add (And (PSIT, 0x03), ShiftRight (And (PSIT, 0x0C), 0x02), Local0)
                                    If (LEqual (0x05, Local0))
                                    {
                                        Store (0x0C, PMD1)
                                    }
                                    Else
                                    {
                                        If (LEqual (0x03, Local0))
                                        {
                                            Store (0x0B, PMD1)
                                        }
                                        Else
                                        {
                                            Store (0x0A, PMD1)
                                        }
                                    }
                                }
                            }
                            Else
                            {
                                Store (0x01, PMD1)
                            }

                            If (And (SDMA, 0x02))
                            {
                                Store (Or (SDT1, 0x40), DMD1)
                                If (And (ICR0, 0x02))
                                {
                                    Add (DMD1, 0x02, DMD1)
                                }

                                If (And (ICR3, 0x02))
                                {
                                    Store (0x45, DMD1)
                                }
                            }
                            Else
                            {
                                Or (Subtract (And (PMD1, 0x07), 0x02), 0x20, DMD1)
                            }

                            Return (PIB1)
                        }
                    }
                }

                Device (SECD)
                {
                    Name (_ADR, 0x01)
                    Method (_GTM, 0, NotSerialized)
                    {
                        Noop
                        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 (GETD (And (SDMA, 0x04), And (ICR3, 0x04), And (ICR0, 0x04), SDT2), 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 (GETD (And (SDMA, 0x08), And (ICR3, 0x08), And (ICR0, 0x08), SDT3), DMA1)
                        If (LEqual (DMA1, 0xFFFFFFFF))
                        {
                            Store (PIO1, DMA1)
                        }

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

                    Method (_STM, 3, NotSerialized)
                    {
                        Noop
                        CreateDWordField (Arg0, 0x00, PIO0)
                        CreateDWordField (Arg0, 0x04, DMA0)
                        CreateDWordField (Arg0, 0x08, PIO1)
                        CreateDWordField (Arg0, 0x0C, DMA1)
                        CreateDWordField (Arg0, 0x10, FLAG)
                        Store (0x04, ICR2)
                        If (LEqual (SizeOf (Arg1), 0x0200))
                        {
                            And (SECT, 0x4CF0, SECT)
                            And (SDMA, 0x0B, SDMA)
                            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)
                            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 (SDMA, 0x04, SDMA)
                                Store (SETD (DMA0), SDT2)
                                If (And (W880, 0x20))
                                {
                                    Or (ICR1, 0x04, ICR1)
                                    Or (ICR5, 0x04, ICR5)
                                }

                                If (And (W880, 0x10))
                                {
                                    Or (ICR1, 0x04, ICR1)
                                }

                                If (LLess (DMA0, 0x1E))
                                {
                                    Or (ICR3, 0x04, ICR3)
                                }

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

                        If (LEqual (SizeOf (Arg2), 0x0200))
                        {
                            And (SECT, 0x3F0F, SECT)
                            Store (0x00, SSIT)
                            And (SDMA, 0x07, SDMA)
                            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)
                            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 (SDMA, 0x08, SDMA)
                                Store (SETD (DMA1), SDT3)
                                If (And (W881, 0x20))
                                {
                                    Or (ICR1, 0x08, ICR1)
                                    Or (ICR5, 0x08, ICR5)
                                }

                                If (And (W881, 0x10))
                                {
                                    Or (ICR1, 0x08, ICR1)
                                }

                                If (LLess (DMA0, 0x1E))
                                {
                                    Or (ICR3, 0x08, ICR3)
                                }

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

                    Method (_PS0, 0, NotSerialized)
                    {
                        Noop
                    }

                    Method (_PS3, 0, NotSerialized)
                    {
                        Noop
                    }

                    Device (S_D0)
                    {
                        Name (_ADR, 0x00)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Noop
                            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 (SDMA, 0x04))
                            {
                                Store (Or (SDT2, 0x40), DMD0)
                                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)
                        }
                    }

                    Device (S_D1)
                    {
                        Name (_ADR, 0x01)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Noop
                            Name (SIB1, Buffer (0x0E)
                            {
                                0x03, 0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF, 0x03, 
                                0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF
                            })
                            CreateByteField (SIB1, 0x01, PMD1)
                            CreateByteField (SIB1, 0x08, DMD1)
                            If (And (SECT, 0x20))
                            {
                                If (LEqual (And (SECT, 0x90), 0x80))
                                {
                                    Store (0x08, PMD1)
                                }
                                Else
                                {
                                    Add (And (SSIT, 0x03), ShiftRight (And (SSIT, 0x0C), 0x02), Local0)
                                    If (LEqual (0x05, Local0))
                                    {
                                        Store (0x0C, PMD1)
                                    }
                                    Else
                                    {
                                        If (LEqual (0x03, Local0))
                                        {
                                            Store (0x0B, PMD1)
                                        }
                                        Else
                                        {
                                            Store (0x0A, PMD1)
                                        }
                                    }
                                }
                            }
                            Else
                            {
                                Store (0x01, PMD1)
                            }

                            If (And (SDMA, 0x08))
                            {
                                Store (Or (SDT3, 0x40), DMD1)
                                If (And (ICR0, 0x08))
                                {
                                    Add (DMD1, 0x02, DMD1)
                                }

                                If (And (ICR3, 0x08))
                                {
                                    Store (0x45, DMD1)
                                }
                            }
                            Else
                            {
                                Or (Subtract (And (PMD1, 0x07), 0x02), 0x20, DMD1)
                            }

                            Return (SIB1)
                        }
                    }
                }
            }

            Device (IDE1)
            {
                Name (_ADR, 0x001F0002)
                OperationRegion (IDE1, PCI_Config, 0x90, 0x03)
                Field (IDE1, DWordAcc, NoLock, Preserve)
                {
                    MAP,    8, 
                    Offset (0x02), 
                    PCS,    8
                }

                OperationRegion (IDEC, PCI_Config, 0x40, 0x18)
                Field (IDEC, DWordAcc, NoLock, Preserve)
                {
                    PRIT,   16, 
                    SECT,   16, 
                    PSIT,   4, 
                    SSIT,   4, 
                    Offset (0x08), 
                    SDMA,   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
                }

                Method (CTYP, 1, NotSerialized)
                {
                    Store (Zero, Local0)
                    If (Arg0)
                    {
                        If (LAnd (LGreater (MAP, 0x01), LLess (MAP, 0x06)))
                        {
                            Store (0x01, Local0)
                        }
                        Else
                        {
                            If (LEqual (MAP, Zero))
                            {
                                Store (0x03, Local0)
                            }

                            If (LEqual (MAP, One))
                            {
                                Store (0x04, Local0)
                            }
                        }
                    }
                    Else
                    {
                        If (LGreater (MAP, 0x05))
                        {
                            Store (0x02, Local0)
                        }
                        Else
                        {
                            If (LEqual (MAP, Zero))
                            {
                                Store (0x05, Local0)
                            }

                            If (LEqual (MAP, One))
                            {
                                Store (0x06, Local0)
                            }
                        }
                    }

                    Return (Local0)
                }

                Device (PRID)
                {
                    Name (_ADR, 0x00)
                    Method (_GTM, 0, NotSerialized)
                    {
                        Noop
                        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 (GETD (And (SDMA, 0x01), And (ICR3, 0x01), And (ICR0, 0x01), SDT0), 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 (GETD (And (SDMA, 0x02), And (ICR3, 0x02), And (ICR0, 0x02), SDT1), DMA1)
                        If (LEqual (DMA1, 0xFFFFFFFF))
                        {
                            Store (PIO1, DMA1)
                        }

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

                    Method (_STM, 3, NotSerialized)
                    {
                        Noop
                        CreateDWordField (Arg0, 0x00, PIO0)
                        CreateDWordField (Arg0, 0x04, DMA0)
                        CreateDWordField (Arg0, 0x08, PIO1)
                        CreateDWordField (Arg0, 0x0C, DMA1)
                        CreateDWordField (Arg0, 0x10, FLAG)
                        Store (0x04, ICR2)
                        If (LEqual (SizeOf (Arg1), 0x0200))
                        {
                            And (PRIT, 0x4CF0, PRIT)
                            And (SDMA, 0x0E, SDMA)
                            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)
                            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 (SDMA, 0x01, SDMA)
                                Store (SETD (DMA0), SDT0)
                                If (And (W880, 0x20))
                                {
                                    Or (ICR1, 0x01, ICR1)
                                    Or (ICR5, 0x01, ICR5)
                                }

                                If (And (W880, 0x10))
                                {
                                    Or (ICR1, 0x01, ICR1)
                                }

                                If (LLess (DMA0, 0x1E))
                                {
                                    Or (ICR3, 0x01, ICR3)
                                }

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

                        If (LEqual (SizeOf (Arg2), 0x0200))
                        {
                            And (PRIT, 0x3F0F, PRIT)
                            Store (0x00, PSIT)
                            And (SDMA, 0x0D, SDMA)
                            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)
                            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 (SDMA, 0x02, SDMA)
                                Store (SETD (DMA1), SDT1)
                                If (And (W881, 0x20))
                                {
                                    Or (ICR1, 0x02, ICR1)
                                    Or (ICR5, 0x02, ICR5)
                                }

                                If (And (W881, 0x10))
                                {
                                    Or (ICR1, 0x02, ICR1)
                                }

                                If (LLess (DMA0, 0x1E))
                                {
                                    Or (ICR3, 0x02, ICR3)
                                }

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

                    Method (_PS0, 0, NotSerialized)
                    {
                    }

                    Method (_PS3, 0, NotSerialized)
                    {
                    }

                    Device (P_D0)
                    {
                        Name (_ADR, 0x00)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Noop
                            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 (SDMA, 0x01))
                            {
                                Store (Or (SDT0, 0x40), DMD0)
                                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)
                        }
                    }

                    Device (P_D1)
                    {
                        Name (_ADR, 0x01)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Noop
                            Name (PIB1, Buffer (0x0E)
                            {
                                0x03, 0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF, 0x03, 
                                0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF
                            })
                            CreateByteField (PIB1, 0x01, PMD1)
                            CreateByteField (PIB1, 0x08, DMD1)
                            If (And (PRIT, 0x20))
                            {
                                If (LEqual (And (PRIT, 0x90), 0x80))
                                {
                                    Store (0x08, PMD1)
                                }
                                Else
                                {
                                    Add (And (PSIT, 0x03), ShiftRight (And (PSIT, 0x0C), 0x02), Local0)
                                    If (LEqual (0x05, Local0))
                                    {
                                        Store (0x0C, PMD1)
                                    }
                                    Else
                                    {
                                        If (LEqual (0x03, Local0))
                                        {
                                            Store (0x0B, PMD1)
                                        }
                                        Else
                                        {
                                            Store (0x0A, PMD1)
                                        }
                                    }
                                }
                            }
                            Else
                            {
                                Store (0x01, PMD1)
                            }

                            If (And (SDMA, 0x02))
                            {
                                Store (Or (SDT1, 0x40), DMD1)
                                If (And (ICR0, 0x02))
                                {
                                    Add (DMD1, 0x02, DMD1)
                                }

                                If (And (ICR3, 0x02))
                                {
                                    Store (0x45, DMD1)
                                }
                            }
                            Else
                            {
                                Or (Subtract (And (PMD1, 0x07), 0x02), 0x20, DMD1)
                            }

                            Return (PIB1)
                        }
                    }
                }

                Device (SECD)
                {
                    Name (_ADR, 0x01)
                    Method (_GTM, 0, NotSerialized)
                    {
                        Noop
                        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 (GETD (And (SDMA, 0x04), And (ICR3, 0x04), And (ICR0, 0x04), SDT2), 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 (GETD (And (SDMA, 0x08), And (ICR3, 0x08), And (ICR0, 0x08), SDT3), DMA1)
                        If (LEqual (DMA1, 0xFFFFFFFF))
                        {
                            Store (PIO1, DMA1)
                        }

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

                    Method (_STM, 3, NotSerialized)
                    {
                        Noop
                        CreateDWordField (Arg0, 0x00, PIO0)
                        CreateDWordField (Arg0, 0x04, DMA0)
                        CreateDWordField (Arg0, 0x08, PIO1)
                        CreateDWordField (Arg0, 0x0C, DMA1)
                        CreateDWordField (Arg0, 0x10, FLAG)
                        Store (0x04, ICR2)
                        If (LEqual (SizeOf (Arg1), 0x0200))
                        {
                            And (SECT, 0x4CF0, SECT)
                            And (SDMA, 0x0B, SDMA)
                            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)
                            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 (SDMA, 0x04, SDMA)
                                Store (SETD (DMA0), SDT2)
                                If (And (W880, 0x20))
                                {
                                    Or (ICR1, 0x04, ICR1)
                                    Or (ICR5, 0x04, ICR5)
                                }

                                If (And (W880, 0x10))
                                {
                                    Or (ICR1, 0x04, ICR1)
                                }

                                If (LLess (DMA0, 0x1E))
                                {
                                    Or (ICR3, 0x04, ICR3)
                                }

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

                        If (LEqual (SizeOf (Arg2), 0x0200))
                        {
                            And (SECT, 0x3F0F, SECT)
                            Store (0x00, SSIT)
                            And (SDMA, 0x07, SDMA)
                            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)
                            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 (SDMA, 0x08, SDMA)
                                Store (SETD (DMA1), SDT3)
                                If (And (W881, 0x20))
                                {
                                    Or (ICR1, 0x08, ICR1)
                                    Or (ICR5, 0x08, ICR5)
                                }

                                If (And (W881, 0x10))
                                {
                                    Or (ICR1, 0x08, ICR1)
                                }

                                If (LLess (DMA0, 0x1E))
                                {
                                    Or (ICR3, 0x08, ICR3)
                                }

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

                    Method (_PS0, 0, NotSerialized)
                    {
                    }

                    Method (_PS3, 0, NotSerialized)
                    {
                    }

                    Device (S_D0)
                    {
                        Name (_ADR, 0x00)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Noop
                            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 (SDMA, 0x04))
                            {
                                Store (Or (SDT2, 0x40), DMD0)
                                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)
                        }
                    }

                    Device (S_D1)
                    {
                        Name (_ADR, 0x01)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Noop
                            Name (SIB1, Buffer (0x0E)
                            {
                                0x03, 0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF, 0x03, 
                                0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF
                            })
                            CreateByteField (SIB1, 0x01, PMD1)
                            CreateByteField (SIB1, 0x08, DMD1)
                            If (And (SECT, 0x20))
                            {
                                If (LEqual (And (SECT, 0x90), 0x80))
                                {
                                    Store (0x08, PMD1)
                                }
                                Else
                                {
                                    Add (And (SSIT, 0x03), ShiftRight (And (SSIT, 0x0C), 0x02), Local0)
                                    If (LEqual (0x05, Local0))
                                    {
                                        Store (0x0C, PMD1)
                                    }
                                    Else
                                    {
                                        If (LEqual (0x03, Local0))
                                        {
                                            Store (0x0B, PMD1)
                                        }
                                        Else
                                        {
                                            Store (0x0A, PMD1)
                                        }
                                    }
                                }
                            }
                            Else
                            {
                                Store (0x01, PMD1)
                            }

                            If (And (SDMA, 0x02))
                            {
                                Store (Or (SDT3, 0x40), DMD1)
                                If (And (ICR0, 0x08))
                                {
                                    Add (DMD1, 0x02, DMD1)
                                }

                                If (And (ICR3, 0x08))
                                {
                                    Store (0x45, DMD1)
                                }
                            }
                            Else
                            {
                                Or (Subtract (And (PMD1, 0x07), 0x02), 0x20, DMD1)
                            }

                            Return (SIB1)
                        }
                    }
                }
            }

            Device (SMBS)
            {
                Name (_ADR, 0x001F0003)
            }

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

            Device (USB1)
            {
                Name (_ADR, 0x001D0000)
                OperationRegion (USBO, PCI_Config, 0xC4, 0x04)
                Field (USBO, DWordAcc, Lock, Preserve)
                {
                    RSEN,   2
                }

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

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

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

            Device (USB2)
            {
                Name (_ADR, 0x001D0001)
                OperationRegion (USBO, PCI_Config, 0xC4, 0x04)
                Field (USBO, DWordAcc, Lock, Preserve)
                {
                    RSEN,   2
                }

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

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

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

            Device (USB3)
            {
                Name (_ADR, 0x001D0002)
                OperationRegion (USBO, PCI_Config, 0xC4, 0x04)
                Field (USBO, DWordAcc, Lock, Preserve)
                {
                    RSEN,   2
                }

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

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

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

            Device (USB4)
            {
                Name (_ADR, 0x001D0003)
                OperationRegion (USBO, PCI_Config, 0xC4, 0x04)
                Field (USBO, DWordAcc, Lock, Preserve)
                {
                    RSEN,   2
                }

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

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

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

            Device (EUSB)
            {
                Name (_ADR, 0x001D0007)
                Name (_S3D, 0x02)
                Name (_S4D, 0x02)
                Name (_PRW, Package (0x02)
                {
                    0x0D, 
                    0x04
                })
            }
        }
    }

    Scope (_SI)
    {
        Method (_SST, 1, NotSerialized)
        {
            If (LEqual (Arg0, 0x01))
            {
                \_SB.PCI0.LPC0.SIO.ENWK ()
            }
        }
    }

    Scope (_TZ)
    {
    }

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

    Name (_S0, Package (0x02)
    {
        0x00, 
        0x00
    })
    Name (_S1, Package (0x02)
    {
        0x01, 
        0x01
    })
    Name (_S4, Package (0x02)
    {
        0x06, 
        0x06
    })
    Name (_S5, Package (0x02)
    {
        0x07, 
        0x07
    })
    Name (PICF, 0x00)
    Method (_PIC, 1, NotSerialized)
    {
        Store (Arg0, \PICF)
    }

    Method (_PTS, 1, NotSerialized)
    {
        Store (Arg0, DEBG)
        If (LEqual (Arg0, 0x01))
        {
            \_SB.PCI0.LPC0.SIO.ENWK ()
            \_SB.PCI0.LPC0.SIO.CLED (0x02)
        }

        If (LEqual (Arg0, 0x03))
        {
            \_SB.PCI0.LPC0.SIO.CLED (0x03)
        }

        If (LNot (LLess (Arg0, 0x04)))
        {
            \_SB.PCI0.LPC0.SIO.CLED (0x01)
        }
    }

    Method (_WAK, 1, NotSerialized)
    {
        ShiftLeft (Arg0, 0x04, DEBG)
        \_SB.PCI0.LPC0.SIO.CLED (0x00)
        Notify (\_SB.PCI0.PWRB, 0x02)
        \_SB.PCI0.LPC0.SIO.DSWK ()
    }

    Scope (\)
    {
        Name (SSDT, Package (0x18)
        {
            "CPU0IST ", 
            0x00000000, 
            0x00000000, 
            "CPU1IST ", 
            0x00000000, 
            0x00000000, 
            "CPU0CST ", 
            0x00000000, 
            0x00000000, 
            "CPU1CST ", 
            0x00000000, 
            0x00000000, 
            "CPU2IST ", 
            0x80000000, 
            0x80000000, 
            "CPU3IST ", 
            0x80000000, 
            0x80000000, 
            "CPU2CST ", 
            0x80000000, 
            0x80000000, 
            "CPU3CST ", 
            0x80000000, 
            0x80000000
        })
        Name (CFGD, 0x0F474108)
        Name (\PDC0, 0x80000000)
        Name (\PDC1, 0x80000000)
        Name (\PDC2, 0x80000000)
        Name (\PDC3, 0x80000000)
    }

    Scope (\_PR.CPU0)
    {
        Name (HI0, 0x00)
        Name (HC0, 0x00)
        Method (_PDC, 1, NotSerialized)
        {
            CreateDWordField (Arg0, 0x08, CAP0)
            Store (CAP0, PDC0)
            If (LAnd (And (CFGD, 0x4000), LEqual (And (PDC0, 0x0A), 0x0A)))
            {
                If (And (CFGD, 0x03))
                {
                    OperationRegion (IST0, SystemMemory, DerefOf (Index (SSDT, 0x01)), DerefOf (Index (SSDT, 0x02)))
                    Load (IST0, HI0)
                }

                If (And (CFGD, 0x10))
                {
                    OperationRegion (CST0, SystemMemory, DerefOf (Index (SSDT, 0x07)), DerefOf (Index (SSDT, 0x08)))
                    Load (CST0, HC0)
                }
            }
        }
    }

    Scope (\_PR.CPU1)
    {
        Name (HI1, 0x00)
        Name (HC1, 0x00)
        Method (_PDC, 1, NotSerialized)
        {
            CreateDWordField (Arg0, 0x08, CAP1)
            Store (CAP1, PDC1)
            If (LAnd (And (CFGD, 0x4000), LEqual (And (PDC1, 0x0A), 0x0A)))
            {
                If (And (CFGD, 0x03))
                {
                    OperationRegion (IST1, SystemMemory, DerefOf (Index (SSDT, 0x04)), DerefOf (Index (SSDT, 0x05)))
                    Load (IST1, HI1)
                }

                If (And (CFGD, 0x10))
                {
                    OperationRegion (CST1, SystemMemory, DerefOf (Index (SSDT, 0x0A)), DerefOf (Index (SSDT, 0x0B)))
                    Load (CST1, HC1)
                }
            }

            If (LEqual (And (PDC1, 0x0A), 0x0A)) {}
        }
    }

    Scope (\_PR.CPU2)
    {
        Name (HI2, 0x00)
        Name (HC2, 0x00)
        Method (_PDC, 1, NotSerialized)
        {
            CreateDWordField (Arg0, 0x08, CAP2)
            Store (CAP2, PDC2)
            If (LAnd (And (CFGD, 0x4000), LEqual (And (PDC2, 0x0A), 0x0A)))
            {
                If (And (CFGD, 0x03))
                {
                    OperationRegion (IST2, SystemMemory, DerefOf (Index (SSDT, 0x0D)), DerefOf (Index (SSDT, 0x0E)))
                    Load (IST2, HI2)
                }

                If (And (CFGD, 0x10))
                {
                    OperationRegion (CST2, SystemMemory, DerefOf (Index (SSDT, 0x13)), DerefOf (Index (SSDT, 0x14)))
                    Load (CST2, HC2)
                }
            }
        }
    }

    Scope (\_PR.CPU3)
    {
        Name (HI3, 0x00)
        Name (HC3, 0x00)
        Method (_PDC, 1, NotSerialized)
        {
            CreateDWordField (Arg0, 0x08, CAP3)
            Store (CAP3, PDC3)
            If (LAnd (And (CFGD, 0x4000), LEqual (And (PDC3, 0x0A), 0x0A)))
            {
                If (And (CFGD, 0x03))
                {
                    OperationRegion (IST3, SystemMemory, DerefOf (Index (SSDT, 0x10)), DerefOf (Index (SSDT, 0x11)))
                    Load (IST3, HI3)
                }

                If (And (CFGD, 0x10))
                {
                    OperationRegion (CST3, SystemMemory, DerefOf (Index (SSDT, 0x16)), DerefOf (Index (SSDT, 0x17)))
                    Load (CST3, HC3)
                }
            }

            If (LEqual (And (PDC3, 0x0A), 0x0A)) {}
        }
    }
}


[-- Attachment #3 --]
DSDT¬NSINTELGLENWOODMSFT[€RCRBÀÑþ@[<RCRB€€€HPASHPAEH	PATDSATDSMBDAZADA97DOSYS
H_GPE_L03p
DEBG†\/_SB_PCI0USB1
_L04p
DEBG†\/_SB_PCI0USB2
D_L08p
DEBG†\/_SB_PCI0LPC0SIO_COM1
†\/_SB_PCI0LPC0SIO_COM2
†\/_SB_PCI0PWRB
D_L09p
	DEBG†\/_SB_PCI0EXP1
†\/_SB_PCI0EXP5
†\/_SB_PCI0EXP6
L_L0Bp
DEBG†\/_SB_PCI0DEV1PXHA
†\/_SB_PCI0DEV1PXHB
†\/_SB_PCI0PCIB
_L0Cp
DEBG†\/_SB_PCI0USB3
_L0Dp

DEBG†\/_SB_PCI0EUSB
_L0Ep
DEBG†\/_SB_PCI0USB4
:_L1D†\/_SB_PCI0LPC0SIO_KBC0
†\/_SB_PCI0LPC0SIO_MSE0
9_PR_[ƒCPU0[ƒCPU1[ƒCPU2[ƒCPU3†s_SB_[‚rPCI0_INI_HIDAÐ
_BBN
_ADR
[€REGS
@
À[:REGS@(PAM0PAM1PAM2PAM3PAM4PAM5PAM6HEN_ Z000[€DRBS@Ñþ@[4DRBS@€Z001Z002Z003Z004@>Z005Z006Z007Z008RSRCF ˆÿGøø‡÷ø‡
ÿÿ‡ÿ?@‡@ÿ@‡€ÿ¿@‡Àÿÿ@‡
ÿ?
@‡@
ÿ
@‡€
ÿ¿
@‡À
ÿÿ
@‡ÿ?@‡@ÿ@‡€ÿ¿@‡Àÿÿ@‡ÿÿ‡‡
ÿýñ‡yG^_CRSpaŠRSRC¸BTMNŠRSRC¼BTMXŠRSRCÄBTLNy{Z000
ø
BTMNtðBTMNBTLNtrBTMNBTLN
BTMXRSRC C0RWŠRSRC
YC0MNŠRSRC
]C0MXŠRSRC
eC0LNpC0RW “{PAM1

pC0RWpC0LN ’{PAM1
p@C0LNRSRCxC4RWŠRSRC
tC4MNŠRSRC
xC4MXŠRSRC
€C4LNpC4RW “{PAM1
0
pC4RWpC4LN ’{PAM1
0p@C4LNRSRCPC8RWŠRSRC
C8MNŠRSRC
“C8MXŠRSRC
›C8LNpC8RW “{PAM2

pC8RWpC8LN ’{PAM2
p@C8LNRSRC(CCRWŠRSRC
ªCCMNŠRSRC
®CCMXŠRSRC
¶CCLNpCCRW “{PAM2
0
pCCRWpCCLN ’{PAM2
0p@CCLNRSRCD0RWŠRSRC
ÅD0MNŠRSRC
ÉD0MXŠRSRC
ÑD0LNpD0RW “{PAM3

pD0RWpD0LN ’{PAM3
p@D0LNRSRCØD4RWŠRSRC
àD4MNŠRSRC
äD4MXŠRSRC
ìD4LNpD4RW “{PAM3
0
pD4RWpD4LN ’{PAM3
0p@D4LNRSRC°D8RWŠRSRC
ûD8MNŠRSRC
ÿD8MXŠRSRCD8LNpD8RW “{PAM4

pD8RWpD8LN ’{PAM4
p@D8LNRSRCˆDCRWŠRSRCDCMNŠRSRCDCMXŠRSRC"DCLNpDCRW “{PAM4
0
pDCRWpDCLN ’{PAM4
0p@DCLNRSRC`	E0RWŠRSRC1E0MNŠRSRC5E0MXŠRSRC=E0LNpE0RW “{PAM5

pE0RWpE0LN ’{PAM5
p@E0LNRSRC8
E4RWŠRSRCLE4MNŠRSRCPE4MXŠRSRCXE4LNpE4RW “{PAM5
0
pE4RWpE4LN ’{PAM5
0p@E4LNRSRCE8RWŠRSRCgE8MNŠRSRCkE8MXŠRSRCsE8LNpE8RW “{PAM6

pE8RWpE8LN ’{PAM6
p@E8LNRSRCèECRWŠRSRC‚ECMNŠRSRC†ECMXŠRSRCŽECLNpECRW “{PAM6
0
pECRWpECLN ’{PAM6
0p@ECLNRSRCÀF0RWŠRSRCF0MNŠRSRC¡F0MXŠRSRC©F0LNpF0RW “{PAM0
0
pF0RWpF0LN ’{PAM0
0pF0LN M	HPAEŠRSRCîM2MNŠRSRCòM2MXŠRSRCúM2LNpÐþM2MNpÿÐþM2MXpM2LN “HPAS
pÐþM2MNpÿÐþM2MX “HPAS
p ÐþM2MNpÿ#ÐþM2MX “HPAS
p0ÐþM2MNpÿ3ÐþM2MX¤RSRCI#_PRT A’\PICF¤Gÿÿ
\/_SB_PCI0LPC0LNKA
ÿÿ
\/_SB_PCI0LPC0LNKB
ÿÿ
\/_SB_PCI0LPC0LNKA
ÿÿ
\/_SB_PCI0LPC0LNKC
ÿÿ
\/_SB_PCI0LPC0LNKD
ÿÿ
\/_SB_PCI0LPC0LNKH
ÿÿ
\/_SB_PCI0LPC0LNKD
ÿÿ
\/_SB_PCI0LPC0LNKC
ÿÿ
\/_SB_PCI0LPC0LNKA
ÿÿ
\/_SB_PCI0LPC0LNKC
ÿÿ
\/_SB_PCI0LPC0LNKD
ÿÿ
\/_SB_PCI0LPC0LNKA
¡O
¤K

ÿÿ



ÿÿ



ÿÿ



ÿÿ



ÿÿ



ÿÿ



ÿÿ



ÿÿ



ÿÿ



ÿÿ



ÿÿ



ÿÿ


	_S3D¤
	_S4D¤
[‚B$DEV1_ADR[‚EPXHA_ADR
_PRW

K_PRT G’\PICF¤Mÿÿ
\/_SB_PCI0LPC0LNKA
ÿÿ
\/_SB_PCI0LPC0LNKB
ÿÿ
\/_SB_PCI0LPC0LNKC
ÿÿ
\/_SB_PCI0LPC0LNKD
ÿÿ
\/_SB_PCI0LPC0LNKC
ÿÿ
\/_SB_PCI0LPC0LNKD
¡K¤G
ÿÿ



ÿÿ



ÿÿ



ÿÿ



ÿÿ



ÿÿ


[‚IPXHB_ADR
_PRW

O_PRT I’\PICF¤Oÿÿ
\/_SB_PCI0LPC0LNKA
ÿÿ
\/_SB_PCI0LPC0LNKB
ÿÿ
\/_SB_PCI0LPC0LNKC
ÿÿ
\/_SB_PCI0LPC0LNKD
¡=¤:
ÿÿ


0
ÿÿ


1
ÿÿ


2
ÿÿ


3[‚L
EXP1_ADR_PRW
	
O_PRT A’\PICF¤Gÿÿ
\/_SB_PCI0LPC0LNKA
ÿÿ
\/_SB_PCI0LPC0LNKB
ÿÿ
\/_SB_PCI0LPC0LNKC
ÿÿ
\/_SB_PCI0LPC0LNKD
¡5¤2ÿÿ


ÿÿ


ÿÿ


ÿÿ


[‚OEXP5_ADR_PRW
	
B_PRT (’\PICF¤ÿÿ
\/_SB_PCI0LPC0LNKA
¡¤ÿÿ


[‚OEXP6_ADR_PRW
	
B_PRT (’\PICF¤ÿÿ
\/_SB_PCI0LPC0LNKB
¡¤ÿÿ


[‚OPCIB_ADR_PRW

B
_PRT J’\PICF¤@ÿÿ
\/_SB_PCI0LPC0LNKA
ÿÿ
\/_SB_PCI0LPC0LNKB
ÿÿ
\/_SB_PCI0LPC0LNKC
¡/¤,
ÿÿ



ÿÿ



ÿÿ


[‚Š’LPC0_ADRDVEN

DECDph[1[‚KMBRD_HIDAÐ_UID
RSRCGGG$$G((G,,G00G44G88G<<GrrG€€GG¤¤G¨¨G¬¬G°°G¸¸G¼¼G••G@G		G€G€€@G..GÐÐGþþ†	@Ñþ@†	0Ñþ†	€Ñþ@†	ð†	Òþ†	ðþyF_CRS‹RSRC
¢PMMN‹RSRC
¤PMMX{^^PMBA€ÿPMMNpPMMNPMMX‹RSRC
ªGPMN‹RSRC
¬GPMX{^^GPBA€ÿGPMNpGPMNGPMX¤RSRC[‚5DMAC_HIDAÐ_CRS 
GGGÀÀ *y[‚&MATH_HIDAÐ_CRS
Gðð# y[‚,PIC__HIDAÐ_CRS
G  G  #y[‚@RTC__HIDAÐBUF0

GppyBUF1

Gpp"y_CRS 
HPAE¤BUF0¤BUF1[‚"SPKR_HIDAÐ_CRS

Gaay[‚@TIMR_HIDAÐBUF0
G@@GPPyBUF1
G@@GPP"y_CRS 
HPAE¤BUF0¤BUF1[‚N
MMTM_HIDAÐBUF0
""†	Ðþy(_STA ’•OSYSÑ HPAE¤
¡
 HPAE¤
¤
G_CRS JHPAEŠBUF0

HPT0 “HPAS
pÐþHPT0 “HPAS
p ÐþHPT0 “HPAS
p0ÐþHPT0¤BUF0[‚ELNKA_HIDAÐ_UID
_PRS	
#ÌyRSRC	
#y_DIS}PIRA
€PIRA-_CRS‹RSRC
IRQ0{PIRA
`y
`IRQ0pRSRC[1¤RSRC(_SRSph[1‹h
IRQ0‚IRQ0`v`}`{PIRA
pPIRA_STA {PIRA
€¤
	¤
[‚J
LNKB_HIDAÐ_UID
_PRS	
#ÌyRSRC	
#y_DIS}PIRB
€PIRB&_CRS‹RSRC
IRQ0{PIRB
`y
`IRQ0¤RSRC$_SRS‹h
IRQ0‚IRQ0`v`}`{PIRB
pPIRB_STA {PIRB
€¤
	¤
[‚J
LNKC_HIDAÐ_UID
_PRS	
#ÌyRSRC	
#y_DIS}PIRC
€PIRC&_CRS‹RSRC
IRQ0{PIRC
`y
`IRQ0¤RSRC$_SRS‹h
IRQ0‚IRQ0`v`}`{PIRC
pPIRC_STA {PIRC
€¤
	¤
[‚J
LNKD_HIDAÐ_UID
_PRS	
#ÌyRSRC	
#y_DIS}PIRD
€PIRD&_CRS‹RSRC
IRQ0{PIRD
`y
`IRQ0¤RSRC$_SRS‹h
IRQ0‚IRQ0`v`}`{PIRD
pPIRD_STA {PIRD
€¤
	¤
[‚ELNKE_HIDAÐ_UID
_PRS	
#ÌyRSRC	
#y_DIS}PIRE
€PIRE-_CRS‹RSRC
IRQ0{PIRE
`y
`IRQ0pRSRC[1¤RSRC(_SRSph[1‹h
IRQ0‚IRQ0`v`}`{PIRE
pPIRE_STA {PIRE
€¤
	¤
[‚ELNKF_HIDAÐ_UID
_PRS	
#ÌyRSRC	
#y_DIS}PIRF
€PIRF-_CRS‹RSRC
IRQ0{PIRF
`y
`IRQ0pRSRC[1¤RSRC(_SRSph[1‹h
IRQ0‚IRQ0`v`}`{PIRF
pPIRF_STA {PIRF
€¤
	¤
[‚ELNKG_HIDAÐ_UID
_PRS	
#ÌyRSRC	
#y_DIS}PIRG
€PIRG-_CRS‹RSRC
IRQ0{PIRG
`y
`IRQ0pRSRC[1¤RSRC(_SRSph[1‹h
IRQ0‚IRQ0`v`}`{PIRG
pPIRG_STA {PIRG
€¤
	¤
[‚ELNKH_HIDAÐ_UID
_PRS	
#ÌyRSRC	
#y_DIS}PIRH
€PIRH-_CRS‹RSRC
IRQ0{PIRH
`y
`IRQ0pRSRC[1¤RSRC(_SRSph[1‹h
IRQ0‚IRQ0`v`}`{PIRH
pPIRH_STA {PIRH
€¤
	¤
[€GPOX€
0["GPOX8IO27<LV27LBL27[€PIRX
`
[PIRXPIRAPIRBPIRCPIRD[€PIRY
h
[PIRYPIREPIRFPIRGPIRH[€ELR0
 
[BELR0	PBLVFELSSELSTELPBELLOELGNELYLELBEELIEELSNELOCELSO[€ROUT
¸
[JROUTGPI0GPI1GPI2GPI3GPI4GPI5GPI6GPI7GPI8GPI9GP10GP11GP12GP13GP14GP15[€PMIO
0[PMIOHGPESGPEE[€REGS
@
[REGSPMBA0GPBA[‚&FWH__HID%Ô_CRS
†	€ÿ€y[‚AàSIO__HIDAÐ
[W627[€SIBP
.
[SIBPBPIO[€SIIO
.
[SIIOINDXDATA[†JINDXDATA8LDN_@
POW_HACT_OIOBHIOBLIO2HIO2L@INT_DMASM5Z009Z00AHMODEIRMD
SLEDPLEDCFG_p
‡BPIOp
‡BPIOphLDN_
XCFGp
ªBPIO>STA_[#W627PCFG_hp
a 	ACT_p
a¡ ‘IOBHIOBLp

aXCFG['W627¤a'DIS_[#W627ˆCFG_hp
ACT_XCFG['W627¤
'PS0_[#W627ˆCFG_hp
ACT_XCFG['W627¤
'PS3_[#W627ˆCFG_hp
ACT_XCFG['W627¤
[‚:KBC0_HIDAÐ_CRS
G``Gdd#y_PRW

[‚*MSE0_HIDAÐ_CRS	
#y_PRW

[‚BCOM1_HIDAÐ_UID
_STApSTA_
a¤a_DISDIS_
I
_CRSRSRC

G"yŒRSRC
IO1_ŒRSRC
IO2_ŒRSRC
IO3_ŒRSRC
IO4_‹RSRC
	IRQV[#W627ˆCFG_
 7ACT_pIOBLIO1_pIOBHIO2_pIOBLIO3_pIOBHIO4_p
`y`INT_IRQVXCFG['W627¤RSRC_PRSD
p1Gøø#0Gøø#0Gèè#0Gèè#1
Gøø#1
Gøø#1
Gèè#1
Gèè#8yN_SRSŒh
IO1_Œh
IO2_‹h
	IRQV[#W627ˆCFG_
pIO1_IOBLpIO2_IOBH‚IRQV`t`
INT_p
ACT_XCFG['W627_PS0PS0_
_PS3PS3_
[‚B COM29_HID[#W627ˆCFG_
 IRMD
8pAÐa¡pAÐaXCFG['W627¤a_UID
_STApSTA_
a¤a_DISDIS_
I
_CRSRSRC

G"yŒRSRC
IO1_ŒRSRC
IO2_ŒRSRC
IO3_ŒRSRC
IO4_‹RSRC
	IRQV[#W627ˆCFG_
 7ACT_pIOBLIO1_pIOBHIO2_pIOBLIO3_pIOBHIO4_p
`y`INT_IRQVXCFG['W627¤RSRC_PRSD
p0Gøø#1Gøø#0Gèè#0Gèè#1
Gøø#1
Gøø#1
Gèè#1
Gèè#8yN_SRSŒh
IO1_Œh
IO2_‹h
	IRQV[#W627ˆCFG_
pIO1_IOBLpIO2_IOBH‚IRQV`t`
INT_p
ACT_XCFG['W627_PS0PS0_
_PS3PS3_
[‚E"FDC__HIDAÐ_UID
_STApSTA_
a¤a_DISDIS_
B_CRSRSRC
GG"*y[#W627ˆCFG_
 L
ACT_ŒRSRC
IO1_ŒRSRC
IO2_ŒRSRC
IO3_ŒRSRC
IO4_ŒRSRC

IO5_ŒRSRC
IO6_ŒRSRC
IO7_ŒRSRC

IO8_‹RSRC
IRQVŒRSRC
DMAVpIOBLIO1_pIOBHIO2_pIOBLIO3_pIOBHIO4_rIOBL
IO5_pIOBHIO6_rIOBL
IO7_pIOBHIO8_p
`y`INT_IRQVp
`y`DMASDMAVXCFG['W627¤RSRC_PRS8
51GððG÷÷#@*1GppGww#@*8yD_SRSŒh
IO1_Œh
IO2_‹h
IRQVŒh
DMAV[#W627ˆCFG_
pIO1_IOBLpIO2_IOBH‚IRQV`t`
INT_‚DMAV`t`
DMASp
ACT_XCFG['W627_PS0PS0_
_PS3PS3_
[‚BRPRT_9_HID[#W627ˆCFG_
 “MODE
pAÐa¡pAÐaXCFG['W627¤a_UID
_STApSTA_
a¤a_DISDIS_
H$_CRS[#W627ˆCFG_
CRSA

G"yŒCRSA
IOA1ŒCRSA
IOA2ŒCRSA
IOA3ŒCRSA
IOA4ŒCRSA
ALA1ŒCRSA
LNA1‹CRSA
	IRQACRSB
GG"*yŒCRSB
IOB1ŒCRSB
IOB2ŒCRSB
IOB3ŒCRSB
IOB4ŒCRSB
ALB1ŒCRSB
LNB1ŒCRSB

IOB5ŒCRSB
IOB6ŒCRSB
IOB7ŒCRSB

IOB8ŒCRSB
ALB2ŒCRSB
LNB2‹CRSB
IRQB‹CRSB
DMAV CACT_ K	“MODE
pIOBLIOB1pIOBHIOB2pIOBLIOB3pIOBHIOB4pIOBLIOB5rIOBH
IOB6pIOBLIOB7rIOBH
IOB8 $“IOBL
¼p
ALB1p
LNB1p
ALB2p
LNB2p
`y`INT_IRQBp
`y`DMASDMAV¤CRSB¡@pIOBLIOA1pIOBHIOA2pIOBLIOA3pIOBHIOA4p
`y`INT_IRQA “IOBL
¼p
ALA1p
LNA1¤CRSA¡ 
“MODE
¤CRSB¡¤CRSAXCFG['W627PRSAE
Q0Gxx#€0Gxx# 0Gxx#€0Gxx# 0G¼¼#€0G¼¼# 8yPRSBG	
“0GxxGxx#€*0GxxGxx# *0GxxGxx#€*0GxxGxx# *0G¼¼G¼¼#€*0G¼¼G¼¼# *8y7_PRS[#W627ˆCFG_
 “MODE
pPRSB`¡pPRSA`XCFG['W627¤`I_SRS[#W627ˆCFG_
 G
“MODE
Œh
IOB1Œh
IOB2Œh
IOB3Œh
IOB4Œh
ALB1Œh
LNB1Œh

IOB5Œh
IOB6Œh
IOB7Œh

IOB8Œh
ALB2Œh
LNB2‹h
IRQB‹h
DMAVpIOB1IOBLpIOB2IOBHIRQB`t`
INT_DMAV`t`
DMAS¡JŒh
IOA1Œh
IOA2Œh
IOA3Œh
IOA4Œh
ALA1Œh
LNA1‹h
	IRQApIOA1IOBLpIOA2IOBHIRQA`t`
INT_p
ACT_XCFG['W627_PS0PS0_
_PS3PS3_
GENWK[#W627ˆCFG_

p
ACT_p
ACT_p
óINDXp
?DATAp
öINDXp
0DATAp
ùINDXp
DATAXCFG['W627@DSWK[#W627ˆCFG_

p
ACT_p
öINDXp
DATAp
ùINDXp
DATAp
óINDXp
?DATAXCFG['W627$CLED[#W627ˆCFG_
	phSLEDXCFG['W627NATAGGETP£ “{h
	
¤ÿÿÿÿ 
“{h
	
¤„z{h
`z{h0
a¤w
t
	r`a-GETD£ h i¤
 j¤wt
k
¤wt
k
¤ÿÿÿÿ GETT£¤w
t
	r{zh

{h
GGETF£TMPF
 
h}TMPF
TMPF {j
}TMPF
TMPF 
i}TMPF
TMPF {j
 }TMPF
TMPF {j@}TMPF
TMPF¤TMPFASETP£ 	’•h
ð¤
¡. ({i
 ’”h
x{j
¤# ’”h
´{j
¤!¤<SETD£ 	’”h
¤
 	’”h
¤
 	’”h
-¤
 	’”h
<¤
 	’”h
Z¤
¤
1SETT£ &{i
 ’”h
x{j
¤
 ’”h
´{j
¤
	¤
[‚@ÒIDEC_ADR[€IDEC
@
[OIDECPRITSECTPSITSSITSDMASDT0SDT1SDT2SDT3BICR0ICR1ICR2ICR3ICR4ICR5[‚@ePRID_ADR
J_GTM£PBUF
ŠPBUF
PIO0ŠPBUF
DMA0ŠPBUF
PIO1ŠPBUF
DMA1ŠPBUF
FLAGpGETPPRITPIO0pGETD{SDMA
{ICR3
{ICR0
SDT0DMA0 “DMA0ÿÿÿÿpPIO0DMA0 .{PRIT@ “{PRIT

€p„PIO1¡pGETTPSITPIO1¡pÿÿÿÿPIO1pGETD{SDMA
{ICR3
{ICR0
SDT1DMA1 “DMA1ÿÿÿÿpPIO1DMA1pGETF{SDMA
{SDMA
PRITFLAG¤PBUF@/_STM£Šh
PIO0Šh
DMA0Šh
PIO1Šh
DMA1Šh
FLAGp
ICR2 N“‡i{PRITðLPRIT{SDMA
SDMAp
SDT0{ICR0
ICR0{ICR1
ICR1{ICR3
ICR3{ICR5
ICR5‹i
bW490‹i
jW530‹i
~W630‹i
€W640‹i
°W880}PRIT€PRIT {FLAG
{W490}PRIT
PRIT}PRITSETPPIO0W530W640PRIT O{FLAG
}SDMA
SDMApSETDDMA0SDT0 {W880
 }ICR1
ICR1}ICR5
ICR5 {W880
}ICR1
ICR1 •DMA0
}ICR3
ICR3 •DMA0
<}ICR0
ICR0 I“‡j{PRIT?PRITp
PSIT{SDMA

SDMAp
SDT1{ICR0

ICR0{ICR1

ICR1{ICR3

ICR3{ICR5

ICR5‹j
bW491‹j
jW531‹j
~W631‹j
€W641‹j
°W881}PRIT@€PRIT {FLAG
{W491}PRIT
 PRIT L{FLAG
}PRIT@PRIT ”PIO1
ð}PRIT
€PRIT¡!}PRIT
PRITpSETTPIO1W531W641PSIT O{FLAG
}SDMA
SDMApSETDDMA1SDT1 {W881
 }ICR1
ICR1}ICR5
ICR5 {W881
}ICR1
ICR1 •DMA0
}ICR3
ICR3 •DMA0
<}ICR0
ICR0_PS0£_PS3£[‚DP_D0_ADR
F_GTF£PIB0
 ï ïŒPIB0
PMD0ŒPIB0
DMD0 @{PRIT
 “{PRIT
	
p
PMD0¡Ap

PMD0z{PRIT
`z{PRIT0
ar`ab “
bp
PMD0 “
bp
PMD0¡p
PMD0 <{SDMA
p}SDT0
@DMD0 {ICR0
rDMD0
DMD0 {ICR3
p
EDMD0¡}t{PMD0


 DMD0¤PIB0[‚OP_D1_ADR
A_GTF£PIB1
°ï°ïŒPIB1
PMD1ŒPIB1
DMD1 K{PRIT
  “{PRIT

€p
PMD1¡<r{PSIT
z{PSIT

` “
`p
PMD1¡ “
`p
PMD1¡p

PMD1¡p
PMD1 <{SDMA
p}SDT1
@DMD1 {ICR0
rDMD1
DMD1 {ICR3
p
EDMD1¡}t{PMD1


 DMD1¤PIB1[‚@eSECD_ADR
J_GTM£SBUF
ŠSBUF
PIO0ŠSBUF
DMA0ŠSBUF
PIO1ŠSBUF
DMA1ŠSBUF
FLAGpGETPSECTPIO0pGETD{SDMA
{ICR3
{ICR0
SDT2DMA0 “DMA0ÿÿÿÿpPIO0DMA0 .{SECT@ “{SECT

€p„PIO1¡pGETTSSITPIO1¡pÿÿÿÿPIO1pGETD{SDMA
{ICR3
{ICR0
SDT3DMA1 “DMA1ÿÿÿÿpPIO1DMA1pGETF{SDMA
{SDMA
SECTFLAG¤SBUF@/_STM£Šh
PIO0Šh
DMA0Šh
PIO1Šh
DMA1Šh
FLAGp
ICR2 N“‡i{SECTðLSECT{SDMA
SDMAp
SDT2{ICR0
ICR0{ICR1
ICR1{ICR3
ICR3{ICR5
ICR5‹i
bW490‹i
jW530‹i
~W630‹i
€W640‹i
°W880}SECT€SECT {FLAG
{W490}SECT
SECT}SECTSETPPIO0W530W640SECT O{FLAG
}SDMA
SDMApSETDDMA0SDT2 {W880
 }ICR1
ICR1}ICR5
ICR5 {W880
}ICR1
ICR1 •DMA0
}ICR3
ICR3 •DMA0
<}ICR0
ICR0 I“‡j{SECT?SECTp
SSIT{SDMA
SDMAp
SDT3{ICR0
ICR0{ICR1
ICR1{ICR3
ICR3{ICR5
ICR5‹j
bW491‹j
jW531‹j
~W631‹j
€W641‹j
°W881}SECT@€SECT {FLAG
{W491}SECT
 SECT L{FLAG
}SECT@SECT ”PIO1
ð}SECT
€SECT¡!}SECT
SECTpSETTPIO1W531W641SSIT O{FLAG
}SDMA
SDMApSETDDMA1SDT3 {W881
 }ICR1
ICR1}ICR5
ICR5 {W881
}ICR1
ICR1 •DMA0
}ICR3
ICR3 •DMA0
<}ICR0
ICR0_PS0£_PS3£[‚DS_D0_ADR
F_GTF£SIB0
 ï ïŒSIB0
PMD0ŒSIB0
DMD0 @{SECT
 “{SECT
	
p
PMD0¡Ap

PMD0z{SECT
`z{SECT0
ar`ab “
bp
PMD0 “
bp
PMD0¡p
PMD0 <{SDMA
p}SDT2
@DMD0 {ICR0
rDMD0
DMD0 {ICR3
p
EDMD0¡}t{PMD0


 DMD0¤SIB0[‚OS_D1_ADR
A_GTF£SIB1
°ï°ïŒSIB1
PMD1ŒSIB1
DMD1 K{SECT
  “{SECT

€p
PMD1¡<r{SSIT
z{SSIT

` “
`p
PMD1¡ “
`p
PMD1¡p

PMD1¡p
PMD1 <{SDMA
p}SDT3
@DMD1 {ICR0
rDMD1
DMD1 {ICR3
p
EDMD1¡}t{PMD1


 DMD1¤SIB1[‚CÚIDE1_ADR[€IDE1

[IDE1MAP_PCS_[€IDEC
@
[OIDECPRITSECTPSITSSITSDMASDT0SDT1SDT2SDT3BICR0ICR1ICR2ICR3ICR4ICR5GCTYPp` 1h ”MAP_
•MAP_
p
`¡ “MAP_p
` “MAP_p
`¡( ”MAP_
p
`¡ “MAP_p
` “MAP_p
`¤`[‚NdPRID_ADR
J_GTM£PBUF
ŠPBUF
PIO0ŠPBUF
DMA0ŠPBUF
PIO1ŠPBUF
DMA1ŠPBUF
FLAGpGETPPRITPIO0pGETD{SDMA
{ICR3
{ICR0
SDT0DMA0 “DMA0ÿÿÿÿpPIO0DMA0 .{PRIT@ “{PRIT

€p„PIO1¡pGETTPSITPIO1¡pÿÿÿÿPIO1pGETD{SDMA
{ICR3
{ICR0
SDT1DMA1 “DMA1ÿÿÿÿpPIO1DMA1pGETF{SDMA
{SDMA
PRITFLAG¤PBUF@/_STM£Šh
PIO0Šh
DMA0Šh
PIO1Šh
DMA1Šh
FLAGp
ICR2 N“‡i{PRITðLPRIT{SDMA
SDMAp
SDT0{ICR0
ICR0{ICR1
ICR1{ICR3
ICR3{ICR5
ICR5‹i
bW490‹i
jW530‹i
~W630‹i
€W640‹i
°W880}PRIT€PRIT {FLAG
{W490}PRIT
PRIT}PRITSETPPIO0W530W640PRIT O{FLAG
}SDMA
SDMApSETDDMA0SDT0 {W880
 }ICR1
ICR1}ICR5
ICR5 {W880
}ICR1
ICR1 •DMA0
}ICR3
ICR3 •DMA0
<}ICR0
ICR0 I“‡j{PRIT?PRITp
PSIT{SDMA

SDMAp
SDT1{ICR0

ICR0{ICR1

ICR1{ICR3

ICR3{ICR5

ICR5‹j
bW491‹j
jW531‹j
~W631‹j
€W641‹j
°W881}PRIT@€PRIT {FLAG
{W491}PRIT
 PRIT L{FLAG
}PRIT@PRIT ”PIO1
ð}PRIT
€PRIT¡!}PRIT
PRITpSETTPIO1W531W641PSIT O{FLAG
}SDMA
SDMApSETDDMA1SDT1 {W881
 }ICR1
ICR1}ICR5
ICR5 {W881
}ICR1
ICR1 •DMA0
}ICR3
ICR3 •DMA0
<}ICR0
ICR0_PS0_PS3[‚DP_D0_ADR
F_GTF£PIB0
 ï ïŒPIB0
PMD0ŒPIB0
DMD0 @{PRIT
 “{PRIT
	
p
PMD0¡Ap

PMD0z{PRIT
`z{PRIT0
ar`ab “
bp
PMD0 “
bp
PMD0¡p
PMD0 <{SDMA
p}SDT0
@DMD0 {ICR0
rDMD0
DMD0 {ICR3
p
EDMD0¡}t{PMD0


 DMD0¤PIB0[‚OP_D1_ADR
A_GTF£PIB1
°ï°ïŒPIB1
PMD1ŒPIB1
DMD1 K{PRIT
  “{PRIT

€p
PMD1¡<r{PSIT
z{PSIT

` “
`p
PMD1¡ “
`p
PMD1¡p

PMD1¡p
PMD1 <{SDMA
p}SDT1
@DMD1 {ICR0
rDMD1
DMD1 {ICR3
p
EDMD1¡}t{PMD1


 DMD1¤PIB1[‚NdSECD_ADR
J_GTM£SBUF
ŠSBUF
PIO0ŠSBUF
DMA0ŠSBUF
PIO1ŠSBUF
DMA1ŠSBUF
FLAGpGETPSECTPIO0pGETD{SDMA
{ICR3
{ICR0
SDT2DMA0 “DMA0ÿÿÿÿpPIO0DMA0 .{SECT@ “{SECT

€p„PIO1¡pGETTSSITPIO1¡pÿÿÿÿPIO1pGETD{SDMA
{ICR3
{ICR0
SDT3DMA1 “DMA1ÿÿÿÿpPIO1DMA1pGETF{SDMA
{SDMA
SECTFLAG¤SBUF@/_STM£Šh
PIO0Šh
DMA0Šh
PIO1Šh
DMA1Šh
FLAGp
ICR2 N“‡i{SECTðLSECT{SDMA
SDMAp
SDT2{ICR0
ICR0{ICR1
ICR1{ICR3
ICR3{ICR5
ICR5‹i
bW490‹i
jW530‹i
~W630‹i
€W640‹i
°W880}SECT€SECT {FLAG
{W490}SECT
SECT}SECTSETPPIO0W530W640SECT O{FLAG
}SDMA
SDMApSETDDMA0SDT2 {W880
 }ICR1
ICR1}ICR5
ICR5 {W880
}ICR1
ICR1 •DMA0
}ICR3
ICR3 •DMA0
<}ICR0
ICR0 I“‡j{SECT?SECTp
SSIT{SDMA
SDMAp
SDT3{ICR0
ICR0{ICR1
ICR1{ICR3
ICR3{ICR5
ICR5‹j
bW491‹j
jW531‹j
~W631‹j
€W641‹j
°W881}SECT@€SECT {FLAG
{W491}SECT
 SECT L{FLAG
}SECT@SECT ”PIO1
ð}SECT
€SECT¡!}SECT
SECTpSETTPIO1W531W641SSIT O{FLAG
}SDMA
SDMApSETDDMA1SDT3 {W881
 }ICR1
ICR1}ICR5
ICR5 {W881
}ICR1
ICR1 •DMA0
}ICR3
ICR3 •DMA0
<}ICR0
ICR0_PS0_PS3[‚DS_D0_ADR
F_GTF£SIB0
 ï ïŒSIB0
PMD0ŒSIB0
DMD0 @{SECT
 “{SECT
	
p
PMD0¡Ap

PMD0z{SECT
`z{SECT0
ar`ab “
bp
PMD0 “
bp
PMD0¡p
PMD0 <{SDMA
p}SDT2
@DMD0 {ICR0
rDMD0
DMD0 {ICR3
p
EDMD0¡}t{PMD0


 DMD0¤SIB0[‚OS_D1_ADR
A_GTF£SIB1
°ï°ïŒSIB1
PMD1ŒSIB1
DMD1 K{SECT
  “{SECT

€p
PMD1¡<r{SSIT
z{SSIT

` “
`p
PMD1¡ “
`p
PMD1¡p

PMD1¡p
PMD1 <{SDMA
p}SDT3
@DMD1 {ICR0
rDMD1
DMD1 {ICR3
p
EDMD1¡}t{PMD1


 DMD1¤SIB1[‚SMBS_ADR[‚PWRB_HIDAÐ[‚BUSB1_ADR[€USBO
Ä
[USBORSEN_PRW

_PSW 	hp
RSEN¡p
RSEN	_S3D¤
	_S4D¤
[‚BUSB2_ADR[€USBO
Ä
[USBORSEN_PRW

_PSW 	hp
RSEN¡p
RSEN	_S3D¤
	_S4D¤
[‚BUSB3_ADR[€USBO
Ä
[USBORSEN_PRW

_PSW 	hp
RSEN¡p
RSEN	_S3D¤
	_S4D¤
[‚BUSB4_ADR[€USBO
Ä
[USBORSEN_PRW

_PSW 	hp
RSEN¡p
RSEN	_S3D¤
	_S4D¤
[‚)EUSB_ADR_S3D
_S4D
_PRW

)_SI_#_SST “h
\/_SB_PCI0LPC0SIO_ENWK_TZ_[€DBG_
€
[DBG_DEBG_S0_

_S1_

_S4_

_S5_

PICF

_PICph\PICFB_PTSphDEBG 5“h
\/_SB_PCI0LPC0SIO_ENWK\/_SB_PCI0LPC0SIO_CLED
 “h
\/_SB_PCI0LPC0SIO_CLED
 ’•h
\/_SB_PCI0LPC0SIO_CLED
A_WAKyh
DEBG\/_SB_PCI0LPC0SIO_CLED
†\/_SB_PCI0PWRB
\/_SB_PCI0LPC0SIO_DSWKC\SSDTC

CPU0IST 
CPU1IST 
CPU0CST 
CPU1CST 
CPU2IST €€
CPU3IST €€
CPU2CST €€
CPU3CST €€CFGDAG\PDC0€\PDC1€\PDC2€\PDC3€E
\._PR_CPU0HI0_
HC0_
J_PDCŠh
CAP0pCAP0PDC0 A{CFGD@“{PDC0



 ,{CFGD
[€IST0ƒˆSSDT
ƒˆSSDT
[ IST0HI0_ ,{CFGD
[€CST0ƒˆSSDT
ƒˆSSDT
[ CST0HC0_B\._PR_CPU1HI1_
HC1_
G	_PDCŠh
CAP1pCAP1PDC1 A{CFGD@“{PDC1



 ,{CFGD
[€IST1ƒˆSSDT
ƒˆSSDT
[ IST1HI1_ ,{CFGD
[€CST1ƒˆSSDT

ƒˆSSDT
[ CST1HC1_ “{PDC1



E
\._PR_CPU2HI2_
HC2_
J_PDCŠh
CAP2pCAP2PDC2 A{CFGD@“{PDC2



 ,{CFGD
[€IST2ƒˆSSDT

ƒˆSSDT
[ IST2HI2_ ,{CFGD
[€CST2ƒˆSSDT
ƒˆSSDT
[ CST2HC2_B\._PR_CPU3HI3_
HC3_
G	_PDCŠh
CAP3pCAP3PDC3 A{CFGD@“{PDC3



 ,{CFGD
[€IST3ƒˆSSDT
ƒˆSSDT
[ IST3HI3_ ,{CFGD
[€CST3ƒˆSSDT
ƒˆSSDT
[ CST3HC3_ “{PDC3




Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?46CB27C1.4090805>