Skip site navigation (1)Skip section navigation (2)
Date:      Sat, 31 Jan 2004 01:40:01 +0900
From:      Sangwoo Shim <ssw@neo.redjade.org>
To:        jhb@freebsd.org
Cc:        current@freebsd.org
Subject:   Interrupt storm on acpi0 occurred after madt.c change
Message-ID:  <20040130164001.GA49968@neo.redjade.org>

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

--17pEHd4RhPHOinZp
Content-Type: text/plain; charset=euc-kr
Content-Disposition: inline

Hi.
I've experienced interrupt storm on acpi0 after your v1.10 madt.c commit.
(which is located at src/sys/i386/acpica/madt.c);
What really makes me frustrating is this storm wasn't here before 1.10 change,
which is exactly stand against your commit log message. :-(
I've recompiled kernel with v1.9 of madt.c and the problem didn't occur.

I'm using ASUS P2B-D with two p3-650 processors.
BIOS version is 1014 beta 3 (which is the last published one);

My kernel config is stripped GENERIC, which includes
option	CPU_FASTER_5X86_FPU
option	CPU_ENABLE_SSE
device	acpi		# Mine hangs with acpi loaded as module.

Attached file is my acpidump -t -d output.
Thanks.

--17pEHd4RhPHOinZp
Content-Type: text/plain; charset=euc-kr
Content-Disposition: attachment; filename="ssw.asl"

/*
  RSD PTR: OEM=ASUS, ACPI_Rev=1.0x (0)
	RSDT=0x0fffd000, cksum=135
 */
/*
  RSDT: Length=48, Revision=1, Checksum=24,
	OEMID=ASUS, OEM Table ID=P2B-D, OEM Revision=0x58582e33,
	Creator ID=MSFT, Creator Revision=0x31313031
	Entries={ 0x0fffd100, 0x0fffd040, 0x0fffd080 }
 */
/*
  FADT:	FACS=0xffff000, DSDT=0xfffd180
	INT_MODEL=PIC
	Preferred_PM_Profile=Unspecified (0)
	SCI_INT=9
	SMI_CMD=0xb2, ACPI_ENABLE=0xa1, ACPI_DISABLE=0xa0, S4BIOS_REQ=0x0
	PSTATE_CNT=0x0
	PM1a_EVT_BLK=0xe400-0xe403
	PM1a_CNT_BLK=0xe404-0xe405
	PM_TMR_BLK=0xe408-0xe40b
	GPE0_BLK=0xe40c-0xe40f
	P_LVL2_LAT=190 us, P_LVL3_LAT=1900 us
	FLUSH_SIZE=0, FLUSH_STRIDE=0
	DUTY_OFFSET=1, DUTY_WIDTH=0
	DAY_ALRM=13, MON_ALRM=0, CENTURY=0
	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=7518, Revision=1, Checksum=14,
	OEMID=ASUS, OEM Table ID=P2B-D, OEM Revision=0x1000,
	Creator ID=MSFT, Creator Revision=0x1000001
 */
/*
  BOOT: Length=40, Revision=1, Checksum=62,
	OEMID=ASUS, OEM Table ID=P2B-D, OEM Revision=0x58582e33,
	Creator ID=MSFT, Creator Revision=0x31313031
 */
/*
  APIC: Length=92, Revision=1, Checksum=95,
	OEMID=ASUS, OEM Table ID=P2B-D, OEM Revision=0x58582e33,
	Creator ID=MSFT, Creator Revision=0x31313031
	Local APIC ADDR=0xfee00000
	Flags={PC-AT}

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

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

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

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

	Type=Local APIC
	ACPI CPU=1
	Flags={ENABLED}
	APIC ID=0
 */
/*
 * Intel ACPI Component Architecture
 * AML Disassembler version 20031203
 *
 * Disassembly of /tmp/acpidump.vLE7w8, Sat Jan 31 01:03:38 2004
 */
DefinitionBlock ("DSDT.aml", "DSDT", 1, "ASUS", "P2B-D   ", 4096)
{
    Scope (\_PR)
    {
        Processor (\_PR.CPU, 0x00, 0x00000000, 0x00) {}
        Processor (\_PR.CPU1, 0x01, 0x00000000, 0x00) {}
    }

    Name (\_S0, Package (0x04)
    {
        0x05, 
        0x05, 
        0x00, 
        0x00
    })
    Name (\_S1, Package (0x04)
    {
        0x07, 
        0x07, 
        0x00, 
        0x00
    })
    Name (\_S4, Package (0x04)
    {
        0x06, 
        0x06, 
        0x00, 
        0x00
    })
    Name (\_S5, Package (0x04)
    {
        0x06, 
        0x06, 
        0x00, 
        0x00
    })
    OperationRegion (\DEBG, SystemIO, 0x80, 0x01)
    Field (\DEBG, ByteAcc, NoLock, Preserve)
    {
        DBG1,   8
    }

    OperationRegion (GPOB, SystemIO, 0xE42C, 0x10)
    Field (GPOB, ByteAcc, NoLock, Preserve)
    {
        Offset (0x03), 
        TO12,   1, 
        Offset (0x08), 
        FANM,   1, 
        Offset (0x09), 
        PLED,   1, 
            ,   3, 
            ,   2, 
            ,   16, 
        MSG0,   1
    }

    Name (\PICF, 0x00)
    Method (_PIC, 1, NotSerialized)
    {
        Store (Arg0, \PICF)
    }

    Method (\_PTS, 1, NotSerialized)
    {
        If (LNot (LEqual (Arg0, 0x05)))
        {
            Store (0x00, FANM)
            Store (0x00, PLED)
        }

        If (LEqual (Arg0, 0x01))
        {
            Store (One, TO12)
        }

        If (LEqual (Arg0, 0x02)) {}
        Store (One, TO12)
        Or (Arg0, 0xF0, Local2)
        Store (Local2, DBG1)
    }

    Method (\_WAK, 1, NotSerialized)
    {
        Notify (\_SB.PWRB, 0x02)
        Store (0x01, FANM)
        Store (One, PLED)
        Store (0xFF, DBG1)
    }

    Scope (\_SI)
    {
        Method (_MSG, 1, NotSerialized)
        {
            If (LEqual (Arg0, Zero))
            {
                Store (One, MSG0)
            }
            Else
            {
                Store (Zero, MSG0)
            }
        }
    }

    Scope (\_SB)
    {
        Device (PWRB)
        {
            Name (_HID, EisaId ("PNP0C0C"))
            Method (_STA, 0, NotSerialized)
            {
                Return (0x0B)
            }
        }

        OperationRegion (MGRM, SystemMemory, 0x04E3, 0x02)
        Field (MGRM, WordAcc, NoLock, Preserve)
        {
            MEM0,   16
        }

        Method (MEMS, 0, NotSerialized)
        {
            Return (MEM0)
        }

        Device (MEM)
        {
            Name (_HID, EisaId ("PNP0C01"))
            Method (_CRS, 0, NotSerialized)
            {
                Name (BUF1, Buffer (0x4A)
                {
                    0x86, 0x09, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
                    0x00, 0x00, 0x0A, 0x00, 0x86, 0x09, 0x00, 0x00, 
                    0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x01, 0x00, 
                    0x86, 0x09, 0x00, 0x01, 0x00, 0x00, 0x10, 0x00, 
                    0x00, 0x00, 0x00, 0x00, 0x86, 0x09, 0x00, 0x01, 
                    0x00, 0x00, 0xC0, 0xFE, 0x00, 0x10, 0x00, 0x00, 
                    0x86, 0x09, 0x00, 0x01, 0x00, 0x00, 0xE0, 0xFE, 
                    0x00, 0x10, 0x00, 0x00, 0x86, 0x09, 0x00, 0x00, 
                    0x00, 0x00, 0xFE, 0xFF, 0x00, 0x00, 0x02, 0x00, 
                    0x79, 0x00
                })
                CreateDWordField (BUF1, 0x20, EMLN)
                Store (MEMS (), EMLN)
                ShiftLeft (EMLN, 0x14, EMLN)
                Return (BUF1)
            }
        }

        Device (LNKA)
        {
            Name (_HID, EisaId ("PNP0C0F"))
            Name (_UID, 0x01)
            Method (_STA, 0, NotSerialized)
            {
                And (\_SB.PCI0.PX40.PIRA, 0x8F, Local0)
                If (LLess (Local0, 0x80))
                {
                    Return (0x0B)
                }
                Else
                {
                    Return (0x09)
                }
            }

            Name (_PRS, Buffer (0x06)
            {
                0x23, 0xF8, 0xDE, 0x18, 0x79, 0x00
            })
            Method (_DIS, 0, NotSerialized)
            {
                Store (0x80, \_SB.PCI0.PX40.PIRA)
            }

            Method (_CRS, 0, NotSerialized)
            {
                Name (BUFA, Buffer (0x06)
                {
                    0x23, 0x00, 0x00, 0x18, 0x79, 0x00
                })
                CreateWordField (BUFA, 0x01, IRA)
                And (\_SB.PCI0.PX40.PIRA, 0x8F, Local0)
                If (LLess (Local0, 0x80))
                {
                    And (Local0, 0x0F, Local0)
                    ShiftLeft (One, Local0, Local1)
                    Store (Local1, IRA)
                }

                Return (BUFA)
            }

            Method (_SRS, 1, NotSerialized)
            {
                CreateByteField (Arg0, 0x01, IRA1)
                CreateByteField (Arg0, 0x02, IRA2)
                ShiftLeft (IRA2, 0x08, Local0)
                Or (Local0, IRA1, Local0)
                Store (0x00, Local1)
                ShiftRight (Local0, 0x01, Local0)
                While (LGreater (Local0, 0x00))
                {
                    Increment (Local1)
                    ShiftRight (Local0, 0x01, Local0)
                }

                And (\_SB.PCI0.PX40.PIRA, 0x70, Local0)
                Or (Local1, Local0, \_SB.PCI0.PX40.PIRA)
            }
        }

        Device (LNKB)
        {
            Name (_HID, EisaId ("PNP0C0F"))
            Name (_UID, 0x02)
            Method (_STA, 0, NotSerialized)
            {
                And (\_SB.PCI0.PX40.PIRB, 0x8F, Local0)
                If (LLess (Local0, 0x80))
                {
                    Return (0x0B)
                }
                Else
                {
                    Return (0x09)
                }
            }

            Name (_PRS, Buffer (0x06)
            {
                0x23, 0xF8, 0xDE, 0x18, 0x79, 0x00
            })
            Method (_DIS, 0, NotSerialized)
            {
                Store (0x80, \_SB.PCI0.PX40.PIRB)
            }

            Method (_CRS, 0, NotSerialized)
            {
                Name (BUFB, Buffer (0x06)
                {
                    0x23, 0x00, 0x00, 0x18, 0x79, 0x00
                })
                CreateWordField (BUFB, 0x01, IRB)
                And (\_SB.PCI0.PX40.PIRB, 0x8F, Local0)
                If (LLess (Local0, 0x80))
                {
                    And (Local0, 0x0F, Local0)
                    ShiftLeft (One, Local0, Local1)
                    Store (Local1, IRB)
                }

                Return (BUFB)
            }

            Method (_SRS, 1, NotSerialized)
            {
                CreateByteField (Arg0, 0x01, IRB1)
                CreateByteField (Arg0, 0x02, IRB2)
                ShiftLeft (IRB2, 0x08, Local0)
                Or (Local0, IRB1, Local0)
                Store (0x00, Local1)
                ShiftRight (Local0, 0x01, Local0)
                While (LGreater (Local0, 0x00))
                {
                    Increment (Local1)
                    ShiftRight (Local0, 0x01, Local0)
                }

                And (\_SB.PCI0.PX40.PIRB, 0x70, Local0)
                Or (Local1, Local0, \_SB.PCI0.PX40.PIRB)
            }
        }

        Device (LNKC)
        {
            Name (_HID, EisaId ("PNP0C0F"))
            Name (_UID, 0x03)
            Method (_STA, 0, NotSerialized)
            {
                And (\_SB.PCI0.PX40.PIRC, 0x8F, Local0)
                If (LLess (Local0, 0x80))
                {
                    Return (0x0B)
                }
                Else
                {
                    Return (0x09)
                }
            }

            Name (_PRS, Buffer (0x06)
            {
                0x23, 0xF8, 0xDE, 0x18, 0x79, 0x00
            })
            Method (_DIS, 0, NotSerialized)
            {
                Store (0x80, \_SB.PCI0.PX40.PIRC)
            }

            Method (_CRS, 0, NotSerialized)
            {
                Name (BUFC, Buffer (0x06)
                {
                    0x23, 0x00, 0x00, 0x18, 0x79, 0x00
                })
                CreateWordField (BUFC, 0x01, IRC)
                And (\_SB.PCI0.PX40.PIRC, 0x8F, Local0)
                If (LLess (Local0, 0x80))
                {
                    And (Local0, 0x0F, Local0)
                    ShiftLeft (One, Local0, Local1)
                    Store (Local1, IRC)
                }

                Return (BUFC)
            }

            Method (_SRS, 1, NotSerialized)
            {
                CreateByteField (Arg0, 0x01, IRC1)
                CreateByteField (Arg0, 0x02, IRC2)
                ShiftLeft (IRC2, 0x08, Local0)
                Or (Local0, IRC1, Local0)
                Store (0x00, Local1)
                ShiftRight (Local0, 0x01, Local0)
                While (LGreater (Local0, 0x00))
                {
                    Increment (Local1)
                    ShiftRight (Local0, 0x01, Local0)
                }

                And (\_SB.PCI0.PX40.PIRC, 0x70, Local0)
                Or (Local1, Local0, \_SB.PCI0.PX40.PIRC)
            }
        }

        Device (LNKD)
        {
            Name (_HID, EisaId ("PNP0C0F"))
            Name (_UID, 0x04)
            Method (_STA, 0, NotSerialized)
            {
                And (\_SB.PCI0.PX40.PIRD, 0x8F, Local0)
                If (LLess (Local0, 0x80))
                {
                    Return (0x0B)
                }
                Else
                {
                    Return (0x09)
                }
            }

            Name (_PRS, Buffer (0x06)
            {
                0x23, 0xF8, 0xDE, 0x18, 0x79, 0x00
            })
            Method (_DIS, 0, NotSerialized)
            {
                Store (0x80, \_SB.PCI0.PX40.PIRD)
            }

            Method (_CRS, 0, NotSerialized)
            {
                Name (BUFD, Buffer (0x06)
                {
                    0x23, 0x00, 0x00, 0x18, 0x79, 0x00
                })
                CreateWordField (BUFD, 0x01, IRD)
                And (\_SB.PCI0.PX40.PIRD, 0x8F, Local0)
                If (LLess (Local0, 0x80))
                {
                    And (Local0, 0x0F, Local0)
                    ShiftLeft (One, Local0, Local1)
                    Store (Local1, IRD)
                }

                Return (BUFD)
            }

            Method (_SRS, 1, NotSerialized)
            {
                CreateByteField (Arg0, 0x01, IRD1)
                CreateByteField (Arg0, 0x02, IRD2)
                ShiftLeft (IRD2, 0x08, Local0)
                Or (Local0, IRD1, Local0)
                Store (0x00, Local1)
                ShiftRight (Local0, 0x01, Local0)
                While (LGreater (Local0, 0x00))
                {
                    Increment (Local1)
                    ShiftRight (Local0, 0x01, Local0)
                }

                And (\_SB.PCI0.PX40.PIRD, 0x70, Local0)
                Or (Local1, Local0, \_SB.PCI0.PX40.PIRD)
            }
        }

        Device (PCI0)
        {
            Name (_HID, EisaId ("PNP0A03"))
            Name (_ADR, 0x00)
            Name (CRES, Buffer (0x88)
            {
                0x88, 0x0D, 0x00, 0x02, 0x0C, 0x00, 0x00, 0x00, 
                0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x01, 
                0x47, 0x01, 0xF8, 0x0C, 0xF8, 0x0C, 0x01, 0x08, 
                0x88, 0x0D, 0x00, 0x01, 0x0C, 0x03, 0x00, 0x00, 
                0x00, 0x00, 0xF7, 0x0C, 0x00, 0x00, 0xF8, 0x0C, 
                0x88, 0x0D, 0x00, 0x01, 0x0C, 0x03, 0x00, 0x00, 
                0x00, 0x0D, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0xF3, 
                0x87, 0x17, 0x00, 0x00, 0x0C, 0x03, 0x00, 0x00, 
                0x00, 0x00, 0x00, 0x00, 0x0A, 0x00, 0xFF, 0xFF, 
                0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                0x02, 0x00, 0x87, 0x17, 0x00, 0x00, 0x0C, 0x03, 
                0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x0C, 0x00, 
                0xFF, 0xFF, 0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 
                0x00, 0x80, 0x01, 0x00, 0x87, 0x17, 0x00, 0x00, 
                0x0C, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                0x10, 0x00, 0xFF, 0xFF, 0xFD, 0xFF, 0x00, 0x00, 
                0x00, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x79, 0x00
            })
            Method (_CRS, 0, NotSerialized)
            {
                CreateDWordField (CRES, 0x76, RAMT)
                CreateDWordField (CRES, 0x82, RAMR)
                Add (MEMS (), 0x01, RAMT)
                ShiftLeft (RAMT, 0x14, RAMT)
                Subtract (0xFFFE0000, RAMT, RAMR)
                Return (CRES)
            }

            Name (PICM, Package (0x18)
            {
                Package (0x04)
                {
                    0x000CFFFF, 
                    0x00, 
                    \_SB.LNKA, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000CFFFF, 
                    0x01, 
                    \_SB.LNKB, 
                    0x00
                }, 

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

                Package (0x04)
                {
                    0x000CFFFF, 
                    0x03, 
                    \_SB.LNKD, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000BFFFF, 
                    0x00, 
                    \_SB.LNKB, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000BFFFF, 
                    0x01, 
                    \_SB.LNKC, 
                    0x00
                }, 

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

                Package (0x04)
                {
                    0x000BFFFF, 
                    0x03, 
                    \_SB.LNKA, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000AFFFF, 
                    0x00, 
                    \_SB.LNKC, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000AFFFF, 
                    0x01, 
                    \_SB.LNKD, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000AFFFF, 
                    0x02, 
                    \_SB.LNKA, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000AFFFF, 
                    0x03, 
                    \_SB.LNKB, 
                    0x00
                }, 

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

                Package (0x04)
                {
                    0x0009FFFF, 
                    0x01, 
                    \_SB.LNKA, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0009FFFF, 
                    0x02, 
                    \_SB.LNKB, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0009FFFF, 
                    0x03, 
                    \_SB.LNKC, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0004FFFF, 
                    0x00, 
                    \_SB.LNKA, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0004FFFF, 
                    0x01, 
                    \_SB.LNKB, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0004FFFF, 
                    0x02, 
                    \_SB.LNKC, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0004FFFF, 
                    0x03, 
                    \_SB.LNKD, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0001FFFF, 
                    0x00, 
                    \_SB.LNKA, 
                    0x00
                }, 

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

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

                Package (0x04)
                {
                    0x0001FFFF, 
                    0x03, 
                    \_SB.LNKD, 
                    0x00
                }
            })
            Name (APIC, Package (0x18)
            {
                Package (0x04)
                {
                    0x000CFFFF, 
                    0x00, 
                    0x00, 
                    0x10
                }, 

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

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

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

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

                Package (0x04)
                {
                    0x000BFFFF, 
                    0x01, 
                    0x00, 
                    0x12
                }, 

                Package (0x04)
                {
                    0x000BFFFF, 
                    0x02, 
                    0x00, 
                    0x13
                }, 

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

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

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

                Package (0x04)
                {
                    0x000AFFFF, 
                    0x02, 
                    0x00, 
                    0x10
                }, 

                Package (0x04)
                {
                    0x000AFFFF, 
                    0x03, 
                    0x00, 
                    0x11
                }, 

                Package (0x04)
                {
                    0x0009FFFF, 
                    0x00, 
                    0x00, 
                    0x13
                }, 

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

                Package (0x04)
                {
                    0x0009FFFF, 
                    0x02, 
                    0x00, 
                    0x11
                }, 

                Package (0x04)
                {
                    0x0009FFFF, 
                    0x03, 
                    0x00, 
                    0x12
                }, 

                Package (0x04)
                {
                    0x0004FFFF, 
                    0x00, 
                    0x00, 
                    0x10
                }, 

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

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

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

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

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

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

                Package (0x04)
                {
                    0x0001FFFF, 
                    0x03, 
                    0x00, 
                    0x13
                }
            })
            Method (_PRT, 0, NotSerialized)
            {
                If (LNot (\PICF))
                {
                    Return (PICM)
                }
                Else
                {
                    Return (APIC)
                }
            }

            Device (PX40)
            {
                Name (_ADR, 0x00040000)
                OperationRegion (PIRQ, PCI_Config, 0x60, 0x04)
                Field (PIRQ, ByteAcc, NoLock, Preserve)
                {
                    PIRA,   8, 
                    PIRB,   8, 
                    PIRC,   8, 
                    PIRD,   8
                }

                Device (SYSR)
                {
                    Name (_HID, EisaId ("PNP0C02"))
                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (BUF1, Buffer (0x72)
                        {
                            0x47, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x40, 
                            0x47, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x10, 
                            0x47, 0x01, 0x94, 0x02, 0x94, 0x02, 0x01, 0x04, 
                            0x47, 0x01, 0x10, 0x00, 0x10, 0x00, 0x01, 0x10, 
                            0x47, 0x01, 0x22, 0x00, 0x22, 0x00, 0x01, 0x1E, 
                            0x47, 0x01, 0x44, 0x00, 0x44, 0x00, 0x01, 0x1C, 
                            0x47, 0x01, 0x62, 0x00, 0x62, 0x00, 0x01, 0x02, 
                            0x47, 0x01, 0x65, 0x00, 0x65, 0x00, 0x01, 0x0B, 
                            0x47, 0x01, 0x74, 0x00, 0x74, 0x00, 0x01, 0x0C, 
                            0x47, 0x01, 0x91, 0x00, 0x91, 0x00, 0x01, 0x03, 
                            0x47, 0x01, 0xA2, 0x00, 0xA2, 0x00, 0x01, 0x1E, 
                            0x47, 0x01, 0xE0, 0x00, 0xE0, 0x00, 0x01, 0x10, 
                            0x47, 0x01, 0xF0, 0x03, 0xF0, 0x03, 0x01, 0x02, 
                            0x47, 0x01, 0xD0, 0x04, 0xD0, 0x04, 0x01, 0x02, 
                            0x79, 0x00
                        })
                        CreateByteField (BUF1, 0x02, PMLO)
                        CreateByteField (BUF1, 0x03, PMHI)
                        CreateByteField (BUF1, 0x04, PMRL)
                        CreateByteField (BUF1, 0x05, PMRH)
                        CreateByteField (BUF1, 0x0A, SBLO)
                        CreateByteField (BUF1, 0x0B, SBHI)
                        CreateByteField (BUF1, 0x0C, SBRL)
                        CreateByteField (BUF1, 0x0D, SBRH)
                        Store (\_SB.PCI0.PX43.PM00, Local0)
                        And (Local0, 0xFE, PMLO)
                        Store (\_SB.PCI0.PX43.PM01, PMHI)
                        Store (\_SB.PCI0.PX43.SB00, Local0)
                        And (Local0, 0xFE, SBLO)
                        Store (\_SB.PCI0.PX43.SB01, SBHI)
                        Store (PMLO, PMRL)
                        Store (PMHI, PMRH)
                        Store (SBLO, SBRL)
                        Store (SBHI, SBRH)
                        Return (BUF1)
                    }
                }

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

                Device (DMA1)
                {
                    Name (_HID, EisaId ("PNP0200"))
                    Name (_CRS, Buffer (0x25)
                    {
                        0x2A, 0x10, 0x04, 0x47, 0x01, 0x00, 0x00, 0x00, 
                        0x00, 0x01, 0x10, 0x47, 0x01, 0x80, 0x00, 0x80, 
                        0x00, 0x01, 0x11, 0x47, 0x01, 0x94, 0x00, 0x94, 
                        0x00, 0x01, 0x0C, 0x47, 0x01, 0xC0, 0x00, 0xC0, 
                        0x00, 0x01, 0x20, 0x79, 0x00
                    })
                }

                Device (TMR)
                {
                    Name (_HID, EisaId ("PNP0100"))
                    Name (_CRS, Buffer (0x0D)
                    {
                        0x47, 0x01, 0x40, 0x00, 0x40, 0x00, 0x01, 0x04, 
                        0x22, 0x01, 0x00, 0x79, 0x00
                    })
                }

                Device (RTC)
                {
                    Name (_HID, EisaId ("PNP0B00"))
                    Name (_CRS, Buffer (0x0D)
                    {
                        0x47, 0x01, 0x70, 0x00, 0x70, 0x00, 0x01, 0x04, 
                        0x22, 0x00, 0x01, 0x79, 0x00
                    })
                }

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

                Device (COPR)
                {
                    Name (_HID, EisaId ("PNP0C04"))
                    Name (_CRS, Buffer (0x0D)
                    {
                        0x47, 0x01, 0xF0, 0x00, 0xF0, 0x00, 0x01, 0x10, 
                        0x22, 0x00, 0x20, 0x79, 0x00
                    })
                }

                OperationRegion (W977, SystemIO, 0x03F0, 0x02)
                Field (W977, ByteAcc, NoLock, Preserve)
                {
                    NIDX,   8, 
                    NDAT,   8
                }

                IndexField (NIDX, NDAT, ByteAcc, NoLock, Preserve)
                {
                    Offset (0x07), 
                    LDNM,   8, 
                    Offset (0x20), 
                    DEVI,   8, 
                    DEVR,   8, 
                    Offset (0x30), 
                    ACTR,   8, 
                    Offset (0x60), 
                    IOAH,   8, 
                    IOAL,   8, 
                    IOBH,   8, 
                    IOBL,   8, 
                    Offset (0x70), 
                    INTR,   8, 
                    Offset (0x72), 
                    INRQ,   8, 
                    Offset (0x74), 
                    DMCH,   8, 
                    Offset (0xE0), 
                    MSWK,   8, 
                    Offset (0xE4), 
                    KBWK,   8, 
                    Offset (0xF0), 
                    OPT1,   8, 
                    OPT2,   8
                }

                Method (ENFG, 0, NotSerialized)
                {
                    Store (0x00, Local0)
                    Store (0x11, Local1)
                    While (LNot (LEqual (Local0, 0x71)))
                    {
                        Store (0x87, NIDX)
                        Store (0x87, NIDX)
                        If (LOr (LEqual (DEVI, 0x97), LEqual (DEVI, 0x52)))
                        {
                            Store (0x71, Local0)
                        }

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

                Method (EXFG, 0, NotSerialized)
                {
                    Store (0xAA, NIDX)
                }

                Device (FDC0)
                {
                    Name (_HID, EisaId ("PNP0700"))
                    Method (_STA, 0, NotSerialized)
                    {
                        ENFG ()
                        Store (Zero, LDNM)
                        If (ACTR)
                        {
                            EXFG ()
                            Return (0x0F)
                        }
                        Else
                        {
                            EXFG ()
                            Return (0x0D)
                        }
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        ENFG ()
                        Store (Zero, LDNM)
                        Store (Zero, ACTR)
                        EXFG ()
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (BUF0, Buffer (0x19)
                        {
                            0x47, 0x01, 0xF2, 0x03, 0xF2, 0x03, 0x00, 0x04, 
                            0x47, 0x01, 0xF7, 0x03, 0xF7, 0x03, 0x00, 0x01, 
                            0x23, 0x40, 0x00, 0x01, 0x2A, 0x04, 0x00, 0x79, 
                            0x00
                        })
                        CreateWordField (BUF0, 0x11, IRQW)
                        CreateByteField (BUF0, 0x15, DMAV)
                        ENFG ()
                        Store (Zero, LDNM)
                        Store (One, Local0)
                        ShiftLeft (Local0, INTR, IRQW)
                        Store (One, Local0)
                        ShiftLeft (Local0, DMCH, DMAV)
                        EXFG ()
                        Return (BUF0)
                    }

                    Name (_PRS, Buffer (0x19)
                    {
                        0x47, 0x01, 0xF2, 0x03, 0xF2, 0x03, 0x00, 0x04, 
                        0x47, 0x01, 0xF7, 0x03, 0xF7, 0x03, 0x00, 0x01, 
                        0x23, 0x40, 0x00, 0x01, 0x2A, 0x04, 0x00, 0x79, 
                        0x00
                    })
                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateByteField (Arg0, 0x02, IOLO)
                        CreateByteField (Arg0, 0x03, IOHI)
                        CreateWordField (Arg0, 0x11, IRQW)
                        CreateByteField (Arg0, 0x15, DMAV)
                        ENFG ()
                        Store (Zero, LDNM)
                        And (IOLO, 0xF8, IOAL)
                        Store (IOHI, IOAH)
                        FindSetRightBit (IRQW, Local0)
                        Decrement (Local0)
                        Store (Local0, INTR)
                        FindSetRightBit (DMAV, Local0)
                        Decrement (Local0)
                        Store (Local0, DMCH)
                        Store (One, ACTR)
                        EXFG ()
                    }
                }

                Device (LPT)
                {
                    Name (_HID, EisaId ("PNP0400"))
                    Method (_STA, 0, NotSerialized)
                    {
                        ENFG ()
                        Store (0x01, LDNM)
                        And (OPT1, 0x02, Local0)
                        If (LOr (IOAH, IOAL))
                        {
                            If (LEqual (Local0, 0x02))
                            {
                                EXFG ()
                                Return (0x00)
                            }
                            Else
                            {
                                If (ACTR)
                                {
                                    EXFG ()
                                    Return (0x0F)
                                }
                                Else
                                {
                                    EXFG ()
                                    Return (0x0D)
                                }
                            }
                        }

                        EXFG ()
                        Return (0x00)
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        ENFG ()
                        Store (0x01, LDNM)
                        Store (Zero, ACTR)
                        EXFG ()
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (BUF5, Buffer (0x0E)
                        {
                            0x47, 0x01, 0x78, 0x03, 0x78, 0x03, 0x00, 0x04, 
                            0x23, 0x80, 0x00, 0x01, 0x79, 0x00
                        })
                        CreateByteField (BUF5, 0x02, IOLO)
                        CreateByteField (BUF5, 0x03, IOHI)
                        CreateByteField (BUF5, 0x04, IORL)
                        CreateByteField (BUF5, 0x05, IORH)
                        CreateWordField (BUF5, 0x09, IRQW)
                        ENFG ()
                        Store (0x01, LDNM)
                        Store (IOAL, IOLO)
                        Store (IOAL, IORL)
                        Store (IOAH, IOHI)
                        Store (IOAH, IORH)
                        Store (One, Local0)
                        ShiftLeft (Local0, INTR, IRQW)
                        EXFG ()
                        Return (BUF5)
                    }

                    Name (_PRS, Buffer (0x2D)
                    {
                        0x31, 0x05, 0x47, 0x01, 0x78, 0x03, 0x78, 0x03, 
                        0x00, 0x08, 0x23, 0xA0, 0x00, 0x01, 0x31, 0x05, 
                        0x47, 0x01, 0x78, 0x02, 0x78, 0x02, 0x00, 0x08, 
                        0x23, 0xA0, 0x00, 0x01, 0x31, 0x05, 0x47, 0x01, 
                        0xBC, 0x03, 0xBC, 0x03, 0x00, 0x04, 0x23, 0xA0, 
                        0x00, 0x01, 0x38, 0x79, 0x00
                    })
                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateByteField (Arg0, 0x02, IOLO)
                        CreateByteField (Arg0, 0x03, IOHI)
                        CreateWordField (Arg0, 0x09, IRQW)
                        ENFG ()
                        Store (0x01, LDNM)
                        Store (IOLO, IOAL)
                        Store (IOHI, IOAH)
                        FindSetRightBit (IRQW, Local0)
                        Decrement (Local0)
                        Store (Local0, INTR)
                        Store (One, ACTR)
                        EXFG ()
                    }
                }

                Device (ECP)
                {
                    Name (_HID, EisaId ("PNP0401"))
                    Method (_STA, 0, NotSerialized)
                    {
                        ENFG ()
                        Store (0x01, LDNM)
                        And (OPT1, 0x02, Local0)
                        If (LOr (IOAH, IOAL))
                        {
                            If (LEqual (Local0, 0x02))
                            {
                                If (ACTR)
                                {
                                    EXFG ()
                                    Return (0x0F)
                                }
                                Else
                                {
                                    EXFG ()
                                    Return (0x05)
                                }
                            }
                            Else
                            {
                                EXFG ()
                                Return (0x00)
                            }
                        }

                        EXFG ()
                        Return (0x00)
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        ENFG ()
                        Store (0x01, LDNM)
                        Store (Zero, ACTR)
                        EXFG ()
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (BUF6, Buffer (0x19)
                        {
                            0x47, 0x01, 0x78, 0x03, 0x78, 0x03, 0x00, 0x04, 
                            0x47, 0x01, 0x78, 0x07, 0x78, 0x07, 0x00, 0x04, 
                            0x23, 0x80, 0x00, 0x01, 0x2A, 0x02, 0x00, 0x79, 
                            0x00
                        })
                        CreateByteField (BUF6, 0x02, IOLO)
                        CreateByteField (BUF6, 0x03, IOHI)
                        CreateByteField (BUF6, 0x04, IORL)
                        CreateByteField (BUF6, 0x05, IORH)
                        CreateByteField (BUF6, 0x0A, I2LO)
                        CreateByteField (BUF6, 0x0B, I2HI)
                        CreateByteField (BUF6, 0x0C, I2RL)
                        CreateByteField (BUF6, 0x0D, I2RH)
                        CreateWordField (BUF6, 0x11, IRQW)
                        CreateByteField (BUF6, 0x15, DMAC)
                        ENFG ()
                        Store (0x01, LDNM)
                        Store (IOAL, IOLO)
                        Store (IOAL, IORL)
                        Store (IOLO, I2LO)
                        Store (IOLO, I2RL)
                        Store (IOAH, IORH)
                        Store (IOAH, IOHI)
                        Add (IOHI, 0x04, I2HI)
                        Add (IOHI, 0x04, I2RH)
                        Store (One, Local0)
                        ShiftLeft (Local0, INTR, IRQW)
                        Store (One, Local0)
                        ShiftLeft (Local0, DMCH, DMAC)
                        EXFG ()
                        Return (BUF6)
                    }

                    Name (_PRS, Buffer (0x4E)
                    {
                        0x31, 0x05, 0x47, 0x01, 0x78, 0x03, 0x78, 0x03, 
                        0x00, 0x04, 0x47, 0x01, 0x78, 0x07, 0x78, 0x07, 
                        0x00, 0x04, 0x23, 0xA0, 0x00, 0x01, 0x2A, 0x0B, 
                        0x00, 0x31, 0x05, 0x47, 0x01, 0x78, 0x02, 0x78, 
                        0x02, 0x00, 0x04, 0x47, 0x01, 0x78, 0x06, 0x78, 
                        0x06, 0x00, 0x04, 0x23, 0xA0, 0x00, 0x01, 0x2A, 
                        0x0B, 0x00, 0x31, 0x05, 0x47, 0x01, 0xBC, 0x03, 
                        0xBC, 0x03, 0x00, 0x04, 0x47, 0x01, 0xBC, 0x07, 
                        0xBC, 0x07, 0x00, 0x04, 0x23, 0xA0, 0x00, 0x01, 
                        0x2A, 0x0B, 0x00, 0x38, 0x79, 0x00
                    })
                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateByteField (Arg0, 0x02, IOLO)
                        CreateByteField (Arg0, 0x03, IOHI)
                        CreateWordField (Arg0, 0x11, IRQW)
                        CreateByteField (Arg0, 0x15, DMAC)
                        ENFG ()
                        Store (0x01, LDNM)
                        Store (IOLO, IOAL)
                        Store (IOHI, IOAH)
                        FindSetRightBit (IRQW, Local0)
                        Decrement (Local0)
                        Store (Local0, INTR)
                        FindSetRightBit (DMAC, Local0)
                        Decrement (Local0)
                        Store (Local0, DMCH)
                        Store (One, ACTR)
                        EXFG ()
                    }
                }

                Device (UAR1)
                {
                    Name (_HID, EisaId ("PNP0501"))
                    Name (_UID, 0x01)
                    Method (_STA, 0, NotSerialized)
                    {
                        ENFG ()
                        Store (0x02, LDNM)
                        If (LOr (IOAH, IOAL))
                        {
                            If (ACTR)
                            {
                                EXFG ()
                                Return (0x0F)
                            }
                            Else
                            {
                                EXFG ()
                                Return (0x0D)
                            }
                        }

                        EXFG ()
                        Return (0x00)
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        ENFG ()
                        Store (0x02, LDNM)
                        Store (Zero, ACTR)
                        EXFG ()
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (BUF1, Buffer (0x0E)
                        {
                            0x47, 0x01, 0xF8, 0x03, 0xF8, 0x03, 0x00, 0x08, 
                            0x23, 0x10, 0x00, 0x01, 0x79, 0x00
                        })
                        CreateByteField (BUF1, 0x02, IOLO)
                        CreateByteField (BUF1, 0x03, IOHI)
                        CreateByteField (BUF1, 0x04, IORL)
                        CreateByteField (BUF1, 0x05, IORH)
                        CreateWordField (BUF1, 0x09, IRQW)
                        ENFG ()
                        Store (0x02, LDNM)
                        Store (IOAL, IOLO)
                        Store (IOAL, IORL)
                        Store (IOAH, IOHI)
                        Store (IOAH, IORH)
                        Store (One, Local0)
                        ShiftLeft (Local0, INTR, IRQW)
                        EXFG ()
                        Return (BUF1)
                    }

                    Name (_PRS, Buffer (0x49)
                    {
                        0x31, 0x05, 0x47, 0x01, 0xF8, 0x03, 0xF8, 0x03, 
                        0x00, 0x08, 0x23, 0x10, 0x00, 0x01, 0x31, 0x05, 
                        0x47, 0x01, 0xF8, 0x02, 0xF8, 0x02, 0x00, 0x08, 
                        0x23, 0x08, 0x00, 0x01, 0x31, 0x05, 0x47, 0x01, 
                        0xE8, 0x03, 0xE8, 0x03, 0x00, 0x08, 0x23, 0x10, 
                        0x00, 0x01, 0x31, 0x05, 0x47, 0x01, 0xE8, 0x02, 
                        0xE8, 0x02, 0x00, 0x08, 0x23, 0x08, 0x00, 0x01, 
                        0x31, 0x05, 0x47, 0x01, 0xE8, 0x02, 0xF8, 0x03, 
                        0x00, 0x08, 0x23, 0xB8, 0x14, 0x01, 0x38, 0x79, 
                        0x00
                    })
                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateByteField (Arg0, 0x02, IOLO)
                        CreateByteField (Arg0, 0x03, IOHI)
                        CreateWordField (Arg0, 0x09, IRQW)
                        ENFG ()
                        Store (0x02, LDNM)
                        Store (IOLO, IOAL)
                        Store (IOHI, IOAH)
                        FindSetRightBit (IRQW, Local0)
                        Decrement (Local0)
                        Store (Local0, INTR)
                        Store (One, ACTR)
                        EXFG ()
                    }

                    Name (_PRW, Package (0x02)
                    {
                        0x0A, 
                        0x01
                    })
                }

                Device (UAR2)
                {
                    Name (_HID, EisaId ("PNP0501"))
                    Name (_UID, 0x02)
                    Method (_STA, 0, NotSerialized)
                    {
                        ENFG ()
                        Store (0x03, LDNM)
                        If (LOr (IOAH, IOAL))
                        {
                            If (LAnd (LEqual (DEVI, 0x97), LEqual (DEVR, 0x71)))
                            {
                                If (ACTR)
                                {
                                    EXFG ()
                                    Return (0x0F)
                                }
                                Else
                                {
                                    EXFG ()
                                    Return (0x0D)
                                }
                            }
                            Else
                            {
                                If (LNot (LEqual (OPT2, Zero)))
                                {
                                    EXFG ()
                                    Return (Zero)
                                }
                                Else
                                {
                                    If (ACTR)
                                    {
                                        EXFG ()
                                        Return (0x0F)
                                    }
                                    Else
                                    {
                                        EXFG ()
                                        Return (0x0D)
                                    }
                                }
                            }
                        }

                        EXFG ()
                        Return (0x00)
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        ENFG ()
                        Store (0x03, LDNM)
                        Store (Zero, ACTR)
                        EXFG ()
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (BUF1, Buffer (0x0E)
                        {
                            0x47, 0x01, 0xF8, 0x02, 0xF8, 0x02, 0x00, 0x08, 
                            0x23, 0x08, 0x00, 0x01, 0x79, 0x00
                        })
                        CreateByteField (BUF1, 0x02, IOLO)
                        CreateByteField (BUF1, 0x03, IOHI)
                        CreateByteField (BUF1, 0x04, IORL)
                        CreateByteField (BUF1, 0x05, IORH)
                        CreateWordField (BUF1, 0x09, IRQW)
                        ENFG ()
                        Store (0x03, LDNM)
                        Store (IOAL, IOLO)
                        Store (IOAL, IORL)
                        Store (IOAH, IOHI)
                        Store (IOAH, IORH)
                        Store (One, Local0)
                        ShiftLeft (Local0, INTR, IRQW)
                        EXFG ()
                        Return (BUF1)
                    }

                    Name (_PRS, Buffer (0x49)
                    {
                        0x31, 0x05, 0x47, 0x01, 0xF8, 0x02, 0xF8, 0x02, 
                        0x00, 0x08, 0x23, 0x08, 0x00, 0x01, 0x31, 0x05, 
                        0x47, 0x01, 0xF8, 0x03, 0xF8, 0x03, 0x00, 0x08, 
                        0x23, 0x10, 0x00, 0x01, 0x31, 0x05, 0x47, 0x01, 
                        0xE8, 0x02, 0xE8, 0x02, 0x00, 0x08, 0x23, 0x08, 
                        0x00, 0x01, 0x31, 0x05, 0x47, 0x01, 0xE8, 0x03, 
                        0xE8, 0x03, 0x00, 0x08, 0x23, 0x10, 0x00, 0x01, 
                        0x31, 0x05, 0x47, 0x01, 0xE8, 0x02, 0xF8, 0x03, 
                        0x00, 0x08, 0x23, 0xB8, 0x14, 0x01, 0x38, 0x79, 
                        0x00
                    })
                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateByteField (Arg0, 0x02, IOLO)
                        CreateByteField (Arg0, 0x03, IOHI)
                        CreateWordField (Arg0, 0x09, IRQW)
                        ENFG ()
                        Store (0x03, LDNM)
                        Store (IOLO, IOAL)
                        Store (IOHI, IOAH)
                        FindSetRightBit (IRQW, Local0)
                        Decrement (Local0)
                        Store (Local0, INTR)
                        Store (One, ACTR)
                        EXFG ()
                    }

                    Name (_PRW, Package (0x02)
                    {
                        0x0A, 
                        0x01
                    })
                }

                Device (IRDA)
                {
                    Name (_HID, EisaId ("PNP0510"))
                    Method (_STA, 0, NotSerialized)
                    {
                        ENFG ()
                        If (LAnd (LEqual (DEVI, 0x97), LEqual (DEVR, 0x71)))
                        {
                            Store (0x06, LDNM)
                            If (ACTR)
                            {
                                EXFG ()
                                Return (0x0F)
                            }
                            Else
                            {
                                If (LOr (IOAH, IOAL))
                                {
                                    EXFG ()
                                    Return (0x05)
                                }
                                Else
                                {
                                    EXFG ()
                                    Return (0x00)
                                }
                            }
                        }
                        Else
                        {
                            Store (0x03, LDNM)
                            If (LOr (IOAH, IOAL))
                            {
                                If (OPT2)
                                {
                                    If (ACTR)
                                    {
                                        EXFG ()
                                        Return (0x0F)
                                    }
                                    Else
                                    {
                                        EXFG ()
                                        Return (0x05)
                                    }
                                }
                            }

                            EXFG ()
                            Return (0x00)
                        }
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        ENFG ()
                        If (LAnd (LEqual (DEVI, 0x97), LEqual (DEVR, 0x71)))
                        {
                            Store (0x06, LDNM)
                        }
                        Else
                        {
                            Store (0x03, LDNM)
                        }

                        Store (Zero, ACTR)
                        EXFG ()
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (BUF1, Buffer (0x0E)
                        {
                            0x47, 0x01, 0xF8, 0x02, 0xF8, 0x02, 0x00, 0x08, 
                            0x23, 0x08, 0x00, 0x01, 0x79, 0x00
                        })
                        CreateByteField (BUF1, 0x02, IOLO)
                        CreateByteField (BUF1, 0x03, IOHI)
                        CreateByteField (BUF1, 0x04, IORL)
                        CreateByteField (BUF1, 0x05, IORH)
                        CreateWordField (BUF1, 0x09, IRQW)
                        ENFG ()
                        If (LAnd (LEqual (DEVI, 0x97), LEqual (DEVR, 0x71)))
                        {
                            Store (0x06, LDNM)
                        }
                        Else
                        {
                            Store (0x03, LDNM)
                        }

                        Store (IOAL, IOLO)
                        Store (IOAL, IORL)
                        Store (IOAH, IOHI)
                        Store (IOAH, IORH)
                        Store (One, Local0)
                        ShiftLeft (Local0, INTR, IRQW)
                        EXFG ()
                        Return (BUF1)
                    }

                    Name (_PRS, Buffer (0x49)
                    {
                        0x31, 0x05, 0x47, 0x01, 0xF8, 0x02, 0xF8, 0x02, 
                        0x00, 0x08, 0x23, 0x08, 0x00, 0x01, 0x31, 0x05, 
                        0x47, 0x01, 0xF8, 0x03, 0xF8, 0x03, 0x00, 0x08, 
                        0x23, 0x10, 0x00, 0x01, 0x31, 0x05, 0x47, 0x01, 
                        0xE8, 0x02, 0xE8, 0x02, 0x00, 0x08, 0x23, 0x08, 
                        0x00, 0x01, 0x31, 0x05, 0x47, 0x01, 0xE8, 0x03, 
                        0xE8, 0x03, 0x00, 0x08, 0x23, 0x10, 0x00, 0x01, 
                        0x31, 0x05, 0x47, 0x01, 0xE8, 0x02, 0xF8, 0x03, 
                        0x00, 0x08, 0x23, 0xB8, 0x14, 0x01, 0x38, 0x79, 
                        0x00
                    })
                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateByteField (Arg0, 0x02, IOLO)
                        CreateByteField (Arg0, 0x03, IOHI)
                        CreateWordField (Arg0, 0x09, IRQW)
                        ENFG ()
                        If (LAnd (LEqual (DEVI, 0x97), LEqual (DEVR, 0x71)))
                        {
                            Store (0x06, LDNM)
                        }
                        Else
                        {
                            Store (0x03, LDNM)
                        }

                        Store (IOLO, IOAL)
                        Store (IOHI, IOAH)
                        FindSetRightBit (IRQW, Local0)
                        Decrement (Local0)
                        Store (Local0, INTR)
                        Store (One, ACTR)
                        EXFG ()
                    }
                }

                OperationRegion (KBC1, SystemIO, 0x64, 0x01)
                Field (KBC1, ByteAcc, NoLock, Preserve)
                {
                    KBIN,   8
                }

                OperationRegion (KBC2, SystemIO, 0x60, 0x01)
                Field (KBC2, ByteAcc, NoLock, Preserve)
                {
                    KBDA,   8
                }

                Device (PS2K)
                {
                    Name (_HID, EisaId ("PNP0303"))
                    Method (_STA, 0, NotSerialized)
                    {
                        ENFG ()
                        Store (0x05, LDNM)
                        And (INTR, 0x0F, Local0)
                        If (LNot (LEqual (Local0, 0x00)))
                        {
                            EXFG ()
                            Return (0x0F)
                        }
                        Else
                        {
                            EXFG ()
                            Return (0x05)
                        }
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (BUF0, Buffer (0x16)
                        {
                            0x47, 0x01, 0x60, 0x00, 0x60, 0x00, 0x00, 0x01, 
                            0x47, 0x01, 0x64, 0x00, 0x64, 0x00, 0x00, 0x01, 
                            0x23, 0x02, 0x00, 0x01, 0x79, 0x00
                        })
                        Return (BUF0)
                    }
                }

                Device (PS2M)
                {
                    Name (_HID, EisaId ("PNP0F13"))
                    Method (_STA, 0, NotSerialized)
                    {
                        ENFG ()
                        Store (0x05, LDNM)
                        And (INRQ, 0x0F, Local0)
                        If (LEqual (Local0, 0x00))
                        {
                            EXFG ()
                            Return (0x00)
                        }
                        Else
                        {
                            If (LEqual (Local0, 0x02))
                            {
                                EXFG ()
                                Return (0x0D)
                            }
                            Else
                            {
                                EXFG ()
                                Return (0x0F)
                            }
                        }
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        And (0x03, KBIN, Local0)
                        While (Local0)
                        {
                            Store (KBDA, Local1)
                            And (0x03, KBIN, Local0)
                        }

                        Store (0xA7, KBIN)
                        ENFG ()
                        Store (0x05, LDNM)
                        Store (0x02, INRQ)
                        And (INTR, 0x0F, Local0)
                        If (LEqual (Local0, 0x00))
                        {
                            Store (Zero, ACTR)
                        }

                        EXFG ()
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (BUF0, Buffer (0x06)
                        {
                            0x23, 0x00, 0x10, 0x01, 0x79, 0x00
                        })
                        CreateWordField (BUF0, 0x01, IRQW)
                        ENFG ()
                        Store (0x05, LDNM)
                        Store (One, Local0)
                        ShiftLeft (Local0, INRQ, IRQW)
                        EXFG ()
                        Return (BUF0)
                    }

                    Name (_PRS, Buffer (0x06)
                    {
                        0x23, 0xB8, 0x14, 0x01, 0x79, 0x00
                    })
                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQW)
                        And (0x03, KBIN, Local0)
                        While (Local0)
                        {
                            Store (KBDA, Local1)
                            And (0x03, KBIN, Local0)
                        }

                        Store (0xA8, KBIN)
                        ENFG ()
                        Store (0x05, LDNM)
                        FindSetRightBit (IRQW, Local0)
                        Decrement (Local0)
                        Store (Local0, INRQ)
                        Store (One, ACTR)
                        EXFG ()
                    }

                    Name (_PRW, Package (0x02)
                    {
                        0x0A, 
                        0x01
                    })
                }
            }

            Device (PX43)
            {
                Name (_ADR, 0x00040003)
                OperationRegion (IPMU, PCI_Config, 0x40, 0x02)
                Field (IPMU, ByteAcc, NoLock, Preserve)
                {
                    PM00,   8, 
                    PM01,   8
                }

                OperationRegion (ISMB, PCI_Config, 0x90, 0x02)
                Field (ISMB, ByteAcc, NoLock, Preserve)
                {
                    SB00,   8, 
                    SB01,   8
                }
            }

            Device (BX00)
            {
                Name (_ADR, 0x00)
            }

            Device (USB0)
            {
                Name (_ADR, 0x00040002)
                Name (_PRW, Package (0x02)
                {
                    0x08, 
                    0x01
                })
            }

            Name (_PRW, Package (0x02)
            {
                0x09, 
                0x01
            })
        }
    }

    Scope (\_GPE)
    {
        Method (_L08, 0, Serialized)
        {
            Notify (\_SB.PCI0.USB0, 0x02)
        }

        Method (_L0A, 0, Serialized)
        {
            Notify (\_SB.PCI0.PX40.UAR1, 0x02)
            Notify (\_SB.PCI0.PX40.UAR2, 0x02)
        }

        Method (_L09, 0, Serialized)
        {
            Notify (\_SB.PCI0, 0x02)
        }
    }
}


--17pEHd4RhPHOinZp--



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