Jump to content

sony VPCEB37FD/B


nmano
 Share

2 posts in this topic

Recommended Posts

Thanks for your hard work i am new installer 10.6.4 sl

can you make for me dsdt.dsl for support this intel hd

i upload my dump dsl

ple help me.

thank you.

 

/*

* Intel ACPI Component Architecture

* AML Disassembler version 20091214

*

* Disassembly of ./DSDT.aml, Sun Nov 14 17:12:59 2010

*

*

* Original Table Header:

* Signature "DSDT"

* Length 0x0000AE05 (44549)

* Revision 0x01 **** ACPI 1.0, no 64-bit math support

* Checksum 0xF1

* OEM ID "Sony"

* OEM Table ID "VAIO"

* OEM Revision 0x20100817 (537921559)

* Compiler ID "INTL"

* Compiler Version 0x20051117 (537202967)

*/

DefinitionBlock ("./DSDT.aml", "DSDT", 1, "Sony", "VAIO", 0x20100817)

{

External (PDC7)

External (PDC6)

External (PDC5)

External (PDC4)

External (PDC3)

External (PDC2)

External (PDC1)

External (PDC0)

External (CFGD)

External (HNOT, MethodObj) // 1 Arguments

External (GP53)

External (GP52)

External (NNAB, IntObj)

External (IDAB, MethodObj) // 0 Arguments

External (\ECST, MethodObj) // 1 Arguments

External (\_PR_.CPU0._PPC)

External (\_SB_.LID_._LID)

 

Name (SS1, 0x01)

Name (SS2, 0x00)

Name (SS3, 0x01)

Name (SS4, 0x01)

Name (IOST, 0x0400)

Name (TOPM, 0xDFFFFFFF)

Name (ROMS, 0xFFE00000)

Name (MG1B, 0x00000000)

Name (MG1L, 0x00000000)

Name (MG2B, 0xE0000000)

Name (MG2L, 0x1C40C000)

Name (SP2O, 0x4E)

Name (MCHB, 0xFED10000)

Name (MCHL, 0x4000)

Name (EGPB, 0xFED19000)

Name (EGPL, 0x1000)

Name (DMIB, 0xFED18000)

Name (DMIL, 0x1000)

Name (IFPB, 0xFED14000)

Name (IFPL, 0x1000)

Name (PEBS, 0xF8000000)

Name (PELN, 0x04000000)

Name (TTTB, 0xFED20000)

Name (TTTL, 0x00020000)

Name (SMBS, 0xEFA0)

Name (PBLK, 0x0410)

Name (PMBS, 0x0400)

Name (PMLN, 0x80)

Name (LVL2, 0x0414)

Name (LVL3, 0x0415)

Name (LVL4, 0x0416)

Name (SMIP, 0xB2)

Name (GPBS, 0x0500)

Name (GPLN, 0x80)

Name (APCB, 0xFEC00000)

Name (APCL, 0x1000)

Name (PM30, 0x0430)

Name (SRCB, 0xFED1C000)

Name (SRCL, 0x4000)

Name (SUSW, 0xFF)

Name (HPTB, 0xFED00000)

Name (HPTC, 0xFED1F404)

Name (ACPH, 0xDE)

Name (ASSB, 0x00)

Name (AOTB, 0x00)

Name (AAXB, 0x00)

Name (PEHP, 0x00)

Name (SHPC, 0x01)

Name (PEPM, 0x00)

Name (PEER, 0x00)

Name (PECS, 0x00)

Name (ITKE, 0x00)

Name (FMBL, 0x01)

Name (FDTP, 0x02)

Name (BRF, 0x01)

Name (BPH, 0x02)

Name (BLC, 0x03)

Name (BRFS, 0x04)

Name (BPHS, 0x05)

Name (BLCT, 0x06)

Name (BRF4, 0x07)

Name (BEP, 0x08)

Name (BBF, 0x09)

Name (BOF, 0x0A)

Name (BPT, 0x0B)

Name (SRAF, 0x0C)

Name (WWP, 0x0D)

Name (SDOE, 0x0E)

Name (TRTP, 0x01)

Name (TRTD, 0x02)

Name (TRTI, 0x03)

Name (GCDD, 0x01)

Name (DSTA, 0x0A)

Name (DSLO, 0x0C)

Name (DSLC, 0x0E)

Name (PITS, 0x10)

Name (SBCS, 0x12)

Name (SALS, 0x13)

Name (LSSS, 0x2A)

Name (SOOT, 0x35)

Name (PDBR, 0x4D)

Name (SMBL, 0x10)

Name (TCGM, 0x00)

Name (SP1O, 0x164E)

Name (IO2B, 0x0680)

OperationRegion (GNVS, SystemMemory, 0xD2F28C18, 0x0178)

Field (GNVS, AnyAcc, Lock, Preserve)

{

OSYS, 16,

SMIF, 8,

PRM0, 8,

PRM1, 8,

SCIF, 8,

PRM2, 8,

PRM3, 8,

LCKF, 8,

PRM4, 8,

PRM5, 8,

P80D, 32,

LIDS, 8,

PWRS, 8,

DBGS, 8,

THOF, 8,

ACT1, 8,

ACTT, 8,

PSVT, 8,

TC1V, 8,

TC2V, 8,

TSPV, 8,

CRTT, 8,

DTSE, 8,

DTS1, 8,

DTS2, 8,

DTSF, 8,

BNUM, 8,

B0SC, 8,

B0SS, 8,

Offset (0x25),

REVN, 8,

Offset (0x28),

APIC, 8,

TCNT, 8,

PCP0, 8,

PCP1, 8,

PPCM, 8,

PPMF, 32,

Offset (0x32),

NATP, 8,

CMAP, 8,

CMBP, 8,

LPTP, 8,

FDCP, 8,

CMCP, 8,

CIRP, 8,

SMSC, 8,

W381, 8,

SMC1, 8,

IGDS, 8,

TLST, 8,

CADL, 8,

PADL, 8,

CSTE, 16,

NSTE, 16,

SSTE, 16,

NDID, 8,

DID1, 32,

DID2, 32,

DID3, 32,

DID4, 32,

DID5, 32,

KSV0, 32,

KSV1, 8,

PNID, 8,

Offset (0x67),

BLCS, 8,

BRTL, 8,

ALSE, 8,

ALAF, 8,

LLOW, 8,

LHIH, 8,

Offset (0x6E),

EMAE, 8,

EMAP, 16,

EMAL, 16,

Offset (0x74),

MEFE, 8,

DSTS, 8,

Offset (0x78),

PPRP, 32,

PPRQ, 8,

LPPR, 8,

Offset (0x82),

GTF0, 56,

GTF2, 56,

IDEM, 8,

GTF1, 56,

BID, 8,

Offset (0xAA),

ASLB, 32,

IBTT, 8,

IPAT, 8,

ITVF, 8,

ITVM, 8,

IPSC, 8,

IBLC, 8,

IBIA, 8,

ISSC, 8,

I409, 8,

I509, 8,

I609, 8,

I709, 8,

IPCF, 8,

IDMS, 8,

IF1E, 8,

HVCO, 8,

NXD1, 32,

NXD2, 32,

NXD3, 32,

NXD4, 32,

NXD5, 32,

NXD6, 32,

NXD7, 32,

NXD8, 32,

GSMI, 8,

PAVP, 8,

Offset (0xE1),

OSCC, 8,

NEXP, 8,

SDGV, 8,

SDDV, 8,

Offset (0xEB),

DSEN, 8,

ECON, 8,

GPIC, 8,

CTYP, 8,

L01C, 8,

VFN0, 8,

VFN1, 8,

Offset (0x100),

NVGA, 32,

NVHA, 32,

AMDA, 32,

DID6, 32,

DID7, 32,

DID8, 32,

EBAS, 32,

CPSP, 32,

EECP, 32,

EVCP, 32,

XBAS, 32,

OBS1, 32,

OBS2, 32,

OBS3, 32,

OBS4, 32,

OBS5, 32,

OBS6, 32,

OBS7, 32,

OBS8, 32,

Offset (0x157),

ATMC, 8,

PTMC, 8,

ATRA, 8,

PTRA, 8,

PNHM, 32,

TBAB, 32,

TBAH, 32,

RTIP, 8,

TSOD, 8,

ATPC, 8,

PTPC, 8,

PFLV, 8,

BREV, 8,

BCEN, 8,

ALER, 8,

Q45T, 8,

SBRL, 8,

DPBM, 8,

DPCM, 8,

DPDM, 8,

ALFP, 8,

SYSD, 8,

IMON, 8,

SEAM, 8

}

 

Scope (\_SB)

{

Name (PR00, Package (0x1E)

{

Package (0x04)

{

0x001FFFFF,

0x00,

LNKF,

0x00

},

 

Package (0x04)

{

0x001FFFFF,

0x01,

LNKD,

0x00

},

 

Package (0x04)

{

0x001FFFFF,

0x02,

LNKC,

0x00

},

 

Package (0x04)

{

0x001FFFFF,

0x03,

LNKA,

0x00

},

 

Package (0x04)

{

0x001DFFFF,

0x01,

LNKD,

0x00

},

 

Package (0x04)

{

0x001DFFFF,

0x02,

LNKA,

0x00

},

 

Package (0x04)

{

0x001DFFFF,

0x03,

LNKC,

0x00

},

 

Package (0x04)

{

0x001DFFFF,

0x00,

LNKH,

0x00

},

 

Package (0x04)

{

0x001AFFFF,

0x01,

LNKF,

0x00

},

 

Package (0x04)

{

0x001AFFFF,

0x02,

LNKC,

0x00

},

 

Package (0x04)

{

0x001AFFFF,

0x03,

LNKD,

0x00

},

 

Package (0x04)

{

0x001BFFFF,

0x00,

LNKG,

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)

{

0x0016FFFF,

0x00,

LNKA,

0x00

},

 

Package (0x04)

{

0x0016FFFF,

0x01,

LNKD,

0x00

},

 

Package (0x04)

{

0x0016FFFF,

0x02,

LNKC,

0x00

},

 

Package (0x04)

{

0x0016FFFF,

0x03,

LNKB,

0x00

},

 

Package (0x04)

{

0x001AFFFF,

0x00,

LNKA,

0x00

},

 

Package (0x04)

{

0x0002FFFF,

0x00,

LNKA,

0x00

},

 

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)

{

0x0003FFFF,

0x00,

LNKA,

0x00

},

 

Package (0x04)

{

0x0003FFFF,

0x01,

LNKB,

0x00

},

 

Package (0x04)

{

0x0003FFFF,

0x02,

LNKC,

0x00

},

 

Package (0x04)

{

0x0003FFFF,

0x03,

LNKD,

0x00

}

})

Name (AR00, Package (0x1E)

{

Package (0x04)

{

0x001FFFFF,

0x00,

0x00,

0x15

},

 

Package (0x04)

{

0x001FFFFF,

0x01,

0x00,

0x13

},

 

Package (0x04)

{

0x001FFFFF,

0x02,

0x00,

0x12

},

 

Package (0x04)

{

0x001FFFFF,

0x03,

0x00,

0x10

},

 

Package (0x04)

{

0x001DFFFF,

0x01,

0x00,

0x13

},

 

Package (0x04)

{

0x001DFFFF,

0x02,

0x00,

0x10

},

 

Package (0x04)

{

0x001DFFFF,

0x03,

0x00,

0x12

},

 

Package (0x04)

{

0x001DFFFF,

0x00,

0x00,

0x17

},

 

Package (0x04)

{

0x001AFFFF,

0x01,

0x00,

0x15

},

 

Package (0x04)

{

0x001AFFFF,

0x02,

0x00,

0x12

},

 

Package (0x04)

{

0x001AFFFF,

0x03,

0x00,

0x13

},

 

Package (0x04)

{

0x001BFFFF,

0x00,

0x00,

0x16

},

 

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)

{

0x0016FFFF,

0x00,

0x00,

0x10

},

 

Package (0x04)

{

0x0016FFFF,

0x01,

0x00,

0x13

},

 

Package (0x04)

{

0x0016FFFF,

0x02,

0x00,

0x12

},

 

Package (0x04)

{

0x0016FFFF,

0x03,

0x00,

0x11

},

 

Package (0x04)

{

0x001AFFFF,

0x00,

0x00,

0x10

},

 

Package (0x04)

{

0x0002FFFF,

0x00,

0x00,

0x10

},

 

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)

{

0x0003FFFF,

0x00,

0x00,

0x10

},

 

Package (0x04)

{

0x0003FFFF,

0x01,

0x00,

0x11

},

 

Package (0x04)

{

0x0003FFFF,

0x02,

0x00,

0x12

},

 

Package (0x04)

{

0x0003FFFF,

0x03,

0x00,

0x13

}

})

Name (PR01, 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 (AR01, 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 (PR02, 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 (AR02, 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 (PR03, 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 (AR03, 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 (PR04, 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 (AR04, 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 (PR05, 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 (AR05, 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 (PR07, 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 (AR07, 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 (PR0A, 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 (AR0A, 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 (PR80, Package (0x1D)

{

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,

LNKF,

0x00

},

 

Package (0x04)

{

0x001FFFFF,

0x01,

LNKD,

0x00

},

 

Package (0x04)

{

0x001FFFFF,

0x02,

LNKC,

0x00

},

 

Package (0x04)

{

0x001FFFFF,

0x03,

LNKA,

0x00

},

 

Package (0x04)

{

0x001DFFFF,

0x01,

LNKD,

0x00

},

 

Package (0x04)

{

0x001DFFFF,

0x02,

LNKA,

0x00

},

 

Package (0x04)

{

0x001DFFFF,

0x03,

LNKC,

0x00

},

 

Package (0x04)

{

0x001DFFFF,

0x00,

LNKH,

0x00

},

 

Package (0x04)

{

0x001AFFFF,

0x00,

LNKA,

0x00

},

 

Package (0x04)

{

0x001AFFFF,

0x01,

LNKF,

0x00

},

 

Package (0x04)

{

0x001AFFFF,

0x02,

LNKC,

0x00

},

 

Package (0x04)

{

0x001AFFFF,

0x03,

LNKD,

0x00

},

 

Package (0x04)

{

0x001BFFFF,

0x00,

LNKG,

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)

{

0x0016FFFF,

0x00,

LNKA,

0x00

},

 

Package (0x04)

{

0x0016FFFF,

0x01,

LNKD,

0x00

},

 

Package (0x04)

{

0x0016FFFF,

0x02,

LNKC,

0x00

},

 

Package (0x04)

{

0x0016FFFF,

0x03,

LNKB,

0x00

},

 

Package (0x04)

{

0x0003FFFF,

0x00,

LNKA,

0x00

},

 

Package (0x04)

{

0x0003FFFF,

0x01,

LNKB,

0x00

},

 

Package (0x04)

{

0x0003FFFF,

0x02,

LNKC,

0x00

},

 

Package (0x04)

{

0x0003FFFF,

0x03,

LNKD,

0x00

}

})

Name (AR80, Package (0x1D)

{

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,

0x15

},

 

Package (0x04)

{

0x001FFFFF,

0x01,

0x00,

0x13

},

 

Package (0x04)

{

0x001FFFFF,

0x02,

0x00,

0x12

},

 

Package (0x04)

{

0x001FFFFF,

0x03,

0x00,

0x10

},

 

Package (0x04)

{

0x001DFFFF,

0x01,

0x00,

0x13

},

 

Package (0x04)

{

0x001DFFFF,

0x02,

0x00,

0x10

},

 

Package (0x04)

{

0x001DFFFF,

0x03,

0x00,

0x12

},

 

Package (0x04)

{

0x001DFFFF,

0x00,

0x00,

0x17

},

 

Package (0x04)

{

0x001AFFFF,

0x00,

0x00,

0x10

},

 

Package (0x04)

{

0x001AFFFF,

0x01,

0x00,

0x15

},

 

Package (0x04)

{

0x001AFFFF,

0x02,

0x00,

0x12

},

 

Package (0x04)

{

0x001AFFFF,

0x03,

0x00,

0x13

},

 

Package (0x04)

{

0x001BFFFF,

0x00,

0x00,

0x16

},

 

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)

{

0x0016FFFF,

0x00,

0x00,

0x10

},

 

Package (0x04)

{

0x0016FFFF,

0x01,

0x00,

0x13

},

 

Package (0x04)

{

0x0016FFFF,

0x02,

0x00,

0x12

},

 

Package (0x04)

{

0x0016FFFF,

0x03,

0x00,

0x11

},

 

Package (0x04)

{

0x0003FFFF,

0x00,

0x00,

0x10

},

 

Package (0x04)

{

0x0003FFFF,

0x01,

0x00,

0x11

},

 

Package (0x04)

{

0x0003FFFF,

0x02,

0x00,

0x12

},

 

Package (0x04)

{

0x0003FFFF,

0x03,

0x00,

0x13

}

})

Name (PR81, 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 (AR81, 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 (PR82, 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 (AR82, 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 (PR83, 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 (AR83, 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 (PR84, 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 (AR84, 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 (PR85, 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 (AR85, 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 (PR87, 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 (AR87, 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 (PR08, 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 (AR08, 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 (PR88, 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 (AR88, 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 ("PNP0A08"))

Name (_CID, 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 ())

}

 

OperationRegion (HBUS, PCI_Config, 0x40, 0xC0)

Field (HBUS, DWordAcc, NoLock, Preserve)

{

EPEN, 1,

, 11,

EPBR, 20,

Offset (0x08),

MHEN, 1,

, 13,

MHBR, 18,

Offset (0x10),

IIEN, 1,

, 11,

DIBI, 20,

Offset (0x28),

DIEN, 1,

, 11,

DIBR, 20,

Offset (0x30),

IPEN, 1,

, 11,

IPBR, 20,

Offset (0x62),

TUUD, 16,

Offset (0x70),

, 4,

TLUD, 12,

Offset (0x89),

, 3,

GTSE, 1,

Offset (0x8A)

}

 

OperationRegion (MCHT, SystemMemory, 0xFED10000, 0x1100)

Field (MCHT, ByteAcc, NoLock, Preserve)

{

Offset (0xD40),

ADVE, 1,

, 11,

ADVT, 20,

Offset (0x101E),

T0IS, 16,

Offset (0x105E),

T1IS, 16,

Offset (0x10EF),

ESCS, 8

}

 

Name (BUF0, ResourceTemplate ()

{

WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode,

0x0000, // Granularity

0x0000, // Range Minimum

0x00FE, // Range Maximum

0x0000, // Translation Offset

0x00FF, // Length

,, )

DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,

0x00000000, // Granularity

0x00000000, // Range Minimum

0x00000CF7, // Range Maximum

0x00000000, // Translation Offset

0x00000CF8, // Length

,, , TypeStatic)

IO (Decode16,

0x0CF8, // Range Minimum

0x0CF8, // Range Maximum

0x01, // Alignment

0x08, // Length

)

DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,

0x00000000, // Granularity

0x00000D00, // Range Minimum

0x0000FFFF, // Range Maximum

0x00000000, // Translation Offset

0x0000F300, // Length

,, , TypeStatic)

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

0x00000000, // Granularity

0x000A0000, // Range Minimum

0x000BFFFF, // Range Maximum

0x00000000, // Translation Offset

0x00020000, // Length

,, , AddressRangeMemory, TypeStatic)

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

0x00000000, // Granularity

0x000C0000, // Range Minimum

0x000C3FFF, // Range Maximum

0x00000000, // Translation Offset

0x00004000, // Length

,, , AddressRangeMemory, TypeStatic)

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

0x00000000, // Granularity

0x000C4000, // Range Minimum

0x000C7FFF, // Range Maximum

0x00000000, // Translation Offset

0x00004000, // Length

,, , AddressRangeMemory, TypeStatic)

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

0x00000000, // Granularity

0x000C8000, // Range Minimum

0x000CBFFF, // Range Maximum

0x00000000, // Translation Offset

0x00004000, // Length

,, , AddressRangeMemory, TypeStatic)

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

0x00000000, // Granularity

0x000CC000, // Range Minimum

0x000CFFFF, // Range Maximum

0x00000000, // Translation Offset

0x00004000, // Length

,, , AddressRangeMemory, TypeStatic)

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

0x00000000, // Granularity

0x000D0000, // Range Minimum

0x000D3FFF, // Range Maximum

0x00000000, // Translation Offset

0x00004000, // Length

,, , AddressRangeMemory, TypeStatic)

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

0x00000000, // Granularity

0x000D4000, // Range Minimum

0x000D7FFF, // Range Maximum

0x00000000, // Translation Offset

0x00004000, // Length

,, , AddressRangeMemory, TypeStatic)

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

0x00000000, // Granularity

0x000D8000, // Range Minimum

0x000DBFFF, // Range Maximum

0x00000000, // Translation Offset

0x00004000, // Length

,, , AddressRangeMemory, TypeStatic)

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

0x00000000, // Granularity

0x000DC000, // Range Minimum

0x000DFFFF, // Range Maximum

0x00000000, // Translation Offset

0x00004000, // Length

,, , AddressRangeMemory, TypeStatic)

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

0x00000000, // Granularity

0x000E0000, // Range Minimum

0x000E3FFF, // Range Maximum

0x00000000, // Translation Offset

0x00004000, // Length

,, , AddressRangeMemory, TypeStatic)

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

0x00000000, // Granularity

0x000E4000, // Range Minimum

0x000E7FFF, // Range Maximum

0x00000000, // Translation Offset

0x00004000, // Length

,, , AddressRangeMemory, TypeStatic)

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

0x00000000, // Granularity

0x000E8000, // Range Minimum

0x000EBFFF, // Range Maximum

0x00000000, // Translation Offset

0x00004000, // Length

,, , AddressRangeMemory, TypeStatic)

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

0x00000000, // Granularity

0x000EC000, // Range Minimum

0x000EFFFF, // Range Maximum

0x00000000, // Translation Offset

0x00004000, // Length

,, , AddressRangeMemory, TypeStatic)

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

0x00000000, // Granularity

0x000F0000, // Range Minimum

0x000FFFFF, // Range Maximum

0x00000000, // Translation Offset

0x00010000, // Length

,, , AddressRangeMemory, TypeStatic)

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

0x00000000, // Granularity

0x00000000, // Range Minimum

0xFEAFFFFF, // Range Maximum

0x00000000, // Translation Offset

0x00000000, // Length

,, , AddressRangeMemory, TypeStatic)

})

Method (_CRS, 0, Serialized)

{

CreateWordField (BUF0, 0x0A, PBMX)

Store (Subtract (ShiftRight (\PELN, 0x14), 0x02), PBMX)

CreateWordField (BUF0, 0x0E, PBLN)

Store (Subtract (ShiftRight (\PELN, 0x14), 0x01), PBLN)

If (\_SB.CPBG.IMCH.PM1L)

{

CreateDWordField (BUF0, 0x7C, C0LN)

Store (Zero, C0LN)

}

 

If (LEqual (\_SB.CPBG.IMCH.PM1L, 0x01))

{

CreateBitField (BUF0, 0x0358, C0RW)

Store (Zero, C0RW)

}

 

If (\_SB.CPBG.IMCH.PM1H)

{

CreateDWordField (BUF0, 0x96, C4LN)

Store (Zero, C4LN)

}

 

If (LEqual (\_SB.CPBG.IMCH.PM1H, 0x01))

{

CreateBitField (BUF0, 0x0428, C4RW)

Store (Zero, C4RW)

}

 

If (\_SB.CPBG.IMCH.PM2L)

{

CreateDWordField (BUF0, 0xB0, C8LN)

Store (Zero, C8LN)

}

 

If (LEqual (\_SB.CPBG.IMCH.PM2L, 0x01))

{

CreateBitField (BUF0, 0x04F8, C8RW)

Store (Zero, C8RW)

}

 

If (\_SB.CPBG.IMCH.PM2H)

{

CreateDWordField (BUF0, 0xCA, CCLN)

Store (Zero, CCLN)

}

 

If (LEqual (\_SB.CPBG.IMCH.PM2H, 0x01))

{

CreateBitField (BUF0, 0x05C8, CCRW)

Store (Zero, CCRW)

}

 

If (\_SB.CPBG.IMCH.PM3L)

{

CreateDWordField (BUF0, 0xE4, D0LN)

Store (Zero, D0LN)

}

 

If (LEqual (\_SB.CPBG.IMCH.PM3L, 0x01))

{

CreateBitField (BUF0, 0x0698, D0RW)

Store (Zero, D0RW)

}

 

If (\_SB.CPBG.IMCH.PM3H)

{

CreateDWordField (BUF0, 0xFE, D4LN)

Store (Zero, D4LN)

}

 

If (LEqual (\_SB.CPBG.IMCH.PM3H, 0x01))

{

CreateBitField (BUF0, 0x0768, D4RW)

Store (Zero, D4RW)

}

 

If (\_SB.CPBG.IMCH.PM4L)

{

CreateDWordField (BUF0, 0x0118, D8LN)

Store (Zero, D8LN)

}

 

If (LEqual (\_SB.CPBG.IMCH.PM4L, 0x01))

{

CreateBitField (BUF0, 0x0838, D8RW)

Store (Zero, D8RW)

}

 

If (\_SB.CPBG.IMCH.PM4H)

{

CreateDWordField (BUF0, 0x0132, DCLN)

Store (Zero, DCLN)

}

 

If (LEqual (\_SB.CPBG.IMCH.PM4H, 0x01))

{

CreateBitField (BUF0, 0x0908, DCRW)

Store (Zero, DCRW)

}

 

If (\_SB.CPBG.IMCH.PM5L)

{

CreateDWordField (BUF0, 0x014C, E0LN)

Store (Zero, E0LN)

}

 

If (LEqual (\_SB.CPBG.IMCH.PM5L, 0x01))

{

CreateBitField (BUF0, 0x09D8, E0RW)

Store (Zero, E0RW)

}

 

If (\_SB.CPBG.IMCH.PM5H)

{

CreateDWordField (BUF0, 0x0166, E4LN)

Store (Zero, E4LN)

}

 

If (LEqual (\_SB.CPBG.IMCH.PM5H, 0x01))

{

CreateBitField (BUF0, 0x0AA8, E4RW)

Store (Zero, E4RW)

}

 

If (\_SB.CPBG.IMCH.PM6L)

{

CreateDWordField (BUF0, 0x0180, E8LN)

Store (Zero, E8LN)

}

 

If (LEqual (\_SB.CPBG.IMCH.PM6L, 0x01))

{

CreateBitField (BUF0, 0x0B78, E8RW)

Store (Zero, E8RW)

}

 

If (\_SB.CPBG.IMCH.PM6H)

{

CreateDWordField (BUF0, 0x019A, ECLN)

Store (Zero, ECLN)

}

 

If (LEqual (\_SB.CPBG.IMCH.PM6H, 0x01))

{

CreateBitField (BUF0, 0x0C48, ECRW)

Store (Zero, ECRW)

}

 

If (\_SB.CPBG.IMCH.PM0H)

{

CreateDWordField (BUF0, 0x01B4, F0LN)

Store (Zero, F0LN)

}

 

If (LEqual (\_SB.CPBG.IMCH.PM0H, 0x01))

{

CreateBitField (BUF0, 0x0D18, F0RW)

Store (Zero, F0RW)

}

 

CreateDWordField (BUF0, 0x01C2, M1MN)

CreateDWordField (BUF0, 0x01C6, M1MX)

CreateDWordField (BUF0, 0x01CE, M1LN)

If (Or (LEqual (And (PNHM, 0x000FFFF0), 0x000106E0), LEqual (And (

PNHM, 0x000FFFF0), 0x000106A0)))

{

If (LGreaterEqual (PNHM, 0x000106E1))

{

Store (\_SB.PCI0.IO10.TOLM, Local0)

ShiftLeft (Increment (Local0), 0x1A, M1MN)

}

Else

{

Store (\_SB.PCI0.IIO0.TOLM, Local0)

ShiftLeft (Increment (Local0), 0x1A, M1MN)

}

}

Else

{

ShiftLeft (TLUD, 0x14, M1MN)

}

 

Add (Subtract (M1MX, M1MN), 0x01, M1LN)

Return (BUF0)

}

 

Name (GUID, Buffer (0x10)

{

/* 0000 */ 0x5B, 0x4D, 0xDB, 0x33, 0xF7, 0x1F, 0x1C, 0x40,

/* 0008 */ 0x96, 0x57, 0x74, 0x41, 0xC0, 0x3D, 0xD7, 0x66

})

Name (SUPP, 0x00)

Name (CTRL, 0x00)

Method (_OSC, 4, Serialized)

{

Store (Arg3, Local0)

CreateDWordField (Local0, 0x00, CDW1)

CreateDWordField (Local0, 0x04, CDW2)

CreateDWordField (Local0, 0x08, CDW3)

If (LAnd (LEqual (Arg0, GUID), NEXP))

{

Store (CDW2, SUPP)

Store (CDW3, CTRL)

If (Not (And (CDW1, 0x01)))

{

If (And (CTRL, 0x02))

{

NHPG ()

}

 

If (And (CTRL, 0x04))

{

NPME ()

}

}

 

If (LNotEqual (Arg1, One))

{

Or (CDW1, 0x08, CDW1)

}

 

If (LNotEqual (CDW3, CTRL))

{

Or (CDW1, 0x10, CDW1)

}

 

Store (CTRL, CDW3)

Store (CTRL, OSCC)

Return (Local0)

}

Else

{

Or (CDW1, 0x04, CDW1)

Return (Local0)

}

}

 

Scope (\_SB.PCI0)

{

Method (AR00, 0, NotSerialized)

{

If (Or (LEqual (And (PNHM, 0x000FFFF0), 0x000106E0), LEqual (And (

PNHM, 0x000FFFF0), 0x000106A0)))

{

Return (\_SB.AR80)

}

Else

{

Return (\_SB.AR00)

}

}

 

Method (PR00, 0, NotSerialized)

{

If (Or (LEqual (And (PNHM, 0x000FFFF0), 0x000106E0), LEqual (And (

PNHM, 0x000FFFF0), 0x000106A0)))

{

Return (\_SB.PR80)

}

Else

{

Return (\_SB.PR00)

}

}

 

Method (AR01, 0, NotSerialized)

{

If (Or (LEqual (And (PNHM, 0x000FFFF0), 0x000106E0), LEqual (And (

PNHM, 0x000FFFF0), 0x000106A0)))

{

Return (\_SB.AR81)

}

Else

{

Return (\_SB.AR01)

}

}

 

Method (PR01, 0, NotSerialized)

{

If (Or (LEqual (And (PNHM, 0x000FFFF0), 0x000106E0), LEqual (And (

PNHM, 0x000FFFF0), 0x000106A0)))

{

Return (\_SB.PR81)

}

Else

{

Return (\_SB.PR01)

}

}

 

Method (AR02, 0, NotSerialized)

{

If (Or (LEqual (And (PNHM, 0x000FFFF0), 0x000106E0), LEqual (And (

PNHM, 0x000FFFF0), 0x000106A0)))

{

Return (\_SB.AR82)

}

Else

{

Return (\_SB.AR02)

}

}

 

Method (PR02, 0, NotSerialized)

{

If (Or (LEqual (And (PNHM, 0x000FFFF0), 0x000106E0), LEqual (And (

PNHM, 0x000FFFF0), 0x000106A0)))

{

Return (\_SB.PR82)

}

Else

{

Return (\_SB.PR02)

}

}

 

Method (AR03, 0, NotSerialized)

{

If (Or (LEqual (And (PNHM, 0x000FFFF0), 0x000106E0), LEqual (And (

PNHM, 0x000FFFF0), 0x000106A0)))

{

Return (\_SB.AR83)

}

Else

{

Return (\_SB.AR03)

}

}

 

Method (PR03, 0, NotSerialized)

{

If (Or (LEqual (And (PNHM, 0x000FFFF0), 0x000106E0), LEqual (And (

PNHM, 0x000FFFF0), 0x000106A0)))

{

Return (\_SB.PR83)

}

Else

{

Return (\_SB.PR03)

}

}

 

Method (AR04, 0, NotSerialized)

{

If (Or (LEqual (And (PNHM, 0x000FFFF0), 0x000106E0), LEqual (And (

PNHM, 0x000FFFF0), 0x000106A0)))

{

Return (\_SB.AR84)

}

Else

{

Return (\_SB.AR04)

}

}

 

Method (PR04, 0, NotSerialized)

{

If (Or (LEqual (And (PNHM, 0x000FFFF0), 0x000106E0), LEqual (And (

PNHM, 0x000FFFF0), 0x000106A0)))

{

Return (\_SB.PR84)

}

Else

{

Return (\_SB.PR04)

}

}

 

Method (AR05, 0, NotSerialized)

{

If (Or (LEqual (And (PNHM, 0x000FFFF0), 0x000106E0), LEqual (And (

PNHM, 0x000FFFF0), 0x000106A0)))

{

Return (\_SB.AR85)

}

Else

{

Return (\_SB.AR05)

}

}

 

Method (PR05, 0, NotSerialized)

{

If (Or (LEqual (And (PNHM, 0x000FFFF0), 0x000106E0), LEqual (And (

PNHM, 0x000FFFF0), 0x000106A0)))

{

Return (\_SB.PR85)

}

Else

{

Return (\_SB.PR05)

}

}

 

Method (AR07, 0, NotSerialized)

{

If (Or (LEqual (And (PNHM, 0x000FFFF0), 0x000106E0), LEqual (And (

PNHM, 0x000FFFF0), 0x000106A0)))

{

Return (\_SB.AR87)

}

Else

{

Return (\_SB.AR07)

}

}

 

Method (PR07, 0, NotSerialized)

{

If (Or (LEqual (And (PNHM, 0x000FFFF0), 0x000106E0), LEqual (And (

PNHM, 0x000FFFF0), 0x000106A0)))

{

Return (\_SB.PR87)

}

Else

{

Return (\_SB.PR07)

}

}

 

Method (AR08, 0, NotSerialized)

{

If (Or (LEqual (And (PNHM, 0x000FFFF0), 0x000106E0), LEqual (And (

PNHM, 0x000FFFF0), 0x000106A0)))

{

Return (\_SB.AR88)

}

Else

{

Return (\_SB.AR08)

}

}

 

Method (PR08, 0, NotSerialized)

{

If (Or (LEqual (And (PNHM, 0x000FFFF0), 0x000106E0), LEqual (And (

PNHM, 0x000FFFF0), 0x000106A0)))

{

Return (\_SB.PR88)

}

Else

{

Return (\_SB.PR08)

}

}

}

 

Device (P0PF)

{

Name (_ADR, 0x001E0000)

Method (_PRW, 0, NotSerialized)

{

Return (GPRW (0x0B, 0x04))

}

}

 

Device (LPCB)

{

Name (_ADR, 0x001F0000)

Scope (\_SB)

{

OperationRegion (\_SB.PCI0.LPCB.LPC1, PCI_Config, 0x40, 0xC0)

Field (\_SB.PCI0.LPCB.LPC1, AnyAcc, NoLock, Preserve)

{

Offset (0x20),

PARC, 8,

PBRC, 8,

PCRC, 8,

PDRC, 8,

Offset (0x28),

PERC, 8,

PFRC, 8,

PGRC, 8,

PHRC, 8

}

 

Device (LNKA)

{

Name (_HID, EisaId ("PNP0C0F"))

Name (_UID, 0x01)

Method (_DIS, 0, Serialized)

{

Or (PARC, 0x80, PARC)

}

 

Name (_PRS, ResourceTemplate ()

{

IRQ (Level, ActiveLow, Shared, )

{1,3,4,5,6,7,10,12,14,15}

})

Method (_CRS, 0, Serialized)

{

Name (RTLA, ResourceTemplate ()

{

IRQ (Level, ActiveLow, Shared, )

{}

})

CreateWordField (RTLA, 0x01, IRQ0)

Store (Zero, IRQ0)

ShiftLeft (0x01, And (PARC, 0x0F), IRQ0)

Return (RTLA)

}

 

Method (_SRS, 1, Serialized)

{

CreateWordField (Arg0, 0x01, IRQ0)

FindSetRightBit (IRQ0, Local0)

Decrement (Local0)

Store (Local0, PARC)

}

 

Method (_STA, 0, Serialized)

{

If (And (PARC, 0x80))

{

Return (0x09)

}

Else

{

Return (0x0B)

}

}

}

 

Device (LNKB)

{

Name (_HID, EisaId ("PNP0C0F"))

Name (_UID, 0x02)

Method (_DIS, 0, Serialized)

{

Or (PBRC, 0x80, PBRC)

}

 

Name (_PRS, ResourceTemplate ()

{

IRQ (Level, ActiveLow, Shared, )

{1,3,4,5,6,7,11,12,14,15}

})

Method (_CRS, 0, Serialized)

{

Name (RTLB, ResourceTemplate ()

{

IRQ (Level, ActiveLow, Shared, )

{}

})

CreateWordField (RTLB, 0x01, IRQ0)

Store (Zero, IRQ0)

ShiftLeft (0x01, And (PBRC, 0x0F), IRQ0)

Return (RTLB)

}

 

Method (_SRS, 1, Serialized)

{

CreateWordField (Arg0, 0x01, IRQ0)

FindSetRightBit (IRQ0, Local0)

Decrement (Local0)

Store (Local0, PBRC)

}

 

Method (_STA, 0, Serialized)

{

If (And (PBRC, 0x80))

{

Return (0x09)

}

Else

{

Return (0x0B)

}

}

}

 

Device (LNKC)

{

Name (_HID, EisaId ("PNP0C0F"))

Name (_UID, 0x03)

Method (_DIS, 0, Serialized)

{

Or (PCRC, 0x80, PCRC)

}

 

Name (_PRS, ResourceTemplate ()

{

IRQ (Level, ActiveLow, Shared, )

{1,3,4,5,6,7,10,12,14,15}

})

Method (_CRS, 0, Serialized)

{

Name (RTLC, ResourceTemplate ()

{

IRQ (Level, ActiveLow, Shared, )

{}

})

CreateWordField (RTLC, 0x01, IRQ0)

Store (Zero, IRQ0)

ShiftLeft (0x01, And (PCRC, 0x0F), IRQ0)

Return (RTLC)

}

 

Method (_SRS, 1, Serialized)

{

CreateWordField (Arg0, 0x01, IRQ0)

FindSetRightBit (IRQ0, Local0)

Decrement (Local0)

Store (Local0, PCRC)

}

 

Method (_STA, 0, Serialized)

{

If (And (PCRC, 0x80))

{

Return (0x09)

}

Else

{

Return (0x0B)

}

}

}

 

Device (LNKD)

{

Name (_HID, EisaId ("PNP0C0F"))

Name (_UID, 0x04)

Method (_DIS, 0, Serialized)

{

Or (PDRC, 0x80, PDRC)

}

 

Name (_PRS, ResourceTemplate ()

{

IRQ (Level, ActiveLow, Shared, )

{1,3,4,5,6,7,11,12,14,15}

})

Method (_CRS, 0, Serialized)

{

Name (RTLD, ResourceTemplate ()

{

IRQ (Level, ActiveLow, Shared, )

{}

})

CreateWordField (RTLD, 0x01, IRQ0)

Store (Zero, IRQ0)

ShiftLeft (0x01, And (PDRC, 0x0F), IRQ0)

Return (RTLD)

}

 

Method (_SRS, 1, Serialized)

{

CreateWordField (Arg0, 0x01, IRQ0)

FindSetRightBit (IRQ0, Local0)

Decrement (Local0)

Store (Local0, PDRC)

}

 

Method (_STA, 0, Serialized)

{

If (And (PDRC, 0x80))

{

Return (0x09)

}

Else

{

Return (0x0B)

}

}

}

 

Device (LNKE)

{

Name (_HID, EisaId ("PNP0C0F"))

Name (_UID, 0x05)

Method (_DIS, 0, Serialized)

{

Or (PERC, 0x80, PERC)

}

 

Name (_PRS, ResourceTemplate ()

{

IRQ (Level, ActiveLow, Shared, )

{1,3,4,5,6,7,10,12,14,15}

})

Method (_CRS, 0, Serialized)

{

Name (RTLE, ResourceTemplate ()

{

IRQ (Level, ActiveLow, Shared, )

{}

})

CreateWordField (RTLE, 0x01, IRQ0)

Store (Zero, IRQ0)

ShiftLeft (0x01, And (PERC, 0x0F), IRQ0)

Return (RTLE)

}

 

Method (_SRS, 1, Serialized)

{

CreateWordField (Arg0, 0x01, IRQ0)

FindSetRightBit (IRQ0, Local0)

Decrement (Local0)

Store (Local0, PERC)

}

 

Method (_STA, 0, Serialized)

{

If (And (PERC, 0x80))

{

Return (0x09)

}

Else

{

Return (0x0B)

}

}

}

 

Device (LNKF)

{

Name (_HID, EisaId ("PNP0C0F"))

Name (_UID, 0x06)

Method (_DIS, 0, Serialized)

{

Or (PFRC, 0x80, PFRC)

}

 

Name (_PRS, ResourceTemplate ()

{

IRQ (Level, ActiveLow, Shared, )

{1,3,4,5,6,7,11,12,14,15}

})

Method (_CRS, 0, Serialized)

{

Name (RTLF, ResourceTemplate ()

{

IRQ (Level, ActiveLow, Shared, )

{}

})

CreateWordField (RTLF, 0x01, IRQ0)

Store (Zero, IRQ0)

ShiftLeft (0x01, And (PFRC, 0x0F), IRQ0)

Return (RTLF)

}

 

Method (_SRS, 1, Serialized)

{

CreateWordField (Arg0, 0x01, IRQ0)

FindSetRightBit (IRQ0, Local0)

Decrement (Local0)

Store (Local0, PFRC)

}

 

Method (_STA, 0, Serialized)

{

If (And (PFRC, 0x80))

{

Return (0x09)

}

Else

{

Return (0x0B)

}

}

}

 

Device (LNKG)

{

Name (_HID, EisaId ("PNP0C0F"))

Name (_UID, 0x07)

Method (_DIS, 0, Serialized)

{

Or (PGRC, 0x80, PGRC)

}

 

Name (_PRS, ResourceTemplate ()

{

IRQ (Level, ActiveLow, Shared, )

{1,3,4,5,6,7,10,12,14,15}

})

Method (_CRS, 0, Serialized)

{

Name (RTLG, ResourceTemplate ()

{

IRQ (Level, ActiveLow, Shared, )

{}

})

CreateWordField (RTLG, 0x01, IRQ0)

Store (Zero, IRQ0)

ShiftLeft (0x01, And (PGRC, 0x0F), IRQ0)

Return (RTLG)

}

 

Method (_SRS, 1, Serialized)

{

CreateWordField (Arg0, 0x01, IRQ0)

FindSetRightBit (IRQ0, Local0)

Decrement (Local0)

Store (Local0, PGRC)

}

 

Method (_STA, 0, Serialized)

{

If (And (PGRC, 0x80))

{

Return (0x09)

}

Else

{

Return (0x0B)

}

}

}

 

Device (LNKH)

{

Name (_HID, EisaId ("PNP0C0F"))

Name (_UID, 0x08)

Method (_DIS, 0, Serialized)

{

Or (PHRC, 0x80, PHRC)

}

 

Name (_PRS, ResourceTemplate ()

{

IRQ (Level, ActiveLow, Shared, )

{1,3,4,5,6,7,11,12,14,15}

})

Method (_CRS, 0, Serialized)

{

Name (RTLH, ResourceTemplate ()

{

IRQ (Level, ActiveLow, Shared, )

{}

})

CreateWordField (RTLH, 0x01, IRQ0)

Store (Zero, IRQ0)

ShiftLeft (0x01, And (PHRC, 0x0F), IRQ0)

Return (RTLH)

}

 

Method (_SRS, 1, Serialized)

{

CreateWordField (Arg0, 0x01, IRQ0)

FindSetRightBit (IRQ0, Local0)

Decrement (Local0)

Store (Local0, PHRC)

}

 

Method (_STA, 0, Serialized)

{

If (And (PHRC, 0x80))

{

Return (0x09)

}

Else

{

Return (0x0B)

}

}

}

}

 

OperationRegion (LPC0, PCI_Config, 0x40, 0xC0)

Field (LPC0, AnyAcc, NoLock, Preserve)

{

Offset (0x40),

IOD0, 8,

IOD1, 8,

Offset (0xB0),

RAEN, 1,

, 13,

RCBA, 18

}

 

Device (DMAC)

{

Name (_HID, EisaId ("PNP0200"))

Name (_CRS, ResourceTemplate ()

{

IO (Decode16,

0x0000, // Range Minimum

0x0000, // Range Maximum

0x01, // Alignment

0x20, // Length

)

IO (Decode16,

0x0081, // Range Minimum

0x0081, // Range Maximum

0x01, // Alignment

0x11, // Length

)

IO (Decode16,

0x0093, // Range Minimum

0x0093, // Range Maximum

0x01, // Alignment

0x0D, // Length

)

IO (Decode16,

0x00C0, // Range Minimum

0x00C0, // Range Maximum

0x01, // Alignment

0x20, // Length

)

DMA (Compatibility, NotBusMaster, Transfer8_16, )

{4}

})

}

 

Device (FWHD)

{

Name (_HID, EisaId ("INT0800"))

Name (_CRS, ResourceTemplate ()

{

Memory32Fixed (ReadOnly,

0xFF000000, // Address Base

0x01000000, // Address Length

)

})

}

 

Device (HPET)

{

Name (_HID, EisaId ("PNP0103"))

Name (_UID, 0x00)

Name (BUF0, ResourceTemplate ()

{

Memory32Fixed (ReadWrite,

0xFED00000, // Address Base

0x00000400, // Address Length

)

})

Method (_STA, 0, NotSerialized)

{

If (LGreaterEqual (OSYS, 0x07D1))

{

If (HPAE)

{

Return (0x0F)

}

}

Else

{

If (HPAE)

{

Return (0x0B)

}

}

 

Return (0x00)

}

 

Method (_CRS, 0, Serialized)

{

If (HPAE)

{

CreateDWordField (BUF0, 0x04, HPT0)

If (LEqual (HPAS, 0x01))

{

Store (0xFED01000, HPT0)

}

 

If (LEqual (HPAS, 0x02))

{

Store (0xFED02000, HPT0)

}

 

If (LEqual (HPAS, 0x03))

{

Store (0xFED03000, HPT0)

}

}

 

Return (BUF0)

}

}

 

Device (IPIC)

{

Name (_HID, EisaId ("PNP0000"))

Name (_CRS, ResourceTemplate ()

{

IO (Decode16,

0x0020, // Range Minimum

0x0020, // Range Maximum

0x01, // Alignment

0x02, // Length

)

IO (Decode16,

0x0024, // Range Minimum

0x0024, // Range Maximum

0x01, // Alignment

0x02, // Length

)

IO (Decode16,

0x0028, // Range Minimum

0x0028, // Range Maximum

0x01, // Alignment

0x02, // Length

)

IO (Decode16,

0x002C, // Range Minimum

0x002C, // Range Maximum

0x01, // Alignment

0x02, // Length

)

IO (Decode16,

0x0030, // Range Minimum

0x0030, // Range Maximum

0x01, // Alignment

0x02, // Length

)

IO (Decode16,

0x0034, // Range Minimum

0x0034, // Range Maximum

0x01, // Alignment

0x02, // Length

)

IO (Decode16,

0x0038, // Range Minimum

0x0038, // Range Maximum

0x01, // Alignment

0x02, // Length

)

IO (Decode16,

0x003C, // Range Minimum

0x003C, // Range Maximum

0x01, // Alignment

0x02, // Length

)

IO (Decode16,

0x00A0, // Range Minimum

0x00A0, // Range Maximum

0x01, // Alignment

0x02, // Length

)

IO (Decode16,

0x00A4, // Range Minimum

0x00A4, // Range Maximum

0x01, // Alignment

0x02, // Length

)

IO (Decode16,

0x00A8, // Range Minimum

0x00A8, // Range Maximum

0x01, // Alignment

0x02, // Length

)

IO (Decode16,

0x00AC, // Range Minimum

0x00AC, // Range Maximum

0x01, // Alignment

0x02, // Length

)

IO (Decode16,

0x00B0, // Range Minimum

0x00B0, // Range Maximum

0x01, // Alignment

0x02, // Length

)

IO (Decode16,

0x00B4, // Range Minimum

0x00B4, // Range Maximum

0x01, // Alignment

0x02, // Length

)

IO (Decode16,

0x00B8, // Range Minimum

0x00B8, // Range Maximum

0x01, // Alignment

0x02, // Length

)

IO (Decode16,

0x00BC, // Range Minimum

0x00BC, // Range Maximum

0x01, // Alignment

0x02, // Length

)

IO (Decode16,

0x04D0, // Range Minimum

0x04D0, // Range Maximum

0x01, // Alignment

0x02, // Length

)

IRQNoFlags ()

{2}

})

}

 

Device (MATH)

{

Name (_HID, EisaId ("PNP0C04"))

Name (_CRS, ResourceTemplate ()

{

IO (Decode16,

0x00F0, // Range Minimum

0x00F0, // Range Maximum

0x01, // Alignment

0x01, // Length

)

IRQNoFlags ()

{13}

})

}

 

Device (LDRC)

{

Name (_HID, EisaId ("PNP0C02"))

Name (_UID, 0x02)

Name (_CRS, ResourceTemplate ()

{

IO (Decode16,

0x002E, // Range Minimum

0x002E, // Range Maximum

0x01, // Alignment

0x02, // Length

)

IO (Decode16,

0x004E, // Range Minimum

0x004E, // Range Maximum

0x01, // Alignment

0x02, // Length

)

IO (Decode16,

0x0061, // Range Minimum

0x0061, // Range Maximum

0x01, // Alignment

0x01, // Length

)

IO (Decode16,

0x0063, // Range Minimum

0x0063, // Range Maximum

0x01, // Alignment

0x01, // Length

)

IO (Decode16,

0x0065, // Range Minimum

0x0065, // Range Maximum

0x01, // Alignment

0x01, // Length

)

IO (Decode16,

0x0067, // Range Minimum

0x0067, // Range Maximum

0x01, // Alignment

0x01, // Length

)

IO (Decode16,

0x0070, // Range Minimum

0x0070, // Range Maximum

0x01, // Alignment

0x01, // Length

)

IO (Decode16,

0x0080, // Range Minimum

0x0080, // Range Maximum

0x01, // Alignment

0x01, // Length

)

IO (Decode16,

0x0092, // Range Minimum

0x0092, // Range Maximum

0x01, // Alignment

0x01, // Length

)

IO (Decode16,

0x00B2, // Range Minimum

0x00B2, // Range Maximum

0x01, // Alignment

0x02, // Length

)

IO (Decode16,

0x0680, // Range Minimum

0x0680, // Range Maximum

0x01, // Alignment

0x20, // Length

)

IO (Decode16,

0xFF00, // Range Minimum

0xFF00, // Range Maximum

0x01, // Alignment

0x10, // Length

)

IO (Decode16,

0xFF10, // Range Minimum

0xFF10, // Range Maximum

0x01, // Alignment

0x04, // Length

)

IO (Decode16,

0x0800, // Range Minimum

0x0800, // Range Maximum

0x01, // Alignment

0x04, // Length

)

IO (Decode16,

0x0400, // Range Minimum

0x0400, // Range Maximum

0x01, // Alignment

0x80, // Length

)

IO (Decode16,

0x0500, // Range Minimum

0x0500, // Range Maximum

0x01, // Alignment

0x80, // Length

)

IO (Decode16,

0x164E, // Range Minimum

0x164E, // Range Maximum

0x01, // Alignment

0x02, // Length

)

})

}

 

Device (RTC)

{

Name (_HID, EisaId ("PNP0B00"))

Name (_CRS, ResourceTemplate ()

{

IO (Decode16,

0x0070, // Range Minimum

0x0070, // Range Maximum

0x01, // Alignment

0x08, // Length

)

IRQNoFlags ()

{8}

})

}

 

Device (TIMR)

{

Name (_HID, EisaId ("PNP0100"))

Name (_CRS, ResourceTemplate ()

{

IO (Decode16,

0x0040, // Range Minimum

0x0040, // Range Maximum

0x01, // Alignment

0x04, // Length

)

IO (Decode16,

0x0050, // Range Minimum

0x0050, // Range Maximum

0x10, // Alignment

0x04, // Length

)

IRQNoFlags ()

{0}

})

}

 

Name (CPUL, 0x00)

Name (MCHL, 0x00)

Name (PCHL, 0x00)

Name (DIML, 0x00)

If (LNotEqual (TBAB, Zero))

{

OperationRegion (TBLK, SystemMemory, TBAB, 0x4000)

Field (TBLK, AnyAcc, NoLock, Preserve)

{

Offset (0x24),

MMCH, 1,

MCPU, 1,

MBUD, 2,

Offset (0x26),

Offset (0x50),

, 1,

MMTL, 7,

MGTD, 1,

MCTD, 1,

MPOL, 2,

MGPL, 9,

MCPL, 10,

Offset (0x54),

MMPL, 10,

Offset (0x56),

MTL, 16,

Offset (0x64),

MMPC, 16,

MPPC, 16,

MCPC, 16,

Offset (0x98),

, 1,

NMTL, 7,

NGTD, 1,

NCTD, 1,

NPOL, 2,

NGPL, 9,

NCPL, 10,

Offset (0x9C),

Offset (0xA8),

Offset (0xAA),

TMPL, 10,

Offset (0xAC)

}

}

 

If (LNotEqual (TBAB, Zero))

{

OperationRegion (PTBA, SystemMemory, TBAB, 0x4000)

Field (PTBA, AnyAcc, NoLock, Preserve)

{

Offset (0x1A),

PTRC, 16,

Offset (0x30),

CTV1, 16,

CTV2, 16,

Offset (0x60),

PMCP, 16

}

}

 

Device (PS2K)

{

Name (_HID, EisaId ("PNP0303"))

Name (_CRS, ResourceTemplate ()

{

IO (Decode16,

0x0060, // Range Minimum

0x0060, // Range Maximum

0x01, // Alignment

0x01, // Length

)

IO (Decode16,

0x0064, // Range Minimum

0x0064, // Range Maximum

0x01, // Alignment

0x01, // Length

)

IRQ (Edge, ActiveHigh, Exclusive, )

{1}

})

Name (_PRS, ResourceTemplate ()

{

StartDependentFn (0x00, 0x00)

{

FixedIO (

0x0060, // Address

0x01, // Length

)

FixedIO (

0x0064, // Address

0x01, // Length

)

IRQNoFlags ()

{1}

}

EndDependentFn ()

})

}

 

Device (PS2M)

{

Name (SYNP, 0x1290D94D)

Name (ALPS, 0x1190D94D)

Name (ALPT, "SNYALP0012")

Name (SNYA, "SNYSYN0004")

Method (_HID, 0, NotSerialized)

{

If (LAnd (And (SYSD, 0x04), 0x01))

{

If (LEqual (And (SYSD, 0x30), 0x00))

{

Return (SNYA)

}

Else

{

Return (ALPT)

}

}

Else

{

If (LEqual (And (SYSD, 0x30), 0x00))

{

Return (SYNP)

}

Else

{

Return (ALPS)

}

}

}

 

Name (_CID, EisaId ("PNP0F13"))

Name (_CRS, ResourceTemplate ()

{

IRQ (Edge, ActiveHigh, Exclusive, )

{12}

})

Name (_PRS, ResourceTemplate ()

{

StartDependentFn (0x00, 0x00)

{

IRQNoFlags ()

{12}

}

EndDependentFn ()

})

}

}

 

Device (USB1)

{

Name (_ADR, 0x001D0001)

OperationRegion (U1CS, PCI_Config, 0xC4, 0x04)

Field (U1CS, DWordAcc, NoLock, Preserve)

{

U1EN, 2

}

 

Method (_PSW, 1, NotSerialized)

{

If (Arg0)

{

Store (0x03, U1EN)

}

Else

{

Store (0x00, U1EN)

}

}

 

Method (_S3D, 0, NotSerialized)

{

Return (0x02)

}

 

Device (HUBN)

{

Name (_ADR, 0x00)

Device (PRT1)

{

Name (_ADR, 0x01)

Method (_DSM, 4, Serialized)

{

If (LEqual (Arg0, Buffer (0x10)

{

/* 0000 */ 0x8F, 0x70, 0xFC, 0xA5, 0x75, 0x87, 0xA6, 0x4B,

/* 0008 */ 0xBD, 0x0C, 0xBA, 0x90, 0xA1, 0xEC, 0x72, 0xF8

}))

{

Name (_T_0, Zero)

Store (ToInteger (Arg2), _T_0)

If (LEqual (_T_0, 0x00))

{

Name (_T_1, Zero)

Store (ToInteger (Arg1), _T_1)

If (LEqual (_T_1, 0x01))

{

Return (Buffer (0x01)

{

0x07

})

}

Else

{

Return (Buffer (0x01)

{

0x00

})

}

}

Else

{

If (LEqual (_T_0, 0x01))

{

Return (0x01)

}

Else

{

If (LEqual (_T_0, 0x02))

{

Return (SDGV)

}

Else

{

Return (0x00)

}

}

}

}

Else

{

Return (0x00)

}

}

}

 

Device (PRT2)

{

Name (_ADR, 0x02)

Method (_DSM, 4, Serialized)

{

If (LEqual (Arg0, Buffer (0x10)

{

/* 0000 */ 0x8F, 0x70, 0xFC, 0xA5, 0x75, 0x87, 0xA6, 0x4B,

/* 0008 */ 0xBD, 0x0C, 0xBA, 0x90, 0xA1, 0xEC, 0x72, 0xF8

}))

{

Name (_T_0, Zero)

Store (ToInteger (Arg2), _T_0)

If (LEqual (_T_0, 0x00))

{

Name (_T_1, Zero)

Store (ToInteger (Arg1), _T_1)

If (LEqual (_T_1, 0x01))

{

Return (Buffer (0x01)

{

0x07

})

}

Else

{

Return (Buffer (0x01)

{

0x00

})

}

}

Else

{

If (LEqual (_T_0, 0x01))

{

Return (0x01)

}

Else

{

If (LEqual (_T_0, 0x02))

{

Return (SDGV)

}

Else

{

Return (0x00)

}

}

}

}

Else

{

Return (0x00)

}

}

}

}

 

Method (_PRW, 0, NotSerialized)

{

Return (GPRW (0x03, 0x03))

}

}

 

Device (USB2)

{

Name (_ADR, 0x001D0002)

OperationRegion (U1CS, PCI_Config, 0xC4, 0x04)

Field (U1CS, DWordAcc, NoLock, Preserve)

{

U1EN, 2

}

 

Method (_PSW, 1, NotSerialized)

{

If (Arg0)

{

Store (0x03, U1EN)

}

Else

{

Store (0x00, U1EN)

}

}

 

Method (_S3D, 0, NotSerialized)

{

Return (0x02)

}

 

Device (HUBN)

{

Name (_ADR, 0x00)

Device (PRT1)

{

Name (_ADR, 0x01)

Method (_DSM, 4, Serialized)

{

If (LEqual (Arg0, Buffer (0x10)

{

/* 0000 */ 0x8F, 0x70, 0xFC, 0xA5, 0x75, 0x87, 0xA6, 0x4B,

/* 0008 */ 0xBD, 0x0C, 0xBA, 0x90, 0xA1, 0xEC, 0x72, 0xF8

}))

{

Name (_T_0, Zero)

Store (ToInteger (Arg2), _T_0)

If (LEqual (_T_0, 0x00))

{

Name (_T_1, Zero)

Store (ToInteger (Arg1), _T_1)

If (LEqual (_T_1, 0x01))

{

Return (Buffer (0x01)

{

0x07

})

}

Else

{

Return (Buffer (0x01)

{

0x00

})

}

}

Else

{

If (LEqual (_T_0, 0x01))

{

Return (0x01)

}

Else

{

If (LEqual (_T_0, 0x02))

{

Return (SDGV)

}

Else

{

Return (0x00)

}

}

}

}

Else

{

Return (0x00)

}

}

}

 

Device (PRT2)

{

Name (_ADR, 0x02)

Method (_DSM, 4, Serialized)

{

If (LEqual (Arg0, Buffer (0x10)

{

/* 0000 */ 0x8F, 0x70, 0xFC, 0xA5, 0x75, 0x87, 0xA6, 0x4B,

/* 0008 */ 0xBD, 0x0C, 0xBA, 0x90, 0xA1, 0xEC, 0x72, 0xF8

}))

{

Name (_T_0, Zero)

Store (ToInteger (Arg2), _T_0)

If (LEqual (_T_0, 0x00))

{

Name (_T_1, Zero)

Store (ToInteger (Arg1), _T_1)

If (LEqual (_T_1, 0x01))

{

Return (Buffer (0x01)

{

0x07

})

}

Else

{

Return (Buffer (0x01)

{

0x00

})

}

}

Else

{

If (LEqual (_T_0, 0x01))

{

Return (0x01)

}

Else

{

If (LEqual (_T_0, 0x02))

{

Return (SDGV)

}

Else

{

Return (0x00)

}

}

}

}

Else

{

Return (0x00)

}

}

}

}

 

Method (_PRW, 0, NotSerialized)

{

Return (GPRW (0x04, 0x03))

}

}

 

Device (USB3)

{

Name (_ADR, 0x001D0003)

OperationRegion (U1CS, PCI_Config, 0xC4, 0x04)

Field (U1CS, DWordAcc, NoLock, Preserve)

{

U1EN, 2

}

 

Method (_PSW, 1, NotSerialized)

{

If (Arg0)

{

Store (0x03, U1EN)

}

Else

{

Store (0x00, U1EN)

}

}

 

Method (_S3D, 0, NotSerialized)

{

Return (0x02)

}

 

Device (HUBN)

{

Name (_ADR, 0x00)

Device (PRT1)

{

Name (_ADR, 0x01)

Method (_DSM, 4, Serialized)

{

If (LEqual (Arg0, Buffer (0x10)

{

/* 0000 */ 0x8F, 0x70, 0xFC, 0xA5, 0x75, 0x87, 0xA6, 0x4B,

/* 0008 */ 0xBD, 0x0C, 0xBA, 0x90, 0xA1, 0xEC, 0x72, 0xF8

}))

{

Name (_T_0, Zero)

Store (ToInteger (Arg2), _T_0)

If (LEqual (_T_0, 0x00))

{

Name (_T_1, Zero)

Store (ToInteger (Arg1), _T_1)

If (LEqual (_T_1, 0x01))

{

Return (Buffer (0x01)

{

0x07

})

}

Else

{

Return (Buffer (0x01)

{

0x00

})

}

}

Else

{

If (LEqual (_T_0, 0x01))

{

Return (0x01)

}

Else

{

If (LEqual (_T_0, 0x02))

{

Return (SDGV)

}

Else

{

Return (0x00)

}

}

}

}

Else

{

Return (0x00)

}

}

}

 

Device (PRT2)

{

Name (_ADR, 0x02)

Method (_DSM, 4, Serialized)

{

If (LEqual (Arg0, Buffer (0x10)

{

/* 0000 */ 0x8F, 0x70, 0xFC, 0xA5, 0x75, 0x87, 0xA6, 0x4B,

/* 0008 */ 0xBD, 0x0C, 0xBA, 0x90, 0xA1, 0xEC, 0x72, 0xF8

}))

{

Name (_T_0, Zero)

Store (ToInteger (Arg2), _T_0)

If (LEqual (_T_0, 0x00))

{

Name (_T_1, Zero)

Store (ToInteger (Arg1), _T_1)

If (LEqual (_T_1, 0x01))

{

Return (Buffer (0x01)

{

0x07

})

}

Else

{

Return (Buffer (0x01)

{

0x00

})

}

}

Else

{

If (LEqual (_T_0, 0x01))

{

Return (0x01)

}

Else

{

If (LEqual (_T_0, 0x02))

{

Return (SDGV)

}

Else

{

Return (0x00)

}

}

}

}

Else

{

Return (0x00)

}

}

}

}

 

Method (_PRW, 0, NotSerialized)

{

Return (GPRW (0x0C, 0x03))

}

}

 

Device (USB4)

{

Name (_ADR, 0x001D0004)

OperationRegion (U1CS, PCI_Config, 0xC4, 0x04)

Field (U1CS, DWordAcc, NoLock, Preserve)

{

U1EN, 2

}

 

Method (_PSW, 1, NotSerialized)

{

If (Arg0)

{

Store (0x03, U1EN)

}

Else

{

Store (0x00, U1EN)

}

}

 

Method (_S3D, 0, NotSerialized)

{

Return (0x02)

}

 

Device (HUBN)

{

Name (_ADR, 0x00)

Device (PRT1)

{

Name (_ADR, 0x01)

Method (_DSM, 4, Serialized)

{

If (LEqual (Arg0, Buffer (0x10)

{

/* 0000 */ 0x8F, 0x70, 0xFC, 0xA5, 0x75, 0x87, 0xA6, 0x4B,

/* 0008 */ 0xBD, 0x0C, 0xBA, 0x90, 0xA1, 0xEC, 0x72, 0xF8

}))

{

Name (_T_0, Zero)

Store (ToInteger (Arg2), _T_0)

If (LEqual (_T_0, 0x00))

{

Name (_T_1, Zero)

Store (ToInteger (Arg1), _T_1)

If (LEqual (_T_1, 0x01))

{

Return (Buffer (0x01)

{

0x07

})

}

Else

{

Return (Buffer (0x01)

{

0x00

})

}

}

Else

{

If (LEqual (_T_0, 0x01))

{

Return (0x01)

}

Else

{

If (LEqual (_T_0, 0x02))

{

Return (SDGV)

}

Else

{

Return (0x00)

}

}

}

}

Else

{

Return (0x00)

}

}

}

 

Device (PRT2)

{

Name (_ADR, 0x02)

Method (_DSM, 4, Serialized)

{

If (LEqual (Arg0, Buffer (0x10)

{

/* 0000 */ 0x8F, 0x70, 0xFC, 0xA5, 0x75, 0x87, 0xA6, 0x4B,

/* 0008 */ 0xBD, 0x0C, 0xBA, 0x90, 0xA1, 0xEC, 0x72, 0xF8

}))

{

Name (_T_0, Zero)

Store (ToInteger (Arg2), _T_0)

If (LEqual (_T_0, 0x00))

{

Name (_T_1, Zero)

Store (ToInteger (Arg1), _T_1)

If (LEqual (_T_1, 0x01))

{

Return (Buffer (0x01)

{

0x07

})

}

Else

{

Return (Buffer (0x01)

{

0x00

})

}

}

Else

{

If (LEqual (_T_0, 0x01))

{

Return (0x01)

}

Else

{

If (LEqual (_T_0, 0x02))

{

Return (SDGV)

}

Else

{

Return (0x00)

}

}

}

}

Else

{

Return (0x00)

}

}

}

}

 

Method (_PRW, 0, NotSerialized)

{

Return (GPRW (0x0E, 0x03))

}

}

 

Device (USB5)

{

Name (_ADR, 0x001A0001)

OperationRegion (U1CS, PCI_Config, 0xC4, 0x04)

Field (U1CS, DWordAcc, NoLock, Preserve)

{

U1EN, 2

}

 

Method (_PSW, 1, NotSerialized)

{

If (Arg0)

{

Store (0x03, U1EN)

}

Else

{

Store (0x00, U1EN)

}

}

 

Method (_S3D, 0, NotSerialized)

{

Return (0x02)

}

 

Device (HUBN)

{

Name (_ADR, 0x00)

Device (PRT1)

{

Name (_ADR, 0x01)

Method (_DSM, 4, Serialized)

{

If (LEqual (Arg0, Buffer (0x10)

{

/* 0000 */ 0x8F, 0x70, 0xFC, 0xA5, 0x75, 0x87, 0xA6, 0x4B,

/* 0008 */ 0xBD, 0x0C, 0xBA, 0x90, 0xA1, 0xEC, 0x72, 0xF8

}))

{

Name (_T_0, Zero)

Store (ToInteger (Arg2), _T_0)

If (LEqual (_T_0, 0x00))

{

Name (_T_1, Zero)

Store (ToInteger (Arg1), _T_1)

If (LEqual (_T_1, 0x01))

{

Return (Buffer (0x01)

{

0x07

})

}

Else

{

Return (Buffer (0x01)

{

0x00

})

}

}

Else

{

If (LEqual (_T_0, 0x01))

{

Return (0x01)

}

Else

{

If (LEqual (_T_0, 0x02))

{

Return (SDGV)

}

Else

{

Return (0x00)

}

}

}

}

Else

{

Return (0x00)

}

}

}

 

Device (PRT2)

{

Name (_ADR, 0x02)

Method (_DSM, 4, Serialized)

{

If (LEqual (Arg0, Buffer (0x10)

{

/* 0000 */ 0x8F, 0x70, 0xFC, 0xA5, 0x75, 0x87, 0xA6, 0x4B,

/* 0008 */ 0xBD, 0x0C, 0xBA, 0x90, 0xA1, 0xEC, 0x72, 0xF8

}))

{

Name (_T_0, Zero)

Store (ToInteger (Arg2), _T_0)

If (LEqual (_T_0, 0x00))

{

Name (_T_1, Zero)

Store (ToInteger (Arg1), _T_1)

If (LEqual (_T_1, 0x01))

{

Return (Buffer (0x01)

{

0x07

})

}

Else

{

Return (Buffer (0x01)

{

0x00

})

}

}

Else

{

If (LEqual (_T_0, 0x01))

{

Return (0x01)

}

Else

{

If (LEqual (_T_0, 0x02))

{

Return (SDGV)

}

Else

{

Return (0x00)

}

}

}

}

Else

{

Return (0x00)

}

}

}

}

 

Method (_PRW, 0, NotSerialized)

{

Return (GPRW (0x05, 0x03))

}

}

 

Device (USB6)

{

Name (_ADR, 0x001A0002)

OperationRegion (U1CS, PCI_Config, 0xC4, 0x04)

Field (U1CS, DWordAcc, NoLock, Preserve)

{

U1EN, 2

}

 

Method (_PSW, 1, NotSerialized)

{

If (Arg0)

{

Store (0x03, U1EN)

}

Else

{

Store (0x00, U1EN)

}

}

 

Method (_S3D, 0, NotSerialized)

{

Return (0x02)

}

 

Device (HUBN)

{

Name (_ADR, 0x00)

Device (PRT1)

{

Name (_ADR, 0x01)

Method (_DSM, 4, Serialized)

{

If (LEqual (Arg0, Buffer (0x10)

{

/* 0000 */ 0x8F, 0x70, 0xFC, 0xA5, 0x75, 0x87, 0xA6, 0x4B,

/* 0008 */ 0xBD, 0x0C, 0xBA, 0x90, 0xA1, 0xEC, 0x72, 0xF8

}))

{

Name (_T_0, Zero)

Store (ToInteger (Arg2), _T_0)

If (LEqual (_T_0, 0x00))

{

Name (_T_1, Zero)

Store (ToInteger (Arg1), _T_1)

If (LEqual (_T_1, 0x01))

{

Return (Buffer (0x01)

{

0x07

})

}

Else

{

Return (Buffer (0x01)

{

0x00

})

}

}

Else

{

If (LEqual (_T_0, 0x01))

{

Return (0x01)

}

Else

{

If (LEqual (_T_0, 0x02))

{

Return (SDGV)

}

Else

{

Return (0x00)

}

}

}

}

Else

{

Return (0x00)

}

}

}

 

Device (PRT2)

{

Name (_ADR, 0x02)

Method (_DSM, 4, Serialized)

{

If (LEqual (Arg0, Buffer (0x10)

{

/* 0000 */ 0x8F, 0x70, 0xFC, 0xA5, 0x75, 0x87, 0xA6, 0x4B,

/* 0008 */ 0xBD, 0x0C, 0xBA, 0x90, 0xA1, 0xEC, 0x72, 0xF8

}))

{

Name (_T_0, Zero)

Store (ToInteger (Arg2), _T_0)

If (LEqual (_T_0, 0x00))

{

Name (_T_1, Zero)

Store (ToInteger (Arg1), _T_1)

If (LEqual (_T_1, 0x01))

{

Return (Buffer (0x01)

{

0x07

})

}

Else

{

Return (Buffer (0x01)

{

0x00

})

}

}

Else

{

If (LEqual (_T_0, 0x01))

{

Return (0x01)

}

Else

{

If (LEqual (_T_0, 0x02))

{

Return (SDGV)

}

Else

{

Return (0x00)

}

}

}

}

Else

{

Return (0x00)

}

}

}

}

 

Method (_PRW, 0, NotSerialized)

{

Return (GPRW (0x20, 0x03))

}

}

 

Device (USB7)

{

Name (_ADR, 0x001A0003)

OperationRegion (U1CS, PCI_Config, 0xC4, 0x04)

Field (U1CS, DWordAcc, NoLock, Preserve)

{

U1EN, 2

}

 

Method (_PSW, 1, NotSerialized)

{

If (Arg0)

{

Store (0x03, U1EN)

}

Else

{

Store (0x00, U1EN)

}

}

 

Method (_S3D, 0, NotSerialized)

{

Return (0x02)

}

 

Device (HUBN)

{

Name (_ADR, 0x00)

Device (PRT1)

{

Name (_ADR, 0x01)

Method (_DSM, 4, Serialized)

{

If (LEqual (Arg0, Buffer (0x10)

{

/* 0000 */ 0x8F, 0x70, 0xFC, 0xA5, 0x75, 0x87, 0xA6, 0x4B,

/* 0008 */ 0xBD, 0x0C, 0xBA, 0x90, 0xA1, 0xEC, 0x72, 0xF8

}))

{

Name (_T_0, Zero)

Store (ToInteger (Arg2), _T_0)

If (LEqual (_T_0, 0x00))

{

Name (_T_1, Zero)

Store (ToInteger (Arg1), _T_1)

If (LEqual (_T_1, 0x01))

{

Return (Buffer (0x01)

{

0x07

})

}

Else

{

Return (Buffer (0x01)

{

0x00

})

}

}

Else

{

If (LEqual (_T_0, 0x01))

{

Return (0x01)

}

Else

{

If (LEqual (_T_0, 0x02))

{

Return (SDGV)

}

Else

{

Return (0x00)

}

}

}

}

Else

{

Return (0x00)

}

}

}

 

Device (PRT2)

{

Name (_ADR, 0x02)

Method (_DSM, 4, Serialized)

{

If (LEqual (Arg0, Buffer (0x10)

{

/* 0000 */ 0x8F, 0x70, 0xFC, 0xA5, 0x75, 0x87, 0xA6, 0x4B,

/* 0008 */ 0xBD, 0x0C, 0xBA, 0x90, 0xA1, 0xEC, 0x72, 0xF8

}))

{

Name (_T_0, Zero)

Store (ToInteger (Arg2), _T_0)

If (LEqual (_T_0, 0x00))

{

Name (_T_1, Zero)

Store (ToInteger (Arg1), _T_1)

If (LEqual (_T_1, 0x01))

{

Return (Buffer (0x01)

{

0x07

})

}

Else

{

Return (Buffer (0x01)

{

0x00

})

}

}

Else

{

If (LEqual (_T_0, 0x01))

{

Return (0x01)

}

Else

{

If (LEqual (_T_0, 0x02))

{

Return (SDGV)

}

Else

{

Return (0x00)

}

}

}

}

Else

{

Return (0x00)

}

}

}

}

 

Method (_PRW, 0, NotSerialized)

{

Return (GPRW (0x25, 0x03))

}

}

 

Device (HDEF)

{

Name (_ADR, 0x001B0000)

OperationRegion (HDAR, PCI_Config, 0x4C, 0x10)

Field (HDAR, WordAcc, NoLock, Preserve)

{

DCKA, 1,

Offset (0x01),

DCKM, 1,

, 6,

DCKS, 1,

Offset (0x08),

, 15,

PMES, 1

}

 

Method (_PRW, 0, NotSerialized)

{

Return (GPRW (0x0D, 0x04))

}

}

 

Device (RP01)

{

Name (_ADR, 0x001C0000)

OperationRegion (PXCS, PCI_Config, 0x40, 0xC0)

Field (PXCS, AnyAcc, NoLock, WriteAsZeros)

{

Offset (0x12),

, 13,

LASX, 1,

Offset (0x1A),

ABPX, 1,

, 2,

PDCX, 1,

, 2,

PDSX, 1,

Offset (0x1B),

LSCX, 1,

Offset (0x20),

Offset (0x22),

PSPX, 1,

Offset (0x98),

, 30,

HPEX, 1,

PMEX, 1,

, 30,

HPSX, 1,

PMSX, 1

}

 

Method (_PRW, 0, NotSerialized)

{

Return (GPRW (0x09, 0x03))

}

 

Device (PXSX)

{

Name (_ADR, 0x00)

Name (_PRW, Package (0x02)

{

0x09,

0x03

})

}

 

Method (_PRT, 0, NotSerialized)

{

If (PICM)

{

Return (AR02 ())

}

 

Return (PR02 ())

}

}

 

Device (RP03)

{

Name (_ADR, 0x001C0002)

OperationRegion (PXCS, PCI_Config, 0x40, 0xC0)

Field (PXCS, AnyAcc, NoLock, WriteAsZeros)

{

Offset (0x12),

, 13,

LASX, 1,

Offset (0x1A),

ABPX, 1,

, 2,

PDCX, 1,

, 2,

PDSX, 1,

Offset (0x1B),

LSCX, 1,

Offset (0x20),

Offset (0x22),

PSPX, 1,

Offset (0x98),

, 30,

HPEX, 1,

PMEX, 1,

, 30,

HPSX, 1,

PMSX, 1

}

 

Method (_PRW, 0, NotSerialized)

{

Return (GPRW (0x09, 0x03))

}

 

Device (PXSX)

{

Name (_ADR, 0x00)

Name (_PRW, Package (0x02)

{

0x09,

0x03

})

}

 

Method (_PRT, 0, NotSerialized)

{

If (PICM)

{

Return (AR04 ())

}

 

Return (PR04 ())

}

}

 

Device (IO10)

{

Name (_ADR, 0x00080000)

OperationRegion (IBUS, PCI_Config, 0xD0, 0xE0)

Field (IBUS, DWordAcc, NoLock, Preserve)

{

, 26,

TOLM, 6,

, 26,

TOHM, 38,

Offset (0xB0),

VTEN, 1,

, 11,

VTBA, 20

}

}

 

Device (IO1X)

{

Name (_ADR, 0x00080001)

OperationRegion (PBIC, PCI_Config, 0x00, 0xF0)

Field (PBIC, DWordAcc, NoLock, Preserve)

{

Offset (0x7C),

SR0, 32,

SR1, 32,

SR2, 32,

SR3, 32,

SR4, 32,

SR5, 32,

SR6, 32,

SR7, 32,

SR8, 32,

SR9, 32

}

}

 

Device (IIO0)

{

Name (_ADR, 0x00140000)

OperationRegion (IBUS, PCI_Config, 0xD0, 0xE0)

Field (IBUS, DWordAcc, NoLock, Preserve)

{

, 26,

TOLM, 6,

, 26,

TOHM, 38,

Offset (0xB0),

VTEN, 1,

, 11,

VTBA, 20

}

}

 

Device (IIOX)

{

Name (_ADR, 0x00140001)

OperationRegion (PBIC, PCI_Config, 0x00, 0xF0)

Field (PBIC, DWordAcc, NoLock, Preserve)

{

Offset (0x7C),

SR0, 32,

SR1, 32,

SR2, 32,

SR3, 32,

SR4, 32,

SR5, 32,

SR6, 32,

SR7, 32,

SR8, 32,

SR9, 32

}

}

 

Device (RP02)

{

Name (_ADR, 0x001C0001)

OperationRegion (PXCS, PCI_Config, 0x40, 0xC0)

Field (PXCS, AnyAcc, NoLock, WriteAsZeros)

{

Offset (0x12),

, 13,

LASX, 1,

Offset (0x1A),

ABPX, 1,

, 2,

PDCX, 1,

, 2,

PDSX, 1,

Offset (0x1B),

LSCX, 1,

Offset (0x20),

Offset (0x22),

PSPX, 1,

Offset (0x98),

, 30,

HPEX, 1,

PMEX, 1,

, 30,

HPSX, 1,

PMSX, 1

}

 

Method (_PRT, 0, NotSerialized)

{

If (PICM)

{

Return (AR03 ())

}

 

Return (PR03 ())

}

 

Device (SDD1)

{

Name (_ADR, 0x00)

OperationRegion (P0CS, PCI_Config, 0x00, 0x10)

Field (P0CS, AnyAcc, NoLock, Preserve)

{

RVID, 16,

RDID, 16

}

 

Method (_STA, 0, Serialized)

{

Return (0x0B)

}

 

Method (_RMV, 0, Serialized)

{

Return (0x00)

}

}

 

Device (MSDD)

{

Name (_ADR, 0x01)

OperationRegion (P1CS, PCI_Config, 0x00, 0x10)

Field (P1CS, AnyAcc, NoLock, Preserve)

{

RVID, 16,

RDID, 16

}

 

Method (_RMV, 0, Serialized)

{

Return (0x00)

}

}

 

Device (SDD2)

{

Name (_ADR, 0x04)

OperationRegion (P4CS, PCI_Config, 0x00, 0x10)

Field (P4CS, AnyAcc, NoLock, Preserve)

{

RVID, 16,

RDID, 16

}

 

Method (_RMV, 0, Serialized)

{

Return (0x00)

}

}

}

 

Device (EHC1)

{

Name (_ADR, 0x001D0000)

OperationRegion (U1CS, PCI_Config, 0xC4, 0x04)

Field (U1CS, DWordAcc, NoLock, Preserve)

{

U1EN, 2

}

 

Method (_PSW, 1, NotSerialized)

{

If (Arg0)

{

Store (0x03, U1EN)

}

Else

{

Store (0x00, U1EN)

}

}

 

Method (_S3D, 0, NotSerialized)

{

Return (0x02)

}

 

Name (PLDT, Buffer (0x10) {})

CreateField (PLDT, 0x00, 0x20, DW00)

CreateField (PLDT, 0x20, 0x20, DW01)

CreateField (PLDT, 0x40, 0x20, DW02)

CreateField (PLDT, 0x60, 0x20, DW03)

Device (RHUB)

{

Name (_ADR, 0x00)

Device (IHUB)

{

Name (_ADR, 0x01)

Name (_UPC, Package (0x04)

{

0x00,

0xFF,

0x00,

0x00

})

Device (PRT1)

{

Name (_ADR, 0x01)

Name (_UPC, Package (0x04)

{

0xFF,

0x00,

0x00,

0x00

})

Method (_PLD, 0, NotSerialized)

{

Store (0x82, DW00)

Store (0x00060013, DW01)

Store (0x1251, DW02)

Store (0x03, DW03)

Return (PLDT)

}

}

 

Device (PRT2)

{

Name (_ADR, 0x02)

Name (_UPC, Package (0x04)

{

0xFF,

0x00,

0x00,

0x00

})

Method (_PLD, 0, NotSerialized)

{

Store (0x82, DW00)

Store (0x0005000D, DW01)

Store (0x1159, DW02)

Store (0x03, DW03)

Return (PLDT)

}

}

 

Device (PRT3)

{

Name (_ADR, 0x03)

Name (_UPC, Package (0x04)

{

0x00,

0xFF,

0x00,

0x00

})

}

 

Device (PRT4)

{

Name (_ADR, 0x04)

Name (_UPC, Package (0x04)

{

0xFF,

0x02,

0x00,

0x00

})

Method (_PLD, 0, NotSerialized)

{

Store (0x82, DW00)

Store (0x00050023, DW01)

Store (0x1251, DW02)

Store (0x03, DW03)

Return (PLDT)

}

}

 

Device (PRT5)

{

Name (_ADR, 0x05)

Name (_UPC, Package (0x04)

{

0xFF,

0x00,

0x00,

0x00

})

Method (_PLD, 0, NotSerialized)

{

Store (0x82, DW00)

Store (0x0005000D, DW01)

Store (0x1159, DW02)

Store (0x03, DW03)

Return (PLDT)

}

}

 

Device (PRT6)

{

Name (_ADR, 0x06)

Name (_UPC, Package (0x04)

{

0xFF,

0x00,

0x00,

0x00

})

Method (_PLD, 0, NotSerialized)

{

Store (0x82, DW00)

Store (0x0005000D, DW01)

Store (0x1159, DW02)

Store (0x03, DW03)

Return (PLDT)

}

}

}

}

 

Method (_PRW, 0, NotSerialized)

{

Return (GPRW (0x0D, 0x03))

}

}

 

Device (EHC2)

{

Name (_ADR, 0x001A0000)

OperationRegion (U1CS, PCI_Config, 0xC4, 0x04)

Field (U1CS, DWordAcc, NoLock, Preserve)

{

U1EN, 2

}

 

Method (_PSW, 1, NotSerialized)

{

If (Arg0)

{

Store (0x03, U1EN)

}

Else

{

Store (0x00, U1EN)

}

}

 

Method (_S3D, 0, NotSerialized)

{

Return (0x02)

}

 

Name (PLDT, Buffer (0x10) {})

CreateField (PLDT, 0x00, 0x20, DW00)

CreateField (PLDT, 0x20, 0x20, DW01)

CreateField (PLDT, 0x40, 0x20, DW02)

CreateField (PLDT, 0x60, 0x20, DW03)

Device (RHUB)

{

Name (_ADR, 0x00)

Device (IHUB)

{

Name (_ADR, 0x01)

Name (_UPC, Package (0x04)

{

0x00,

0xFF,

0x00,

0x00

})

Device (PRT1)

{

Name (_ADR, 0x01)

Name (_UPC, Package (0x04)

{

0x00,

0xFF,

0x00,

0x00

})

}

 

Device (PRT2)

{

Name (_ADR, 0x02)

Name (_UPC, Package (0x04)

{

0xFF,

0x00,

0x00,

0x00

})

Method (_PLD, 0, NotSerialized)

{

Store (0x82, DW00)

Store (0x00, DW01)

Store (0x00, DW02)

Store (0x00, DW03)

Return (PLDT)

}

}

 

Device (PRT3)

{

Name (_ADR, 0x03)

Name (_UPC, Package (0x04)

{

0x00,

0xFF,

0x00,

0x00

})

}

 

Device (PRT4)

{

Name (_ADR, 0x04)

Name (_UPC, Package (0x04)

{

0xFF,

0x00,

0x00,

0x00

})

Method (_PLD, 0, NotSerialized)

{

Store (0x82, DW00)

Store (0x00, DW01)

Store (0x00, DW02)

Store (0x00, DW03)

Return (PLDT)

}

}

 

Device (PRT5)

{

Name (_ADR, 0x05)

Name (_UPC, Package (0x04)

{

0xFF,

0x00,

0x00,

0x00

})

Method (_PLD, 0, NotSerialized)

{

Store (0x82, DW00)

Store (0x00, DW01)

Store (0x00, DW02)

Store (0x00, DW03)

Return (PLDT)

}

}

 

Device (PRT6)

{

Name (_ADR, 0x06)

Name (_UPC, Package (0x04)

{

0xFF,

0x00,

0x00,

0x00

})

Method (_PLD, 0, NotSerialized)

{

Store (0x82, DW00)

Store (0x00, DW01)

Store (0x00, DW02)

Store (0x00, DW03)

Return (PLDT)

}

}

}

}

 

Method (_PRW, 0, NotSerialized)

{

Return (GPRW (0x0D, 0x03))

}

}

 

Device (GFX0)

{

Name (_ADR, 0x00020000)

Method (PCPC, 0, NotSerialized)

{

\ECST (0x6F)

}

 

Method (_DOS, 1, NotSerialized)

{

Store (And (Arg0, 0x07), DSEN)

}

 

Method (_DOD, 0, NotSerialized)

{

Store (0x00, NDID)

If (CondRefOf (IDAB))

{

IDAB ()

}

Else

{

If (LNotEqual (DIDL, Zero))

{

Store (SDDL (DID1), DID1)

}

 

If (LNotEqual (DDL2, Zero))

{

Store (SDDL (DID2), DID2)

}

 

If (LNotEqual (DDL3, Zero))

{

Store (SDDL (DID3), DID3)

}

 

If (LNotEqual (DDL4, Zero))

{

Store (SDDL (DID4), DID4)

}

 

If (LNotEqual (DDL5, Zero))

{

Store (SDDL (DID5), DID5)

}

}

 

If (LEqual (NDID, 0x01))

{

Name (TMP1, Package (0x01)

{

0xFFFFFFFF

})

Store (Or (0x00010000, DID1), Index (TMP1, 0x00))

Return (TMP1)

}

 

If (LEqual (NDID, 0x02))

{

Name (TMP2, Package (0x02)

{

0xFFFFFFFF,

0xFFFFFFFF

})

Store (Or (0x00010000, DID1), Index (TMP2, 0x00))

Store (Or (0x00010000, DID2), Index (TMP2, 0x01))

Return (TMP2)

}

 

If (LEqual (NDID, 0x03))

{

Name (TMP3, Package (0x03)

{

0xFFFFFFFF,

0xFFFFFFFF,

0xFFFFFFFF

})

Store (Or (0x00010000, DID1), Index (TMP3, 0x00))

Store (Or (0x00010000, DID2), Index (TMP3, 0x01))

Store (Or (0x00010000, DID3), Index (TMP3, 0x02))

Return (TMP3)

}

 

If (LEqual (NDID, 0x04))

{

Name (TMP4, Package (0x04)

{

0xFFFFFFFF,

0xFFFFFFFF,

0xFFFFFFFF,

0xFFFFFFFF

})

Store (Or (0x00010000, DID1), Index (TMP4, 0x00))

Store (Or (0x00010000, DID2), Index (TMP4, 0x01))

Store (Or (0x00010000, DID3), Index (TMP4, 0x02))

Store (Or (0x00010000, DID4), Index (TMP4, 0x03))

Return (TMP4)

}

 

If (CondRefOf (NNAB))

{

Return (NNAB)

}

Else

{

If (LGreater (NDID, 0x04))

{

Name (TMP5, Package (0x05)

{

0xFFFFFFFF,

0xFFFFFFFF,

0xFFFFFFFF,

0xFFFFFFFF,

0xFFFFFFFF

})

Store (Or (0x00010000, DID1), Index (TMP5, 0x00))

Store (Or (0x00010000, DID2), Index (TMP5, 0x01))

Store (Or (0x00010000, DID3), Index (TMP5, 0x02))

Store (Or (0x00010000, DID4), Index (TMP5, 0x03))

Store (Or (0x00010000, DID5), Index (TMP5, 0x04))

Return (TMP5)

}

}

 

Return (Package (0x01)

{

0x0400

})

}

 

Name (RTL0, Buffer (0x09)

{

/* 0000 */ 0x0D, 0x13, 0x1C, 0x29, 0x3B, 0x55, 0x7B, 0xB1,

/* 0008 */ 0xFF

})

Name (ICL0, Package (0x0B)

{

0x64,

0x64,

0x05,

0x08,

0x0B,

0x10,

0x17,

0x22,

0x30,

0x46,

0x64

})

Name (RTL1, Buffer (0x09)

{

/* 0000 */ 0x37, 0x3E, 0x4B, 0x5C, 0x6F, 0x86, 0xA0, 0xC3,

/* 0008 */ 0xFF

})

Name (ICL1, Package (0x0B)

{

0x64,

0x64,

0x15,

0x18,

0x1D,

0x24,

0x2C,

0x35,

0x3F,

0x4C,

0x64

})

Device (DD01)

{

Method (_ADR, 0, Serialized)

{

If (LEqual (DID1, 0x00))

{

Return (0x01)

}

Else

{

Return (And (0xFFFF, DID1))

}

}

 

Method (_DCS, 0, NotSerialized)

{

Return (CDDS (DID1))

}

 

Method (_DGS, 0, NotSerialized)

{

Return (NDDS (DID1))

}

 

Method (_DSS, 1, NotSerialized)

{

If (LEqual (And (Arg0, 0xC0000000), 0xC0000000))

{

Store (NSTE, CSTE)

}

}

}

 

Device (DD02)

{

Method (_ADR, 0, Serialized)

{

If (LEqual (DID2, 0x00))

{

Return (0x02)

}

Else

{

Return (And (0xFFFF, DID2))

}

}

 

Method (_DCS, 0, NotSerialized)

{

Return (CDDS (DID2))

}

 

Method (_DGS, 0, NotSerialized)

{

Return (NDDS (DID2))

}

 

Method (_DSS, 1, NotSerialized)

{

If (LEqual (And (Arg0, 0xC0000000), 0xC0000000))

{

Store (NSTE, CSTE)

}

}

 

Method (_BCL, 0, NotSerialized)

{

Name (_T_0, Zero)

Store (ToInteger (PNID), _T_0)

If (LEqual (_T_0, 0x05))

{

Return (ICL1)

}

Else

{

If (LEqual (_T_0, 0x06))

{

Return (ICL1)

}

Else

{

If (LEqual (_T_0, 0x07))

{

Return (ICL1)

}

Else

{

If (LEqual (_T_0, 0x08))

{

Return (ICL1)

}

Else

{

Return (ICL0)

}

}

}

}

}

 

Method (_BCM, 1, NotSerialized)

{

If (LAnd (LGreater (PNID, 0x04), LLess (PNID, 0x09)))

{

Store (Subtract (Match (ICL1, MEQ, Arg0, MTR, 0x00, 0x02), 0x02

), Local0)

Store (DerefOf (Index (RTL1, Local0)), Local0)

}

Else

{

Store (Subtract (Match (ICL0, MEQ, Arg0, MTR, 0x00, 0x02), 0x02

), Local0)

Store (DerefOf (Index (RTL0, Local0)), Local0)

}

 

\_SB.PCI0.GFX0.AINT (0x01, Local0)

Store (Arg0, BRTL)

}

 

Method (_BQC, 0, NotSerialized)

{

Return (BRTL)

}

}

 

Device (DD03)

{

Method (_ADR, 0, Serialized)

{

If (LEqual (DID3, 0x00))

{

Return (0x03)

}

Else

{

Return (And (0xFFFF, DID3))

}

}

 

Method (_DCS, 0, NotSerialized)

{

If (LEqual (DID3, 0x00))

{

Return (0x0B)

}

Else

{

Return (CDDS (DID3))

}

}

 

Method (_DGS, 0, NotSerialized)

{

Return (NDDS (DID3))

}

 

Method (_DSS, 1, NotSerialized)

{

If (LEqual (And (Arg0, 0xC0000000), 0xC0000000))

{

Store (NSTE, CSTE)

}

}

}

 

Device (DD04)

{

Method (_ADR, 0, Serialized)

{

If (LEqual (DID4, 0x00))

{

Return (0x04)

}

Else

{

Return (And (0xFFFF, DID4))

}

}

 

Method (_DCS, 0, NotSerialized)

{

If (LEqual (DID4, 0x00))

{

Return (0x0B)

}

Else

{

Return (CDDS (DID4))

}

}

 

Method (_DGS, 0, NotSerialized)

{

Return (NDDS (DID4))

}

 

Method (_DSS, 1, NotSerialized)

{

If (LEqual (And (Arg0, 0xC0000000), 0xC0000000))

{

Store (NSTE, CSTE)

}

}

}

 

Device (DD05)

{

Method (_ADR, 0, Serialized)

{

If (LEqual (DID5, 0x00))

{

Return (0x05)

}

Else

{

Return (And (0xFFFF, DID5))

}

}

 

Method (_DCS, 0, NotSerialized)

{

If (LEqual (DID5, 0x00))

{

Return (0x0B)

}

Else

{

Return (CDDS (DID5))

}

}

 

Method (_DGS, 0, NotSerialized)

{

Return (NDDS (DID5))

}

 

Method (_DSS, 1, NotSerialized)

{

If (LEqual (And (Arg0, 0xC0000000), 0xC0000000))

{

Store (NSTE, CSTE)

}

}

}

 

Device (DD06)

{

Method (_ADR, 0, Serialized)

{

If (LEqual (DID6, 0x00))

{

Return (0x06)

}

Else

{

Return (And (0xFFFF, DID6))

}

}

 

Method (_DCS, 0, NotSerialized)

{

If (LEqual (DID6, 0x00))

{

Return (0x0B)

}

Else

{

Return (CDDS (DID6))

}

}

 

Method (_DGS, 0, NotSerialized)

{

Return (NDDS (DID6))

}

 

Method (_DSS, 1, NotSerialized)

{

If (LEqual (And (Arg0, 0xC0000000), 0xC0000000))

{

Store (NSTE, CSTE)

}

}

}

 

Device (DD07)

{

Method (_ADR, 0, Serialized)

{

If (LEqual (DID7, 0x00))

{

Return (0x07)

}

Else

{

Return (And (0xFFFF, DID7))

}

}

 

Method (_DCS, 0, NotSerialized)

{

If (LEqual (DID7, 0x00))

{

Return (0x0B)

}

Else

{

Return (CDDS (DID7))

}

}

 

Method (_DGS, 0, NotSerialized)

{

Return (NDDS (DID7))

}

 

Method (_DSS, 1, NotSerialized)

{

If (LEqual (And (Arg0, 0xC0000000), 0xC0000000))

{

Store (NSTE, CSTE)

}

}

}

 

Device (DD08)

{

Method (_ADR, 0, Serialized)

{

If (LEqual (DID8, 0x00))

{

Return (0x08)

}

Else

{

Return (And (0xFFFF, DID8))

}

}

 

Method (_DCS, 0, NotSerialized)

{

If (LEqual (DID8, 0x00))

{

Return (0x0B)

}

Else

{

Return (CDDS (DID8))

}

}

 

Method (_DGS, 0, NotSerialized)

{

Return (NDDS (DID8))

}

 

Method (_DSS, 1, NotSerialized)

{

If (LEqual (And (Arg0, 0xC0000000), 0xC0000000))

{

Store (NSTE, CSTE)

}

}

}

 

Method (SDDL, 1, NotSerialized)

{

Increment (NDID)

Store (And (Arg0, 0x0F0F), Local0)

Or (0x80000000, Local0, Local1)

If (LEqual (DIDL, Local0))

{

Return (Local1)

}

 

If (LEqual (DDL2, Local0))

{

Return (Local1)

}

 

If (LEqual (DDL3, Local0))

{

Return (Local1)

}

 

If (LEqual (DDL4, Local0))

{

Return (Local1)

}

 

If (LEqual (DDL5, Local0))

{

Return (Local1)

}

 

If (LEqual (DDL6, Local0))

{

Return (Local1)

}

 

If (LEqual (DDL7, Local0))

{

Return (Local1)

}

 

If (LEqual (DDL8, Local0))

{

Return (Local1)

}

 

Return (0x00)

}

 

Method (CDDS, 1, NotSerialized)

{

Store (And (Arg0, 0x0F0F), Local0)

If (LEqual (0x00, Local0))

{

Return (0x1D)

}

 

If (LEqual (CADL, Local0))

{

Return (0x1F)

}

 

If (LEqual (CAL2, Local0))

{

Return (0x1F)

}

 

If (LEqual (CAL3, Local0))

{

Return (0x1F)

}

 

If (LEqual (CAL4, Local0))

{

Return (0x1F)

}

 

If (LEqual (CAL5, Local0))

{

Return (0x1F)

}

 

If (LEqual (CAL6, Local0))

{

Return (0x1F)

}

 

If (LEqual (CAL7, Local0))

{

Return (0x1F)

}

 

If (LEqual (CAL8, Local0))

{

Return (0x1F)

}

 

Return (0x1D)

}

 

Method (NDDS, 1, NotSerialized)

{

Store (And (Arg0, 0x0F0F), Local0)

If (LEqual (0x00, Local0))

{

Return (0x00)

}

 

If (LEqual (NADL, Local0))

{

Return (0x01)

}

 

If (LEqual (NDL2, Local0))

{

Return (0x01)

}

 

If (LEqual (NDL3, Local0))

{

Return (0x01)

}

 

If (LEqual (NDL4, Local0))

{

Return (0x01)

}

 

If (LEqual (NDL5, Local0))

{

Return (0x01)

}

 

If (LEqual (NDL6, Local0))

{

Return (0x01)

}

 

If (LEqual (NDL7, Local0))

{

Return (0x01)

}

 

If (LEqual (NDL8, Local0))

{

Return (0x01)

}

 

Return (0x00)

}

 

Method (MXMX, 1, Serialized)

{

If (LEqual (Arg0, 0x00))

{

Store (0x01, GP52)

Store (0x01, GP53)

P8XH (0x01, 0x77)

P8XH (0x00, 0x01)

}

 

If (LEqual (Arg0, 0x01))

{

Store (0x00, GP52)

Store (0x00, GP53)

P8XH (0x01, 0x77)

P8XH (0x00, 0x00)

}

 

Return (0x01)

}

 

Scope (\_SB.PCI0)

{

OperationRegion (MCHP, PCI_Config, 0x40, 0xC0)

Field (MCHP, AnyAcc, NoLock, Preserve)

{

Offset (0x60),

TASM, 10,

Offset (0x62)

}

}

 

OperationRegion (IGDP, PCI_Config, 0x40, 0xC0)

Field (IGDP, AnyAcc, NoLock, Preserve)

{

Offset (0x12),

, 1,

GIVD, 1,

, 2,

GUMA, 3,

Offset (0x14),

, 4,

GMFN, 1,

Offset (0x18),

Offset (0xA4),

ASLE, 8,

Offset (0xA8),

GSSE, 1,

GSSB, 14,

GSES, 1,

Offset (0xB0),

, 12,

CDVL, 1,

Offset (0xB2),

Offset (0xB5),

LBPC, 8,

Offset (0xBC),

ASLS, 32

}

 

OperationRegion (IGDM, SystemMemory, ASLB, 0x2000)

Field (IGDM, AnyAcc, NoLock, Preserve)

{

SIGN, 128,

SIZE, 32,

OVER, 32,

SVER, 256,

VVER, 128,

GVER, 128,

MBOX, 32,

DMOD, 32,

Offset (0x100),

DRDY, 32,

CSTS, 32,

CEVT, 32,

Offset (0x120),

DIDL, 32,

DDL2, 32,

DDL3, 32,

DDL4, 32,

DDL5, 32,

DDL6, 32,

DDL7, 32,

DDL8, 32,

CPDL, 32,

CPL2, 32,

CPL3, 32,

CPL4, 32,

CPL5, 32,

CPL6, 32,

CPL7, 32,

CPL8, 32,

CADL, 32,

CAL2, 32,

CAL3, 32,

CAL4, 32,

CAL5, 32,

CAL6, 32,

CAL7, 32,

CAL8, 32,

NADL, 32,

NDL2, 32,

NDL3, 32,

NDL4, 32,

NDL5, 32,

NDL6, 32,

NDL7, 32,

NDL8, 32,

ASLP, 32,

TIDX, 32,

CHPD, 32,

CLID, 32,

CDCK, 32,

SXSW, 32,

EVTS, 32,

CNOT, 32,

NRDY, 32,

Offset (0x200),

SCIE, 1,

GEFC, 4,

GXFC, 3,

GESF, 8,

Offset (0x204),

PARM, 32,

DSLP, 32,

Offset (0x300),

ARDY, 32,

ASLC, 32,

TCHE, 32,

ALSI, 32,

BCLP, 32,

PFIT, 32,

CBLV, 32,

BCLM, 320,

CPFM, 32,

EPFM, 32,

PLUT, 592,

PFMB, 32,

CCDV, 32,

PCFT, 32,

Offset (0x400),

GVD1, 49152,

PHED, 32,

BDDC, 2048

}

 

Name (DBTB, Package (0x15)

{

0x00,

0x07,

0x38,

0x01C0,

0x0E00,

0x3F,

0x01C7,

0x0E07,

0x01F8,

0x0E38,

0x0FC0,

0x00,

0x00,

0x00,

0x00,

0x00,

0x7000,

0x7007,

0x7038,

0x71C0,

0x7E00

})

Name (CDCT, Package (0x05)

{

Package (0x02)

{

0xE4,

0x0140

},

 

Package (0x02)

{

0xDE,

0x014D

},

 

Package (0x02)

{

0xDE,

0x014D

},

 

Package (0x02)

{

0x00,

0x00

},

 

Package (0x02)

{

0xDE,

0x014D

}

})

Name (SUCC, 0x01)

Name (NVLD, 0x02)

Name (CRIT, 0x04)

Name (NCRT, 0x06)

Method (GSCI, 0, Serialized)

{

Method (GBDA, 0, Serialized)

{

If (LEqual (GESF, 0x00))

{

Store (0x0679, PARM)

Store (Zero, GESF)

Return (SUCC)

}

 

If (LEqual (GESF, 0x01))

{

Store (0x0240, PARM)

Store (Zero, GESF)

Return (SUCC)

}

 

If (LEqual (GESF, 0x04))

{

And (PARM, 0xEFFF0000, PARM)

And (PARM, ShiftLeft (DerefOf (Index (DBTB, IBTT)), 0x10),

PARM)

Or (IBTT, PARM, PARM)

Store (Zero, GESF)

Return (SUCC)

}

 

If (LEqual (GESF, 0x05))

{

Store (IPSC, PARM)

Or (PARM, ShiftLeft (IPAT, 0x08), PARM)

Add (PARM, 0x0100, PARM)

Or (PARM, ShiftLeft (LIDS, 0x10), PARM)

Add (PARM, 0x00010000, PARM)

Or (PARM, ShiftLeft (IBIA, 0x14), PARM)

Store (Zero, GESF)

Return (SUCC)

}

 

If (LEqual (GESF, 0x06))

{

Store (ITVF, PARM)

Or (PARM, ShiftLeft (ITVM, 0x04), PARM)

Store (Zero, GESF)

Return (SUCC)

}

 

If (LEqual (GESF, 0x07))

{

Store (GIVD, PARM)

XOr (PARM, 0x01, PARM)

Or (PARM, ShiftLeft (GMFN, 0x01), PARM)

Or (PARM, ShiftLeft (0x03, 0x0B), PARM)

Or (PARM, ShiftLeft (IDMS, 0x11), PARM)

Or (ShiftLeft (DerefOf (Index (DerefOf (Index (CDCT, HVCO)), CDVL

)), 0x15), PARM, PARM)

Store (0x01, GESF)

Return (SUCC)

}

 

If (LEqual (GESF, 0x0A))

{

Store (0x00, PARM)

If (ISSC)

{

Or (PARM, 0x03, PARM)

}

 

Store (0x00, GESF)

Return (SUCC)

}

 

If (LEqual (GESF, 0x0B))

{

Store (KSV0, PARM)

Store (KSV1, GESF)

Return (SUCC)

}

 

Store (Zero, GESF)

Return (CRIT)

}

 

Method (SBCB, 0, Serialized)

{

If (LEqual (GESF, 0x00))

{

Store (0x00, PARM)

Store (0x000F87FD, PARM)

Store (Zero, GESF)

Return (SUCC)

}

 

If (LEqual (GESF, 0x01))

{

Store (Zero, GESF)

Store (Zero, PARM)

Return (SUCC)

}

 

If (LEqual (GESF, 0x03))

{

Store (Zero, GESF)

Store (Zero, PARM)

Return (SUCC)

}

 

If (LEqual (GESF, 0x04))

{

Store (Zero, GESF)

Store (Zero, PARM)

Return (SUCC)

}

 

If (LEqual (GESF, 0x05))

{

Store (Zero, GESF)

Store (Zero, PARM)

Return (SUCC)

}

 

If (LEqual (GESF, 0x06))

{

Store (And (PARM, 0x0F), ITVF)

Store (ShiftRight (And (PARM, 0xF0), 0x04), ITVM)

Store (Zero, GESF)

Store (Zero, PARM)

Return (SUCC)

}

 

If (LEqual (GESF, 0x07))

{

If (LEqual (PARM, 0x00))

{

Store (CLID, Local0)

If (And (0x80000000, Local0))

{

And (CLID, 0x0F, CLID)

GLID (CLID)

}

}

 

Store (Zero, GESF)

Store (Zero, PARM)

Return (SUCC)

}

 

If (LEqual (GESF, 0x08))

{

Store (Zero, GESF)

Store (Zero, PARM)

Return (SUCC)

}

 

If (LEqual (GESF, 0x09))

{

And (PARM, 0xFF, IBTT)

Store (Zero, GESF)

Store (Zero, PARM)

Return (SUCC)

}

 

If (LEqual (GESF, 0x0A))

{

And (PARM, 0xFF, IPSC)

If (And (ShiftRight (PARM, 0x08), 0xFF))

{

And (ShiftRight (PARM, 0x08), 0xFF, IPAT)

Decrement (IPAT)

}

 

And (ShiftRight (PARM, 0x14), 0x07, IBIA)

Store (Zero, GESF)

Store (Zero, PARM)

Return (SUCC)

}

 

If (LEqual (GESF, 0x0B))

{

And (ShiftRight (PARM, 0x01), 0x01, IF1E)

If (And (PARM, ShiftLeft (0x0F, 0x0D)))

{

And (ShiftRight (PARM, 0x0D), 0x0F, IDMS)

}

Else

{

And (ShiftRight (PARM, 0x11), 0x0F, IDMS)

}

 

Store (Zero, GESF)

Store (Zero, PARM)

Return (SUCC)

}

 

If (LEqual (GESF, 0x10))

{

Store (Zero, GESF)

Store (Zero, PARM)

Return (SUCC)

}

 

If (LEqual (GESF, 0x11))

{

Store (ShiftLeft (LIDS, 0x08), PARM)

Add (PARM, 0x0100, PARM)

Store (Zero, GESF)

Return (SUCC)

}

 

If (LEqual (GESF, 0x12))

{

If (And (PARM, 0x01))

{

If (LEqual (ShiftRight (PARM, 0x01), 0x01))

{

Store (0x01, ISSC)

}

Else

{

Store (Zero, GESF)

Return (CRIT)

}

}

Else

{

Store (0x00, ISSC)

}

 

Store (Zero, GESF)

Store (Zero, PARM)

Return (SUCC)

}

 

If (LEqual (GESF, 0x13))

{

Store (Zero, GESF)

Store (Zero, PARM)

Return (SUCC)

}

 

If (LEqual (GESF, 0x14))

{

And (PARM, 0x0F, PAVP)

Store (Zero, GESF)

Store (Zero, PARM)

Return (SUCC)

}

 

Store (Zero, GESF)

Return (SUCC)

}

 

If (LEqual (GEFC, 0x04))

{

Store (GBDA (), GXFC)

}

 

If (LEqual (GEFC, 0x06))

{

Store (SBCB (), GXFC)

}

 

Store (0x00, GEFC)

Store (0x01, SCIS)

Store (0x00, GSSE)

Store (0x00, SCIE)

Return (Zero)

}

 

Method (PDRD, 0, NotSerialized)

{

If (LNot (DRDY))

{

Sleep (ASLP)

}

 

Return (LNot (DRDY))

}

 

Method (PSTS, 0, NotSerialized)

{

If (LGreater (CSTS, 0x02))

{

Sleep (ASLP)

}

 

Return (LEqual (CSTS, 0x03))

}

 

Method (GNOT, 2, NotSerialized)

{

If (PDRD ())

{

Return (0x01)

}

 

Store (Arg0, CEVT)

Store (0x03, CSTS)

If (LAnd (LEqual (CHPD, 0x00), LEqual (Arg1, 0x00)))

{

If (LOr (LGreater (OSYS, 0x07D0), LLess (OSYS, 0x07D6)))

{

Notify (\_SB.PCI0, Arg1)

}

Else

{

Notify (\_SB.PCI0.GFX0, Arg1)

}

}

 

If (CondRefOf (HNOT))

{

HNOT (Arg0)

}

Else

{

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

}

 

Return (0x00)

}

 

Method (GHDS, 1, NotSerialized)

{

Store (Arg0, TIDX)

Return (GNOT (0x01, 0x00))

}

 

Method (GLID, 1, NotSerialized)

{

Store (Arg0, CLID)

Return (GNOT (0x02, 0x00))

}

 

Method (GDCK, 1, NotSerialized)

{

Store (Arg0, CDCK)

Return (GNOT (0x04, 0x00))

}

 

Method (PARD, 0, NotSerialized)

{

If (LNot (ARDY))

{

Sleep (ASLP)

}

 

Return (LNot (ARDY))

}

 

Method (AINT, 2, NotSerialized)

{

If (LNot (And (TCHE, ShiftLeft (0x01, Arg0))))

{

Return (0x01)

}

 

If (PARD ())

{

Return (0x01)

}

 

If (LEqual (Arg0, 0x02))

{

If (CPFM)

{

And (CPFM, 0x0F, Local0)

And (EPFM, 0x0F, Local1)

If (LEqual (Local0, 0x01))

{

If (And (Local1, 0x06))

{

Store (0x06, PFIT)

}

Else

{

If (And (Local1, 0x08))

{

Store (0x08, PFIT)

}

Else

{

Store (0x01, PFIT)

}

}

}

 

If (LEqual (Local0, 0x06))

{

If (And (Local1, 0x08))

{

Store (0x08, PFIT)

}

Else

{

If (And (Local1, 0x01))

{

Store (0x01, PFIT)

}

Else

{

Store (0x06, PFIT)

}

}

}

 

If (LEqual (Local0, 0x08))

{

If (And (Local1, 0x01))

{

Store (0x01, PFIT)

}

Else

{

If (And (Local1, 0x06))

{

Store (0x06, PFIT)

}

Else

{

Store (0x08, PFIT)

}

}

}

}

Else

{

XOr (PFIT, 0x07, PFIT)

}

 

Or (PFIT, 0x80000000, PFIT)

Store (0x04, ASLC)

}

Else

{

If (LEqual (Arg0, 0x01))

{

Store (Arg1, BCLP)

Or (BCLP, 0x80000000, BCLP)

Store (0x02, ASLC)

}

Else

{

If (LEqual (Arg0, 0x00))

{

Store (Arg1, ALSI)

Store (0x01, ASLC)

}

Else

{

Return (0x01)

}

}

}

 

Store (0x01, ASLE)

Return (0x00)

}

 

Method (SCIP, 0, NotSerialized)

{

If (LNotEqual (OVER, 0x00))

{

Return (LNot (GSMI))

}

 

Return (0x00)

}

}

 

Device (RP04)

{

Name (_ADR, 0x001C0003)

OperationRegion (PXCS, PCI_Config, 0x40, 0xC0)

Field (PXCS, AnyAcc, NoLock, WriteAsZeros)

{

Offset (0x12),

, 13,

LASX, 1,

Offset (0x1A),

ABPX, 1,

, 2,

PDCX, 1,

, 2,

PDSX, 1,

Offset (0x1B),

LSCX, 1,

Offset (0x20),

Offset (0x22),

PSPX, 1,

Offset (0x98),

, 30,

HPEX, 1,

PMEX, 1,

, 30,

HPSX, 1,

PMSX, 1

}

 

Method (_PRT, 0, NotSerialized)

{

If (PICM)

{

Return (AR05 ())

}

 

Return (PR05 ())

}

}

 

Device (RP05)

{

Name (_ADR, 0x001C0004)

OperationRegion (PXCS, PCI_Config, 0x40, 0xC0)

Field (PXCS, AnyAcc, NoLock, WriteAsZeros)

{

Offset (0x12),

, 13,

LASX, 1,

Offset (0x1A),

ABPX, 1,

, 2,

PDCX, 1,

, 2,

PDSX, 1,

Offset (0x1B),

LSCX, 1,

Offset (0x20),

Offset (0x22),

PSPX, 1,

Offset (0x98),

, 30,

HPEX, 1,

PMEX, 1,

, 30,

HPSX, 1,

PMSX, 1

}

}

 

Device (RP06)

{

Name (_ADR, 0x001C0005)

OperationRegion (PXCS, PCI_Config, 0x40, 0xC0)

Field (PXCS, AnyAcc, NoLock, WriteAsZeros)

{

Offset (0x12),

, 13,

LASX, 1,

Offset (0x1A),

ABPX, 1,

, 2,

PDCX, 1,

, 2,

PDSX, 1,

Offset (0x1B),

LSCX, 1,

Offset (0x20),

Offset (0x22),

PSPX, 1,

Offset (0x98),

, 30,

HPEX, 1,

PMEX, 1,

, 30,

HPSX, 1,

PMSX, 1

}

 

Method (_PRW, 0, NotSerialized)

{

Return (GPRW (0x09, 0x03))

}

 

Device (PXSX)

{

Name (_ADR, 0x00)

Name (_PRW, Package (0x02)

{

0x09,

0x03

})

Method (_RMV, 0, NotSerialized)

{

Return (0x01)

}

}

 

Method (_PRT, 0, NotSerialized)

{

If (PICM)

{

Return (AR08 ())

}

 

Return (PR08 ())

}

}

 

Device (PEGP)

{

Name (_ADR, 0x00010000)

Device (VGA)

{

OperationRegion (ATFX, PCI_Config, 0x00, 0x10)

Field (ATFX, AnyAcc, NoLock, Preserve)

{

ATID, 16

}

 

Name (_ADR, 0x00)

OperationRegion (AVFX, PCI_Config, 0x00, 0x10)

Field (AVFX, AnyAcc, NoLock, Preserve)

{

AVID, 16

}

 

Method (_STA, 0, NotSerialized)

{

Return (0x0F)

}

 

Name (I10B, Buffer (0x08) {})

CreateField (I10B, 0x00, 0x08, I_AL)

CreateField (I10B, 0x08, 0x08, I_AH)

CreateField (I10B, 0x10, 0x08, I_BL)

CreateField (I10B, 0x18, 0x08, I_BH)

CreateField (I10B, 0x20, 0x08, I_CL)

CreateField (I10B, 0x28, 0x08, I_CH)

CreateField (I10B, 0x30, 0x08, I_DL)

CreateField (I10B, 0x38, 0x08, I_DH)

Name (RTL0, Buffer (0x09)

{

/* 0000 */ 0x0D, 0x13, 0x1C, 0x29, 0x3B, 0x55, 0x7B, 0xB1,

/* 0008 */ 0xFF

})

Name (ICL0, Package (0x0B)

{

0x64,

0x64,

0x05,

0x08,

0x0B,

0x10,

0x17,

0x22,

0x30,

0x46,

0x64

})

Name (RTL1, Buffer (0x09)

{

/* 0000 */ 0x37, 0x3E, 0x4B, 0x5C, 0x6F, 0x86, 0xA0, 0xC3,

/* 0008 */ 0xFF

})

Name (ICL1, Package (0x0B)

{

0x64,

0x64,

0x15,

0x18,

0x1D,

0x24,

0x2C,

0x35,

0x3F,

0x4C,

0x64

})

Device (LCD)

{

Name (_ADR, 0x0110)

Method (_BCL, 0, NotSerialized)

{

Name (_T_0, Zero)

Store (ToInteger (PNID), _T_0)

If (LEqual (_T_0, 0x05))

{

Return (ICL1)

}

Else

{

If (LEqual (_T_0, 0x06))

{

Return (ICL1)

}

Else

{

If (LEqual (_T_0, 0x07))

{

Return (ICL1)

}

Else

{

If (LEqual (_T_0, 0x08))

{

Return (ICL1)

}

Else

{

Return (ICL0)

}

}

}

}

}

 

Method (_BCM, 1, NotSerialized)

{

If (LAnd (LGreater (PNID, 0x04), LLess (PNID, 0x09)))

{

Store (Subtract (Match (ICL1, MEQ, Arg0, MTR, 0x00, 0x02), 0x02

), Local0)

Store (DerefOf (Index (RTL1, Local0)), Local0)

}

Else

{

Store (Subtract (Match (ICL0, MEQ, Arg0, MTR, 0x00, 0x02), 0x02

), Local0)

Store (DerefOf (Index (RTL0, Local0)), Local0)

}

 

Store (Arg0, BRTL)

Store (0x82, I_AL)

Store (0xA0, I_AH)

Store (0x05, I_BL)

Store (0x01, I_BH)

Store (Local0, I_CL)

PHDD (0xE2, I10B)

}

 

Method (_BQC, 0, NotSerialized)

{

Return (BRTL)

}

 

Name (_DCS, 0x1F)

Name (_DGS, 0x01)

Method (_DSS, 1, NotSerialized)

{

If (And (Arg0, 0x40000000))

{

If (And (Arg0, 0x01))

{

Store (0x1F, _DCS)

}

Else

{

Store (0x1D, _DCS)

}

}

Else

{

}

}

}

 

Device (CRT)

{

Name (_ADR, 0x0100)

Name (_DCS, 0x1F)

Name (_DGS, 0x01)

Method (_DSS, 1, NotSerialized)

{

If (And (Arg0, 0x40000000))

{

If (And (Arg0, 0x01))

{

Store (0x1F, _DCS)

}

Else

{

Store (0x1D, _DCS)

}

}

Else

{

}

}

}

 

Device (TV)

{

Name (_ADR, 0x0200)

Name (_DCS, 0x0D)

Name (_DGS, 0x00)

Method (_DSS, 1, NotSerialized)

{

If (And (Arg0, 0x40000000))

{

If (And (Arg0, 0x01))

{

Store (0x1F, _DCS)

}

Else

{

Store (0x1D, _DCS)

}

}

Else

{

}

}

}

 

Device (DFP1)

{

Name (_ADR, 0x0210)

Name (_DCS, 0x1F)

Name (_DGS, 0x01)

Method (_DSS, 1, NotSerialized)

{

If (And (Arg0, 0x40000000))

{

If (And (Arg0, 0x01))

{

Store (0x1F, _DCS)

}

Else

{

Store (0x1D, _DCS)

}

}

Else

{

}

}

}

 

Name (SWIT, 0x01)

Name (_DOD, Package (0x04)

{

0x00010100,

0x00010110,

0x00010200,

0x00010210

})

Name (ATIB, Buffer (0x0100) {})

Method (XTIF, 2, Serialized)

{

If (LEqual (Arg0, 0x00))

{

Return (AF00 ())

}

 

If (LEqual (Arg0, 0x01))

{

Return (AF01 ())

}

 

If (LEqual (Arg0, 0x02))

{

Return (AF02 ())

}

 

If (LEqual (Arg0, 0x03))

{

Return (AF03 (DerefOf (Index (Arg1, 0x02)), DerefOf (Index (Arg1,

0x04))))

}

 

If (LEqual (Arg0, 0x05))

{

Return (AF05 ())

}

 

If (LEqual (Arg0, 0x06))

{

Return (AF06 (DerefOf (Index (Arg1, 0x03))))

}

 

If (LEqual (Arg0, 0x07))

{

Return (AF07 ())

}

 

If (LEqual (Arg0, 0x08))

{

Return (AF08 (DerefOf (Index (Arg1, 0x02))))

}

Else

{

CreateWordField (ATIB, 0x00, SSZE)

CreateWordField (ATIB, 0x02, VERN)

CreateDWordField (ATIB, 0x04, NMSK)

CreateDWordField (ATIB, 0x08, SFUN)

Store (0x00, SSZE)

Store (0x00, VERN)

Store (0x00, NMSK)

Store (0x00, SFUN)

Return (ATIB)

}

}

 

Method (AF00, 0, NotSerialized)

{

CreateWordField (ATIB, 0x00, SSZE)

CreateWordField (ATIB, 0x02, VERN)

CreateDWordField (ATIB, 0x04, NMSK)

CreateDWordField (ATIB, 0x08, SFUN)

Store (0x0C, SSZE)

Store (0x01, VERN)

Store (0x00, NMSK)

Store (NMSK, MSKN)

Store (0x00, SFUN)

Return (ATIB)

}

 

Method (AF01, 0, NotSerialized)

{

CreateWordField (ATIB, 0x00, SSZE)

CreateDWordField (ATIB, 0x02, VMSK)

CreateDWordField (ATIB, 0x06, FLGS)

Store (0x0A, SSZE)

Store (0x03, VMSK)

Store (0x01, FLGS)

Return (ATIB)

}

 

Name (PSBR, Buffer (0x04)

{

0x00, 0x00, 0x00, 0x00

})

Name (MSKN, 0x00)

Name (SEXM, 0x00)

Name (STHG, 0x00)

Name (STHI, 0x00)

Name (SFPG, 0x00)

Name (SFPI, 0x00)

Name (SSPS, 0x00)

Name (SSDM, 0x0A)

Name (SCDY, 0x00)

Name (SACT, Buffer (0x06)

{

0x01, 0x02, 0x08, 0x03, 0x09, 0x0A

})

Method (AF02, 0, NotSerialized)

{

CreateBitField (PSBR, 0x00, PDSW)

CreateBitField (PSBR, 0x01, PEXM)

CreateBitField (PSBR, 0x02, PTHR)

CreateBitField (PSBR, 0x03, PFPS)

CreateBitField (PSBR, 0x04, PSPS)

CreateBitField (PSBR, 0x05, PDCC)

CreateWordField (ATIB, 0x00, SSZE)

CreateDWordField (ATIB, 0x02, PSBI)

CreateByteField (ATIB, 0x06, EXPM)

CreateByteField (ATIB, 0x07, THRM)

CreateByteField (ATIB, 0x08, THID)

CreateByteField (ATIB, 0x09, FPWR)

CreateByteField (ATIB, 0x0A, FPID)

CreateByteField (ATIB, 0x0B, SPWR)

Store (0x0C, SSZE)

Store (PSBR, PSBI)

If (PDSW)

{

Store (Zero, PDSW)

}

 

If (PEXM)

{

Store (SEXM, EXPM)

Store (Zero, SEXM)

Store (Zero, PEXM)

}

 

If (PTHR)

{

Store (STHG, THRM)

Store (STHI, THID)

Store (Zero, STHG)

Store (Zero, STHI)

Store (Zero, PTHR)

}

 

If (PFPS)

{

Store (SFPG, FPWR)

Store (SFPI, FPWR)

Store (Zero, SFPG)

Store (Zero, SFPI)

Store (Zero, PFPS)

}

 

If (PSPS)

{

Store (SSPS, SPWR)

Store (Zero, PSPS)

}

 

Return (ATIB)

}

 

Method (AF03, 2, NotSerialized)

{

CreateWordField (ATIB, 0x00, SSZE)

CreateWordField (ATIB, 0x02, SSDP)

CreateWordField (ATIB, 0x04, SCDP)

Store (Arg0, SSDP)

Store (Arg1, SCDP)

Name (NXTD, 0x06)

Name (CIDX, 0x06)

Store (SSDP, Local1)

And (Local1, 0x0B, Local1)

Store (SCDP, Local2)

If (CondRefOf (\_SB.LID._LID, Local4))

{

And (Local2, Not (0x01), Local2)

}

Else

{

Or (Local2, 0x01, Local2)

}

 

Store (Zero, Local0)

While (LLess (Local0, SizeOf (SACT)))

{

Store (DerefOf (Index (SACT, Local0)), Local3)

If (LEqual (Local3, Local1))

{

Store (Local0, CIDX)

Store (SizeOf (SACT), Local0)

}

Else

{

Increment (Local0)

}

}

 

Store (CIDX, Local0)

While (LLess (Local0, SizeOf (SACT)))

{

Increment (Local0)

If (LEqual (Local0, SizeOf (SACT)))

{

Store (0x00, Local0)

}

 

Store (DerefOf (Index (SACT, Local0)), Local3)

If (LEqual (And (Local3, Local2), Local3))

{

Store (Local0, NXTD)

Store (SizeOf (SACT), Local0)

}

}

 

If (LEqual (NXTD, SizeOf (SACT)))

{

Store (Zero, SSDP)

}

Else

{

Store (NXTD, Local0)

Store (DerefOf (Index (SACT, Local0)), Local3)

And (SSDP, Not (0x0B), SSDP)

Or (SSDP, Local3, SSDP)

}

 

Store (0x04, SSZE)

Return (ATIB)

}

 

Method (AF05, 0, NotSerialized)

{

CreateWordField (ATIB, 0x00, SSZE)

CreateByteField (ATIB, 0x02, TSEF)

CreateByteField (ATIB, 0x03, TVIF)

Store (0x04, SSZE)

Store (0x00, TSEF)

Return (ATIB)

}

 

Method (AF06, 1, NotSerialized)

{

CreateWordField (ATIB, 0x00, SSZE)

CreateByteField (ATIB, 0x02, TSEF)

CreateByteField (ATIB, 0x03, TVIF)

Store (0x04, SSZE)

Store (0x00, TSEF)

Store (Arg0, TVIF)

Return (ATIB)

}

 

Method (AF07, 0, NotSerialized)

{

CreateWordField (ATIB, 0x00, SSZE)

CreateByteField (ATIB, 0x02, XMOD)

Store (0x03, SSZE)

Store (0x00, XMOD)

Return (ATIB)

}

 

Method (AF08, 1, NotSerialized)

{

CreateWordField (ATIB, 0x00, SSZE)

CreateByteField (ATIB, 0x02, XMOD)

Store (0x03, SSZE)

Store (Arg0, XMOD)

Return (ATIB)

}

 

Method (AFN0, 0, Serialized)

{

If (And (MSKN, 0x01))

{

CreateBitField (PSBR, 0x00, PDSW)

Store (One, PDSW)

Notify (VGA, 0x81)

}

}

 

Method (AFN1, 1, Serialized)

{

If (And (MSKN, 0x02))

{

Store (Arg0, Local0)

And (Local0, 0x03, Local0)

Store (Local0, SEXM)

CreateBitField (PSBR, 0x01, PEXM)

Store (One, PEXM)

Notify (VGA, 0x81)

}

}

 

Method (AFN2, 2, Serialized)

{

If (And (MSKN, 0x04))

{

Store (Arg0, Local0)

Store (Local0, STHI)

Store (Arg1, Local0)

Store (And (Local0, 0x03, Local0), STHG)

CreateBitField (PSBR, 0x02, PTHS)

Store (One, PTHS)

Notify (VGA, 0x81)

}

}

 

Method (AFN3, 2, Serialized)

{

If (And (MSKN, 0x08))

{

Store (Arg0, Local0)

Store (Local0, SFPI)

Store (Arg1, Local0)

Store (And (Local0, 0x03, Local0), SFPG)

CreateBitField (PSBR, 0x03, PFPS)

Store (One, PFPS)

Notify (VGA, 0x81)

}

}

 

Method (AFN4, 1, Serialized)

{

If (And (MSKN, 0x10))

{

Store (Arg0, Local0)

Store (SSPS, Local1)

Store (Local0, SSPS)

If (LEqual (Local0, Local1)) {}

Else

{

CreateBitField (PSBR, 0x04, PSPS)

Store (One, PSPS)

Notify (VGA, 0x81)

}

}

}

 

Method (AFN5, 0, Serialized)

{

If (And (MSKN, 0x20))

{

CreateBitField (PSBR, 0x05, PDCC)

Store (One, PDCC)

Notify (VGA, 0x81)

}

}

}

 

Method (_PRT, 0, NotSerialized)

{

If (PICM)

{

Return (AR01 ())

}

 

Return (PR01 ())

}

 

Device (M92X)

{

Name (_ADR, 0xFFFF)

}

 

Device (M96L)

{

Name (_ADR, 0xFFFF)

}

 

Device (MADI)

{

Name (_ADR, 0xFFFF)

}

 

Device (PARK)

{

Name (_ADR, 0xFFFF)

}

 

Device (N10P)

{

Name (_ADR, 0xFFFF)

}

 

Device (N10M)

{

Name (_ADR, 0xFFFF)

}

 

Device (N11P)

{

Name (_ADR, 0xFFFF)

}

 

Device (N11M)

{

Name (_ADR, 0xFFFF)

}

 

Device (NPGE)

{

Name (_ADR, 0xFFFF)

}

}

 

Device (PEG3)

{

Name (_ADR, 0x00030000)

Device (VGA)

{

OperationRegion (ATFX, PCI_Config, 0x00, 0x10)

Field (ATFX, AnyAcc, NoLock, Preserve)

{

ATID, 16

}

 

Name (_ADR, 0x00)

OperationRegion (AVFX, PCI_Config, 0x00, 0x10)

Field (AVFX, AnyAcc, NoLock, Preserve)

{

AVID, 16

}

 

Method (_STA, 0, NotSerialized)

{

Return (0x0F)

}

 

Name (I10B, Buffer (0x08) {})

CreateField (I10B, 0x00, 0x08, I_AL)

CreateField (I10B, 0x08, 0x08, I_AH)

CreateField (I10B, 0x10, 0x08, I_BL)

CreateField (I10B, 0x18, 0x08, I_BH)

CreateField (I10B, 0x20, 0x08, I_CL)

CreateField (I10B, 0x28, 0x08, I_CH)

CreateField (I10B, 0x30, 0x08, I_DL)

CreateField (I10B, 0x38, 0x08, I_DH)

Name (RTL0, Buffer (0x09)

{

/* 0000 */ 0x0D, 0x13, 0x1C, 0x29, 0x3B, 0x55, 0x7B, 0xB1,

/* 0008 */ 0xFF

})

Name (ICL0, Package (0x0B)

{

0x64,

0x64,

0x05,

0x08,

0x0B,

0x10,

0x17,

0x22,

0x30,

0x46,

0x64

})

Name (RTL1, Buffer (0x09)

{

/* 0000 */ 0x37, 0x3E, 0x4B, 0x5C, 0x6F, 0x86, 0xA0, 0xC3,

/* 0008 */ 0xFF

})

Name (ICL1, Package (0x0B)

{

0x64,

0x64,

0x15,

0x18,

0x1D,

0x24,

0x2C,

0x35,

0x3F,

0x4C,

0x64

})

Device (LCD)

{

Name (_ADR, 0x0110)

Method (_BCL, 0, NotSerialized)

{

Name (_T_0, Zero)

Store (ToInteger (PNID), _T_0)

If (LEqual (_T_0, 0x05))

{

Return (ICL1)

}

Else

{

If (LEqual (_T_0, 0x06))

{

Return (ICL1)

}

Else

{

If (LEqual (_T_0, 0x07))

{

Return (ICL1)

}

Else

{

If (LEqual (_T_0, 0x08))

{

Return (ICL1)

}

Else

{

Return (ICL0)

}

}

}

}

}

 

Method (_BCM, 1, NotSerialized)

{

If (LAnd (LGreater (PNID, 0x04), LLess (PNID, 0x09)))

{

Store (Subtract (Match (ICL1, MEQ, Arg0, MTR, 0x00, 0x02), 0x02

), Local0)

Store (DerefOf (Index (RTL1, Local0)), Local0)

}

Else

{

Store (Subtract (Match (ICL0, MEQ, Arg0, MTR, 0x00, 0x02), 0x02

), Local0)

Store (DerefOf (Index (RTL0, Local0)), Local0)

}

 

Store (Arg0, BRTL)

Store (0x82, I_AL)

Store (0xA0, I_AH)

Store (0x05, I_BL)

Store (0x01, I_BH)

Store (Local0, I_CL)

PHDD (0xE2, I10B)

}

 

Method (_BQC, 0, NotSerialized)

{

Return (BRTL)

}

 

Name (_DCS, 0x1F)

Name (_DGS, 0x01)

Method (_DSS, 1, NotSerialized)

{

If (And (Arg0, 0x40000000))

{

If (And (Arg0, 0x01))

{

Store (0x1F, _DCS)

}

Else

{

Store (0x1D, _DCS)

}

}

Else

{

}

}

}

 

Device (CRT)

{

Name (_ADR, 0x0100)

Name (_DCS, 0x1F)

Name (_DGS, 0x01)

Method (_DSS, 1, NotSerialized)

{

If (And (Arg0, 0x40000000))

{

If (And (Arg0, 0x01))

{

Store (0x1F, _DCS)

}

Else

{

Store (0x1D, _DCS)

}

}

Else

{

}

}

}

 

Device (TV)

{

Name (_ADR, 0x0200)

Name (_DCS, 0x0D)

Name (_DGS, 0x00)

Method (_DSS, 1, NotSerialized)

{

If (And (Arg0, 0x40000000))

{

If (And (Arg0, 0x01))

{

Store (0x1F, _DCS)

}

Else

{

Store (0x1D, _DCS)

}

}

Else

{

}

}

}

 

Device (DFP1)

{

Name (_ADR, 0x0210)

Name (_DCS, 0x1F)

Name (_DGS, 0x01)

Method (_DSS, 1, NotSerialized)

{

If (And (Arg0, 0x40000000))

{

If (And (Arg0, 0x01))

{

Store (0x1F, _DCS)

}

Else

{

Store (0x1D, _DCS)

}

}

Else

{

}

}

}

 

Name (SWIT, 0x01)

Name (_DOD, Package (0x04)

{

0x00010100,

0x00010110,

0x00010200,

0x00010210

})

Name (ATIB, Buffer (0x0100) {})

Method (XTIF, 2, Serialized)

{

If (LEqual (Arg0, 0x00))

{

Return (AF00 ())

}

 

If (LEqual (Arg0, 0x01))

{

Return (AF01 ())

}

 

If (LEqual (Arg0, 0x02))

{

Return (AF02 ())

}

 

If (LEqual (Arg0, 0x03))

{

Return (AF03 (DerefOf (Index (Arg1, 0x02)), DerefOf (Index (Arg1,

0x04))))

}

 

If (LEqual (Arg0, 0x05))

{

Return (AF05 ())

}

 

If (LEqual (Arg0, 0x06))

{

Return (AF06 (DerefOf (Index (Arg1, 0x03))))

}

 

If (LEqual (Arg0, 0x07))

{

Return (AF07 ())

}

 

If (LEqual (Arg0, 0x08))

{

Return (AF08 (DerefOf (Index (Arg1, 0x02))))

}

Else

{

CreateWordField (ATIB, 0x00, SSZE)

CreateWordField (ATIB, 0x02, VERN)

CreateDWordField (ATIB, 0x04, NMSK)

CreateDWordField (ATIB, 0x08, SFUN)

Store (0x00, SSZE)

Store (0x00, VERN)

Store (0x00, NMSK)

Store (0x00, SFUN)

Return (ATIB)

}

}

 

Method (AF00, 0, NotSerialized)

{

CreateWordField (ATIB, 0x00, SSZE)

CreateWordField (ATIB, 0x02, VERN)

CreateDWordField (ATIB, 0x04, NMSK)

CreateDWordField (ATIB, 0x08, SFUN)

Store (0x0C, SSZE)

Store (0x01, VERN)

Store (0x00, NMSK)

Store (NMSK, MSKN)

Store (0x00, SFUN)

Return (ATIB)

}

 

Method (AF01, 0, NotSerialized)

{

CreateWordField (ATIB, 0x00, SSZE)

CreateDWordField (ATIB, 0x02, VMSK)

CreateDWordField (ATIB, 0x06, FLGS)

Store (0x0A, SSZE)

Store (0x03, VMSK)

Store (0x01, FLGS)

Return (ATIB)

}

 

Name (PSBR, Buffer (0x04)

{

0x00, 0x00, 0x00, 0x00

})

Name (MSKN, 0x00)

Name (SEXM, 0x00)

Name (STHG, 0x00)

Name (STHI, 0x00)

Name (SFPG, 0x00)

Name (SFPI, 0x00)

Name (SSPS, 0x00)

Name (SSDM, 0x0A)

Name (SCDY, 0x00)

Name (SACT, Buffer (0x06)

{

0x01, 0x02, 0x08, 0x03, 0x09, 0x0A

})

Method (AF02, 0, NotSerialized)

{

CreateBitField (PSBR, 0x00, PDSW)

CreateBitField (PSBR, 0x01, PEXM)

CreateBitField (PSBR, 0x02, PTHR)

CreateBitField (PSBR, 0x03, PFPS)

CreateBitField (PSBR, 0x04, PSPS)

CreateBitField (PSBR, 0x05, PDCC)

CreateWordField (ATIB, 0x00, SSZE)

CreateDWordField (ATIB, 0x02, PSBI)

CreateByteField (ATIB, 0x06, EXPM)

CreateByteField (ATIB, 0x07, THRM)

CreateByteField (ATIB, 0x08, THID)

CreateByteField (ATIB, 0x09, FPWR)

CreateByteField (ATIB, 0x0A, FPID)

CreateByteField (ATIB, 0x0B, SPWR)

Store (0x0C, SSZE)

Store (PSBR, PSBI)

If (PDSW)

{

Store (Zero, PDSW)

}

 

If (PEXM)

{

Store (SEXM, EXPM)

Store (Zero, SEXM)

Store (Zero, PEXM)

}

 

If (PTHR)

{

Store (STHG, THRM)

Store (STHI, THID)

Store (Zero, STHG)

Store (Zero, STHI)

Store (Zero, PTHR)

}

 

If (PFPS)

{

Store (SFPG, FPWR)

Store (SFPI, FPWR)

Store (Zero, SFPG)

Store (Zero, SFPI)

Store (Zero, PFPS)

}

 

If (PSPS)

{

Store (SSPS, SPWR)

Store (Zero, PSPS)

}

 

Return (ATIB)

}

 

Method (AF03, 2, NotSerialized)

{

CreateWordField (ATIB, 0x00, SSZE)

CreateWordField (ATIB, 0x02, SSDP)

CreateWordField (ATIB, 0x04, SCDP)

Store (Arg0, SSDP)

Store (Arg1, SCDP)

Name (NXTD, 0x06)

Name (CIDX, 0x06)

Store (SSDP, Local1)

And (Local1, 0x0B, Local1)

Store (SCDP, Local2)

If (CondRefOf (\_SB.LID._LID, Local4))

{

And (Local2, Not (0x01), Local2)

}

Else

{

Or (Local2, 0x01, Local2)

}

 

Store (Zero, Local0)

While (LLess (Local0, SizeOf (SACT)))

{

Store (DerefOf (Index (SACT, Local0)), Local3)

If (LEqual (Local3, Local1))

{

Store (Local0, CIDX)

Store (SizeOf (SACT), Local0)

}

Else

{

Increment (Local0)

}

}

 

Store (CIDX, Local0)

While (LLess (Local0, SizeOf (SACT)))

{

Increment (Local0)

If (LEqual (Local0, SizeOf (SACT)))

{

Store (0x00, Local0)

}

 

Store (DerefOf (Index (SACT, Local0)), Local3)

If (LEqual (And (Local3, Local2), Local3))

{

Store (Local0, NXTD)

Store (SizeOf (SACT), Local0)

}

}

 

If (LEqual (NXTD, SizeOf (SACT)))

{

Store (Zero, SSDP)

}

Else

{

Store (NXTD, Local0)

Store (DerefOf (Index (SACT, Local0)), Local3)

And (SSDP, Not (0x0B), SSDP)

Or (SSDP, Local3, SSDP)

}

 

Store (0x04, SSZE)

Return (ATIB)

}

 

Method (AF05, 0, NotSerialized)

{

CreateWordField (ATIB, 0x00, SSZE)

CreateByteField (ATIB, 0x02, TSEF)

CreateByteField (ATIB, 0x03, TVIF)

Store (0x04, SSZE)

Store (0x00, TSEF)

Return (ATIB)

}

 

Method (AF06, 1, NotSerialized)

{

CreateWordField (ATIB, 0x00, SSZE)

CreateByteField (ATIB, 0x02, TSEF)

CreateByteField (ATIB, 0x03, TVIF)

Store (0x04, SSZE)

Store (0x00, TSEF)

Store (Arg0, TVIF)

Return (ATIB)

}

 

Method (AF07, 0, NotSerialized)

{

CreateWordField (ATIB, 0x00, SSZE)

CreateByteField (ATIB, 0x02, XMOD)

Store (0x03, SSZE)

Store (0x00, XMOD)

Return (ATIB)

}

 

Method (AF08, 1, NotSerialized)

{

CreateWordField (ATIB, 0x00, SSZE)

CreateByteField (ATIB, 0x02, XMOD)

Store (0x03, SSZE)

Store (Arg0, XMOD)

Return (ATIB)

}

 

Method (AFN0, 0, Serialized)

{

If (And (MSKN, 0x01))

{

CreateBitField (PSBR, 0x00, PDSW)

Store (One, PDSW)

Notify (VGA, 0x81)

}

}

 

Method (AFN1, 1, Serialized)

{

If (And (MSKN, 0x02))

{

Store (Arg0, Local0)

And (Local0, 0x03, Local0)

Store (Local0, SEXM)

CreateBitField (PSBR, 0x01, PEXM)

Store (One, PEXM)

Notify (VGA, 0x81)

}

}

 

Method (AFN2, 2, Serialized)

{

If (And (MSKN, 0x04))

{

Store (Arg0, Local0)

Store (Local0, STHI)

Store (Arg1, Local0)

Store (And (Local0, 0x03, Local0), STHG)

CreateBitField (PSBR, 0x02, PTHS)

Store (One, PTHS)

Notify (VGA, 0x81)

}

}

 

Method (AFN3, 2, Serialized)

{

If (And (MSKN, 0x08))

{

Store (Arg0, Local0)

Store (Local0, SFPI)

Store (Arg1, Local0)

Store (And (Local0, 0x03, Local0), SFPG)

CreateBitField (PSBR, 0x03, PFPS)

Store (One, PFPS)

Notify (VGA, 0x81)

}

}

 

Method (AFN4, 1, Serialized)

{

If (And (MSKN, 0x10))

{

Store (Arg0, Local0)

Store (SSPS, Local1)

Store (Local0, SSPS)

If (LEqual (Local0, Local1)) {}

Else

{

CreateBitField (PSBR, 0x04, PSPS)

Store (One, PSPS)

Notify (VGA, 0x81)

}

}

}

 

Method (AFN5, 0, Serialized)

{

If (And (MSKN, 0x20))

{

CreateBitField (PSBR, 0x05, PDCC)

Store (One, PDCC)

Notify (VGA, 0x81)

}

}

}

 

Method (_PRT, 0, NotSerialized)

{

If (PICM)

{

Return (AR01 ())

}

 

Return (PR01 ())

}

 

Device (M92X)

{

Name (_ADR, 0xFFFF)

}

 

Device (M96L)

{

Name (_ADR, 0xFFFF)

}

 

Device (MADI)

{

Name (_ADR, 0xFFFF)

}

 

Device (PARK)

{

Name (_ADR, 0xFFFF)

}

 

Device (N10P)

{

Name (_ADR, 0xFFFF)

}

 

Device (N10M)

{

Name (_ADR, 0xFFFF)

}

 

Device (N11P)

{

Name (_ADR, 0xFFFF)

}

 

Device (N11M)

{

Name (_ADR, 0xFFFF)

}

 

Device (NPGE)

{

Name (_ADR, 0xFFFF)

}

}

}

 

Scope (\_GPE)

{

Method (_L0B, 0, NotSerialized)

{

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

}

 

Method (_L03, 0, NotSerialized)

{

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

}

 

Method (_L04, 0, NotSerialized)

{

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

}

 

Method (_L0C, 0, NotSerialized)

{

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

}

 

Method (_L0E, 0, NotSerialized)

{

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

}

 

Method (_L05, 0, NotSerialized)

{

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

}

 

Method (_L20, 0, NotSerialized)

{

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

}

 

Method (_L25, 0, NotSerialized)

{

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

}

 

Method (_L0D, 0, NotSerialized)

{

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

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

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

}

}

}

 

Scope (\_PR)

{

Processor (CPU0, 0x01, 0x00000410, 0x06) {}

Processor (CPU1, 0x02, 0x00000410, 0x06) {}

Processor (CPU2, 0x03, 0x00000410, 0x06) {}

Processor (CPU3, 0x04, 0x00000410, 0x06) {}

Processor (CPU4, 0x05, 0x00000410, 0x06) {}

Processor (CPU5, 0x06, 0x00000410, 0x06) {}

Processor (CPU6, 0x07, 0x00000410, 0x06) {}

Processor (CPU7, 0x08, 0x00000410, 0x06) {}

}

 

Mutex (MUTX, 0x00)

Scope (\)

{

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

Field (XCMS, ByteAcc, NoLock, Preserve)

{

XIND, 8,

XDAT, 8

}

 

IndexField (XIND, XDAT, ByteAcc, NoLock, Preserve)

{

Offset (0x6C),

CM6C, 8,

CM6D, 8,

CM6E, 8,

CM6F, 8,

Offset (0x75),

CM75, 8,

Offset (0x78),

ATFR, 8

}

}

 

Name (BFER, 0x00)

Mutex (RWCM, 0x00)

Method (DBGC, 3, NotSerialized)

{

Acquire (RWCM, 0xFFFF)

If (LEqual (Arg2, 0x02))

{

Store (CM6D, BFER)

If (LNotEqual (Arg0, BFER))

{

Store (BFER, CM6E)

Sleep (0x01)

Store (Arg0, CM6D)

}

 

Sleep (0x01)

Store (Arg1, CM6F)

}

 

Release (RWCM)

}

 

OperationRegion (PRT0, SystemIO, 0x80, 0x04)

Field (PRT0, DWordAcc, Lock, Preserve)

{

P80H, 32

}

 

Method (P8XH, 2, Serialized)

{

If (LEqual (Arg0, 0x00))

{

Store (Or (And (P80D, 0xFFFFFF00), Arg1), P80D)

}

 

If (LEqual (Arg0, 0x01))

{

Store (Or (And (P80D, 0xFFFF00FF), ShiftLeft (Arg1, 0x08)

), P80D)

}

 

If (LEqual (Arg0, 0x02))

{

Store (Or (And (P80D, 0xFF00FFFF), ShiftLeft (Arg1, 0x10)

), P80D)

}

 

If (LEqual (Arg0, 0x03))

{

Store (Or (And (P80D, 0x00FFFFFF), ShiftLeft (Arg1, 0x18)

), P80D)

}

 

Store (P80D, P80H)

}

 

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

Field (SPRT, ByteAcc, Lock, Preserve)

{

SSMP, 8

}

 

Method (\_PIC, 1, NotSerialized)

{

Store (Arg0, GPIC)

Store (Arg0, PICM)

}

 

Method (_PTS, 1, NotSerialized)

{

\DBGC (Add (0x4D, Arg0), 0x00, BCEN)

Store (0x00, P80D)

P8XH (0x00, Arg0)

Store (0x00, CM75)

PHSB (0xEB, 0x00)

If (LEqual (Arg0, 0x03))

{

If (LAnd (DTSE, LGreater (TCNT, 0x01)))

{

TRAP (\TRTD, 0x1E)

}

}

 

\DBGC (Add (0x4D, Arg0), 0x80, BCEN)

}

 

Method (_WAK, 1, Serialized)

{

\DBGC (Add (0x50, Arg0), 0x00, BCEN)

P8XH (0x01, 0xAB)

If (NEXP)

{

If (And (OSCC, 0x02))

{

\_SB.PCI0.NHPG ()

}

 

If (And (OSCC, 0x04))

{

\_SB.PCI0.NPME ()

}

}

 

If (LOr (LEqual (Arg0, 0x03), LEqual (Arg0, 0x04)))

{

If (CM75)

{

Store (0x00, CM75)

Notify (\_SB.PWRB, 0x02)

}

 

Acquire (\_SB.PCI0.LPCB.EC.MECR, 0xFFFF)

Sleep (0x05)

Store (\_SB.PCI0.LPCB.EC.RPWR, PWRS)

Release (\_SB.PCI0.LPCB.EC.MECR)

Notify (\_SB.ADP1, 0x81)

Notify (\_SB.BAT0, 0x81)

PNOT ()

If (LAnd (DTSE, LGreater (TCNT, 0x01)))

{

TRAP (\TRTD, 0x14)

}

 

If (LEqual (OSYS, 0x07D2))

{

If (And (CFGD, 0x01))

{

If (LGreater (\_PR.CPU0._PPC, 0x00))

{

Subtract (\_PR.CPU0._PPC, 0x01, \_PR.CPU0._PPC)

PNOT ()

Add (\_PR.CPU0._PPC, 0x01, \_PR.CPU0._PPC)

PNOT ()

}

Else

{

Add (\_PR.CPU0._PPC, 0x01, \_PR.CPU0._PPC)

PNOT ()

Subtract (\_PR.CPU0._PPC, 0x01, \_PR.CPU0._PPC)

PNOT ()

}

}

}

 

If (LEqual (RP1D, 0x00))

{

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

}

 

If (LEqual (RP2D, 0x00))

{

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

}

 

If (LEqual (RP3D, 0x00))

{

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

}

 

If (LEqual (RP4D, 0x00))

{

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

}

 

If (LEqual (RP5D, 0x00))

{

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

}

 

If (LEqual (RP6D, 0x00))

{

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

}

}

 

\DBGC (Add (0x50, Arg0), 0x80, BCEN)

Return (Package (0x02)

{

0x00,

0x00

})

}

 

Method (GETB, 3, Serialized)

{

Multiply (Arg0, 0x08, Local0)

Multiply (Arg1, 0x08, Local1)

CreateField (Arg2, Local0, Local1, TBF3)

Return (TBF3)

}

 

Method (PNOT, 0, Serialized)

{

If (LGreater (TCNT, 0x01))

{

If (And (PDC0, 0x08))

{

Notify (\_PR.CPU0, 0x80)

If (And (PDC0, 0x10))

{

Sleep (0x64)

Notify (\_PR.CPU0, 0x81)

}

}

 

If (And (PDC1, 0x08))

{

Notify (\_PR.CPU1, 0x80)

If (And (PDC1, 0x10))

{

Sleep (0x64)

Notify (\_PR.CPU1, 0x81)

}

}

 

If (And (PDC2, 0x08))

{

Notify (\_PR.CPU2, 0x80)

If (And (PDC2, 0x10))

{

Sleep (0x64)

Notify (\_PR.CPU2, 0x81)

}

}

 

If (And (PDC3, 0x08))

{

Notify (\_PR.CPU3, 0x80)

If (And (PDC3, 0x10))

{

Sleep (0x64)

Notify (\_PR.CPU3, 0x81)

}

}

 

If (And (PDC4, 0x08))

{

Notify (\_PR.CPU4, 0x80)

If (And (PDC4, 0x10))

{

Sleep (0x64)

Notify (\_PR.CPU4, 0x81)

}

}

 

If (And (PDC5, 0x08))

{

Notify (\_PR.CPU5, 0x80)

If (And (PDC5, 0x10))

{

Sleep (0x64)

Notify (\_PR.CPU5, 0x81)

}

}

 

If (And (PDC6, 0x08))

{

Notify (\_PR.CPU6, 0x80)

If (And (PDC6, 0x10))

{

Sleep (0x64)

Notify (\_PR.CPU6, 0x81)

}

}

 

If (And (PDC7, 0x08))

{

Notify (\_PR.CPU7, 0x80)

If (And (PDC7, 0x10))

{

Sleep (0x64)

Notify (\_PR.CPU7, 0x81)

}

}

}

Else

{

Notify (\_PR.CPU0, 0x80)

Sleep (0x64)

Notify (\_PR.CPU0, 0x81)

}

}

 

Method (TRAP, 2, Serialized)

{

Store (Arg1, SMIF)

If (LEqual (Arg0, \TRTP))

{

Store (0x00, TRP0)

}

 

If (LEqual (Arg0, \TRTD))

{

Store (Arg1, DTSF)

Store (0x00, TRPD)

Return (DTSF)

}

 

Return (SMIF)

}

 

Scope (\_SB.PCI0)

{

Method (_INI, 0, NotSerialized)

{

Store (0x07D0, OSYS)

If (CondRefOf (\_OSI, Local0))

{

If (\_OSI ("Linux"))

{

Store (0x03E8, OSYS)

}

 

If (\_OSI ("Windows 2001"))

{

Store (0x07D1, OSYS)

}

 

If (\_OSI ("Windows 2001 SP1"))

{

Store (0x07D1, OSYS)

}

 

If (\_OSI ("Windows 2001 SP2"))

{

Store (0x07D2, OSYS)

}

 

If (\_OSI ("Windows 2006"))

{

Store (0x07D6, OSYS)

}

 

If (\_OSI ("Windows 2009"))

{

Store (0x07D9, OSYS)

}

}

 

If (LOr (LEqual (OSYS, 0x07D1), LEqual (OSYS, 0x07D2)))

{

Store (0x00, Local1)

Store (PHS (0xC1), Local1)

And (Local1, 0x0F, Local1)

If (LGreater (Local1, 0x08))

{

Store (0x08, Local1)

PHSB (0xC2, Local1)

}

 

If (LAnd (LGreater (PNID, 0x04), LLess (PNID, 0x09)))

{

Store (DerefOf (Index (\BTL1, Local1)), Local2)

}

Else

{

Store (DerefOf (Index (\BTL0, Local1)), Local2)

}

 

If (And (IGDS, IGDS))

{

Store (Local2, BRTL)

}

Else

{

\_SB.PCI0.PEGP.VGA.LCD._BCM (Local2)

}

}

}

 

Method (NHPG, 0, Serialized)

{

Store (0x00, ^RP01.HPEX)

Store (0x00, ^RP02.HPEX)

Store (0x00, ^RP03.HPEX)

Store (0x00, ^RP04.HPEX)

Store (0x01, ^RP01.HPSX)

Store (0x01, ^RP02.HPSX)

Store (0x01, ^RP03.HPSX)

Store (0x01, ^RP04.HPSX)

}

 

Method (NPME, 0, Serialized)

{

Store (0x00, ^RP01.PMEX)

Store (0x00, ^RP02.PMEX)

Store (0x00, ^RP03.PMEX)

Store (0x00, ^RP04.PMEX)

Store (0x00, ^RP05.PMEX)

Store (0x00, ^RP06.PMEX)

Store (0x01, ^RP01.PMSX)

Store (0x01, ^RP02.PMSX)

Store (0x01, ^RP03.PMSX)

Store (0x01, ^RP04.PMSX)

Store (0x01, ^RP05.PMSX)

Store (0x01, ^RP06.PMSX)

}

}

 

Scope (\)

{

Name (PICM, 0x00)

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)

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

}

 

Return (PRWP)

}

}

 

Scope (\_SB.PCI0)

{

Device (PDRC)

{

Name (_HID, EisaId ("PNP0C02"))

Name (_UID, 0x01)

Name (BUF0, ResourceTemplate ()

{

Memory32Fixed (ReadWrite,

0x00000000, // Address Base

0x00004000, // Address Length

)

Memory32Fixed (ReadWrite,

0x00000000, // Address Base

0x00004000, // Address Length

)

Memory32Fixed (ReadWrite,

0x00000000, // Address Base

0x00001000, // Address Length

)

Memory32Fixed (ReadWrite,

0x00000000, // Address Base

0x00001000, // Address Length

)

Memory32Fixed (ReadWrite,

0x00000000, // Address Base

0x00000000, // Address Length

)

Memory32Fixed (ReadWrite,

0xFED20000, // Address Base

0x00020000, // Address Length

)

Memory32Fixed (ReadOnly,

0xFED90000, // Address Base

0x00004000, // Address Length

)

Memory32Fixed (ReadWrite,

0xFED45000, // Address Base

0x0004B000, // Address Length

)

Memory32Fixed (ReadOnly,

0xFF000000, // Address Base

0x01000000, // Address Length

)

Memory32Fixed (ReadOnly,

0xFEE00000, // Address Base

0x00100000, // Address Length

)

Memory32Fixed (ReadWrite,

0x00000000, // Address Base

0x00001000, // Address Length

)

})

Method (_CRS, 0, Serialized)

{

CreateDWordField (BUF0, 0x04, RBR0)

ShiftLeft (\_SB.PCI0.LPCB.RCBA, 0x0E, RBR0)

CreateDWordField (BUF0, 0x7C, TBR0)

Store (TBAB, TBR0)

CreateDWordField (BUF0, 0x80, TBLN)

If (LEqual (TBAB, 0x00))

{

Store (0x00, TBLN)

}

 

If (Or (LEqual (And (PNHM, 0x000FFFF0), 0x000106E0), LEqual (And (

PNHM, 0x000FFFF0), 0x000106A0)))

{

CreateDWordField (BUF0, 0x14, MBLN)

Store (Zero, MBLN)

}

Else

{

CreateDWordField (BUF0, 0x10, MBR0)

ShiftLeft (\_SB.PCI0.MHBR, 0x0E, MBR0)

}

 

CreateDWordField (BUF0, 0x1C, DBR0)

ShiftLeft (\_SB.PCI0.DIBR, 0x0C, DBR0)

If (Or (LEqual (And (PNHM, 0x000FFFF0), 0x000106E0), LEqual (And (

PNHM, 0x000FFFF0), 0x000106A0)))

{

ShiftLeft (\_SB.PCI0.DIBI, 0x0C, DBR0)

}

 

If (Or (LEqual (And (PNHM, 0x000FFFF0), 0x000106E0), LEqual (And (

PNHM, 0x000FFFF0), 0x000106A0)))

{

CreateDWordField (BUF0, 0x2C, EBLN)

Store (Zero, EBLN)

}

Else

{

CreateDWordField (BUF0, 0x28, EBR0)

ShiftLeft (\_SB.PCI0.EPBR, 0x0C, EBR0)

}

 

CreateDWordField (BUF0, 0x34, XBR0)

ShiftLeft (\_SB.CPBG.IMCH.PXBR, 0x14, XBR0)

CreateDWordField (BUF0, 0x38, XSZ0)

ShiftRight (0x10000000, \_SB.CPBG.IMCH.PXSZ, XSZ0)

CreateDWordField (BUF0, 0x4C, VTB0)

CreateDWordField (BUF0, 0x50, VTLN)

If (Or (LEqual (And (PNHM, 0x000FFFF0), 0x000106E0), LEqual (And (

PNHM, 0x000FFFF0), 0x000106A0)))

{

If (LGreaterEqual (PNHM, 0x000106E1))

{

If (\_SB.PCI0.IO10.VTEN)

{

ShiftLeft (\_SB.PCI0.IO10.VTBA, 0x0C, VTB0)

}

Else

{

Store (Zero, VTLN)

}

}

Else

{

If (\_SB.PCI0.IIO0.VTEN)

{

ShiftLeft (\_SB.PCI0.IIO0.VTBA, 0x0C, VTB0)

}

Else

{

Store (Zero, VTLN)

}

}

}

Else

{

If (\_SB.PCI0.ADVE)

{

ShiftLeft (\_SB.PCI0.ADVT, 0x0C, VTB0)

}

Else

{

Store (Zero, VTLN)

}

}

 

Return (BUF0)

}

}

}

 

Method (BRTN, 1, Serialized)

{

If (LEqual (And (DID1, 0x0F00), 0x0400))

{

Notify (\_SB.PCI0.GFX0.DD01, Arg0)

}

 

If (LEqual (And (DID2, 0x0F00), 0x0400))

{

Notify (\_SB.PCI0.GFX0.DD02, Arg0)

}

 

If (LEqual (And (DID3, 0x0F00), 0x0400))

{

Notify (\_SB.PCI0.GFX0.DD03, Arg0)

}

 

If (LEqual (And (DID4, 0x0F00), 0x0400))

{

Notify (\_SB.PCI0.GFX0.DD04, Arg0)

}

 

If (LEqual (And (DID5, 0x0F00), 0x0400))

{

Notify (\_SB.PCI0.GFX0.DD05, Arg0)

}

 

If (LEqual (And (DID6, 0x0F00), 0x0400))

{

Notify (\_SB.PCI0.GFX0.DD06, Arg0)

}

 

If (LEqual (And (DID7, 0x0F00), 0x0400))

{

Notify (\_SB.PCI0.GFX0.DD07, Arg0)

}

 

If (LEqual (And (DID8, 0x0F00), 0x0400))

{

Notify (\_SB.PCI0.GFX0.DD08, Arg0)

}

}

 

Scope (\)

{

OperationRegion (IO_T, SystemIO, 0xFF00, 0x10)

Field (IO_T, ByteAcc, NoLock, Preserve)

{

TRPI, 16,

Offset (0x04),

Offset (0x06),

Offset (0x08),

TRP0, 8,

Offset (0x0A),

Offset (0x0B),

Offset (0x0C),

Offset (0x0D),

Offset (0x0E),

Offset (0x0F),

Offset (0x10)

}

 

OperationRegion (IO_D, SystemIO, 0xFF10, 0x04)

Field (IO_D, ByteAcc, NoLock, Preserve)

{

TRPD, 8

}

 

OperationRegion (IO_H, SystemIO, 0x1000, 0x04)

Field (IO_H, ByteAcc, NoLock, Preserve)

{

TRPH, 8

}

 

OperationRegion (PMIO, SystemIO, \PMBS, 0x80)

Field (PMIO, ByteAcc, NoLock, Preserve)

{

Offset (0x20),

, 2,

SPST, 1,

Offset (0x42),

, 1,

GPEC, 1,

Offset (0x64),

, 9,

SCIS, 1,

Offset (0x66)

}

 

OperationRegion (GPIO, SystemIO, \GPBS, 0x64)

Field (GPIO, ByteAcc, NoLock, Preserve)

{

GU00, 8,

GU01, 8,

GU02, 8,

GU03, 8,

GIO0, 8,

GIO1, 8,

GIO2, 8,

GIO3, 8,

Offset (0x0C),

GL00, 8,

GL01, 8,

GL02, 8,

, 3,

GP27, 1,

GP28, 1,

Offset (0x10),

Offset (0x18),

GB00, 8,

GB01, 8,

GB02, 8,

GB03, 8,

Offset (0x2C),

GIV0, 8,

GIV1, 8,

GIV2, 8,

GIV3, 8,

GU04, 8,

GU05, 8,

GU06, 8,

GU07, 8,

GIO4, 8,

GIO5, 8,

GIO6, 8,

GIO7, 8,

, 4,

GPID, 3,

Offset (0x39),

GL05, 8,

GL06, 8,

GL07, 8,

Offset (0x40),

GU08, 8,

GU09, 8,

GU0A, 8,

GU0B, 8,

GIO8, 8,

GIO9, 8,

GIOA, 8,

GIOB, 8,

GL08, 8,

GL09, 8,

GL0A, 8,

GL0B, 8

}

 

OperationRegion (RCRB, SystemMemory, \SRCB, 0x4000)

Field (RCRB, DWordAcc, Lock, Preserve)

{

Offset (0x1000),

Offset (0x3000),

Offset (0x3404),

HPAS, 2,

, 5,

HPAE, 1,

Offset (0x3418),

, 1,

, 1,

SATD, 1,

SMBD, 1,

HDAD, 1,

Offset (0x341A),

RP1D, 1,

RP2D, 1,

RP3D, 1,

RP4D, 1,

RP5D, 1,

RP6D, 1,

RP7D, 1,

RP8D, 1

}

 

Method (GETP, 1, Serialized)

{

If (LEqual (And (Arg0, 0x09), 0x00))

{

Return (0xFFFFFFFF)

}

 

If (LEqual (And (Arg0, 0x09), 0x08))

{

Return (0x0384)

}

 

ShiftRight (And (Arg0, 0x0300), 0x08, Local0)

ShiftRight (And (Arg0, 0x3000), 0x0C, Local1)

Return (Multiply (0x1E, Subtract (0x09, Add (Local0, Local1))

))

}

 

Method (GDMA, 5, Serialized)

{

If (Arg0)

{

If (LAnd (Arg1, Arg4))

{

Return (0x14)

}

 

If (LAnd (Arg2, Arg4))

{

Return (Multiply (Subtract (0x04, Arg3), 0x0F))

}

 

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

}

 

Return (0xFFFFFFFF)

}

 

Method (GETT, 1, Serialized)

{

Return (Multiply (0x1E, Subtract (0x09, Add (And (ShiftRight (Arg0, 0x02

), 0x03), And (Arg0, 0x03)))))

}

 

Method (GETF, 3, Serialized)

{

Name (TMPF, 0x00)

If (Arg0)

{

Or (TMPF, 0x01, TMPF)

}

 

If (And (Arg2, 0x02))

{

Or (TMPF, 0x02, TMPF)

}

 

If (Arg1)

{

Or (TMPF, 0x04, TMPF)

}

 

If (And (Arg2, 0x20))

{

Or (TMPF, 0x08, TMPF)

}

 

If (And (Arg2, 0x4000))

{

Or (TMPF, 0x10, TMPF)

}

 

Return (TMPF)

}

 

Method (SETP, 3, Serialized)

{

If (LGreater (Arg0, 0xF0))

{

Return (0x08)

}

Else

{

If (And (Arg1, 0x02))

{

If (LAnd (LLessEqual (Arg0, 0x78), And (Arg2, 0x02)))

{

Return (0x2301)

}

 

If (LAnd (LLessEqual (Arg0, 0xB4), And (Arg2, 0x01)))

{

Return (0x2101)

}

}

 

Return (0x1001)

}

}

 

Method (SDMA, 1, Serialized)

{

If (LLessEqual (Arg0, 0x14))

{

Return (0x01)

}

 

If (LLessEqual (Arg0, 0x1E))

{

Return (0x02)

}

 

If (LLessEqual (Arg0, 0x2D))

{

Return (0x01)

}

 

If (LLessEqual (Arg0, 0x3C))

{

Return (0x02)

}

 

If (LLessEqual (Arg0, 0x5A))

{

Return (0x01)

}

 

Return (0x00)

}

 

Method (SETT, 3, Serialized)

{

If (And (Arg1, 0x02))

{

If (LAnd (LLessEqual (Arg0, 0x78), And (Arg2, 0x02)))

{

Return (0x0B)

}

 

If (LAnd (LLessEqual (Arg0, 0xB4), And (Arg2, 0x01)))

{

Return (0x09)

}

}

 

Return (0x04)

}

}

 

Scope (\_SB.PCI0)

{

Device (SAT0)

{

Name (_ADR, 0x001F0002)

OperationRegion (SACS, PCI_Config, 0x40, 0xC0)

Field (SACS, DWordAcc, NoLock, Preserve)

{

PRIT, 16,

SECT, 16,

PSIT, 4,

SSIT, 4,

Offset (0x08),

SYNC, 4,

Offset (0x0A),

SDT0, 2,

, 2,

SDT1, 2,

Offset (0x0B),

SDT2, 2,

, 2,

SDT3, 2,

Offset (0x14),

ICR0, 4,

ICR1, 4,

ICR2, 4,

ICR3, 4,

ICR4, 4,

ICR5, 4,

Offset (0x50),

MAPV, 2

}

}

 

Device (SAT1)

{

Name (_ADR, 0x001F0005)

OperationRegion (SACS, PCI_Config, 0x40, 0xC0)

Field (SACS, DWordAcc, NoLock, Preserve)

{

PRIT, 16,

SECT, 16,

PSIT, 4,

SSIT, 4,

Offset (0x08),

SYNC, 4,

Offset (0x0A),

SDT0, 2,

, 2,

SDT1, 2,

Offset (0x0B),

SDT2, 2,

, 2,

SDT3, 2,

Offset (0x14),

ICR0, 4,

ICR1, 4,

ICR2, 4,

ICR3, 4,

ICR4, 4,

ICR5, 4,

Offset (0x50),

MAPV, 2

}

}

 

Device (SBUS)

{

Name (_ADR, 0x001F0003)

OperationRegion (SMBP, PCI_Config, 0x40, 0xC0)

Field (SMBP, DWordAcc, NoLock, Preserve)

{

, 2,

I2CE, 1

}

 

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

Field (SMPB, DWordAcc, NoLock, Preserve)

{

, 5,

SBAR, 11

}

 

OperationRegion (SMBI, SystemIO, ShiftLeft (SBAR, 0x05), 0x10)

Field (SMBI, ByteAcc, NoLock, Preserve)

{

HSTS, 8,

Offset (0x02),

HCON, 8,

HCOM, 8,

TXSA, 8,

DAT0, 8,

DAT1, 8,

HBDR, 8,

PECR, 8,

RXSA, 8,

SDAT, 16

}

 

Method (SSXB, 2, Serialized)

{

If (STRT ())

{

Return (0x00)

}

 

Store (0x00, I2CE)

Store (0xBF, HSTS)

Store (Arg0, TXSA)

Store (Arg1, HCOM)

Store (0x48, HCON)

If (COMP ())

{

Or (HSTS, 0xFF, HSTS)

Return (0x01)

}

 

Return (0x00)

}

 

Method (SRXB, 1, Serialized)

{

If (STRT ())

{

Return (0xFFFF)

}

 

Store (0x00, I2CE)

Store (0xBF, HSTS)

Store (Or (Arg0, 0x01), TXSA)

Store (0x44, HCON)

If (COMP ())

{

Or (HSTS, 0xFF, HSTS)

Return (DAT0)

}

 

Return (0xFFFF)

}

 

Method (SWRB, 3, Serialized)

{

If (STRT ())

{

Return (0x00)

}

 

Store (0x00, I2CE)

Store (0xBF, HSTS)

Store (Arg0, TXSA)

Store (Arg1, HCOM)

Store (Arg2, DAT0)

Store (0x48, HCON)

If (COMP ())

{

Or (HSTS, 0xFF, HSTS)

Return (0x01)

}

 

Return (0x00)

}

 

Method (SRDB, 2, Serialized)

{

If (STRT ())

{

Return (0xFFFF)

}

 

Store (0x00, I2CE)

Store (0xBF, HSTS)

Store (Or (Arg0, 0x01), TXSA)

Store (Arg1, HCOM)

Store (0x48, HCON)

If (COMP ())

{

Or (HSTS, 0xFF, HSTS)

Return (DAT0)

}

 

Return (0xFFFF)

}

 

Method (SWRW, 3, Serialized)

{

If (STRT ())

{

Return (0x00)

}

 

Store (0x00, I2CE)

Store (0xBF, HSTS)

Store (Arg0, TXSA)

Store (Arg1, HCOM)

And (Arg2, 0xFF, DAT1)

And (ShiftRight (Arg2, 0x08), 0xFF, DAT0)

Store (0x4C, HCON)

If (COMP ())

{

Or (HSTS, 0xFF, HSTS)

Return (0x01)

}

 

Return (0x00)

}

 

Method (SRDW, 2, Serialized)

{

If (STRT ())

{

Return (0xFFFF)

}

 

Store (0x00, I2CE)

Store (0xBF, HSTS)

Store (Or (Arg0, 0x01), TXSA)

Store (Arg1, HCOM)

Store (0x4C, HCON)

If (COMP ())

{

Or (HSTS, 0xFF, HSTS)

Return (Or (ShiftLeft (DAT0, 0x08), DAT1))

}

 

Return (0xFFFFFFFF)

}

 

Method (SBLW, 4, Serialized)

{

If (STRT ())

{

Return (0x00)

}

 

Store (Arg3, I2CE)

Store (0xBF, HSTS)

Store (Arg0, TXSA)

Store (Arg1, HCOM)

Store (SizeOf (Arg2), DAT0)

Store (0x00, Local1)

Store (DerefOf (Index (Arg2, 0x00)), HBDR)

Store (0x54, HCON)

While (LGreater (SizeOf (Arg2), Local1))

{

Store (0x0FA0, Local0)

While (LAnd (LNot (And (HSTS, 0x80)), Local0))

{

Decrement (Local0)

Stall (0x32)

}

 

If (LNot (Local0))

{

KILL ()

Return (0x00)

}

 

Store (0x80, HSTS)

Increment (Local1)

If (LGreater (SizeOf (Arg2), Local1))

{

Store (DerefOf (Index (Arg2, Local1)), HBDR)

}

}

 

If (COMP ())

{

Or (HSTS, 0xFF, HSTS)

Return (0x01)

}

 

Return (0x00)

}

 

Method (SBLR, 3, Serialized)

{

Name (TBUF, Buffer (0x0100) {})

If (STRT ())

{

Return (0x00)

}

 

Store (Arg2, I2CE)

Store (0xBF, HSTS)

Store (Or (Arg0, 0x01), TXSA)

Store (Arg1, HCOM)

Store (0x54, HCON)

Store (0x0FA0, Local0)

While (LAnd (LNot (And (HSTS, 0x80)), Local0))

{

Decrement (Local0)

Stall (0x32)

}

 

If (LNot (Local0))

{

KILL ()

Return (0x00)

}

 

Store (DAT0, Index (TBUF, 0x00))

Store (0x80, HSTS)

Store (0x01, Local1)

While (LLess (Local1, DerefOf (Index (TBUF, 0x00))))

{

Store (0x0FA0, Local0)

While (LAnd (LNot (And (HSTS, 0x80)), Local0))

{

Decrement (Local0)

Stall (0x32)

}

 

If (LNot (Local0))

{

KILL ()

Return (0x00)

}

 

Store (HBDR, Index (TBUF, Local1))

Store (0x80, HSTS)

Increment (Local1)

}

 

If (COMP ())

{

Or (HSTS, 0xFF, HSTS)

Return (TBUF)

}

 

Return (0x00)

}

 

Method (STRT, 0, Serialized)

{

Store (0xC8, Local0)

While (Local0)

{

If (And (HSTS, 0x40))

{

Decrement (Local0)

Sleep (0x01)

If (LEqual (Local0, 0x00))

{

Return (0x01)

}

}

Else

{

Store (0x00, Local0)

}

}

 

Store (0x0FA0, Local0)

While (Local0)

{

If (And (HSTS, 0x01))

{

Decrement (Local0)

Stall (0x32)

If (LEqual (Local0, 0x00))

{

KILL ()

}

}

Else

{

Return (0x00)

}

}

 

Return (0x01)

}

 

Method (COMP, 0, Serialized)

{

Store (0x0FA0, Local0)

While (Local0)

{

If (And (HSTS, 0x02))

{

Return (0x01)

}

Else

{

Decrement (Local0)

Stall (0x32)

If (LEqual (Local0, 0x00))

{

KILL ()

}

}

}

 

Return (0x00)

}

 

Method (KILL, 0, Serialized)

{

Or (HCON, 0x02, HCON)

Or (HSTS, 0xFF, HSTS)

}

}

}

 

Scope (\_GPE)

{

Method (_L01, 0, NotSerialized)

{

Add (L01C, 0x01, L01C)

P8XH (0x00, 0x01)

P8XH (0x01, L01C)

If (LAnd (LEqual (RP1D, 0x00), \_SB.PCI0.RP01.HPSX))

{

Sleep (0x64)

If (\_SB.PCI0.RP01.PDCX)

{

Store (0x01, \_SB.PCI0.RP01.PDCX)

Store (0x01, \_SB.PCI0.RP01.HPSX)

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

}

Else

{

Store (0x01, \_SB.PCI0.RP01.HPSX)

}

}

 

If (LAnd (LEqual (RP2D, 0x00), \_SB.PCI0.RP02.HPSX))

{

Sleep (0x64)

If (\_SB.PCI0.RP02.PDCX)

{

Store (0x01, \_SB.PCI0.RP02.PDCX)

Store (0x01, \_SB.PCI0.RP02.HPSX)

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

}

Else

{

Store (0x01, \_SB.PCI0.RP02.HPSX)

}

}

 

If (LAnd (LEqual (RP3D, 0x00), \_SB.PCI0.RP03.HPSX))

{

Sleep (0x64)

If (\_SB.PCI0.RP03.PDCX)

{

Store (0x01, \_SB.PCI0.RP03.PDCX)

Store (0x01, \_SB.PCI0.RP03.HPSX)

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

}

Else

{

Store (0x01, \_SB.PCI0.RP03.HPSX)

}

}

 

If (LAnd (LEqual (RP4D, 0x00), \_SB.PCI0.RP04.HPSX))

{

Sleep (0x64)

If (\_SB.PCI0.RP04.PDCX)

{

Store (0x01, \_SB.PCI0.RP04.PDCX)

Store (0x01, \_SB.PCI0.RP04.HPSX)

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

}

Else

{

Store (0x01, \_SB.PCI0.RP04.HPSX)

}

}

 

If (LAnd (LEqual (RP5D, 0x00), \_SB.PCI0.RP05.HPSX))

{

Sleep (0x64)

If (\_SB.PCI0.RP05.PDCX)

{

Store (0x01, \_SB.PCI0.RP05.PDCX)

Store (0x01, \_SB.PCI0.RP05.HPSX)

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

}

Else

{

Store (0x01, \_SB.PCI0.RP05.HPSX)

}

}

 

If (LAnd (LEqual (RP6D, 0x00), \_SB.PCI0.RP06.HPSX))

{

Sleep (0x64)

If (\_SB.PCI0.RP06.PDCX)

{

Store (0x01, \_SB.PCI0.RP06.PDCX)

Store (0x01, \_SB.PCI0.RP06.HPSX)

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

}

Else

{

Store (0x01, \_SB.PCI0.RP06.HPSX)

}

}

}

 

Method (_L06, 0, NotSerialized)

{

If (LAnd (\_SB.PCI0.GFX0.GSSE, LNot (GSMI)))

{

\_SB.PCI0.GFX0.GSCI ()

}

 

Store (0x01, SCIS)

}

 

Method (_L07, 0, NotSerialized)

{

Store (0x20, \_SB.PCI0.SBUS.HSTS)

}

 

Method (_L1B, 0, NotSerialized)

{

Notify (\_SB.PWRB, 0x02)

}

 

Method (_L09, 0, NotSerialized)

{

If (\_SB.PCI0.RP01.PSPX)

{

While (\_SB.PCI0.RP01.PSPX)

{

Store (0x01, \_SB.PCI0.RP01.PSPX)

Store (0x01, \_SB.PCI0.RP01.PMSX)

}

 

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

}

 

If (\_SB.PCI0.RP03.PSPX)

{

While (\_SB.PCI0.RP03.PSPX)

{

Store (0x01, \_SB.PCI0.RP03.PSPX)

Store (0x01, \_SB.PCI0.RP03.PMSX)

}

 

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

}

 

If (\_SB.PCI0.RP06.PSPX)

{

While (\_SB.PCI0.RP06.PSPX)

{

Store (0x01, \_SB.PCI0.RP06.PSPX)

Store (0x01, \_SB.PCI0.RP06.PMSX)

}

 

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

}

}

}

 

Scope (\_SB)

{

Device (CPBG)

{

Name (_HID, EisaId ("PNP0A03"))

Name (_UID, 0xFF)

Method (_BBN, 0, NotSerialized)

{

Return (Subtract (ShiftRight (\PELN, 0x14), 0x01))

}

 

Name (_ADR, 0x00)

Name (BUF0, ResourceTemplate ()

{

WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode,

0x0000, // Granularity

0x00FF, // Range Minimum

0x00FF, // Range Maximum

0x0000, // Translation Offset

0x0001, // Length

,, )

})

Method (_CRS, 0, Serialized)

{

CreateWordField (BUF0, 0x08, PBMN)

Store (Subtract (ShiftRight (\PELN, 0x14), 0x01), PBMN)

CreateWordField (BUF0, 0x0A, PBMX)

Store (Subtract (ShiftRight (\PELN, 0x14), 0x01), PBMX)

Return (BUF0)

}

 

Device (IMCH)

{

Name (_ADR, 0x01)

OperationRegion (PBUS, PCI_Config, 0x00, 0xC0)

Field (PBUS, DWordAcc, NoLock, Preserve)

{

Offset (0x40),

, 4,

PM0H, 2,

Offset (0x41),

PM1L, 2,

, 2,

PM1H, 2,

Offset (0x42),

PM2L, 2,

, 2,

PM2H, 2,

Offset (0x43),

PM3L, 2,

, 2,

PM3H, 2,

Offset (0x44),

PM4L, 2,

, 2,

PM4H, 2,

Offset (0x45),

PM5L, 2,

, 2,

PM5H, 2,

Offset (0x46),

PM6L, 2,

, 2,

PM6H, 2,

Offset (0x47),

Offset (0x48),

, 7,

HENA, 1,

Offset (0x50),

PXEN, 1,

PXSZ, 2,

, 17,

PXBR, 12

}

}

}

}

 

OperationRegion (SMI0, SystemMemory, 0xD2F11918, 0x0420)

Field (SMI0, AnyAcc, NoLock, Preserve)

{

BCMD, 8,

DID, 32,

INFO, 4096

}

 

Field (SMI0, AnyAcc, NoLock, Preserve)

{

Offset (0x05),

INFB, 8

}

 

Field (SMI0, AnyAcc, NoLock, Preserve)

{

Offset (0x05),

INFD, 32

}

 

Field (SMI0, AnyAcc, NoLock, Preserve)

{

Offset (0x05),

INDD, 64

}

 

Field (SMI0, AnyAcc, NoLock, Preserve)

{

Offset (0x05),

SXBF, 8320

}

 

Field (SMI0, AnyAcc, NoLock, Preserve)

{

Offset (0x05),

INF1, 8,

INF2, 8

}

 

OperationRegion (SMI1, SystemIO, 0x00000800, 0xFFFF0004)

Field (SMI1, AnyAcc, NoLock, Preserve)

{

SMIC, 8

}

 

Mutex (MPHS, 0x00)

Method (PHS0, 1, NotSerialized)

{

Store (Arg0, BCMD)

Store (Zero, SMIC)

While (LEqual (BCMD, Arg0)) {}

Store (0x00, BCMD)

}

 

Method (PHS, 1, Serialized)

{

Acquire (MPHS, 0xFFFF)

Store (0x00, DID)

PHS0 (Arg0)

Store (INFD, Local0)

Release (MPHS)

Return (Local0)

}

 

Method (PHSD, 2, Serialized)

{

Acquire (MPHS, 0xFFFF)

Store (0x00, DID)

Store (Arg1, INFD)

PHS0 (Arg0)

Store (INFD, Local0)

Release (MPHS)

Return (Local0)

}

 

Method (PHDD, 2, Serialized)

{

Acquire (MPHS, 0xFFFF)

Store (0x00, DID)

Store (Arg1, INDD)

PHS0 (Arg0)

Store (INDD, Local0)

Release (MPHS)

Return (Local0)

}

 

Method (PHSW, 3, Serialized)

{

Acquire (MPHS, 0xFFFF)

Store (0x00, DID)

Store (Arg1, INF1)

Store (Arg2, INF2)

PHS0 (Arg0)

Store (INFB, Local0)

Release (MPHS)

Return (Local0)

}

 

Method (PHSB, 2, Serialized)

{

Acquire (MPHS, 0xFFFF)

Store (0x00, DID)

Store (Arg1, INFB)

PHS0 (Arg0)

Store (INFB, Local0)

Release (MPHS)

Return (Local0)

}

 

Scope (\_SB)

{

Scope (PCI0)

{

Scope (LPCB)

{

Device (EC)

{

Name (_HID, EisaId ("PNP0C09"))

Mutex (MECR, 0x00)

Method (_CRS, 0, NotSerialized)

{

Name (BFFR, ResourceTemplate ()

{

IO (Decode16,

0x0062, // Range Minimum

0x0062, // Range Maximum

0x00, // Alignment

0x01, // Length

)

IO (Decode16,

0x0066, // Range Minimum

0x0066, // Range Maximum

0x00, // Alignment

0x01, // Length

)

})

Return (BFFR)

}

 

OperationRegion (ECF2, EmbeddedControl, 0x00, 0xFF)

Field (ECF2, ByteAcc, Lock, Preserve)

{

, 3,

PRCP, 1,

, 1,

LSTE, 1,

BATP, 1,

RPWR, 1,

, 4,

CHGE, 1,

LVDS, 1,

, 1,

AUAM, 1,

ENR0, 8,

ENR1, 8,

ESR0, 8,

ESR1, 8,

BSTS, 8,

WKSR, 8,

Offset (0x0A),

LSDH, 8,

LSDL, 8,

Offset (0x19),

ISID, 8,

Offset (0x20),

BTPL, 8,

BTPH, 8,

BSNL, 8,

BSNH, 8,

BDCL, 8,

BDCH, 8,

BDVL, 8,

BDVH, 8,

BAVL, 8,

BAVH, 8,

BACL, 8,

BACH, 8,

RSCL, 8,

RSCH, 8,

BRCL, 8,

BRCH, 8,

FCCL, 8,

FCCH, 8,

, 4,

FDCH, 1,

FUCH, 1,

DCHG, 1,

BTIT, 1,

BSTH, 8,

OMFL, 8,

OMFH, 8,

IBMF, 8,

ASSR, 8,

Offset (0x40),

TS1R, 8,

TS1L, 8,

TS2R, 8,

TS2L, 8,

TS3R, 8,

TS3L, 8,

F1FL, 8,

F1FH, 8,

F2FL, 8,

F2FH, 8,

T1U1, 8,

T1U2, 8,

T1U3, 8,

T1U4, 8,

T1U5, 8,

T1U6, 8,

T1U7, 8,

T1D1, 8,

T1D2, 8,

T1D3, 8,

T1L1, 8,

T2R1, 8,

T2U1, 8,

T3L1, 8,

T3L2, 8,

Offset (0x60),

SMBN, 8,

SPTR, 8,

SSTS, 8,

SADR, 8,

SCMD, 8,

SBFR, 256,

SCNT, 8,

Offset (0xEE),

ALFS, 1,

Offset (0xEF),

, 6,

ECAK, 1,

CMST, 1,

ALSL, 8,

ALSH, 8

}

 

Method (_REG, 2, NotSerialized)

{

If (LAnd (LEqual (Arg0, 0x03), LEqual (Arg1, 0x01)))

{

Store (BATP, BNUM)

Store (RSCL, B0SC)

Store (RPWR, PWRS)

Notify (\_SB.BAT0, 0x81)

PNOT ()

Store (Arg1, ECON)

}

}

 

Name (_GPE, 0x17)

Method (_Q21, 0, NotSerialized)

{

P8XH (0x00, 0x21)

Store (RPWR, PWRS)

Notify (\_SB.ADP1, 0x81)

Notify (\_SB.BAT0, 0x80)

PNOT ()

}

 

Method (_Q22, 0, NotSerialized)

{

P8XH (0x00, 0x22)

Store (RPWR, PWRS)

Notify (\_SB.ADP1, 0x81)

Notify (\_SB.BAT0, 0x80)

PNOT ()

}

 

Method (_Q23, 0, NotSerialized)

{

P8XH (0x00, 0x23)

Store (RSCL, B0SC)

Store (BATP, BNUM)

Notify (\_SB.BAT0, 0x81)

}

 

Method (_Q24, 0, NotSerialized)

{

P8XH (0x00, 0x24)

Store (RSCL, B0SC)

Store (BATP, BNUM)

Notify (\_SB.BAT0, 0x81)

}

 

Method (_Q25, 0, NotSerialized)

{

P8XH (0x00, 0x25)

Store (RSCL, B0SC)

Notify (\_SB.BAT0, 0x80)

}

 

Method (_Q26, 0, NotSerialized)

{

P8XH (0x00, 0x26)

Notify (\_SB.PCI0.LPCB.SNC, 0x90)

}

 

Method (_Q27, 0, NotSerialized)

{

P8XH (0x00, 0x27)

Notify (\_SB.PCI0.LPCB.SNC, 0x90)

}

 

Method (_Q29, 0, NotSerialized)

{

P8XH (0x00, 0x29)

Notify (\_SB.LID0, 0x80)

}

 

Method (_Q2A, 0, NotSerialized)

{

P8XH (0x00, 0x2A)

Notify (\_SB.LID0, 0x80)

}

 

Method (_Q2B, 0, NotSerialized)

{

P8XH (0x00, 0x2B)

Notify (\_SB.PCI0.LPCB.SNC, 0x94)

}

 

Method (_Q2C, 0, NotSerialized)

{

P8XH (0x00, 0x2C)

Notify (\_SB.PCI0.LPCB.SNC, 0x94)

}

 

Method (_Q32, 0, NotSerialized)

{

P8XH (0x00, 0x32)

Notify (\_SB.PWRB, 0x80)

}

 

Method (_Q34, 0, NotSerialized)

{

P8XH (0x00, 0x34)

Notify (\_TZ.TZ00, 0x80)

If (LGreater (TCNT, 0x01))

{

Notify (\_TZ.TZ01, 0x80)

}

}

 

Method (_Q45, 0, NotSerialized)

{

P8XH (0x00, 0x45)

Increment (Q45T)

Notify (\_SB.PCI0.LPCB.SNC, 0x93)

}

 

Name (HF1P, 0x81)

Name (HF1R, 0x01)

Name (HF5P, 0x85)

Name (HF5R, 0x05)

Name (HF6P, 0x86)

Name (HF6R, 0x06)

Name (HF7P, 0x87)

Name (HF7R, 0x07)

Name (HF8P, 0x88)

Name (HF8R, 0x08)

Name (HF9P, 0x89)

Name (HF9R, 0x09)

Name (HFAP, 0x8A)

Name (HFAR, 0x0A)

Name (HFBP, 0x8B)

Name (HFBR, 0x0B)

Name (HFCP, 0x8C)

Name (HFCR, 0x0C)

Name (HFDP, 0x8D)

Name (HFDR, 0x0D)

Name (HS1P, 0x90)

Name (HS1R, 0x10)

Name (HS2P, 0x91)

Name (HS2R, 0x11)

Name (HUPP, 0x95)

Name (HUPR, 0x15)

Name (HDWP, 0x96)

Name (HDWR, 0x16)

Name (HMUP, 0x97)

Name (HMUR, 0x17)

Name (HTRP, 0x99)

Name (HTRR, 0x19)

Name (HCUP, 0x9A)

Name (HCUR, 0x1A)

Name (HCDP, 0x9B)

Name (HCDR, 0x1B)

Name (HEJP, 0x9F)

Name (HEJR, 0x1F)

Name (HAVP, 0xA1)

Name (HAVR, 0x21)

Name (HVOP, 0xA5)

Name (HVOR, 0x25)

Name (HABP, 0xA6)

Name (HABR, 0x26)

Method (_Q58, 0, NotSerialized)

{

P8XH (0x00, 0x58)

SECR (HF5P)

Notify (\_SB.PCI0.LPCB.SNC, 0x92)

}

 

Method (_Q59, 0, NotSerialized)

{

P8XH (0x00, 0x59)

SECR (HF5R)

Notify (\_SB.PCI0.LPCB.SNC, 0x92)

}

 

Method (_Q5A, 0, NotSerialized)

{

P8XH (0x00, 0x5A)

SECR (HF6P)

Notify (\_SB.PCI0.LPCB.SNC, 0x92)

}

 

Method (_Q5B, 0, NotSerialized)

{

P8XH (0x00, 0x5B)

SECR (HF6R)

Notify (\_SB.PCI0.LPCB.SNC, 0x92)

}

 

Method (_Q5C, 0, NotSerialized)

{

P8XH (0x00, 0x5C)

SECR (HF7P)

Notify (\_SB.PCI0.LPCB.SNC, 0x92)

}

 

Method (_Q5D, 0, NotSerialized)

{

P8XH (0x00, 0x5D)

SECR (HF7R)

Notify (\_SB.PCI0.LPCB.SNC, 0x92)

}

 

Method (_Q60, 0, NotSerialized)

{

P8XH (0x00, 0x60)

SECR (HF9P)

Notify (\_SB.PCI0.LPCB.SNC, 0x92)

}

 

Method (_Q61, 0, NotSerialized)

{

P8XH (0x00, 0x61)

SECR (HF9R)

Notify (\_SB.PCI0.LPCB.SNC, 0x92)

}

 

Method (_Q62, 0, NotSerialized)

{

P8XH (0x00, 0x62)

SECR (HFAP)

Notify (\_SB.PCI0.LPCB.SNC, 0x92)

}

 

Method (_Q63, 0, NotSerialized)

{

P8XH (0x00, 0x63)

SECR (HFAR)

Notify (\_SB.PCI0.LPCB.SNC, 0x92)

}

 

Method (_Q66, 0, NotSerialized)

{

P8XH (0x00, 0x66)

SECR (HFCP)

Notify (\_SB.PCI0.LPCB.SNC, 0x92)

}

 

Method (_Q67, 0, NotSerialized)

{

P8XH (0x00, 0x67)

SECR (HFCR)

Notify (\_SB.PCI0.LPCB.SNC, 0x92)

}

 

Method (_Q82, 0, NotSerialized)

{

P8XH (0x00, 0x82)

SECR (HS1P)

Notify (\_SB.PCI0.LPCB.SNC, 0x92)

}

 

Method (_Q83, 0, NotSerialized)

{

P8XH (0x00, 0x83)

SECR (HS1R)

Notify (\_SB.PCI0.LPCB.SNC, 0x92)

}

 

Method (_Q84, 0, NotSerialized)

{

P8XH (0x00, 0x84)

SECR (HVOP)

Notify (\_SB.PCI0.LPCB.SNC, 0x92)

}

 

Method (_Q85, 0, NotSerialized)

{

P8XH (0x00, 0x85)

SECR (HVOR)

Notify (\_SB.PCI0.LPCB.SNC, 0x92)

}

 

Method (_Q86, 0, NotSerialized)

{

P8XH (0x00, 0x86)

SECR (HABP)

Notify (\_SB.PCI0.LPCB.SNC, 0x92)

}

 

Method (_Q87, 0, NotSerialized)

{

P8XH (0x00, 0x87)

SECR (HABR)

Notify (\_SB.PCI0.LPCB.SNC, 0x92)

}

 

Method (SECR, 1, NotSerialized)

{

Store (Arg0, \_SB.PCI0.LPCB.SNC.XECR)

}

 

Method (GECR, 0, NotSerialized)

{

Return (\_SB.PCI0.LPCB.SNC.XECR)

}

}

}

}

}

 

Scope (\_SB)

{

Device (BAT0)

{

Name (_HID, EisaId ("PNP0C0A"))

Name (_UID, 0x00)

Name (PSTA, 0x00)

Method (_STA, 0, NotSerialized)

{

\DBGC (0xB0, 0x00, BCEN)

Sleep (0x05)

If (LEqual (ECON, 0x00))

{

Store (0x00, Local1)

}

Else

{

Acquire (\_SB.PCI0.LPCB.EC.MECR, 0xFFFF)

Sleep (0x05)

Store (\_SB.PCI0.LPCB.EC.BATP, Local1)

Release (\_SB.PCI0.LPCB.EC.MECR)

}

 

If (LEqual (Local1, 0x00))

{

Store (0x0F, Local0)

}

Else

{

Store (0x1F, Local0)

}

 

Store (Local0, PSTA)

\DBGC (0xB0, 0x80, BCEN)

Return (Local0)

}

 

Name (MULV, 0x00)

Name (BATI, Package (0x0D)

{

0x00,

0x2710,

0x2710,

0x00,

0xFFFFFFFF,

0x03E8,

0x01,

0x64,

0x64,

"",

"",

"LiOn",

"Sony Corp."

})

Method (_BIF, 0, NotSerialized)

{

\DBGC (0xB1, 0x00, BCEN)

Store (0x01, MULV)

Sleep (0x05)

If (LEqual (ECON, 0x00)) {}

Else

{

Acquire (\_SB.PCI0.LPCB.EC.MECR, 0xFFFF)

Sleep (0x05)

And (\_SB.PCI0.LPCB.EC.OMFH, 0x80, Local0)

If (Local0)

{

Store (0x00, Index (BATI, 0x00))

Store (0x0A, MULV)

}

Else

{

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

}

 

Store (\_SB.PCI0.LPCB.EC.BDCH, Local0)

Or (ShiftLeft (Local0, 0x08), \_SB.PCI0.LPCB.EC.BDCL, Local0)

Store (Multiply (Local0, MULV), Index (BATI, 0x01))

Store (\_SB.PCI0.LPCB.EC.FCCH, Local0)

Or (ShiftLeft (Local0, 0x08), \_SB.PCI0.LPCB.EC.FCCL, Local0)

Store (Multiply (Local0, MULV), Index (BATI, 0x02))

Store (\_SB.PCI0.LPCB.EC.BAVH, Local0)

Or (ShiftLeft (Local0, 0x08), \_SB.PCI0.LPCB.EC.BAVL, Local0)

Store (Multiply (Local0, MULV), Index (BATI, 0x04))

Release (\_SB.PCI0.LPCB.EC.MECR)

}

 

\DBGC (0xB1, 0x80, BCEN)

Return (BATI)

}

 

Name (PKG0, Package (0x04)

{

0x02,

0xFFFFFFFF,

0xFFFFFFFF,

0xFFFFFFFF

})

Method (_BST, 0, NotSerialized)

{

\DBGC (0xB2, 0x00, BCEN)

Sleep (0x05)

If (LEqual (ECON, 0x00)) {}

Else

{

Acquire (\_SB.PCI0.LPCB.EC.MECR, 0xFFFF)

Sleep (0x05)

If (LEqual (\_SB.PCI0.LPCB.EC.CHGE, 0x01))

{

Store (\_SB.PCI0.LPCB.EC.RSCL, Local0)

If (LEqual (Local0, 0x64))

{

Store (0x00, Index (PKG0, 0x00))

}

Else

{

Store (0x02, Index (PKG0, 0x00))

}

}

Else

{

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

}

 

Name (MULV, 0x00)

And (\_SB.PCI0.LPCB.EC.OMFH, 0x80, Local0)

If (Local0)

{

Store (0x0A, MULV)

}

Else

{

Store (0x01, MULV)

}

 

Store (\_SB.PCI0.LPCB.EC.BRCH, Local0)

Or (ShiftLeft (Local0, 0x08), \_SB.PCI0.LPCB.EC.BRCL, Local0)

Store (Multiply (Local0, MULV), Index (PKG0, 0x02))

Store (\_SB.PCI0.LPCB.EC.BACH, Local0)

Or (ShiftLeft (Local0, 0x08), \_SB.PCI0.LPCB.EC.BACL, Local0)

If (LAnd (Local0, 0x8000))

{

Add (Not (Local0), 0x01, Local0)

And (Local0, 0xFFFF, Local0)

}

 

Store (\_SB.PCI0.LPCB.EC.BAVH, Local1)

Or (ShiftLeft (Local1, 0x08), \_SB.PCI0.LPCB.EC.BAVL, Local1)

Divide (Local1, 0x03E8, , Local1)

Store (Multiply (Local0, Local1), Index (PKG0, 0x01))

Release (\_SB.PCI0.LPCB.EC.MECR)

}

 

\DBGC (0xB2, 0x80, BCEN)

Return (PKG0)

}

 

Method (_PCL, 0, NotSerialized)

{

\DBGC (0xB3, 0x80, BCEN)

Return (\_SB)

}

}

}

 

Scope (\_SB)

{

Device (ADP1)

{

Name (_HID, "ACPI0003")

Method (_PSR, 0, NotSerialized)

{

\DBGC (0x40, 0x00, BCEN)

If (LEqual (ECON, 0x00))

{

And (PHSB (0xD4, 0x00), 0x80, Local0)

}

Else

{

Acquire (\_SB.PCI0.LPCB.EC.MECR, 0xFFFF)

Sleep (0x05)

Store (\_SB.PCI0.LPCB.EC.RPWR, Local0)

Release (\_SB.PCI0.LPCB.EC.MECR)

}

 

If (LEqual (Local0, 0x00))

{

Return (0x00)

}

Else

{

Return (0x01)

}

}

 

Method (_PCL, 0, NotSerialized)

{

Return (\_SB)

}

}

 

Device (LID0)

{

Name (_HID, EisaId ("PNP0C0D"))

Method (_LID, 0, NotSerialized)

{

\DBGC (0x41, 0x00, BCEN)

If (ECON)

{

Acquire (\_SB.PCI0.LPCB.EC.MECR, 0xFFFF)

Sleep (0x05)

Store (\_SB.PCI0.LPCB.EC.LSTE, Local0)

Release (\_SB.PCI0.LPCB.EC.MECR)

}

Else

{

And (PHSB (0xD4, 0x00), 0x20, Local0)

}

 

\DBGC (0x41, 0x80, BCEN)

Return (Local0)

}

}

 

Device (PWRB)

{

Name (_HID, EisaId ("PNP0C0C"))

Name (_PRW, Package (0x02)

{

0x1B,

0x04

})

}

}

 

Scope (\_TZ)

{

ThermalZone (TZ00)

{

Method (_CRT, 0, Serialized)

{

Return (Add (0x0AAC, Multiply (CRTT, 0x0A)))

}

 

Method (_PSV, 0, Serialized)

{

Return (Add (0x0AAC, Multiply (PSVT, 0x0A)))

}

 

Method (_TMP, 0, Serialized)

{

If (ECON)

{

Acquire (\_SB.PCI0.LPCB.EC.MECR, 0xFFFF)

Sleep (0x05)

Store (\_SB.PCI0.LPCB.EC.TS1R, Local0)

Release (\_SB.PCI0.LPCB.EC.MECR)

Return (Add (0x0AAC, Multiply (Local0, 0x0A)))

}

 

Return (0x0BC2)

}

}

 

ThermalZone (TZ01)

{

Method (_CRT, 0, Serialized)

{

Return (Add (0x0AAC, Multiply (CRTT, 0x0A)))

}

 

Method (_TMP, 0, Serialized)

{

If (ECON)

{

Acquire (\_SB.PCI0.LPCB.EC.MECR, 0xFFFF)

Sleep (0x05)

Store (\_SB.PCI0.LPCB.EC.TS1R, Local0)

Release (\_SB.PCI0.LPCB.EC.MECR)

Return (Add (0x0AAC, Multiply (Local0, 0x0A)))

}

 

Return (0x0BD6)

}

 

Method (_PSL, 0, Serialized)

{

If (LEqual (TCNT, 0x08))

{

Return (Package (0x08)

{

\_PR.CPU0,

\_PR.CPU1,

\_PR.CPU2,

\_PR.CPU3,

\_PR.CPU4,

\_PR.CPU5,

\_PR.CPU6,

\_PR.CPU7

})

}

 

If (LEqual (TCNT, 0x04))

{

Return (Package (0x04)

{

\_PR.CPU0,

\_PR.CPU1,

\_PR.CPU2,

\_PR.CPU3

})

}

 

If (LEqual (TCNT, 0x02))

{

Return (Package (0x02)

{

\_PR.CPU0,

\_PR.CPU1

})

}

 

Return (Package (0x01)

{

\_PR.CPU0

})

}

 

Method (_TC1, 0, Serialized)

{

Return (TC1V)

}

 

Method (_TC2, 0, Serialized)

{

Return (TC2V)

}

 

Method (_TSP, 0, Serialized)

{

Return (TSPV)

}

 

Method (_PSV, 0, Serialized)

{

Return (Add (0x0AAC, Multiply (PSVT, 0x0A)))

}

}

}

 

Scope (\)

{

Name (BTL0, Buffer (0x09)

{

/* 0000 */ 0x05, 0x08, 0x0B, 0x10, 0x17, 0x22, 0x30, 0x46,

/* 0008 */ 0x64

})

Name (BTL1, Buffer (0x09)

{

/* 0000 */ 0x15, 0x18, 0x1D, 0x24, 0x2C, 0x35, 0x3F, 0x4C,

/* 0008 */ 0x64

})

}

 

Scope (\_SB)

{

Scope (PCI0)

{

Scope (LPCB)

{

Device (SNC)

{

Name (_HID, EisaId ("SNY5001"))

Name (CPUT, 0x00)

Name (UPBR, 0x00)

Name (DNBR, 0x00)

Method (_INI, 0, NotSerialized)

{

Store (0x00, ALER)

}

 

Method (GBRT, 0, NotSerialized)

{

Store (0x00, Local1)

Store (PHS (0xC1), Local1)

And (Local1, 0x0F, Local1)

If (LGreater (Local1, 0x08))

{

Store (0x08, Local1)

PHSB (0xC2, Local1)

}

 

Return (Local1)

}

 

Method (SBRT, 1, NotSerialized)

{

If (LGreater (Arg0, 0x08))

{

Return (0x00)

}

 

PHSB (0xC2, Arg0)

If (LAnd (LGreater (PNID, 0x04), LLess (PNID, 0x09)))

{

Store (DerefOf (Index (\BTL1, Arg0)), Local0)

}

Else

{

Store (DerefOf (Index (\BTL0, Arg0)), Local0)

}

 

If (And (IGDS, IGDS))

{

\_SB.PCI0.GFX0.DD02._BCM (Local0)

}

Else

{

\_SB.PCI0.PEGP.VGA.LCD._BCM (Local0)

}

 

Return (0x00)

}

 

Method (PWAK, 0, NotSerialized)

{

\DBGC (0xF3, 0x00, BCEN)

If (LOr (LEqual (OSYS, 0x07D1), LEqual (OSYS, 0x07D2)))

{

Store (0x00, Local1)

Store (PHS (0xC1), Local1)

And (Local1, 0x0F, Local1)

If (LGreater (Local1, 0x08))

{

Store (0x08, Local1)

PHSB (0xC2, Local1)

}

 

If (LAnd (LGreater (PNID, 0x04), LLess (PNID, 0x09)))

{

Store (DerefOf (Index (BTL1, Local1)), Local2)

}

Else

{

Store (DerefOf (Index (BTL0, Local1)), Local2)

}

 

If (And (IGDS, IGDS))

{

Store (Local2, BRTL)

}

Else

{

\_SB.PCI0.PEGP.VGA.LCD._BCM (Local2)

}

}

 

PNOT ()

\DBGC (0xF3, 0x80, BCEN)

Return (Zero)

}

 

Name (EVS0, 0x07)

Name (EVS1, 0x00)

Name (EVS2, 0x00)

Mutex (MSNE, 0x00)

Method (GSNE, 1, NotSerialized)

{

Acquire (MSNE, 0xFFFF)

\DBGC (0xF1, 0x00, BCEN)

Store (ShiftRight (And (Arg0, 0xFF000000), 0x18), Local1)

Store (ShiftRight (And (Arg0, 0x00FF0000), 0x10), Local2)

Store (And (Arg0, 0xFFFF), Local3)

Store (0x00, Local0)

If (LEqual (Local1, 0x00))

{

If (LEqual (Local2, 0x00))

{

Store (And (Arg0, 0xFFFF0000), Local0)

Store (Or (Local0, 0x07), Local0)

}

 

If (LEqual (Local2, 0x01))

{

Store (And (Arg0, 0xFFFF0000), Local0)

Store (Or (Local0, 0x00), Local0)

}

 

If (LEqual (Local2, 0x02))

{

Store (And (Arg0, 0xFFFF0000), Local0)

Store (Or (Local0, 0x00), Local0)

}

}

Else

{

If (LEqual (Local1, 0x01))

{

If (LEqual (Local2, 0x00))

{

Store (And (Arg0, 0xFFFF0000), Local0)

Store (Or (Local0, EVS0), Local0)

}

 

If (LEqual (Local2, 0x01))

{

Store (And (Arg0, 0xFFFF0000), Local0)

Store (Or (Local0, EVS1), Local0)

}

 

If (LEqual (Local2, 0x02))

{

Store (And (Arg0, 0xFFFF0000), Local0)

Store (Or (Local0, EVS2), Local0)

}

}

Else

{

Store (Ones, Local0)

}

}

 

\DBGC (0xF1, 0x80, BCEN)

Release (MSNE)

Return (Local0)

}

 

Method (SSNE, 1, NotSerialized)

{

Acquire (MSNE, 0xFFFF)

\DBGC (0xF4, 0x00, BCEN)

Store (ShiftRight (And (Arg0, 0xFF000000), 0x18), Local1)

Store (ShiftRight (And (Arg0, 0x00FF0000), 0x10), Local2)

Store (And (Arg0, 0xFFFF), Local3)

Store (0x00, Local0)

If (LEqual (Local1, 0x00))

{

If (LEqual (Local2, 0x00))

{

Store (Or (Arg0, EVS0), EVS0)

}

 

If (LEqual (Local2, 0x01))

{

Store (Or (Arg0, EVS1), EVS1)

}

 

If (LEqual (Local2, 0x02))

{

Store (Or (Arg0, EVS2), EVS2)

}

}

Else

{

If (LEqual (Local1, 0x01))

{

If (LEqual (Local2, 0x00))

{

Store (And (EVS0, Not (Arg0)), EVS0)

}

 

If (LEqual (Local2, 0x01))

{

Store (And (EVS1, Not (Arg0)), EVS1)

}

 

If (LEqual (Local2, 0x02))

{

Store (And (EVS2, Not (Arg0)), EVS2)

}

}

}

 

\DBGC (0xF4, 0x80, BCEN)

Release (MSNE)

}

 

Method (SODV, 1, NotSerialized)

{

\DBGC (0xF6, 0x00, BCEN)

If (LNotEqual (DSEN, 0x00))

{

Return (Ones)

}

 

Store (Arg0, AODV)

If (LNot (And (AODV, CADD)))

{

Store (0x01, AODV)

}

 

If (LNotEqual (CADD, PADD))

{

Store (CADD, PADD)

Notify (\_SB.PCI0, 0x00)

And (PNHM, 0x000FFFF0, Local0)

If (Or (LEqual (Local0, 0x000106E0), LEqual (Local0, 0x000106A0)))

{

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

}

Else

{

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

}

 

Sleep (0x02EE)

}

 

\DBGC (0xF6, 0x80, BCEN)

Return (Zero)

}

 

Mutex (MIDB, 0x00)

Method (RBMF, 1, Serialized)

{

Acquire (MIDB, 0xFFFF)

\DBGC (0xF7, 0x00, BCEN)

And (Arg0, 0x00010000, Local0)

Store (PHSD (0xDC, Local0), Local0)

If (LEqual (Local0, 0x02))

{

Sleep (0x1388)

}

 

\DBGC (0xF7, 0x80, BCEN)

Release (MIDB)

Return (Local0)

}

 

Method (RSBI, 1, Serialized)

{

Return (Zero)

}

 

Method (CBMF, 1, Serialized)

{

Acquire (MIDB, 0xFFFF)

Or (And (Arg0, 0x0001FFFF), 0x02000000, Local0)

Store (PHSD (0xDC, Local0), Local0)

Release (MIDB)

Return (Zero)

}

 

Method (EAWK, 1, Serialized)

{

Acquire (MIDB, 0xFFFF)

PHSB (0xD3, 0x00)

Not (Arg0, Local0)

Release (MIDB)

Return (Local0)

}

 

Name (SNI0, 0x53636E53)

Name (SNI1, 0x6F707075)

Name (SNI2, 0x64657472)

Name (SNI3, 0x0100)

Name (SNI4, 0x38590000)

Name (SNIA, 0xCE75)

Name (SNN0, 0x0101)

Name (SNN1, 0x00)

Name (SNN2, 0x0100)

Name (SNN3, 0x00)

Name (SNN4, 0x0135)

Name (SNN5, 0x013A)

Name (SNN6, 0x0119)

Name (SNN7, 0x00)

Name (SNN8, 0x00)

Name (SNN9, 0x0136)

Name (SNNA, 0x011D)

Name (SNNB, 0x0114)

Name (SNNC, 0x00)

Name (SNND, 0x00)

Name (SNNE, 0x0105)

Name (SNNF, 0x0122)

Name (XECR, 0x00)

Name (ENMK, 0xFFEA)

Name (ENCR, 0x00)

Name (ESR, 0x00)

Method (SN00, 1, NotSerialized)

{

Store (And (Arg0, 0xFF), Local1)

If (LEqual (Local1, 0x00))

{

Return (SNI0)

}

 

If (LEqual (Local1, 0x01))

{

Return (SNI1)

}

 

If (LEqual (Local1, 0x02))

{

Return (SNI2)

}

 

If (LEqual (Local1, 0x03))

{

Return (SNI3)

}

 

If (LEqual (Local1, 0x04))

{

Return (SNI4)

}

 

If (LEqual (Local1, 0x10))

{

Return (SNIA)

}

 

If (LAnd (LGreaterEqual (Local1, 0x20), LLessEqual (Local1, 0x2F)))

{

Store (SNGN (Local1), Local2)

Return (Local2)

}

 

Return (0x00)

}

 

Method (SNGN, 1, NotSerialized)

{

Store (And (Arg0, 0x0F), Local1)

If (LEqual (Local1, 0x00))

{

Return (SNN0)

}

 

If (LEqual (Local1, 0x01))

{

Return (SNN1)

}

 

If (LEqual (Local1, 0x02))

{

Return (SNN2)

}

 

If (LEqual (Local1, 0x03))

{

Return (SNN3)

}

 

If (LEqual (Local1, 0x04))

{

Return (SNN4)

}

 

If (LEqual (Local1, 0x05))

{

Return (SNN5)

}

 

If (LEqual (Local1, 0x06))

{

Return (SNN6)

}

 

If (LEqual (Local1, 0x07))

{

Return (SNN7)

}

 

If (LEqual (Local1, 0x08))

{

Return (SNN8)

}

 

If (LEqual (Local1, 0x09))

{

Return (SNN9)

}

 

If (LEqual (Local1, 0x0A))

{

Return (SNNA)

}

 

If (LEqual (Local1, 0x0B))

{

Return (SNNB)

}

 

If (LEqual (Local1, 0x0C))

{

Return (SNNC)

}

 

If (LEqual (Local1, 0x0D))

{

Return (SNND)

}

 

If (LEqual (Local1, 0x0E))

{

Return (SNNE)

}

 

If (LEqual (Local1, 0x0F))

{

Return (SNNF)

}

 

Return (0x00)

}

 

Mutex (SNM0, 0x00)

Method (SN01, 0, NotSerialized)

{

Acquire (SNM0, 0xFFFF)

Store (PHS (0xD6), Local1)

And (Local1, Not (ENMK), Local1)

And (ENCR, ENMK, Local2)

Or (Local1, Local2, Local1)

Release (SNM0)

Return (Local1)

}

 

Method (SN02, 1, NotSerialized)

{

Acquire (SNM0, 0xFFFF)

Store (Arg0, Local1)

If (LNotEqual (Local1, 0x00))

{

And (Local1, Not (ENMK), Local2)

If (LNotEqual (Local2, 0x00))

{

PHSD (0xD7, Local2)

}

 

And (Local1, ENMK, Local2)

If (LNotEqual (Local2, 0x00))

{

And (ENCR, ENMK, Local3)

Or (Local3, Local2, ENCR)

}

}

 

Release (SNM0)

}

 

Method (SN03, 1, NotSerialized)

{

Acquire (SNM0, 0xFFFF)

Store (Arg0, Local1)

If (LNotEqual (Local1, 0x00))

{

And (Local1, Not (ENMK), Local2)

If (LNotEqual (Local2, 0x00))

{

PHSD (0xD8, Local1)

}

 

And (Local1, ENMK, Local2)

If (LNotEqual (Local2, 0x00))

{

And (ENCR, ENMK, Local3)

And (Local3, Not (Local2), ENCR)

}

}

 

Release (SNM0)

}

 

Method (SN04, 0, NotSerialized)

{

Acquire (\_SB.PCI0.LPCB.EC.MECR, 0xFFFF)

Sleep (0x05)

Store (\_SB.PCI0.LPCB.EC.ESR0, Local1)

Release (\_SB.PCI0.LPCB.EC.MECR)

And (Local1, Not (ENMK), Local1)

And (ESR, ENMK, Local2)

Or (Local1, Local2, Local1)

Return (Local1)

}

 

Method (SN05, 1, NotSerialized)

{

Store (Arg0, Local1)

If (LNotEqual (Local1, 0x00))

{

And (Local1, Not (ENMK), Local2)

If (LNotEqual (Local2, 0x00))

{

PHSD (0xDA, Local1)

}

 

And (Local1, ENMK, Local2)

If (LNotEqual (Local2, 0x00))

{

And (ESR, ENMK, Local3)

And (Local3, Not (Local2), ESR)

}

}

}

 

Mutex (SNM1, 0x00)

Mutex (SNM2, 0x00)

Name (SNBF, Buffer (0x0410) {})

CreateField (SNBF, 0x00, 0x20, SNBD)

Method (SN06, 1, NotSerialized)

{

Acquire (SNM2, 0xFFFF)

Store (Arg0, SNBF)

SNCM ()

Release (SNM2)

Return (SNBF)

}

 

Method (SNCM, 0, NotSerialized)

{

Acquire (SNM1, 0xFFFF)

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

\DBGC (0xF0, Local0, BCEN)

And (Local0, 0x0F, Local0)

If (LEqual (Local0, 0x00))

{

SNF0 (SNBF)

}

Else

{

If (LEqual (Local0, 0x02))

{

SNF2 (SNBF)

}

Else

{

If (LEqual (Local0, 0x04))

{

SNF4 (SNBF)

}

Else

{

If (LEqual (Local0, 0x05))

{

SNF5 (SNBF)

}

Else

{

If (LEqual (Local0, 0x06))

{

SNF6 (SNBF)

}

Else

{

If (LEqual (Local0, 0x09))

{

SNF9 (SNBF)

}

Else

{

If (LEqual (Local0, 0x0A))

{

SNFA (SNBF)

}

Else

{

If (LEqual (Local0, 0x0B))

{

SNFB (SNBF)

}

Else

{

If (LEqual (Local0, 0x0E))

{

SNFE (SNBF)

}

Else

{

If (LEqual (Local0, 0x0F))

{

SNFF (SNBF)

}

Else

{

}

}

}

}

}

}

}

}

}

}

 

Release (SNM1)

Return (SNBF)

}

 

Method (SN07, 1, NotSerialized)

{

Acquire (SNM2, 0xFFFF)

Store (Arg0, Local0)

Store (Local0, SNBD)

SNCM ()

Release (SNM2)

Return (SNBD)

}

 

Method (SNF0, 1, NotSerialized)

{

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

If (LEqual (Local0, 0x00))

{

Store (0x01, Local1)

PHSB (0xD0, Local1)

}

Else

{

If (LEqual (Local0, 0x01))

{

Store (0x01, Local1)

PHSB (0xD1, Local1)

}

Else

{

}

}

 

\DBGC (0x70, 0x80, BCEN)

Return (SNBF)

}

 

Method (SNF1, 1, NotSerialized)

{

\DBGC (0x71, 0x80, BCEN)

Return (SNBF)

}

 

Method (SNF2, 1, NotSerialized)

{

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

If (LEqual (Local0, 0x00))

{

Store (0x04, Local1)

PHSB (0xD0, Local1)

}

Else

{

If (LEqual (Local0, 0x01))

{

Store (0x04, Local1)

PHSB (0xD1, Local1)

}

Else

{

If (LEqual (Local0, 0x02))

{

Acquire (\_SB.PCI0.LPCB.EC.MECR, 0xFFFF)

Sleep (0x05)

Store (\_SB.PCI0.LPCB.EC.GECR (), Local1)

Release (\_SB.PCI0.LPCB.EC.MECR)

Store (Local1, Index (SNBF, 0x00))

}

Else

{

}

}

}

 

\DBGC (0x72, 0x80, BCEN)

}

 

Method (SNF3, 1, NotSerialized)

{

\DBGC (0x73, 0x80, BCEN)

Return (SNBF)

}

 

Method (SNF4, 1, NotSerialized)

{

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

If (LEqual (Local0, 0x00))

{

Store (PHS (0xE7), Local1)

Store (Local1, SNBF)

}

 

If (LEqual (Local0, 0x01))

{

ShiftRight (And (Store (SN04 (), Local1), 0x10), 0x04, Local1)

Store (Local1, Index (SNBF, 0x00))

}

Else

{

If (LEqual (Local0, 0x02))

{

Store (PHS (0xDD), Local1)

Store (And (Local1, 0x01), Index (SNBF, 0x00))

}

Else

{

If (LEqual (Local0, 0x03))

{

Store (PHS (0xDD), Local1)

ShiftRight (And (Local1, 0x06), 0x01, Local1)

Store (Local1, Index (SNBF, 0x00))

}

Else

{

If (LEqual (Local0, 0x04))

{

Store (DerefOf (Index (SNBF, 0x02)), Local1)

And (Local1, 0x03, Local1)

PHSD (0xDE, Local1)

}

Else

{

If (LEqual (Local0, 0x05))

{

Store (PHS (0xDD), Local1)

ShiftRight (And (Local1, 0x30), 0x04, Local1)

Store (Local1, Index (SNBF, 0x00))

}

Else

{

If (LEqual (Local0, 0x06))

{

Store (DerefOf (Index (SNBF, 0x02)), Local1)

And (Local1, 0x03, Local1)

PHSD (0xDF, Local1)

}

Else

{

If (LEqual (Local0, 0x09))

{

Store (PHS (0xDD), Local1)

ShiftRight (And (Local1, 0x3000), 0x0C, Local1)

Store (Local1, Index (SNBF, 0x00))

}

Else

{

If (LEqual (Local0, 0x0A))

{

Store (DerefOf (Index (SNBF, 0x02)), Local1)

And (Local1, 0x03, Local1)

PHSD (0xEC, Local1)

}

Else

{

}

}

}

}

}

}

}

}

 

\DBGC (0x74, 0x80, BCEN)

Return (SNBF)

}

 

Method (SNF5, 1, NotSerialized)

{

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

If (LEqual (Local0, 0x00))

{

Acquire (\_SB.PCI0.LPCB.EC.MECR, 0xFFFF)

Sleep (0x05)

Store (\_SB.PCI0.LPCB.EC.ISID, Local1)

Release (\_SB.PCI0.LPCB.EC.MECR)

If (LEqual (Local1, 0x05))

{

Store (0x01, Local1)

}

Else

{

Store (0x00, Local1)

}

 

Store (Local1, Index (SNBF, 0x00))

\DBGC (0x75, 0x80, BCEN)

Return (SNBF)

}

Else

{

If (LEqual (Local0, 0x01))

{

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

And (Local2, 0x01, Local2)

Store (Local2, ATFR)

}

Else

{

}

}

}

 

Method (SNF6, 1, NotSerialized)

{

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

If (LEqual (Local0, 0x00))

{

Store (PHSB (0xF4, 0x55), Local1)

And (Local1, 0x07, Local1)

Store (Local1, Index (SNBF, 0x00))

}

 

If (LEqual (Local0, 0x01))

{

Store (DerefOf (Index (SNBF, 0x02)), Local1)

And (Local1, 0x06, Local1)

PHSB (0xF4, Local1)

}

 

\DBGC (0x76, 0x80, BCEN)

Return (SNBF)

}

 

Method (SNF7, 1, NotSerialized)

{

\DBGC (0x77, 0x80, BCEN)

Return (SNBF)

}

 

Method (SNF8, 1, NotSerialized)

{

\DBGC (0x78, 0x80, BCEN)

Return (SNBF)

}

 

Method (SNF9, 1, NotSerialized)

{

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

If (LEqual (Local0, 0x00))

{

Store (PHS (0xE4), Local1)

Store (And (Local1, 0xF5), Index (SNBF, 0x00))

}

Else

{

If (LEqual (Local0, 0x01))

{

Store (DerefOf (Index (SNBF, 0x02)), Local1)

PHSD (0xE5, Local1)

}

Else

{

If (LEqual (Local0, 0x02))

{

Store (PHS (0xF3), Local1)

Store (Local1, Index (SNBF, 0x00))

}

}

}

 

\DBGC (0x79, 0x80, BCEN)

Return (SNBF)

}

 

Method (SNFA, 1, NotSerialized)

{

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

If (LEqual (Local0, 0x00))

{

Store (\PNID, Index (SNBF, 0x00))

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

}

Else

{

}

 

\DBGC (0x7A, 0x80, BCEN)

Return (SNBF)

}

 

Method (SNFB, 1, NotSerialized)

{

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

If (LEqual (Local0, 0x00))

{

Acquire (MIDB, 0xFFFF)

Store (PHSD (0xDC, 0x00), Local1)

If (LEqual (Local1, 0x02))

{

Sleep (0x1388)

}

 

Release (MIDB)

Store (And (Local1, 0x07), Index (SNBF, 0x00))

}

 

\DBGC (0x7B, 0x80, BCEN)

Return (SNBF)

}

 

Method (SNFC, 1, NotSerialized)

{

\DBGC (0x7C, 0x80, BCEN)

Return (SNBF)

}

 

Method (SNFD, 1, NotSerialized)

{

\DBGC (0x7D, 0x80, BCEN)

Return (SNBF)

}

 

Method (SNFE, 1, NotSerialized)

{

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

If (LEqual (Local0, 0x00))

{

Store (PHS (0xC7), Local1)

And (Local1, 0xFF, Local1)

If (LEqual (Local1, 0xFE))

{

Store (0x01, Local1)

}

Else

{

Store (0x00, Local1)

}

 

Store (Local1, Index (SNBF, 0x00))

Return (SNBF)

}

Else

{

If (LEqual (Local0, 0x01))

{

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

And (Local2, 0x01, Local2)

If (LEqual (Local2, 0x00))

{

Store (0xA0, Local3)

}

Else

{

Store (0xA1, Local3)

}

 

PHSB (0xC8, Local3)

}

Else

{

}

}

 

\DBGC (0x7E, 0x80, BCEN)

Return (SNBF)

}

 

Method (SNFF, 1, NotSerialized)

{

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

If (LEqual (Local0, 0x00))

{

Store (0x02, Local1)

Store (Local1, Index (SNBF, 0x00))

}

 

If (LEqual (Local0, 0x01))

{

Store (0x00, Local1)

Store (PHS (0xF2), Local1)

P8XH (0x00, Local1)

And (Local1, 0x03, Local1)

Store (Local1, Index (SNBF, 0x00))

}

Else

{

If (LEqual (Local0, 0x02))

{

Store (DerefOf (Index (SNBF, 0x02)), Local1)

P8XH (0x00, Local1)

And (Local1, 0x03, Local1)

PHSB (0xE8, Local1)

If (SEAM)

{

Store (0x4A, MTL)

Store (0x54, PSVT)

Store (0x58, CRTT)

}

Else

{

Store (0x55, MTL)

Store (0x63, PSVT)

Store (0x67, CRTT)

}

 

Notify (\_TZ.TZ00, 0x81)

Notify (\_TZ.TZ01, 0x81)

}

}

 

\DBGC (0x7F, 0x80, BCEN)

Return (SNBF)

}

}

}

}

}

 

Scope (\)

{

Name (\AODV, 0x00)

Name (\CADD, 0x00)

Name (\PADD, 0x00)

}

 

Name (\_S0, Package (0x04)

{

0x00,

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) {}

}

 

Method (WAK, 1, NotSerialized)

{

}

}

Link to comment
Share on other sites