Modified BIOS to get all cores working

Joeandmat · September 23, 2008

Yes, Should be, I can take a second look at it again if you would like

yes, i'd like.. because is not my computer.. is my friend's computer.. i don't want to kill it!

bye!

skyting · September 23, 2008

Hi, MACNUT..

could you help me to mod this BIOS:

ASUS's notebook--A8FM http://dlsvr.asus.com/pub/ASUS/nb/A8Fm/A8Fm212AS.zip

Thanks!

skyting · September 23, 2008

Oh..sorry..

I upload it as accessory.

A8Fm212AS.zip

Dane33 · September 23, 2008

Waiting for my nx7400 core2duo to work...

HELP ...

Something I could do?

Dane33 · September 23, 2008

Isn't it that one ?

Hej Macnut, could you help me with this one?

intel® Core™2 CPU T7200 @ 2ghz

ere is the link to the BIOS file for HP nx7400:

ftp://ftp.hp.com/pub/softpaq/sp36501-37000/sp36750.exe

Chipset: Mobile Intel 945GM Express Chipset with 667-MHz front side bus

Graphics: Intel Graphics Media Accelerator 950

Only issue: Kernel Panic when core2duo is enabled..

best regards and thanks in advance for the great job you're doing to the community!

skyting · September 23, 2008

If somebody Can tell me what Fields to edit on this bios, I'd be happy to.
This is one of those odd ones that I've not figured out the correct part of the CPU field to edit.

Would editing the entire Field under the CPU string correctly work? I can try it, but would hate for it to become bricked.

CODE

/*
* Intel ACPI Component Architecture

* AML Disassembler version 20050930

*

* Disassembly of mydsdt.aml, Tue Sep 23 14:51:19 2008

*/

DefinitionBlock ("DSDT.aml", "DSDT", 1, "A8Fm0", "A8Fm0205", 517)

{

Scope (_SB)

{

Name (ATKP, Zero)

Device (ATKD)

{

Name (_HID, "ATK0100")

Name (_UID, 0x01010100)

Method (INIT, 1, NotSerialized)

{

Store (One, ATKP)

Return (MNAM)

}

Method (BSTS, 0, NotSerialized)

{

Store (IKFG, Local0)

If (ACPF)

{

And (Local0, 0x7F, Local0)

}

If (ISFF)

{

Or (Local0, 0x20, Local0)

}

Return (Local0)

}

Method (TMPR, 0, NotSerialized)

{

Store (\_TZ.GTMP (), Local0)

Store (\_TZ.PRJF (), Local1)

ShiftLeft (Local1, 0x10, Local1)

Add (\_TZ.KELV (Local0), Local1, Local0)

Store (Zero, Local2)

If (TENA)

{

Store (TDTY, Local2)

}

Else

{

Store (HKTH (), Local3)

If (LNot (LEqual (Local3, 0xFFFF)))

{

Store (Local3, Local2)

}

}

ShiftLeft (Local2, 0x18, Local2)

Add (Local0, Local2, Local0)

Return (Local0)

}

Method (SFUN, 0, NotSerialized)

{

Store (0x37, Local0)

Or (Local0, 0x40, Local0)

Or (Local0, 0x80, Local0)

Or (Local0, 0x0800, Local0)

Or (Local0, 0x00020000, Local0)

Return (Local0)

}

Method (OSVR, 1, NotSerialized)

{

}

Method (GPLV, 0, NotSerialized)

{

Return (LBTN)

}

Method (SPLV, 1, NotSerialized)

{

Store (Arg0, LBTN)

^^PCI0.SBRG.EC0.STBR ()

}

Method (WLED, 1, NotSerialized)

{

OWLD (Arg0)

}

Method (BLED, 1, NotSerialized)

{

OBTD (Arg0)

}

Method (RSTS, 0, NotSerialized)

{

Return (ORST ())

}

Method (SDSP, 1, NotSerialized)

{

If (NATK ())

{

SWHG (Arg0)

}

}

Method (GPID, 0, NotSerialized)

{

Return (LCDR)

}

Method (HWRS, 0, NotSerialized)

{

Store (0x00, Local0)

If (And (WLDP, 0x01))

{

Add (Local0, 0x80, Local0)

}

If (And (BTDP, 0x01))

{

Add (Local0, 0x0100, Local0)

}

Return (Local0)

}

Method (GLCD, 0, NotSerialized)

{

Return (LCDV)

}

Name (WAPF, 0x00)

Method (CWAP, 1, NotSerialized)

{

Or (Arg0, WAPF, WAPF)

Return (0x01)

}

Name (PCDV, 0x00)

Method (WDOG, 1, NotSerialized)

{

If (LEqual (Arg0, 0x00))

{

Store (PTIM, PCDV)

Return (0x3C)

}

If (LEqual (Arg0, 0x01))

{

If (LIDS)

{

Store (PTIM, PCDV)

Return (One)

}

If (LLess (\_TZ.RLTM (), PTMP))

{

Store (PTIM, PCDV)

Return (One)

}

Decrement (PCDV)

If (LEqual (PCDV, 0x00))

{

Store (PTIM, PCDV)

Notify (ATKD, 0x6D)

}

Return (One)

}

Return (Zero)

}

Method (ANVI, 1, Serialized)

{

Store (ASMI (Arg0), Local0)

Return (Local0)

}

Method (SMBB, 1, Serialized)

{

ShiftRight (Arg0, 0x10, Local0)

And (Local0, 0xFF, Local0)

ShiftRight (Arg0, 0x18, Local1)

And (Arg0, 0xFF, Local2)

If (And (Local1, 0x01))

{

Return (RBYT (Local1, Local0))

}

Else

{

Return (WBYT (Local1, Local0, Local2))

}

}

Method (SMBW, 1, Serialized)

{

ShiftRight (Arg0, 0x10, Local0)

And (Local0, 0xFF, Local0)

ShiftRight (Arg0, 0x18, Local1)

And (Arg0, 0xFF, Local2)

If (And (Local1, 0x01))

{

Return (RWRD (Local1, Local0))

}

Else

{

Return (WWRD (Local1, Local0, Local2))

}

}

Method (SMBK, 1, Serialized)

{

ShiftRight (Arg0, 0x08, Local0)

And (Local0, 0xFF, Local0)

If (Local0)

{

ShiftRight (Arg0, 0x10, Local0)

And (Local0, 0xFF, Local0)

ShiftRight (Arg0, 0x18, Local1)

And (Local1, 0xFF, Local1)

And (Arg0, 0x0F, Local3)

If (And (Local1, 0x01))

{

RBLK (Local1, Local0, Local3)

}

Else

{

WBLK (Local1, Local0, Local3)

}

Return (0x00)

}

Else

{

ShiftRight (Arg0, 0x10, Local2)

And (Local2, 0xFF, Local2)

ShiftRight (Arg0, 0x18, Local1)

If (And (Local1, 0x01))

{

Return (DerefOf (Index (RBUF, Local2)))

}

Else

{

And (Arg0, 0xFF, Local1)

Store (Local1, Index (RBUF, Local2))

Return (0x00)

}

}

}

Method (ECRW, 1, Serialized)

{

ShiftRight (Arg0, 0x18, Local0)

And (Local0, 0xFF, Local0)

ShiftRight (Arg0, 0x10, Local1)

And (Local1, 0xFF, Local1)

ShiftRight (Arg0, 0x08, Local2)

And (Local2, 0xFF, Local2)

And (Arg0, 0xFF, Local3)

If (LNot (LEqual (Acquire (^^PCI0.SBRG.EC0.MUEC, 0xFFFF), 0x00)))

{

Return (Ones)

}

Store (Local0, ^^PCI0.SBRG.EC0.CDT3)

Store (Local1, ^^PCI0.SBRG.EC0.CDT2)

Store (Local2, ^^PCI0.SBRG.EC0.CDT1)

Store (Local3, ^^PCI0.SBRG.EC0.CMD1)

Store (0x05, Local0)

While (LAnd (Local0, ^^PCI0.SBRG.EC0.CMD1))

{

Sleep (0x01)

Decrement (Local0)

}

Store (^^PCI0.SBRG.EC0.CDT3, Local0)

Store (^^PCI0.SBRG.EC0.CDT2, Local1)

Store (^^PCI0.SBRG.EC0.CDT1, Local2)

Store (^^PCI0.SBRG.EC0.CMD1, Local3)

Release (^^PCI0.SBRG.EC0.MUEC)

ShiftLeft (Local0, 0x08, Local0)

Or (Local0, Local1, Local0)

ShiftLeft (Local0, 0x08, Local0)

Or (Local0, Local2, Local0)

ShiftLeft (Local0, 0x08, Local0)

Or (Local0, Local3, Local0)

Return (Local0)

}

Method (RDDT, 0, NotSerialized)

{

Store (\_TZ.RTMV (), Local0)

ShiftLeft (Local0, 0x08, Local0)

Add (Local0, \_TZ.GTMP (), Local0)

ShiftLeft (Local0, 0x08, Local0)

ISMI (0xA1)

Add (Local0, ATMP, Local0)

ShiftLeft (Local0, 0x08, Local0)

Add (Local0, BTMP, Local0)

Return (Local0)

}

}

}

Scope (_PR)

{

Processor (CPU1, 0x01, 0x00000810, 0x06)

{

OperationRegion (STBL, SystemMemory, 0xFFFF0000, 0xFFFF)

Name (NCPU, 0x00)

Name (PDC1, 0x80000000)

Name (HNDL, 0x80000000)

Name (CFGD, 0x80000000)

Name (TBLD, 0x00)

Name (ISC1, 0x00)

Method (_PDC, 1, NotSerialized)

{

CreateDWordField (Arg0, 0x08, DAT0)

Store (DAT0, PDC1)

If (LEqual (TBLD, 0x00))

{

If (LAnd (LNot (LLess (NCPU, 0x02)), LEqual (And (PDC1, 0x0A), 0x0A)))

{

Load (STBL, HNDL)

Store (0x01, TBLD)

}

If (LAnd (LEqual (NCPU, 0x01), LEqual (And (PDC1, 0x01), 0x01)))

{

If (And (PDC1, 0x01)) {}

}

}

}

}

}

Scope (_PR)

{

Processor (CPU2, 0x02, 0x00000810, 0x06)

{

OperationRegion (STBL, SystemMemory, 0xFFFF0000, 0xFFFF)

Name (NCPU, 0x00)

Name (PDC2, 0x80000000)

Name (HNDL, 0x80000000)

Name (CFGD, 0x80000000)

Name (TBLD, 0x00)

Method (_PDC, 1, NotSerialized)

{

CreateDWordField (Arg0, 0x08, DAT0)

Store (DAT0, PDC2)

If (LEqual (TBLD, 0x00))

{

If (LAnd (LNot (LLess (NCPU, 0x02)), LEqual (And (PDC2, 0x01), 0x01)))

{

Load (STBL, HNDL)

Store (0x02, TBLD)

}

If (LAnd (LEqual (NCPU, 0x01), LEqual (And (PDC2, 0x01), 0x01)))

{

If (LNot (And (PDC2, 0x10)))

{

Load (STBL, HNDL)

Store (0x01, TBLD)

}

}

}

}

}

}

Name (PMBS, 0x0800)

Name (PMLN, 0x80)

Name (GPBS, 0x0480)

Name (GPLN, 0x40)

Name (SMBL, 0x00)

Name (PM30, 0x0830)

Name (SUSW, 0xFF)

Name (APIC, 0x01)

Name (PCIB, 0xE0000000)

Name (PCIL, 0x04000000)

Name (APCB, 0xFEC00000)

Name (APCL, 0x00100000)

Name (SMBS, 0x0400)

Name (MBLF, 0x0A)

Name (SMIP, 0xB2)

OperationRegion (BIOS, SystemMemory, 0xFFFFFF00, 0xFF)

Field (BIOS, ByteAcc, NoLock, Preserve)

{

SS1, 1,

SS2, 1,

SS3, 1,

SS4, 1,

Offset (0x01),

IOST, 16,

TOPM, 32,

ROMS, 32,

MG1B, 32,

MG1L, 32,

MG2B, 32,

MG2L, 32,

Offset (0x1C),

ASSB, 8,

AOTB, 8,

AAXB, 32

}

Method (RRIO, 4, NotSerialized)

{

Store ("RRIO", Debug)

}

Method (RDMA, 3, NotSerialized)

{

Store ("rDMA", Debug)

}

Name (PICM, 0x00)

Method (_PIC, 1, NotSerialized)

{

If (Arg0)

{

Store (0xAA, DBG8)

}

Else

{

Store (0xAC, DBG8)

}

Store (Arg0, PICM)

}

Name (OSVR, Ones)

Method (OSFL, 0, NotSerialized)

{

If (LNot (LEqual (OSVR, Ones)))

{

Return (OSVR)

}

If (LEqual (PICM, 0x00))

{

Store (0xAC, DBG8)

}

Store (0x01, OSVR)

If (MCTH (_OS, "Microsoft Windows NT"))

{

Store (0x00, OSVR)

}

Else

{

If (MCTH (_OS, "Microsoft WindowsME: Millennium Edition"))

{

Store (0x02, OSVR)

}

If (MCTH (_OS, "Linux"))

{

Store (0x03, OSVR)

}

}

Return (OSVR)

}

Method (MCTH, 2, NotSerialized)

{

If (LLess (SizeOf (Arg0), SizeOf (Arg1)))

{

Return (Zero)

}

Add (SizeOf (Arg0), 0x01, Local0)

Name (BUF0, Buffer (Local0) {})

Name (BUF1, Buffer (Local0) {})

Store (Arg0, BUF0)

Store (Arg1, BUF1)

While (Local0)

{

Decrement (Local0)

If (LNot (LEqual (DerefOf (Index (BUF0, Local0)), DerefOf (Index (BUF1, Local0)))))

{

Return (Zero)

}

}

Return (One)

}

Name (PRWP, Package (0x02)

{

Zero,

Zero

})

Method (GPRW, 2, NotSerialized)

{

Store (Arg0, Index (PRWP, 0x00))

Store (ShiftLeft (SS1, 0x01), Local0)

Or (Local0, ShiftLeft (SS2, 0x02), Local0)

Or (Local0, ShiftLeft (SS3, 0x03), Local0)

Or (Local0, ShiftLeft (SS4, 0x04), Local0)

If (And (ShiftLeft (0x01, Arg1), Local0))

{

Store (Arg1, Index (PRWP, 0x01))

}

Else

{

ShiftRight (Local0, 0x01, Local0)

If (LOr (LEqual (OSFL (), 0x01), LEqual (OSFL (), 0x02)))

{

FindSetLeftBit (Local0, Index (PRWP, 0x01))

}

Else

{

FindSetRightBit (Local0, Index (PRWP, 0x01))

}

}

Return (PRWP)

}

Name (WAKP, Package (0x02)

{

Zero,

Zero

})

OperationRegion (DEB0, SystemIO, 0x80, 0x01)

Field (DEB0, ByteAcc, NoLock, Preserve)

{

DBG8, 8

}

OperationRegion (DEB1, SystemIO, 0x90, 0x02)

Field (DEB1, WordAcc, NoLock, Preserve)

{

DBG9, 16

}

Scope (_SB)

{

Name (PR00, Package (0x12)

{

Package (0x04)

{

0x0001FFFF,

0x00,

LNKA,

0x00

},

Package (0x04)

{

0x0001FFFF,

0x01,

LNKB,

0x00

},

Package (0x04)

{

0x0001FFFF,

0x02,

LNKC,

0x00

},

Package (0x04)

{

0x0001FFFF,

0x03,

LNKD,

0x00

},

Package (0x04)

{

0x001FFFFF,

0x00,

LNKC,

0x00

},

Package (0x04)

{

0x001FFFFF,

0x01,

LNKD,

0x00

},

Package (0x04)

{

0x001DFFFF,

0x00,

LNKH,

0x00

},

Package (0x04)

{

0x001DFFFF,

0x02,

LNKE,

0x00

},

Package (0x04)

{

0x001DFFFF,

0x03,

LNKG,

0x00

},

Package (0x04)

{

0x001EFFFF,

0x00,

LNKB,

0x00

},

Package (0x04)

{

0x001EFFFF,

0x01,

LNKE,

0x00

},

Package (0x04)

{

0x001BFFFF,

0x00,

LNKF,

0x00

},

Package (0x04)

{

0x001CFFFF,

0x00,

LNKA,

0x00

},

Package (0x04)

{

0x001CFFFF,

0x01,

LNKB,

0x00

},

Package (0x04)

{

0x001CFFFF,

0x02,

LNKC,

0x00

},

Package (0x04)

{

0x001CFFFF,

0x03,

LNKD,

0x00

},

Package (0x04)

{

0x0002FFFF,

0x00,

LNKA,

0x00

},

Package (0x04)

{

0x001DFFFF,

0x01,

LNKD,

0x00

}

})

Name (AR00, Package (0x12)

{

Package (0x04)

{

0x0001FFFF,

0x00,

0x00,

0x10

},

Package (0x04)

{

0x0001FFFF,

0x01,

0x00,

0x11

},

Package (0x04)

{

0x0001FFFF,

0x02,

0x00,

0x12

},

Package (0x04)

{

0x0001FFFF,

0x03,

0x00,

0x13

},

Package (0x04)

{

0x001FFFFF,

0x00,

0x00,

0x12

},

Package (0x04)

{

0x001FFFFF,

0x01,

0x00,

0x13

},

Package (0x04)

{

0x001DFFFF,

0x00,

0x00,

0x17

},

Package (0x04)

{

0x001DFFFF,

0x02,

0x00,

0x14

},

Package (0x04)

{

0x001DFFFF,

0x03,

0x00,

0x16

},

Package (0x04)

{

0x001EFFFF,

0x00,

0x00,

0x11

},

Package (0x04)

{

0x001EFFFF,

0x01,

0x00,

0x14

},

Package (0x04)

{

0x001BFFFF,

0x00,

0x00,

0x15

},

Package (0x04)

{

0x001CFFFF,

0x00,

0x00,

0x10

},

Package (0x04)

{

0x001CFFFF,

0x01,

0x00,

0x11

},

Package (0x04)

{

0x001CFFFF,

0x02,

0x00,

0x12

},

Package (0x04)

{

0x001CFFFF,

0x03,

0x00,

0x13

},

Package (0x04)

{

0x0002FFFF,

0x00,

0x00,

0x10

},

Package (0x04)

{

0x001DFFFF,

0x01,

0x00,

0x13

}

})

Name (PR01, Package (0x02)

{

Package (0x04)

{

0xFFFF,

0x00,

LNKA,

0x00

},

Package (0x04)

{

0xFFFF,

0x01,

LNKB,

0x00

}

})

Name (AR01, Package (0x02)

{

Package (0x04)

{

0xFFFF,

0x00,

0x00,

0x10

},

Package (0x04)

{

0xFFFF,

0x01,

0x00,

0x11

}

})

Name (PR04, Package (0x04)

{

Package (0x04)

{

0xFFFF,

0x00,

LNKA,

0x00

},

Package (0x04)

{

0xFFFF,

0x01,

LNKB,

0x00

},

Package (0x04)

{

0xFFFF,

0x02,

LNKC,

0x00

},

Package (0x04)

{

0xFFFF,

0x03,

LNKD,

0x00

}

})

Name (AR04, Package (0x04)

{

Package (0x04)

{

0xFFFF,

0x00,

0x00,

0x10

},

Package (0x04)

{

0xFFFF,

0x01,

0x00,

0x11

},

Package (0x04)

{

0xFFFF,

0x02,

0x00,

0x12

},

Package (0x04)

{

0xFFFF,

0x03,

0x00,

0x13

}

})

Name (PR05, Package (0x04)

{

Package (0x04)

{

0xFFFF,

0x00,

LNKB,

0x00

},

Package (0x04)

{

0xFFFF,

0x01,

LNKC,

0x00

},

Package (0x04)

{

0xFFFF,

0x02,

LNKD,

0x00

},

Package (0x04)

{

0xFFFF,

0x03,

LNKA,

0x00

}

})

Name (AR05, Package (0x04)

{

Package (0x04)

{

0xFFFF,

0x00,

0x00,

0x11

},

Package (0x04)

{

0xFFFF,

0x01,

0x00,

0x12

},

Package (0x04)

{

0xFFFF,

0x02,

0x00,

0x13

},

Package (0x04)

{

0xFFFF,

0x03,

0x00,

0x10

}

})

Name (PR06, Package (0x04)

{

Package (0x04)

{

0xFFFF,

0x00,

LNKC,

0x00

},

Package (0x04)

{

0xFFFF,

0x01,

LNKD,

0x00

},

Package (0x04)

{

0xFFFF,

0x02,

LNKA,

0x00

},

Package (0x04)

{

0xFFFF,

0x03,

LNKB,

0x00

}

})

Name (AR06, Package (0x04)

{

Package (0x04)

{

0xFFFF,

0x00,

0x00,

0x12

},

Package (0x04)

{

0xFFFF,

0x01,

0x00,

0x13

},

Package (0x04)

{

0xFFFF,

0x02,

0x00,

0x10

},

Package (0x04)

{

0xFFFF,

0x03,

0x00,

0x11

}

})

Name (PR07, Package (0x04)

{

Package (0x04)

{

0xFFFF,

0x00,

LNKD,

0x00

},

Package (0x04)

{

0xFFFF,

0x01,

LNKA,

0x00

},

Package (0x04)

{

0xFFFF,

0x02,

LNKB,

0x00

},

Package (0x04)

{

0xFFFF,

0x03,

LNKC,

0x00

}

})

Name (AR07, Package (0x04)

{

Package (0x04)

{

0xFFFF,

0x00,

0x00,

0x13

},

Package (0x04)

{

0xFFFF,

0x01,

0x00,

0x10

},

Package (0x04)

{

0xFFFF,

0x02,

0x00,

0x11

},

Package (0x04)

{

0xFFFF,

0x03,

0x00,

0x12

}

})

Name (PR08, Package (0x04)

{

Package (0x04)

{

0xFFFF,

0x00,

LNKA,

0x00

},

Package (0x04)

{

0xFFFF,

0x01,

LNKB,

0x00

},

Package (0x04)

{

0xFFFF,

0x02,

LNKC,

0x00

},

Package (0x04)

{

0xFFFF,

0x03,

LNKD,

0x00

}

})

Name (AR08, Package (0x04)

{

Package (0x04)

{

0xFFFF,

0x00,

0x00,

0x10

},

Package (0x04)

{

0xFFFF,

0x01,

0x00,

0x11

},

Package (0x04)

{

0xFFFF,

0x02,

0x00,

0x12

},

Package (0x04)

{

0xFFFF,

0x03,

0x00,

0x13

}

})

Name (PR09, Package (0x04)

{

Package (0x04)

{

0xFFFF,

0x00,

LNKB,

0x00

},

Package (0x04)

{

0xFFFF,

0x01,

LNKC,

0x00

},

Package (0x04)

{

0xFFFF,

0x02,

LNKD,

0x00

},

Package (0x04)

{

0xFFFF,

0x03,

LNKA,

0x00

}

})

Name (AR09, Package (0x04)

{

Package (0x04)

{

0xFFFF,

0x00,

0x00,

0x11

},

Package (0x04)

{

0xFFFF,

0x01,

0x00,

0x12

},

Package (0x04)

{

0xFFFF,

0x02,

0x00,

0x13

},

Package (0x04)

{

0xFFFF,

0x03,

0x00,

0x10

}

})

Name (PRSA, ResourceTemplate ()

{

IRQ (Level, ActiveLow, Shared) {3,4,5,6,7,10,11,12,14,15}

})

Alias (PRSA, PRSB)

Alias (PRSA, PRSC)

Alias (PRSA, PRSD)

Alias (PRSA, PRSE)

Alias (PRSA, PRSF)

Alias (PRSA, PRSG)

Alias (PRSA, PRSH)

Device (PCI0)

{

Name (_HID, EisaId ("PNP0A03"))

Name (_ADR, 0x00)

Method (^BN00, 0, NotSerialized)

{

Return (0x00)

}

Method (_BBN, 0, NotSerialized)

{

Return (BN00 ())

}

Name (_UID, 0x00)

Method (_PRT, 0, NotSerialized)

{

If (PICM)

{

Return (AR00)

}

Return (PR00)

}

Method (_S3D, 0, NotSerialized)

{

If (LOr (LEqual (OSFL (), 0x01), LEqual (OSFL (), 0x02)))

{

Return (0x02)

}

Else

{

Return (0x03)

}

}

Name (_CID, 0x030AD041)

Device (MCH)

{

Name (_HID, EisaId ("PNP0C01"))

Name (_UID, 0x0A)

Name (_CRS, ResourceTemplate ()

{

Memory32Fixed (ReadWrite, 0xFED13000, 0x00007000)

})

}

Method (NPTS, 1, NotSerialized)

{

}

Method (NWAK, 1, NotSerialized)

{

}

Device (P0P2)

{

Name (_ADR, 0x00010000)

Method (_PRW, 0, NotSerialized)

{

Return (GPRW (0x09, 0x04))

}

}

Device (P0P1)

{

Name (_ADR, 0x001E0000)

Method (_PRW, 0, NotSerialized)

{

Return (GPRW (0x0B, 0x04))

}

Method (_PRT, 0, NotSerialized)

{

If (PICM)

{

Return (AR01)

}

Return (PR01)

}

Device (P394)

{

Name (_ADR, 0x00)

Method (_PRW, 0, NotSerialized)

{

Return (GPRW (0x0B, 0x03))

}

}

Device (SD)

{

Name (_ADR, 0x01)

}

Device (MMC)

{

Name (_ADR, 0x02)

}

}

Device (SBRG)

{

Name (_ADR, 0x001F0000)

Device (IELK)

{

Name (_HID, "AWY0001")

OperationRegion (RXA0, PCI_Config, 0xA0, 0x20)

Field (RXA0, ByteAcc, NoLock, Preserve)

{

, 9,

PBLV, 1,

Offset (0x10),

, 1,

PBMS, 1,

, 1,

PMCS, 1,

ECNS, 1,

Offset (0x11),

ECT1, 16,

ELEN, 1,

Offset (0x14)

}

Method (\_GPE._L0A, 0, NotSerialized)

{

Notify (\_SB.PCI0.SBRG.IELK, 0x81)

Store (0x01, \_SB.PCI0.SBRG.IELK.PMCS)

}

Method (_STA, 0, NotSerialized)

{

If (ELEN)

{

Return (0x0F)

}

Else

{

Return (0x00)

}

}

Method (SMOD, 1, NotSerialized)

{

}

Method (GPBS, 0, NotSerialized)

{

Return (XOr (PBLV, 0x01))

}

}

Method (SPTS, 1, NotSerialized)

{

Store (One, PS1S)

Store (One, PS1E)

Store (One, SLPS)

}

Method (SWAK, 1, NotSerialized)

{

Store (Zero, SLPS)

Store (Zero, PS1E)

If (RTCS) {}

Else

{

Notify (PWRB, 0x02)

}

If (BRTC) {}

Else

{

Notify (PWRB, 0x02)

}

}

OperationRegion (APMP, SystemIO, SMIP, 0x02)

Field (APMP, ByteAcc, NoLock, Preserve)

{

APMC, 8,

APMS, 8

}

Field (APMP, ByteAcc, NoLock, Preserve)

{

Offset (0x01),

, 1,

BRTC, 1

}

OperationRegion (PMS0, SystemIO, PMBS, 0x04)

Field (PMS0, ByteAcc, NoLock, Preserve)

{

, 10,

RTCS, 1,

, 4,

WAKS, 1,

Offset (0x03),

PWBT, 1,

Offset (0x04)

}

OperationRegion (SMIE, SystemIO, PM30, 0x08)

Field (SMIE, ByteAcc, NoLock, Preserve)

{

, 4,

PS1E, 1,

, 31,

PS1S, 1,

Offset (0x08)

}

Scope (\_SB)

{

Name (SLPS, 0x00)

}

Device (PIC)

{

Name (_HID, EisaId ("PNP0000"))

Name (_CRS, ResourceTemplate ()

{

IO (Decode16, 0x0020, 0x0020, 0x00, 0x02)

IO (Decode16, 0x00A0, 0x00A0, 0x00, 0x02)

IRQNoFlags () {2}

})

}

Device (DMAD)

{

Name (_HID, EisaId ("PNP0200"))

Name (_CRS, ResourceTemplate ()

{

DMA (Compatibility, BusMaster, Transfer8) {4}

IO (Decode16, 0x0000, 0x0000, 0x00, 0x10)

IO (Decode16, 0x0081, 0x0081, 0x00, 0x03)

IO (Decode16, 0x0087, 0x0087, 0x00, 0x01)

IO (Decode16, 0x0089, 0x0089, 0x00, 0x03)

IO (Decode16, 0x008F, 0x008F, 0x00, 0x01)

IO (Decode16, 0x00C0, 0x00C0, 0x00, 0x20)

})

}

Device (TMR)

{

Name (_HID, EisaId ("PNP0100"))

Name (_CRS, ResourceTemplate ()

{

IO (Decode16, 0x0040, 0x0040, 0x00, 0x04)

IRQNoFlags () {0}

})

}

Device (RTC0)

{

Name (_HID, EisaId ("PNP0B00"))

Name (_CRS, ResourceTemplate ()

{

IO (Decode16, 0x0070, 0x0070, 0x00, 0x02)

IRQNoFlags () {8}

})

}

Device (PS2K)

{

Name (_HID, EisaId ("PNP0303"))

Name (_CID, 0x0B03D041)

Method (_STA, 0, NotSerialized)

{

ShiftLeft (0x01, 0x0A, Local0)

If (And (IOST, Local0))

{

Return (0x0F)

}

Return (0x00)

}

Name (_CRS, ResourceTemplate ()

{

IO (Decode16, 0x0060, 0x0060, 0x00, 0x01)

IO (Decode16, 0x0064, 0x0064, 0x00, 0x01)

IRQNoFlags () {1}

})

}

Device (PS2M)

{

Name (_HID, EisaId ("SYN0A06"))

Name (_CID, Package (0x05)

{

0x000A2E4F,

0x02002E4F,

0x030FD041,

0x130FD041,

0x120FD041

})

Method (_STA, 0, NotSerialized)

{

ShiftLeft (0x01, 0x0C, Local0)

If (And (IOST, Local0))

{

Return (0x0F)

}

Return (0x00)

}

Name (CRS1, ResourceTemplate ()

{

IRQNoFlags () {12}

})

Name (CRS2, ResourceTemplate ()

{

IO (Decode16, 0x0060, 0x0060, 0x00, 0x01)

IO (Decode16, 0x0064, 0x0064, 0x00, 0x01)

IRQNoFlags () {12}

})

Method (_CRS, 0, NotSerialized)

{

ShiftLeft (0x01, 0x0A, Local0)

If (And (IOST, Local0))

{

Return (CRS1)

}

Else

{

Return (CRS2)

}

}

}

Device (SPKR)

{

Name (_HID, EisaId ("PNP0800"))

Name (_CRS, ResourceTemplate ()

{

IO (Decode16, 0x0061, 0x0061, 0x00, 0x01)

})

}

Device (COPR)

{

Name (_HID, EisaId ("PNP0C04"))

Name (_CRS, ResourceTemplate ()

{

IO (Decode16, 0x00F0, 0x00F0, 0x00, 0x10)

IRQNoFlags () {13}

})

}

Device (RMSC)

{

Name (_HID, EisaId ("PNP0C02"))

Name (_UID, 0x10)

Name (CRS, ResourceTemplate ()

{

IO (Decode16, 0x0010, 0x0010, 0x00, 0x10)

IO (Decode16, 0x0022, 0x0022, 0x00, 0x1E)

IO (Decode16, 0x0044, 0x0044, 0x00, 0x0A)

IO (Decode16, 0x0050, 0x0050, 0x00, 0x10)

IO (Decode16, 0x0063, 0x0063, 0x00, 0x01)

IO (Decode16, 0x0065, 0x0065, 0x00, 0x01)

IO (Decode16, 0x0067, 0x0067, 0x00, 0x09)

IO (Decode16, 0x0072, 0x0072, 0x00, 0x0E)

IO (Decode16, 0x0080, 0x0080, 0x00, 0x01)

IO (Decode16, 0x0084, 0x0084, 0x00, 0x03)

IO (Decode16, 0x0088, 0x0088, 0x00, 0x01)

IO (Decode16, 0x008C, 0x008C, 0x00, 0x03)

IO (Decode16, 0x0090, 0x0090, 0x00, 0x10)

IO (Decode16, 0x00A2, 0x00A2, 0x00, 0x1E)

IO (Decode16, 0x00E0, 0x00E0, 0x00, 0x10)

IO (Decode16, 0x04D0, 0x04D0, 0x00, 0x02)

IO (Decode16, 0x0000, 0x0000, 0x00, 0x00)

IO (Decode16, 0x0000, 0x0000, 0x00, 0x00)

IO (Decode16, 0x0000, 0x0000, 0x00, 0x00)

Memory32Fixed (ReadWrite, 0xFED1C000, 0x00004000)

Memory32Fixed (ReadWrite, 0xFED20000, 0x00020000)

Memory32Fixed (ReadWrite, 0xFED45000, 0x00045000)

})

Method (_CRS, 0, NotSerialized)

{

CreateWordField (CRS, 0x82, GP00)

CreateWordField (CRS, 0x84, GP01)

CreateByteField (CRS, 0x87, GP0L)

Store (PMBS, GP00)

Store (PMBS, GP01)

Store (PMLN, GP0L)

If (SMBS)

{

CreateWordField (CRS, 0x8A, GP10)

CreateWordField (CRS, 0x8C, GP11)

CreateByteField (CRS, 0x8F, GP1L)

Store (SMBS, GP10)

Store (SMBS, GP11)

Store (SMBL, GP1L)

}

If (GPBS)

{

CreateWordField (CRS, 0x92, GP20)

CreateWordField (CRS, 0x94, GP21)

CreateByteField (CRS, 0x97, GP2L)

Store (GPBS, GP20)

Store (GPBS, GP21)

Store (GPLN, GP2L)

}

Return (CRS)

}

}

Device (HPET)

{

Name (_HID, EisaId ("PNP0103"))

Name (CRS, ResourceTemplate ()

{

Memory32Fixed (ReadOnly, 0xFED00000, 0x00000400)

})

Method (_STA, 0, NotSerialized)

{

Return (0x0F)

}

Method (_CRS, 0, NotSerialized)

{

Return (CRS)

}

}

OperationRegion (RX80, PCI_Config, 0x00, 0xFF)

Field (RX80, ByteAcc, NoLock, Preserve)

{

Offset (0x80),

LPCD, 16,

LPCE, 16

}

Name (DBPT, Package (0x04)

{

Package (0x08)

{

0x03F8,

0x02F8,

0x0220,

0x0228,

0x0238,

0x02E8,

0x0338,

0x03E8

},

Package (0x08)

{

0x03F8,

0x02F8,

0x0220,

0x0228,

0x0238,

0x02E8,

0x0338,

0x03E8

},

Package (0x03)

{

0x0378,

0x0278,

0x03BC

},

Package (0x02)

{

0x03F0,

0x0370

}

})

Name (DDLT, Package (0x04)

{

Package (0x02)

{

0x00,

0xFFF8

},

Package (0x02)

{

0x04,

0xFF8F

},

Package (0x02)

{

0x08,

0xFCFF

},

Package (0x02)

{

0x0C,

0xEFFF

}

})

Method (RRIO, 4, NotSerialized)

{

If (LAnd (LNot (LGreater (Arg0, 0x03)), LNot (LLess (Arg0, 0x00))))

{

Store (Match (DerefOf (Index (DBPT, Arg0)), MEQ, Arg2, MTR, 0x00, 0x00), Local0)

If (LNot (LEqual (Local0, Ones)))

{

Store (DerefOf (Index (DerefOf (Index (DDLT, Arg0)), 0x00)), Local1)

Store (DerefOf (Index (DerefOf (Index (DDLT, Arg0)), 0x01)), Local2)

ShiftLeft (Local0, Local1, Local0)

And (LPCD, Local2, LPCD)

Or (LPCD, Local0, LPCD)

WX82 (Arg0, Arg1)

}

}

If (LEqual (Arg0, 0x08))

{

If (LEqual (Arg2, 0x0200))

{

WX82 (0x08, Arg0)

}

Else

{

If (LEqual (Arg2, 0x0208))

{

WX82 (0x09, Arg0)

}

}

}

If (LAnd (LNot (LGreater (Arg0, 0x0D)), LNot (LLess (Arg0, 0x0A))))

{

WX82 (Arg0, Arg1)

}

}

Method (WX82, 2, NotSerialized)

{

ShiftLeft (0x01, Arg0, Local0)

If (Arg1)

{

Or (LPCE, Local0, LPCE)

}

Else

{

Not (Local0, Local0)

And (LPCE, Local0, LPCE)

}

}

Method (RDMA, 3, NotSerialized)

{

}

Device (FWH)

{

Name (_HID, EisaId ("PNP0C02"))

Name (_UID, 0x02)

Name (CRS, ResourceTemplate ()

{

Memory32Fixed (ReadOnly, 0x00000000, 0x00000000)

Memory32Fixed (ReadOnly, 0x00000000, 0x00000000)

})

CreateDWordField (CRS, 0x04, BS00)

CreateDWordField (CRS, 0x08, BL00)

CreateDWordField (CRS, 0x10, BS10)

CreateDWordField (CRS, 0x14, BL10)

Method (_CRS, 0, NotSerialized)

{

Store (0xFF800000, Local0)

FindSetRightBit (FHD0, Local1)

Decrement (Local1)

If (Local1)

{

Multiply (Local1, 0x00080000, Local1)

}

Add (Local0, Local1, Local2)

Store (Local2, BS00)

Add (BS00, 0x00400000, BS10)

Subtract (0x00, BS10, BL00)

Store (BL00, BL10)

Return (CRS)

}

}

Device (FWHE)

{

Name (_HID, EisaId ("PNP0C02"))

Name (_UID, 0x03)

Name (CRS, ResourceTemplate ()

{

Memory32Fixed (ReadOnly, 0x00000000, 0x00000000)

})

Method (_CRS, 0, NotSerialized)

{

CreateDWordField (CRS, 0x04, BS00)

CreateDWordField (CRS, 0x08, BL00)

If (LEqual (^^FWH.BS00, 0x00))

{

^^FWH._CRS ()

}

Add (^^FWH.BS00, ^^FWH.BL00, BS00)

Subtract (^^FWH.BS10, BS00, BL00)

Return (CRS)

}

}

OperationRegion (FHR0, PCI_Config, 0xD9, 0x01)

Field (FHR0, ByteAcc, NoLock, Preserve)

{

FHD0, 8

}

Device (^PCIE)

{

Name (_HID, EisaId ("PNP0C02"))

Name (_UID, 0x11)

Name (CRS, ResourceTemplate ()

{

Memory32Fixed (ReadOnly, 0xE0000000, 0x10000000)

})

Method (_CRS, 0, NotSerialized)

{

CreateDWordField (CRS, 0x04, BAS1)

CreateDWordField (CRS, 0x08, LEN1)

Store (PCIB, BAS1)

Store (PCIL, LEN1)

Return (CRS)

}

}

Device (OMSC)

{

Name (_HID, EisaId ("PNP0C02"))

Name (_UID, 0x00)

Name (CRS, ResourceTemplate ()

{

IO (Decode16, 0x0400, 0x0400, 0x00, 0x20)

Memory32Fixed (ReadOnly, 0x00000000, 0x00000000)

Memory32Fixed (ReadOnly, 0x00000000, 0x00000000)

Memory32Fixed (ReadOnly, 0xFEC10000, 0x00008000)

Memory32Fixed (ReadOnly, 0xFEC20000, 0x00008000)

Memory32Fixed (ReadOnly, 0xFEC28000, 0x00008000)

})

Method (_CRS, 0, NotSerialized)

{

If (APIC)

{

CreateDWordField (CRS, 0x10, ML01)

CreateDWordField (CRS, 0x0C, MB01)

CreateDWordField (CRS, 0x1C, ML02)

CreateDWordField (CRS, 0x18, MB02)

Store (0xFEC00000, MB01)

Store (0x1000, ML01)

Store (0xFEE00000, MB02)

Store (0x1000, ML02)

}

Return (CRS)

}

}

Device (^^RMEM)

{

Name (_HID, EisaId ("PNP0C01"))

Name (_UID, 0x01)

Name (CRS, ResourceTemplate ()

{

Memory32Fixed (ReadWrite, 0x00000000, 0x000A0000)

Memory32Fixed (ReadOnly, 0x00000000, 0x00000000)

Memory32Fixed (ReadOnly, 0x000E0000, 0x00020000)

Memory32Fixed (ReadWrite, 0x00100000, 0x00000000)

Memory32Fixed (ReadOnly, 0x00000000, 0x00000000)

})

Method (_CRS, 0, NotSerialized)

{

CreateDWordField (CRS, 0x10, BAS1)

CreateDWordField (CRS, 0x14, LEN1)

CreateDWordField (CRS, 0x1C, BAS2)

CreateDWordField (CRS, 0x20, LEN2)

CreateDWordField (CRS, 0x2C, LEN3)

CreateDWordField (CRS, 0x34, BAS4)

CreateDWordField (CRS, 0x38, LEN4)

If (OSFL ()) {}

Else

{

If (MG1B)

{

If (LGreater (MG1B, 0x000C0000))

{

Store (0x000C0000, BAS1)

Subtract (MG1B, BAS1, LEN1)

}

}

Else

{

Store (0x000C0000, BAS1)

Store (0x00020000, LEN1)

}

If (Add (MG1B, MG1L, Local0))

{

Store (Local0, BAS2)

Subtract (0x00100000, BAS2, LEN2)

}

}

Subtract (MG2B, 0x00100000, LEN3)

Add (MG2B, MG2L, BAS4)

Subtract (0x00, BAS4, LEN4)

Return (CRS)

}

}

}

Device (IDE0)

{

Name (_ADR, 0x001F0001)

Name (REGF, 0x01)

Method (_REG, 2, NotSerialized)

{

If (LEqual (Arg0, 0x02))

{

Store (Arg1, REGF)

}

}

OperationRegion (BAR0, PCI_Config, 0x00, 0x0100)

Field (BAR0, DWordAcc, NoLock, Preserve)

{

VDID, 32,

Offset (0x40),

TIMP, 16,

TIMS, 16,

STMP, 4,

STMS, 4,

Offset (0x48),

UDMP, 2,

UDMS, 2,

Offset (0x4A),

UDTP, 6,

Offset (0x4B),

UDTS, 6,

Offset (0x54),

PCB0, 2,

SCB0, 2,

PCA0, 2,

SCA0, 2,

, 4,

FPB0, 2,

FSB0, 2,

PSIG, 2,

SSIG, 2

}

Name (TIM0, Package (0x09)

{

Package (0x04)

{

0x78,

0xB4,

0xF0,

0x0384

},

Package (0x04)

{

0x23,

0x21,

0x10,

0x00

},

Package (0x04)

{

0x0B,

0x09,

0x04,

0x00

},

Package (0x06)

{

0x70,

0x49,

0x36,

0x27,

0x19,

0x0F

},

Package (0x06)

{

0x00,

0x01,

0x02,

0x01,

0x02,

0x01

},

Package (0x06)

{

0x00,

0x00,

0x00,

0x01,

0x01,

0x01

},

Package (0x06)

{

0x00,

0x00,

0x00,

0x00,

0x00,

0x01

},

Package (0x04)

{

0x04,

0x03,

0x02,

0x00

},

Package (0x04)

{

0x02,

0x01,

0x00,

0x00

}

})

Name (TMD0, Buffer (0x14) {})

CreateDWordField (TMD0, 0x00, PIO0)

CreateDWordField (TMD0, 0x04, DMA0)

CreateDWordField (TMD0, 0x08, PIO1)

CreateDWordField (TMD0, 0x0C, DMA1)

CreateDWordField (TMD0, 0x10, CHNF)

Name (GTIM, 0x00)

Name (GSTM, 0x00)

Name (GUDM, 0x00)

Name (GUDT, 0x00)

Name (GCB0, 0x00)

Name (GFB0, 0x00)

Device (CHN0)

{

Name (_ADR, 0x00)

Method (_GTM, 0, NotSerialized)

{

Return (GTM (TIMP, STMP, UDMP, UDTP, PCB0, FPB0))

}

Method (_STM, 3, NotSerialized)

{

Store (Arg0, Debug)

Store (Arg0, TMD0)

Store (TIMP, GTIM)

Store (UDTP, GUDT)

If (STM ())

{

Store (GTIM, TIMP)

Store (GSTM, STMP)

Store (GUDM, UDMP)

Store (GUDT, UDTP)

Store (GCB0, PCB0)

Store (GFB0, FPB0)

}

Store (GTF (0x00, Arg1), ATA0)

Store (GTF (0x01, Arg2), ATA1)

}

Device (DRV0)

{

Name (_ADR, 0x00)

Method (_GTF, 0, NotSerialized)

{

Return (RATA (ATA0))

}

}

Device (DRV1)

{

Name (_ADR, 0x01)

Method (_GTF, 0, NotSerialized)

{

Return (RATA (ATA1))

}

}

}

Device (CHN1)

{

Name (_ADR, 0x01)

Method (_GTM, 0, NotSerialized)

{

Return (GTM (TIMS, STMS, UDMS, UDTS, SCB0, FSB0))

}

Method (_STM, 3, NotSerialized)

{

Store (Arg0, Debug)

Store (Arg0, TMD0)

Store (TIMS, GTIM)

Store (UDTS, GUDT)

If (STM ())

{

Store (GTIM, TIMS)

Store (GSTM, STMS)

Store (GUDM, UDMS)

Store (GUDT, UDTS)

Store (GCB0, SCB0)

Store (GFB0, FSB0)

}

Store (GTF (0x00, Arg1), ATA2)

Store (GTF (0x01, Arg2), ATA3)

}

Device (DRV0)

{

Name (_ADR, 0x00)

Method (_GTF, 0, NotSerialized)

{

Return (RATA (ATA2))

}

}

Device (DRV1)

{

Name (_ADR, 0x01)

Method (_GTF, 0, NotSerialized)

{

Return (RATA (ATA3))

}

}

}

Method (GTM, 6, Serialized)

{

Store (Ones, PIO0)

Store (PIO0, PIO1)

Store (PIO0, DMA0)

Store (PIO0, DMA1)

Store (Zero, CHNF)

If (REGF) {}

Else

{

Return (TMD0)

}

If (And (Arg0, 0x02))

{

Or (CHNF, 0x02, CHNF)

}

ShiftRight (And (Arg0, 0x3300), 0x08, Local5)

Store (Match (DerefOf (Index (TIM0, 0x01)), MLE, Local5, MTR, 0x00, 0x00), Local6)

Store (DerefOf (Index (DerefOf (Index (TIM0, 0x00)), Local6)), Local7)

Store (Local7, DMA0)

If (And (Arg0, 0x08))

{

Store (0x0384, PIO0)

}

Else

{

Store (Local7, PIO0)

}

If (And (Arg0, 0x20))

{

Or (CHNF, 0x08, CHNF)

}

If (And (Arg0, 0x4000))

{

Or (CHNF, 0x10, CHNF)

Store (Match (DerefOf (Index (TIM0, 0x02)), MLE, Arg1, MTR, 0x00, 0x00), Local5)

Store (DerefOf (Index (DerefOf (Index (TIM0, 0x00)), Local5)), Local6)

Store (Local6, DMA1)

If (And (Arg0, 0x80))

{

Store (0x0384, PIO1)

}

Else

{

Store (Local6, PIO1)

}

}

If (And (Arg2, 0x01))

{

And (Arg3, 0x03, Local5)

If (LAnd (And (Arg5, 0x01), LEqual (Local5, 0x01)))

{

Add (Local5, 0x04, Local5)

}

Else

{

If (And (Arg4, 0x01))

{

Add (Local5, 0x02, Local5)

}

}

Store (DerefOf (Index (DerefOf (Index (TIM0, 0x03)), Local5)), DMA0)

Or (CHNF, 0x01, CHNF)

}

If (And (Arg2, 0x02))

{

And (ShiftRight (Arg3, 0x04), 0x03, Local5)

If (LAnd (And (Arg5, 0x02), LEqual (Local5, 0x01)))

{

Add (Local5, 0x04, Local5)

}

Else

{

If (And (Arg4, 0x02))

{

Add (Local5, 0x02, Local5)

}

}

Store (DerefOf (Index (DerefOf (Index (TIM0, 0x03)), Local5)), DMA1)

Or (CHNF, 0x04, CHNF)

}

Store (TMD0, Debug)

Return (TMD0)

}

Method (STM, 0, Serialized)

{

If (REGF) {}

Else

{

Return (0x00)

}

And (GTIM, 0x8044, GTIM)

Store (0x00, GSTM)

Store (0x00, GUDM)

Store (0x00, GCB0)

And (GUDT, 0xCC, GUDT)

Store (0x00, GFB0)

If (And (CHNF, 0x01))

{

Store (Match (DerefOf (Index (TIM0, 0x03)), MLE, DMA0, MTR, 0x00, 0x00), Local0)

If (LGreater (Local0, 0x05))

{

Store (0x05, Local0)

}

Or (GUDT, DerefOf (Index (DerefOf (Index (TIM0, 0x04)), Local0)), GUDT)

Or (GCB0, DerefOf (Index (DerefOf (Index (TIM0, 0x05)), Local0)), GCB0)

Or (GFB0, DerefOf (Index (DerefOf (Index (TIM0, 0x06)), Local0)), GFB0)

Or (GUDM, 0x01, GUDM)

}

Else

{

If (Or (LEqual (PIO0, Ones), LEqual (PIO0, 0x00)))

{

If (And (LLess (DMA0, Ones), LGreater (DMA0, 0x00)))

{

Store (DMA0, PIO0)

Or (GTIM, 0x08, GTIM)

}

}

}

If (And (CHNF, 0x04))

{

Store (Match (DerefOf (Index (TIM0, 0x03)), MLE, DMA1, MTR, 0x00, 0x00), Local0)

If (LGreater (Local0, 0x05))

{

Store (0x05, Local0)

}

Or (GUDT, ShiftLeft (DerefOf (Index (DerefOf (Index (TIM0, 0x04)), Local0)), 0x04), GUDT)

Or (GCB0, ShiftLeft (DerefOf (Index (DerefOf (Index (TIM0, 0x05)), Local0)), 0x01), GCB0)

Or (GFB0, ShiftLeft (DerefOf (Index (DerefOf (Index (TIM0, 0x06)), Local0)), 0x01), GFB0)

Or (GUDM, 0x02, GUDM)

}

Else

{

If (Or (LEqual (PIO1, Ones), LEqual (PIO1, 0x00)))

{

If (And (LLess (DMA1, Ones), LGreater (DMA1, 0x00)))

{

Store (DMA1, PIO1)

Or (GTIM, 0x80, GTIM)

}

}

}

If (And (CHNF, 0x02))

{

Or (GTIM, 0x03, GTIM)

}

If (And (CHNF, 0x08))

{

Or (GTIM, 0x30, GTIM)

}

And (Match (DerefOf (Index (TIM0, 0x00)), MGE, PIO0, MTR, 0x00, 0x00), 0x03, Local0)

Store (DerefOf (Index (DerefOf (Index (TIM0, 0x01)), Local0)), Local1)

ShiftLeft (Local1, 0x08, Local2)

Or (GTIM, Local2, GTIM)

If (And (CHNF, 0x10))

{

Or (GTIM, 0x4000, GTIM)

And (Match (DerefOf (Index (TIM0, 0x00)), MGE, PIO1, MTR, 0x00, 0x00), 0x03, Local0)

Store (DerefOf (Index (DerefOf (Index (TIM0, 0x02)), Local0)), GSTM)

}

Return (0x01)

}

Name (AT01, Buffer (0x07)

{

0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0xEF

})

Name (AT02, Buffer (0x07)

{

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x90

})

Name (AT03, Buffer (0x07)

{

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC6

})

Name (AT04, Buffer (0x07)

{

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x91

})

Name (ATA0, Buffer (0x1D) {})

Name (ATA1, Buffer (0x1D) {})

Name (ATA2, Buffer (0x1D) {})

Name (ATA3, Buffer (0x1D) {})

Name (ATAB, Buffer (0x1D) {})

CreateByteField (ATAB, 0x00, CMDC)

Method (GTFB, 3, Serialized)

{

Multiply (CMDC, 0x38, Local0)

Add (Local0, 0x08, Local1)

CreateField (ATAB, Local1, 0x38, CMDX)

Multiply (CMDC, 0x07, Local0)

CreateByteField (ATAB, Add (Local0, 0x02), A001)

CreateByteField (ATAB, Add (Local0, 0x06), A005)

Store (Arg0, CMDX)

Store (Arg1, A001)

Store (Arg2, A005)

Increment (CMDC)

}

Method (GTF, 2, Serialized)

{

Store (Arg1, Debug)

Store (0x00, CMDC)

Name (ID49, 0x0C00)

Name (ID59, 0x00)

Name (ID53, 0x04)

Name (ID63, 0x0F00)

Name (ID88, 0x0F00)

Name (IRDY, 0x01)

Name (PIOT, 0x00)

Name (DMAT, 0x00)

If (LEqual (SizeOf (Arg1), 0x0200))

{

CreateWordField (Arg1, 0x62, IW49)

Store (IW49, ID49)

CreateWordField (Arg1, 0x6A, IW53)

Store (IW53, ID53)

CreateWordField (Arg1, 0x7E, IW63)

Store (IW63, ID63)

CreateWordField (Arg1, 0x76, IW59)

Store (IW59, ID59)

CreateWordField (Arg1, 0xB0, IW88)

Store (IW88, ID88)

}

Store (0xA0, Local7)

If (Arg0)

{

Store (0xB0, Local7)

And (CHNF, 0x08, IRDY)

If (And (CHNF, 0x10))

{

Store (PIO1, PIOT)

}

Else

{

Store (PIO0, PIOT)

}

If (And (CHNF, 0x04))

{

If (And (CHNF, 0x10))

{

Store (DMA1, DMAT)

}

Else

{

Store (DMA0, DMAT)

}

}

}

Else

{

And (CHNF, 0x02, IRDY)

Store (PIO0, PIOT)

If (And (CHNF, 0x01))

{

Store (DMA0, DMAT)

}

}

If (LAnd (LAnd (And (ID53, 0x04), And (ID88, 0xFF00)), DMAT))

{

Store (Match (DerefOf (Index (TIM0, 0x03)), MLE, DMAT, MTR, 0x00, 0x00), Local1)

If (LGreater (Local1, 0x05))

{

Store (0x05, Local1)

}

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

}

Else

{

If (LAnd (And (ID63, 0xFF00), PIOT))

{

And (Match (DerefOf (Index (TIM0, 0x00)), MGE, PIOT, MTR, 0x00, 0x00), 0x03, Local0)

Or (0x20, DerefOf (Index (DerefOf (Index (TIM0, 0x08)), Local0)), Local1)

GTFB (AT01, Local1, Local7)

}

}

If (IRDY)

{

And (Match (DerefOf (Index (TIM0, 0x00)), MGE, PIOT, MTR, 0x00, 0x00), 0x03, Local0)

Or (0x08, DerefOf (Index (DerefOf (Index (TIM0, 0x07)), Local0)), Local1)

GTFB (AT01, Local1, Local7)

}

Else

{

If (And (ID49, 0x0400))

{

GTFB (AT01, 0x01, Local7)

}

}

If (LAnd (And (ID59, 0x0100), And (ID59, 0xFF)))

{

GTFB (AT03, And (ID59, 0xFF), Local7)

}

Store (ATAB, Debug)

Return (ATAB)

}

Method (RATA, 1, NotSerialized)

{

CreateByteField (Arg0, 0x00, CMDN)

Multiply (CMDN, 0x38, Local0)

CreateField (Arg0, 0x08, Local0, RETB)

Store (RETB, Debug)

Return (RETB)

}

}

Device (IDE1)

{

Name (_ADR, 0x001F0002)

}

Device (USB0)

{

Name (_ADR, 0x001D0000)

OperationRegion (BAR0, PCI_Config, 0xC0, 0x05)

Field (BAR0, ByteAcc, NoLock, Preserve)

{

UBL1, 16,

Offset (0x04),

P0WE, 1,

P1WE, 1,

Offset (0x05)

}

Method (_S3D, 0, NotSerialized)

{

If (LOr (LEqual (OSFL (), 0x01), LEqual (OSFL (), 0x02)))

{

Return (0x02)

}

Else

{

Return (0x03)

}

}

Method (_PSW, 1, NotSerialized)

{

If (Arg0)

{

Store (0x01, P0WE)

Store (0x01, P1WE)

}

Else

{

Store (0x00, P0WE)

Store (0x00, P1WE)

}

}

Method (UPAC, 1, NotSerialized)

{

Store (Zero, Local0)

If (LEqual (OSFG, OS9X))

{

Store (One, Local0)

}

Else

{

If (LEqual (OSFG, OS98))

{

Store (One, Local0)

}

}

If (Local0)

{

If (LEqual (Arg0, 0x03))

{

Return (One)

}

}

Return (Zero)

}

OperationRegion (UPCI, PCI_Config, 0x20, 0x04)

Field (UPCI, ByteAcc, NoLock, Preserve)

{

UBAS, 32

}

Name (BASA, 0xB400)

Name (P0ST, Zero)

Name (P1ST, Zero)

Method (SSTA, 0, NotSerialized)

{

Store (UBAS, BASA)

And (BASA, 0xFFFFFFFE, BASA)

OperationRegion (UHCI, SystemIO, BASA, 0x20)

Field (UHCI, ByteAcc, NoLock, Preserve)

{

RSTP, 1,

HRST, 1,

GRST, 1,

Offset (0x10),

CCS0, 1,

CSC0, 1,

PED0, 1,

Offset (0x12),

CCS1, 1,

CSC1, 1,

PED1, 1

}

Store (CCS0, P0ST)

Store (CCS1, P1ST)

}

Method (RSTA, 0, NotSerialized)

{

Store (BASA, UBAS)

OperationRegion (UHCI, SystemIO, BASA, 0x20)

Field (UHCI, ByteAcc, NoLock, Preserve)

{

RSTP, 1,

HRST, 1,

GRST, 1,

Offset (0x10),

CCS0, 1,

CSC0, 1,

PED0, 1,

Offset (0x12),

CCS1, 1,

CSC1, 1,

PED1, 1

}

}

Method (USBS, 1, NotSerialized)

{

If (UPAC (Arg0))

{

SSTA ()

}

}

Method (USBW, 1, NotSerialized)

{

If (UPAC (Arg0))

{

RSTA ()

}

}

Method (_PRW, 0, NotSerialized)

{

Return (GPRW (0x03, 0x03))

}

}

Device (USB2)

{

Name (_ADR, 0x001D0002)

OperationRegion (BAR0, PCI_Config, 0xC0, 0x05)

Field (BAR0, ByteAcc, NoLock, Preserve)

{

UBL1, 16,

Offset (0x04),

P0WE, 1,

P1WE, 1,

Offset (0x05)

}

Method (_S3D, 0, NotSerialized)

{

If (LOr (LEqual (OSFL (), 0x01), LEqual (OSFL (), 0x02)))

{

Return (0x02)

}

Else

{

Return (0x03)

}

}

Method (_PSW, 1, NotSerialized)

{

If (Arg0)

{

Store (0x01, P0WE)

Store (0x01, P1WE)

}

Else

{

Store (0x00, P0WE)

Store (0x00, P1WE)

}

}

Method (UPAC, 1, NotSerialized)

{

Store (Zero, Local0)

If (LEqual (OSFG, OS9X))

{

Store (One, Local0)

}

Else

{

If (LEqual (OSFG, OS98))

{

Store (One, Local0)

}

}

If (Local0)

{

If (LEqual (Arg0, 0x03))

{

Return (One)

}

}

Return (Zero)

}

OperationRegion (UPCI, PCI_Config, 0x20, 0x04)

Field (UPCI, ByteAcc, NoLock, Preserve)

{

UBAS, 32

}

Name (BASA, 0xB400)

Name (P0ST, Zero)

Name (P1ST, Zero)

Method (SSTA, 0, NotSerialized)

{

Store (UBAS, BASA)

And (BASA, 0xFFFFFFFE, BASA)

OperationRegion (UHCI, SystemIO, BASA, 0x20)

Field (UHCI, ByteAcc, NoLock, Preserve)

{

RSTP, 1,

HRST, 1,

GRST, 1,

Offset (0x10),

CCS0, 1,

CSC0, 1,

PED0, 1,

Offset (0x12),

CCS1, 1,

CSC1, 1,

PED1, 1

}

Store (CCS0, P0ST)

Store (CCS1, P1ST)

}

Method (RSTA, 0, NotSerialized)

{

Store (BASA, UBAS)

OperationRegion (UHCI, SystemIO, BASA, 0x20)

Field (UHCI, ByteAcc, NoLock, Preserve)

{

RSTP, 1,

HRST, 1,

GRST, 1,

Offset (0x10),

CCS0, 1,

CSC0, 1,

PED0, 1,

Offset (0x12),

CCS1, 1,

CSC1, 1,

PED1, 1

}

}

Method (USBS, 1, NotSerialized)

{

If (UPAC (Arg0))

{

SSTA ()

}

}

Method (USBW, 1, NotSerialized)

{

If (UPAC (Arg0))

{

RSTA ()

}

}

Method (_PRW, 0, NotSerialized)

{

Return (GPRW (0x0C, 0x03))

}

}

Device (USB3)

{

Name (_ADR, 0x001D0003)

OperationRegion (BAR0, PCI_Config, 0xC0, 0x05)

Field (BAR0, ByteAcc, NoLock, Preserve)

{

UBL1, 16,

Offset (0x04),

P0WE, 1,

P1WE, 1,

Offset (0x05)

}

Method (_S3D, 0, NotSerialized)

{

If (LOr (LEqual (OSFL (), 0x01), LEqual (OSFL (), 0x02)))

{

Return (0x02)

}

Else

{

Return (0x03)

}

}

Method (_PSW, 1, NotSerialized)

{

If (Arg0)

{

Store (0x01, P0WE)

Store (0x01, P1WE)

}

Else

{

Store (0x00, P0WE)

Store (0x00, P1WE)

}

}

Method (UPAC, 1, NotSerialized)

{

Store (Zero, Local0)

If (LEqual (OSFG, OS9X))

{

Store (One, Local0)

}

Else

{

If (LEqual (OSFG, OS98))

{

Store (One, Local0)

}

}

If (Local0)

{

If (LEqual (Arg0, 0x03))

{

Return (One)

}

}

Return (Zero)

}

OperationRegion (UPCI, PCI_Config, 0x20, 0x04)

Field (UPCI, ByteAcc, NoLock, Preserve)

{

UBAS, 32

}

Name (BASA, 0xB400)

Name (P0ST, Zero)

Name (P1ST, Zero)

Method (SSTA, 0, NotSerialized)

{

Store (UBAS, BASA)

And (BASA, 0xFFFFFFFE, BASA)

OperationRegion (UHCI, SystemIO, BASA, 0x20)

Field (UHCI, ByteAcc, NoLock, Preserve)

{

RSTP, 1,

HRST, 1,

GRST, 1,

Offset (0x10),

CCS0, 1,

CSC0, 1,

PED0, 1,

Offset (0x12),

CCS1, 1,

CSC1, 1,

PED1, 1

}

Store (CCS0, P0ST)

Store (CCS1, P1ST)

}

Method (RSTA, 0, NotSerialized)

{

Store (BASA, UBAS)

OperationRegion (UHCI, SystemIO, BASA, 0x20)

Field (UHCI, ByteAcc, NoLock, Preserve)

{

RSTP, 1,

HRST, 1,

GRST, 1,

Offset (0x10),

CCS0, 1,

CSC0, 1,

PED0, 1,

Offset (0x12),

CCS1, 1,

CSC1, 1,

PED1, 1

}

}

Method (USBS, 1, NotSerialized)

{

If (UPAC (Arg0))

{

SSTA ()

}

}

Method (USBW, 1, NotSerialized)

{

If (UPAC (Arg0))

{

RSTA ()

}

}

Method (_PRW, 0, NotSerialized)

{

Return (GPRW (0x0E, 0x03))

}

}

Device (EUSB)

{

Name (_ADR, 0x001D0007)

Method (_PRW, 0, NotSerialized)

{

Return (GPRW (0x0D, 0x03))

}

}

Device (MC97)

{

Name (_ADR, 0x001E0003)

Method (_PRW, 0, NotSerialized)

{

Return (GPRW (0x05, 0x04))

}

}

Device (HDAC)

{

Name (_ADR, 0x001B0000)

Method (_PRW, 0, NotSerialized)

{

Return (GPRW (0x05, 0x04))

}

}

Device (P0P4)

{

Name (_ADR, 0x001C0000)

Method (_PRW, 0, NotSerialized)

{

Return (GPRW (0x09, 0x04))

}

Method (_PRT, 0, NotSerialized)

{

If (PICM)

{

Return (AR04)

}

Return (PR04)

}

Device (WLAN)

{

Name (_ADR, 0x00)

OperationRegion (MINP, PCI_Config, 0x00, 0x68)

Field (MINP, ByteAcc, NoLock, Preserve)

{

VNUM, 32,

Offset (0x09),

PINF, 8,

SBCC, 8,

BSCC, 8,

Offset (0x2C),

SNUM, 32,

Offset (0x34)

}

Method (MPDP, 0, NotSerialized)

{

If (LEqual (SNUM, 0xFFFFFFFF))

{

Return (0x00)

}

If (LNot (LEqual (BSCC, 0x02)))

{

Return (0x00)

}

Return (One)

}

}

}

Device (P0P5)

{

Name (_ADR, 0x001C0001)

Method (_PRW, 0, NotSerialized)

{

Return (GPRW (0x09, 0x04))

}

Method (_PRT, 0, NotSerialized)

{

If (PICM)

{

Return (AR05)

}

Return (PR05)

}

}

Device (P0P6)

{

Name (_ADR, 0x001C0002)

Method (_PRW, 0, NotSerialized)

{

Return (GPRW (0x09, 0x04))

}

Method (_PRT, 0, NotSerialized)

{

If (PICM)

{

Return (AR06)

}

Return (PR06)

}

}

Device (P0P8)

{

Name (_ADR, 0x001C0004)

Method (_PRW, 0, NotSerialized)

{

Return (GPRW (0x09, 0x04))

}

Method (_PRT, 0, NotSerialized)

{

If (PICM)

{

Return (AR08)

}

Return (PR08)

}

}

Device (P0P9)

{

Name (_ADR, 0x001C0005)

Method (_PRW, 0, NotSerialized)

{

Return (GPRW (0x09, 0x04))

}

Method (_PRT, 0, NotSerialized)

{

If (PICM)

{

Return (AR09)

}

Return (PR09)

}

}

Device (VGA)

{

Name (_ADR, 0x00020000)

OperationRegion (VSID, PCI_Config, 0x00, 0x04)

Field (VSID, ByteAcc, NoLock, Preserve)

{

REG0, 32

}

Method (PRST, 0, NotSerialized)

{

If (LEqual (REG0, 0xFFFFFFFF))

{

Return (Zero)

}

Else

{

Return (One)

}

}

Name (LCDM, 0x0808)

Name (CRTM, 0x0101)

Name (TVOM, 0x0202)

Name (DONE, Zero)

Name (DOSF, One)

Name (UPDN, One)

Name (NXTD, 0x01)

Method (MD2A, 1, NotSerialized)

{

Store (Zero, Local0)

If (And (Arg0, LCDM))

{

Or (Local0, 0x01, Local0)

}

If (And (Arg0, CRTM))

{

Or (Local0, 0x02, Local0)

}

If (And (Arg0, TVOM))

{

Or (Local0, 0x04, Local0)

}

If (LNot (Local0))

{

Return (NXTD)

}

Return (Local0)

}

Method (MA2D, 1, NotSerialized)

{

Store (Zero, Local0)

If (And (Arg0, 0x01))

{

Or (Local0, LCDM, Local0)

}

If (And (Arg0, 0x02))

{

Or (Local0, CRTM, Local0)

}

If (And (Arg0, 0x04))

{

Or (Local0, TVOM, Local0)

}

If (LNot (Local0))

{

Return (LCDM)

}

Return (Local0)

}

Method (_INI, 0, NotSerialized)

{

GCAD ()

Store (CADL, PADL)

GCDD ()

GNDD ()

}

Method (_DOS, 1, NotSerialized)

{

Store (Arg0, DOSF)

}

Method (_DOD, 0, NotSerialized)

{

Return (Package (0x03)

{

0x00010100,

0x00010400,

0x0200

})

}

Device (CRTD)

{

Name (_ADR, 0x0100)

Method (_DCS, 0, NotSerialized)

{

If (And (CSTE, CRTM))

{

Return (0x1F)

}

Return (0x1D)

}

Method (_DGS, 0, NotSerialized)

{

If (And (NSTE, CRTM))

{

Return (0x01)

}

Return (0x00)

}

Method (_DSS, 1, NotSerialized)

{

If (And (Arg0, 0x40000000))

{

If (And (Arg0, 0x80000000))

{

Store (NSTE, CSTE)

Store (One, DONE)

}

}

}

}

Device (TVOD)

{

Name (_ADR, 0x0200)

Method (_DCS, 0, NotSerialized)

{

If (And (CSTE, TVOM))

{

Return (0x1F)

}

Return (0x1D)

}

Method (_DGS, 0, NotSerialized)

{

If (And (NSTE, TVOM))

{

Return (0x01)

}

Return (0x00)

}

Method (_DSS, 1, NotSerialized)

{

If (And (Arg0, 0x40000000))

{

If (And (Arg0, 0x80000000))

{

Store (NSTE, CSTE)

Store (One, DONE)

}

}

}

}

Device (LCDD)

{

Name (_ADR, 0x0400)

Method (_DCS, 0, NotSerialized)

{

If (And (CSTE, LCDM))

{

Return (0x1F)

}

Return (0x1D)

}

Method (_DGS, 0, NotSerialized)

{

If (And (NSTE, LCDM))

{

Return (0x01)

}

Return (0x00)

}

Method (_DSS, 1, NotSerialized)

{

If (And (Arg0, 0x40000000))

{

If (And (Arg0, 0x80000000))

{

Store (NSTE, CSTE)

Store (One, DONE)

}

}

}

Method (_BCL, 0, NotSerialized)

{

Return (Package (0x10)

{

0x50,

0x32,

0x19,

0x1E,

0x23,

0x28,

0x2D,

0x37,

0x3C,

0x41,

0x46,

0x4B,

0x55,

0x5A,

0x5F,

0x64

})

}

Method (_BCM, 1, NotSerialized)

{

Store (Arg0, Local0)

Subtract (Local0, 0x19, Local0)

Divide (Local0, 0x05, Local1, Local0)

If (LGreater (Local0, 0x0F))

{

Store (0x0F, Local0)

}

If (LLess (Local0, 0x00))

{

Store (0x00, Local0)

}

Store (Local0, LBTN)

^^^SBRG.EC0.STBR ()

}

Method (_BQC, 0, NotSerialized)

{

Store (LBTN, Local0)

Multiply (Local0, 0x05, Local0)

Add (Local0, 0x19, Local0)

Return (Local0)

}

}

Method (SWHD, 1, Serialized)

{

Store (One, UPDN)

If (And (DOSF, 0x03))

{

If (\NATK ())

{

Store (0x00, SFUN)

}

Else

{

Store (0x04, SFUN)

}

Store (Arg0, SSTE)

If (\NATK ())

{

Store (MA2D (Arg0), NSTE)

Store (NSTE, SSTE)

}

ISMI (0x94)

Notify (VGA, 0x81)

}

Else

{

If (LNot (LEqual (CADL, PADL)))

{

Store (CADL, PADL)

If (LEqual (OSFG, OSXP))

{

Notify (PCI0, 0x00)

}

Else

{

Notify (VGA, 0x00)

}

Sleep (0x03E8)

}

Store (Zero, DONE)

Notify (VGA, 0x80)

Store (0x01F4, Local0)

While (Local0)

{

If (DONE)

{

Store (Zero, Local0)

}

Else

{

Sleep (0x0A)

Decrement (Local0)

}

}

}

}

Method (GCDD, 0, NotSerialized)

{

Store (0x01, SFUN)

ISMI (0x95)

Return (CSTE)

}

Method (GNDD, 0, NotSerialized)

{

Store (0x05, SFUN)

ISMI (0x95)

Return (NSTE)

}

Method (GCAD, 0, NotSerialized)

{

Store (0x02, SFUN)

ISMI (0x95)

Return (CADL)

}

Method (ADVD, 0, NotSerialized)

{

GCDD ()

GCAD ()

If (\NATK ())

{

If (UPDN)

{

Store (MD2A (CSTE), NXTD)

Store (Zero, UPDN)

}

Store (Zero, Local0)

Store (MD2A (CADL), Local1)

While (LNot (LEqual (NXTD, Local0)))

{

Increment (NXTD)

If (LGreater (NXTD, 0x06))

{

Store (One, NXTD)

}

And (NXTD, Local1, Local0)

}

Store (MA2D (NXTD), NSTE)

Store (NXTD, DBG8)

Return (NXTD)

}

Return (GNDD ())

}

Method (NATK, 0, NotSerialized)

{

Return (One)

}

}

Device (P0P7)

{

Name (_ADR, 0x001C0003)

Name (_HPP, Package (0x04)

{

0x08,

0x40,

0x01,

0x00

})

Device (XCRD)

{

Name (_ADR, 0x00)

Method (_STA, 0, NotSerialized)

{

If (And (FDRT, 0x00080000))

{

Return (0x00)

}

Store (RBPE (0x000E305A), Local0)

If (And (Local0, 0x40))

{

Return (0x0F)

}

Else

{

Return (0x00)

}

}

Method (_EJ0, 1, NotSerialized)

{

^^^SBRG.EC0.SPIN (0x67, 0x00)

}

Name (_EJD, "\\_SB.PCI0.USB3.RHUB.PRT0")

}

Method (_PRW, 0, NotSerialized)

{

Return (GPRW (0x09, 0x04))

}

Method (_PRT, 0, NotSerialized)

{

If (PICM)

{

Return (AR07)

}

Return (PR07)

}

}

Device (USB1)

{

Name (_ADR, 0x001D0001)

OperationRegion (BAR0, PCI_Config, 0xC0, 0x05)

Field (BAR0, ByteAcc, NoLock, Preserve)

{

UBL1, 16,

Offset (0x04),

P0WE, 1,

P1WE, 1,

Offset (0x05)

}

Method (_S3D, 0, NotSerialized)

{

If (LOr (LEqual (OSFL (), 0x01), LEqual (OSFL (), 0x02)))

{

Return (0x02)

}

Else

{

Return (0x03)

}

}

Method (_PSW, 1, NotSerialized)

{

If (Arg0)

{

Store (0x01, P0WE)

Store (0x01, P1WE)

}

Else

{

Store (0x00, P0WE)

Store (0x00, P1WE)

}

}

Method (UPAC, 1, NotSerialized)

{

Store (Zero, Local0)

If (LEqual (OSFG, OS9X))

{

Store (One, Local0)

}

Else

{

If (LEqual (OSFG, OS98))

{

Store (One, Local0)

}

}

If (Local0)

{

If (LEqual (Arg0, 0x03))

{

Return (One)

}

}

Return (Zero)

}

OperationRegion (UPCI, PCI_Config, 0x20, 0x04)

Field (UPCI, ByteAcc, NoLock, Preserve)

{

UBAS, 32

}

Name (BASA, 0xB400)

Name (P0ST, Zero)

Name (P1ST, Zero)

Method (SSTA, 0, NotSerialized)

{

Store (UBAS, BASA)

And (BASA, 0xFFFFFFFE, BASA)

OperationRegion (UHCI, SystemIO, BASA, 0x20)

Field (UHCI, ByteAcc, NoLock, Preserve)

{

RSTP, 1,

HRST, 1,

GRST, 1,

Offset (0x10),

CCS0, 1,

CSC0, 1,

PED0, 1,

Offset (0x12),

CCS1, 1,

CSC1, 1,

PED1, 1

}

Store (CCS0, P0ST)

Store (CCS1, P1ST)

}

Method (RSTA, 0, NotSerialized)

{

Store (BASA, UBAS)

OperationRegion (UHCI, SystemIO, BASA, 0x20)

Field (UHCI, ByteAcc, NoLock, Preserve)

{

RSTP, 1,

HRST, 1,

GRST, 1,

Offset (0x10),

CCS0, 1,

CSC0, 1,

PED0, 1,

Offset (0x12),

CCS1, 1,

CSC1, 1,

PED1, 1

}

}

Method (USBS, 1, NotSerialized)

{

If (UPAC (Arg0))

{

SSTA ()

}

}

Method (USBW, 1, NotSerialized)

{

If (UPAC (Arg0))

{

RSTA ()

}

}

}

}

}

Scope (_SB.PCI0.SBRG)

{

Device (EC0)

{

Name (_HID, EisaId ("PNP0C09"))

Name (_CRS, ResourceTemplate ()

{

IO (Decode16, 0x0062, 0x0062, 0x00, 0x01)

IO (Decode16, 0x0066, 0x0066, 0x00, 0x01)

})

Name (_GPE, 0x1C)

Mutex (MUEC, 0x00)

Name (ECFL, Zero)

Method (ECAV, 0, NotSerialized)

{

If (LNot (LLess (SLPT, 0x04)))

{

Return (Zero)

}

Return (ECFL)

}

OperationRegion (ECOR, EmbeddedControl, 0x00, 0x80)

Field (ECOR, ByteAcc, Lock, Preserve)

{

Offset (0x04),

CMD1, 8,

CDT1, 8,

CDT2, 8,

CDT3, 8,

Offset (0x43),

P50I, 1,

, 1,

, 1,

P43I, 1,

P54I, 1,

P55I, 1,

, 1,

Offset (0x44),

P54D, 8,

P55D, 8,

Offset (0x48),

P54S, 8,

P55S, 8,

P50S, 8,

P43S, 8,

P54T, 8,

P55T, 8,

P50T, 8,

P43T, 8,

P60S, 8,

P61S, 8,

P62S, 8,

P63S, 8,

P64S, 8,

P65S, 8,

P66S, 8,

P67S, 8,

P60T, 8,

P61T, 8,

P62T, 8,

P63T, 8,

P64T, 8,

P65T, 8,

P66T, 8,

P67T, 8,

Offset (0x78),

P60I, 1,

P61I, 1,

P62I, 1,

P63I, 1,

P64I, 1,

P65I, 1,

P66I, 1,

P67I, 1

}

Name (SMBF, 0x00)

OperationRegion (SMBX, EmbeddedControl, 0x18, 0x28)

Field (SMBX, ByteAcc, NoLock, Preserve)

{

PRTC, 8,

SSTS, 5,

, 1,

ALFG, 1,

CDFG, 1,

ADDR, 8,

CMDB, 8,

BDAT, 256,

BCNT, 8,

, 1,

ALAD, 7,

ALD0, 8,

ALD1, 8

}

Field (SMBX, ByteAcc, NoLock, Preserve)

{

Offset (0x04),

DAT0, 8,

DAT1, 8

}

Field (SMBX, ByteAcc, NoLock, Preserve)

{

Offset (0x04),

DT2B, 16

}

OperationRegion (NSBS, EmbeddedControl, 0x40, 0x04)

Field (NSBS, ByteAcc, NoLock, Preserve)

{

A2AD, 8,

A2D0, 8,

A2D1, 8,

A3AD, 8

}

Method (_INI, 0, NotSerialized)

{

If (LNot (LGreater (OSFG, OSME)))

{

Store (One, ECFL)

}

}

Method (_REG, 2, NotSerialized)

{

If (LEqual (Arg0, 0x03))

{

Store (Arg1, ECFL)

}

}

Method (_Q0A, 0, NotSerialized)

{

Notify (SLPB, 0x80)

}

Method (_Q0B, 0, NotSerialized)

{

If (And (^^^^ATKD.WAPF, 0x04))

{

Or (WLDP, BTDP, Local0)

If (Local0)

{

If (ATKP)

{

Notify (ATKD, 0x88)

}

}

}

Else

{

If (And (^^^^ATKD.WAPF, 0x01))

{

If (LAnd (WLDP, BTDP))

{

Store (WRST, Local0)

Or (ShiftLeft (BRST, 0x01), Local0, Local0)

Increment (Local0)

If (LGreater (Local0, 0x03))

{

Store (0x00, Local0)

}

Store (DerefOf (Index (WBTL, Local0)), Local1)

Name (_T_0, Zero)

Store (ToInteger (Local1), _T_0)

If (LEqual (_T_0, 0x00))

{

Notify (ATKD, 0x5D)

Sleep (0x0DAC)

OBTD (0x00)

Notify (ATKD, 0x7E)

}

Else

{

If (LEqual (_T_0, 0x01))

{

Notify (ATKD, 0x5D)

Sleep (0x0DAC)

OBTD (0x00)

Notify (ATKD, 0x7E)

}

Else

{

If (LEqual (_T_0, 0x02))

{

Notify (ATKD, 0x5D)

Sleep (0x0DAC)

OBTD (0x01)

Notify (ATKD, 0x7D)

}

Else

{

If (LEqual (_T_0, 0x03))

{

Notify (ATKD, 0x5D)

Sleep (0x0DAC)

OBTD (0x01)

Notify (ATKD, 0x7D)

}

}

}

}

}

Else

{

If (WLDP)

{

Notify (ATKD, 0x5D)

}

Else

{

If (BTDP)

{

If (BRST)

{

OBTD (0x00)

Notify (ATKD, 0x7E)

}

Else

{

OBTD (0x01)

Notify (ATKD, 0x7D)

}

}

}

}

}

Else

{

If (LAnd (WLDP, BTDP))

{

Store (WRST, Local0)

Or (ShiftLeft (BRST, 0x01), Local0, Local0)

Increment (Local0)

If (LGreater (Local0, 0x03))

{

Store (0x00, Local0)

}

Store (DerefOf (Index (WBTL, Local0)), Local1)

Name (_T_1, Zero)

Store (ToInteger (Local1), _T_1)

If (LEqual (_T_1, 0x00))

{

OWLD (0x00)

Notify (ATKD, 0x5F)

Sleep (0x0DAC)

OBTD (0x00)

Notify (ATKD, 0x7E)

}

Else

{

If (LEqual (_T_1, 0x01))

{

OWLD (0x01)

Notify (ATKD, 0x5E)

Sleep (0x0DAC)

OBTD (0x00)

Notify (ATKD, 0x7E)

}

Else

{

If (LEqual (_T_1, 0x02))

{

OWLD (0x00)

Notify (ATKD, 0x5F)

Sleep (0x0DAC)

OBTD (0x01)

Notify (ATKD, 0x7D)

}

Else

{

If (LEqual (_T_1, 0x03))

{

OWLD (0x01)

Notify (ATKD, 0x5E)

Sleep (0x0DAC)

OBTD (0x01)

Notify (ATKD, 0x7D)

}

}

}

}

}

Else

{

If (WLDP)

{

If (WRST)

{

OWLD (0x00)

Notify (ATKD, 0x5F)

}

Else

{

OWLD (0x01)

Notify (ATKD, 0x5E)

}

}

Else

{

If (BTDP)

{

If (BRST)

{

OBTD (0x00)

Notify (ATKD, 0x7E)

}

Else

{

OBTD (0x01)

Notify (ATKD, 0x7D)

}

}

}

}

}

}

}

Name (WBTL, Package (0x04)

{

0x00,

0x01,

0x02,

0x03

})

Method (_Q32, 0, NotSerialized)

{

If (WLDP)

{

If (ATKP)

{

Notify (ATKD, 0x5D)

}

}

}

Method (_Q0E, 0, NotSerialized)

{

If (LEqual (OSFG, OSVT))

{

If (LEqual (^^^VGA.DOSF, 0x04)) {}

Else

{

If (ATKP)

{

Store (LBTN, Local0)

If (LGreater (Local0, 0x00))

{

Decrement (Local0)

}

If (LGreater (Local0, 0x0F))

{

Store (0x0F, Local0)

}

Notify (ATKD, Add (Local0, 0x20))

}

Notify (^^^VGA.LCDD, 0x87)

}

Return (One)

}

Else

{

If (LGreater (LBTN, 0x00))

{

Decrement (LBTN)

}

If (LGreater (LBTN, 0x0F))

{

Store (0x0F, LBTN)

}

STBR ()

If (ATKP)

{

Notify (ATKD, Add (LBTN, 0x20))

}

Return (One)

}

}

Method (_Q0F, 0, NotSerialized)

{

If (LEqual (OSFG, OSVT))

{

If (LAnd (^^^VGA.DOSF, 0x04)) {}

Else

{

If (ATKP)

{

Store (LBTN, Local0)

If (LLess (Local0, 0x0F))

{

Increment (Local0)

}

Else

{

Store (0x0F, Local0)

}

Notify (ATKD, Add (Local0, 0x10))

}

Notify (^^^VGA.LCDD, 0x86)

}

Return (One)

}

Else

{

If (LLess (LBTN, 0x0F))

{

Increment (LBTN)

}

Else

{

Store (0x0F, LBTN)

}

STBR ()

If (ATKP)

{

Notify (ATKD, Add (LBTN, 0x10))

}

Return (One)

}

}

Method (_Q10, 0, NotSerialized)

{

Store (OTGB (), Local0)

If (ATKP)

{

Subtract (0x34, Local0, Local0)

Notify (ATKD, Local0)

}

}

Method (_Q11, 0, NotSerialized)

{

ISMI (0xA5)

If (LNot (GVBI))

{

FHKW ()

Store (ADVG (), Local0)

If (NATK ())

{

Add (Local0, 0x60, Local1)

If (ATKP)

{

Notify (ATKD, Local1)

}

Else

{

SWHG (Local0)

}

}

Else

{

SWHG (Local0)

}

FHKS ()

}

}

Name (FHKM, One)

Method (FHKW, 0, Serialized)

{

While (LNot (FHKM))

{

Sleep (0x0A)

}

Store (Zero, FHKM)

}

Method (FHKS, 0, Serialized)

{

Store (One, FHKM)

}

Method (_Q13, 0, NotSerialized)

{

If (ATKP)

{

Notify (ATKD, 0x32)

}

}

Method (_Q14, 0, NotSerialized)

{

If (LLess (AVOL, 0x0F))

{

Increment (AVOL)

}

If (ATKP)

{

Notify (ATKD, 0x31)

}

}

Method (_Q15, 0, NotSerialized)

{

If (LGreater (AVOL, 0x00))

{

Decrement (AVOL)

}

If (ATKP)

{

Notify (ATKD, 0x30)

}

}

Method (_Q20, 0, NotSerialized)

{

If (CDFG)

{

Store (One, SMBF)

Store (Zero, CDFG)

}

If (ALFG)

{

ALMH (ALAD)

Store (Zero, ALFG)

}

}

Name (TPED, One)

Method (_Q12, 0, NotSerialized)

{

If (TPED)

{

SPIN (0x41, 0x00)

Store (Zero, TPED)

}

Else

{

SPIN (0x41, 0x01)

Store (One, TPED)

}

If (ATKP)

{

Notify (ATKD, 0x6B)

}

}

Method (_Q0C, 0, NotSerialized)

{

If (ATKP)

{

Notify (ATKD, 0x50)

}

}

Method (_Q0D, 0, NotSerialized)

{

If (ATKP)

{

Notify (ATKD, 0x51)

}

}

Method (_Q31, 0, NotSerialized)

{

Notify (ATKD, 0x95)

STC5 (0x4E)

Or (ISFF, 0x01, ISFF)

STC5 (0x4B)

Sleep (0x01F4)

STC5 (0x2B)

}

Method (_Q30, 0, NotSerialized)

{

If (ATKP)

{

If (BTDP)

{

Store (RGPL (0x21, 0x01), Local0)

If (Local0)

{

SGPL (0x21, 0x01, 0x00)

SGPL (0x24, 0x01, 0x01)

Notify (ATKD, 0x7E)

}

Else

{

SGPL (0x21, 0x01, 0x01)

SGPL (0x24, 0x01, 0x00)

Notify (ATKD, 0x7D)

}

}

}

}

Method (_Q35, 0, NotSerialized)

{

If (ATKP)

{

Notify (ATKD, 0x5C)

}

}

Method (_Q6E, 0, NotSerialized)

{

If (ATKP)

{

Notify (ATKD, 0x5C)

}

}

Name (LEDS, Ones)

Method (EC0S, 1, NotSerialized)

{

If (LEqual (Arg0, 0x03)) {}

If (LGreater (Arg0, 0x01))

{

SPIN (0x24, 0x01)

}

If (Arg0)

{

If (LLess (Arg0, 0x04))

{

Store (RDC3 (0x02), Local0)

And (Local0, 0xE0, LEDS)

And (LEDS, 0x80, Local1)

If (LNot (Local1))

{

SPIN (0x27, 0x01)

}

And (LEDS, 0x40, Local1)

If (LNot (Local1))

{

SPIN (0x26, 0x01)

}

And (LEDS, 0x20, Local1)

If (LNot (Local1))

{

SPIN (0x25, 0x01)

}

}

}

}

Method (EC0W, 1, NotSerialized)

{

If (LEqual (Arg0, 0x03))

{

SPIN (0x24, 0x00)

}

If (LNot (LGreater (Arg0, 0x04)))

{

Store (ACPS (), Local0)

XOr (Local0, 0x01, Local0)

Store (Local0, ACPF)

Store (DCPS (0x00), DCPF)

}

If (Arg0)

{

If (LLess (Arg0, 0x04))

{

And (LEDS, 0x80, Local1)

If (LNot (Local1))

{

SPIN (0x27, 0x00)

}

And (LEDS, 0x40, Local1)

If (LNot (Local1))

{

SPIN (0x26, 0x00)

}

And (LEDS, 0x20, Local1)

If (LNot (Local1))

{

SPIN (0x25, 0x00)

}

}

}

}

}

}

OperationRegion (_SB.PCI0.SBRG.PIX0, PCI_Config, 0x60, 0x0C)

Field (\_SB.PCI0.SBRG.PIX0, ByteAcc, NoLock, Preserve)

{

PIRA, 8,

PIRB, 8,

PIRC, 8,

PIRD, 8,

Offset (0x08),

PIRE, 8,

PIRF, 8,

PIRG, 8,

PIRH, 8

}

Scope (_SB)

{

Name (BUFA, ResourceTemplate ()

{

IRQ (Level, ActiveLow, Shared) {15}

})

CreateWordField (BUFA, 0x01, IRA0)

Device (LNKA)

{

Name (_HID, EisaId ("PNP0C0F"))

Name (_UID, 0x01)

Method (_STA, 0, NotSerialized)

{

And (PIRA, 0x80, Local0)

If (Local0)

{

Return (0x09)

}

Else

{

Return (0x0B)

}

}

Method (_PRS, 0, NotSerialized)

{

Return (PRSA)

}

Method (_DIS, 0, NotSerialized)

{

Or (PIRA, 0x80, PIRA)

}

Method (_CRS, 0, NotSerialized)

{

And (PIRA, 0x0F, Local0)

ShiftLeft (0x01, Local0, IRA0)

Return (BUFA)

}

Method (_SRS, 1, NotSerialized)

{

CreateWordField (Arg0, 0x01, IRA)

FindSetRightBit (IRA, Local0)

Decrement (Local0)

Store (Local0, PIRA)

}

}

Device (LNKB)

{

Name (_HID, EisaId ("PNP0C0F"))

Name (_UID, 0x02)

Method (_STA, 0, NotSerialized)

{

And (PIRB, 0x80, Local0)

If (Local0)

{

Return (0x09)

}

Else

{

Return (0x0B)

}

}

Method (_PRS, 0, NotSerialized)

{

Return (PRSB)

}

Method (_DIS, 0, NotSerialized)

{

Or (PIRB, 0x80, PIRB)

}

Method (_CRS, 0, NotSerialized)

{

And (PIRB, 0x0F, Local0)

ShiftLeft (0x01, Local0, IRA0)

Return (BUFA)

}

Method (_SRS, 1, NotSerialized)

{

CreateWordField (Arg0, 0x01, IRA)

FindSetRightBit (IRA, Local0)

Decrement (Local0)

Store (Local0, PIRB)

}

}

Device (LNKC)

{

Name (_HID, EisaId ("PNP0C0F"))

Name (_UID, 0x03)

Method (_STA, 0, NotSerialized)

{

And (PIRC, 0x80, Local0)

If (Local0)

{

Return (0x09)

}

Else

{

Return (0x0B)

}

}

Method (_PRS, 0, NotSerialized)

{

Return (PRSC)

}

Method (_DIS, 0, NotSerialized)

{

Or (PIRC, 0x80, PIRC)

}

Method (_CRS, 0, NotSerialized)

{

And (PIRC, 0x0F, Local0)

ShiftLeft (0x01, Local0, IRA0)

Return (BUFA)

}

Method (_SRS, 1, NotSerialized)

{

CreateWordField (Arg0, 0x01, IRA)

FindSetRightBit (IRA, Local0)

Decrement (Local0)

Store (Local0, PIRC)

}

}

Device (LNKD)

{

Name (_HID, EisaId ("PNP0C0F"))

Name (_UID, 0x04)

Method (_STA, 0, NotSerialized)

{

And (PIRD, 0x80, Local0)

If (Local0)

{

Return (0x09)

}

Else

{

Return (0x0B)

}

}

Method (_PRS, 0, NotSerialized)

{

Return (PRSD)

}

Method (_DIS, 0, NotSerialized)

{

Or (PIRD, 0x80, PIRD)

}

Method (_CRS, 0, NotSerialized)

{

And (PIRD, 0x0F, Local0)

ShiftLeft (0x01, Local0, IRA0)

Return (BUFA)

}

Method (_SRS, 1, NotSerialized)

{

CreateWordField (Arg0, 0x01, IRA)

FindSetRightBit (IRA, Local0)

Decrement (Local0)

Store (Local0, PIRD)

}

}

Device (LNKE)

{

Name (_HID, EisaId ("PNP0C0F"))

Name (_UID, 0x05)

Method (_STA, 0, NotSerialized)

{

And (PIRE, 0x80, Local0)

If (Local0)

{

Return (0x09)

}

Else

{

Return (0x0B)

}

}

Method (_PRS, 0, NotSerialized)

{

Return (PRSE)

}

Method (_DIS, 0, NotSerialized)

{

Or (PIRE, 0x80, PIRE)

}

Method (_CRS, 0, NotSerialized)

{

And (PIRE, 0x0F, Local0)

ShiftLeft (0x01, Local0, IRA0)

Return (BUFA)

}

Method (_SRS, 1, NotSerialized)

{

CreateWordField (Arg0, 0x01, IRA)

FindSetRightBit (IRA, Local0)

Decrement (Local0)

Store (Local0, PIRE)

}

}

Device (LNKF)

{

Name (_HID, EisaId ("PNP0C0F"))

Name (_UID, 0x06)

Method (_STA, 0, NotSerialized)

{

And (PIRF, 0x80, Local0)

If (Local0)

{

Return (0x09)

}

Else

{

Return (0x0B)

}

}

Method (_PRS, 0, NotSerialized)

{

Return (PRSF)

}

Method (_DIS, 0, NotSerialized)

{

Or (PIRF, 0x80, PIRF)

}

Method (_CRS, 0, NotSerialized)

{

And (PIRF, 0x0F, Local0)

ShiftLeft (0x01, Local0, IRA0)

Return (BUFA)

}

Method (_SRS, 1, NotSerialized)

{

CreateWordField (Arg0, 0x01, IRA)

FindSetRightBit (IRA, Local0)

Decrement (Local0)

Store (Local0, PIRF)

}

}

Device (LNKG)

{

Name (_HID, EisaId ("PNP0C0F"))

Name (_UID, 0x07)

Method (_STA, 0, NotSerialized)

{

And (PIRG, 0x80, Local0)

If (Local0)

{

Return (0x09)

}

Else

{

Return (0x0B)

}

}

Method (_PRS, 0, NotSerialized)

{

Return (PRSG)

}

Method (_DIS, 0, NotSerialized)

{

Or (PIRG, 0x80, PIRG)

}

Method (_CRS, 0, NotSerialized)

{

And (PIRG, 0x0F, Local0)

ShiftLeft (0x01, Local0, IRA0)

Return (BUFA)

}

Method (_SRS, 1, NotSerialized)

{

CreateWordField (Arg0, 0x01, IRA)

FindSetRightBit (IRA, Local0)

Decrement (Local0)

Store (Local0, PIRG)

}

}

Device (LNKH)

{

Name (_HID, EisaId ("PNP0C0F"))

Name (_UID, 0x08)

Method (_STA, 0, NotSerialized)

{

And (PIRH, 0x80, Local0)

If (Local0)

{

Return (0x09)

}

Else

{

Return (0x0B)

}

}

Method (_PRS, 0, NotSerialized)

{

Return (PRSH)

}

Method (_DIS, 0, NotSerialized)

{

Or (PIRH, 0x80, PIRH)

}

Method (_CRS, 0, NotSerialized)

{

And (PIRH, 0x0F, Local0)

ShiftLeft (0x01, Local0, IRA0)

Return (BUFA)

}

Method (_SRS, 1, NotSerialized)

{

CreateWordField (Arg0, 0x01, IRA)

FindSetRightBit (IRA, Local0)

Decrement (Local0)

Store (Local0, PIRH)

}

}

}

Scope (_SB)

{

Name (XCPD, 0x00)

Name (XNPT, 0x01)

Name (XCAP, 0x02)

Name (XDCP, 0x04)

Name (XDCT, 0x08)

Name (XDST, 0x0A)

Name (XLCP, 0x0C)

Name (XLCT, 0x10)

Name (XLST, 0x12)

Name (XSCP, 0x14)

Name (XSCT, 0x18)

Name (XSST, 0x1A)

Name (XRCT, 0x1C)

Mutex (MUTE, 0x00)

Method (RBPE, 1, Serialized)

{

Acquire (MUTE, 0x03E8)

Add (Arg0, PCIB, Local0)

OperationRegion (PCFG, SystemMemory, Local0, 0x01)

Field (PCFG, ByteAcc, NoLock, Preserve)

{

XCFG, 8

}

Release (MUTE)

Return (XCFG)

}

Method (RWPE, 1, Serialized)

{

Acquire (MUTE, 0x03E8)

And (Arg0, 0xFFFFFFFE, Arg0)

Add (Arg0, PCIB, Local0)

OperationRegion (PCFG, SystemMemory, Local0, 0x02)

Field (PCFG, WordAcc, NoLock, Preserve)

{

XCFG, 16

}

Release (MUTE)

Return (XCFG)

}

Method (RDPE, 1, Serialized)

{

Acquire (MUTE, 0x03E8)

And (Arg0, 0xFFFFFFFC, Arg0)

Add (Arg0, PCIB, Local0)

OperationRegion (PCFG, SystemMemory, Local0, 0x04)

Field (PCFG, DWordAcc, NoLock, Preserve)

{

XCFG, 32

}

Release (MUTE)

Return (XCFG)

}

Method (WBPE, 2, Serialized)

{

Acquire (MUTE, 0x0FFF)

Add (Arg0, PCIB, Local0)

OperationRegion (PCFG, SystemMemory, Local0, 0x01)

Field (PCFG, ByteAcc, NoLock, Preserve)

{

XCFG, 8

}

Store (Arg1, XCFG)

Release (MUTE)

}

Method (WWPE, 2, NotSerialized)

{

Acquire (MUTE, 0x03E8)

And (Arg0, 0xFFFFFFFE, Arg0)

Add (Arg0, PCIB, Local0)

OperationRegion (PCFG, SystemMemory, Local0, 0x02)

Field (PCFG, WordAcc, NoLock, Preserve)

{

XCFG, 16

}

Store (Arg1, XCFG)

Release (MUTE)

}

Method (WDPE, 2, NotSerialized)

{

Acquire (MUTE, 0x03E8)

And (Arg0, 0xFFFFFFFC, Arg0)

Add (Arg0, PCIB, Local0)

OperationRegion (PCFG, SystemMemory, Local0, 0x04)

Field (PCFG, DWordAcc, NoLock, Preserve)

{

XCFG, 32

}

Store (Arg1, XCFG)

Release (MUTE)

}

Method (RWDP, 3, NotSerialized)

{

Acquire (MUTE, 0x03E8)

And (Arg0, 0xFFFFFFFC, Arg0)

Add (Arg0, PCIB, Local0)

OperationRegion (PCFG, SystemMemory, Local0, 0x04)

Field (PCFG, DWordAcc, NoLock, Preserve)

{

XCFG, 32

}

And (XCFG, Arg2, Local1)

Or (Local1, Arg1, XCFG)

Release (MUTE)

}

Method (RPME, 1, NotSerialized)

{

Add (Arg0, 0x84, Local0)

Store (RDPE (Local0), Local1)

If (LEqual (Local1, 0xFFFFFFFF))

{

Return (0x00)

}

Else

{

If (LAnd (Local1, 0x00010000))

{

WDPE (Local0, And (Local1, 0x00010000))

Return (0x01)

}

Return (0x00)

}

}

}

Scope (_SB.PCI0.SBRG.EC0)

{

Method (WCMD, 1, Serialized)

{

If (ECAV ())

{

If (LEqual (Acquire (MUEC, 0xFFFF), 0x00))

{

Store (Arg0, CMD1)

Release (MUEC)

}

}

}

Method (DLY0, 1, Serialized)

{

If (LNot (ECAV ()))

{

Return (Ones)

}

Store (Ones, Local0)

If (LEqual (Acquire (MUEC, 0xFFFF), 0x00))

{

Store (Arg0, CDT1)

Store (0x6B, CDT2)

Store (0x00, CDT3)

Store (0xBB, CMD1)

Store (0x7F, Local1)

While (LAnd (Local1, CMD1))

{

Sleep (0x01)

Decrement (Local1)

}

If (LEqual (CMD1, Zero))

{

Store (CDT1, Local0)

}

Release (MUEC)

}

Return (Local0)

}

Method (RRAM, 2, Serialized)

{

If (ECAV ())

{

If (LEqual (Acquire (MUEC, 0xFFFF), 0x00))

{

Store (Arg0, CDT3)

Store (Arg1, CDT2)

Store (0xBA, CMD1)

Store (0x7F, Local0)

While (LAnd (Local0, CMD1))

{

Sleep (0x01)

Decrement (Local0)

}

If (LEqual (CMD1, Zero))

{

Store (CDT1, Local0)

}

Else

{

Store (Ones, Local0)

}

Release (MUEC)

Return (Local0)

}

}

Return (Ones)

}

Method (WRAM, 3, Serialized)

{

If (ECAV ())

{

If (LEqual (Acquire (MUEC, 0xFFFF), 0x00))

{

Store (Arg0, CDT3)

Store (Arg1, CDT2)

Store (Arg2, CDT1)

Store (0xBB, CMD1)

Store (0x7F, Local0)

While (LAnd (Local0, CMD1))

{

Sleep (0x01)

Decrement (Local0)

}

If (LEqual (CMD1, Zero))

{

Store (One, Local0)

}

Else

{

Store (Ones, Local0)

}

Release (MUEC)

Return (Local0)

}

}

Return (Ones)

}

Method (STBR, 0, Serialized)

{

SBDA ()

}

Method (SBDA, 0, Serialized)

{

If (ACPF)

{

Store (DerefOf (Index (PWAC, LBTN)), Local0)

}

Else

{

Store (DerefOf (Index (PWDC, LBTN)), Local0)

}

Add (0x02, 0x83, Local1)

SADC (Local0, Local1)

}

Method (SADC, 2, Serialized)

{

If (ECAV ())

{

If (LEqual (Acquire (MUEC, 0xFFFF), 0x00))

{

Store (Arg0, CDT1)

Store (Arg1, CDT2)

Store (0xC4, CMD1)

Store (0x7F, Local0)

While (LAnd (Local0, CMD1))

{

Sleep (0x01)

Decrement (Local0)

}

If (LEqual (CMD1, Zero))

{

Store (CDT1, Local0)

}

Else

{

Store (Ones, Local0)

}

Release (MUEC)

Return (Local0)

}

}

Return (Ones)

}

Method (SBQH, 3, Serialized)

{

If (ECAV ())

{

If (LEqual (Acquire (MUEC, 0xFFFF), 0x00))

{

Store (Arg0, CDT1)

Store (Arg1, CDT2)

Store (Arg2, CMD1)

Store (0x7F, Local0)

While (LAnd (Local0, CMD1))

{

Sleep (0x01)

Decrement (Local0)

}

If (LEqual (CMD1, Zero))

{

Store (CDT1, Local0)

}

Else

{

Store (Ones, Local0)

}

Release (MUEC)

Return (Local0)

}

}

Return (Ones)

}

Method (STC5, 1, Serialized)

{

If (ECAV ())

{

If (LEqual (Acquire (MUEC, 0xFFFF), 0x00))

{

Store (Arg0, CDT1)

Store (0xC5, CMD1)

Store (0x7F, Local0)

While (LAnd (Local0, CMD1))

{

Sleep (0x01)

Decrement (Local0)

}

If (LEqual (CMD1, Zero))

{

Store (CDT1, Local0)

}

Else

{

Store (Ones, Local0)

}

Release (MUEC)

Return (Local0)

}

}

Return (Ones)

}

Method (SPIN, 2, Serialized)

{

ShiftRight (Arg0, 0x04, Local0)

And (Arg0, 0x0F, Local1)

If (LNot (LEqual (Local0, 0x05)))

{

If (LEqual (Local0, 0x02))

{

Add (Local1, 0x08, Local1)

}

Else

{

If (LEqual (Local0, 0x04))

{

Add (Local1, 0x10, Local1)

}

Else

{

If (LEqual (Local0, 0x06))

{

Add (Local1, 0x18, Local1)

}

Else

{

Return (Ones)

}

}

}

}

If (Arg1)

{

Or (Local1, 0x20, Local1)

}

Else

{

Or (Local1, 0x40, Local1)

}

STC5 (Local1)

Return (One)

}

Method (RPIN, 1, Serialized)

{

ShiftRight (Arg0, 0x04, Local0)

And (Local0, 0x0F, Local0)

And (Arg0, 0x0F, Local1)

Store (RDC3 (Local0), Local2)

ShiftRight (Local2, Local1, Local2)

And (Local2, 0x01, Local2)

Return (Local2)

}

Method (RDC3, 1, Serialized)

{

If (ECAV ())

{

If (LEqual (Acquire (MUEC, 0xFFFF), 0x00))

{

Store (Arg0, CDT1)

Store (0xC3, CMD1)

Store (0x7F, Local0)

While (LAnd (Local0, CMD1))

{

Sleep (0x01)

Decrement (Local0)

}

If (LEqual (CMD1, Zero))

{

Store (CDT1, Local0)

}

Else

{

Store (Ones, Local0)

}

Release (MUEC)

Return (Local0)

}

}

Return (Ones)

}

Method (RBAT, 2, Serialized)

{

If (LNot (ECAV ()))

{

Return (Ones)

}

If (LEqual (Acquire (MUEC, 0xFFFF), 0x00))

{

Store (0x03, Local0)

While (Local0)

{

Store (Arg0, CDT2)

Store (Arg1, Local1)

ShiftLeft (Local1, 0x01, Local1)

Add (Local1, 0xDA, Local1)

Store (Local1, CMD1)

Store (0x7F, Local1)

While (LAnd (CMD1, Local1))

{

Decrement (Local1)

Sleep (0x01)

}

If (LEqual (CMD1, 0x00))

{

Store (CDT1, Local1)

Store (Zero, Local0)

}

Else

{

Store (Ones, Local1)

Decrement (Local0)

}

}

Release (MUEC)

Return (Local1)

}

Return (Ones)

}

Method (WBAT, 3, Serialized)

{

Or (Arg0, 0x80, Local3)

If (LNot (ECAV ()))

{

Return (Ones)

}

If (LEqual (Acquire (MUEC, 0xFFFF), 0x00))

{

Store (0x03, Local0)

While (Local0)

{

Store (Arg2, CDT1)

Store (Local3, CDT2)

Store (Arg1, Local1)

ShiftLeft (Local1, 0x01, Local1)

Add (Local1, 0xDA, Local1)

Store (Local1, CMD1)

Store (0x7F, Local1)

While (LAnd (CMD1, Local1))

{

Decrement (Local1)

Sleep (0x01)

}

}

Release (MUEC)

Return (Local1)

}

Return (Ones)

}

Method (FNCT, 2, Serialized)

{

If (ECAV ())

{

If (LEqual (Acquire (MUEC, 0xFFFF), 0x00))

{

Store (Arg0, CDT2)

Store (Arg1, CDT1)

Store (0xC4, CMD1)

Store (0x7F, Local0)

While (LAnd (Local0, CMD1))

{

Sleep (0x01)

Decrement (Local0)

}

Release (MUEC)

}

}

}

Name (WRQK, 0x02)

Name (RDQK, 0x03)

Name (SDBT, 0x04)

Name (RCBT, 0x05)

Name (WRBT, 0x06)

Name (RDBT, 0x07)

Name (WRWD, 0x08)

Name (RDWD, 0x09)

Name (WRBL, 0x0A)

Name (RDBL, 0x0B)

Name (PCLL, 0x0C)

Name (GOOD, 0x00)

Name (UKER, 0x07)

Name (DAER, 0x10)

Name (CMDN, 0x12)

Name (UKE2, 0x13)

Name (DADN, 0x17)

Name (SBTO, 0x18)

Name (USPT, 0x19)

Name (SBBY, 0x1A)

Method (SWTC, 2, Serialized)

{

Store (0x05, Local2)

While (Local2)

{

Store (Arg1, PRTC)

And (Arg0, 0xFFFF, Local1)

While (Local1)

{

If (LEqual (PRTC, 0x00))

{

Store (SSTS, Local0)

Store (Zero, Local1)

If (Local0)

{

Decrement (Local2)

}

Else

{

Store (Zero, Local2)

}

}

Else

{

Sleep (0x01)

If (LNot (LEqual (Local1, 0xFFFF)))

{

Decrement (Local1)

If (LEqual (Local1, 0x00))

{

Store (Zero, PRTC)

Store (Zero, Local2)

Store (UKER, Local0)

}

}

}

}

}

Return (Local0)

}

Method (SMBR, 3, Serialized)

{

Store (Package (0x03)

{

0x07,

0x00,

0x00

}, Local0)

If (LNot (ECAV ()))

{

Return (Local0)

}

If (LNot (LEqual (Arg0, RDBL)))

{

If (LNot (LEqual (Arg0, RDWD)))

{

If (LNot (LEqual (Arg0, RDBT)))

{

If (LNot (LEqual (Arg0, RCBT)))

{

If (LNot (LEqual (Arg0, RDQK)))

{

Return (Local0)

}

}

}

}

}

If (LEqual (Acquire (MUEC, 0xFFFF), 0x00))

{

Store (PRTC, Local1)

Store (Zero, Local2)

While (LNot (LEqual (Local1, 0x00)))

{

Stall (0x0A)

Increment (Local2)

If (LGreater (Local2, 0x03E8))

{

Store (SBBY, Index (Local0, 0x00))

Store (Zero, Local1)

}

Else

{

Store (PRTC, Local1)

}

}

If (LNot (LGreater (Local2, 0x03E8)))

{

ShiftLeft (Arg1, 0x01, Local3)

Or (Local3, 0x01, Local3)

Store (Local3, ADDR)

If (LNot (LEqual (Arg0, RDQK)))

{

If (LNot (LEqual (Arg0, RCBT)))

{

Store (Arg2, CMDB)

}

}

Store (SWTC (0x07D0, Arg0), Index (Local0, 0x00))

If (LEqual (DerefOf (Index (Local0, 0x00)), 0x00))

{

If (LEqual (Arg0, RDBL))

{

Store (BCNT, Index (Local0, 0x01))

Store (BDAT, Index (Local0, 0x02))

}

If (LEqual (Arg0, RDWD))

{

Store (0x02, Index (Local0, 0x01))

Store (DT2B, Index (Local0, 0x02))

}

If (LEqual (Arg0, RDBT))

{

Store (0x01, Index (Local0, 0x01))

Store (DAT0, Index (Local0, 0x02))

}

If (LEqual (Arg0, RCBT))

{

Store (0x01, Index (Local0, 0x01))

Store (DAT0, Index (Local0, 0x02))

}

}

}

Release (MUEC)

}

Return (Local0)

}

Method (SMBW, 5, Serialized)

{

Store (Package (0x01)

{

0x07

}, Local0)

If (LNot (ECAV ()))

{

Return (Local0)

}

If (LNot (LEqual (Arg0, WRBL)))

{

If (LNot (LEqual (Arg0, WRWD)))

{

If (LNot (LEqual (Arg0, WRBT)))

{

If (LNot (LEqual (Arg0, SDBT)))

{

If (LNot (LEqual (Arg0, WRQK)))

{

Return (Local0)

}

}

}

}

}

If (LEqual (Acquire (MUEC, 0xFFFF), 0x00))

{

Store (PRTC, Local1)

Store (Zero, Local2)

While (LNot (LEqual (Local1, 0x00)))

{

Stall (0x0A)

Increment (Local2)

If (LGreater (Local2, 0x03E8))

{

Store (SBBY, Index (Local0, 0x00))

Store (Zero, Local1)

}

Else

{

Store (PRTC, Local1)

}

}

If (LNot (LGreater (Local2, 0x03E8)))

{

ShiftLeft (Arg1, 0x01, Local3)

Store (Local3, ADDR)

If (LNot (LEqual (Arg0, WRQK)))

{

If (LNot (LEqual (Arg0, SDBT)))

{

Store (Arg2, CMDB)

}

}

If (LEqual (Arg0, WRBL))

{

Store (Arg3, BCNT)

Store (Arg4, BDAT)

}

If (LEqual (Arg0, WRWD))

{

Store (Arg4, DT2B)

}

If (LEqual (Arg0, WRBT))

{

Store (Arg4, DAT0)

}

If (LEqual (Arg0, SDBT))

{

Store (Arg4, DAT0)

}

Store (SWTC (0x07D0, Arg0), Index (Local0, 0x00))

}

Release (MUEC)

}

Return (Local0)

}

}

Scope (\)

{

OperationRegion (PMIO, SystemIO, PMBS, 0x50)

Field (PMIO, ByteAcc, NoLock, Preserve)

{

Offset (0x10),

, 1,

TDTY, 3,

TENA, 1,

TTDT, 3,

FRCT, 1,

, 8,

THLS, 1,

Offset (0x13),

Offset (0x28),

, 1,

PEHS, 1,

, 7,

PEPS, 1,

BLLS, 1,

SBPS, 1,

Offset (0x2A),

G00S, 1,

G01S, 1,

G02S, 1,

G03S, 1,

G04S, 1,

G05S, 1,

G06S, 1,

G07S, 1,

G08S, 1,

G09S, 1,

G0AS, 1,

G0BS, 1,

G0CS, 1,

G0DS, 1,

G0ES, 1,

G0FS, 1,

, 1,

PEHE, 1,

TPOL, 1,

, 6,

PEPE, 1,

BLLE, 1,

SBPE, 1,

Offset (0x2E),

G00E, 1,

G01E, 1,

G02E, 1,

G03E, 1,

G04E, 1,

G05E, 1,

G06E, 1,

G07E, 1,

G08E, 1,

G09E, 1,

G0AE, 1,

G0BE, 1,

G0CE, 1,

G0DE, 1,

G0EE, 1,

G0FE, 1,

, 4,

SLPE, 1,

APME, 1,

, 5,

MCSE, 1,

, 1,

TCOE, 1,

PERE, 1,

Offset (0x32),

Offset (0x34),

, 4,

SLPS, 1,

APMS, 1,

, 5,

MCSS, 1,

, 1,

TCOS, 1,

PERS, 1,

Offset (0x36),

Offset (0x42),

, 1,

GPEC, 1

}

OperationRegion (GPIS, SystemIO, PMBS, 0x50)

Field (GPIS, ByteAcc, NoLock, Preserve)

{

Offset (0x2A),

GL00, 16

}

OperationRegion (GPIO, SystemIO, GPBS, 0x40)

Field (GPIO, ByteAcc, NoLock, Preserve)

{

Offset (0x0C),

GL10, 32,

Offset (0x18),

GB00, 32,

Offset (0x2C),

GP00, 32,

Offset (0x38),

GL20, 32

}

OperationRegion (RCBA, SystemMemory, 0xFED1C000, 0x4000)

Field (RCBA, ByteAcc, NoLock, Preserve)

{

Offset (0x3418),

FDRT, 32

}

Method (RGPL, 2, Serialized)

{

Store (Arg1, Local0)

Store (Zero, Local1)

While (Local0)

{

ShiftLeft (Local1, 0x01, Local1)

Or (Local1, 0x01, Local1)

Decrement (Local0)

}

If (LLess (Arg0, 0x20))

{

Store (GL10, Local0)

Store (Arg0, Local2)

}

Else

{

Store (GL20, Local0)

Subtract (Arg0, 0x20, Local2)

}

ShiftLeft (Local1, Local2, Local1)

And (Local0, Local1, Local0)

ShiftRight (Local0, Local2, Local0)

Return (Local0)

}

Method (SGPL, 3, Serialized)

{

Store (Arg1, Local0)

Store (Zero, Local1)

While (Local0)

{

ShiftLeft (Local1, 0x01, Local1)

Or (Local1, 0x01, Local1)

Decrement (Local0)

}

If (LLess (Arg0, 0x20))

{

Store (GL10, Local0)

Store (Arg0, Local2)

}

Else

{

Store (GL20, Local0)

Subtract (Arg0, 0x20, Local2)

}

ShiftLeft (Local1, Local2, Local1)

Not (Local1, Local3)

And (Local0, Local3, Local0)

ShiftLeft (Arg2, Local2, Local4)

Or (Local0, Local4, Local0)

If (LLess (Arg0, 0x20))

{

Store (Local0, GL10)

}

Else

{

Store (Local0, GL20)

}

}

Method (RGPP, 1, Serialized)

{

ShiftRight (GP00, Arg0, Local0)

And (Local0, 0x01, Local0)

Return (Local0)

}

Method (TGPP, 1, Serialized)

{

ShiftLeft (0x01, Arg0, Local0)

XOr (GP00, Local0, GP00)

}

Method (SGPP, 2, Serialized)

{

ShiftLeft (0x01, Arg0, Local0)

If (Arg1)

{

Or (GP00, Local0, GP00)

}

Else

{

Not (Local0, Local1)

And (GP00, Local1, GP00)

}

}

Name (PMEW, Zero)

Method (SBRS, 1, NotSerialized)

{

CPXS ()

\_SB.PCI0.USB0.USBS (Arg0)

\_SB.PCI0.USB1.USBS (Arg0)

\_SB.PCI0.USB2.USBS (Arg0)

\_SB.PCI0.USB3.USBS (Arg0)

}

Method (SBRW, 1, NotSerialized)

{

Store (SBPS, PMEW)

\_SB.PCI0.USB0.USBW (Arg0)

\_SB.PCI0.USB1.USBW (Arg0)

\_SB.PCI0.USB2.USBW (Arg0)

\_SB.PCI0.USB3.USBW (Arg0)

}

Method (STRP, 1, NotSerialized)

{

If (Arg0)

{

Store (One, SLPS)

Store (One, SLPE)

}

Else

{

Store (Zero, SLPE)

Store (One, SLPS)

}

}

Method (HKTH, 0, Serialized)

{

If (THLS)

{

Return (TTDT)

}

Else

{

Return (0xFFFF)

}

}

Method (CPXS, 0, NotSerialized)

{

Store (0x00, Local0)

Store (0x00010000, Local1)

Store (0x000E0060, Local2)

Store (0x000E00DC, Local3)

While (LLess (Local0, 0x04))

{

If (LNot (And (FDRT, Local1)))

{

While (And (\_SB.RDPE (Local2), 0x00010000))

{

Or (\_SB.RDPE (Local2), 0x00010000, Local4)

\_SB.WDPE (Local2, Local4)

}

While (And (\_SB.RDPE (Local3), 0x80000000))

{

Or (\_SB.RDPE (Local3), 0x80000000, Local4)

\_SB.WDPE (Local3, Local4)

}

}

Add (Local2, 0x1000, Local2)

Add (Local3, 0x1000, Local3)

ShiftLeft (Local1, 0x01, Local1)

Increment (Local0)

}

While (And (PEPS, 0x01))

{

Or (PEPS, 0x01, PEPS)

}

}

}

Scope (_GPE)

{

Method (_L03, 0, Serialized)

{

Notify (\_SB.PCI0.USB0, 0x02)

}

Method (_L04, 0, Serialized)

{

Notify (\_SB.PCI0.USB1, 0x02)

}

Method (_L0C, 0, Serialized)

{

Notify (\_SB.PCI0.USB2, 0x02)

}

Method (_L0E, 0, Serialized)

{

Notify (\_SB.PCI0.USB3, 0x02)

}

Method (_L0D, 0, Serialized)

{

Notify (\_SB.PCI0.EUSB, 0x02)

}

Method (_L05, 0, Serialized)

{

Notify (\_SB.PCI0.HDAC, 0x02)

}

Method (_L0B, 0, Serialized)

{

If (PMEW)

{

Notify (\_SB.PCI0.P0P1, 0x02)

Store (Zero, PMEW)

}

Else

{

}

}

Method (_L01, 0, NotSerialized)

{

Sleep (0x64)

If (LNot (And (FDRT, 0x00080000)))

{

Store (\_SB.RBPE (0x000E305A), Local0)

If (And (Local0, 0x08))

{

\_SB.WBPE (0x000E305A, 0x08)

\_SB.WBPE (0x000E30DF, 0x40)

\_SB.WBPE (0x000E305B, 0x01)

Sleep (0x03E8)

Notify (\_SB.PCI0.P0P7, 0x00)

}

}

}

Method (_L09, 0, Serialized)

{

Notify (\_SB.PCI0.P0P4, 0x02)

Notify (\_SB.PCI0.P0P5, 0x02)

Notify (\_SB.PCI0.P0P6, 0x02)

Notify (\_SB.PCI0.P0P7, 0x02)

Notify (\_SB.PCI0.P0P8, 0x02)

Notify (\_SB.PCI0.P0P9, 0x02)

}

}

Scope (\)

{

OperationRegion (SMB0, SystemIO, SMBS, 0x10)

Field (SMB0, ByteAcc, NoLock, Preserve)

{

HSTS, 8,

SSTS, 8,

HSTC, 8,

HCMD, 8,

HADR, 8,

HDT0, 8,

HDT1, 8,

BLKD, 8,

SLCT, 8,

SHCM, 8,

SLEV, 16,

SLDT, 16,

SCFG, 8,

SADR, 8

}

Name (RBUF, Package (0x20) {})

Method (HBSY, 0, NotSerialized)

{

Store (0x00FFFFFF, Local0)

While (Local0)

{

And (HSTS, 0x01, Local1)

If (LNot (Local1))

{

Return (Zero)

}

Decrement (Local0)

}

Return (One)

}

Method (WTSB, 0, NotSerialized)

{

Store (0x00FFFFFF, Local0)

While (Local0)

{

Decrement (Local0)

And (HSTS, 0x1E, Local1)

If (LEqual (Local1, 0x02))

{

Return (One)

}

If (Local1)

{

Return (Zero)

}

}

Return (Zero)

}

Mutex (P4SM, 0x00)

Method (SBYT, 2, Serialized)

{

If (LNot (LEqual (Acquire (P4SM, 0xFFFF), 0x00)))

{

Return (Ones)

}

Store (0x05, Local0)

While (Local0)

{

If (HBSY ())

{

Decrement (Local0)

}

Else

{

Store (Arg0, HADR)

Store (Arg1, HCMD)

Store (0xFF, HSTS)

Store (0x44, HSTC)

If (WTSB ())

{

Release (P4SM)

Return (One)

}

Else

{

Decrement (Local0)

}

}

}

Release (P4SM)

Return (Ones)

}

Method (WBYT, 3, Serialized)

{

If (LNot (LEqual (Acquire (P4SM, 0xFFFF), 0x00)))

{

Return (Ones)

}

Store (0x05, Local0)

While (Local0)

{

If (HBSY ())

{

Decrement (Local0)

}

Else

{

Store (Arg0, HADR)

Store (Arg1, HCMD)

Store (Arg2, HDT0)

Store (0xFF, HSTS)

Store (0x48, HSTC)

If (WTSB ())

{

Release (P4SM)

Return (One)

}

Else

{

Decrement (Local0)

}

}

}

Release (P4SM)

Return (Ones)

}

Method (WWRD, 3, Serialized)

{

If (LNot (LEqual (Acquire (P4SM, 0xFFFF), 0x00)))

{

Return (Ones)

}

Store (0x05, Local0)

While (Local0)

{

If (HBSY ())

{

Decrement (Local0)

}

Else

{

Store (Arg0, HADR)

Store (Arg1, HCMD)

And (Arg2, 0xFF, Local1)

ShiftRight (Arg2, 0x08, Local2)

And (Local2, 0xFF, Local2)

Store (Local2, HDT0)

Store (Local1, HDT1)

Store (0xFF, HSTS)

Store (0x4C, HSTC)

If (WTSB ())

{

Release (P4SM)

Return (One)

}

Else

{

Decrement (Local0)

}

}

}

Release (P4SM)

Return (Ones)

}

Method (WBLK, 3, Serialized)

{

If (LNot (LEqual (Acquire (P4SM, 0xFFFF), 0x00)))

{

Return (Ones)

}

Store (0x05, Local0)

While (Local0)

{

If (HBSY ())

{

Decrement (Local0)

}

Else

{

Store (Arg0, HADR)

Store (Arg1, HCMD)

Store (HSTC, Local1)

Store (Arg2, Local2)

Store (0x00, Local1)

While (Local2)

{

Store (DerefOf (Index (RBUF, Local1)), BLKD)

Decrement (Local2)

Increment (Local1)

}

Store (Arg2, HDT0)

Store (HSTC, Local1)

Store (0xFF, HSTS)

Store (0x54, HSTC)

If (WTSB ())

{

Release (P4SM)

Return (One)

}

Else

{

Decrement (Local0)

}

}

}

Release (P4SM)

Return (Ones)

}

Method (RSBT, 2, Serialized)

{

If (LNot (LEqual (Acquire (P4SM, 0xFFFF), 0x00)))

{

Return (Ones)

}

Store (0x05, Local0)

While (Local0)

{

If (HBSY ())

{

Decrement (Local0)

}

Else

{

Or (Arg0, 0x01, HADR)

Store (Arg1, HCMD)

Store (0xFF, HSTS)

Store (0x44, HSTC)

If (WTSB ())

{

Release (P4SM)

Return (HDT0)

}

Else

{

Decrement (Local0)

}

}

}

Release (P4SM)

Return (Ones)

}

Method (RBYT, 2, Serialized)

{

If (LNot (LEqual (Acquire (P4SM, 0xFFFF), 0x00)))

{

Return (Ones)

}

Store (0x05, Local0)

While (Local0)

{

If (HBSY ())

{

Decrement (Local0)

}

Else

{

Or (Arg0, 0x01, HADR)

Store (Arg1, HCMD)

Store (0xFF, HSTS)

Store (0x48, HSTC)

If (WTSB ())

{

Release (P4SM)

Return (HDT0)

}

Else

{

Decrement (Local0)

}

}

}

Release (P4SM)

Return (Ones)

}

Method (RWRD, 2, Serialized)

{

If (LNot (LEqual (Acquire (P4SM, 0xFFFF), 0x00)))

{

Return (Ones)

}

Store (0x05, Local0)

While (Local0)

{

If (HBSY ())

{

Decrement (Local0)

}

Else

{

Or (Arg0, 0x01, HADR)

Store (Arg1, HCMD)

Store (0xFF, HSTS)

Store (0x4C, HSTC)

If (WTSB ())

{

Store (HDT0, Local1)

ShiftLeft (Local1, 0x08, Local1)

Store (HDT1, Local2)

Add (Local1, Local2, Local1)

Release (P4SM)

Return (Local1)

}

Else

{

Decrement (Local0)

}

}

}

Release (P4SM)

Return (Ones)

}

Method (RBLK, 3, Serialized)

{

If (LNot (LEqual (Acquire (P4SM, 0xFFFF), 0x00)))

{

Return (Ones)

}

Store (0x05, Local0)

While (Local0)

{

If (HBSY ())

{

Decrement (Local0)

}

Else

{

Or (Arg0, 0x01, HADR)

Store (Arg1, HCMD)

Store (0xFF, HSTS)

Store (0x54, HSTC)

If (WTSB ())

{

Store (HSTC, Local1)

Store (HDT0, Local2)

Store (Local2, Local3)

Store (0x00, RBUF)

Store (0x00, Local1)

While (Local2)

{

Store (BLKD, Index (RBUF, Local1))

Decrement (Local2)

Increment (Local1)

}

Release (P4SM)

Return (Local3)

}

Else

{

Decrement (Local0)

}

}

}

Release (P4SM)

Return (Ones)

}

}

Scope (\)

{

Name (TSP, 0x0A)

Name (TC1, 0x02)

Name (TC2, 0x0A)

}

Scope (_TZ)

{

Name (HLMT, 0x00)

Name (LLMT, 0x00)

Name (F1PW, 0x00)

Name (F2PW, 0x00)

Name (ATMP, 0x3C)

Name (LTMP, 0x00)

Name (FANL, 0x00)

Method (KELV, 1, NotSerialized)

{

And (Arg0, 0xFF, Local0)

If (LNot (LLess (Local0, 0x80)))

{

Subtract (0x0100, Local0, Local0)

Multiply (Local0, 0x0A, Local0)

Subtract (0x0AAC, Local0, Local0)

Return (Local0)

}

Multiply (Local0, 0x0A, Local0)

Add (Local0, 0x0AAC, Local0)

Return (Local0)

}

Method (CELC, 1, NotSerialized)

{

Subtract (Arg0, 0x0AAC, Local0)

Divide (Local0, 0x0A, Local1, Local0)

Return (Local0)

}

Name (PLCY, 0x00)

ThermalZone (THRM)

{

Method (_CRT, 0, NotSerialized)

{

Return (KELV (TCRT))

}

Method (_TMP, 0, NotSerialized)

{

Store (0x05, Local1)

While (Local1)

{

Store (GTMP (), Local0)

If (LGreater (Local0, TCRT))

{

Decrement (Local1)

}

Else

{

Store (0x00, Local1)

}

}

Return (KELV (Local0))

}

Name (_PSL, Package (0x01)

{

\_PR.CPU1

})

Method (_TSP, 0, NotSerialized)

{

Multiply (TSP, 0x0A, Local0)

Return (Local0)

}

Method (_TC1, 0, NotSerialized)

{

Return (TC1)

}

Method (_TC2, 0, NotSerialized)

{

Return (TC2)

}

Method (_PSV, 0, NotSerialized)

{

If (PLCY)

{

Return (KELV (PPSV))

}

Else

{

If (TJ85)

{

Return (KELV (0x5A))

}

Else

{

Return (KELV (TPSV))

}

}

}

Name (_AL0, Package (0x01)

{

FN00

})

Method (_AC0, 0, NotSerialized)

{

If (PLCY)

{

Return (KELV (PAC0))

}

Else

{

Return (KELV (TAC0))

}

}

Method (_SCP, 1, NotSerialized)

{

TCHG ()

Notify (THRM, 0x81)

}

}

Method (TRMS, 1, NotSerialized)

{

If (Arg0)

{

TMSS (Arg0)

}

}

Method (TRMW, 1, NotSerialized)

{

If (Arg0)

{

If (LLess (Arg0, 0x04))

{

TMSW (Arg0)

TCHG ()

}

}

}

Name (FANC, 0x00)

Method (TCHG, 0, Serialized)

{

MINT ()

GTMP ()

If (LNot (LLess (LTMP, 0x80)))

{

Store (0x00, LTMP)

}

If (PLCY)

{

Store (^THRM._PSV (), Local0)

Store (CELC (Local0), Local0)

Store (^THRM._AC0 (), Local1)

Store (CELC (Local1), Local1)

If (LGreater (LTMP, TCRT))

{

Store (0x7F, HLMT)

Store (TCRT, LLMT)

Store (0x10, FANL)

}

Else

{

If (LGreater (LTMP, Local1))

{

Store (TCRT, HLMT)

Store (Local1, LLMT)

Store (0x11, FANL)

}

Else

{

If (LGreater (LTMP, Local0))

{

Store (Local1, HLMT)

Store (Local0, LLMT)

Store (0x12, FANL)

}

Else

{

Store (Local0, HLMT)

Store (0xC9, LLMT)

Store (0x13, FANL)

}

}

}

}

Else

{

Name (LYON, Buffer (0x06)

{

0x00, 0x1E, 0x39, 0x43, 0x4D, 0x57

})

Name (HYON, Buffer (0x06)

{

0x32, 0x3C, 0x46, 0x50, 0x5A, 0x69

})

Name (LM85, Buffer (0x06)

{

0x00, 0x1E, 0x39, 0x43, 0x49, 0x4D

})

Name (HM85, Buffer (0x06)

{

0x32, 0x3C, 0x46, 0x4B, 0x50, 0x5A

})

Name (TEML, Buffer (SizeOf (LYON)) {})

Name (TEMH, Buffer (SizeOf (HYON)) {})

If (TJ85)

{

Store (LM85, TEML)

Store (HM85, TEMH)

}

Else

{

Store (LYON, TEML)

Store (HYON, TEMH)

}

Name (FANS, Buffer (0x06)

{

0x00, 0x90, 0xA5, 0xBC, 0xD5, 0xFF

})

Store (LTMP, Local0)

If (LNot (LLess (Local0, TCRT)))

{

Notify (THRM, 0x80)

}

Name (FIND, 0x00)

Store (0x00, Local5)

Subtract (SizeOf (LYON), 0x01, Local4)

While (LEqual (FIND, 0x00))

{

If (LAnd (LNot (LLess (Local0, DerefOf (Index (TEML, Local5)))), LNot (LGreater (Local0, DerefOf (Index (TEMH, Local5))))))

{

If (LLess (Local5, Local4))

{

Increment (Local5)

If (LAnd (LNot (LLess (Local0, DerefOf (Index (TEML, Local5)))), LNot (LGreater (Local0, DerefOf (Index (TEMH, Local5))))))

{

Store (DerefOf (Index (TEML, Local5)), Local6)

Subtract (Local0, Local6, Local2)

Decrement (Local5)

Store (DerefOf (Index (TEMH, Local5)), Local6)

Subtract (Local6, Local0, Local3)

If (LLess (Local3, Local2))

{

Increment (Local5)

}

}

Else

{

Decrement (Local5)

}

}

Store (DerefOf (Index (TEMH, Local5)), HLMT)

Store (DerefOf (Index (TEML, Local5)), LLMT)

Store (DerefOf (Index (FANS, Local5)), FANL)

Store (Local5, FANC)

Store (0x01, FIND)

}

Else

{

Increment (Local5)

}

}

}

WTML (HLMT, LLMT)

\_SB.PCI0.SBRG.EC0.FNCT (0x84, FANL)

UMIT ()

}

Method (GTMP, 0, Serialized)

{

Store (RTMP (), Local0)

If (And (TDO1, 0x80))

{

Subtract (0xFF, TDO1, Local1)

Subtract (Local0, Local1, Local0)

}

Else

{

Add (Local0, TDO1, Local0)

If (LGreater (Local0, 0x7F))

{

Store (0x7F, Local0)

}

}

Store (Local0, LTMP)

Return (Local0)

}

Method (STML, 2, Serialized)

{

Store (Arg0, Local1)

Store (Arg1, Local2)

If (And (TDO1, 0x80))

{

Subtract (0xFF, TDO1, Local3)

Add (Arg0, Local3, Local1)

If (LGreater (Local1, 0x7F))

{

Store (0x7F, Local1)

}

Add (Arg1, Local3, Local2)

If (LGreater (Local2, 0x7F))

{

Store (0x7F, Local2)

}

}

Else

{

Subtract (Arg0, TDO1, Local1)

Subtract (Arg1, TDO1, Local2)

}

WTML (Local1, Local2)

}

}

Scope (\)

{

Method (TZEV, 0, Serialized)

{

\_TZ.TCHG ()

Notify (\_TZ.THRM, 0x80)

}

}

Scope (\)

{

Name (FAN1, 0x00)

Name (FAN2, 0x00)

Device (FN00)

{

Name (_HID, EisaId ("PNP0C0B"))

Name (_PR0, Package (0x01)

{

GFAN

})

}

PowerResource (GFAN, 0x00, 0x0000)

{

Method (_STA, 0, NotSerialized)

{

Return (FAN1)

}

Method (_ON, 0, NotSerialized)

{

Store (0x01, FAN1)

}

Method (_OFF, 0, NotSerialized)

{

Store (0x00, FAN1)

}

}

Name (_SB.PCI0.SBRG._PR0, Package (0x01)

{

GFAN

})

Method (FANW, 1, NotSerialized)

{

Noop

}

Method (FANS, 1, NotSerialized)

{

If (Arg0)

{

\GFAN._OFF ()

}

}

}

Scope (_TZ)

{

Name (FON1, 0x76)

Name (FON2, 0xA0)

Method (TMSW, 1, NotSerialized)

{

If (Arg0)

{

If (LLess (Arg0, 0x04))

{

WBYT (0x98, 0x0B, 0x7F)

WBYT (0x98, 0x0C, 0xC9)

WBYT (0x98, 0x19, 0x7F)

WBYT (0x98, 0x20, 0x7F)

RBYT (0x98, 0x02)

RBYT (0x98, 0x02)

}

}

}

Method (TMSS, 1, NotSerialized)

{

If (Arg0)

{

WBYT (0x98, 0x0D, 0x7F)

WBYT (0x98, 0x0E, 0xC9)

RBYT (0x98, 0x02)

RBYT (0x98, 0x02)

}

STCF (Arg0)

If (LEqual (Arg0, 0x01))

{

\_SB.PCI0.SBRG.EC0.FNCT (0x85, 0x00)

\_SB.PCI0.SBRG.EC0.FNCT (0x84, 0x00)

}

}

Name (MASK, 0x00)

Method (MINT, 0, Serialized)

{

Store (RBYT (0x98, 0x03), MASK)

WBYT (0x98, 0x09, 0xA0)

}

Method (WTML, 2, Serialized)

{

WBYT (0x98, 0x0D, Arg0)

WBYT (0x98, 0x0E, Arg1)

RBYT (0x98, 0x02)

RBYT (0x98, 0x02)

}

Method (UMIT, 0, Serialized)

{

WBYT (0x98, 0x09, MASK)

}

Method (RLTM, 0, NotSerialized)

{

Store (RBYT (0x98, 0x01), Local0)

If (Not (Local0))

{

If (LNot (LEqual (Local0, 0x80)))

{

Store (Local0, ATMP)

}

}

Return (ATMP)

}

Method (RTMP, 0, NotSerialized)

{

Store (RBYT (0x98, 0x01), Local0)

If (Not (Local0))

{

Store (Local0, LTMP)

}

Return (LTMP)

}

Name (AAAA, Buffer (0x06)

{

0x00, 0x90, 0xA5, 0xBC, 0xD5, 0xFF

})

Name (FAND, Buffer (0x06)

{

0x00, 0x20, 0x25, 0x2A, 0x2E, 0x33

})

Method (RFAN, 0, NotSerialized)

{

Store (DerefOf (Index (FAND, FANC)), Local0)

Return (Local0)

}

Method (RTMV, 0, NotSerialized)

{

Store (RBYT (0x98, 0x01), Local0)

If (Not (Local0))

{

If (LNot (LEqual (Local0, 0x80)))

{

Store (Local0, LTMP)

}

}

Return (LTMP)

}

}

Scope (_SB)

{

Device (LID)

{

Name (_HID, EisaId ("PNP0C0D"))

Method (_LID, 0, NotSerialized)

{

Return (GLID ())

}

}

}

Scope (\)

{

Method (LDEV, 0, Serialized)

{

TLID ()

And (LIDS, 0x01)

XOr (LIDS, 0x01, LIDS)

Notify (\_SB.LID, 0x80)

}

}

Scope (\)

{

Method (DIAG, 1, NotSerialized)

{

Store (Arg0, DBG8)

}

OperationRegion (GPSC, SystemIO, 0xB2, 0x02)

Field (GPSC, ByteAcc, NoLock, Preserve)

{

SMCM, 8,

SMST, 8

}

Method (ISMI, 1, Serialized)

{

Store (Arg0, SMCM)

}

Method (ASMI, 1, Serialized)

{

Store (Arg0, ALPR)

Store (0xA6, SMCM)

Return (ALPR)

}

OperationRegion (ECMS, SystemIO, 0x72, 0x02)

Field (ECMS, ByteAcc, Lock, Preserve)

{

EIND, 8,

EDAT, 8

}

IndexField (EIND, EDAT, ByteAcc, NoLock, Preserve)

{

Offset (0x40),

IKFG, 8,

FRPN, 16,

RAMB, 32,

AVOL, 8,

LBTN, 8,

ERRF, 8,

OCLK, 8,

WIDE, 1,

OVCK, 2,

SLPN, 3,

Offset (0x4C),

CPUR, 6,

CPUF, 2,

LBT2, 8,

PCMS, 8,

CLKS, 8,

CLKL, 8,

CLKD, 128,

ALSL, 8,

ALAE, 1,

ALDE, 1,

ALSP, 1,

Offset (0x63),

WLDP, 1,

BTDP, 1,

WRST, 1,

BRST, 1,

ISFF, 1,

TJ85, 1,

Offset (0x64),

RQST, 4,

RCNT, 4,

ERRS, 16,

RAMS, 1,

Offset (0x68)

}

OperationRegion (RAMW, SystemMemory, RAMB, 0x0100)

Field (RAMW, AnyAcc, NoLock, Preserve)

{

TRTY, 8,

FSFN, 8,

FSTA, 16,

FADR, 32,

FSIZ, 16,

ACTD, 8,

AVLD, 8,

SETD, 8,

ACPF, 8,

DCPF, 8,

DCP2, 8,

DCTP, 8,

CTPY, 8,

PADL, 16,

CADL, 16,

CSTE, 16,

NSTE, 16,

SSTE, 16,

SFUN, 8,

TPSV, 8,

TAC0, 8,

TCRT, 8,

TDO1, 8,

TDO2, 8,

PPSV, 8,

PAC0, 8,

T0HL, 8,

T0LL, 8,

T0F1, 8,

T0F2, 8,

T1HL, 8,

T1LL, 8,

T1F1, 8,

T1F2, 8,

T2HL, 8,

T2LL, 8,

T2F1, 8,

T2F2, 8,

T3HL, 8,

T3LL, 8,

T3F1, 8,

T3F2, 8,

T4HL, 8,

T4LL, 8,

T4F1, 8,

T4F2, 8,

T5HL, 8,

T5LL, 8,

T5F1, 8,

T5F2, 8,

T6HL, 8,

T6LL, 8,

T6F1, 8,

T6F2, 8,

T7HL, 8,

T7LL, 8,

T7F1, 8,

T7F2, 8,

SLPT, 8,

AIBF, 8,

IDES, 8,

VGAF, 16,

C4CP, 8,

LUXS, 8,

LUXL, 8,

LUXH, 8,

LUXF, 8,

MNAM, 64,

DBR1, 32,

DBR2, 32,

DBR3, 32,

DBR4, 32,

LCDV, 32,

LCDR, 8,

DTSF, 8,

DTSA, 8,

BTMP, 8,

ATMP, 8,

GVBI, 8,

INSF, 8,

TPMS, 8,

PTIM, 8,

PTMP, 8,

LIDS, 8,

OSOS, 8,

ALPR, 32

}

OperationRegion (DBGM, SystemMemory, 0x000D0000, 0x04)

Field (DBGM, DWordAcc, NoLock, Preserve)

{

DBGG, 32

}

Name (OSFG, 0x00)

Name (OS9X, 0x01)

Name (OS98, 0x02)

Name (OSME, 0x04)

Name (OS2K, 0x08)

Name (OSXP, 0x10)

Name (OSVT, 0x20)

Method (MSOS, 0, NotSerialized)

{

If (CondRefOf (_OSI, Local0))

{

If (_OSI ("Windows 2001"))

{

Store (OSXP, OSFG)

}

If (_OSI ("Windows 2001 SP1"))

{

Store (OSXP, OSFG)

}

If (_OSI ("Windows 2001 SP2"))

{

Store (OSXP, OSFG)

}

If (_OSI ("Windows 2006"))

{

Store (OSVT, OSFG)

}

}

Else

{

If (MCTH (_OS, "Microsoft Windows"))

{

Store (OS98, OSFG)

}

Else

{

If (MCTH (_OS, "Microsoft WindowsME: Millennium Edition"))

{

Store (OSME, OSFG)

}

Else

{

If (MCTH (_OS, "Microsoft Windows NT"))

{

Store (OS2K, OSFG)

}

Else

{

Store (OSXP, OSFG)

}

}

}

}

Store (OSFG, OSOS)

Return (OSFG)

}

Method (DBGR, 4, NotSerialized)

{

Store (Arg0, DBR1)

Store (Arg1, DBR2)

Store (Arg2, DBR3)

Store (Arg3, DBR4)

ISMI (0x96)

}

Name (ONAM, "ASUSTEK")

Method (ADVG, 0, NotSerialized)

{

If (\_SB.PCI0.VGA.PRST ())

{

Return (\_SB.PCI0.VGA.ADVD ())

}

Return (0x03)

}

Method (SWHG, 1, Serialized)

{

If (\_SB.PCI0.VGA.PRST ())

{

\_SB.PCI0.VGA.SWHD (Arg0)

Return (One)

}

Return (Zero)

}

Method (NATK, 0, NotSerialized)

{

If (\_SB.PCI0.VGA.PRST ())

{

Return (\_SB.PCI0.VGA.NATK ())

}

Return (One)

}

Name (PWAC, Buffer (0x10)

{

0x18, 0x2F, 0x3E, 0x4A, 0x52, 0x56, 0x5C, 0x60,

0x64, 0x68, 0x6C, 0x70, 0x73, 0x76, 0x78, 0x88

})

Name (PWDC, Buffer (0x10)

{

0x18, 0x2F, 0x37, 0x3F, 0x48, 0x4C, 0x50, 0x54,

0x58, 0x5C, 0x60, 0x64, 0x68, 0x6C, 0x70, 0x74

})

}

Scope (_SB.PCI0)

{

Method (_INI, 0, NotSerialized)

{

MSOS ()

}

}

Scope (_SB.PCI0)

{

Device (AC0)

{

Name (_HID, "ACPI0003")

Method (_PSR, 0, NotSerialized)

{

Return (ACPF)

}

Name (_PCL, Package (0x01)

{

PCI0

})

}

}

Scope (\)

{

Name (ACWA, 0x00)

Method (ACEV, 0, NotSerialized)

{

If (ACPS ())

{

Store (Zero, ACPF)

Store (0x57, Local0)

}

Else

{

Store (0x02, ACWA)

Store (One, ACPF)

Store (0x58, Local0)

}

\_SB.PCI0.SBRG.EC0.STBR ()

Notify (\_SB.PCI0.AC0, 0x80)

If (\_SB.ATKP)

{

Notify (\_SB.ATKD, Local0)

}

Sleep (0x64)

TGAC ()

Notify (\_PR.CPU1, 0x80)

Sleep (0x0A)

Notify (\_PR.CPU1, 0x81)

If (LEqual (\_PR.CPU1.NCPU, 0x02))

{

Notify (\_PR.CPU2, 0x80)

Sleep (0x0A)

Notify (\_PR.CPU2, 0x81)

}

Sleep (0x0A)

NBAT (0x80)

}

}

Scope (_SB.PCI0)

{

Device (BAT0)

{

Name (_HID, EisaId ("PNP0C0A"))

Name (_UID, 0x00)

Name (_PCL, Package (0x01)

{

PCI0

})

Method (_STA, 0, NotSerialized)

{

If (BATP (0x00))

{

Return (0x1F)

}

Else

{

Return (0x0F)

}

}

Name (LOW2, 0x012C)

Name (DVOT, 0x0E)

Name (PUNT, One)

Name (LFCC, 0x1770)

Name (NBIF, Package (0x0D)

{

0x00,

0xFFFFFFFF,

0xFFFFFFFF,

0x01,

0xFFFFFFFF,

0xFFFFFFFF,

0xFFFFFFFF,

0xFFFFFFFF,

0xFFFFFFFF,

"",

"",

"",

""

})

Name (PBIF, Package (0x0D)

{

0x01,

0x1770,

0x1770,

0x01,

0x39D0,

0x0258,

0x012C,

0x3C,

0x3C,

"M3N",

" ",

"LIon",

"ASUSTek"

})

Name (PBST, Package (0x04)

{

0x00,

0xFFFFFFFF,

0xFFFFFFFF,

0xFFFFFFFF

})

Method (FBIF, 5, NotSerialized)

{

Store (Arg0, PUNT)

Store (Arg1, Local1)

Store (Arg2, Local2)

If (LEqual (PUNT, 0x00))

{

Multiply (Local1, 0x0A, Local1)

Multiply (Local2, 0x0A, Local2)

}

Store (Arg0, Index (PBIF, 0x00))

Store (Local1, Index (PBIF, 0x01))

Store (Local2, Index (PBIF, 0x02))

Store (Local2, LFCC)

Store (Arg3, Index (PBIF, 0x03))

Store (Arg4, Index (PBIF, 0x04))

Divide (Local1, 0x0A, Local3, Local5)

Store (Local5, Index (PBIF, 0x05))

ShiftRight (Local5, 0x01, Local6)

Store (Local6, Index (PBIF, 0x06))

Store (Local6, LOW2)

Divide (Local1, 0x64, Local3, Local7)

Store (Local7, Index (PBIF, 0x07))

Store (Local7, Index (PBIF, 0x08))

}

Method (CBIF, 0, NotSerialized)

{

If (PUNT)

{

Store (DerefOf (Index (PBIF, 0x04)), Local0)

Add (Local0, 0x01F4, Local0)

Divide (Local0, 0x03E8, Local1, DVOT)

Store (Zero, Index (PBIF, 0x00))

Multiply (DerefOf (Index (PBIF, 0x01)), DVOT, Index (PBIF, 0x01))

Multiply (DerefOf (Index (PBIF, 0x02)), DVOT, Index (PBIF, 0x02))

Multiply (DerefOf (Index (PBIF, 0x05)), DVOT, Index (PBIF, 0x05))

Multiply (DerefOf (Index (PBIF, 0x06)), DVOT, Index (PBIF, 0x06))

Multiply (DerefOf (Index (PBIF, 0x07)), DVOT, Index (PBIF, 0x07))

Multiply (DerefOf (Index (PBIF, 0x08)), DVOT, Index (PBIF, 0x08))

}

}

Method (_BIF, 0, NotSerialized)

{

If (LNot (BATP (0x00)))

{

Return (NBIF)

}

Acquire (MMPX, 0xFFFF)

BATS (0x00)

Store (^^SBRG.EC0.BIF9 (), Index (PBIF, 0x09))

Store (ONAM, Index (PBIF, 0x0C))

Store (^^SBRG.EC0.BIF0 (), Local0)

Store (^^SBRG.EC0.BIF1 (), Local1)

Store (^^SBRG.EC0.BIF2 (), Local2)

Store (^^SBRG.EC0.BIF3 (), Local3)

Store (^^SBRG.EC0.BIF4 (), Local4)

Release (MMPX)

If (LNot (LEqual (Local0, Ones)))

{

If (LNot (LEqual (Local1, Ones)))

{

If (LNot (LEqual (Local2, Ones)))

{

If (LNot (LEqual (Local3, Ones)))

{

If (LNot (LEqual (Local4, Ones)))

{

FBIF (Local0, Local1, Local2, Local3, Local4)

CBIF ()

}

}

}

}

}

If (LEqual (PUNT, 0x00))

{

Multiply (Local2, 0x0A, Local2)

}

Store (Local2, LFCC)

Return (PBIF)

}

Method (FBST, 5, NotSerialized)

{

And (Arg1, 0xFFFF, Local1)

If (ACPF)

{

Store (One, Local0)

If (Local0)

{

Store (CHGS (0x00), Local2)

If (LEqual (Local2, 0xFFFF))

{

If (LGreater (Local1, 0xA0))

{

Store (0x02, Local0)

}

Else

{

Store (Zero, Local0)

}

}

Else

{

If (Local2)

{

Store (0x02, Local0)

}

Else

{

Store (Zero, Local0)

}

}

}

Else

{

Store (0x01, Local0)

}

}

Else

{

Store (0x01, Local0)

}

If (And (Arg0, 0x0300))

{

Or (Local0, 0x04, Local0)

}

If (LNot (LLess (Local1, 0x8000)))

{

And (Subtract (0x00, Local1), 0xFFFF, Local1)

}

Store (Arg2, Local2)

If (LEqual (PUNT, 0x00))

{

Multiply (Local1, DVOT, Local1)

Multiply (Local2, 0x0A, Local2)

}

And (Local0, 0x02, Local3)

Divide (LFCC, 0xC8, Local4, Local5)

If (LEqual (Local3, 0x00))

{

Subtract (LFCC, Local2, Local3)

If (LLess (Local3, Local5))

{

Store (LFCC, Local2)

}

}

Else

{

If (LNot (LLess (Local2, LFCC)))

{

Subtract (LFCC, Local5, Local2)

}

}

If (And (Local0, 0x01))

{

Divide (Local2, MBLF, Local3, Local4)

If (LLess (Local1, Local4))

{

Store (Local4, Local1)

}

}

Store (Local0, Index (PBST, 0x00))

Store (Local1, Index (PBST, 0x01))

Store (Local2, Index (PBST, 0x02))

If (ACPF)

{

Store (RGPL (0x0A, 0x01), Local2)

If (LEqual (Local2, 0x01))

{

Store (Arg4, Index (PBST, 0x02))

And (Local0, 0xFFFFFFFD, Local0)

Store (Local0, Index (PBST, 0x00))

}

}

Store (Arg3, Index (PBST, 0x03))

}

Method (CBST, 0, NotSerialized)

{

If (PUNT)

{

Multiply (DerefOf (Index (PBST, 0x01)), DVOT, Index (PBST, 0x01))

Multiply (DerefOf (Index (PBST, 0x02)), DVOT, Index (PBST, 0x02))

}

}

Method (_BST, 0, NotSerialized)

{

If (LNot (BATP (0x00)))

{

Store (Zero, Index (PBST, 0x00))

Store (Ones, Index (PBST, 0x01))

Store (Ones, Index (PBST, 0x02))

Store (Ones, Index (PBST, 0x03))

Return (PBST)

}

If (MES4)

{

Decrement (MES4)

Return (PBST)

}

Acquire (MMPX, 0xFFFF)

BATS (0x00)

Store (^^SBRG.EC0.BSTS (), Local0)

If (ACWA)

{

Store (0x02, Local0)

Decrement (ACWA)

}

Store (^^SBRG.EC0.BSTS (), Local0)

Store (^^SBRG.EC0.BCRT (), Local1)

Store (^^SBRG.EC0.BRCP (), Local2)

Store (^^SBRG.EC0.BVOT (), Local3)

Store (^^SBRG.EC0.BIF2 (), Local4)

Release (MMPX)

If (LNot (LEqual (Local0, Ones)))

{

If (LNot (LEqual (Local1, Ones)))

{

If (LNot (LEqual (Local2, Ones)))

{

If (LNot (LEqual (Local3, Ones)))

{

FBST (Local0, Local1, Local2, Local3, Local4)

CBST ()

}

}

}

}

Return (PBST)

}

}

Name (B0CR, 0x00)

Name (B1CR, 0x00)

Method (GGCC, 1, Serialized)

{

Acquire (MMPX, 0xFFFF)

BATS (Arg0)

Store (^SBRG.EC0.BCRT (), Local0)

Release (MMPX)

If (LEqual (Local0, Ones))

{

If (Arg0)

{

Store (B1CR, Local0)

}

Else

{

Store (B0CR, Local0)

}

}

And (Local0, 0x8000, Local1)

If (Local1)

{

Store (0x00, Local0)

}

If (Arg0)

{

Store (Local0, B1CR)

}

Else

{

Store (Local0, B0CR)

}

Return (Local0)

}

}

Scope (_SB.PCI0.SBRG.EC0)

{

Name (BADR, 0x0B)

Name (CADR, 0x09)

Name (SADR, 0x0A)

Method (ALMH, 1, NotSerialized)

{

If (LEqual (Arg0, BADR))

{

NBAT (0x80)

}

}

Method (BIFW, 1, NotSerialized)

{

Store (SMBR (RDWD, BADR, Arg0), Local0)

Store (DerefOf (Index (Local0, 0x00)), Local1)

If (Local1)

{

Return (Ones)

}

Else

{

Return (DerefOf (Index (Local0, 0x02)))

}

}

Method (BIF0, 0, NotSerialized)

{

Store (One, Local1)

Store (One, Local2)

While (And (LNot (LEqual (Local1, 0x00)), LNot (LGreater (Local2, 0x03))))

{

Store (SMBR (RDWD, BADR, 0x03), Local0)

Store (DerefOf (Index (Local0, 0x00)), Local1)

Increment (Local2)

}

If (Local1)

{

Return (Ones)

}

Else

{

Store (DerefOf (Index (Local0, 0x02)), Local2)

ShiftRight (Local2, 0x0F, Local2)

And (Local2, 0x01, Local2)

XOr (Local2, 0x01, Local2)

Return (Local2)

}

}

Method (BIF1, 0, NotSerialized)

{

Store (Ones, Local1)

Store (One, Local0)

While (And (LEqual (Local1, Ones), LNot (LGreater (Local0, 0x03))))

{

Store (BIFW (0x18), Local1)

Increment (Local0)

}

Return (Local1)

}

Method (BIF2, 0, NotSerialized)

{

Store (Ones, Local1)

Store (One, Local0)

While (And (LEqual (Local1, Ones), LNot (LGreater (Local0, 0x03))))

{

Store (BIFW (0x10), Local1)

Increment (Local0)

}

Return (Local1)

}

Method (BIF3, 0, NotSerialized)

{

Store (Ones, Local1)

Store (One, Local0)

While (And (LEqual (Local1, Ones), LNot (LGreater (Local0, 0x03))))

{

Store (BIFW (0x03), Local1)

Increment (Local0)

}

If (LNot (LEqual (Local1, Ones)))

{

ShiftRight (Local1, 0x09, Local1)

And (Local1, 0x01, Local1)

XOr (Local1, 0x01, Local1)

}

Return (Local1)

}

Method (BIF4, 0, NotSerialized)

{

Store (Ones, Local1)

Store (One, Local0)

While (And (LEqual (Local1, Ones), LNot (LGreater (Local0, 0x03))))

{

Store (BIFW (0x19), Local1)

Increment (Local0)

}

Return (Local1)

}

Method (BIF9, 0, NotSerialized)

{

Name (BSTR, Buffer (0x20) {})

Store (SMBR (RDBL, BADR, 0x21), Local0)

If (LNot (LEqual (DerefOf (Index (Local0, 0x00)), 0x00)))

{

Store (0x00, Index (BSTR, 0x00))

}

Else

{

Store (DerefOf (Index (Local0, 0x02)), BSTR)

Store (0x00, Index (BSTR, DerefOf (Index (Local0, 0x01))))

}

Return (BSTR)

}

Method (BSTS, 0, NotSerialized)

{

Return (BIFW (0x16))

}

Method (BCRT, 0, NotSerialized)

{

Return (BIFW (0x0A))

}

Method (BRCP, 0, NotSerialized)

{

Return (BIFW (0x0F))

}

Method (BVOT, 0, NotSerialized)

{

Return (BIFW (0x09))

}

}

Scope (\)

{

Mutex (MMPX, 0x00)

Method (BATP, 1, Serialized)

{

If (Arg0)

{

Return (DCP2)

}

Else

{

Return (DCPF)

}

}

Method (BTEV, 0, Serialized)

{

Store (DCPS (0x00), DCPF)

TGDC (0x00)

Notify (\_SB.PCI0.BAT0, 0x81)

Notify (\_SB.PCI0.AC0, 0x80)

}

Method (NBAT, 1, NotSerialized)

{

If (BATP (0x00))

{

Notify (\_SB.PCI0.BAT0, Arg0)

}

}

Method (BTCF, 0, Serialized)

{

Notify (\_SB.PCI0.BAT0, 0x81)

Notify (\_SB.PCI0.AC0, 0x80)

}

Method (BLEV, 0, NotSerialized)

{

If (\_SB.ATKP)

{

Notify (\_SB.ATKD, 0x6E)

}

Else

{

If (BATP (0x00))

{

Notify (\_SB.PCI0.BAT0, 0x80)

}

}

}

}

Scope (_SB)

{

Device (PWRB)

{

Name (_HID, EisaId ("PNP0C0C"))

Name (_UID, 0xAA)

Name (_STA, 0x0B)

}

Device (SLPB)

{

Name (_HID, EisaId ("PNP0C0E"))

Method (_PRW, 0, NotSerialized)

{

Return (Package (0x02)

{

0x0B,

0x04

})

}

}

}

Scope (\)

{

Name (MES4, Zero)

Method (OEMS, 1, NotSerialized)

{

SBRS (Arg0)

\_SB.PCI0.SBRG.EC0.EC0S (Arg0)

If (LEqual (Arg0, 0x04))

{

If (LEqual (OSFG, OS2K))

{

Store (Arg0, SLPN)

}

}

Add (Arg0, 0xD0, DBG8)

Store (Arg0, SLPT)

If (Arg0)

{

STRP (0x01)

}

PRJS (Arg0)

}

Method (OEMW, 1, NotSerialized)

{

Store (Zero, SLPT)

\_SB.PCI0.SBRG.EC0.EC0W (Arg0)

If (LEqual (Arg0, 0x04))

{

If (LNot (LGreater (OSFG, OSME)))

{

Store (0x02, MES4)

}

Else

{

Store (Zero, MES4)

}

}

SBRW (Arg0)

If (LEqual (Arg0, 0x04))

{

Notify (\_SB.SLPB, 0x02)

}

If (LEqual (Arg0, 0x03))

{

Notify (\_SB.PCI0.P0P7, 0x00)

}

PRJW (Arg0)

Add (Arg0, 0xF0, DBG8)

}

}

Scope (_SB.ATKD)

{

Method (FSMI, 1, NotSerialized)

{

Store (Arg0, FSFN)

Or (Arg0, 0xA0, Local0)

Store (Local0, DBG8)

ISMI (0x90)

Return (FSTA)

}

Method (FLSH, 1, NotSerialized)

{

Store (Arg0, FSTA)

FSMI (0x00)

}

Method (FINI, 1, NotSerialized)

{

Store (Arg0, FADR)

Return (FSMI (0x01))

}

Method (FERS, 1, NotSerialized)

{

Store (Arg0, FSTA)

Return (FSMI (0x02))

}

Method (FWRI, 1, NotSerialized)

{

Store (Arg0, FADR)

Store (0x1000, FSIZ)

Return (Subtract (0x1000, FSMI (0x03)))

}

Method (FWRP, 0, NotSerialized)

{

Store (0x00, FSIZ)

Return (Subtract (0x1000, FSMI (0x03)))

}

Method (FEBW, 1, NotSerialized)

{

Store (Arg0, FADR)

Return (FSMI (0x04))

}

Method (FEBR, 1, NotSerialized)

{

Store (Arg0, FADR)

Return (FSMI (0x05))

}

Method (FEDW, 0, NotSerialized)

{

Return (FSMI (0x06))

}

}

Scope (\)

{

Method (PXE3, 0, Serialized)

{

Store (\_SB.PCI0.SBRG.EC0.RPIN (0x63), Local0)

If (Local0)

{

\_SB.PCI0.SBRG.EC0.SPIN (0x67, 0x00)

}

Else

{

\_SB.PCI0.SBRG.EC0.SPIN (0x67, 0x01)

Sleep (0x1E)

}

}

Method (ACPS, 0, Serialized)

{

Store (\_SB.PCI0.SBRG.EC0.RPIN (0x64), Local0)

Return (Local0)

}

Method (CHGS, 1, Serialized)

{

Store (RGPL (0x0A, 0x01), Local0)

XOr (Local0, 0x01, Local0)

Return (Local0)

}

Method (DCPS, 1, Serialized)

{

Store (\_SB.PCI0.SBRG.EC0.RPIN (0x55), Local0)

XOr (Local0, 0x01, Local0)

Return (Local0)

}

Method (BATS, 1, Serialized)

{

}

Name (LCDB, 0x00)

Method (PRJS, 1, Serialized)

{

SGPL (0x1A, 0x01, 0x00)

If (LNot (LGreater (Arg0, 0x03)))

{

Store (RGPL (0x06, 0x01), LCDB)

SGPL (0x06, 0x01, 0x00)

}

}

Method (PRJW, 1, Serialized)

{

Store (0x01, LIDS)

SGPL (0x1A, 0x01, 0x01)

If (LNot (LGreater (Arg0, 0x03)))

{

SGPL (0x06, 0x01, LCDB)

}

}

Method (GLID, 0, Serialized)

{

Return (\_SB.PCI0.SBRG.EC0.RPIN (0x54))

}

Method (TLID, 0, Serialized)

{

}

Method (TGAC, 0, Serialized)

{

}

Method (TGDC, 1, Serialized)

{

}

Method (FCTR, 3, Serialized)

{

}

Method (OWLD, 1, Serialized)

{

And (Arg0, 0x01, Arg0)

Store (Arg0, WRST)

XOr (Arg0, 0x01, Arg0)

SGPL (0x0F, 0x01, Arg0)

}

Method (OBTD, 1, Serialized)

{

And (Arg0, 0x01, Arg0)

Store (Arg0, BRST)

SGPL (0x21, 0x01, Arg0)

}

Method (ORST, 0, Serialized)

{

Store (0x00, Local0)

If (WRST)

{

Or (Local0, 0x01, Local0)

}

If (BRST)

{

Or (Local0, 0x02, Local0)

}

Return (Local0)

}

Method (GBTL, 0, Serialized)

{

Return (\_SB.PCI0.SBRG.EC0.RPIN (0x22))

}

Method (SBTL, 1, Serialized)

{

\_SB.PCI0.SBRG.EC0.SPIN (0x22, Arg0)

}

Method (BL2C, 0, NotSerialized)

{

If (LNot (\_SB.PCI0.SBRG.EC0.RPIN (0x50)))

{

Store (0x01, Local1)

}

Return (Local1)

}

Method (STCF, 1, Serialized)

{

If (LEqual (Arg0, 0x01))

{

\_SB.PCI0.SBRG.EC0.FNCT (0x84, 0x00)

}

}

Method (OTGB, 0, Serialized)

{

Store (RGPL (0x06, 0x01), Local0)

XOr (Local0, 0x01, Local0)

SGPL (0x06, 0x01, Local0)

Return (Local0)

}

Method (OTPM, 0, Serialized)

{

}

}

Scope (_GPE)

{

Method (_L00, 0, NotSerialized)

{

TZEV ()

}

}

Scope (_SB.PCI0.SBRG.EC0)

{

Method (_Q33, 0, NotSerialized)

{

PXE3 ()

}

Method (_Q34, 0, NotSerialized)

{

ACEV ()

}

Method (_Q2F, 0, NotSerialized)

{

BTEV ()

}

Method (_Q50, 0, NotSerialized)

{

BLEV ()

}

Method (_Q2E, 0, NotSerialized)

{

LDEV ()

}

Method (_Q36, 0, NotSerialized)

{

If (ATKP)

{

Notify (ATKD, 0x8A)

}

}

Method (_Q6D, 0, NotSerialized)

{

If (ATKP)

{

Notify (ATKD, 0x8A)

}

}

Method (_Q6F, 0, NotSerialized)

{

If (ATKP)

{

Notify (ATKD, 0x99)

}

}

}

Scope (_TZ)

{

Method (PRJF, 0, Serialized)

{

Store (RFAN (), Local0)

Return (Local0)

}

}

Scope (_SB.PCI0.USB3)

{

Device (RHUB)

{

Name (_ADR, 0x00)

Device (PRT0)

{

Name (_ADR, 0x00)

Name (_EJD, "\\_SB.PCI0.P0P7")

}

Device (PRT1)

{

Name (_ADR, 0x01)

}

}

}

Scope (_SB)

{

Scope (PCI0)

{

Name (CRS, ResourceTemplate ()

{

WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode,

0x0000, // Address Space Granularity

0x0000, // Address Range Minimum

0x00FF, // Address Range Maximum

0x0000, // Address Translation Offset

0x0100,,,)

IO (Decode16, 0x0CF8, 0x0CF8, 0x01, 0x08)

WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,

0x0000, // Address Space Granularity

0x0000, // Address Range Minimum

0x0CF7, // Address Range Maximum

0x0000, // Address Translation Offset

0x0CF8,,,

, TypeStatic)

WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,

0x0000, // Address Space Granularity

0x0D00, // Address Range Minimum

0xFFFF, // Address Range Maximum

0x0000, // Address Translation Offset

0xF300,,,

, TypeStatic)

DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,

0x00000000, // Address Space Granularity

0x000A0000, // Address Range Minimum

0x000BFFFF, // Address Range Maximum

0x00000000, // Address Translation Offset

0x00020000,,,

, AddressRangeMemory, TypeStatic)

DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,

0x00000000, // Address Space Granularity

0x000C0000, // Address Range Minimum

0x000DFFFF, // Address Range Maximum

0x00000000, // Address Translation Offset

0x00020000,,,

, AddressRangeMemory, TypeStatic)

DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,

0x00000000, // Address Space Granularity

0x00000000, // Address Range Minimum

0x00000000, // Address Range Maximum

0x00000000, // Address Translation Offset

0x00000000,,,

, AddressRangeMemory, TypeStatic)

})

CreateDWordField (CRS, 0x5C, MIN5)

CreateDWordField (CRS, 0x60, MAX5)

CreateDWordField (CRS, 0x68, LEN5)

CreateDWordField (CRS, 0x76, MIN6)

CreateDWordField (CRS, 0x7A, MAX6)

CreateDWordField (CRS, 0x82, LEN6)

Method (_CRS, 0, NotSerialized)

{

Store (MG1L, Local0)

If (Local0)

{

Store (MG1B, MIN5)

Store (MG1L, LEN5)

Add (MIN5, Decrement (Local0), MAX5)

}

Store (MG2B, MIN6)

Store (MG2L, LEN6)

Store (MG2L, Local0)

Add (MIN6, Decrement (Local0), MAX6)

Return (CRS)

}

}

}

Name (WOTB, 0x00)

Name (WSSB, 0x00)

Name (WAXB, 0x00)

Method (_PTS, 1, NotSerialized)

{

Store (Arg0, DBG8)

PTS (Arg0)

Store (0x00, Index (WAKP, 0x00))

Store (0x00, Index (WAKP, 0x01))

If (LAnd (LEqual (Arg0, 0x04), LEqual (OSFL (), 0x02)))

{

Sleep (0x0BB8)

}

Store (ASSB, WSSB)

Store (AOTB, WOTB)

Store (AAXB, WAXB)

Store (Arg0, ASSB)

Store (OSFL (), AOTB)

Store (Zero, AAXB)

}

Name (SLID, 0x01)

Method (_WAK, 1, NotSerialized)

{

ShiftLeft (Arg0, 0x04, DBG8)

Store (0x01, SLID)

WAK (Arg0)

If (ASSB)

{

Store (WSSB, ASSB)

Store (WOTB, AOTB)

Store (WAXB, AAXB)

}

If (DerefOf (Index (WAKP, 0x00)))

{

Store (0x00, Index (WAKP, 0x01))

}

Else

{

Store (Arg0, Index (WAKP, 0x01))

}

If (MCTH (_OS, "Microsoft Windows"))

{

If (LEqual (Arg0, 0x04))

{

Notify (\_SB.PWRB, 0x02)

}

}

If (LEqual (Arg0, 0x03)) {}

Return (WAKP)

}

Device (_SB.PCI0.SBRG.TPM)

{

Method (_HID, 0, NotSerialized)

{

If (LEqual (TPMS, 0x01))

{

Return (0x0201D824)

}

Else

{

Return (0x0435CF4D)

}

}

Method (_CID, 0, NotSerialized)

{

Return (0x310CD041)

}

Name (_UID, 0x01)

Name (CRS1, ResourceTemplate ()

{

IO (Decode16, 0x4710, 0x4710, 0x01, 0x02)

IO (Decode16, 0x4700, 0x4700, 0x01, 0x0C)

Memory32Fixed (ReadWrite, 0xFED40000, 0x00005000)

})

Name (CRS2, ResourceTemplate ()

{

Memory32Fixed (ReadWrite, 0xFED40000, 0x00005000)

})

Method (_CRS, 0, NotSerialized)

{

If (LEqual (TPMS, 0x01))

{

Return (CRS1)

}

Else

{

Return (CRS2)

}

}

Method (_STA, 0, NotSerialized)

{

If (TPMS)

{

Return (0x0F)

}

Else

{

Return (0x00)

}

}

}

Scope (_SB.PCI0.SBRG.TPM)

{

Name (TPMR, Package (0x03)

{

Zero,

Zero,

Zero

})

Method (_DSM, 4, NotSerialized)

{

If (LEqual (Arg0, Buffer (0x10)

{

0xA6, 0xFA, 0xDD, 0x3D, 0x1B, 0x36, 0xB4, 0x4E,

0xA4, 0x24, 0x8D, 0x10, 0x08, 0x9D, 0x16, 0x53

}))

{

Name (_T_0, Zero)

Store (ToInteger (Arg2), _T_0)

If (LEqual (_T_0, 0x00))

{

Return (Buffer (0x01)

{

0x7F

})

}

Else

{

If (LEqual (_T_0, 0x01))

{

Return ("1.0")

}

Else

{

If (LEqual (_T_0, 0x02))

{

Store (ToInteger (DerefOf (Index (Arg3, 0x00))), RQST)

Return (Zero)

}

Else

{

If (LEqual (_T_0, 0x03))

{

Return (Package (0x02)

{

0x00,

RQST

})

}

Else

{

If (LEqual (_T_0, 0x04))

{

Return (One)

}

Else

{

If (LEqual (_T_0, 0x05))

{

Store (RCNT, Index (TPMR, 0x01))

Store (ERRS, Index (TPMR, 0x02))

Return (TPMR)

}

Else

{

If (LEqual (_T_0, 0x06))

{

Return (Zero)

}

Else

{

}

}

}

}

}

}

}

}

Else

{

If (LEqual (Arg0, Buffer (0x10)

{

0xED, 0x54, 0x60, 0x37, 0x13, 0xCC, 0x75, 0x46,

0x90, 0x1C, 0x47, 0x56, 0xD7, 0xF2, 0xD4, 0x5D

}))

{

Name (_T_1, Zero)

Store (ToInteger (Arg2), _T_1)

If (LEqual (_T_1, 0x00))

{

Return (Buffer (0x01)

{

0x03

})

}

Else

{

If (LEqual (_T_1, 0x01))

{

Store (ToInteger (DerefOf (Index (Arg3, 0x00))), RAMS)

Return (Zero)

}

Else

{

}

}

}

}

Return (Buffer (0x01)

{

0x00

})

}

}

Name (_S0, Package (0x04)

{

0x00,

0x00,

0x00,

0x00

})

If (SS1)

{

Name (_S1, Package (0x04)

{

0x01,

0x00,

0x00,

0x00

})

}

If (SS3)

{

Name (_S3, Package (0x04)

{

0x05,

0x00,

0x00,

0x00

})

}

If (SS4)

{

Name (_S4, Package (0x04)

{

0x06,

0x00,

0x00,

0x00

})

}

Name (_S5, Package (0x04)

{

0x07,

0x00,

0x00,

0x00

})

Method (PTS, 1, NotSerialized)

{

If (Arg0)

{

\_SB.PCI0.NPTS (Arg0)

\_SB.PCI0.SBRG.SPTS (Arg0)

\_TZ.TRMS (Arg0)

OEMS (Arg0)

}

}

Method (WAK, 1, NotSerialized)

{

\_SB.PCI0.NWAK (Arg0)

\_SB.PCI0.SBRG.SWAK (Arg0)

\_TZ.TRMW (Arg0)

OEMW (Arg0)

}

}

This bios is currently like the above. Till somebody tells me what fields to edit, I can't do these yet.

Sorry,

-OMN

Thanks for your work, MACNUT.

By the way, can you give me some suggestions for my problem?

When I install kalyway 10.5.2's iso to this computer, I use my fixed disk. But after I add iso file to the disk, and then restart my computer, there will be a error, it is :

Darwin kernel version..........................

and it will be stop here. I have tried to using -x, -v, -f, cpus=1, and other orders to solve this problem, but all of them are unuseful. So I think whether it will be OK if I flash BIOS.

Do you think my way is right, or you have other ideas? Thx!

Pierre Lambert · September 23, 2008

There was a lot to Fix, Hope it works for you.
http://rapidshare.com/files/147762192/F7LAS.204.zip.html

Can you change the date of the bios so that I can flashed with "Winflash"?

Thank you in advance.

Pierre Lambert · September 23, 2008

What is winflash saying? what error?

Bios older than the version installed !

skyting · September 23, 2008

That's a .exe file, not a bios image.

What is winflash saying? what error?

Not 100% sure, does this happen with any ISO file?

I am not sure that with any other ISO file. So I will try other one. Thanks a lot !

Pierre Lambert · September 23, 2008

I didn't Change anything but the DSDT strings, what version are you using?
I show a Rom build Version of 4.13 with the bios you linked for editing.

I do not have all understood, but I gave you a print screen in my post above.

I think since the date it is the same problem.

Pierre Lambert · September 23, 2008

I didn't see the image when I replied, sorry.
I changed version date to 3/25/08, Hope that will do it for you.

Bios here

http://rapidshare.com/files/147814827/F7LAS.204.rom.zip.html

Always the same problem!

The new file always contains the date 02/25/08!

Thank you in advance.

Joeandmat · September 23, 2008

thanks macnut for your works! when i can test it i leave you my feedback!

thanks again!

Alex DeWolf · September 24, 2008

Could you modify this bios for the F8Sn
http://dlsvr04.asus.com/pub/ASUS/nb/F3Sg/F8SNG303AS.zip

I have a model with a Core 2 Duo 2.1Ghz, 3gb ram, 250Gb hd, Geforce 9500GS, Chipset is Mobile Intel® 965 PM Express Chipset + ICH8M

I basically can't instally leo4all, iatkos, etc, always getting ACPI errors. The only way I was able to get to the install screen was using the cpus=1, and even so it would freeze later.

Me too. Mine has the T9300 Core Duo.

Thanks

Alex

Any mods for the Asus F8SN-C1 (T9300 cpu and Nvidia 9500m GPU)

Alex

FlyingMac · September 24, 2008

hi man.

it seems u r the god of mac, but I am really new to mac and I could not install it yet, I need your help.

should I change bios of main board to install mac?

if yes? how should I post my bios to you to modify it? please help me.

thanks in advance. You are really great. greater than Jobs.

email: shantiaster@gmail.com

-----------------------------

hardware:

MB ABIT IB9 : chipset intel p965 and ICH8

cpu Intel 3.06 with sse2 and sse3 support

vga geforce 8500

ram 2*1 gig 800

hdd 160 sata

Well, I guess the title says it all, after spending a lot of time reading Documentations, Specifications, Forums.. and hunting for testers , I finally got tehmachacker (thank you) to test a modified BIOS, and as expected, it worked.

This is the issue that intends this mod to fix:

http://forum.insanelymac.com/index.php?showtopic=78235

Basically, what I'm doing is modifying and fixing errors in the DSDT; removing aliases for the "processor" devices, because the ACPIPlatform kext doesn't like them and treat them as other CPUs.. (it's written for Macs, and Apple doesn't use that in their Firmware's ACPI Tables, actually I don't see why we need them, well..)

I for example change this:
	Scope (_PR)
			{
				Processor (P001, 0x01, 0x00000810, 0x06) {}
				Alias (P001, CPU1)
			}
into:
	Scope (_PR)
			{
				Processor (P001, 0x01, 0x00000810, 0x06) {}
			}
Sometimes I have to fix more stuff.. you should know that when you try to compile your DSDT.

So if you want to get a fixed BIOS, you can PM me post your request here, included with:

a direct link to the BIOS file,

your PC specs (CPU, Chipset and Graphics Card),

and a description of the issues.

Don't PM me with requests, post them in this thread.

You will find some of the modified BIOSes here.

Keep in mind that I take no responsibility for a bad flash or if anything goes wrong..

NOTE: About Dell laptops, I'm still trying to find the cause of the issues, so if anyone has any suggestions, you're welcome .

arkacom · September 24, 2008

Done
http://rapidshare.com/files/147852670/4C1333V1.60.zip.html

Done

http://rapidshare.com/files/147852900/A7Sas.206.zip.html

The date is hard coded, you could change in hex i guess.

Thanks for BIOS, but i still can't install Leopard (i think problem in BIOS settings or somewhere else).

Is there someone who successfully installed on Asrock 4Core1333-Viiv? I need advices.

fen · September 24, 2008

tanks Macnut!

...but Flash 2 BIOS ROM Utility if check the file wrot:

"Boot block in file is not valid"

fen · September 24, 2008

...but from DOS all good!

now, I have 2 cpus.

Macnut, you are realy man!

tanx for you job!

eddmaster · September 24, 2008

Hy Macnut, would u please help me modding my Asus P5KC bios please? My iDeneb v1.1 (os x 10.5.4 - EFI, GUID, vanilla) is showing that i am running (and having) just a single core with my Intel C2D E6750! My bios is attached here. And thanks in advance!

PS: The bios-file is the lastest from the original ASUS support site ( 4 my mobo, of course :whistle: )

P5KC_1203.zip

dawiinci · September 24, 2008

This is really great news.

I have the P35 Neo2-FR. So if I will update it with your BIOS do I have any limitations through this mod? For example if I only want to boot Vista. Is it possible to flash the original BIOS back if it doesn't work or I don't need it anymore?

By the way are there users who had any success with this board? (Leopard)

Thanks!!

Alex DeWolf · September 24, 2008

This has been requested before on this thread.

I have an Asus F8Sn-C1:

Processor: Intel Core 2 Duo Processor T9300 (2.5GHz, 6MB L2 Cache, FSB 800MHz)

Chipset: Mobile Intel PM965 & ICH8M

Memory: 3GB (2GB + 1GB) DDR2-667 Memory, Max Capacity 4GB

Display: 14.1" WXGA (1280x800) Color Shine LCD, w/ Asus Splendid Video Intelligent Technology

Graphics Module: nVidia Geforce 9500M GS Graphics Controller, w/ 512MB Meg

Here is the BIOS:

http://dlsvr04.asus.com/pub/ASUS/nb/F8Sn/F8SNG304AS.zip

I got 10.5.4 working with QE/CI but the openGL performance is glitchy and may be related to the required CPS=1 at boot.

Thanks

Alex DeWolf

Alex DeWolf · September 24, 2008

Done
http://rapidshare.com/files/148022745/F8SNGAS.304.zip.html

THank you so much. I will add this to my thread on installing 10.5.4 on the Asus F8SN.

Alex

Bandolero1 · September 24, 2008

Hello Macnut,

Looks like you did take over from Kabyl.

Would be very gratefull if you could make a modified bios for my Asus laptop.

Its version 306 for a Asus M/B: F3Sg

Processor: Intel mobile core 2 Duo T 8100

Chipset: intel GM 965

Graphics card: NVIDEA Geforce 9300M G

F3Sg306AS.zip

arkacom · September 24, 2008

What are the setting you are using in the bios.?

What you mean exactly?

All my settings are default.

mikrobi · September 24, 2008

can you please take a look to the attached Asus M2N4 SLI BIOS please ?

1204.zip

Dane33 · September 24, 2008

That's a .exe file, not a bios image.

When I go to the HP Homepage... it IS the current Bios version of my laptop...

HP nx7400 - f.0d (homepage says f.0c) t7200 2x2ghz core2duo ...

don't find another link to the bios... please help!

best regards

Benny

Modified BIOS to get all cores working

Recommended Posts

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites