From owner-acpi-jp@jp.FreeBSD.org Sat Jan  3 05:09:40 2004
Received: (from daemon@localhost)
	by castle.jp.FreeBSD.org (8.11.6p2+3.4W/8.11.3) id i02K9er78729;
	Sat, 3 Jan 2004 05:09:40 +0900 (JST)
	(envelope-from owner-acpi-jp@jp.FreeBSD.org)
Received: from mail.cruzio.com (mail.cruzio.com [63.249.95.37])
	by castle.jp.FreeBSD.org (8.11.6p2+3.4W/8.11.3) with ESMTP/inet id i02K9cC78722
	for <acpi-jp@jp.FreeBSD.org>; Sat, 3 Jan 2004 05:09:38 +0900 (JST)
	(envelope-from slazar@cruzio.com)
Received: from seano (dsl3-63-249-68-90.cruzio.com [63.249.68.90])
	by mail.cruzio.com with SMTP id i02K9SNg053092
	for <acpi-jp@jp.FreeBSD.org>; Fri, 2 Jan 2004 12:09:29 -0800 (PST)
Message-ID: <002b01c3d16c$5a87d3b0$6401a8c0@seano>
From: "Sean Lazar" <slazar@cruzio.com>
To: <acpi-jp@jp.FreeBSD.org>
References: <XFMail.20040102132727.jhb@FreeBSD.org>
MIME-Version: 1.0
Content-Type: text/plain;
	charset="iso-8859-1"
Content-Transfer-Encoding: 7bit
X-Priority: 3
X-MSMail-Priority: Normal
X-Mailer: Microsoft Outlook Express 6.00.2800.1158
X-MimeOLE: Produced By Microsoft MimeOLE V6.00.2800.1165
Reply-To: acpi-jp@jp.FreeBSD.org
Precedence: list
Date: Fri, 2 Jan 2004 12:09:34 -0800
X-Sequence: acpi-jp 2966
Subject: [acpi-jp 2966] Gateway 400SD4 and thermal issues
Sender: owner-acpi-jp@jp.FreeBSD.org
X-Originator: slazar@cruzio.com
X-Distribute: distribute version 2.1 (Alpha) patchlevel 24e+031216

Hello,

Sorry if this is a second post. Not sure if the first one got through. I
have a Gateway 400SD4 laptop that I am having thermal issues with in
FreeBSD-CURRENT. The two-speed fan dosen't seem to come on. With ACPI on,
after the system has been running a little while and has warmed up, if I
turn off acpi with "acpiconf -d" the fan will kick on immediately. After
that the fan appears to behave normally, turning on and off when necessary.
If the laptop boots warm with the fan on, it will shut off when it gets cool
but it won't come back on again.

There is a second fan on this model that seems to work fine, but it dosen't
do enough to cool down the system. Below is my original acpidump asl file. I
tried editing it and removing the OS-dependent areas and if statements in
the TZ section and using a custom dsdt file with acpi_dsdt_load="YES" and
acpi_dsdt_name="/boot/DSDT.asl" in my /boot/loader.conf. I also tried
hw.acpi.os_name="Microsoft Windows NT" in /boot/loader.conf and other OS
names as well. I also tried debug.acpi.disable="thermal".

What else can I try? Any ACPI patches out there? Or perhaps I can
sucessfully edit this file with some hints :) I've read the Intel ACPI spec
and I am starting to understand the format...

Sean
----------------------------------------------------------------------------
-------------


/*
  RSD PTR: OEM=PTLTD, ACPI_Rev=1.0x (0)
	RSDT=0x0fef9c2c, cksum=115
 */
/*
  RSDT: Length=44, Revision=1, Checksum=78,
	OEMID=GATEWA, OEM Table ID=400, OEM Revision=0x20031002,
	Creator ID= LTP, Creator Revision=0x0
	Entries={ 0x0fefef64, 0x0fefefd8 }
 */
/*
  FADT:	FACS=0xfefffc0, DSDT=0xfef9c58
	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=0x0
	PM1a_EVT_BLK=0x1000-0x1003
	PM1a_CNT_BLK=0x1004-0x1005
	PM2_CNT_BLK=0x1020-0x1020
	PM_TMR_BLK=0x1008-0x100b
	GPE0_BLK=0x1028-0x102b
	GPE1_BLK=0x102c-0x102f, GPE1_BASE=16
	P_LVL2_LAT=1 us, P_LVL3_LAT=85 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=21260, Revision=1, Checksum=215,
	OEMID=GATEWA, OEM Table ID=400, OEM Revision=0x20031002,
	Creator ID=MSFT, Creator Revision=0x100000d
 */
/*
  BOOT: Length=40, Revision=1, Checksum=58,
	OEMID=GATEWA, OEM Table ID=400, OEM Revision=0x20031002,
	Creator ID= LTP, Creator Revision=0x1
 */
/*
 * Intel ACPI Component Architecture
 * AML Disassembler version 20031203
 *
 * Disassembly of /tmp/acpidump.Mu6aat, Thu Jan  1 21:32:21 2004
 */
DefinitionBlock ("DSDT.aml", "DSDT", 1, "GATEWA", "400     ", 537071618)
{
    OperationRegion (DBG, SystemIO, 0x80, 0x01)
    Field (DBG, ByteAcc, NoLock, Preserve)
    {
        DEBG,   8
    }

    Scope (_PR)
    {
        Processor (CPU0, 0x00, 0x00001010, 0x06) {}
    }

    Name (\_S0, Package (0x02)
    {
        0x00,
        0x00
    })
    Name (\_S3, Package (0x02)
    {
        0x05,
        0x05
    })
    Name (\_S4, Package (0x02)
    {
        0x06,
        0x06
    })
    Name (\_S5, Package (0x02)
    {
        0x07,
        0x07
    })
    Method (_PTS, 1, NotSerialized)
    {
        Store (Arg0, \_SB.STAT)
        Store (">>>> _PTS ------------", Debug)
        Store (Arg0, Debug)
        Store (Arg0, \_SB.SLEE)
        Store (0x01, \_SB.PCI0.LPC0.EC0.APWR)
        If (LEqual (Arg0, 0x03))
        {
            Store (0x80, \_SB.PCI0.LPC0.BCMD)
            Store (0x00, \_SB.PCI0.LPC0.SMIC)
        }

        If (LEqual (Arg0, 0x04))
        {
            Store (0x01, \_SB.S4WP)
            Store (Zero, \_SB.PCI0.LPC0.EC0.WL10)
        }

        If (LEqual (Arg0, 0x05))
        {
            Store (0x85, \_SB.PCI0.LPC0.BCMD)
            Store (0x00, \_SB.PCI0.LPC0.SMIC)
        }
    }

    Method (_WAK, 1, NotSerialized)
    {
        Store (Arg0, \_SB.STAT)
        If (LEqual (Arg0, 0x04))
        {
            Store (0x01, \_SB.OKEC)
            Notify (\_SB.SLPB, 0x02)
        }

        Store (0x00, \_SB.POPF)
        Store (\_SB.PCI0.LPC0.EC0.ACDF, \_SB.ACST)
        Store (0x00, \_SB.SLEE)
    }

    Scope (_GPE)
    {
        Method (_L05, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.MDM0, 0x02)
        }

        Method (_L0B, 0, NotSerialized)
        {
            If (LEqual (SizeOf (\_OS), 0x11))
            {
                Store (0x00, \_SB.PCI0.HUB.ILAN.IPME)
            }

            Notify (\_SB.PCI0.HUB, 0x00)
            If (Or (LEqual (\_SB.PCI0.MYOS, 0x01), LEqual (\_SB.PCI0.MYOS,
0x03)))
            {
                Notify (\_SB.SLPB, 0x02)
            }
        }

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

        Method (_L1C, 0, NotSerialized)
        {
            Sleep (0x01)
            Notify (\_SB.LID, 0x00)
        }

        Method (_E18, 0, NotSerialized)
        {
            Sleep (0x01)
        }
    }

    Scope (_SB)
    {
        Name (MES3, 0x00)
        Name (STAT, 0x00)
        Device (LNKA)
        {
            Name (_HID, EisaId ("PNP0C0F"))
            Name (_UID, 0x01)
            Name (_PRS, Buffer (0x06)
            {
                0x23, 0x00, 0x04, 0x18, 0x79, 0x00
            })
            Name (RSRC, Buffer (0x06)
            {
                0x23, 0x00, 0x00, 0x18, 0x79, 0x00
            })
            Method (_DIS, 0, NotSerialized)
            {
                Or (\_SB.PCI0.LPC0.PIRA, 0x80, \_SB.PCI0.LPC0.PIRA)
            }

            Method (_CRS, 0, NotSerialized)
            {
                CreateWordField (RSRC, 0x01, IRQ0)
                And (\_SB.PCI0.LPC0.PIRA, 0x0F, Local0)
                ShiftLeft (0x01, Local0, IRQ0)
                Return (RSRC)
            }

            Method (_SRS, 1, NotSerialized)
            {
                CreateWordField (Arg0, 0x01, IRQ0)
                FindSetRightBit (IRQ0, Local0)
                Decrement (Local0)
                Or (Local0, And (\_SB.PCI0.LPC0.PIRA, 0x70),
\_SB.PCI0.LPC0.PIRA)
            }

            Method (_STA, 0, NotSerialized)
            {
                If (And (\_SB.PCI0.LPC0.PIRA, 0x80))
                {
                    Return (0x09)
                }

                Return (0x0B)
            }
        }

        Device (LNKB)
        {
            Name (_HID, EisaId ("PNP0C0F"))
            Name (_UID, 0x02)
            Name (_PRS, Buffer (0x06)
            {
                0x23, 0x00, 0x04, 0x18, 0x79, 0x00
            })
            Name (RSRC, Buffer (0x06)
            {
                0x23, 0x00, 0x00, 0x18, 0x79, 0x00
            })
            Method (_DIS, 0, NotSerialized)
            {
                Or (\_SB.PCI0.LPC0.PIRB, 0x80, \_SB.PCI0.LPC0.PIRB)
            }

            Method (_CRS, 0, NotSerialized)
            {
                CreateWordField (RSRC, 0x01, IRQ0)
                And (\_SB.PCI0.LPC0.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 (\_SB.PCI0.LPC0.PIRB, 0x70),
\_SB.PCI0.LPC0.PIRB)
            }

            Method (_STA, 0, NotSerialized)
            {
                If (And (\_SB.PCI0.LPC0.PIRB, 0x80))
                {
                    Return (0x09)
                }

                Return (0x0B)
            }
        }

        Device (LNKC)
        {
            Name (_HID, EisaId ("PNP0C0F"))
            Name (_UID, 0x03)
            Name (_PRS, Buffer (0x06)
            {
                0x23, 0x00, 0x04, 0x18, 0x79, 0x00
            })
            Name (RSRC, Buffer (0x06)
            {
                0x23, 0x00, 0x00, 0x18, 0x79, 0x00
            })
            Method (_DIS, 0, NotSerialized)
            {
                Or (\_SB.PCI0.LPC0.PIRC, 0x80, \_SB.PCI0.LPC0.PIRC)
            }

            Method (_CRS, 0, NotSerialized)
            {
                CreateWordField (RSRC, 0x01, IRQ0)
                And (\_SB.PCI0.LPC0.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 (\_SB.PCI0.LPC0.PIRC, 0x70),
\_SB.PCI0.LPC0.PIRC)
            }

            Method (_STA, 0, NotSerialized)
            {
                If (And (\_SB.PCI0.LPC0.PIRC, 0x80))
                {
                    Return (0x09)
                }

                Return (0x0B)
            }
        }

        Device (LNKD)
        {
            Name (_HID, EisaId ("PNP0C0F"))
            Name (_UID, 0x04)
            Name (_PRS, Buffer (0x06)
            {
                0x23, 0x20, 0x00, 0x18, 0x79, 0x00
            })
            Name (RSRC, Buffer (0x06)
            {
                0x23, 0x00, 0x00, 0x18, 0x79, 0x00
            })
            Method (_DIS, 0, NotSerialized)
            {
                Or (\_SB.PCI0.LPC0.PIRD, 0x80, \_SB.PCI0.LPC0.PIRD)
            }

            Method (_CRS, 0, NotSerialized)
            {
                CreateWordField (RSRC, 0x01, IRQ0)
                And (\_SB.PCI0.LPC0.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 (\_SB.PCI0.LPC0.PIRD, 0x70),
\_SB.PCI0.LPC0.PIRD)
            }

            Method (_STA, 0, NotSerialized)
            {
                If (And (\_SB.PCI0.LPC0.PIRD, 0x80))
                {
                    Return (0x09)
                }

                Return (0x0B)
            }
        }

        Device (LNKE)
        {
            Name (_HID, EisaId ("PNP0C0F"))
            Name (_UID, 0x05)
            Name (_PRS, Buffer (0x06)
            {
                0x23, 0x00, 0x04, 0x18, 0x79, 0x00
            })
            Name (RSRC, Buffer (0x06)
            {
                0x23, 0x00, 0x00, 0x18, 0x79, 0x00
            })
            Name (INES, 0x00)
            Method (_DIS, 0, NotSerialized)
            {
                If (Or (LEqual (\_SB.PCI0.MYOS, 0x00), LEqual
(\_SB.PCI0.MYOS, 0x02)))
                {
                    Or (\_SB.PCI0.LPC0.PIRE, 0x80, \_SB.PCI0.LPC0.PIRE)
                }
                Else
                {
                    Or (INES, 0x80, INES)
                }
            }

            Method (_CRS, 0, NotSerialized)
            {
                CreateWordField (RSRC, 0x01, IRQ0)
                And (\_SB.PCI0.LPC0.PIRE, 0x0F, Local0)
                ShiftLeft (0x01, Local0, IRQ0)
                Return (RSRC)
            }

            Method (_SRS, 1, NotSerialized)
            {
                CreateWordField (Arg0, 0x01, IRQ0)
                FindSetRightBit (IRQ0, Local0)
                Decrement (Local0)
                Or (Local0, And (\_SB.PCI0.LPC0.PIRE, 0x70),
\_SB.PCI0.LPC0.PIRE)
                Store (\_SB.PCI0.LPC0.PIRE, INES)
            }

            Method (_STA, 0, NotSerialized)
            {
                If (Or (LEqual (\_SB.PCI0.MYOS, 0x00), LEqual
(\_SB.PCI0.MYOS, 0x02)))
                {
                    If (And (\_SB.PCI0.LPC0.PIRE, 0x80))
                    {
                        Return (0x09)
                    }
                }
                Else
                {
                    If (And (INES, 0x80))
                    {
                        Return (0x09)
                    }
                }

                Return (0x0B)
            }
        }

        Device (LNKF)
        {
            Name (_HID, EisaId ("PNP0C0F"))
            Name (_UID, 0x06)
            Name (_PRS, Buffer (0x06)
            {
                0x23, 0x00, 0x04, 0x18, 0x79, 0x00
            })
            Name (RSRC, Buffer (0x06)
            {
                0x23, 0x00, 0x00, 0x18, 0x79, 0x00
            })
            Method (_DIS, 0, NotSerialized)
            {
                Or (\_SB.PCI0.LPC0.PIRF, 0x80, \_SB.PCI0.LPC0.PIRF)
            }

            Method (_CRS, 0, NotSerialized)
            {
                CreateWordField (RSRC, 0x01, IRQ0)
                And (\_SB.PCI0.LPC0.PIRF, 0x0F, Local0)
                ShiftLeft (0x01, Local0, IRQ0)
                Return (RSRC)
            }

            Method (_SRS, 1, NotSerialized)
            {
                CreateWordField (Arg0, 0x01, IRQ0)
                FindSetRightBit (IRQ0, Local0)
                Decrement (Local0)
                Or (Local0, And (\_SB.PCI0.LPC0.PIRF, 0x70),
\_SB.PCI0.LPC0.PIRF)
            }

            Method (_STA, 0, NotSerialized)
            {
                If (And (\_SB.PCI0.LPC0.PIRF, 0x80))
                {
                    Return (0x09)
                }

                Return (0x0B)
            }
        }

        Device (LNKG)
        {
            Name (_HID, EisaId ("PNP0C0F"))
            Name (_UID, 0x07)
            Name (_PRS, Buffer (0x06)
            {
                0x23, 0x00, 0x04, 0x18, 0x79, 0x00
            })
            Name (RSRC, Buffer (0x06)
            {
                0x23, 0x00, 0x00, 0x18, 0x79, 0x00
            })
            Method (_DIS, 0, NotSerialized)
            {
                Or (\_SB.PCI0.LPC0.PIRG, 0x80, \_SB.PCI0.LPC0.PIRG)
            }

            Method (_CRS, 0, NotSerialized)
            {
                CreateWordField (RSRC, 0x01, IRQ0)
                And (\_SB.PCI0.LPC0.PIRG, 0x0F, Local0)
                ShiftLeft (0x01, Local0, IRQ0)
                Return (RSRC)
            }

            Method (_SRS, 1, NotSerialized)
            {
                CreateWordField (Arg0, 0x01, IRQ0)
                FindSetRightBit (IRQ0, Local0)
                Decrement (Local0)
                Or (Local0, And (\_SB.PCI0.LPC0.PIRG, 0x70),
\_SB.PCI0.LPC0.PIRG)
            }

            Method (_STA, 0, NotSerialized)
            {
                If (And (\_SB.PCI0.LPC0.PIRG, 0x80))
                {
                    Return (0x09)
                }

                Return (0x0B)
            }
        }

        Device (LNKH)
        {
            Name (_HID, EisaId ("PNP0C0F"))
            Name (_UID, 0x08)
            Name (_PRS, Buffer (0x06)
            {
                0x23, 0x00, 0x04, 0x18, 0x79, 0x00
            })
            Name (RSRC, Buffer (0x06)
            {
                0x23, 0x00, 0x00, 0x18, 0x79, 0x00
            })
            Method (_DIS, 0, NotSerialized)
            {
                Or (\_SB.PCI0.LPC0.PIRH, 0x80, \_SB.PCI0.LPC0.PIRH)
            }

            Method (_CRS, 0, NotSerialized)
            {
                CreateWordField (RSRC, 0x01, IRQ0)
                And (\_SB.PCI0.LPC0.PIRH, 0x0F, Local0)
                ShiftLeft (0x01, Local0, IRQ0)
                Return (RSRC)
            }

            Method (_SRS, 1, NotSerialized)
            {
                CreateWordField (Arg0, 0x01, IRQ0)
                FindSetRightBit (IRQ0, Local0)
                Decrement (Local0)
                Or (Local0, And (\_SB.PCI0.LPC0.PIRH, 0x70),
\_SB.PCI0.LPC0.PIRH)
            }

            Method (_STA, 0, NotSerialized)
            {
                If (And (\_SB.PCI0.LPC0.PIRH, 0x80))
                {
                    Return (0x09)
                }

                Return (0x0B)
            }
        }

        Device (PCI0)
        {
            Name (MYOS, 0x02)
            Method (_INI, 0, NotSerialized)
            {
                Store (0x02, MYOS)
                If (LEqual (SizeOf (\_OS), 0x11))
                {
                    Store (0x00, MYOS)
                    Store (0x00, \_SB.W2KF)
                }
                Else
                {
                    If (LEqual (SizeOf (\_OS), 0x27))
                    {
                        Store (0x02, MYOS)
                        Store (0x02, \_SB.W2KF)
                    }
                    Else
                    {
                        If (LEqual (SizeOf (\_OS), 0x14))
                        {
                            Store (0x01, MYOS)
                            Store (0x01, \_SB.W2KF)
                            If (CondRefOf (_OSI, Local0))
                            {
                                If (\_OSI ("Windows 2001"))
                                {
                                    Store (0x03, MYOS)
                                    Store (0x03, \_SB.W2KF)
                                }
                            }
                        }
                    }
                }
            }

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

            Name (BUF0, Buffer (0x0201)
            {
                0x88, 0x0E, 0x00, 0x02, 0x0C, 0x00, 0x00, 0x00,
                0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x01,
                0x00, 0x87, 0x18, 0x00, 0x01, 0x0C, 0x03, 0x00,
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF7,
                0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8,
                0x0C, 0x00, 0x00, 0x00, 0x47, 0x01, 0xF8, 0x0C,
                0xF8, 0x0C, 0x01, 0x08, 0x87, 0x18, 0x00, 0x01,
                0x0C, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0D,
                0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,
                0x00, 0x00, 0x00, 0xF3, 0x00, 0x00, 0x00, 0x87,
                0x18, 0x00, 0x00, 0x0C, 0x03, 0x00, 0x00, 0x00,
                0x00, 0x00, 0x00, 0x0A, 0x00, 0xFF, 0xFF, 0x0B,
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
                0x00, 0x00, 0x87, 0x18, 0x00, 0x00, 0x0C, 0x03,
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00,
                0xFF, 0x3F, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00,
                0x00, 0x40, 0x00, 0x00, 0x00, 0x87, 0x18, 0x00,
                0x00, 0x0C, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
                0x40, 0x0C, 0x00, 0xFF, 0x7F, 0x0C, 0x00, 0x00,
                0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
                0x87, 0x18, 0x00, 0x00, 0x0C, 0x03, 0x00, 0x00,
                0x00, 0x00, 0x00, 0x80, 0x0C, 0x00, 0xFF, 0xBF,
                0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40,
                0x00, 0x00, 0x00, 0x87, 0x18, 0x00, 0x00, 0x0C,
                0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x0C,
                0x00, 0xFF, 0xFF, 0x0C, 0x00, 0x00, 0x00, 0x00,
                0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x87, 0x18,
                0x00, 0x00, 0x0C, 0x03, 0x00, 0x00, 0x00, 0x00,
                0x00, 0x00, 0x0D, 0x00, 0xFF, 0x3F, 0x0D, 0x00,
                0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00,
                0x00, 0x87, 0x18, 0x00, 0x00, 0x0C, 0x03, 0x00,
                0x00, 0x00, 0x00, 0x00, 0x40, 0x0D, 0x00, 0xFF,
                0x7F, 0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                0x40, 0x00, 0x00, 0x00, 0x87, 0x18, 0x00, 0x00,
                0x0C, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
                0x0D, 0x00, 0xFF, 0xBF, 0x0D, 0x00, 0x00, 0x00,
                0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x87,
                0x18, 0x00, 0x00, 0x0C, 0x03, 0x00, 0x00, 0x00,
                0x00, 0x00, 0xC0, 0x0D, 0x00, 0xFF, 0xFF, 0x0D,
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00,
                0x00, 0x00, 0x87, 0x18, 0x00, 0x00, 0x0C, 0x03,
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00,
                0xFF, 0x3F, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00,
                0x00, 0x40, 0x00, 0x00, 0x00, 0x87, 0x18, 0x00,
                0x00, 0x0C, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
                0x40, 0x0E, 0x00, 0xFF, 0x7F, 0x0E, 0x00, 0x00,
                0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
                0x87, 0x18, 0x00, 0x00, 0x0C, 0x03, 0x00, 0x00,
                0x00, 0x00, 0x00, 0x80, 0x0E, 0x00, 0xFF, 0xBF,
                0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40,
                0x00, 0x00, 0x00, 0x87, 0x18, 0x00, 0x00, 0x0C,
                0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x0E,
                0x00, 0xFF, 0xFF, 0x0E, 0x00, 0x00, 0x00, 0x00,
                0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x87, 0x18,
                0x00, 0x00, 0x0C, 0x03, 0x00, 0x00, 0x00, 0x00,
                0x00, 0x00, 0x0F, 0x00, 0xFF, 0xFF, 0x0F, 0x00,
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
                0x00, 0x87, 0x18, 0x00, 0x00, 0x0C, 0x03, 0x00,
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF,
                0xFF, 0xBF, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00,
                0x00, 0x00, 0x00, 0x00, 0x87, 0x18, 0x00, 0x00,
                0x0C, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x79,
                0x00
            })
            Method (_CRS, 0, Serialized)
            {
                If (PM1L)
                {
                    CreateDWordField (BUF0, 0x80, C0LN)
                    Store (Zero, C0LN)
                }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

                CreateDWordField (BUF0, 0x01D3, M1MN)
                CreateDWordField (BUF0, 0x01D7, M1MX)
                CreateDWordField (BUF0, 0x01DF, M1LN)
                Multiply (0x02000000, DRB7, M1MN)
                Add (Subtract (M1MX, M1MN), 0x01, M1LN)
                ShiftRight (And (\_SB.PCI0.LPC0.MTSE, 0x00038000), 0x0F,
Local0)
                If (And (Local0, 0x04))
                {
                    CreateDWordField (BUF0, 0x01EE, M2MN)
                    CreateDWordField (BUF0, 0x01F2, M2MX)
                    CreateDWordField (BUF0, 0x01FA, M2LN)
                    Store (0xFED00000, M2MN)
                    Store (0xFED003FF, M2MX)
                    Store (0x0400, M2LN)
                    If (LEqual (Local0, 0x05))
                    {
                        Store (0xFED01000, M2MN)
                        Store (0xFED013FF, M2MX)
                    }

                    If (LEqual (Local0, 0x06))
                    {
                        Store (0xFED02000, M2MN)
                        Store (0xFED023FF, M2MX)
                    }

                    If (LEqual (Local0, 0x07))
                    {
                        Store (0xFED03000, M2MN)
                        Store (0xFED033FF, M2MX)
                    }
                }

                Return (BUF0)
            }

            Name (_PRT, Package (0x0C)
            {
                Package (0x04)
                {
                    0xFFFF,
                    0x00,
                    \_SB.LNKA,
                    0x00
                },

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

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

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

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

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

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

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

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

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

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

                Package (0x04)
                {
                    0x001FFFFF,
                    0x01,
                    \_SB.LNKB,
                    0x00
                }
            })
            Device (AGP)
            {
                Name (_ADR, 0x00010000)
                Name (_PRT, Package (0x01)
                {
                    Package (0x04)
                    {
                        0xFFFF,
                        0x00,
                        \_SB.LNKA,
                        0x00
                    }
                })
                Device (VGA)
                {
                    Name (_ADR, 0x00)
                    Name (SWIT, 0x01)
                    Name (CRTA, 0x01)
                    Name (LCDA, 0x01)
                    Name (TV0A, 0x01)
                    Name (TOGF, 0x00)
                    Method (_STA, 0, NotSerialized)
                    {
                        Return (0x0F)
                    }

                    Name (_PSC, 0x00)
                    Name (USBF, 0x00)
                    Method (_PS0, 0, NotSerialized)
                    {
                        If (LLess (USBF, 0x01))
                        {
                            Increment (USBF)
                            If (LEqual (USBF, 0x01))
                            {
                                Store (0x92, \_SB.PCI0.LPC0.BCMD)
                                Store (0x00, \_SB.PCI0.LPC0.SMIC)
                            }
                        }

                        If (LEqual (\_SB.PCI0.MYOS, 0x00))
                        {
                            Store (0x9A, \_SB.PCI0.LPC0.BCMD)
                            Store (0x00, \_SB.PCI0.LPC0.SMIC)
                        }

                        Store (0x00, _PSC)
                    }

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

                    Method (_DOS, 1, NotSerialized)
                    {
                        Store (And (Arg0, 0x03), SWIT)
                    }

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

                    Device (CRT)
                    {
                        Name (_ADR, 0x0100)
                        Method (_DCS, 0, NotSerialized)
                        {
                            If (CRTA)
                            {
                                Return (0x1F)
                            }
                            Else
                            {
                                Return (0x1D)
                            }
                        }

                        Method (_DGS, 0, NotSerialized)
                        {
                            If (CRTA)
                            {
                                Return (0x01)
                            }
                            Else
                            {
                                Return (0x00)
                            }
                        }

                        Method (_DSS, 1, NotSerialized)
                        {
                            Store ("CRT --_DSS", Debug)
                        }
                    }

                    Device (LCD)
                    {
                        Name (_ADR, 0x0110)
                        Method (_DCS, 0, NotSerialized)
                        {
                            If (LCDA)
                            {
                                Return (0x1F)
                            }
                            Else
                            {
                                Return (0x1D)
                            }
                        }

                        Method (_DGS, 0, NotSerialized)
                        {
                            Store (LCDA, Local0)
                            If (LCDA)
                            {
                                Return (0x01)
                            }
                            Else
                            {
                                Return (0x00)
                            }
                        }

                        Method (_DSS, 1, NotSerialized)
                        {
                            Store ("LCD --_DSS", Debug)
                        }
                    }

                    Method (SWIH, 0, NotSerialized)
                    {
                        GETD ()
                        Store (0x97, \_SB.PCI0.LPC0.BCMD)
                        Store (0x00, \_SB.PCI0.LPC0.SMIC)
                        Store (\_SB.DISD, Local0)
                        If (LEqual (Local0, 0x03))
                        {
                            Increment (TOGF)
                            Store (TOGF, Local1)
                            If (LEqual (Local1, 0x01))
                            {
                                Store (One, LCDA)
                                Store (Zero, CRTA)
                                Store (Zero, TV0A)
                            }
                            Else
                            {
                                If (LEqual (Local1, 0x02))
                                {
                                    Store (Zero, LCDA)
                                    Store (One, CRTA)
                                    Store (Zero, TV0A)
                                }
                                Else
                                {
                                    If (LEqual (Local1, 0x03))
                                    {
                                        Store (One, LCDA)
                                        Store (One, CRTA)
                                        Store (Zero, TV0A)
                                    }
                                    Else
                                    {
                                        Store (One, TOGF)
                                        Store (One, LCDA)
                                        Store (Zero, CRTA)
                                        Store (Zero, TV0A)
                                    }
                                }
                            }
                        }
                        Else
                        {
                            If (LEqual (Local0, 0x05))
                            {
                                Increment (TOGF)
                                Store (TOGF, Local1)
                                If (LEqual (Local1, 0x01))
                                {
                                    Store (One, LCDA)
                                    Store (Zero, CRTA)
                                    Store (Zero, TV0A)
                                }
                                Else
                                {
                                    Store (Zero, TOGF)
                                    Store (Zero, LCDA)
                                    Store (Zero, CRTA)
                                    Store (One, TV0A)
                                }
                            }
                            Else
                            {
                                If (LEqual (Local0, 0x07))
                                {
                                    Increment (TOGF)
                                    Store (TOGF, Local1)
                                    If (LEqual (Local1, 0x01))
                                    {
                                        Store (0x01, LCDA)
                                        Store (0x00, CRTA)
                                        Store (0x00, TV0A)
                                    }
                                    Else
                                    {
                                        If (LEqual (Local1, 0x02))
                                        {
                                            Store (0x00, LCDA)
                                            Store (0x01, CRTA)
                                            Store (0x00, TV0A)
                                        }
                                        Else
                                        {
                                            If (LEqual (Local1, 0x03))
                                            {
                                                Store (0x01, LCDA)
                                                Store (0x01, CRTA)
                                                Store (0x00, TV0A)
                                            }
                                            Else
                                            {
                                                Store (0x00, TOGF)
                                                Store (0x00, LCDA)
                                                Store (0x00, CRTA)
                                                Store (0x01, TV0A)
                                            }
                                        }
                                    }
                                }
                                Else
                                {
                                    Store (0x01, TOGF)
                                    Store (0x01, LCDA)
                                    Store (0x00, CRTA)
                                    Store (0x00, TV0A)
                                }
                            }
                        }

                        Notify (\_SB.PCI0.AGP.VGA, 0x80)
                    }

                    Method (GETD, 0, NotSerialized)
                    {
                        Store (0x98, \_SB.PCI0.LPC0.BCMD)
                        Store (0x00, \_SB.PCI0.LPC0.SMIC)
                        Store (\_SB.DISD, Local0)
                        If (LEqual (Local0, 0x01))
                        {
                            Store (0x01, TOGF)
                        }

                        If (LEqual (Local0, 0x02))
                        {
                            Store (0x02, TOGF)
                        }

                        If (LEqual (Local0, 0x03))
                        {
                            Store (0x03, TOGF)
                        }

                        If (LEqual (Local0, 0x04))
                        {
                            Store (0x00, TOGF)
                        }
                    }
                }
            }

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

                OperationRegion (REGS, PCI_Config, 0x40, 0xC0)
                Field (REGS, DWordAcc, NoLock, Preserve)
                {
                    PMBA,   16,
                    Offset (0x18),
                    GPBA,   16,
                    Offset (0x90),
                    MTSE,   32,
                    Offset (0xA6),
                    ECO1,   1,
                    ECO2,   1,
                    ELPT,   1,
                    EFDD,   1
                }

                OperationRegion (PIRX, PCI_Config, 0x60, 0x0C)
                Field (PIRX, DWordAcc, NoLock, Preserve)
                {
                    AccessAs (ByteAcc, 0x00),
                    PIRA,   8,
                    PIRB,   8,
                    PIRC,   8,
                    PIRD,   8,
                    Offset (0x08),
                    PIRE,   8,
                    PIRF,   8,
                    PIRG,   8,
                    PIRH,   8
                }

                Device (MBRD)
                {
                    Name (_HID, EisaId ("PNP0C02"))
                    Name (_UID, 0x1F)
                    Name (RSRC, Buffer (0x0126)
                    {
                        0x47, 0x01, 0x10, 0x00, 0x10, 0x00, 0x01, 0x10,
                        0x47, 0x01, 0x24, 0x00, 0x24, 0x00, 0x01, 0x02,
                        0x47, 0x01, 0x28, 0x00, 0x28, 0x00, 0x01, 0x02,
                        0x47, 0x01, 0x2C, 0x00, 0x2C, 0x00, 0x01, 0x02,
                        0x47, 0x01, 0x30, 0x00, 0x30, 0x00, 0x01, 0x02,
                        0x47, 0x01, 0x34, 0x00, 0x34, 0x00, 0x01, 0x02,
                        0x47, 0x01, 0x38, 0x00, 0x38, 0x00, 0x01, 0x02,
                        0x47, 0x01, 0x3C, 0x00, 0x3C, 0x00, 0x01, 0x02,
                        0x47, 0x01, 0x50, 0x00, 0x50, 0x00, 0x01, 0x04,
                        0x47, 0x01, 0x68, 0x00, 0x68, 0x00, 0x01, 0x01,
                        0x47, 0x01, 0x6C, 0x00, 0x6C, 0x00, 0x01, 0x01,
                        0x47, 0x01, 0x72, 0x00, 0x72, 0x00, 0x01, 0x06,
                        0x47, 0x01, 0x80, 0x00, 0x80, 0x00, 0x01, 0x01,
                        0x47, 0x01, 0x90, 0x00, 0x90, 0x00, 0x01, 0x10,
                        0x47, 0x01, 0xA4, 0x00, 0xA4, 0x00, 0x01, 0x02,
                        0x47, 0x01, 0xA8, 0x00, 0xA8, 0x00, 0x01, 0x02,
                        0x47, 0x01, 0xAC, 0x00, 0xAC, 0x00, 0x01, 0x02,
                        0x47, 0x01, 0xB0, 0x00, 0xB0, 0x00, 0x01, 0x06,
                        0x47, 0x01, 0xB8, 0x00, 0xB8, 0x00, 0x01, 0x02,
                        0x47, 0x01, 0xBC, 0x00, 0xBC, 0x00, 0x01, 0x02,
                        0x47, 0x01, 0x00, 0x10, 0x00, 0x10, 0x01, 0x80,
                        0x47, 0x01, 0x80, 0x11, 0x80, 0x11, 0x01, 0x40,
                        0x47, 0x01, 0xC0, 0x01, 0xC0, 0x01, 0x01, 0x10,
                        0x47, 0x01, 0x2E, 0x00, 0x2E, 0x00, 0x01, 0x02,
                        0x47, 0x01, 0x4E, 0x00, 0x4E, 0x00, 0x01, 0x02,
                        0x47, 0x01, 0x00, 0xFE, 0x00, 0xFE, 0x00, 0x01,
                        0x47, 0x01, 0xD0, 0x04, 0xD0, 0x04, 0x01, 0x02,
                        0x47, 0x01, 0x00, 0x06, 0x00, 0x06, 0x01, 0x10,
                        0x47, 0x01, 0x10, 0x06, 0x10, 0x06, 0x01, 0x10,
                        0x86, 0x09, 0x00, 0x00, 0x00, 0x00, 0x80, 0xFF,
                        0x00, 0x00, 0x40, 0x00, 0x86, 0x09, 0x00, 0x00,
                        0x00, 0x00, 0xF0, 0xFF, 0x00, 0x00, 0x10, 0x00,
                        0x86, 0x09, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
                        0x00, 0x00, 0x0A, 0x00, 0x86, 0x09, 0x00, 0x00,
                        0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x02, 0x00,
                        0x86, 0x09, 0x00, 0x01, 0x00, 0x00, 0x10, 0x00,
                        0x00, 0x00, 0x00, 0x00, 0x79, 0x00
                    })
                    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)
                        CreateDWordField (RSRC, 0x0120, TMEM)
                        Store (\_SB.PCI0.DRB3, TMEM)
                        ShiftLeft (TMEM, 0x19, TMEM)
                        Subtract (TMEM, 0x00100000, TMEM)
                        Return (RSRC)
                    }
                }

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

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

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

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

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

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

                OperationRegion (GPOX, SystemIO, 0x1180, 0x40)
                Field (GPOX, DWordAcc, Lock, Preserve)
                {
                    Offset (0x07),
                        ,   1,
                    IO25,   1,
                        ,   1,
                    IO27,   1,
                    Offset (0x0E),
                        ,   1,
                    LV17,   1,
                    Offset (0x0F),
                        ,   1,
                    LV25,   1,
                        ,   1,
                    LV27,   1,
                    Offset (0x1B),
                        ,   1,
                    BL25,   1,
                        ,   1,
                    BL27,   1,
                    Offset (0x38),
                    RBID,   2,
                    LBID,   2,
                    LV36,   1,
                    LV37,   1,
                    LV38,   1,
                    LV39,   1,
                    LV40,   1,
                    LV41,   1,
                    LV42,   1,
                    LV43,   1
                }

                OperationRegion (PMIO, SystemIO, 0x1000, 0x51)
                Field (PMIO, WordAcc, Lock, Preserve)
                {
                    AccessAs (DWordAcc, 0x00),
                    Offset (0x29),
                        ,   3,
                    PMES,   1,
                    Offset (0x2B),
                        ,   3,
                    PMEE,   1,
                    Offset (0x2C),
                    GPI0,   1,
                    GPI1,   1,
                    GPI2,   1,
                    GPI3,   1,
                    GPI4,   1,
                    GPI5,   1,
                    GPI6,   1,
                    GPI7,   1,
                    GPI8,   1,
                    GPI9,   1,
                    GPIA,   1,
                    GPIB,   1,
                    GPIC,   1,
                    GPID,   1,
                    GPIE,   1,
                    GPIF,   1,
                        ,   6,
                    GPEE,   1
                }

                Device (KBC)
                {
                    Name (_HID, EisaId ("PNP0303"))
                    Name (_CRS, Buffer (0x15)
                    {
                        0x47, 0x01, 0x60, 0x00, 0x60, 0x00, 0x01, 0x01,
                        0x47, 0x01, 0x64, 0x00, 0x64, 0x00, 0x01, 0x01,
                        0x22, 0x02, 0x00, 0x79, 0x00
                    })
                    Method (_STA, 0, NotSerialized)
                    {
                        Return (0x0F)
                    }
                }

                Device (MOUE)
                {
                    Name (_HID, EisaId ("IBM3780"))
                    Name (_CID, 0x130FD041)
                    Name (_CRS, Buffer (0x05)
                    {
                        0x22, 0x00, 0x10, 0x79, 0x00
                    })
                    Method (_STA, 0, NotSerialized)
                    {
                        If (LEqual (SizeOf (\_OS), 0x14))
                        {
                            Return (0x00)
                        }
                        Else
                        {
                            If (\_SB.PS2M)
                            {
                                Return (0x0F)
                            }
                            Else
                            {
                                Return (0x00)
                            }
                        }
                    }
                }

                Device (MOU2)
                {
                    Name (_HID, EisaId ("PNP0F13"))
                    Name (_CRS, Buffer (0x05)
                    {
                        0x22, 0x00, 0x10, 0x79, 0x00
                    })
                    Method (_STA, 0, NotSerialized)
                    {
                        If (LEqual (SizeOf (\_OS), 0x14))
                        {
                            If (\_SB.PS2M)
                            {
                                Return (0x0F)
                            }
                            Else
                            {
                                Return (0x00)
                            }
                        }
                        Else
                        {
                            Return (0x00)
                        }
                    }
                }

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

                    Mutex (N393, 0x00)
                    Method (LDRS, 3, NotSerialized)
                    {
                        Acquire (N393, 0xFFFF)
                        Store (0x07, INDX)
                        Store (Arg0, DATA)
                        Store (Arg1, INDX)
                        Store (Arg2, DATA)
                        Release (N393)
                    }

                    Method (LDRG, 2, NotSerialized)
                    {
                        Acquire (N393, 0xFFFF)
                        Store (0x07, INDX)
                        Store (Arg0, DATA)
                        Store (Arg1, INDX)
                        Store (DATA, Local0)
                        Release (N393)
                        Return (Local0)
                    }

                    Method (RCF6, 1, NotSerialized)
                    {
                        Acquire (N393, 0xFFFF)
                        Store (0x26, INDX)
                        Store (DATA, Local0)
                        And (Local0, Arg0, Local0)
                        Release (N393)
                        Return (XOr (Local0, Arg0))
                    }

                    Device (ECP)
                    {
                        Name (_HID, EisaId ("PNP0401"))
                        Name (_UID, 0x03)
                        Method (_STA, 0, NotSerialized)
                        {
                            Store (LDRG (0x01, 0xF0), Local0)
                            ShiftRight (Local0, 0x05, Local0)
                            If (LAnd (RCF6 (0x02), LOr (LEqual (Local0,
0x04), LEqual (Local0, 0x07))))
                            {
                                ShiftLeft (LDRG (0x01, 0x30), 0x01, Local1)
                                Add (0x0D, Local1, Local1)
                                Return (Local1)
                            }
                            Else
                            {
                                Return (0x00)
                            }
                        }

                        Method (_PS0, 0, NotSerialized)
                        {
                            LDRS (0x01, 0x30, 0x01)
                        }

                        Method (_PS3, 0, NotSerialized)
                        {
                            LDRS (0x01, 0x30, 0x00)
                        }

                        Method (_PRS, 0, NotSerialized)
                        {
                            Return (Buffer (0xBB)
                            {
                                0x30, 0x47, 0x01, 0x78, 0x03, 0x78, 0x03,
0x08,
                                0x08, 0x47, 0x01, 0x78, 0x07, 0x78, 0x07,
0x08,
                                0x08, 0x22, 0x80, 0x00, 0x2A, 0x08, 0x00,
0x30,
                                0x47, 0x01, 0x78, 0x02, 0x78, 0x02, 0x08,
0x08,
                                0x47, 0x01, 0x78, 0x06, 0x78, 0x06, 0x08,
0x08,
                                0x22, 0x20, 0x00, 0x2A, 0x08, 0x00, 0x30,
0x47,
                                0x01, 0x78, 0x03, 0x78, 0x03, 0x08, 0x08,
0x47,
                                0x01, 0x78, 0x07, 0x78, 0x07, 0x08, 0x08,
0x22,
                                0x20, 0x00, 0x2A, 0x08, 0x00, 0x30, 0x47,
0x01,
                                0x78, 0x02, 0x78, 0x02, 0x08, 0x08, 0x47,
0x01,
                                0x78, 0x06, 0x78, 0x06, 0x08, 0x08, 0x22,
0x80,
                                0x00, 0x2A, 0x08, 0x00, 0x30, 0x47, 0x01,
0x78,
                                0x03, 0x78, 0x03, 0x08, 0x08, 0x47, 0x01,
0x78,
                                0x07, 0x78, 0x07, 0x08, 0x08, 0x22, 0x80,
0x00,
                                0x2A, 0x02, 0x00, 0x30, 0x47, 0x01, 0x78,
0x02,
                                0x78, 0x02, 0x08, 0x08, 0x47, 0x01, 0x78,
0x06,
                                0x78, 0x06, 0x08, 0x08, 0x22, 0x20, 0x00,
0x2A,
                                0x02, 0x00, 0x30, 0x47, 0x01, 0x78, 0x03,
0x78,
                                0x03, 0x08, 0x08, 0x47, 0x01, 0x78, 0x07,
0x78,
                                0x07, 0x08, 0x08, 0x22, 0x20, 0x00, 0x2A,
0x02,
                                0x00, 0x30, 0x47, 0x01, 0x78, 0x02, 0x78,
0x02,
                                0x08, 0x08, 0x47, 0x01, 0x78, 0x06, 0x78,
0x06,
                                0x08, 0x08, 0x22, 0x80, 0x00, 0x2A, 0x02,
0x00,
                                0x38, 0x79, 0x00
                            })
                        }

                        Method (_DIS, 0, NotSerialized)
                        {
                            LDRS (0x01, 0x30, 0x00)
                        }

                        Method (_CRS, 0, NotSerialized)
                        {
                            Name (DCRS, Buffer (0x18)
                            {
                                0x47, 0x01, 0x78, 0x03, 0x78, 0x03, 0x08,
0x08,
                                0x47, 0x01, 0x78, 0x07, 0x78, 0x07, 0x08,
0x08,
                                0x22, 0x80, 0x00, 0x2A, 0x08, 0x00, 0x79,
0x00
                            })
                            Store (LDRG (0x01, 0x60), Local1)
                            Store (LDRG (0x01, 0x61), Local0)
                            Store (Local0, Index (DCRS, 0x02))
                            Store (Local0, Index (DCRS, 0x0A))
                            Store (Local0, Index (DCRS, 0x04))
                            Store (Local0, Index (DCRS, 0x0C))
                            Store (Local1, Index (DCRS, 0x03))
                            Store (Local1, Index (DCRS, 0x05))
                            Add (Local1, 0x04, Local1)
                            Store (Local1, Index (DCRS, 0x0B))
                            Store (Local1, Index (DCRS, 0x0D))
                            ShiftLeft (0x01, LDRG (0x01, 0x70), Local0)
                            Store (Local0, Index (DCRS, 0x11))
                            ShiftRight (Local0, 0x08, Local1)
                            Store (Local1, Index (DCRS, 0x12))
                            ShiftLeft (0x01, LDRG (0x01, 0x74), Local0)
                            Store (Local0, Index (DCRS, 0x14))
                            ShiftRight (Local0, 0x08, Local1)
                            Store (Local1, Index (DCRS, 0x15))
                            Return (DCRS)
                        }

                        Method (_SRS, 1, NotSerialized)
                        {
                            CreateByteField (Arg0, 0x02, ADRL)
                            CreateByteField (Arg0, 0x03, ADRM)
                            CreateWordField (Arg0, 0x11, IRQM)
                            CreateWordField (Arg0, 0x14, DMAM)
                            FindSetRightBit (IRQM, Local0)
                            Decrement (Local0)
                            FindSetRightBit (DMAM, Local1)
                            Decrement (Local1)
                            LDRS (0x01, 0x70, Local0)
                            LDRS (0x01, 0x74, Local1)
                            LDRS (0x01, 0x60, ADRM)
                            LDRS (0x01, 0x61, ADRL)
                            LDRS (0x01, 0x30, 0x01)
                        }
                    }

                    Device (EPP)
                    {
                        Name (_HID, EisaId ("PNP0400"))
                        Name (_UID, 0x02)
                        Method (_STA, 0, NotSerialized)
                        {
                            Store (LDRG (0x01, 0xF0), Local0)
                            ShiftRight (Local0, 0x05, Local0)
                            If (LAnd (RCF6 (0x02), LOr (LEqual (Local0,
0x02), LEqual (Local0, 0x03))))
                            {
                                ShiftLeft (LDRG (0x01, 0x30), 0x01, Local1)
                                Add (0x0D, Local1, Local1)
                                Return (Local1)
                            }
                            Else
                            {
                                Return (0x00)
                            }
                        }

                        Method (_PS0, 0, NotSerialized)
                        {
                            LDRS (0x01, 0x30, 0x01)
                        }

                        Method (_PS3, 0, NotSerialized)
                        {
                            LDRS (0x01, 0x30, 0x00)
                        }

                        Method (_PRS, 0, NotSerialized)
                        {
                            Return (Buffer (0x7B)
                            {
                                0x30, 0x47, 0x01, 0x78, 0x03, 0x78, 0x03,
0x08,
                                0x08, 0x47, 0x01, 0x78, 0x07, 0x78, 0x07,
0x08,
                                0x08, 0x22, 0x80, 0x00, 0x30, 0x47, 0x01,
0x78,
                                0x02, 0x78, 0x02, 0x08, 0x08, 0x47, 0x01,
0x78,
                                0x06, 0x78, 0x06, 0x08, 0x08, 0x22, 0x20,
0x00,
                                0x30, 0x47, 0x01, 0x78, 0x03, 0x78, 0x03,
0x08,
                                0x08, 0x47, 0x01, 0x78, 0x07, 0x78, 0x07,
0x08,
                                0x08, 0x22, 0x20, 0x00, 0x30, 0x47, 0x01,
0x78,
                                0x02, 0x78, 0x02, 0x08, 0x08, 0x47, 0x01,
0x78,
                                0x06, 0x78, 0x06, 0x08, 0x08, 0x22, 0x80,
0x00,
                                0x30, 0x47, 0x01, 0x78, 0x01, 0x78, 0x01,
0x08,
                                0x08, 0x47, 0x01, 0x78, 0x05, 0x78, 0x05,
0x08,
                                0x08, 0x22, 0x80, 0x00, 0x30, 0x47, 0x01,
0x78,
                                0x01, 0x78, 0x01, 0x08, 0x08, 0x47, 0x01,
0x78,
                                0x05, 0x78, 0x05, 0x08, 0x08, 0x22, 0x20,
0x00,
                                0x38, 0x79, 0x00
                            })
                        }

                        Method (_DIS, 0, NotSerialized)
                        {
                            LDRS (0x01, 0x30, 0x00)
                        }

                        Method (_CRS, 0, NotSerialized)
                        {
                            Name (DCRS, Buffer (0x15)
                            {
                                0x47, 0x01, 0x78, 0x03, 0x78, 0x03, 0x08,
0x08,
                                0x47, 0x01, 0x78, 0x07, 0x78, 0x07, 0x08,
0x08,
                                0x22, 0x80, 0x00, 0x79, 0x00
                            })
                            Store (LDRG (0x01, 0x60), Local1)
                            Store (LDRG (0x01, 0x61), Local0)
                            Store (Local0, Index (DCRS, 0x02))
                            Store (Local0, Index (DCRS, 0x0A))
                            Store (Local0, Index (DCRS, 0x04))
                            Store (Local0, Index (DCRS, 0x0C))
                            Store (Local1, Index (DCRS, 0x03))
                            Store (Local1, Index (DCRS, 0x05))
                            Add (Local1, 0x04, Local1)
                            Store (Local1, Index (DCRS, 0x0B))
                            Store (Local1, Index (DCRS, 0x0D))
                            ShiftLeft (0x01, LDRG (0x01, 0x70), Local0)
                            Store (Local0, Index (DCRS, 0x11))
                            ShiftRight (Local0, 0x08, Local1)
                            Store (Local1, Index (DCRS, 0x12))
                            Return (DCRS)
                        }

                        Method (_SRS, 1, NotSerialized)
                        {
                            CreateByteField (Arg0, 0x02, ADRL)
                            CreateByteField (Arg0, 0x03, ADRM)
                            CreateWordField (Arg0, 0x11, IRQM)
                            FindSetRightBit (IRQM, Local0)
                            Decrement (Local0)
                            LDRS (0x01, 0x70, Local0)
                            LDRS (0x01, 0x60, ADRM)
                            LDRS (0x01, 0x61, ADRL)
                            LDRS (0x01, 0x30, 0x01)
                        }
                    }

                    Device (LPTB)
                    {
                        Name (_HID, EisaId ("PNP0400"))
                        Name (_UID, 0x01)
                        Method (_STA, 0, NotSerialized)
                        {
                            Store (LDRG (0x01, 0xF0), Local0)
                            ShiftRight (Local0, 0x05, Local0)
                            If (LAnd (RCF6 (0x02), LEqual (Local0, 0x01)))
                            {
                                ShiftLeft (LDRG (0x01, 0x30), 0x01, Local1)
                                Add (0x0D, Local1, Local1)
                                Return (Local1)
                            }
                            Else
                            {
                                Return (0x00)
                            }
                        }

                        Method (_PS0, 0, NotSerialized)
                        {
                            LDRS (0x01, 0x30, 0x01)
                        }

                        Method (_PS3, 0, NotSerialized)
                        {
                            LDRS (0x01, 0x30, 0x00)
                        }

                        Method (_PRS, 0, NotSerialized)
                        {
                            Return (Buffer (0x7B)
                            {
                                0x30, 0x47, 0x01, 0x78, 0x03, 0x78, 0x03,
0x08,
                                0x08, 0x47, 0x01, 0x78, 0x07, 0x78, 0x07,
0x08,
                                0x08, 0x22, 0x80, 0x00, 0x30, 0x47, 0x01,
0x78,
                                0x02, 0x78, 0x02, 0x08, 0x08, 0x47, 0x01,
0x78,
                                0x06, 0x78, 0x06, 0x08, 0x08, 0x22, 0x20,
0x00,
                                0x30, 0x47, 0x01, 0x78, 0x03, 0x78, 0x03,
0x08,
                                0x08, 0x47, 0x01, 0x78, 0x07, 0x78, 0x07,
0x08,
                                0x08, 0x22, 0x20, 0x00, 0x30, 0x47, 0x01,
0x78,
                                0x02, 0x78, 0x02, 0x08, 0x08, 0x47, 0x01,
0x78,
                                0x06, 0x78, 0x06, 0x08, 0x08, 0x22, 0x80,
0x00,
                                0x30, 0x47, 0x01, 0xBC, 0x03, 0xBC, 0x03,
0x04,
                                0x04, 0x47, 0x01, 0xBC, 0x07, 0xBC, 0x07,
0x04,
                                0x04, 0x22, 0x80, 0x00, 0x30, 0x47, 0x01,
0xBC,
                                0x03, 0xBC, 0x03, 0x04, 0x04, 0x47, 0x01,
0xBC,
                                0x07, 0xBC, 0x07, 0x04, 0x04, 0x22, 0x20,
0x00,
                                0x38, 0x79, 0x00
                            })
                        }

                        Method (_DIS, 0, NotSerialized)
                        {
                            LDRS (0x01, 0x30, 0x00)
                        }

                        Method (_CRS, 0, NotSerialized)
                        {
                            Name (DCRS, Buffer (0x15)
                            {
                                0x47, 0x01, 0x78, 0x03, 0x78, 0x03, 0x08,
0x08,
                                0x47, 0x01, 0x78, 0x07, 0x78, 0x07, 0x08,
0x08,
                                0x22, 0x80, 0x00, 0x79, 0x00
                            })
                            Store (LDRG (0x01, 0x60), Local1)
                            Store (LDRG (0x01, 0x61), Local0)
                            Store (Local0, Index (DCRS, 0x02))
                            Store (Local0, Index (DCRS, 0x0A))
                            Store (Local0, Index (DCRS, 0x04))
                            Store (Local0, Index (DCRS, 0x0C))
                            Store (Local1, Index (DCRS, 0x03))
                            Store (Local1, Index (DCRS, 0x05))
                            Add (Local1, 0x04, Local1)
                            Store (Local1, Index (DCRS, 0x0B))
                            Store (Local1, Index (DCRS, 0x0D))
                            If (And (Local0, 0x04))
                            {
                                Store (0x04, Local0)
                            }
                            Else
                            {
                                Store (0x08, Local0)
                            }

                            Store (Local0, Index (DCRS, 0x06))
                            Store (Local0, Index (DCRS, 0x07))
                            Store (Local0, Index (DCRS, 0x0E))
                            Store (Local0, Index (DCRS, 0x0F))
                            ShiftLeft (0x01, LDRG (0x01, 0x70), Local0)
                            Store (Local0, Index (DCRS, 0x11))
                            ShiftRight (Local0, 0x08, Local1)
                            Store (Local1, Index (DCRS, 0x12))
                            Return (DCRS)
                        }

                        Method (_SRS, 1, NotSerialized)
                        {
                            CreateByteField (Arg0, 0x02, ADRL)
                            CreateByteField (Arg0, 0x03, ADRM)
                            CreateWordField (Arg0, 0x11, IRQM)
                            FindSetRightBit (IRQM, Local0)
                            Decrement (Local0)
                            LDRS (0x01, 0x70, Local0)
                            LDRS (0x01, 0x60, ADRM)
                            LDRS (0x01, 0x61, ADRL)
                            LDRS (0x01, 0x30, 0x01)
                        }
                    }

                    Device (LPT)
                    {
                        Name (_HID, EisaId ("PNP0400"))
                        Name (_UID, 0x00)
                        Method (_STA, 0, NotSerialized)
                        {
                            Store (LDRG (0x01, 0xF0), Local0)
                            ShiftRight (Local0, 0x05, Local0)
                            If (LAnd (RCF6 (0x02), LEqual (Local0, 0x00)))
                            {
                                ShiftLeft (LDRG (0x01, 0x30), 0x01, Local1)
                                Add (0x0D, Local1, Local1)
                                Return (Local1)
                            }
                            Else
                            {
                                Return (0x00)
                            }
                        }

                        Method (_PS0, 0, NotSerialized)
                        {
                            LDRS (0x01, 0x30, 0x01)
                        }

                        Method (_PS3, 0, NotSerialized)
                        {
                            LDRS (0x01, 0x30, 0x00)
                        }

                        Method (_PRS, 0, NotSerialized)
                        {
                            Return (Buffer (0x7B)
                            {
                                0x30, 0x47, 0x01, 0x78, 0x03, 0x78, 0x03,
0x08,
                                0x08, 0x47, 0x01, 0x78, 0x07, 0x78, 0x07,
0x08,
                                0x08, 0x22, 0x80, 0x00, 0x30, 0x47, 0x01,
0x78,
                                0x02, 0x78, 0x02, 0x08, 0x08, 0x47, 0x01,
0x78,
                                0x06, 0x78, 0x06, 0x08, 0x08, 0x22, 0x20,
0x00,
                                0x30, 0x47, 0x01, 0x78, 0x03, 0x78, 0x03,
0x08,
                                0x08, 0x47, 0x01, 0x78, 0x07, 0x78, 0x07,
0x08,
                                0x08, 0x22, 0x20, 0x00, 0x30, 0x47, 0x01,
0x78,
                                0x02, 0x78, 0x02, 0x08, 0x08, 0x47, 0x01,
0x78,
                                0x06, 0x78, 0x06, 0x08, 0x08, 0x22, 0x80,
0x00,
                                0x30, 0x47, 0x01, 0xBC, 0x03, 0xBC, 0x03,
0x04,
                                0x04, 0x47, 0x01, 0xBC, 0x07, 0xBC, 0x07,
0x04,
                                0x04, 0x22, 0x80, 0x00, 0x30, 0x47, 0x01,
0xBC,
                                0x03, 0xBC, 0x03, 0x04, 0x04, 0x47, 0x01,
0xBC,
                                0x07, 0xBC, 0x07, 0x04, 0x04, 0x22, 0x20,
0x00,
                                0x38, 0x79, 0x00
                            })
                        }

                        Method (_DIS, 0, NotSerialized)
                        {
                            LDRS (0x01, 0x30, 0x00)
                        }

                        Method (_CRS, 0, NotSerialized)
                        {
                            Name (DCRS, Buffer (0x15)
                            {
                                0x47, 0x01, 0x78, 0x03, 0x78, 0x03, 0x08,
0x08,
                                0x47, 0x01, 0x78, 0x07, 0x78, 0x07, 0x08,
0x08,
                                0x22, 0x80, 0x00, 0x79, 0x00
                            })
                            Store (LDRG (0x01, 0x60), Local1)
                            Store (LDRG (0x01, 0x61), Local0)
                            Store (Local0, Index (DCRS, 0x02))
                            Store (Local0, Index (DCRS, 0x0A))
                            Store (Local0, Index (DCRS, 0x04))
                            Store (Local0, Index (DCRS, 0x0C))
                            Store (Local1, Index (DCRS, 0x03))
                            Store (Local1, Index (DCRS, 0x05))
                            Add (Local1, 0x04, Local1)
                            Store (Local1, Index (DCRS, 0x0B))
                            Store (Local1, Index (DCRS, 0x0D))
                            If (And (Local0, 0x04))
                            {
                                Store (0x04, Local0)
                            }
                            Else
                            {
                                Store (0x08, Local0)
                            }

                            Store (Local0, Index (DCRS, 0x06))
                            Store (Local0, Index (DCRS, 0x07))
                            Store (Local0, Index (DCRS, 0x0E))
                            Store (Local0, Index (DCRS, 0x0F))
                            ShiftLeft (0x01, LDRG (0x01, 0x70), Local0)
                            Store (Local0, Index (DCRS, 0x11))
                            ShiftRight (Local0, 0x08, Local1)
                            Store (Local1, Index (DCRS, 0x12))
                            Return (DCRS)
                        }

                        Method (_SRS, 1, NotSerialized)
                        {
                            CreateByteField (Arg0, 0x02, ADRL)
                            CreateByteField (Arg0, 0x03, ADRM)
                            CreateWordField (Arg0, 0x11, IRQM)
                            FindSetRightBit (IRQM, Local0)
                            Decrement (Local0)
                            LDRS (0x01, 0x70, Local0)
                            LDRS (0x01, 0x60, ADRM)
                            LDRS (0x01, 0x61, ADRL)
                            LDRS (0x01, 0x30, 0x01)
                        }
                    }

                    Device (FDC)
                    {
                        Name (_HID, EisaId ("PNP0700"))
                        Name (_UID, 0x00)
                        Method (_STA, 0, NotSerialized)
                        {
                            If (RCF6 (0x01))
                            {
                                ShiftLeft (LDRG (0x00, 0x30), 0x01, Local1)
                                Add (0x0D, Local1, Local1)
                                Return (Local1)
                            }
                            Else
                            {
                                Return (0x00)
                            }
                        }

                        Method (_PRS, 0, NotSerialized)
                        {
                            Return (Buffer (0x31)
                            {
                                0x30, 0x47, 0x01, 0xF0, 0x03, 0xF0, 0x03,
0x08,
                                0x06, 0x47, 0x01, 0xF7, 0x03, 0xF7, 0x03,
0x01,
                                0x01, 0x22, 0x40, 0x00, 0x2A, 0x04, 0x00,
0x30,
                                0x47, 0x01, 0x70, 0x03, 0x70, 0x03, 0x08,
0x06,
                                0x47, 0x01, 0x77, 0x03, 0x77, 0x03, 0x01,
0x01,
                                0x22, 0x40, 0x00, 0x2A, 0x04, 0x00, 0x38,
0x79,
                                0x00
                            })
                        }

                        Method (_DIS, 0, NotSerialized)
                        {
                            LDRS (0x00, 0x30, 0x00)
                        }

                        Method (_CRS, 0, NotSerialized)
                        {
                            Name (DCRS, Buffer (0x18)
                            {
                                0x47, 0x01, 0xF0, 0x03, 0xF0, 0x03, 0x08,
0x06,
                                0x47, 0x01, 0xF7, 0x03, 0xF7, 0x03, 0x01,
0x01,
                                0x22, 0x40, 0x00, 0x2A, 0x04, 0x00, 0x79,
0x00
                            })
                            Store (LDRG (0x00, 0x60), Local1)
                            Store (LDRG (0x00, 0x61), Local0)
                            Store (Local0, Index (DCRS, 0x02))
                            Store (Local0, Index (DCRS, 0x04))
                            Add (Local0, 0x07, Local0)
                            Store (Local0, Index (DCRS, 0x0A))
                            Store (Local0, Index (DCRS, 0x0C))
                            Store (Local1, Index (DCRS, 0x03))
                            Store (Local1, Index (DCRS, 0x05))
                            Store (Local1, Index (DCRS, 0x0B))
                            Store (Local1, Index (DCRS, 0x0D))
                            ShiftLeft (0x01, LDRG (0x00, 0x70), Local0)
                            Store (Local0, Index (DCRS, 0x11))
                            ShiftRight (Local0, 0x08, Local1)
                            Store (Local1, Index (DCRS, 0x12))
                            ShiftLeft (0x01, LDRG (0x00, 0x74), Local0)
                            Store (Local0, Index (DCRS, 0x14))
                            ShiftRight (Local0, 0x08, Local1)
                            Store (Local1, Index (DCRS, 0x15))
                            Return (DCRS)
                        }

                        Method (_SRS, 1, NotSerialized)
                        {
                            CreateByteField (Arg0, 0x02, ADRL)
                            CreateByteField (Arg0, 0x03, ADRM)
                            CreateWordField (Arg0, 0x11, IRQM)
                            CreateWordField (Arg0, 0x14, DMAM)
                            FindSetRightBit (IRQM, Local0)
                            Decrement (Local0)
                            FindSetRightBit (DMAM, Local1)
                            Decrement (Local1)
                            LDRS (0x00, 0x70, Local0)
                            LDRS (0x00, 0x74, Local1)
                            LDRS (0x00, 0x60, ADRM)
                            LDRS (0x00, 0x61, ADRL)
                            LDRS (0x00, 0x30, 0x01)
                        }
                    }
                }

                Device (EC0)
                {
                    Name (_HID, EisaId ("PNP0C09"))
                    Name (_CRS, Buffer (0x12)
                    {
                        0x47, 0x01, 0x62, 0x00, 0x62, 0x00, 0x01, 0x01,
                        0x47, 0x01, 0x66, 0x00, 0x66, 0x00, 0x01, 0x01,
                        0x79, 0x00
                    })
                    Name (_GPE, 0x1D)
                    Name (OSEJ, 0x00)
                    Name (ECOK, 0x00)
                    Method (_REG, 2, NotSerialized)
                    {
                        If (LEqual (Arg0, 0x03))
                        {
                            Store (Arg1, \_SB.OKEC)
                        }
                    }

                    OperationRegion (ERAM, EmbeddedControl, 0x00, 0xFF)
                    Field (ERAM, ByteAcc, NoLock, Preserve)
                    {
                        Offset (0x04),
                        CMCM,   8,
                        CMD1,   8,
                        CMD2,   8,
                        CMD3,   8,
                        Offset (0x18),
                        SMPR,   8,
                        SMST,   8,
                        SMAD,   8,
                        SMCM,   8,
                        SMD0,   256,
                        BCNT,   8,
                        SMAA,   8,
                        BATD,   16,
                        ACDF,   1,
                        Offset (0x41),
                            ,   4,
                        FPR1,   1,
                        PFN2,   1,
                            ,   1,
                        PFLG,   1,
                        Offset (0x43),
                        TMSS,   2,
                            ,   2,
                        BANK,   4,
                        Offset (0x45),
                        VFAN,   1,
                        Offset (0x46),
                        RL01,   1,
                        RD01,   1,
                        RF01,   1,
                        RP01,   1,
                        RB01,   1,
                        RC01,   1,
                            ,   1,
                        R701,   1,
                        R801,   1,
                        RM01,   1,
                        RI01,   1,
                            ,   1,
                            ,   1,
                            ,   1,
                        RA01,   1,
                        RR01,   1,
                        RL10,   1,
                        RD10,   1,
                        RF10,   1,
                        RP10,   1,
                        RB10,   1,
                        RC10,   1,
                            ,   1,
                        R710,   1,
                        R810,   1,
                        RM10,   1,
                        RI10,   1,
                            ,   1,
                            ,   1,
                            ,   1,
                        RA10,   1,
                        RR10,   1,
                        WL01,   1,
                        WD01,   1,
                        WF01,   1,
                        WP01,   1,
                        WB01,   1,
                        WC01,   1,
                            ,   1,
                        W701,   1,
                        W801,   1,
                        WM01,   1,
                        WI01,   1,
                            ,   1,
                            ,   1,
                            ,   1,
                        WA01,   1,
                        WR01,   1,
                        WL10,   1,
                        WD10,   1,
                        WF10,   1,
                        WP10,   1,
                        WB10,   1,
                        WC10,   1,
                            ,   1,
                        W710,   1,
                        W810,   1,
                        WM10,   1,
                        WI10,   1,
                            ,   1,
                            ,   1,
                            ,   1,
                        WA10,   1,
                        WR10,   1,
                        LIDE,   1,
                        BAYE,   1,
                        EFDE,   1,
                        PRDE,   1,
                        BRBE,   1,
                        CRTE,   1,
                            ,   1,
                        W7BE,   1,
                        W8BE,   1,
                        PMEE,   1,
                        INTE,   1,
                            ,   1,
                            ,   1,
                            ,   1,
                        DB2E,   1,
                        DB3E,   1,
                        Offset (0x52),
                        LIDS,   1,
                        BAYS,   1,
                        EFDS,   1,
                        PRDS,   1,
                        BRBS,   1,
                        CRTS,   1,
                            ,   1,
                        W7BS,   1,
                        W8BS,   1,
                        DPEM,   1,
                        DINT,   1,
                            ,   1,
                            ,   1,
                            ,   1,
                        DB2S,   1,
                        DB3S,   1,
                        Offset (0x57),
                        RG57,   8,
                        CTMP,   8,
                        RG59,   8,
                        RG5A,   8,
                        RG5B,   8,
                        FSPD,   16,
                        Offset (0x5F),
                        FAN2,   1,
                        SFN2,   1,
                        Offset (0x60),
                        UCPU,   1,
                        LCPU,   1,
                        Offset (0x61),
                        CPWR,   8,
                        UPWL,   8,
                        LPWL,   8,
                        Offset (0x71),
                        MBTS,   1,
                        MBTF,   1,
                        Offset (0x72),
                        MBTC,   1,
                            ,   2,
                        MBNH,   1,
                        Offset (0x77),
                        BA1C,   8,
                        MBVG,   16,
                        Offset (0x7E),
                        BCLN,   8,
                        Offset (0x81),
                        SBTS,   1,
                        SBTF,   1,
                        Offset (0x82),
                        SBTC,   1,
                        Offset (0x87),
                        BA2C,   8,
                        ABVG,   16,
                        Offset (0xC1),
                        MCUR,   16,
                        MBRM,   16,
                        Offset (0xC8),
                        ACUR,   16,
                        ABRM,   16,
                        Offset (0xD0),
                        EBPL,   1,
                        Offset (0xD2),
                            ,   6,
                        APWR,   1,
                        Offset (0xD6),
                        DBPL,   8,
                        Offset (0xE7),
                        GQKS,   7
                    }

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

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

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

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

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

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

                    Mutex (MUT0, 0x00)
                    Method (SMRD, 4, NotSerialized)
                    {
                        If (LNot (\_SB.OKEC))
                        {
                            Return (0xFF)
                        }

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

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

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

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

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

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

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

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

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

                        Release (MUT0)
                        Return (Local0)
                    }

                    Method (SMWR, 4, NotSerialized)
                    {
                        If (LNot (\_SB.OKEC))
                        {
                            Return (0xFF)
                        }

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

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

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

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

                            And (SMST, 0x40, SMST)
                            Store (Arg2, SMCM)
                            Store (Arg1, SMAD)
                            Store (Arg0, SMPR)
                            Store (0x00, Local3)
                            While (LNot (And (SMST, 0xBF, Local1)))
                            {
                                Sleep (0x02)
                                Increment (Local3)
                                If (LEqual (Local3, 0x32))
                                {
                                    And (SMST, 0x40, SMST)
                                    Store (Arg2, SMCM)
                                    Store (Arg1, SMAD)
                                    Store (Arg0, SMPR)
                                    Store (0x00, Local3)
                                }
                            }

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

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

                        Release (MUT0)
                        Return (Local0)
                    }

                    Method (BPOL, 1, NotSerialized)
                    {
                        Store (Arg0, DBPL)
                        Store (0x01, EBPL)
                    }

                    Name (ECUS, 0x00)
                    Name (BATO, 0x00)
                    Name (BATN, 0x00)
                    Name (BATF, 0xC0)
                    Method (_Q09, 0, NotSerialized)
                    {
                        If (\_SB.POPF)
                        {
                            Store (0x91, \_SB.PCI0.LPC0.BCMD)
                            Store (0x00, \_SB.PCI0.LPC0.SMIC)
                        }
                        Else
                        {
                            If (LEqual (SizeOf (\_OS), 0x14))
                            {
                                Notify (\_SB.BAT1, 0x80)
                                Notify (\_SB.BAT1, 0x00)
                                Notify (\_SB.ACAD, 0x00)
                            }
                        }

                        If (LEqual (SizeOf (\_OS), 0x14))
                        {
                            BPOL (0x3C)
                        }
                    }

                    Method (_Q20, 0, NotSerialized)
                    {
                        If (And (SMST, 0x40))
                        {
                            Store (SMAA, Local0)
                            If (LEqual (Local0, 0x14))
                            {
                                SELE ()
                                If (And (0x40, BATF))
                                {
                                    Notify (\_SB.BAT1, 0x81)
                                }

                                If (And (0x02, BATF))
                                {
                                    Notify (\_SB.ACAD, 0x00)
                                }

                                Notify (\_SB.BAT1, 0x80)
                                Store (BATD, BATO)
                                And (SMST, 0xBF, SMST)
                            }
                        }
                    }

                    Method (SELE, 0, NotSerialized)
                    {
                        Store (BATD, BATN)
                        Store (0x00, BATF)
                        If (And (0xC0, BATN))
                        {
                            Or (BATF, 0x01, BATF)
                        }

                        If (And (0x0300, BATN))
                        {
                            Or (BATF, 0x04, BATF)
                        }

                        And (BATN, 0x01, Local0)
                        And (BATO, 0x01, Local1)
                        If (Local0)
                        {
                            Or (BATF, 0x0100, BATF)
                        }
                        Else
                        {
                            And (BATF, 0xFEFF, BATF)
                        }

                        If (Not (LEqual (Local0, Local1)))
                        {
                            Or (BATF, 0x40, BATF)
                        }

                        And (BATN, 0xC0, Local0)
                        And (BATO, 0xC0, Local1)
                        If (Not (LEqual (Local0, Local1)))
                        {
                            Or (BATF, 0x02, BATF)
                        }

                        If (And (0x01, BATF))
                        {
                            If (And (0x04, BATF))
                            {
                                Or (BATF, 0x10, BATF)
                            }
                        }
                    }

                    Method (_Q0E, 0, NotSerialized)
                    {
                        Store (0x90, \_SB.PCI0.LPC0.BCMD)
                        Store (0x00, \_SB.PCI0.LPC0.SMIC)
                        If (\_SB.OVRL)
                        {
                            If (\_SB.PCI0.AGP.VGA.SWIT)
                            {
                                Store (0x99, \_SB.PCI0.LPC0.BCMD)
                                Store (0x00, \_SB.PCI0.LPC0.SMIC)
                            }
                            Else
                            {
                                \_SB.PCI0.AGP.VGA.SWIH ()
                            }
                        }
                    }

                    Method (_Q15, 0, NotSerialized)
                    {
                        Notify (\_SB.SLPB, 0x80)
                    }

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

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

                    Method (_Q8A, 0, NotSerialized)
                    {
                        If (LIDE)
                        {
                            Store (0x01, LIDE)
                            Notify (\_SB.LID, 0x80)
                        }
                    }

                    Method (_Q8F, 0, NotSerialized)
                    {
                        If (UCPU)
                        {
                            Store (0x9E, \_SB.PCI0.LPC0.BCMD)
                            Store (0x00, \_SB.PCI0.LPC0.SMIC)
                        }
                        Else
                        {
                            Store (0x9F, \_SB.PCI0.LPC0.BCMD)
                            Store (0x00, \_SB.PCI0.LPC0.SMIC)
                        }
                    }
                }

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

                OperationRegion (SMI1, SystemMemory, 0x0FEFFEBD, 0x00000090)
                Field (SMI1, AnyAcc, NoLock, Preserve)
                {
                    BCMD,   8,
                    DID,    32,
                    INFO,   1024
                }

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

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

            Device (HUB)
            {
                Name (_ADR, 0x001E0000)
                Name (_PRT, Package (0x06)
                {
                    Package (0x04)
                    {
                        0x0002FFFF,
                        0x00,
                        \_SB.LNKC,
                        0x00
                    },

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

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

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

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

                    Package (0x04)
                    {
                        0x0008FFFF,
                        0x00,
                        \_SB.LNKE,
                        0x00
                    }
                })
                Device (ILAN)
                {
                    Name (_ADR, 0x00080000)
                    OperationRegion (NPCC, PCI_Config, 0xE0, 0xEF)
                    Field (NPCC, ByteAcc, NoLock, Preserve)
                    {
                        ILE0,   8,
                        IPME,   1
                    }

                    Name (_PRW, Package (0x02)
                    {
                        0x0B,
                        0x03
                    })
                    Method (_PSW, 1, NotSerialized)
                    {
                        If (LEqual (Arg0, One))
                        {
                            Store (One, LANK)
                        }
                        Else
                        {
                            Store (Zero, LANK)
                        }
                    }

                    Name (LANK, One)
                }

                Device (CRD0)
                {
                    Name (_ADR, 0x00020000)
                    Name (_PSC, 0x00)
                    Name (PFST, 0x00)
                    Name (S4ST, 0x01)
                    OperationRegion (NPCC, PCI_Config, 0x00, 0xE0)
                    Field (NPCC, DWordAcc, NoLock, Preserve)
                    {
                        Offset (0x04),
                        TI04,   8,
                        Offset (0x44),
                        TI44,   16,
                        Offset (0x80),
                        TI80,   8,
                        Offset (0x8E),
                        TI8E,   8,
                        Offset (0x91),
                        TI91,   8,
                        Offset (0xA4),
                        TIA4,   8,
                        TIA5,   8
                    }

                    OperationRegion (TIIO, SystemIO, 0x03E0, 0x02)
                    Field (TIIO, ByteAcc, NoLock, Preserve)
                    {
                        TIID,   8,
                        TIDA,   8
                    }

                    Method (_PS0, 0, NotSerialized)
                    {
                        Store (0x00, TIA4)
                        Store (0x80, TIA5)
                    }

                    Method (_PS2, 0, NotSerialized)
                    {
                        Store (0x00, TIA4)
                        Store (0x80, TIA5)
                    }

                    Method (_PS3, 0, NotSerialized)
                    {
                        Store (Or (TIA5, 0x01), TIA5)
                        Store (0x02, TIA4)
                    }

                    Method (_PSW, 1, NotSerialized)
                    {
                        If (LEqual (Arg0, One))
                        {
                            Store (One, TIWK)
                        }
                        Else
                        {
                            Store (Zero, TIWK)
                        }
                    }

                    Name (TIWK, One)
                    Name (EX03, Zero)
                    Method (TIEN, 1, NotSerialized)
                    {
                        If (TIWK)
                        {
                            If (LEqual (Arg0, One))
                            {
                                Store (TIA4, Local0)
                                Store (And (0xF0, TIA4), TIA4)
                                Store (TI04, Local1)
                                Store (Or (TI04, 0x01), TI04)
                                Store (0x03E1, TI44)
                                Store (0x03, TIID)
                                Store (TIDA, EX03)
                                Store (Or (EX03, 0x80), TIDA)
                                Store (Zero, TI44)
                                Store (Local1, TI04)
                                Store (Local0, TIA4)
                                Store (Or (TIA5, 0x01), TIA5)
                            }

                            If (LEqual (Arg0, Zero))
                            {
                                If (And (TIA5, 0x80))
                                {
                                    Store (TIA5, Local0)
                                    Store (Local0, TIA5)
                                    Notify (\_SB.PCI0.HUB.CRD0, 0x00)
                                }
                            }
                        }
                    }
                }

                Device (ESS)
                {
                    Name (_ADR, 0x00030000)
                    OperationRegion (ESSR, PCI_Config, 0x00, 0x50)
                    Field (ESSR, DWordAcc, NoLock, Preserve)
                    {
                        VID,    32
                    }

                    Method (_INI, 0, NotSerialized)
                    {
                        Store (0x95, \_SB.PCI0.LPC0.BCMD)
                        Store (0x00, \_SB.PCI0.LPC0.SMIC)
                    }
                }
            }

            Device (IDE0)
            {
                Name (_ADR, 0x001F0001)
                OperationRegion (PCI, PCI_Config, 0x00, 0x58)
                Field (PCI, DWordAcc, NoLock, Preserve)
                {
                    Offset (0x42),
                        ,   1,
                    EIOR,   1,
                        ,   13,
                    ESID,   1,
                    Offset (0x48),
                    UMA0,   1,
                    UMA1,   1,
                    UMA2,   1,
                    UMA3,   1,
                    Offset (0x56),
                    PSIG,   2,
                    SSIG,   2
                }

                Field (PCI, DWordAcc, NoLock, Preserve)
                {
                    Offset (0x40),
                    ITM0,   16,
                    ITM1,   16,
                    SIT0,   4,
                    SIT1,   4,
                    Offset (0x48),
                    UDC0,   2,
                    UDC1,   2,
                    Offset (0x4A),
                    UDT0,   8,
                    UDT1,   8,
                    Offset (0x54),
                    ICF0,   2,
                    ICF1,   2,
                    CB80,   4,
                        ,   2,
                    WPPE,   1,
                        ,   1,
                    FSCB,   4,
                    TRIP,   2,
                    TRIS,   2,
                    FATS,   4
                }

                Name (TIM0, Package (0x01)
                {
                    Package (0x05)
                    {
                        0x78,
                        0xB4,
                        0xF0,
                        0x0186,
                        0x0258
                    }
                })
                Name (TIM1, Package (0x01)
                {
                    Package (0x03)
                    {
                        0x78,
                        0x96,
                        0x01FE
                    }
                })
                Name (TIM2, Package (0x01)
                {
                    Package (0x06)
                    {
                        0x18,
                        0x1E,
                        0x2D,
                        0x3C,
                        0x5A,
                        0x78
                    }
                })
                Name (AT01, Buffer (0x07)
                {
                    0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0xEF
                })
                Name (AT02, Buffer (0x07)
                {
                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x90
                })
                Name (AT03, Buffer (0x07)
                {
                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC6
                })
                Name (AT04, Buffer (0x07)
                {
                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x91
                })
                Name (ATA0, Buffer (0x1D) {})
                Name (ATA1, Buffer (0x1D) {})
                Name (ATA2, Buffer (0x1D) {})
                Name (ATA3, Buffer (0x1D) {})
                Name (ATAB, Buffer (0x0E) {})
                Name (CMDC, 0x00)
                Method (_INI, 0, NotSerialized)
                {
                }

                Method (GTFB, 3, Serialized)
                {
                    Multiply (CMDC, 0x38, Local0)
                    CreateField (ATAB, Local0, 0x38, CMDX)
                    Multiply (CMDC, 0x07, Local0)
                    CreateByteField (ATAB, Add (Local0, 0x01), A001)
                    CreateByteField (ATAB, Add (Local0, 0x05), A005)
                    Store (Arg0, CMDX)
                    Store (Arg1, A001)
                    Store (Arg2, A005)
                    Increment (CMDC)
                }

                Mutex (GTFM, 0x00)
                Method (GTF, 3, Serialized)
                {
                    Acquire (GTFM, 0xFFFF)
                    CreateDWordField (Arg2, 0x00, PIO0)
                    CreateDWordField (Arg2, 0x04, DMA0)
                    CreateDWordField (Arg2, 0x08, PIO1)
                    CreateDWordField (Arg2, 0x0C, DMA1)
                    CreateDWordField (Arg2, 0x10, CHNF)
                    Store (0x00, CMDC)
                    Name (ID00, 0x80)
                    Name (ID49, 0x0C00)
                    Name (ID59, 0x00)
                    Name (ID53, 0x04)
                    Name (ID63, 0x0F00)
                    Name (ID88, 0x0F00)
                    Name (IRDY, 0x01)
                    Name (PIOT, 0x00)
                    Name (DMAT, 0x00)
                    If (LEqual (SizeOf (Arg1), 0x0200))
                    {
                        CreateByteField (Arg1, 0x00, IB00)
                        Store (IB00, ID00)
                        CreateWordField (Arg1, 0x62, IW49)
                        Store (IW49, ID49)
                        CreateWordField (Arg1, 0x6A, IW53)
                        Store (IW53, ID53)
                        CreateWordField (Arg1, 0x7E, IW63)
                        Store (IW63, ID63)
                        CreateWordField (Arg1, 0x76, IW59)
                        Store (IW59, ID59)
                        CreateWordField (Arg1, 0xB0, IW88)
                        Store (IW88, ID88)
                    }
                    Else
                    {
                        Return (ATAB)
                    }

                    Store (0xA0, Local7)
                    If (Arg0)
                    {
                        Store (0xB0, Local7)
                        And (CHNF, 0x08, IRDY)
                        If (And (CHNF, 0x10))
                        {
                            Store (PIO1, PIOT)
                        }
                        Else
                        {
                            Store (PIO0, PIOT)
                        }

                        If (And (CHNF, 0x04))
                        {
                            If (And (CHNF, 0x10))
                            {
                                Store (DMA1, DMAT)
                            }
                            Else
                            {
                                Store (DMA0, DMAT)
                            }
                        }
                    }
                    Else
                    {
                        And (CHNF, 0x02, IRDY)
                        Store (PIO0, PIOT)
                        If (And (CHNF, 0x01))
                        {
                            Store (DMA0, DMAT)
                        }
                    }

                    If (LAnd (And (ID53, 0x04), And (ID88, 0xFF)))
                    {
                        Store (0x00, Local1)
                        And (ID88, 0xFF, Local2)
                        While (ShiftRight (Local2, Local1))
                        {
                            Increment (Local1)
                        }

                        Decrement (Local1)
                        GTFB (AT01, Or (0x40, Local1), Local7)
                    }

                    If (IRDY)
                    {
                        Store (Match (DerefOf (Index (TIM0, 0x00)), MGE,
PIOT, MTR, 0x00, 0x00), Local1)
                        If (LEqual (Local1, Ones))
                        {
                            Store (0x04, Local1)
                        }

                        Subtract (0x04, Local1, Local1)
                        GTFB (AT01, Or (0x08, Local1), Local7)
                    }
                    Else
                    {
                        If (And (ID49, 0x0400))
                        {
                            GTFB (AT01, 0x01, Local7)
                        }
                    }

                    Release (GTFM)
                    Return (ATAB)
                }

                Method (RATA, 1, NotSerialized)
                {
                    CreateByteField (Arg0, 0x00, CMDN)
                    Multiply (CMDN, 0x38, Local0)
                    CreateField (Arg0, 0x08, Local0, RETB)
                    Return (RETB)
                }

                Name (REGF, 0x01)
                Method (_REG, 2, NotSerialized)
                {
                    If (LEqual (Arg0, 0x02))
                    {
                        Store (Arg1, REGF)
                    }
                }

                Name (BAYD, 0x00)
                Method (_STA, 0, NotSerialized)
                {
                    Return (0x0F)
                }

                Method (GTM, 6, NotSerialized)
                {
                    Store (Buffer (0x14) {}, Local0)
                    CreateDWordField (Local0, 0x00, PIO0)
                    CreateDWordField (Local0, 0x04, DMA0)
                    CreateDWordField (Local0, 0x08, PIO1)
                    CreateDWordField (Local0, 0x0C, DMA1)
                    CreateDWordField (Local0, 0x10, FLAG)
                    If (LOr (And (Arg0, 0x08), LNot (And (Arg0, 0x01))))
                    {
                        Store (0x0384, PIO0)
                    }
                    Else
                    {
                        Add (ShiftRight (And (Arg0, 0x0300), 0x08),
ShiftRight (And (Arg0, 0x3000), 0x0C), Local1)
                        Multiply (Subtract (0x09, Local1), 0x1E, PIO0)
                    }

                    If (And (Arg0, 0x4000))
                    {
                        If (LOr (And (Arg0, 0x80), LNot (And (Arg0, 0x10))))
                        {
                            Store (0x0384, PIO1)
                        }
                        Else
                        {
                            Add (And (Arg1, 0x03), ShiftRight (And (Arg1,
0x0C), 0x02), Local1)
                            Multiply (Subtract (0x09, Local1), 0x1E, PIO1)
                        }
                    }
                    Else
                    {
                        Store (PIO0, PIO1)
                    }

                    If (And (Arg2, 0x01))
                    {
                        If (And (Arg5, 0x01))
                        {
                            Store (0x08, DMA0)
                        }
                        Else
                        {
                            Subtract (0x04, And (Arg3, 0x03), Local1)
                            If (And (Arg4, 0x01))
                            {
                                Multiply (Local1, 0x0F, DMA0)
                            }
                            Else
                            {
                                Multiply (Local1, 0x1E, DMA0)
                            }
                        }
                    }
                    Else
                    {
                        Store (PIO0, DMA0)
                    }

                    If (And (Arg0, 0x4000))
                    {
                        If (And (Arg2, 0x02))
                        {
                            If (And (Arg5, 0x02))
                            {
                                Store (0x08, DMA1)
                            }
                            Else
                            {
                                Subtract (0x04, ShiftRight (And (Arg3,
0x30), 0x04), Local1)
                                If (And (Arg4, 0x02))
                                {
                                    Multiply (Local1, 0x0F, DMA1)
                                }
                                Else
                                {
                                    Multiply (Local1, 0x1E, DMA1)
                                }
                            }
                        }
                        Else
                        {
                            Store (PIO1, DMA1)
                        }
                    }
                    Else
                    {
                        Store (DMA0, DMA1)
                    }

                    Store (Zero, FLAG)
                    If (And (Arg0, 0x01))
                    {
                        Or (FLAG, 0x10, FLAG)
                    }

                    If (And (Arg2, 0x01))
                    {
                        Or (FLAG, 0x01, FLAG)
                    }

                    If (And (Arg0, 0x02))
                    {
                        Or (FLAG, 0x02, FLAG)
                    }

                    If (And (Arg2, 0x02))
                    {
                        Or (FLAG, 0x04, FLAG)
                    }

                    If (And (Arg0, 0x20))
                    {
                        Or (FLAG, 0x08, FLAG)
                    }

                    Return (Local0)
                }

                Method (STMS, 3, NotSerialized)
                {
                    Store (Buffer (0x18) {}, Local7)
                    CreateDWordField (Local7, 0x00, ITM)
                    CreateDWordField (Local7, 0x04, SIT)
                    CreateDWordField (Local7, 0x08, UDC)
                    CreateDWordField (Local7, 0x0C, UDT)
                    CreateDWordField (Local7, 0x10, ICF)
                    CreateDWordField (Local7, 0x14, A100)
                    Store (0x01, WPPE)
                    CreateDWordField (Arg0, 0x00, PIO0)
                    CreateDWordField (Arg0, 0x04, DMA0)
                    CreateDWordField (Arg0, 0x08, PIO1)
                    CreateDWordField (Arg0, 0x0C, DMA1)
                    CreateDWordField (Arg0, 0x10, FLAG)
                    Store (FLAG, Local4)
                    Store (0x4000, Local0)
                    Name (W49M, 0x00)
                    Name (W53M, 0x00)
                    Name (W62M, 0x00)
                    Name (W64M, 0x00)
                    Name (W88M, 0x00)
                    If (LEqual (SizeOf (Arg1), 0x0200))
                    {
                        CreateDWordField (Arg1, 0x00, W00A)
                        CreateDWordField (Arg1, 0x62, W49A)
                        CreateDWordField (Arg1, 0x6A, W53A)
                        CreateDWordField (Arg1, 0x7C, W62A)
                        CreateDWordField (Arg1, 0x80, W64A)
                        CreateDWordField (Arg1, 0xB0, W88A)
                        Store (W49A, W49M)
                        Store (W53A, W53M)
                        Store (W62A, W62M)
                        Store (W64A, W64M)
                        Store (W88A, W88M)
                        If (W00A)
                        {
                            Or (Local0, 0x8000, Local0)
                        }

                        If (LNot (And (W00A, 0x80)))
                        {
                            Or (Local0, 0x04, Local0)
                        }
                    }
                    Else
                    {
                        Store (0x00, W49M)
                        Store (0x00, W53M)
                        Store (0x00, W62M)
                        Store (0x00, W64M)
                        Store (0x00, W88M)
                    }

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

                    If (LAnd (And (W49M, 0x0800), And (Local4, 0x02)))
                    {
                        Or (Local0, 0x02, Local0)
                    }

                    If (LLess (PIO0, 0x0384))
                    {
                        Or (Local0, 0x01, Local0)
                    }

                    If (And (Local4, 0x01))
                    {
                        Store (PIO0, Local1)
                    }
                    Else
                    {
                        Store (DMA0, Local1)
                    }

                    If (LNot (LLess (Local1, 0xF0)))
                    {
                        Or (Local0, 0x08, Local0)
                    }
                    Else
                    {
                        If (And (W53M, 0x02))
                        {
                            If (LAnd (And (W64M, 0x02), LNot (LGreater
(Local1, 0x78))))
                            {
                                Or (Local0, 0x2301, Local0)
                            }
                            Else
                            {
                                If (LAnd (And (W64M, 0x01), LNot (LGreater
(Local1, 0xB4))))
                                {
                                    Or (Local0, 0x2101, Local0)
                                }
                            }
                        }
                        Else
                        {
                            Or (Local0, 0x1001, Local0)
                        }
                    }

                    Store (Local0, ITM)
                    Store (0x00, SIT)
                    Store (0x00, Local0)
                    If (LAnd (And (0x3F, W88M), And (Local4, 0x01)))
                    {
                        Or (Local0, 0x01, Local0)
                    }

                    Store (Local0, UDC)
                    Store (0x00, Local0)
                    If (And (Local4, 0x01))
                    {
                        If (LLess (DMA0, 0x1E))
                        {
                            Or (A100, 0x1000, A100)
                            Or (Local0, 0x01, Local0)
                        }
                        Else
                        {
                            If (LLess (DMA0, 0x3C))
                            {
                                Divide (DMA0, 0x0F, , Local1)
                            }
                            Else
                            {
                                Divide (DMA0, 0x1E, , Local1)
                            }

                            Subtract (0x04, Local1, Local0)
                        }
                    }

                    Store (Local0, UDT)
                    Store (0x00, Local0)
                    If (LLess (DMA0, 0x3C))
                    {
                        Or (Local0, 0x01, Local0)
                    }

                    Store (Local0, ICF)
                    Return (Local7)
                }

                Method (GTF0, 7, NotSerialized)
                {
                    Store (Buffer (0x07)
                        {
                            0x03, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF
                        }, Local7)
                    CreateByteField (Local7, 0x01, MODE)
                    If (And (Arg2, 0x01))
                    {
                        If (And (Arg6, 0x01))
                        {
                            Store (0x45, MODE)
                        }
                        Else
                        {
                            And (Arg3, 0x03, Local0)
                            If (And (Arg4, 0x01))
                            {
                                Add (Local0, 0x02, Local0)
                            }

                            Or (Local0, 0x40, MODE)
                        }
                    }
                    Else
                    {
                        Add (ShiftRight (And (Arg0, 0x0300), 0x08),
ShiftRight (And (Arg0, 0x3000), 0x0C), Local0)
                        If (LNot (LLess (Local0, 0x05)))
                        {
                            Store (0x22, MODE)
                        }
                        Else
                        {
                            If (LNot (LLess (Local0, 0x03)))
                            {
                                Store (0x21, MODE)
                            }
                            Else
                            {
                                Store (0x20, MODE)
                            }
                        }
                    }

                    Concatenate (Local7, Local7, Local6)
                    If (LOr (And (Arg0, 0x08), LNot (And (Arg0, 0x01))))
                    {
                        If (And (Arg0, 0x02))
                        {
                            Store (0x00, MODE)
                        }
                        Else
                        {
                            Store (0x08, MODE)
                        }
                    }
                    Else
                    {
                        Add (ShiftRight (And (Arg0, 0x0300), 0x08),
ShiftRight (And (Arg0, 0x3000), 0x0C), Local0)
                        If (LNot (LLess (Local0, 0x05)))
                        {
                            Store (0x0C, MODE)
                        }
                        Else
                        {
                            If (LNot (LLess (Local0, 0x03)))
                            {
                                Store (0x0B, MODE)
                            }
                            Else
                            {
                                Store (0x0A, MODE)
                            }
                        }
                    }

                    Concatenate (Local6, Local7, Local5)
                    Return (Local5)
                }

                Name (B04, Buffer (0x04) {})
                Name (B20, Buffer (0x04) {})
                Name (B40, Buffer (0x04) {})
                Device (PRIM)
                {
                    Name (_ADR, 0x00)
                    Name (_PSC, 0x00)
                    Method (_PS0, 0, NotSerialized)
                    {
                        Store (0x00, _PSC)
                    }

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

                    Method (_GTM, 0, NotSerialized)
                    {
                        Store (Buffer (0x14)
                            {
                                0x00
                            }, Local0)
                        Store (^^GTM (^^ITM0, ^^SIT0, ^^UDC0, ^^UDT0,
^^ICF0, ^^FSCB), Local0)
                        Return (Local0)
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        Store (GTF (0x00, Arg1, Arg0), ATA0)
                        Store (^^STMS (Arg0, Arg1, Arg2), Local0)
                        CreateDWordField (Local0, 0x00, ITM)
                        CreateDWordField (Local0, 0x04, SIT)
                        CreateDWordField (Local0, 0x08, UDC)
                        CreateDWordField (Local0, 0x0C, UDT)
                        CreateDWordField (Local0, 0x10, ICF)
                        Store (ITM, ^^ITM0)
                        Store (SIT, ^^SIT0)
                        Store (UDC, ^^UDC0)
                        Store (UDT, ^^UDT0)
                        CreateDWordField (Local0, 0x14, A100)
                        Or (And (^^CB80, 0x0C), ShiftRight (And (0x30,
A100), 0x04), ^^CB80)
                        Or (And (^^FSCB, 0x0C), ShiftRight (And (0x3000,
A100), 0x0C), ^^FSCB)
                        Or (And (^^FATS, 0x0C), ShiftRight (And (0x00300000,
A100), 0x14), ^^FATS)
                        Store (ICF, ^^ICF0)
                    }

                    Device (MAST)
                    {
                        Name (_ADR, 0x00)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Return (RATA (ATA0))
                        }
                    }
                }

                Device (SECN)
                {
                    Name (_ADR, 0x01)
                    Method (_STA, 0, NotSerialized)
                    {
                        Return (0x0F)
                    }

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

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

                    Method (_GTM, 0, NotSerialized)
                    {
                        Store (Buffer (0x14)
                            {
                                0x00
                            }, Local0)
                        Store (^^FSCB, Local1)
                        ShiftRight (Local1, 0x02, Local1)
                        Store (^^GTM (^^ITM1, ^^SIT1, ^^UDC1, ^^UDT1,
^^ICF1, Local1), Local0)
                        Return (Local0)
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        Store (GTF (0x00, Arg1, Arg0), ATA2)
                        Store (^^STMS (Arg0, Arg1, Arg2), Local0)
                        CreateDWordField (Local0, 0x00, ITM)
                        CreateDWordField (Local0, 0x04, SIT)
                        CreateDWordField (Local0, 0x08, UDC)
                        CreateDWordField (Local0, 0x0C, UDT)
                        CreateDWordField (Local0, 0x10, ICF)
                        Store (ITM, ^^ITM1)
                        Store (SIT, ^^SIT1)
                        Store (UDC, ^^UDC1)
                        Store (UDT, ^^UDT1)
                        CreateDWordField (Local0, 0x14, A100)
                        Or (And (^^CB80, 0x03), ShiftRight (And (0x30,
A100), 0x02), ^^CB80)
                        Or (And (^^FSCB, 0x03), ShiftRight (And (0x3000,
A100), 0x0A), ^^FSCB)
                        Or (And (^^FATS, 0x03), ShiftRight (And (0x00300000,
A100), 0x12), ^^FATS)
                        Store (ICF, ^^ICF1)
                    }

                    Device (BAY1)
                    {
                        Name (_ADR, 0x00)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Return (RATA (ATA2))
                        }

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

                Method (_PS0, 0, NotSerialized)
                {
                    If (And (LEqual (_PSC, 0x03), LEqual (\_SB.STAT, 0x03)))
                    {
                        Store (0x89, \_SB.PCI0.LPC0.BCMD)
                        Store (0x00, \_SB.PCI0.LPC0.SMIC)
                    }

                    Store (0x00, _PSC)
                }

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

                Name (_PSC, 0x00)
            }

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

                Name (_PRW, Package (0x02)
                {
                    0x03,
                    0x03
                })
                Method (_PSW, 1, NotSerialized)
                {
                    If (Arg0)
                    {
                        Store (0x03, \_SB.PCI0.USB1.RSEN)
                    }
                    Else
                    {
                        Store (0x00, \_SB.PCI0.USB1.RSEN)
                    }
                }
            }
        }

        Device (LID)
        {
            Name (_HID, EisaId ("PNP0C0D"))
            Name (_PRW, Package (0x02)
            {
                0x1C,
                0x03
            })
            Name (LSTS, 0x00)
            Method (_LID, 0, NotSerialized)
            {
                If (\_SB.OKEC)
                {
                    If (\_SB.PCI0.LPC0.EC0.LIDS)
                    {
                        Store (Zero, LSTS)
                    }
                    Else
                    {
                        Store (One, LSTS)
                    }
                }
                Else
                {
                    Store (Zero, LSTS)
                }

                Return (LSTS)
            }

            Method (_PSW, 1, NotSerialized)
            {
                If (LEqual (\_SB.W2KF, 0x00))
                {
                    If (Arg0)
                    {
                        Store (One, \_SB.PCI0.LPC0.EC0.WL10)
                    }
                    Else
                    {
                        If (LEqual (\_SB.SLEE, 0x03))
                        {
                            Store (Zero, \_SB.PCI0.LPC0.EC0.WL10)
                        }
                    }
                }
                Else
                {
                    If (\_SB.OKEC)
                    {
                        If (LEqual (Arg0, 0x01))
                        {
                            If (\_SB.PCI0.LPC0.EC0.LIDS)
                            {
                                Store (One, \_SB.PCI0.LPC0.EC0.WL10)
                            }
                            Else
                            {
                                Store (Zero, \_SB.PCI0.LPC0.EC0.WL10)
                            }
                        }
                        Else
                        {
                            Store (Zero, \_SB.PCI0.LPC0.EC0.WL10)
                        }
                    }
                }
            }
        }

        Device (ACAD)
        {
            Name (_HID, "ACPI0003")
            Name (_PCL, Package (0x01)
            {
                \_SB
            })
            Name (ACWT, 0x00)
            Method (_PSR, 0, NotSerialized)
            {
                Store (\_SB.ACST, ACWT)
                If (\_SB.OKEC)
                {
                    Store (\_SB.PCI0.LPC0.EC0.ACDF, \_SB.ACST)
                }

                If (LNot (LEqual (ACWT, \_SB.ACST)))
                {
                    Store (0x8B, \_SB.PCI0.LPC0.BCMD)
                    Store (0x00, \_SB.PCI0.LPC0.SMIC)
                }

                Return (\_SB.ACST)
            }
        }

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

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

            Return (Local1)
        }

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

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

        Method (POSW, 1, NotSerialized)
        {
            If (And (Arg0, 0x8000))
            {
                If (LEqual (Arg0, 0xFFFF))
                {
                    Return (0xFFFFFFFF)
                }
                Else
                {
                    Not (Arg0, Local0)
                    Increment (Local0)
                    And (Local0, 0xFFFF, Local0)
                    Return (Local0)
                }
            }
            Else
            {
                Return (Arg0)
            }
        }

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

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

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

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

            Return (Local0)
        }

        Device (BAT1)
        {
            Name (_HID, EisaId ("PNP0C0A"))
            Name (_UID, 0x01)
            Name (_PCL, Package (0x01)
            {
                \_SB
            })
            Name (PBIF, Package (0x0D)
            {
                0x01,
                0xFFFFFFFF,
                0xFFFFFFFF,
                0x01,
                0xFFFFFFFF,
                0xFA,
                0x64,
                0x0A,
                0x19,
                "BAT1",
                " ",
                " ",
                " "
            })
            Name (PBST, Package (0x04)
            {
                0x00,
                0xFFFFFFFF,
                0xFFFFFFFF,
                0x2710
            })
            Name (BAST, 0x00)
            Name (FAST, 0x1B)
            Name (B1ST, 0x0F)
            Name (B1WT, 0x00)
            Method (_STA, 0, NotSerialized)
            {
                If (LLess (FAST, 0x20))
                {
                    Increment (FAST)
                    If (LEqual (FAST, 0x20))
                    {
                        Store (0x9D, \_SB.PCI0.LPC0.BCMD)
                        Store (0x00, \_SB.PCI0.LPC0.SMIC)
                    }
                }

                If (\_SB.OKEC)
                {
                    If (\_SB.PCI0.LPC0.EC0.MBTS)
                    {
                        Store (0x1F, B1ST)
                        Store (\_SB.PCI0.LPC0.EC0.BA1C, \_SB.CM26)
                    }
                    Else
                    {
                        Store (0x0F, B1ST)
                        Store (0xFF, \_SB.CM26)
                    }
                }
                Else
                {
                    Store (0x0F, B1ST)
                }

                Return (B1ST)
            }

            Method (_BIF, 0, NotSerialized)
            {
                If (\_SB.OKEC)
                {
                    If (\_SB.PCI0.LPC0.EC0.MBTS)
                    {
                        UPBI ()
                    }
                    Else
                    {
                        IVBI ()
                    }
                }
                Else
                {
                    IVBI ()
                }

                Return (PBIF)
            }

            Method (_BST, 0, NotSerialized)
            {
                If (\_SB.OKEC)
                {
                    If (\_SB.PCI0.LPC0.EC0.MBTS)
                    {
                        UPBS ()
                    }
                    Else
                    {
                        IVBS ()
                    }
                }
                Else
                {
                    IVBS ()
                }

                Return (PBST)
            }

            Method (UPBI, 0, NotSerialized)
            {
                Store (0x1FFF, Local2)
                \_SB.PCI0.LPC0.EC0.SMWR (0x08, 0x14, 0x01, Local2)
                \_SB.PCI0.LPC0.EC0.SMRD (0x09, 0x14, 0x01, RefOf (Local3))
                If (LEqual (Local2, Or (Local3, 0x0FFF)))
                {
                    If (LNot (\_SB.PCI0.LPC0.EC0.SMRD (0x09, 0x16, 0x10,
RefOf (Local5))))
                    {
                        Store (Local5, Index (PBIF, 0x02))
                    }
                }

                If (\_SB.PCI0.LPC0.EC0.MBNH)
                {
                    Store (0x2328, Index (PBIF, 0x01))
                    Store (0x1C20, Index (PBIF, 0x04))
                    Store ("OANI$", Index (PBIF, 0x09))
                    Store ("NiMH", Index (PBIF, 0x0B))
                }
                Else
                {
                    If (LEqual (\_SB.PCI0.LPC0.EC0.BCLN, 0x42))
                    {
                        Store (0x1130, Index (PBIF, 0x01))
                        Store ("OAL4$3", Index (PBIF, 0x09))
                    }
                    Else
                    {
                        Store (0x1770, Index (PBIF, 0x01))
                        Store ("OAL4$1", Index (PBIF, 0x09))
                    }

                    Store (0x39D0, Index (PBIF, 0x04))
                    Store ("LION", Index (PBIF, 0x0B))
                }

                If (LNot (\_SB.PCI0.LPC0.EC0.SMRD (0x0B, 0x16, 0x20, RefOf
(Local6))))
                {
                    Store (Local6, Index (PBIF, 0x0C))
                }
                Else
                {
                    Store ("SANYO", Index (PBIF, 0x0C))
                }

                Store (0x01, Index (PBIF, 0x00))
                If (LEqual (SizeOf (\_OS), 0x27))
                {
                    Store (0x00, Index (PBIF, 0x00))
                }
            }

            Method (UPBS, 0, NotSerialized)
            {
                Store (\_SB.PCI0.LPC0.EC0.MCUR, Local5)
                Store (POSW (Local5), Index (PBST, 0x01))
                Store (\_SB.PCI0.LPC0.EC0.MBRM, Index (PBST, 0x02))
                Store (\_SB.PCI0.LPC0.EC0.MBVG, Index (PBST, 0x03))
                If (\_SB.PCI0.LPC0.EC0.MBTC)
                {
                    Store (0x02, Index (PBST, 0x00))
                }
                Else
                {
                    Store (0x01, Index (PBST, 0x00))
                }

                Store (\_SB.PCI0.LPC0.EC0.BA1C, \_SB.CM26)
            }

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

            Method (IVBS, 0, NotSerialized)
            {
                Store (0x00, Index (PBST, 0x00))
                Store (0xFFFFFFFF, Index (PBST, 0x01))
                Store (0xFFFFFFFF, Index (PBST, 0x02))
                Store (0x2710, Index (PBST, 0x03))
                Store (0xFF, \_SB.CM26)
            }
        }

        Scope (\_TZ)
        {
            Name (TAC2, 0x0D04)
            Name (TAC1, 0x0D36)
            Name (TAC0, 0x0D68)
            Name (TPAS, 0x0DE0)
            Name (TPC, 0x0E4E)
            Name (TPTM, 0x0C3C)
            Name (TBSE, 0x0AAC)
            Name (LTMP, 0x0CA0)
            Name (TVAR, Buffer (0x05)
            {
                0x00, 0x20, 0x1F, 0x0C, 0x1F
            })
            CreateByteField (TVAR, 0x00, PLCY)
            CreateWordField (TVAR, 0x01, CTOS)
            CreateWordField (TVAR, 0x03, CTHY)
            Device (FAN0)
            {
                Name (_HID, EisaId ("PNP0C0B"))
                Name (_UID, 0x01)
                Name (_PR0, Package (0x01)
                {
                    PFN0
                })
                Method (_PS0, 0, NotSerialized)
                {
                    Store ("Low Speed FAN - _PS0", Debug)
                }

                Method (_PS3, 0, NotSerialized)
                {
                    Store ("Low Speed FAN - _PS3", Debug)
                }
            }

            PowerResource (PFN0, 0x00, 0x0000)
            {
                Name (FNS1, 0x00)
                Name (FFST, 0x01)
                Method (_STA, 0, NotSerialized)
                {
                    Store (FNS1, Local1)
                    If (\_SB.OKEC)
                    {
                        Store (0x00, Local1)
                        If (\_SB.PCI0.LPC0.EC0.FPR1)
                        {
                            Store (0x01, Local1)
                        }
                    }

                    Return (Local1)
                }

                Method (_ON, 0, NotSerialized)
                {
                    Store (0x01, FNS1)
                    If (\_TZ.PFN1.FNS2)
                    {
                        Store ("FAN 1 (Low speed already turn on) ", Debug)
                    }
                    Else
                    {
                        If (\_SB.OKEC)
                        {
                            Store (0xB4, \_SB.PCI0.LPC0.EC0.FSPD)
                            Store (0x01, \_SB.PCI0.LPC0.EC0.FPR1)
                        }
                    }

                    \_TZ.THRM._SCP (0x01)
                }

                Method (_OFF, 0, NotSerialized)
                {
                    Store (0x00, FNS1)
                    If (LEqual (SizeOf (\_OS), 0x14))
                    {
                        If (\_SB.OKEC)
                        {
                            Store (0x00, \_SB.PCI0.LPC0.EC0.FPR1)
                        }
                    }
                    Else
                    {
                        If (LLess (FFST, 0x02))
                        {
                            Store (0x86, \_SB.PCI0.LPC0.BCMD)
                            Store (0x00, \_SB.PCI0.LPC0.SMIC)
                            Increment (FFST)
                        }
                        Else
                        {
                            If (\_SB.OKEC)
                            {
                                Store (0x00, \_SB.PCI0.LPC0.EC0.FPR1)
                            }
                        }
                    }

                    \_TZ.THRM._SCP (0x01)
                }
            }

            Device (FAN1)
            {
                Name (_HID, EisaId ("PNP0C0B"))
                Name (_UID, 0x02)
                Name (_PR0, Package (0x01)
                {
                    PFN1
                })
                Method (_PS0, 0, NotSerialized)
                {
                    Store ("High Speed FAN - _PS0", Debug)
                }

                Method (_PS3, 0, NotSerialized)
                {
                    Store ("High Speed FAN - _PS3", Debug)
                }
            }

            PowerResource (PFN1, 0x00, 0x0000)
            {
                Name (FNS2, 0x00)
                Method (_STA, 0, NotSerialized)
                {
                    Return (FNS2)
                }

                Method (_ON, 0, NotSerialized)
                {
                    Store (One, FNS2)
                    If (\_SB.OKEC)
                    {
                        Store (0xFF, \_SB.PCI0.LPC0.EC0.FSPD)
                        Store (0x01, \_SB.PCI0.LPC0.EC0.FPR1)
                    }

                    \_TZ.THRM._SCP (0x01)
                }

                Method (_OFF, 0, NotSerialized)
                {
                    Store (Zero, FNS2)
                    If (\_TZ.PFN0.FNS1)
                    {
                        If (\_SB.OKEC)
                        {
                            Store (0xB4, \_SB.PCI0.LPC0.EC0.FSPD)
                            Store (0x01, \_SB.PCI0.LPC0.EC0.FPR1)
                        }
                    }
                    Else
                    {
                        If (\_SB.OKEC)
                        {
                            Store (0x00, \_SB.PCI0.LPC0.EC0.FPR1)
                        }
                    }

                    \_TZ.THRM._SCP (0x01)
                }
            }

            Device (FAN2)
            {
                Name (_HID, EisaId ("PNP0C0B"))
                Name (_UID, 0x03)
                Name (_PR0, Package (0x01)
                {
                    PFN2
                })
                Method (_PS0, 0, NotSerialized)
                {
                    Store ("Sec-FAN - _PS0", Debug)
                }

                Method (_PS3, 0, NotSerialized)
                {
                    Store ("Sec-FAN - _PS3", Debug)
                }
            }

            PowerResource (PFN2, 0x00, 0x0000)
            {
                Name (FNS3, 0x00)
                Method (_STA, 0, NotSerialized)
                {
                    Return (FNS3)
                }

                Method (_ON, 0, NotSerialized)
                {
                    Store (One, FNS3)
                    Store (0x01, \_SB.PCI0.LPC0.LV43)
                    \_TZ.THRM._SCP (0x01)
                }

                Method (_OFF, 0, NotSerialized)
                {
                    Store (Zero, FNS3)
                    Store (0x00, \_SB.PCI0.LPC0.LV43)
                    \_TZ.THRM._SCP (0x01)
                }
            }

            ThermalZone (THRM)
            {
                Method (_INI, 0, NotSerialized)
                {
                    Store (\_SB.CM28, Local0)
                    If (LLess (Local0, 0x1C))
                    {
                        Add (0x0AAC, Multiply (0x52, 0x0A), TPAS)
                    }
                    Else
                    {
                        Add (0x0AAC, Multiply (0x4C, 0x0A), TPAS)
                    }
                }

                Name (_AL0, Package (0x01)
                {
                    FAN2
                })
                Method (_AC0, 0, NotSerialized)
                {
                    Return (TAC0)
                }

                Name (_AL1, Package (0x01)
                {
                    FAN1
                })
                Method (_AC1, 0, NotSerialized)
                {
                    Return (TAC1)
                }

                Name (_AL2, Package (0x01)
                {
                    FAN0
                })
                Method (_AC2, 0, NotSerialized)
                {
                    Return (TAC2)
                }

                Method (_CRT, 0, NotSerialized)
                {
                    Return (TPC)
                }

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

                Name (_TSP, 0x64)
                Method (_TMP, 0, NotSerialized)
                {
                    If (\_SB.OKEC)
                    {
                        Store (\_SB.PCI0.LPC0.EC0.CTMP, Local1)
                        Store ("Current Temperature is ----------- ", Debug)
                        Store (Local1, Debug)
                        Store (Local1, \_SB.CM25)
                        Add (Multiply (Local1, 0x0A), TBSE, Local1)
                    }
                    Else
                    {
                        Store (LTMP, Local1)
                    }

                    Return (Local1)
                }

                Name (_PSL, Package (0x01)
                {
                    \_PR.CPU0
                })
                Name (_TC1, 0x02)
                Name (_TC2, 0x03)
                Method (_SCP, 1, NotSerialized)
                {
                    Store (Zero, PLCY)
                    If (\_TZ.PFN0.FNS1)
                    {
                        Store (0x0CF0, TAC2)
                    }
                    Else
                    {
                        Store (0x0D0E, TAC2)
                    }

                    If (\_TZ.PFN1.FNS2)
                    {
                        Store (0x0D22, TAC1)
                    }
                    Else
                    {
                        Store (0x0D40, TAC1)
                    }

                    If (\_TZ.PFN2.FNS3)
                    {
                        Store (0x0D22, TAC0)
                    }
                    Else
                    {
                        Store (0x0D54, TAC0)
                    }

                    Notify (\_TZ.THRM, 0x81)
                }
            }
        }

        Device (SLPB)
        {
            Name (_HID, EisaId ("PNP0C0E"))
        }

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

        IndexField (INDX, DATA, ByteAcc, NoLock, Preserve)
        {
            Offset (0x20),
            ACST,   1,
            OKEC,   1,
            POPF,   1,
            BLTF,   1,
            W2KF,   2,
            S4WP,   1,
            FLA7,   1,
            LSFG,   1,
            LD10,   1,
            PS2M,   1,
            DISD,   3,
            OVRL,   1,
            Offset (0x22),
            SLEE,   8,
            BPFG,   8,
            PWST,   8,
            CM25,   8,
            CM26,   8,
            CM27,   8,
            CM28,   16,
            CM2A,   16,
            DKID,   32,
            CM30,   8,
            CM31,   8,
            CM32,   8
        }
    }
}

