From owner-acpi-jp@jp.FreeBSD.org Fri May 24 08:35:57 2002
Received: (from daemon@localhost)
	by castle.jp.FreeBSD.org (8.11.6+3.4W/8.11.3) id g4NNZvl47746;
	Fri, 24 May 2002 08:35:57 +0900 (JST)
	(envelope-from owner-acpi-jp@jp.FreeBSD.org)
Received: from mailbox-7.st1.spray.net (mailbox-7.st1.spray.net [212.78.202.107])
	by castle.jp.FreeBSD.org (8.11.6+3.4W/8.11.3) with ESMTP/inet id g4NNZrv47734
	for <acpi-jp@jp.FreeBSD.org>; Fri, 24 May 2002 08:35:54 +0900 (JST)
	(envelope-from jordi_yc@lycos.es)
Received: from harry2 (pcp813816pcs.nrockv01.md.comcast.net [68.49.67.154])
	by mailbox-7.st1.spray.net (8.8.8/8.8.8) with ESMTP id BAA24314
	for <acpi-jp@jp.FreeBSD.org>; Fri, 24 May 2002 01:35:20 +0200 (DST)
Posted-Date: Fri, 24 May 2002 01:35:20 +0200 (DST)
Content-Type: text/plain;
  charset="us-ascii"
From: Jordi YC <jordi_yc@lycos.es>
To: acpi-jp@jp.FreeBSD.org
Date: Thu, 23 May 2002 19:35:18 -0400
X-Mailer: KMail [version 1.4]
MIME-Version: 1.0
Content-Transfer-Encoding: 8bit
Message-Id: <200205231935.19260.jordi_yc@lycos.es>
Reply-To: acpi-jp@jp.FreeBSD.org
Precedence: list
X-Distribute: distribute version 2.1 (Alpha) patchlevel 24e+020417
X-Sequence: acpi-jp 1616
Subject: [acpi-jp 1616] ACPI and Sony Vaios (II)
Errors-To: owner-acpi-jp@jp.FreeBSD.org
Sender: owner-acpi-jp@jp.FreeBSD.org
X-Originator: jordi_yc@lycos.es

Hi,

I am an owner of a Sony Vaio PCG-R505TEK running FreeBSD -CURRENT. I have been 
reading some messages in this lists about the Sony BIOS and the ACPI 
implementation. If I am not wrong, the Sony BIOS contains some propietary 
code that are specific for a specific windows version.

Is there anyone using ACPI successfully with a Vaio?

According to the following thread, it is possible to override the BIOS 
implementation using acpitools and dumping / loading DSDT file...(?)
http://groups.google.com/groups?hl=en&lr=&threadm=20011116.000207.74756347.iwasaki_jp.FreeBSD.org%40ns.sol.net&rnum=2&prev=/groups%3Fhl%3Den%26lr%3D%26q%3Dacpi-jp%2Bfor%2Bvaio%2Busers

Can this procedure going to solve Sony's BIOS problem? If yes, where can I get 
more information about this?

Thanks!
Jordi


Follows the content of the acpidump:

/*
RSD PTR: Checksum=83, OEMID=PTLTD, RsdtAddress=0x13cf7391
 */
/*
RSDT: Length=44, Revision=1, Checksum=238,
	OEMID=SONY, OEM Table ID=U1, OEM Revision=0x20010921,
	Creator ID=PTL, Creator Revision=0x0
 */
/*
	Entries={ 0x13cfbf64, 0x13cfbfd8 }
 */
/*
	DSDT=0x13cf73bd
	INT_MODEL=PIC
	SCI_INT=9
	SMI_CMD=0xb2, ACPI_ENABLE=0xf0, ACPI_DISABLE=0xf1, S4BIOS_REQ=0x0
	PM1a_EVT_BLK=0x1000-0x1003
	PM1a_CNT_BLK=0x1004-0x1005
	PM2_CNT_BLK=0x1020-0x1020
	PM2_TMR_BLK=0x1008-0x100b
	PM2_GPE0_BLK=0x1028-0x102b
	PM2_GPE1_BLK=0x102c-0x102f, GPE1_BASE=16
	P_LVL2_LAT=10ms, P_LVL3_LAT=1001ms
	FLUSH_SIZE=0, FLUSH_STRIDE=0
	DUTY_OFFSET=1, DUTY_WIDTH=3
	DAY_ALRM=13, MON_ALRM=0, CENTURY=50
	Flags={WBINVD,PWR_BUTTON,SLP_BUTTON,RTC_S4,DCK_CAP}
 */
/*
DSDT: Length=19367, Revision=1, Checksum=228,
	OEMID=SONY, OEM Table ID=U1, OEM Revision=0x20010921,
	Creator ID=PTL, Creator Revision=0x100000b
 */
DefinitionBlock (
    "acpi_dsdt.aml",	//Output filename
    "DSDT",		//Signature
    0x1,		//DSDT Revision
    "SONY",		//OEMID
    "U1",		//TABLE ID
    0x20010921		//OEM Revision
)

{
Scope(_PR_) {
    Processor(CPU0, 0, 0x1010, 0x6) {
        Name(_PCT, Package(0x2) {
            Buffer(0x11) {0x82, 0xc, 0x0, 0x1, 0x8, 0x0, 0x0, 0xb2, 0x0, 0x0, 
0x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x0 },
            Buffer(0x11) {0x82, 0xc, 0x0, 0x1, 0x8, 0x0, 0x0, 0xb3, 0x0, 0x0, 
0x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x0 },
        })
        Name(_PSS, Package(0x2) {
            Package(0x6) {
                0x02ee,
                0x3db8,
                0x00fa,
                0x00c8,
                0x83,
                0x0,
            },
            Package(0x6) {
                0x0258,
                0x21fc,
                0x00fa,
                0x00c8,
                0x84,
                0x1,
            },
        })
        Method(_PPC) {
            Return(0x0)
        }
    }
}
Name(_S0_, Package(0x2) {
    0x0,
    0x0,
})
Name(_S3_, Package(0x2) {
    0x5,
    0x5,
})
Name(_S4_, Package(0x2) {
    0x6,
    0x6,
})
Name(_S5_, Package(0x2) {
    0x7,
    0x7,
})
Method(_PTS, 1) {
    If(LEqual(Arg0, 0x3)) {
        Store(\_SB_.PCI0.LPC0.SPIC._CRS(), \_SB_.PCI0.LPC0.SPIC.SSRC)
        PHS_(0xa0)
        If(LNot(LOr(\_SB_.PCI0.USB1.RSEN, \_SB_.PCI0.USB2.RSEN))) {
            Store(Zero, \_SB_.PCI0.LPC0.GP25)
        }
        Else {
            Store(One, \_SB_.PCI0.LPC0.GP25)
        }
    }
    If(LEqual(Arg0, 0x4)) {
        Store(\_SB_.PCI0.LPC0.SPIC._CRS(), \_SB_.PCI0.LPC0.SPIC.SSRC)
        PHS_(0xa2)
    }
    If(LOr(LEqual(Arg0, 0x3), LEqual(Arg0, 0x4))) {
        Store(\_SB_.DOCK.GDST(), \_SB_.DOCK.DKST)
    }
}
OperationRegion(SMI0, SystemMemory, 0x13cfcb38, 0x00000415)
Field(SMI0, AnyAcc, NoLock, Preserve) {
    BCMD,	8,
    DID_,	32,
    INFO,	4096
}
Field(SMI0, AnyAcc, NoLock, Preserve) {
    Offset(0x5),
    INFB,	8
}
Field(SMI0, AnyAcc, NoLock, Preserve) {
    Offset(0x5),
    INFD,	32
}
Field(SMI0, AnyAcc, NoLock, Preserve) {
    Offset(0x5),
    SXBF,	8320
}
Field(SMI0, AnyAcc, NoLock, Preserve) {
    Offset(0x5),
    INF1,	8,
    INF2,	8
}
OperationRegion(SMI1, SystemIO, 0x0000fe00, 0x00000002)
Field(SMI1, AnyAcc, NoLock, Preserve) {
    SMIC,	8
}
Mutex(MPHS, 0)
Method(PHS0, 1) {
    Store(Arg0, BCMD)
    Store(Zero, SMIC)
    While(LEqual(BCMD, Arg0)) {
    }
    Store(0x0, BCMD)
}
Method(PHS_, 1, Serialized) {
    Acquire(MPHS, 0xffff)
    Store(0x0, DID_)
    PHS0(Arg0)
    Store(INFD, Local0)
    Release(MPHS)
    Return(Local0)
}
Method(PHSD, 2, Serialized) {
    Acquire(MPHS, 0xffff)
    Store(0x0, DID_)
    Store(Arg1, INFD)
    PHS0(Arg0)
    Store(INFD, Local0)
    Release(MPHS)
    Return(Local0)
}
Method(PHSW, 3, Serialized) {
    Acquire(MPHS, 0xffff)
    Store(0x0, DID_)
    Store(Arg1, INF1)
    Store(Arg2, INF2)
    PHS0(Arg0)
    Store(INFB, Local0)
    Release(MPHS)
    Return(Local0)
}
Method(PHSB, 2, Serialized) {
    Acquire(MPHS, 0xffff)
    Store(0x0, DID_)
    Store(Arg1, INFB)
    PHS0(Arg0)
    Store(INFB, Local0)
    Release(MPHS)
    Return(Local0)
}
Method(PSCS, 1, Serialized) {
    Acquire(MPHS, 0xffff)
    Store(Arg0, DID_)
    PHS0(0x0)
    Store(INFO, Local0)
    Release(MPHS)
    Return(Local0)
}
Method(PSSS, 2, Serialized) {
    Acquire(MPHS, 0xffff)
    Store(Arg0, DID_)
    Store(Arg1, INFO)
    PHS0(0x1)
    Release(MPHS)
}
Method(PSPS, 1, Serialized) {
    Acquire(MPHS, 0xffff)
    Store(Arg0, DID_)
    PHS0(0x2)
    Store(INFO, Local0)
    Release(MPHS)
    Return(Local0)
}
Method(PSDI, 1, Serialized) {
    Acquire(MPHS, 0xffff)
    Store(Arg0, DID_)
    PHS0(0x3)
    Release(MPHS)
}
Method(PSST, 1, Serialized) {
    Acquire(MPHS, 0xffff)
    Store(Arg0, DID_)
    PHS0(0x4)
    Store(INFB, Local0)
    Release(MPHS)
    Return(Local0)
}
Scope(\_GPE) {
    Method(_L03) {
        Notify(\_SB_.PCI0.USB1, 0x2)
    }
    Method(_L04) {
        Notify(\_SB_.PCI0.USB2, 0x2)
    }
    Method(_L05) {
        Notify(\_SB_.PCI0.MODE, 0x2)
    }
    Method(_L0B) {
        Notify(\_SB_.PCI0.HUB_, 0x2)
    }
    Method(_L1D) {
        Notify(\_SB_.PCI0.LPC0.EC0_, 0x2)
    }
}
Scope(_SB_) {
    Device(LID_) {
        Name(_HID, 0x0d0cd041)
        Method(_LID) {
            If(LEqual(\_SB_.PCI0.LPC0.EC0_.ECOK, 0x0)) {
                And(PHSB(0xd4, 0x82), 0x4, Local0)
            }
            Else {
                Store(\_SB_.PCI0.LPC0.EC0_.LIDS, Local0)
            }
            Return(Local0)
        }
    }
    Device(PWRB) {
        Name(_HID, 0x0c0cd041)
        Name(_PRW, Package(0x2) {
            0x1d,
            0x5,
        })
        Method(_STA) {
            Return(0xf)
        }
    }
    Device(DOCK) {
        Name(_HID, 0x150cd041)
        Name(_UID, 0x0)
        Name(_BDN, 0xffffffff)
        Name(DKST, 0x0)
        Name(DKFS, 0x0)
        Name(DCRI, 0x0)
        Event(UDCK)
        Method(GDST) {
            If(LEqual(\_SB_.PCI0.LPC0.EC0_.ECOK, 0x0)) {
                And(PHSB(0xd4, 0x80), 0x4, Local0)
            }
            Else {
                Store(\_SB_.PCI0.LPC0.EC0_.DOKD, Local0)
            }
            If(LEqual(Zero, Local0)) {
                Return(Zero)
            }
            Else {
                Return(Ones)
            }
        }
        Method(_STA) {
            If(LEqual(\_SB_.PCI0.LPC0.FDC_.ARM_, Zero)) {
                If(LEqual(PHS_(0xdd), One)) {
                    Store(One, \_SB_.PCI0.LPC0.FDC_.ARM_)
                }
            }
            Store(GDST(), DKFS)
            If(DKFS) {
                If(LEqual(\_SB_.PCI0.LPC0.FDC_.ARM_, Zero)) {
                    Store(One, Index(\_SB_.PCI0.LPC0.FDC_.FDIB, 0x0, ))
                    Store(One, Index(\_SB_.PCI0.LPC0.FDC_.FDES, 0x0, ))
                }
                Return(0xf)
            }
            Else {
                Store(Zero, Index(\_SB_.PCI0.LPC0.FDC_.FDIB, 0x0, ))
                Store(Zero, Index(\_SB_.PCI0.LPC0.FDC_.FDES, 0x0, ))
                Return(0x0)
            }
        }
        Method(_DCK, 1) {
            Return(DULF(Arg0))
        }
        Method(_EJ0, 1) {
            Store(Ones, \_SB_.PCI0.GCH0.DODF)
            Store(One, DCRI)
            Wait(UDCK, 0xffff)
            Reset(UDCK)
        }
        Method(DULF, 1) {
            If(LEqual(Arg0, 0x1)) {
                \_SB_.PCI0.LPC0.ENCF()
                And(\_SB_.PCI0.LPC0.CR05, 0xfd, \_SB_.PCI0.LPC0.CR05)
                \_SB_.PCI0.LPC0.EXCF()
                Store(Zero, \_SB_.PCI0.LPC0.GP20)
                Store(One, Local0)
            }
            Else {
                \_SB_.PCI0.LPC0.ENCF()
                Or(\_SB_.PCI0.LPC0.CR05, 0x2, \_SB_.PCI0.LPC0.CR05)
                \_SB_.PCI0.LPC0.EXCF()
                Store(One, \_SB_.PCI0.LPC0.GP20)
                If(LEqual(\_SB_.PCI0.LPC0.EC0_.ECOK, 0x0)) {
                    PHSW(0xd5, 0x9f, Zero)
                }
                Else {
                    Store(Zero, \_SB_.PCI0.LPC0.EC0_.DUSE)
                }
                Store(Zero, Local0)
            }
            If(LEqual(\_SB_.PCI0.LPC0.EC0_.ECOK, 0x0)) {
                PHSW(0xd5, 0x9e, Local0)
            }
            Else {
                Store(Local0, \_SB_.PCI0.LPC0.EC0_.ILED)
            }
            Return(One)
        }
    }
    Device(PCI0) {
        Name(_HID, 0x030ad041)
        Name(_ADR, 0x0)
        Name(_BBN, 0x0)
        Name(_PRT, Package(0x8) {
            Package(0x4) {
                0x0001ffff,
                0x0,
                LNKA,
                0x0,
            },
            Package(0x4) {
                0x0001ffff,
                0x1,
                LNKB,
                0x0,
            },
            Package(0x4) {
                0x0001ffff,
                0x2,
                LNKC,
                0x0,
            },
            Package(0x4) {
                0x0001ffff,
                0x3,
                LNKD,
                0x0,
            },
            Package(0x4) {
                0x0002ffff,
                0x0,
                LNKA,
                0x0,
            },
            Package(0x4) {
                0x001fffff,
                0x1,
                LNKB,
                0x0,
            },
            Package(0x4) {
                0x001fffff,
                0x2,
                LNKH,
                0x0,
            },
            Package(0x4) {
                0x001fffff,
                0x3,
                LNKD,
                0x0,
            },
        })
        OperationRegion(REGS, PCI_Config, 0x40, 0xc0)
        Field(REGS, DWordAcc, NoLock, Preserve) {
            Offset(0x12),
            DRP0,	4,
            DRP1,	4,
            Offset(0x14),
            DRP2,	4,
            Offset(0x18),
            ,	7,
            HEN_,	1,
            PAM0,	8,
            PAM1,	8,
            PAM2,	8,
            PAM3,	8,
            PAM4,	8,
            PAM5,	8,
            PAM6,	8,
            Offset(0x30),
            ,	6,
            UMA_,	2
        }
        Name(DMST, Package(0x10) {
            0x0,
            0x20,
            0x20,
            0x30,
            0x40,
            0x40,
            0x60,
            0x80,
            0x0,
            0x80,
            0x80,
            0xc0,
            0x0100,
            0x0100,
            0x0100,
            0x0200,
        })
        Name(RSRC, Buffer(0x01b7) {0x88, 0xe, 0x0, 0x2, 0xc, 0x0, 0x0, 0x0, 
0x0, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 0x3, 
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0x0, 0xff, 0xff, 0xb, 0x0, 0x0, 0x0, 0x0, 
0x0, 0x0, 0x0, 0x2, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 
0x0, 0x0, 0x0, 0xc, 0x0, 0xff, 0x3f, 0xc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 
0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 
0xc, 0x0, 0xff, 0x7f, 0xc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0, 
0x87, 0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80, 0xc, 0x0, 
0xff, 0xbf, 0xc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0, 0x87, 
0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc0, 0xc, 0x0, 0xff, 
0xff, 0xc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0, 0x87, 0x18, 
0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0x0, 0xff, 0x3f, 0xd, 
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 
0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0xd, 0x0, 0xff, 0x7f, 0xd, 0x0, 0x0, 0x0, 
0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 
0x0, 0x0, 0x0, 0x80, 0xd, 0x0, 0xff, 0xbf, 0xd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 
0x40, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 
0xc0, 0xd, 0x0, 0xff, 0xff, 0xd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 
0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 
0x0, 0xff, 0x3f, 0xe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0, 
0x87, 0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0xe, 0x0, 
0xff, 0x7f, 0xe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0, 0x87, 
0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80, 0xe, 0x0, 0xff, 
0xbf, 0xe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0, 0x87, 0x18, 
0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc0, 0xe, 0x0, 0xff, 0xff, 0xe, 
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 
0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x47, 0x1, 0xf8, 0xc, 0xf8, 0xc, 0x1, 0x8, 
0x88, 0xe, 0x0, 0x1, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0xf7, 0xc, 0x0, 0x0, 0xf8, 
0xc, 0x0, 0x88, 0xe, 0x0, 0x1, 0xc, 0x3, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x0, 
0x0, 0x0, 0xf3, 0x0, 0x79, 0x0 })
        Method(_CRS, 0, Serialized) {
            Store(Zero, Local1)
            CreateDWordField(RSRC, 0x017a, BTMN)
            CreateDWordField(RSRC, 0x017e, BTMX)
            CreateDWordField(RSRC, 0x0186, BTLN)
            Store(DRP0, Local0)
            Store(DRP1, Local1)
            Store(DRP2, Local2)
            Add(DerefOf(Index(DMST, Local0, )), DerefOf(Index(DMST, Local1, 
)), Local0)
            Add(DerefOf(Index(DMST, Local2, )), Local0, Local0)
            Multiply(Local0, 0x00100000, Local0)
            Store(Local0, BTMN)
            Subtract(0xfec00000, Local0, BTLN)
            Subtract(Add(BTMN, BTLN, ), 0x1, BTMX)
            CreateBitField(RSRC, 0x0188, C0RW)
            CreateDWordField(RSRC, 0x36, C0MN)
            CreateDWordField(RSRC, 0x3a, C0MX)
            CreateDWordField(RSRC, 0x42, C0LN)
            Store(One, C0RW)
            If(LEqual(And(PAM1, 0x3, ), 0x1)) {
                Store(Zero, C0RW)
            }
            Store(Zero, C0LN)
            If(LNot(And(PAM1, 0x3, ))) {
                Store(0x4000, C0LN)
            }
            CreateBitField(RSRC, 0x0260, C4RW)
            CreateDWordField(RSRC, 0x51, C4MN)
            CreateDWordField(RSRC, 0x55, C4MX)
            CreateDWordField(RSRC, 0x5d, C4LN)
            Store(One, C4RW)
            If(LEqual(And(PAM1, 0x30, ), 0x10)) {
                Store(Zero, C4RW)
            }
            Store(Zero, C4LN)
            If(LNot(And(PAM1, 0x30, ))) {
                Store(0x4000, C4LN)
            }
            CreateBitField(RSRC, 0x0338, C8RW)
            CreateDWordField(RSRC, 0x6c, C8MN)
            CreateDWordField(RSRC, 0x70, C8MX)
            CreateDWordField(RSRC, 0x78, C8LN)
            Store(One, C8RW)
            If(LEqual(And(PAM2, 0x3, ), 0x1)) {
                Store(Zero, C8RW)
            }
            Store(Zero, C8LN)
            If(LNot(And(PAM2, 0x3, ))) {
                Store(0x4000, C8LN)
            }
            CreateBitField(RSRC, 0x0410, CCRW)
            CreateDWordField(RSRC, 0x87, CCMN)
            CreateDWordField(RSRC, 0x8b, CCMX)
            CreateDWordField(RSRC, 0x93, CCLN)
            Store(One, CCRW)
            If(LEqual(And(PAM2, 0x30, ), 0x10)) {
                Store(Zero, CCRW)
            }
            Store(Zero, CCLN)
            If(LNot(And(PAM2, 0x30, ))) {
                Store(0x4000, CCLN)
            }
            CreateBitField(RSRC, 0x04e8, D0RW)
            CreateDWordField(RSRC, 0xa2, D0MN)
            CreateDWordField(RSRC, 0xa6, D0MX)
            CreateDWordField(RSRC, 0xae, D0LN)
            Store(One, D0RW)
            If(LEqual(And(PAM3, 0x3, ), 0x1)) {
                Store(Zero, D0RW)
            }
            Store(Zero, D0LN)
            If(LNot(And(PAM3, 0x3, ))) {
                Store(0x4000, D0LN)
            }
            CreateBitField(RSRC, 0x05c0, D4RW)
            CreateDWordField(RSRC, 0xbd, D4MN)
            CreateDWordField(RSRC, 0xc1, D4MX)
            CreateDWordField(RSRC, 0xc9, D4LN)
            Store(One, D4RW)
            If(LEqual(And(PAM3, 0x30, ), 0x10)) {
                Store(Zero, D4RW)
            }
            Store(Zero, D4LN)
            If(LNot(And(PAM3, 0x30, ))) {
                Store(0x4000, D4LN)
            }
            CreateBitField(RSRC, 0x0698, D8RW)
            CreateDWordField(RSRC, 0xd8, D8MN)
            CreateDWordField(RSRC, 0xdc, D8MX)
            CreateDWordField(RSRC, 0xe4, D8LN)
            Store(One, D8RW)
            If(LEqual(And(PAM4, 0x3, ), 0x1)) {
                Store(Zero, D8RW)
            }
            Store(Zero, D8LN)
            If(LNot(And(PAM4, 0x3, ))) {
                Store(0x4000, D8LN)
            }
            CreateBitField(RSRC, 0x0770, DCRW)
            CreateDWordField(RSRC, 0xf3, DCMN)
            CreateDWordField(RSRC, 0xf7, DCMX)
            CreateDWordField(RSRC, 0xff, DCLN)
            Store(One, DCRW)
            If(LEqual(And(PAM4, 0x30, ), 0x10)) {
                Store(Zero, DCRW)
            }
            Store(Zero, DCLN)
            If(LNot(And(PAM4, 0x30, ))) {
                Store(0x4000, DCLN)
            }
            CreateBitField(RSRC, 0x0848, E0RW)
            CreateDWordField(RSRC, 0x010e, E0MN)
            CreateDWordField(RSRC, 0x0112, E0MX)
            CreateDWordField(RSRC, 0x011a, E0LN)
            Store(One, E0RW)
            If(LEqual(And(PAM5, 0x3, ), 0x1)) {
                Store(Zero, E0RW)
            }
            Store(Zero, E0LN)
            If(LNot(And(PAM5, 0x3, ))) {
                Store(0x4000, E0LN)
            }
            CreateBitField(RSRC, 0x0920, E4RW)
            CreateDWordField(RSRC, 0x0129, E4MN)
            CreateDWordField(RSRC, 0x012d, E4MX)
            CreateDWordField(RSRC, 0x0135, E4LN)
            Store(One, E4RW)
            If(LEqual(And(PAM5, 0x30, ), 0x10)) {
                Store(Zero, E4RW)
            }
            Store(Zero, E4LN)
            If(LNot(And(PAM5, 0x30, ))) {
                Store(0x4000, E4LN)
            }
            CreateBitField(RSRC, 0x09f8, E8RW)
            CreateDWordField(RSRC, 0x0144, E8MN)
            CreateDWordField(RSRC, 0x0148, E8MX)
            CreateDWordField(RSRC, 0x0150, E8LN)
            Store(One, E8RW)
            If(LEqual(And(PAM6, 0x3, ), 0x1)) {
                Store(Zero, E8RW)
            }
            Store(Zero, E8LN)
            If(LNot(And(PAM6, 0x3, ))) {
                Store(0x4000, E8LN)
            }
            CreateBitField(RSRC, 0x0ad0, ECRW)
            CreateDWordField(RSRC, 0x015f, ECMN)
            CreateDWordField(RSRC, 0x0163, ECMX)
            CreateDWordField(RSRC, 0x016b, ECLN)
            Store(One, ECRW)
            If(LEqual(And(PAM6, 0x30, ), 0x10)) {
                Store(Zero, ECRW)
            }
            Store(Zero, ECLN)
            If(LNot(And(PAM6, 0x30, ))) {
                Store(0x4000, ECLN)
            }
            Return(RSRC)
        }
        Device(LVID) {
            Name(_HID, 0x020cd041)
            Name(_UID, 0x20)
            Name(RSRC, Buffer(0xe) {0x86, 0x9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 
0x0, 0x0, 0x0, 0x0, 0x79, 0x0 })
            Method(_CRS, 0, Serialized) {
                CreateDWordField(RSRC, 0x4, SBAS)
                CreateDWordField(RSRC, 0x8, SLEN)
                Store(DRP0, Local0)
                Store(DRP1, Local1)
                Add(DerefOf(Index(DMST, Local0, )), DerefOf(Index(DMST, 
Local1, )), Local0)
                ShiftLeft(Local0, 0x14, Local0)
                If(HEN_) {
                    Subtract(Local0, 0x00100000, Local0)
                }
                If(LEqual(UMA_, 0x2)) {
                    Subtract(Local0, 0x00100000, SBAS)
                    Store(0x00180000, SLEN)
                }
                If(LEqual(UMA_, 0x3)) {
                    Subtract(Local0, 0x00100000, SBAS)
                    Store(0x00100000, SLEN)
                }
                Return(RSRC)
            }
        }
        Device(AGP_) {
            Name(_ADR, 0x00010000)
        }
        Device(GCH0) {
            Name(_ADR, 0x00020000)
            OperationRegion(VGAB, SystemMemory, 0xfffa0000, 0xc000)
            Field(VGAB, AnyAcc, Lock, Preserve) {
                BUF1,	393216
            }
            Name(BUFX, Buffer(0xc000) { })
            Name(SXBB, Buffer(0x0410) { })
            CreateWordField(SXBB, 0x0, SXFN)
            CreateWordField(SXBB, 0x2, SXSL)
            CreateWordField(SXBB, 0x20, SXBX)
            CreateWordField(SXBB, 0x28, SXCX)
            CreateWordField(SXBB, 0x2c, SXAX)
            Name(FNF7, 0x0)
            Name(FNF8, 0x0)
            Name(LDGS, 0x0)
            Name(PDOD, 0x0)
            Name(TBF7, Package(0x10) {
                0x2,
                0x2,
                0x3,
                0x1,
                0x2,
                0x2,
                0x2,
                0x2,
                0x3,
                0x2,
                0x2,
                0x2,
                0x2,
                0x2,
                0x2,
                0x2,
            })
            Name(TBF8, Package(0x10) {
                0x2,
                0x8,
                0x8,
                0x8,
                0x2,
                0x2,
                0x2,
                0x2,
                0x2,
                0x2,
                0x2,
                0x2,
                0x2,
                0x2,
                0x2,
                0x2,
            })
            Method(SXDD) {
                Store(0x32, SXFN)
                Store(0x5f64, SXAX)
                Store(0x0200, SXBX)
                Store(\_SB_.PCI0.LPC0.SNC_.CSXB(SXBB), SXBB)
                Store(And(ShiftRight(SXCX, 0x8, ), 0xf, ), Local0)
                If(LEqual(SXAX, 0x5f)) {
                    Store(" SXDD return value ", Debug)
                    Store(Local0, Debug)
                    Return(Local0)
                }
                Else {
                    Store(" SXDD return value ", Debug)
                    Store(0x0, Debug)
                    Return(0x0)
                }
            }
            Method(SXCD) {
                Store(0x32, SXFN)
                Store(0x5f64, SXAX)
                Store(0x0100, SXBX)
                Store(\_SB_.PCI0.LPC0.SNC_.CSXB(SXBB), SXBB)
                If(LEqual(SXAX, 0x5f)) {
                    Store(And(SXCX, 0xf, ), Local0)
                    Store(" SXCD return value ", Debug)
                    Store(Local0, Debug)
                    Return(Local0)
                }
                Else {
                    Store(" SXCD return value ", Debug)
                    Store(0x0, Debug)
                    Return(0x0)
                }
            }
            Method(SXSD, 1) {
                Store(0x32, SXFN)
                Store(0x5f64, SXAX)
                Store(0x1, SXBX)
                Store(Arg0, SXCX)
                Store(\_SB_.PCI0.LPC0.SNC_.CSXB(SXBB), SXBB)
                Return(SXAX)
            }
            Method(GDCS, 1) {
                Store(SXCD(), Local0)
                If(And(SXCX, Arg0, )) {
                    Return(0x1f)
                }
                Else {
                    Return(0x1d)
                }
                Return(0x1d)
            }
            Method(GDSS, 2) {
                Store(" _DSS Called ", Debug)
                Store(Arg0, Debug)
                If(And(Arg0, 0x40000000, )) {
                    Noop
                }
                Else {
                    Store(SXCD(), Local0)
                    If(LEqual(Local0, 0x0)) {
                        Noop
                    }
                    Else {
                        If(And(Arg1, 0x1, )) {
                            Or(Local0, Arg1, Local0)
                        }
                        Else {
                            And(Not(Arg1, ), Local0, Local0)
                        }
                        SXSD(Local0)
                    }
                }
            }
            Method(GDGS, 1) {
                If(LEqual(FNF7, FNF8)) {
                    Store(GDCS(Arg0), Local0)
                    Return(LOr(And(Local0, 0x2, ), 0x0))
                }
                Store(SXDD(), Local0)
                Store(SXCD(), Local1)
                If(LEqual(LAnd(Local1, Local0), 0x0)) {
                    Store(" Int10h failed. LCD Only ", Debug)
                    If(And(Arg0, 0x2, )) {
                        Return(0x1)
                    }
                    Else {
                        Return(0x0)
                    }
                }
                Else {
                    And(Local0, Local1, Local2)
                    If(FNF7) {
                        Store(And(Local0, DerefOf(Index(TBF7, Local2, )), ), 
Local2)
                        Store(" Next Display value ", Debug)
                        Store(Local2, Debug)
                        Store(LOr(And(Local2, Arg0, ), 0x0), Local2)
                        Return(And(Local2, 0x1, ))
                    }
                    If(FNF8) {
                        Store(LOr(And(DerefOf(Index(TBF8, Local2, )), Arg0, ), 
0x0), Local2)
                        Return(And(Local2, 0x1, ))
                    }
                    Return(0x0)
                }
                Return(0x0)
            }
            Method(_DOS, 1) {
                Store(And(Arg0, 0x3, ), LDGS)
                If(LEqual(Arg0, 0x0)) {
                    Store(0x0, FNF7)
                    Store(0x0, FNF8)
                }
            }
            Name(DODF, Zero)
            Method(_DOD) {
                Name(PSIZ, 0x0)
                Name(PPTR, 0x0)
                If(DODF) {
                    Return(Package(0x1) {
                        0x00010200,
                    })
                }
                Store(SXDD(), Local0)
                Store(Local0, Local1)
                Store(Local0, PDOD)
                While(Local1) {
                    If(And(Local1, 0x1, )) {
                        Increment(PSIZ)
                    }
                    ShiftRight(Local1, 0x1, Local1)
                }
                Store(" _DOD Called. PSIZE ", Debug)
                Store(PSIZ, Debug)
                If(LEqual(PSIZ, 0x1)) {
                    Name(VID1, Package(0x1) {
                        0x00010200,
                    })
                    If(And(Local0, 0x1, )) {
                        Store(0x00010100, Index(VID1, 0x0, ))
                    }
                    If(And(Local0, 0x2, )) {
                        Store(0x00010200, Index(VID1, 0x0, ))
                    }
                    If(And(Local0, 0x4, )) {
                        Store(0x00010300, Index(VID1, 0x0, ))
                    }
                    If(And(Local0, 0x8, )) {
                        Store(0x00010400, Index(VID1, 0x0, ))
                    }
                    Store(" _DOD Called ", Debug)
                    Store(VID1, Debug)
                    Return(VID1)
                }
                If(LEqual(PSIZ, 0x2)) {
                    Name(VID2, Package(0x2) {
                        0x00010100,
                        0x00010200,
                    })
                    If(And(Local0, 0x1, )) {
                        Store(0x00010100, Index(VID2, PPTR, ))
                        Increment(PPTR)
                    }
                    If(And(Local0, 0x2, )) {
                        Store(0x00010200, Index(VID2, PPTR, ))
                        Increment(PPTR)
                    }
                    If(And(Local0, 0x4, )) {
                        Store(0x00010300, Index(VID2, PPTR, ))
                        Increment(PPTR)
                    }
                    If(And(Local0, 0x8, )) {
                        Store(0x00010400, Index(VID2, PPTR, ))
                    }
                    Store(" _DOD Called ", Debug)
                    Store(VID2, Debug)
                    Return(VID2)
                }
                If(LEqual(PSIZ, 0x3)) {
                    Name(VID3, Package(0x3) {
                        0x00010100,
                        0x00010200,
                        0x00010300,
                    })
                    If(And(Local0, 0x1, )) {
                        Store(0x00010100, Index(VID3, PPTR, ))
                        Increment(PPTR)
                    }
                    If(And(Local0, 0x2, )) {
                        Store(0x00010200, Index(VID3, PPTR, ))
                        Increment(PPTR)
                    }
                    If(And(Local0, 0x4, )) {
                        Store(0x00010300, Index(VID3, PPTR, ))
                        Increment(PPTR)
                    }
                    If(And(Local0, 0x8, )) {
                        Store(0x00010400, Index(VID3, PPTR, ))
                    }
                    Store(" _DOD Called ", Debug)
                    Store(VID3, Debug)
                    Return(VID3)
                }
                If(LEqual(PSIZ, 0x4)) {
                    Name(VID4, Package(0x4) {
                        0x00010100,
                        0x00010200,
                        0x00010300,
                        0x00010400,
                    })
                    If(And(Local0, 0x1, )) {
                        Store(0x00010100, Index(VID4, PPTR, ))
                        Increment(PPTR)
                    }
                    If(And(Local0, 0x2, )) {
                        Store(0x00010200, Index(VID4, PPTR, ))
                        Increment(PPTR)
                    }
                    If(And(Local0, 0x4, )) {
                        Store(0x00010300, Index(VID4, PPTR, ))
                        Increment(PPTR)
                    }
                    If(And(Local0, 0x8, )) {
                        Store(0x00010400, Index(VID4, PPTR, ))
                    }
                    Store(" _DOD Called ", Debug)
                    Store(VID4, Debug)
                    Return(VID4)
                }
                Return(Package(0x1) {
                    0x00010200,
                })
            }
            Method(_ROM, 2) {
                Store(BUF1, BUFX)
                If(LGreater(Add(Arg0, Arg1, ), 0xc000)) {
                    Multiply(0x0, 0x8, Local0)
                    Multiply(0x1000, 0x8, Local1)
                }
                Else {
                    Multiply(Arg0, 0x8, Local0)
                    If(LGreater(Arg1, 0x1000)) {
                        Multiply(0x1000, 0x8, Local1)
                    }
                    Else {
                        Multiply(Arg1, 0x8, Local1)
                    }
                }
                CreateField(BUFX, Local0, Local1, BUFY)
                Return(BUFY)
            }
            Device(LFP_) {
                Name(_ADR, 0x0200)
                Method(_DCS) {
                    Return(GDCS(0x2))
                }
                Method(_DGS) {
                    Store(GDGS(0x2), Local0)
                    Store(" LFP _DGS return value ", Debug)
                    Store(Local0, Debug)
                    Return(Local0)
                }
                Method(_DSS, 1) {
                    GDSS(Arg0, 0x2)
                }
            }
            Device(CRT_) {
                Name(_ADR, 0x0100)
                Method(_DCS) {
                    Return(GDCS(0x1))
                }
                Method(_DGS) {
                    Store(GDGS(0x1), Local0)
                    Store(" CRT _DGS return value ", Debug)
                    Store(Local0, Debug)
                    Return(Local0)
                }
                Method(_DSS, 1) {
                    GDSS(Arg0, 0x1)
                }
            }
            Device(DTV_) {
                Name(_ADR, 0x0400)
                Method(_DCS) {
                    Return(GDCS(0x8))
                }
                Method(_DGS) {
                    Store(GDGS(0x8), Local0)
                    Store(" DTV _DGS return value ", Debug)
                    Store(Local0, Debug)
                    Return(Local0)
                }
                Method(_DSS, 1) {
                    GDSS(Arg0, 0x8)
                }
            }
        }
        Device(HUB_) {
            Name(_ADR, 0x001e0000)
            Name(_PRT, Package(0x8) {
                Package(0x4) {
                    0xffff,
                    0x0,
                    LNKA,
                    0x0,
                },
                Package(0x4) {
                    0x0002ffff,
                    0x0,
                    LNKC,
                    0x0,
                },
                Package(0x4) {
                    0x0002ffff,
                    0x1,
                    LNKD,
                    0x0,
                },
                Package(0x4) {
                    0x0008ffff,
                    0x0,
                    LNKE,
                    0x0,
                },
                Package(0x4) {
                    0x000cffff,
                    0x0,
                    LNKA,
                    0x0,
                },
                Package(0x4) {
                    0x000cffff,
                    0x1,
                    LNKB,
                    0x0,
                },
                Package(0x4) {
                    0x000cffff,
                    0x2,
                    LNKC,
                    0x0,
                },
                Package(0x4) {
                    0x000cffff,
                    0x3,
                    LNKD,
                    0x0,
                },
            })
            Device(SD94) {
                Name(_ADR, 0x0)
            }
            Device(LAN_) {
                Name(_ADR, 0x00080000)
                Name(_PRW, Package(0x2) {
                    0xb,
                    0x3,
                })
            }
        }
        Device(LPC0) {
            Name(_ADR, 0x001f0000)
            OperationRegion(PIRX, PCI_Config, 0x60, 0x4)
            Field(PIRX, ByteAcc, NoLock, Preserve) {
                PIRA,	8,
                PIRB,	8,
                PIRC,	8,
                PIRD,	8
            }
            OperationRegion(PIRY, PCI_Config, 0x68, 0x4)
            Field(PIRY, ByteAcc, NoLock, Preserve) {
                PIRE,	8,
                PIRF,	8,
                PIRG,	8,
                PIRH,	8
            }
            OperationRegion(LPCR, PCI_Config, 0x0, 0xf2)
            Field(LPCR, ByteAcc, NoLock, Preserve) {
                Offset(0xc4),
                MON4,	16,
                MON5,	16
            }
            OperationRegion(GPIO, SystemIO, 0x1180, 0x2c)
            Field(GPIO, ByteAcc, NoLock, Preserve) {
                Offset(0xf),
                ,	1,
                GP25,	1
            }
            OperationRegion(REGS, PCI_Config, 0x40, 0xc0)
            Field(REGS, DWordAcc, NoLock, Preserve) {
                PMBA,	16,
                Offset(0x18),
                GPBA,	16,
                Offset(0xb0),
                ,	5,
                FUND,	2
            }
            Device(MBRD) {
                Name(_HID, 0x020cd041)
                Name(_UID, 0x1f)
                Name(RSRC, Buffer(0xd6) {0x47, 0x1, 0x10, 0x0, 0x10, 0x0, 0x1, 
0x10, 0x47, 0x1, 0x24, 0x0, 0x24, 0x0, 0x1, 0x2, 0x47, 0x1, 0x28, 0x0, 0x28, 
0x0, 0x1, 0x2, 0x47, 0x1, 0x2c, 0x0, 0x2c, 0x0, 0x1, 0x2, 0x47, 0x1, 0x30, 
0x0, 0x30, 0x0, 0x1, 0x2, 0x47, 0x1, 0x34, 0x0, 0x34, 0x0, 0x1, 0x2, 0x47, 
0x1, 0x38, 0x0, 0x38, 0x0, 0x1, 0x2, 0x47, 0x1, 0x3c, 0x0, 0x3c, 0x0, 0x1, 
0x2, 0x47, 0x1, 0x50, 0x0, 0x50, 0x0, 0x1, 0x4, 0x47, 0x1, 0x72, 0x0, 0x72, 
0x0, 0x1, 0x6, 0x47, 0x1, 0x80, 0x0, 0x80, 0x0, 0x1, 0x1, 0x47, 0x1, 0x90, 
0x0, 0x90, 0x0, 0x1, 0x10, 0x47, 0x1, 0xa4, 0x0, 0xa4, 0x0, 0x1, 0x2, 0x47, 
0x1, 0xa8, 0x0, 0xa8, 0x0, 0x1, 0x2, 0x47, 0x1, 0xac, 0x0, 0xac, 0x0, 0x1, 
0x2, 0x47, 0x1, 0xb0, 0x0, 0xb0, 0x0, 0x1, 0x6, 0x47, 0x1, 0xb8, 0x0, 0xb8, 
0x0, 0x1, 0x2, 0x47, 0x1, 0xbc, 0x0, 0xbc, 0x0, 0x1, 0x2, 0x47, 0x1, 0x0, 
0x10, 0x0, 0x10, 0x1, 0x80, 0x47, 0x1, 0x80, 0x11, 0x80, 0x11, 0x1, 0x40, 
0x47, 0x1, 0x2e, 0x0, 0x2e, 0x0, 0x1, 0x2, 0x47, 0x1, 0x4e, 0x0, 0x4e, 0x0, 
0x1, 0x2, 0x47, 0x1, 0x0, 0x6, 0x0, 0x6, 0x1, 0x10, 0x47, 0x1, 0xd0, 0x4, 
0xd0, 0x4, 0x1, 0x2, 0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x1, 0x2, 0x86, 0x9, 0x0, 
0x0, 0x0, 0x0, 0x80, 0xff, 0x0, 0x0, 0x80, 0x0, 0x79, 0x0 })
                Method(_CRS) {
                    CreateWordField(RSRC, 0x92, PMMN)
                    CreateWordField(RSRC, 0x94, PMMX)
                    CreateWordField(RSRC, 0x9a, GPMN)
                    CreateWordField(RSRC, 0x9c, GPMX)
                    CreateWordField(RSRC, 0xc2, PHMN)
                    CreateWordField(RSRC, 0xc4, PHMX)
                    And(^^PMBA, 0xff80, PMMN)
                    Store(PMMN, PMMX)
                    And(^^GPBA, 0xff80, GPMN)
                    Store(GPMN, GPMX)
                    Store(^^MON4, PHMN)
                    Store(PHMN, PHMX)
                    Return(RSRC)
                }
                Method(_STA) {
                    Return(0xf)
                }
            }
            Device(DMAC) {
                Name(_HID, 0x0002d041)
                Name(_CRS, Buffer(0x1d) {0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x1, 
0x10, 0x47, 0x1, 0x81, 0x0, 0x81, 0x0, 0x1, 0xf, 0x47, 0x1, 0xc0, 0x0, 0xc0, 
0x0, 0x1, 0x20, 0x2a, 0x10, 0x2, 0x79, 0x0 })
                Method(_STA) {
                    Return(0xf)
                }
            }
            Device(MATH) {
                Name(_HID, 0x040cd041)
                Name(_CRS, Buffer(0xd) {0x47, 0x1, 0xf0, 0x0, 0xf0, 0x0, 0x1, 
0x10, 0x22, 0x0, 0x20, 0x79, 0x0 })
                Method(_STA) {
                    Return(0xf)
                }
            }
            Device(PIC_) {
                Name(_HID, 0xd041)
                Name(_CRS, Buffer(0x15) {0x47, 0x1, 0x20, 0x0, 0x20, 0x0, 0x1, 
0x2, 0x47, 0x1, 0xa0, 0x0, 0xa0, 0x0, 0x1, 0x2, 0x22, 0x4, 0x0, 0x79, 0x0 })
                Method(_STA) {
                    Return(0xf)
                }
            }
            Device(RTC_) {
                Name(_HID, 0x000bd041)
                Name(_CRS, Buffer(0xd) {0x47, 0x1, 0x70, 0x0, 0x70, 0x0, 0x1, 
0x2, 0x22, 0x0, 0x1, 0x79, 0x0 })
                Method(_STA) {
                    Return(0xf)
                }
            }
            Device(SPKR) {
                Name(_HID, 0x0008d041)
                Name(_CRS, Buffer(0xa) {0x47, 0x1, 0x61, 0x0, 0x61, 0x0, 0x1, 
0x1, 0x79, 0x0 })
                Method(_STA) {
                    Return(0xf)
                }
            }
            Device(TMR_) {
                Name(_HID, 0x0001d041)
                Name(_CRS, Buffer(0xd) {0x47, 0x1, 0x40, 0x0, 0x40, 0x0, 0x1, 
0x4, 0x22, 0x1, 0x0, 0x79, 0x0 })
                Method(_STA) {
                    Return(0xf)
                }
            }
            Device(KBC_) {
                Name(_HID, 0x0303d041)
                Name(_CRS, Buffer(0x15) {0x47, 0x1, 0x60, 0x0, 0x60, 0x0, 0x1, 
0x1, 0x47, 0x1, 0x64, 0x0, 0x64, 0x0, 0x1, 0x1, 0x22, 0x2, 0x0, 0x79, 0x0 })
                Method(_STA) {
                    Return(0xf)
                }
            }
            Device(MOUE) {
                Name(_HID, 0x130fd041)
                Name(_CRS, Buffer(0x5) {0x22, 0x0, 0x10, 0x79, 0x0 })
            }
            Device(EC0_) {
                Name(_HID, 0x090cd041)
                Name(_CRS, Buffer(0x12) {0x47, 0x1, 0x62, 0x0, 0x62, 0x0, 0x1, 
0x1, 0x47, 0x1, 0x66, 0x0, 0x66, 0x0, 0x1, 0x1, 0x79, 0x0 })
                Name(_GPE, 0x1c)
                Name(ECOK, 0x0)
                Method(_REG, 2) {
                    If(LEqual(Arg0, 0x3)) {
                        Store(Arg1, ECOK)
                    }
                }
                Name(_PRW, Package(0x2) {
                    0x1d,
                    0x5,
                })
                OperationRegion(ECR_, EmbeddedControl, 0x0, 0xff)
                Field(ECR_, AnyAcc, Lock, Preserve) {
                    Offset(0x80),
                    MPBP,	1,
                    MPBD,	1,
                    DOKD,	1,
                    DFBP,	1,
                    Offset(0x81),
                    BT1A,	1,
                    BT2A,	1,
                    ACAT,	1,
                    Offset(0x82),
                    PWRB,	1,
                    JOGB,	1,
                    LIDS,	1,
                    Offset(0x83),
                    BT1P,	1,
                    BT2P,	1,
                    Offset(0x84),
                    B1ST,	8,
                    B2ST,	8,
                    Offset(0x90),
                    MASK,	8,
                    BT1S,	1,
                    BT2S,	1,
                    Offset(0x92),
                    BT1W,	1,
                    BT2W,	1,
                    Offset(0x93),
                    FAN0,	8,
                    CB0S,	1,
                    CB1S,	1,
                    Offset(0x95),
                    PHYO,	1,
                    Offset(0x96),
                    BRIT,	8,
                    CONT,	8,
                    SNDU,	1,
                    SNDD,	1,
                    Offset(0x99),
                    SMDM,	1,
                    Offset(0x9a),
                    Offset(0x9b),
                    SIRQ,	8,
                    SLOB,	8,
                    SHIB,	8,
                    ILED,	1,
                    Offset(0x9f),
                    DUSE,	1,
                    Offset(0xa0),
                    B1RC,	16,
                    B1AB,	16,
                    B1RT,	16,
                    B1VO,	16,
                    B2RC,	16,
                    B2AB,	16,
                    B2RT,	16,
                    B2VO,	16,
                    B1DC,	16,
                    B1LF,	16,
                    B1DV,	16,
                    B1DL,	16,
                    B2DC,	16,
                    B2LF,	16,
                    B2DV,	16,
                    B2DL,	16,
                    A1TP,	16,
                    A1AT,	16,
                    A1PT,	16,
                    A1CT,	16,
                    A2TP,	16,
                    A2AT,	16,
                    A2PT,	16,
                    A2CT,	16
                }
                Method(_Q50) {
                    PHS_(0xa1)
                    Notify(ACAD, 0x80)
                    Notify(\_PR_.CPU0, 0x80)
                }
                Method(_Q51) {
                    If(BT1A) {
                        Notify(BAT1, 0x0)
                    }
                    Else {
                        Notify(BAT1, 0x1)
                    }
                    Notify(BAT1, 0x80)
                }
                Method(_Q53) {
                    Store("_Q53:Battery Selection", Debug)
                }
                Method(_Q58) {
                    Store("_Q58:ATF temperature trip point changd", Debug)
                    Notify(\_TZ_.ATF0, 0x81)
                }
                Method(_Q5F) {
                    Store("_Q5F:ATF temperature reaches trip point", Debug)
                    Notify(\_TZ_.ATF0, 0x80)
                }
                Method(_Q60) {
                    Notify(\_SB_.PWRB, 0x80)
                }
                Method(_Q66) {
                    Notify(\_SB_.LID_, 0x80)
                }
            }
            Device(SPIC) {
                Name(_HID, 0x0160d94d)
                Name(RSRC, Buffer(0xd) {0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x1, 
0x20, 0x22, 0x0, 0x0, 0x79, 0x0 })
                Name(SSRC, Buffer(0xd) {0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x1, 
0x20, 0x22, 0x0, 0x0, 0x79, 0x0 })
                Name(SIRT, Package(0x4) {
                    0x6,
                    0x9,
                    0xa,
                    0xb,
                })
                Method(_CRS) {
                    CreateByteField(RSRC, 0x2, IOM1)
                    CreateByteField(RSRC, 0x3, IOM2)
                    CreateWordField(RSRC, 0x2, IO1I)
                    CreateWordField(RSRC, 0x4, IO1A)
                    CreateWordField(RSRC, 0x9, IRQV)
                    If(LEqual(\_SB_.PCI0.LPC0.EC0_.ECOK, 0x0)) {
                        Store(PHSB(0xd4, 0x9c), IOM1)
                        Store(PHSB(0xd4, 0x9d), IOM2)
                    }
                    Else {
                        Store(\_SB_.PCI0.LPC0.EC0_.SLOB, IOM1)
                        Store(\_SB_.PCI0.LPC0.EC0_.SHIB, IOM2)
                    }
                    Store(IO1I, IO1A)
                    If(LEqual(\_SB_.PCI0.LPC0.EC0_.ECOK, 0x0)) {
                        ShiftRight(PHSB(0xd4, 0x9b), 0x4, Local0)
                    }
                    Else {
                        ShiftRight(\_SB_.PCI0.LPC0.EC0_.SIRQ, 0x4, Local0)
                    }
                    FindSetRightBit(Local0, Local1)
                    If(Local1) {
                        Decrement(Local1)
                        Store(DerefOf(Index(SIRT, Local1, )), Local0)
                        ShiftLeft(0x1, Local0, IRQV)
                    }
                    Return(RSRC)
                }
                Method(_SRS, 1) {
                    CreateByteField(Arg0, 0x2, IOA1)
                    CreateByteField(Arg0, 0x3, IOA2)
                    CreateWordField(Arg0, 0x9, IRQV)
                    FindSetRightBit(IRQV, Local0)
                    If(Local0) {
                        Decrement(Local0)
                        Store(Match(SIRT, MEQ, Local0, MTR, 0x0, 0x0), Local1)
                        ShiftLeft(0x10, Local1, Local2)
                    }
                    Else {
                        Store(0x0, Local2)
                    }
                    If(LEqual(\_SB_.PCI0.LPC0.EC0_.ECOK, 0x0)) {
                        PHSW(0xd5, 0x9b, Local2)
                    }
                    Else {
                        Store(Local2, \_SB_.PCI0.LPC0.EC0_.SIRQ)
                    }
                    If(LEqual(\_SB_.PCI0.LPC0.EC0_.ECOK, 0x0)) {
                        PHSW(0xd5, 0x9d, IOA2)
                        PHSW(0xd5, 0x9c, IOA1)
                    }
                    Else {
                        Store(IOA2, \_SB_.PCI0.LPC0.EC0_.SHIB)
                        Store(IOA1, \_SB_.PCI0.LPC0.EC0_.SLOB)
                    }
                    Sleep(0x1)
                }
                Name(_PRS, Buffer(0x2a) {0x30, 0x47, 0x1, 0x80, 0x10, 0x80, 
0x10, 0x1, 0x20, 0x30, 0x47, 0x1, 0xa0, 0x10, 0xa0, 0x10, 0x1, 0x20, 0x30, 
0x47, 0x1, 0xc0, 0x10, 0xc0, 0x10, 0x1, 0x20, 0x30, 0x47, 0x1, 0xe0, 0x10, 
0xe0, 0x10, 0x1, 0x20, 0x38, 0x22, 0x40, 0xe, 0x79, 0x0 })
                Method(_DIS) {
                    Store(_CRS(), SSRC)
                    If(LEqual(\_SB_.PCI0.LPC0.EC0_.ECOK, 0x0)) {
                        PHSW(0xd5, 0x9b, 0x0)
                        PHSW(0xd5, 0x9d, 0x0)
                        PHSW(0xd5, 0x9c, 0x0)
                    }
                    Else {
                        Store(0x0, \_SB_.PCI0.LPC0.EC0_.SIRQ)
                        Store(0x0, \_SB_.PCI0.LPC0.EC0_.SHIB)
                        Store(0x0, \_SB_.PCI0.LPC0.EC0_.SLOB)
                    }
                    Sleep(0x1)
                }
                Method(_STA) {
                    If(LEqual(CKOS(), 0x0)) {
                        If(LEqual(\_SB_.PCI0.LPC0.EC0_.ECOK, 0x0)) {
                            ShiftRight(PHSB(0xd4, 0x9b), 0x4, Local0)
                        }
                        Else {
                            ShiftRight(\_SB_.PCI0.LPC0.EC0_.SIRQ, 0x4, Local0)
                        }
                        FindSetRightBit(Local0, Local1)
                        If(Local1) {
                            Return(0xf)
                        }
                        Else {
                            Return(0xd)
                        }
                    }
                    Else {
                        Return(0xf)
                    }
                }
            }
            Device(SNC_) {
                Name(_HID, 0x0150d94d)
                Method(GPID) {
                    Return(PHSB(0xc0, 0x0))
                }
                Method(GBRT) {
                    If(LEqual(\_SB_.PCI0.LPC0.EC0_.ECOK, 0x0)) {
                        Store(PHSD(0xd4, 0x96), Local0)
                    }
                    Else {
                        Store(\_SB_.PCI0.LPC0.EC0_.BRIT, Local0)
                    }
                    Return(PHSB(0xcf, Local0))
                }
                Method(SBRT, 1) {
                    Store(PHSB(0xcd, Arg0), Local0)
                    If(LEqual(\_SB_.PCI0.LPC0.EC0_.ECOK, 0x0)) {
                        PHSB(0xc3, Local0)
                    }
                    Else {
                        Store(Local0, \_SB_.PCI0.LPC0.EC0_.BRIT)
                    }
                    Return(Zero)
                }
                Method(GPBR) {
                    Return(PHSB(0xc1, 0x0))
                }
                Method(SPBR, 1) {
                    PHSB(0xc2, Arg0)
                    Return(Zero)
                }
                Method(GCTR) {
                    If(LEqual(\_SB_.PCI0.LPC0.EC0_.ECOK, 0x0)) {
                        Store(PHSD(0xd4, 0x97), Local0)
                    }
                    Else {
                        Store(\_SB_.PCI0.LPC0.EC0_.CONT, Local0)
                    }
                    Return(PHSB(0xd0, Local0))
                }
                Method(SCTR, 1) {
                    Store(PHSB(0xce, Arg0), Local0)
                    If(LEqual(\_SB_.PCI0.LPC0.EC0_.ECOK, 0x0)) {
                        PHSB(0xc6, Local0)
                    }
                    Else {
                        Store(Local0, \_SB_.PCI0.LPC0.EC0_.CONT)
                    }
                    Return(Zero)
                }
                Method(GPCR) {
                    Return(PHSB(0xc4, 0x0))
                }
                Method(SPCR, 1) {
                    PHSB(0xc5, Arg0)
                    Return(Zero)
                }
                Method(HK_0) {
                    Notify(\_SB_.PCI0.GCH0, 0x0)
                }
                Method(HK80) {
                    Notify(\_SB_.PCI0.GCH0, 0x80)
                }
                Method(HK81) {
                    Notify(\_SB_.PCI0.GCH0, 0x81)
                }
                Method(HKF7) {
                    Store(0x1, \_SB_.PCI0.GCH0.FNF7)
                    Store(0x0, \_SB_.PCI0.GCH0.FNF8)
                    Notify(\_SB_.PCI0.GCH0, 0x80)
                }
                Method(HKF8) {
                    Store(0x0, \_SB_.PCI0.GCH0.FNF7)
                    Store(0x1, \_SB_.PCI0.GCH0.FNF8)
                    Notify(\_SB_.PCI0.GCH0, 0x80)
                }
                Method(SXF7) {
                    Store(\_SB_.PCI0.GCH0.SXDD(), Local0)
                    Store(\_SB_.PCI0.GCH0.SXCD(), Local1)
                    If(LEqual(LAnd(Local1, Local0), 0x0)) {
                        Return(0x0)
                    }
                    Else {
                        And(Local0, Local1, Local2)
                        Store(And(Local0, DerefOf(Index(\_SB_.PCI0.GCH0.TBF7, 
Local2, )), ), Local2)
                        Return(\_SB_.PCI0.GCH0.SXSD(Local2))
                    }
                }
                Method(SXF8) {
                    Store(\_SB_.PCI0.GCH0.SXDD(), Local0)
                    Store(\_SB_.PCI0.GCH0.SXCD(), Local1)
                    If(LEqual(LAnd(Local1, Local0), 0x0)) {
                        Return(0x0)
                    }
                    Else {
                        And(Local0, Local1, Local2)
                        Store(DerefOf(Index(\_SB_.PCI0.GCH0.TBF8, Local2, )), 
Local2)
                        Return(\_SB_.PCI0.GCH0.SXSD(Local2))
                    }
                }
                Method(SLVT) {
                    Store(Zero, \_SB_.PCI0.GCH0.DODF)
                    If(LOr(LEqual(CKOS(), 0x1), LEqual(CKOS(), 0x2))) {
                        Return(SXF7())
                    }
                    Else {
                        Store(\_SB_.PCI0.GCH0.SXDD(), Local0)
                        If(LNot(LEqual(\_SB_.PCI0.GCH0.PDOD, Local0))) {
                            Store(" Call _DOD to re-enumerate ", Debug)
                            If(LAnd(LEqual(CKOS(), 0x0), LNot(\WXP_))) {
                                Notify(\_SB_.PCI0.GCH0, 0x0)
                            }
                            Else {
                                Notify(\_SB_.PCI0.GCH0, 0x81)
                            }
                            Sleep(0x01f4)
                        }
                        If(LEqual(\_SB_.PCI0.GCH0.LDGS, 0x0)) {
                            HKF7()
                        }
                        If(LEqual(\_SB_.PCI0.GCH0.LDGS, 0x1)) {
                            SXF7()
                            Notify(\_SB_.PCI0.GCH0, 0x81)
                        }
                        If(LEqual(\_SB_.PCI0.GCH0.LDGS, 0x2)) {
                            Noop
                        }
                    }
                    Return(0x0)
                }
                Method(SLTT) {
                    If(LOr(LEqual(CKOS(), 0x1), LEqual(CKOS(), 0x2))) {
                        Return(SXF8())
                    }
                    Else {
                        Store(\_SB_.PCI0.GCH0.SXDD(), Local0)
                        If(LNot(LEqual(\_SB_.PCI0.GCH0.PDOD, Local0))) {
                            Store(" Call _DOD to re-enumerate ", Debug)
                            If(LAnd(LEqual(CKOS(), 0x0), LNot(\WXP_))) {
                                Notify(\_SB_.PCI0.GCH0, 0x0)
                            }
                            Else {
                                Notify(\_SB_.PCI0.GCH0, 0x81)
                            }
                            Sleep(0x01f4)
                        }
                        If(LEqual(\_SB_.PCI0.GCH0.LDGS, 0x0)) {
                            HKF8()
                        }
                        If(LEqual(\_SB_.PCI0.GCH0.LDGS, 0x1)) {
                            SXF8()
                            Notify(\_SB_.PCI0.GCH0, 0x81)
                        }
                        If(LEqual(\_SB_.PCI0.GCH0.LDGS, 0x2)) {
                            Noop
                        }
                    }
                    Return(0x0)
                }
                Method(SEVF) {
                    Return(PHSB(0xc9, 0x0))
                }
                Method(GCMI, 1) {
                    Return(PHSD(0xca, Arg0))
                }
                Method(SCMI, 1) {
                    Return(PHSD(0xcb, Arg0))
                }
                Method(PWAK) {
                    Return(Zero)
                }
                Method(PWRN) {
                    Notify(\_SB_.PWRB, 0x80)
                }
                Method(CSXB, 1) {
                    Acquire(MPHS, 0xffff)
                    Store(Arg0, SXBF)
                    PHS0(0xcc)
                    Store(SXBF, Local0)
                    Release(MPHS)
                    Return(Local0)
                }
            }
        }
        Device(IDE0) {
            Name(_ADR, 0x001f0001)
            OperationRegion(IDEC, PCI_Config, 0x40, 0x18)
            Field(IDEC, DWordAcc, NoLock, Preserve) {
                PRIT,	16,
                SECT,	16,
                PSIT,	4,
                SSIT,	4,
                Offset(0x8),
                PDMA,	2,
                SDMA,	2,
                Offset(0xa),
                SDT0,	2,
                ,	2,
                SDT1,	2,
                Offset(0xb),
                SDT2,	2,
                ,	2,
                SDT3,	2,
                Offset(0x14),
                ICR0,	4,
                ICR1,	4,
                ICR2,	4,
                ICR3,	4,
                ICR4,	4,
                ICR5,	4
            }
            Method(GETP, 1) {
                If(LEqual(And(Arg0, 0x9, ), 0x0)) {
                    Return(0xffffffff)
                }
                If(LEqual(And(Arg0, 0x9, ), 0x8)) {
                    Return(0x0384)
                }
                ShiftRight(And(Arg0, 0x0300, ), 0x8, Local0)
                ShiftRight(And(Arg0, 0x3000, ), 0xc, Local1)
                Return(Multiply(0x1e, Subtract(0x9, Add(Local0, Local1, ), ), 
))
            }
            Method(GETD, 4) {
                If(Arg0) {
                    If(Arg1) {
                        Return(0x14)
                    }
                    If(Arg2) {
                        Return(Multiply(Subtract(0x4, Arg3, ), 0xf, ))
                    }
                    Return(Multiply(Subtract(0x4, Arg3, ), 0x1e, ))
                }
                Return(0xffffffff)
            }
            Method(GETF, 2) {
                Name(TMPF, 0x0)
                If(And(Arg0, 0x1, )) {
                    Or(TMPF, 0x1, TMPF)
                }
                If(And(Arg1, 0x2, )) {
                    Or(TMPF, 0x2, TMPF)
                }
                If(And(Arg1, 0x4000, )) {
                    Or(TMPF, 0x10, TMPF)
                }
                Return(TMPF)
            }
            Method(SETP, 3) {
                If(LNot(LLess(Arg0, 0xf0))) {
                    Return(0x8)
                }
                Else {
                    If(And(Arg1, 0x2, )) {
                        If(LAnd(LNot(LGreater(Arg0, 0x78)), And(Arg2, 0x2, ))) 
{
                            Return(0x2301)
                        }
                        If(LAnd(LNot(LGreater(Arg0, 0xb4)), And(Arg2, 0x1, ))) 
{
                            Return(0x2101)
                        }
                    }
                    Return(0x1001)
                }
            }
            Method(SETD, 1) {
                If(LLess(Arg0, 0x1e)) {
                    Return(0x1)
                }
                If(LLess(Arg0, 0x2d)) {
                    Return(0x2)
                }
                If(LLess(Arg0, 0x3c)) {
                    Return(0x1)
                }
                If(LLess(Arg0, 0x5a)) {
                    Return(0x2)
                }
                If(LLess(Arg0, 0x78)) {
                    Return(0x1)
                }
                Return(0x0)
            }
            Device(PRIM) {
                Name(_ADR, 0x0)
                Method(_GTM) {
                    Name(PBUF, Buffer(0x14) {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 })
                    CreateDWordField(PBUF, 0x0, PIO0)
                    CreateDWordField(PBUF, 0x4, DMA0)
                    CreateDWordField(PBUF, 0x8, PIO1)
                    CreateDWordField(PBUF, 0xc, DMA1)
                    CreateDWordField(PBUF, 0x10, FLAG)
                    Store(GETP(PRIT), PIO0)
                    Store(GETD(And(PDMA, 0x1, ), And(ICR3, 0x1, ), And(ICR0, 
0x1, ), SDT0), DMA0)
                    If(LEqual(DMA0, 0xffffffff)) {
                        Store(PIO0, DMA0)
                    }
                    Store(0xffffffff, PIO1)
                    Store(PIO1, DMA1)
                    Store(GETF(PDMA, PRIT), FLAG)
                    Return(PBUF)
                }
                Method(_STM, 3) {
                    CreateDWordField(Arg0, 0x0, PIO0)
                    CreateDWordField(Arg0, 0x4, DMA0)
                    CreateDWordField(Arg0, 0x8, PIO1)
                    CreateDWordField(Arg0, 0xc, DMA1)
                    CreateDWordField(Arg0, 0x10, FLAG)
                    Store(0x0, PRIT)
                    Store(0x0, PSIT)
                    Store(0x0, PDMA)
                    Store(0x0, SDT0)
                    Store(0x0, SDT1)
                    And(ICR0, 0xc, ICR0)
                    And(ICR1, 0xc, ICR1)
                    Store(0x4, ICR2)
                    And(ICR3, 0xc, ICR3)
                    And(ICR5, 0xc, ICR5)
                    If(LEqual(SizeOf(Arg1), 0x0200)) {
                        CreateWordField(Arg1, 0x62, W490)
                        CreateWordField(Arg1, 0x6a, W530)
                        CreateWordField(Arg1, 0x80, W640)
                        CreateWordField(Arg1, 0xb0, W880)
                        Or(PRIT, 0x8004, PRIT)
                        If(LAnd(And(FLAG, 0x2, ), And(W490, 0x0800, ))) {
                            Or(PRIT, 0x2, PRIT)
                        }
                        Or(PRIT, SETP(PIO0, W530, W640), PRIT)
                        If(And(FLAG, 0x1, )) {
                            Or(PDMA, 0x1, PDMA)
                            Store(SETD(DMA0), SDT0)
                            If(And(W880, 0x20, )) {
                                Or(ICR5, 0x1, ICR5)
                            }
                            If(And(W880, 0x10, )) {
                                Or(ICR1, 0x1, ICR1)
                            }
                            If(LLess(DMA0, 0x1e)) {
                                Or(ICR3, 0x1, ICR3)
                            }
                            If(LLess(DMA0, 0x3c)) {
                                Or(ICR0, 0x1, ICR0)
                            }
                        }
                    }
                }
                Device(DRV0) {
                    Name(_ADR, 0x0)
                    Method(_GTF) {
                        Name(PIB0, Buffer(0xe) {0x3, 0x0, 0x0, 0x0, 0x0, 0xa0, 
0xef, 0x3, 0x0, 0x0, 0x0, 0x0, 0xa0, 0xef })
                        CreateByteField(PIB0, 0x1, PMD0)
                        CreateByteField(PIB0, 0x8, DMD0)
                        If(And(PRIT, 0x2, )) {
                            If(LEqual(And(PRIT, 0x9, ), 0x8)) {
                                Store(0x8, PMD0)
                            }
                            Else {
                                Store(0xa, PMD0)
                                ShiftRight(And(PRIT, 0x0300, ), 0x8, Local0)
                                ShiftRight(And(PRIT, 0x3000, ), 0xc, Local1)
                                Add(Local0, Local1, Local2)
                                If(LEqual(0x3, Local2)) {
                                    Store(0xb, PMD0)
                                }
                                If(LEqual(0x5, Local2)) {
                                    Store(0xc, PMD0)
                                }
                            }
                        }
                        Else {
                            Store(0x1, PMD0)
                        }
                        If(And(PDMA, 0x1, )) {
                            Store(Or(SDT0, 0x40, ), DMD0)
                            If(And(ICR0, 0x1, )) {
                                Add(DMD0, 0x2, DMD0)
                            }
                            If(And(ICR3, 0x1, )) {
                                Store(0x45, DMD0)
                            }
                        }
                        Else {
                            Or(Subtract(And(PMD0, 0x7, ), 0x2, ), 0x20, DMD0)
                        }
                        Return(PIB0)
                    }
                }
                Device(DRV1) {
                    Name(_ADR, 0x1)
                }
                Method(_PS0) {
                }
                Method(_PS3) {
                }
            }
            Device(SCND) {
                Name(_ADR, 0x1)
                Method(_GTM) {
                    Name(SBUF, Buffer(0x14) {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 })
                    CreateDWordField(SBUF, 0x0, PIO0)
                    CreateDWordField(SBUF, 0x4, DMA0)
                    CreateDWordField(SBUF, 0x8, PIO1)
                    CreateDWordField(SBUF, 0xc, DMA1)
                    CreateDWordField(SBUF, 0x10, FLAG)
                    Store(GETP(SECT), PIO0)
                    Store(GETD(And(SDMA, 0x1, ), And(ICR3, 0x4, ), And(ICR0, 
0x4, ), SDT2), DMA0)
                    If(LEqual(DMA0, 0xffffffff)) {
                        Store(PIO0, DMA0)
                    }
                    Store(0xffffffff, PIO1)
                    Store(PIO1, DMA1)
                    Store(GETF(SDMA, SECT), FLAG)
                    Return(SBUF)
                }
                Method(_STM, 3) {
                    CreateDWordField(Arg0, 0x0, PIO0)
                    CreateDWordField(Arg0, 0x4, DMA0)
                    CreateDWordField(Arg0, 0x8, PIO1)
                    CreateDWordField(Arg0, 0xc, DMA1)
                    CreateDWordField(Arg0, 0x10, FLAG)
                    Store(0x0, SECT)
                    Store(0x0, SSIT)
                    Store(0x0, SDMA)
                    Store(0x0, SDT2)
                    Store(0x0, SDT3)
                    And(ICR0, 0x3, ICR0)
                    And(ICR1, 0x3, ICR1)
                    Store(0x4, ICR2)
                    And(ICR3, 0x3, ICR3)
                    And(ICR5, 0x3, ICR5)
                    If(LEqual(SizeOf(Arg1), 0x0200)) {
                        CreateWordField(Arg1, 0x62, W490)
                        CreateWordField(Arg1, 0x6a, W530)
                        CreateWordField(Arg1, 0x80, W640)
                        CreateWordField(Arg1, 0xb0, W880)
                        Or(SECT, 0x8004, SECT)
                        If(LAnd(And(FLAG, 0x2, ), And(W490, 0x0800, ))) {
                            Or(SECT, 0x2, SECT)
                        }
                        Or(SECT, SETP(PIO0, W530, W640), SECT)
                        If(And(FLAG, 0x1, )) {
                            Or(SDMA, 0x1, SDMA)
                            Store(SETD(DMA0), SDT2)
                            If(And(W880, 0x20, )) {
                                Or(ICR5, 0x4, ICR5)
                            }
                            If(And(W880, 0x10, )) {
                                Or(ICR1, 0x4, ICR1)
                            }
                            If(LLess(DMA0, 0x1e)) {
                                Or(ICR3, 0x4, ICR3)
                            }
                            If(LLess(DMA0, 0x3c)) {
                                Or(ICR0, 0x4, ICR0)
                            }
                        }
                    }
                }
                Device(DRV0) {
                    Name(_ADR, 0x0)
                    Method(_GTF) {
                        Name(SIB0, Buffer(0xe) {0x3, 0x0, 0x0, 0x0, 0x0, 0xa0, 
0xef, 0x3, 0x0, 0x0, 0x0, 0x0, 0xa0, 0xef })
                        CreateByteField(SIB0, 0x1, PMD0)
                        CreateByteField(SIB0, 0x8, DMD0)
                        If(And(SECT, 0x2, )) {
                            If(LEqual(And(SECT, 0x9, ), 0x8)) {
                                Store(0x8, PMD0)
                            }
                            Else {
                                Store(0xa, PMD0)
                                ShiftRight(And(SECT, 0x0300, ), 0x8, Local0)
                                ShiftRight(And(SECT, 0x3000, ), 0xc, Local1)
                                Add(Local0, Local1, Local2)
                                If(LEqual(0x3, Local2)) {
                                    Store(0xb, PMD0)
                                }
                                If(LEqual(0x5, Local2)) {
                                    Store(0xc, PMD0)
                                }
                            }
                        }
                        Else {
                            Store(0x1, PMD0)
                        }
                        If(And(SDMA, 0x1, )) {
                            Store(Or(SDT2, 0x40, ), DMD0)
                            If(And(ICR0, 0x4, )) {
                                Add(DMD0, 0x2, DMD0)
                            }
                            If(And(ICR3, 0x4, )) {
                                Store(0x45, DMD0)
                            }
                        }
                        Else {
                            Or(Subtract(And(PMD0, 0x7, ), 0x2, ), 0x20, DMD0)
                        }
                        Return(SIB0)
                    }
                }
                Device(DRV1) {
                    Name(_ADR, 0x1)
                }
                Method(_PS0) {
                }
                Method(_PS3) {
                }
            }
        }
        Device(USB1) {
            Name(_ADR, 0x001f0002)
            OperationRegion(USB1, PCI_Config, 0xc4, 0x4)
            Field(USB1, DWordAcc, NoLock, Preserve) {
                RSEN,	2
            }
            Name(_PRW, Package(0x2) {
                0x3,
                0x3,
            })
            Method(_PSW, 1) {
                If(Arg0) {
                    Store(0x3, RSEN)
                }
                Else {
                    Store(0x0, RSEN)
                }
            }
            Method(_PS0) {
                Store(One, ^^LPC0.GP25)
            }
            Method(_PS3) {
            }
        }
        Device(USB2) {
            Name(_ADR, 0x001f0004)
            OperationRegion(USB2, PCI_Config, 0xc4, 0x4)
            Field(USB2, DWordAcc, NoLock, Preserve) {
                RSEN,	2
            }
            Name(_PRW, Package(0x2) {
                0x4,
                0x3,
            })
            Method(_PSW, 1) {
                If(Arg0) {
                    Store(0x3, RSEN)
                }
                Else {
                    Store(0x0, RSEN)
                }
            }
            Method(_PS0) {
                Store(One, ^^LPC0.GP25)
            }
            Method(_PS3) {
            }
        }
        Device(SMBC) {
            Name(_ADR, 0x001f0003)
        }
        Device(AUDI) {
            Name(_ADR, 0x001f0005)
        }
        Device(MODE) {
            Name(_ADR, 0x001f0006)
            Name(_PRW, Package(0x2) {
                0x5,
                0x3,
            })
        }
        Scope(\_SB_.PCI0.HUB_) {
            Device(CRD0) {
                Name(_ADR, 0x00020000)
                OperationRegion(CCRD, PCI_Config, 0x0, 0xe4)
                Field(CCRD, DWordAcc, NoLock, Preserve) {
                    Offset(0x4),
                    CD04,	32,
                    Offset(0x3e),
                    CD3E,	32,
                    Offset(0x44),
                    CD44,	32,
                    Offset(0xe0),
                    CDE0,	8,
                    CDE1,	8
                }
                OperationRegion(EXCA, SystemIO, 0x03e0, 0x2)
                Field(EXCA, ByteAcc, NoLock, Preserve) {
                    INDX,	8,
                    DATA,	8
                }
                IndexField(INDX, DATA, ByteAcc, NoLock, Preserve) {
                    Offset(0x3),
                    ,	7,
                    ERIB,	1
                }
                Method(_INI) {
                    If(LEqual(CKOS(), 0x1)) {
                        Store(Zero, CDE0)
                        Store(Zero, CD04)
                        Store(Zero, CD3E)
                        Store(Zero, CD44)
                    }
                    Else {
                        Store(0x0, CDE1)
                    }
                }
                Name(_PSC, 0x0)
                Method(PSX_, 1) {
                    Store(0x0, CDE0)
                    Store(0x03e0, CD44)
                    Store(One, ERIB)
                    Store(0x0, CD44)
                    Store(Arg0, CDE0)
                    Store(Arg0, _PSC)
                }
                Method(_PS0) {
                    Store(0x0, CDE1)
                    Store(0x0, _PSC)
                }
                Method(_PS1) {
                    PSX_(0x1)
                    Or(CDE1, 0x1, CDE1)
                }
                Method(_PS2) {
                    PSX_(0x2)
                    Or(CDE1, 0x1, CDE1)
                }
                Method(_PS3) {
                    PSX_(0x3)
                    Or(CDE1, 0x1, CDE1)
                }
                Method(_STA) {
                    Return(0xf)
                }
                Name(_PRW, Package(0x2) {
                    0xb,
                    0x3,
                })
            }
        }
        Scope(\_SB_.PCI0.LPC0) {
            Mutex(SLOK, 0)
            OperationRegion(SMC1, SystemIO, 0x2e, 0x2)
            Field(SMC1, ByteAcc, NoLock, Preserve) {
                INDX,	8,
                DATA,	8
            }
            IndexField(INDX, DATA, ByteAcc, NoLock, Preserve) {
                CR00,	8,
                CR01,	8,
                CR02,	8,
                Offset(0x5),
                CR05,	8,
                Offset(0x7),
                CR07,	8,
                Offset(0x23),
                CR23,	8,
                Offset(0x26),
                PPDM,	4,
                Offset(0x27),
                PPIR,	4,
                Offset(0x30),
                RRBA,	8,
                Offset(0x33),
                DIR2,	8,
                POL2,	8
            }
            OperationRegion(RRBL, SystemIO, 0x060d, 0x3)
            Field(RRBL, ByteAcc, NoLock, Preserve) {
                GP20,	1,
                ,	22,
                GP47,	1
            }
            Method(ENCF) {
                Store(0x55, INDX)
            }
            Method(EXCF) {
                Store(0xaa, INDX)
            }
            Device(COMA) {
                Name(_HID, 0x0105d041)
                Name(MCD_, 0x12)
                Name(_EJD, "_SB.DOCK")
                Method(_CRS) {
                    If(\_SB_.PCI0.LPC0.COMA._STA()) {
                        Acquire(SLOK, 0xffff)
                        Store(PSCS(0x12), Local0)
                        Release(SLOK)
                        Return(Local0)
                    }
                    Else {
                        Return(Buffer(0x2) {0x79, 0x0 })
                    }
                }
                Method(_SRS, 1) {
                    Acquire(SLOK, 0xffff)
                    PSSS(0x12, Arg0)
                    Release(SLOK)
                }
                Method(_PRS) {
                    Acquire(SLOK, 0xffff)
                    Store(PSPS(0x12), Local0)
                    Release(SLOK)
                    Return(Local0)
                }
                Method(_DIS) {
                    Acquire(SLOK, 0xffff)
                    PSDI(0x12)
                    Release(SLOK)
                }
                Method(_STA) {
                    Acquire(SLOK, 0xffff)
                    Store(PSST(0x12), Local0)
                    Release(SLOK)
                    Return(Local0)
                }
                Name(_PSC, 0x0)
                Method(_PS0) {
                    ENCF()
                    Store(0x1, GP47)
                    Sleep(0x1)
                    Or(CR02, 0x8, CR02)
                    Store(0x0, _PSC)
                    EXCF()
                }
                Method(_PS3) {
                    ENCF()
                    Store(0x0, GP47)
                    And(CR02, 0xf7, CR02)
                    Store(0x3, _PSC)
                    EXCF()
                }
                Name(_PRW, Package(0x2) {
                    0x8,
                    0x3,
                })
            }
            Device(LPTA) {
                Name(_HID, 0x0004d041)
                Name(_UID, 0x1)
                Name(MCD_, 0x14)
                Name(_EJD, "_SB.DOCK")
                Name(CRSB, Buffer(0xd) {0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x1, 
0x8, 0x22, 0x0, 0x0, 0x79, 0x0 })
                Method(_CRS) {
                    If(\_SB_.PCI0.LPC0.LPTA._STA()) {
                        CreateWordField(CRSB, 0x2, IO1B)
                        CreateWordField(CRSB, 0x4, IO2B)
                        CreateByteField(CRSB, 0x7, IO3B)
                        CreateWordField(CRSB, 0x9, IRQB)
                        Acquire(SLOK, 0xffff)
                        ENCF()
                        ShiftLeft(CR23, 0x2, IO1B)
                        Store(IO1B, IO2B)
                        Store(Zero, IRQB)
                        If(PPIR) {
                            ShiftLeft(0x1, PPIR, IRQB)
                        }
                        If(LEqual(IO1B, 0x03bc)) {
                            Store(0x3, IO3B)
                        }
                        EXCF()
                        Release(SLOK)
                        Return(CRSB)
                    }
                    Else {
                        Return(Buffer(0x2) {0x79, 0x0 })
                    }
                }
                Method(B_SR, 1) {
                    CreateWordField(Arg0, 0x2, IO1S)
                    CreateWordField(Arg0, 0x9, IRQS)
                    Acquire(SLOK, 0xffff)
                    ENCF()
                    ShiftRight(IO1S, 0x2, CR23)
                    FindSetRightBit(IRQS, Local0)
                    If(Local0) {
                        Decrement(Local0)
                    }
                    Store(Local0, PPIR)
                    EXCF()
                    Release(SLOK)
                }
                Method(B_PR) {
                    Return(PSPS(0x14))
                }
                Method(B_DI) {
                    PSDI(0x14)
                }
                Method(_STA) {
                    Return(PSST(0x14))
                }
                Name(_PSC, 0x0)
                Method(_PS0) {
                    ENCF()
                    Or(CR01, 0x4, CR01)
                    Store(0x0, _PSC)
                    EXCF()
                }
                Method(_PS3) {
                    ENCF()
                    And(CR01, 0xfb, CR01)
                    Store(0x3, _PSC)
                    EXCF()
                }
            }
            Device(LPTB) {
                Name(_HID, 0x0004d041)
                Name(_UID, 0x2)
                Name(MCD_, 0x15)
                Name(_EJD, "_SB.DOCK")
                Name(CRSB, Buffer(0xd) {0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x1, 
0x8, 0x22, 0x0, 0x0, 0x79, 0x0 })
                Method(_CRS) {
                    If(\_SB_.PCI0.LPC0.LPTB._STA()) {
                        CreateWordField(CRSB, 0x2, IO1B)
                        CreateWordField(CRSB, 0x4, IO2B)
                        CreateByteField(CRSB, 0x7, IO3B)
                        CreateWordField(CRSB, 0x9, IRQB)
                        Acquire(SLOK, 0xffff)
                        ENCF()
                        ShiftLeft(CR23, 0x2, IO1B)
                        Store(IO1B, IO2B)
                        Store(Zero, IRQB)
                        If(PPIR) {
                            ShiftLeft(0x1, PPIR, IRQB)
                        }
                        If(LEqual(IO1B, 0x03bc)) {
                            Store(0x3, IO3B)
                        }
                        EXCF()
                        Release(SLOK)
                        Return(CRSB)
                    }
                    Else {
                        Return(Buffer(0x2) {0x79, 0x0 })
                    }
                }
                Method(B_SR, 1) {
                    CreateWordField(Arg0, 0x2, IO1S)
                    CreateWordField(Arg0, 0x9, IRQS)
                    Acquire(SLOK, 0xffff)
                    ENCF()
                    ShiftRight(IO1S, 0x2, CR23)
                    FindSetRightBit(IRQS, Local0)
                    If(Local0) {
                        Decrement(Local0)
                    }
                    Store(Local0, PPIR)
                    EXCF()
                    Release(SLOK)
                }
                Method(B_PR) {
                    Return(PSPS(0x15))
                }
                Method(B_DI) {
                    PSDI(0x15)
                }
                Method(_STA) {
                    Return(PSST(0x15))
                }
                Name(_PSC, 0x0)
                Method(_PS0) {
                    ENCF()
                    Or(CR01, 0x4, CR01)
                    Store(0x0, _PSC)
                    EXCF()
                }
                Method(_PS3) {
                    ENCF()
                    And(CR01, 0xfb, CR01)
                    Store(0x3, _PSC)
                    EXCF()
                }
            }
            Device(ECP_) {
                Name(_HID, 0x0104d041)
                Name(MCD_, 0x13)
                Name(_EJD, "_SB.DOCK")
                Name(CRSA, Buffer(0x18) {0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x1, 
0x8, 0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x1, 0x8, 0x22, 0x0, 0x0, 0x2a, 0x0, 0x0, 
0x79, 0x0 })
                Method(_CRS) {
                    If(\_SB_.PCI0.LPC0.ECP_._STA()) {
                        CreateWordField(CRSA, 0x2, IO1A)
                        CreateWordField(CRSA, 0x4, IO2A)
                        CreateByteField(CRSA, 0x7, IO3A)
                        CreateWordField(CRSA, 0xa, IO4A)
                        CreateWordField(CRSA, 0xc, IO5A)
                        CreateByteField(CRSA, 0xf, IO6A)
                        CreateWordField(CRSA, 0x11, IRQA)
                        CreateByteField(CRSA, 0x14, DMAA)
                        Acquire(SLOK, 0xffff)
                        ENCF()
                        ShiftLeft(CR23, 0x2, IO1A)
                        Store(IO1A, IO2A)
                        Add(IO1A, 0x0400, IO4A)
                        Store(IO4A, IO5A)
                        Store(Zero, IRQA)
                        If(PPIR) {
                            ShiftLeft(0x1, PPIR, IRQA)
                        }
                        If(LEqual(IO1A, 0x03bc)) {
                            Store(0x3, IO3A)
                            Store(IO3A, IO6A)
                        }
                        ShiftLeft(0x1, PPDM, DMAA)
                        EXCF()
                        Release(SLOK)
                        Return(CRSA)
                    }
                    Else {
                        Return(Buffer(0x2) {0x79, 0x0 })
                    }
                }
                Method(_SRS, 1) {
                    CreateWordField(Arg0, 0x2, IO1S)
                    CreateWordField(Arg0, 0x11, IRQS)
                    CreateByteField(Arg0, 0x14, DMAS)
                    Acquire(SLOK, 0xffff)
                    ENCF()
                    ShiftRight(IO1S, 0x2, CR23)
                    FindSetRightBit(IRQS, Local0)
                    If(Local0) {
                        Decrement(Local0)
                    }
                    Store(Local0, PPIR)
                    FindSetRightBit(DMAS, Local1)
                    Decrement(Local1)
                    Store(Local1, PPDM)
                    EXCF()
                    Release(SLOK)
                }
                Method(_PRS) {
                    Return(PSPS(0x13))
                }
                Method(_DIS) {
                    PSDI(0x13)
                }
                Method(_STA) {
                    Return(PSST(0x13))
                }
                Name(_PSC, 0x0)
                Method(_PS0) {
                    ENCF()
                    Or(CR01, 0x4, CR01)
                    Store(0x0, _PSC)
                    EXCF()
                }
                Method(_PS3) {
                    ENCF()
                    And(CR01, 0xfb, CR01)
                    Store(0x3, _PSC)
                    EXCF()
                }
            }
            Device(FDC_) {
                Name(_HID, 0x0007d041)
                Name(MCD_, 0x11)
                Name(ARM_, Zero)
                Method(_CRS) {
                    Acquire(SLOK, 0xffff)
                    Store(PSCS(0x11), Local0)
                    Release(SLOK)
                    Return(Local0)
                }
                Method(_SRS, 1) {
                    Acquire(SLOK, 0xffff)
                    PSSS(0x11, Arg0)
                    Release(SLOK)
                }
                Method(_PRS) {
                    Acquire(SLOK, 0xffff)
                    Store(PSPS(0x11), Local0)
                    Release(SLOK)
                    Return(Local0)
                }
                Method(_DIS) {
                    Acquire(SLOK, 0xffff)
                    PSDI(0x11)
                    Release(SLOK)
                }
                Method(_STA) {
                    Acquire(SLOK, 0xffff)
                    Store(PSST(0x11), Local0)
                    Release(SLOK)
                    Return(Local0)
                }
                Name(_PSC, 0x0)
                Method(_PS0) {
                    ENCF()
                    If(LEqual(PHS_(0xd3), One)) {
                        And(CR05, 0xfd, CR05)
                        Sleep(0x1)
                    }
                    Or(CR00, 0x8, CR00)
                    Store(0x0, _PSC)
                    EXCF()
                }
                Method(_PS3) {
                    ENCF()
                    And(CR00, 0xf7, CR00)
                    Or(CR05, 0x2, CR05)
                    Store(0x3, _PSC)
                    EXCF()
                }
                Name(FDES, Buffer(0x14) {0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x0, 0x0, 0x0 })
                Method(_FDE) {
                    Return(FDES)
                }
                Name(FDIB, Package(0x13) {
                    0x0,
                    0x4,
                    0x4f,
                    0x0,
                    0x12,
                    0x0,
                    0x1,
                    0x0,
                    0xdf,
                    0x2,
                    0x37,
                    0x2,
                    0x18,
                    0x1b,
                    0xff,
                    0x6c,
                    0xf6,
                    0x15,
                    0x5,
                })
                Method(_FDI) {
                    Return(FDIB)
                }
                Device(FDD_) {
                    Name(_ADR, 0x0)
                    Name(_EJD, "_SB.DOCK")
                    Method(_STA) {
                        If(LAnd(\_SB_.DOCK.DKFS, LEqual(ARM_, Zero))) {
                            Return(0xf)
                        }
                        Else {
                            Return(0x0)
                        }
                    }
                }
            }
        }
        Scope(\_SB_.PCI0.HUB_.SD94) {
            Name(_EJD, "_SB.DOCK")
        }
        Scope(\_SB_.PCI0.LPC0.EC0_) {
            Method(_Q5A) {
                Store(Zero, \_SB_.PCI0.GCH0.DODF)
                Store(Zero, \_SB_.DOCK.DCRI)
                Notify(\_SB_.DOCK, 0x0)
                If(\WXP_) {
                    Sleep(0x03e8)
                    Notify(\_SB_.PCI0.USB1, 0x0)
                    Notify(\_SB_.PCI0.USB2, 0x0)
                }
            }
            Method(_Q5B) {
                Signal(\_SB_.DOCK.UDCK)
                If(LEqual(\_SB_.DOCK.DCRI, Zero)) {
                    \_SB_.DOCK.DULF(0x0)
                    If(LNot(LEqual(CKOS(), 0x1))) {
                        Notify(\_SB_.DOCK, 0x0)
                    }
                }
                Store(Zero, \_SB_.DOCK.DCRI)
                If(\WXP_) {
                    Sleep(0x03e8)
                    Notify(\_SB_.PCI0.USB1, 0x0)
                    Notify(\_SB_.PCI0.USB2, 0x0)
                }
            }
            Method(_Q5C) {
                If(LOr(LEqual(CKOS(), 0x1), LEqual(CKOS(), 0x3))) {
                    Notify(\_SB_.DOCK, 0x1)
                }
                Else {
                    Notify(\_SB_.DOCK, 0x3)
                }
            }
        }
    }
}
Scope(\_SI_) {
    Method(_SST, 1) {
        If(LEqual(Arg0, 0x0)) {
        }
        If(LEqual(Arg0, 0x1)) {
        }
        If(LEqual(Arg0, 0x2)) {
        }
        If(LEqual(Arg0, 0x3)) {
        }
        If(LEqual(Arg0, 0x4)) {
        }
    }
}
Method(_WAK, 1) {
    If(LEqual(Arg0, 0x4)) {
        PHS_(0xa3)
    }
    If(LOr(LEqual(Arg0, 0x3), LEqual(Arg0, 0x4))) {
        \_SB_.PCI0.LPC0.SPIC._SRS(\_SB_.PCI0.LPC0.SPIC.SSRC)
        Store(\_SB_.DOCK.GDST(), Local0)
        If(LNot(LEqual(Local0, \_SB_.DOCK.DKST))) {
            Notify(\_SB_.DOCK, 0x0)
        }
    }
    If(PHS_(0xdc)) {
        Notify(\_SB_.PWRB, 0x2)
    }
    Return(Zero)
}
Scope(\_TZ_) {
    ThermalZone(ATF0) {
        Method(KELV, 1) {
            Store(Arg0, Local0)
            Multiply(Local0, 0xa, Local0)
            Add(Local0, 0x0aab, Local0)
            Return(Local0)
        }
        Method(_TMP) {
            ShiftRight(PHSD(0xd4, 0xc0), 0x8, Local0)
            If(LGreater(Local0, 0x80)) {
                Sleep(0x32)
                ShiftRight(PHSD(0xd4, 0xc0), 0x8, Local0)
            }
            Return(KELV(Local0))
        }
        Method(_PSV) {
            ShiftRight(PHSD(0xd4, 0xc4), 0x8, Local0)
            Return(KELV(Local0))
        }
        Name(_PSL, Package(0x1) {
            \_PR_.CPU0,
        })
        Method(_CRT) {
            ShiftRight(PHSD(0xd4, 0xc6), 0x8, Local0)
            Return(KELV(Local0))
        }
        Name(_TC1, 0x1)
        Name(_TC2, 0x2)
        Name(_TSP, 0x23)
    }
}
Scope(_SB_) {
    Name(IRQP, Package(0x10) {
        0x0,
        0x0,
        0x0,
        0x0,
        0x0,
        0x0,
        0x0,
        0x0,
        0x0,
        0x0200,
        0x0,
        0x0,
        0x0,
        0x0,
        0x0,
        0x0,
    })
    Device(LNKA) {
        Name(_HID, 0x0f0cd041)
        Name(_UID, 0x1)
        Name(_PRS, Buffer(0x6) {0x23, 0x0, 0x2, 0x18, 0x79, 0x0 })
        Method(_DIS) {
            Or(\_SB_.PCI0.LPC0.PIRA, 0x80, \_SB_.PCI0.LPC0.PIRA)
        }
        Method(_CRS) {
            Name(BUFA, Buffer(0x6) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
            CreateWordField(BUFA, 0x1, IRA1)
            And(\_SB_.PCI0.LPC0.PIRA, 0x8f, Local0)
            If(LLess(Local0, 0x80)) {
                And(Local0, 0xf, Local0)
                Store(DerefOf(Index(IRQP, Local0, )), Local4)
                Store(Local4, IRA1)
            }
            Return(BUFA)
        }
        Method(_SRS, 1) {
            CreateWordField(Arg0, 0x1, IRA1)
            Store(IRA1, Local0)
            Store(Match(IRQP, MEQ, Local0, MTR, 0x0, 0x0), Local1)
            And(\_SB_.PCI0.LPC0.PIRA, 0x70, Local0)
            Or(Local1, Local0, \_SB_.PCI0.LPC0.PIRA)
        }
        Method(_STA) {
            If(LEqual(\_SB_.PCI0.LPC0.PIRA, 0x80)) {
                Return(0x9)
            }
            Else {
                Return(0xb)
            }
        }
    }
    Device(LNKB) {
        Name(_HID, 0x0f0cd041)
        Name(_UID, 0x2)
        Name(_PRS, Buffer(0x6) {0x23, 0x0, 0x2, 0x18, 0x79, 0x0 })
        Method(_DIS) {
            Or(\_SB_.PCI0.LPC0.PIRB, 0x80, \_SB_.PCI0.LPC0.PIRB)
        }
        Method(_CRS) {
            Name(BUFA, Buffer(0x6) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
            CreateWordField(BUFA, 0x1, IRA1)
            And(\_SB_.PCI0.LPC0.PIRB, 0x8f, Local0)
            If(LLess(Local0, 0x80)) {
                And(Local0, 0xf, Local0)
                Store(DerefOf(Index(IRQP, Local0, )), Local4)
                Store(Local4, IRA1)
            }
            Return(BUFA)
        }
        Method(_SRS, 1) {
            CreateWordField(Arg0, 0x1, IRA1)
            Store(IRA1, Local0)
            Store(Match(IRQP, MEQ, Local0, MTR, 0x0, 0x0), Local1)
            And(\_SB_.PCI0.LPC0.PIRB, 0x70, Local0)
            Or(Local1, Local0, \_SB_.PCI0.LPC0.PIRB)
        }
        Method(_STA) {
            If(LEqual(\_SB_.PCI0.LPC0.PIRB, 0x80)) {
                Return(0x9)
            }
            Else {
                Return(0xb)
            }
        }
    }
    Device(LNKC) {
        Name(_HID, 0x0f0cd041)
        Name(_UID, 0x3)
        Name(_PRS, Buffer(0x6) {0x23, 0x0, 0x2, 0x18, 0x79, 0x0 })
        Method(_DIS) {
            Or(\_SB_.PCI0.LPC0.PIRC, 0x80, \_SB_.PCI0.LPC0.PIRC)
        }
        Method(_CRS) {
            Name(BUFA, Buffer(0x6) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
            CreateWordField(BUFA, 0x1, IRA1)
            And(\_SB_.PCI0.LPC0.PIRC, 0x8f, Local0)
            If(LLess(Local0, 0x80)) {
                And(Local0, 0xf, Local0)
                Store(DerefOf(Index(IRQP, Local0, )), Local4)
                Store(Local4, IRA1)
            }
            Return(BUFA)
        }
        Method(_SRS, 1) {
            CreateWordField(Arg0, 0x1, IRA1)
            Store(IRA1, Local0)
            Store(Match(IRQP, MEQ, Local0, MTR, 0x0, 0x0), Local1)
            And(\_SB_.PCI0.LPC0.PIRC, 0x70, Local0)
            Or(Local1, Local0, \_SB_.PCI0.LPC0.PIRC)
        }
        Method(_STA) {
            If(LEqual(\_SB_.PCI0.LPC0.PIRC, 0x80)) {
                Return(0x9)
            }
            Else {
                Return(0xb)
            }
        }
    }
    Device(LNKD) {
        Name(_HID, 0x0f0cd041)
        Name(_UID, 0x4)
        Name(_PRS, Buffer(0x6) {0x23, 0x0, 0x2, 0x18, 0x79, 0x0 })
        Method(_DIS) {
            Or(\_SB_.PCI0.LPC0.PIRD, 0x80, \_SB_.PCI0.LPC0.PIRD)
        }
        Method(_CRS) {
            Name(BUFA, Buffer(0x6) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
            CreateWordField(BUFA, 0x1, IRA1)
            And(\_SB_.PCI0.LPC0.PIRD, 0x8f, Local0)
            If(LLess(Local0, 0x80)) {
                And(Local0, 0xf, Local0)
                Store(DerefOf(Index(IRQP, Local0, )), Local4)
                Store(Local4, IRA1)
            }
            Return(BUFA)
        }
        Method(_SRS, 1) {
            CreateWordField(Arg0, 0x1, IRA1)
            Store(IRA1, Local0)
            Store(Match(IRQP, MEQ, Local0, MTR, 0x0, 0x0), Local1)
            And(\_SB_.PCI0.LPC0.PIRD, 0x70, Local0)
            Or(Local1, Local0, \_SB_.PCI0.LPC0.PIRD)
        }
        Method(_STA) {
            If(LEqual(\_SB_.PCI0.LPC0.PIRD, 0x80)) {
                Return(0x9)
            }
            Else {
                Return(0xb)
            }
        }
    }
    Device(LNKE) {
        Name(_HID, 0x0f0cd041)
        Name(_UID, 0x5)
        Name(_PRS, Buffer(0x6) {0x23, 0x0, 0x2, 0x18, 0x79, 0x0 })
        Method(_DIS) {
            Or(\_SB_.PCI0.LPC0.PIRE, 0x80, \_SB_.PCI0.LPC0.PIRE)
        }
        Method(_CRS) {
            Name(BUFA, Buffer(0x6) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
            CreateWordField(BUFA, 0x1, IRA1)
            And(\_SB_.PCI0.LPC0.PIRE, 0x8f, Local0)
            If(LLess(Local0, 0x80)) {
                And(Local0, 0xf, Local0)
                Store(DerefOf(Index(IRQP, Local0, )), Local4)
                Store(Local4, IRA1)
            }
            Return(BUFA)
        }
        Method(_SRS, 1) {
            CreateWordField(Arg0, 0x1, IRA1)
            Store(IRA1, Local0)
            Store(Match(IRQP, MEQ, Local0, MTR, 0x0, 0x0), Local1)
            And(\_SB_.PCI0.LPC0.PIRE, 0x70, Local0)
            Or(Local1, Local0, \_SB_.PCI0.LPC0.PIRE)
        }
        Method(_STA) {
            If(LEqual(\_SB_.PCI0.LPC0.PIRE, 0x80)) {
                Return(0x9)
            }
            Else {
                Return(0xb)
            }
        }
    }
    Device(LNKH) {
        Name(_HID, 0x0f0cd041)
        Name(_UID, 0x8)
        Name(_PRS, Buffer(0x6) {0x23, 0x0, 0x2, 0x18, 0x79, 0x0 })
        Method(_DIS) {
            Or(\_SB_.PCI0.LPC0.PIRH, 0x80, \_SB_.PCI0.LPC0.PIRH)
        }
        Method(_CRS) {
            Name(BUFA, Buffer(0x6) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
            CreateWordField(BUFA, 0x1, IRA1)
            And(\_SB_.PCI0.LPC0.PIRH, 0x8f, Local0)
            If(LLess(Local0, 0x80)) {
                And(Local0, 0xf, Local0)
                Store(DerefOf(Index(IRQP, Local0, )), Local4)
                Store(Local4, IRA1)
            }
            Return(BUFA)
        }
        Method(_SRS, 1) {
            CreateWordField(Arg0, 0x1, IRA1)
            Store(IRA1, Local0)
            Store(Match(IRQP, MEQ, Local0, MTR, 0x0, 0x0), Local1)
            And(\_SB_.PCI0.LPC0.PIRH, 0x70, Local0)
            Or(Local1, Local0, \_SB_.PCI0.LPC0.PIRH)
        }
        Method(_STA) {
            If(LEqual(\_SB_.PCI0.LPC0.PIRH, 0x80)) {
                Return(0x9)
            }
            Else {
                Return(0xb)
            }
        }
    }
}
Method(CKOS) {
    Store(SizeOf(_OS_), Local0)
    Name(BUFF, Buffer(Local0) { })
    Name(STRG, Buffer(0x9) { })
    Store(_OS_, BUFF)
    Store("NT E: te", STRG)
    Store(Ones, Local4)
    If(LEqual(Local0, 0x11)) {
        Add(Multiply(DerefOf(Index(BUFF, 0xf, )), 0x0100, ), 
DerefOf(Index(BUFF, 0x10, )), Local1)
        Add(Multiply(DerefOf(Index(STRG, 0x6, )), 0x0100, ), 
DerefOf(Index(STRG, 0x7, )), Local2)
        If(LEqual(Local1, Local2)) {
            Store(0x2, Local4)
        }
    }
    Else {
        If(LNot(LLess(Local0, 0x14))) {
            Add(Multiply(DerefOf(Index(BUFF, 0x12, )), 0x0100, ), 
DerefOf(Index(BUFF, 0x13, )), Local1)
            Add(Multiply(DerefOf(Index(STRG, 0x0, )), 0x0100, ), 
DerefOf(Index(STRG, 0x1, )), Local2)
            Add(Multiply(DerefOf(Index(STRG, 0x3, )), 0x0100, ), 
DerefOf(Index(STRG, 0x4, )), Local3)
            Add(Multiply(DerefOf(Index(STRG, 0x6, )), 0x0100, ), 
DerefOf(Index(STRG, 0x7, )), Local5)
            If(LEqual(Local1, Local2)) {
                Store(Zero, Local4)
            }
            Else {
                If(LEqual(Local1, Local3)) {
                    Store(One, Local4)
                }
                Else {
                    If(LEqual(Local1, Local5)) {
                        Store(0x3, Local4)
                    }
                }
            }
        }
    }
    Return(Local4)
}
Name(WXP_, Zero)
Scope(\_SB_) {
    Method(_INI) {
        If(CondRefOf(\_OSI, Local0)) {
            If(\_OSI) {
                "Windows 2001"
                Store(Ones, \WXP_)
            }
        }
    }
}
Scope(\_SB_.PCI0.LPC0.EC0_) {
    Device(BAT1) {
        Name(_HID, 0x0a0cd041)
        Name(_UID, 0x1)
        Name(_PCL, Package(0x1) {
            \_SB_,
        })
        Name(BATI, Package(0xd) {
            0x0,
            0x9650,
            0x9650,
            0x0,
            0x39d0,
            0x0,
            0x78,
            0x0,
            0xa,
            "",
            "",
            "LION",
            "Sony Corp.",
        })
        Name(BATS, Package(0x4) {
            0x2,
            0xffffffff,
            0x0d7a,
            0x3840,
        })
        Method(_STA) {
            And(PHSD(0xd4, 0x80), 0x0100, Local1)
            If(Local1) {
                Store(0x1f, Local0)
            }
            Else {
                Store(0xf, Local0)
            }
            Return(Local0)
        }
        Method(_BIF) {
            Store(PHSD(0xd4, 0xb0), Local1)
            Multiply(Local1, 0xa, Index(BATI, 0x1, ))
            Store(PHSD(0xd4, 0xb2), Local1)
            Multiply(Local1, 0xa, Index(BATI, 0x2, ))
            Store(PHSD(0xd4, 0xb6), Index(BATI, 0x4, ))
            Return(BATI)
        }
        Method(_BST) {
            Store(And(PHSD(0xd4, 0x84), 0xff, Local0), Index(BATS, 0x0, ))
            Store(PHSD(0xd4, 0xa6), Local0)
            Store(PHSD(0xd4, 0xa4), Local1)
            If(LEqual(Local1, 0xffff)) {
                Store(0xffffffff, Local1)
            }
            Else {
                If(LNot(LLess(Local1, 0x8000))) {
                    XOr(Local1, 0xffff, Local1)
                    Increment(Local1)
                }
                Multiply(Local0, Local1, Local1)
                Divide(Local1, 0x03e8, , Local1)
            }
            Store(Local1, Index(BATS, 0x1, ))
            Multiply(PHSD(0xd4, 0xa2), 0xa, Index(BATS, 0x2, ))
            Store(Local0, Index(BATS, 0x3, ))
            Return(BATS)
        }
    }
    Device(ACAD) {
        Name(_HID, "ACPI0003")
        Name(_PCL, Package(0x1) {
            \_SB_,
        })
        Method(_PSR) {
            And(PHSD(0xd4, 0x80), 0x0400, Local1)
            If(Local1) {
                Return(One)
            }
            Else {
                Return(Zero)
            }
        }
        Method(_STA) {
            Return(0xf)
        }
    }
}

}
/*
BOOT: Length=40, Revision=1, Checksum=66,
	OEMID=SONY, OEM Table ID=U1, OEM Revision=0x20010921,
	Creator ID=PTL, Creator Revision=0x1
 */

