Re: [PATCH 1/1] Force ELAN06FA touchpad I2C bus freq to 100KHz

R Ha
2025-01-10T08:31:38Z

[-- Attachment #1: Type: text/plain, Size: 1125 bytes --]

Hi,

Sounds like a good idea. I'm a little worried I'm missing something,
so I think being able to check my earlier answers will help as well.
I'm sending the entire output as attachments, but let me know if it's
better to upload them somewhere and paste the link instead. Some of
the ssdt* files are missing, but they're empty files so Gmail won't
let me attach them.

On Thu, Jan 9, 2025 at 5:19 AM Mika Westerberg
<mika.westerberg@linux.intel.com> wrote:
>
> Hi,
>
> On Wed, Jan 08, 2025 at 03:29:34AM -0600, R Ha wrote:
> > On Tue, Jan 7, 2025 at 11:51 PM Mika Westerberg
> > <mika.westerberg@linux.intel.com> wrote:
> > > There should be Device() node for that too. The ones you listed are just
> > > child devices connected to that bus.
> >
> > You're right, after searching for Device nodes I was able to find this
> > snippet. But it doesn't seem to have anything related to HCNT/LCNT
> > values either, but maybe they're hidden somewhere.
> > Thanks for the tip again.
>
> Can you share the whole acpidump? It is easier for us to check the
> necessary descriptions directly from that.

[-- Attachment #2: dmar.dsl --]
[-- Type: text/x-dsl, Size: 4110 bytes --]

/*
* Intel ACPI Component Architecture
* AML/ASL+ Disassembler version 20240927 (64-bit version)
* Copyright (c) 2000 - 2023 Intel Corporation
*
* Disassembly of dmar.dat
*
* ACPI Data Table [DMAR]
*
* Format: [HexOffset DecimalOffset ByteLength] FieldName : FieldValue (in hex)
*/

[000h 0000 004h] Signature : "DMAR" [DMA Remapping Table]
[004h 0004 004h] Table Length : 00000088
[008h 0008 001h] Revision : 01
[009h 0009 001h] Checksum : 57
[00Ah 0010 006h] Oem ID : "LENOVO"
[010h 0016 008h] Oem Table ID : "CB-01 "
[018h 0024 004h] Oem Revision : 00000001
[01Ch 0028 004h] Asl Compiler ID : "ACPI"
[020h 0032 004h] Asl Compiler Revision : 00040000

[024h 0036 001h] Host Address Width : 26
[025h 0037 001h] Flags : 05
[026h 0038 00Ah] Reserved : 00 00 00 00 00 00 00 00 00 00

[030h 0048 002h] Subtable Type : 0000 [Hardware Unit Definition]
[032h 0050 002h] Length : 0018

[034h 0052 001h] Flags : 00
[035h 0053 001h] Reserved : 00
[036h 0054 002h] PCI Segment Number : 0000
[038h 0056 008h] Register Base Address : 00000000FED90000

[040h 0064 001h] Device Scope Type : 01 [PCI Endpoint Device]
[041h 0065 001h] Entry Length : 08
[042h 0066 002h] Reserved : 0000
[044h 0068 001h] Enumeration ID : 00
[045h 0069 001h] PCI Bus Number : 00

[046h 0070 002h] PCI Path : 02,00

[048h 0072 002h] Subtable Type : 0000 [Hardware Unit Definition]
[04Ah 0074 002h] Length : 0020

[04Ch 0076 001h] Flags : 01
[04Dh 0077 001h] Reserved : 00
[04Eh 0078 002h] PCI Segment Number : 0000
[050h 0080 008h] Register Base Address : 00000000FED91000

[058h 0088 001h] Device Scope Type : 03 [IOAPIC Device]
[059h 0089 001h] Entry Length : 08
[05Ah 0090 002h] Reserved : 0000
[05Ch 0092 001h] Enumeration ID : 02
[05Dh 0093 001h] PCI Bus Number : 00

[05Eh 0094 002h] PCI Path : 1E,07

[060h 0096 001h] Device Scope Type : 04 [Message-capable HPET Device]
[061h 0097 001h] Entry Length : 08
[062h 0098 002h] Reserved : 0000
[064h 0100 001h] Enumeration ID : 00
[065h 0101 001h] PCI Bus Number : 00

[066h 0102 002h] PCI Path : 1E,06

[068h 0104 002h] Subtable Type : 0001 [Reserved Memory Region]
[06Ah 0106 002h] Length : 0020

[06Ch 0108 002h] Reserved : 0000
[06Eh 0110 002h] PCI Segment Number : 0000
[070h 0112 008h] Base Address : 000000004C000000
[078h 0120 008h] End Address (limit) : 00000000503FFFFF

[080h 0128 001h] Device Scope Type : 01 [PCI Endpoint Device]
[081h 0129 001h] Entry Length : 08
[082h 0130 002h] Reserved : 0000
[084h 0132 001h] Enumeration ID : 00
[085h 0133 001h] PCI Bus Number : 00

[086h 0134 002h] PCI Path : 02,00

Raw Table Data: Length 136 (0x88)

0000: 44 4D 41 52 88 00 00 00 01 57 4C 45 4E 4F 56 4F // DMAR.....WLENOVO
0010: 43 42 2D 30 31 20 20 20 01 00 00 00 41 43 50 49 // CB-01 ....ACPI
0020: 00 00 04 00 26 05 00 00 00 00 00 00 00 00 00 00 // ....&...........
0030: 00 00 18 00 00 00 00 00 00 00 D9 FE 00 00 00 00 // ................
0040: 01 08 00 00 00 00 02 00 00 00 20 00 01 00 00 00 // .......... .....
0050: 00 10 D9 FE 00 00 00 00 03 08 00 00 02 00 1E 07 // ................
0060: 04 08 00 00 00 00 1E 06 01 00 20 00 00 00 00 00 // .......... .....
0070: 00 00 00 4C 00 00 00 00 FF FF 3F 50 00 00 00 00 // ...L......?P....
0080: 01 08 00 00 00 00 02 00 // ........

[-- Attachment #3: bgrt.dsl --]
[-- Type: text/x-dsl, Size: 1589 bytes --]

/*
* Intel ACPI Component Architecture
* AML/ASL+ Disassembler version 20240927 (64-bit version)
* Copyright (c) 2000 - 2023 Intel Corporation
*
* Disassembly of bgrt.dat
*
* ACPI Data Table [BGRT]
*
* Format: [HexOffset DecimalOffset ByteLength] FieldName : FieldValue (in hex)
*/

[000h 0000 004h] Signature : "BGRT" [Boot Graphics Resource Table]
[004h 0004 004h] Table Length : 00000038
[008h 0008 001h] Revision : 01
[009h 0009 001h] Checksum : 7D
[00Ah 0010 006h] Oem ID : "LENOVO"
[010h 0016 008h] Oem Table ID : "CB-01 "
[018h 0024 004h] Oem Revision : 00000001
[01Ch 0028 004h] Asl Compiler ID : "ACPI"
[020h 0032 004h] Asl Compiler Revision : 00040000

[024h 0036 002h] Version : 0001
[026h 0038 001h] Status (decoded below) : 00
Displayed : 0
Orientation Offset : 0
[027h 0039 001h] Image Type : 00
[028h 0040 008h] Image Address : 0000000038D15000
[030h 0048 004h] Image OffsetX : 0000023B
[034h 0052 004h] Image OffsetY : 0000011B

Raw Table Data: Length 56 (0x38)

0000: 42 47 52 54 38 00 00 00 01 7D 4C 45 4E 4F 56 4F // BGRT8....}LENOVO
0010: 43 42 2D 30 31 20 20 20 01 00 00 00 41 43 50 49 // CB-01 ....ACPI
0020: 00 00 04 00 01 00 00 00 00 50 D1 38 00 00 00 00 // .........P.8....
0030: 3B 02 00 00 1B 01 00 00 // ;.......

[-- Attachment #4: dbgp.dsl --]
[-- Type: text/x-dsl, Size: 1622 bytes --]

/*
* Intel ACPI Component Architecture
* AML/ASL+ Disassembler version 20240927 (64-bit version)
* Copyright (c) 2000 - 2023 Intel Corporation
*
* Disassembly of dbgp.dat
*
* ACPI Data Table [DBGP]
*
* Format: [HexOffset DecimalOffset ByteLength] FieldName : FieldValue (in hex)
*/

[000h 0000 004h] Signature : "DBGP" [Debug Port Table]
[004h 0004 004h] Table Length : 00000034
[008h 0008 001h] Revision : 01
[009h 0009 001h] Checksum : 42
[00Ah 0010 006h] Oem ID : "LENOVO"
[010h 0016 008h] Oem Table ID : "CB-01 "
[018h 0024 004h] Oem Revision : 00000001
[01Ch 0028 004h] Asl Compiler ID : "ACPI"
[020h 0032 004h] Asl Compiler Revision : 00040000

[024h 0036 001h] Interface Type : 00
[025h 0037 003h] Reserved : 000000

[028h 0040 00Ch] Debug Port Register : [Generic Address Structure]
[028h 0040 001h] Space ID : 01 [SystemIO]
[029h 0041 001h] Bit Width : 08
[02Ah 0042 001h] Bit Offset : 00
[02Bh 0043 001h] Encoded Access Width : 00 [Undefined/Legacy]
[02Ch 0044 008h] Address : 00000000000003F8

Raw Table Data: Length 52 (0x34)

0000: 44 42 47 50 34 00 00 00 01 42 4C 45 4E 4F 56 4F // DBGP4....BLENOVO
0010: 43 42 2D 30 31 20 20 20 01 00 00 00 41 43 50 49 // CB-01 ....ACPI
0020: 00 00 04 00 00 00 00 00 01 08 00 00 F8 03 00 00 // ................
0030: 00 00 00 00 // ....

[-- Attachment #5: apic.dsl --]
[-- Type: text/x-dsl, Size: 25516 bytes --]

/*
* Intel ACPI Component Architecture
* AML/ASL+ Disassembler version 20240927 (64-bit version)
* Copyright (c) 2000 - 2023 Intel Corporation
*
* Disassembly of apic.dat
*
* ACPI Data Table [APIC]
*
* Format: [HexOffset DecimalOffset ByteLength] FieldName : FieldValue (in hex)
*/

[000h 0000 004h] Signature : "APIC" [Multiple APIC Description Table (MADT)]
[004h 0004 004h] Table Length : 000001DC
[008h 0008 001h] Revision : 03
[009h 0009 001h] Checksum : 70
[00Ah 0010 006h] Oem ID : "LENOVO"
[010h 0016 008h] Oem Table ID : "CB-01 "
[018h 0024 004h] Oem Revision : 00000001
[01Ch 0028 004h] Asl Compiler ID : "ACPI"
[020h 0032 004h] Asl Compiler Revision : 00040000

[024h 0036 004h] Local Apic Address : FEE00000
[028h 0040 004h] Flags (decoded below) : 00000001
PC-AT Compatibility : 1

[02Ch 0044 001h] Subtable Type : 00 [Processor Local APIC]
[02Dh 0045 001h] Length : 08
[02Eh 0046 001h] Processor ID : 00
[02Fh 0047 001h] Local Apic ID : 00
[030h 0048 004h] Flags (decoded below) : 00000001
Processor Enabled : 1
Runtime Online Capable : 0

[034h 0052 001h] Subtable Type : 00 [Processor Local APIC]
[035h 0053 001h] Length : 08
[036h 0054 001h] Processor ID : 01
[037h 0055 001h] Local Apic ID : 01
[038h 0056 004h] Flags (decoded below) : 00000001
Processor Enabled : 1
Runtime Online Capable : 0

[03Ch 0060 001h] Subtable Type : 00 [Processor Local APIC]
[03Dh 0061 001h] Length : 08
[03Eh 0062 001h] Processor ID : 02
[03Fh 0063 001h] Local Apic ID : 08
[040h 0064 004h] Flags (decoded below) : 00000001
Processor Enabled : 1
Runtime Online Capable : 0

[044h 0068 001h] Subtable Type : 00 [Processor Local APIC]
[045h 0069 001h] Length : 08
[046h 0070 001h] Processor ID : 03
[047h 0071 001h] Local Apic ID : 09
[048h 0072 004h] Flags (decoded below) : 00000001
Processor Enabled : 1
Runtime Online Capable : 0

[04Ch 0076 001h] Subtable Type : 00 [Processor Local APIC]
[04Dh 0077 001h] Length : 08
[04Eh 0078 001h] Processor ID : 04
[04Fh 0079 001h] Local Apic ID : 10
[050h 0080 004h] Flags (decoded below) : 00000001
Processor Enabled : 1
Runtime Online Capable : 0

[054h 0084 001h] Subtable Type : 00 [Processor Local APIC]
[055h 0085 001h] Length : 08
[056h 0086 001h] Processor ID : 05
[057h 0087 001h] Local Apic ID : 12
[058h 0088 004h] Flags (decoded below) : 00000001
Processor Enabled : 1
Runtime Online Capable : 0

[05Ch 0092 001h] Subtable Type : 00 [Processor Local APIC]
[05Dh 0093 001h] Length : 08
[05Eh 0094 001h] Processor ID : 06
[05Fh 0095 001h] Local Apic ID : 14
[060h 0096 004h] Flags (decoded below) : 00000001
Processor Enabled : 1
Runtime Online Capable : 0

[064h 0100 001h] Subtable Type : 00 [Processor Local APIC]
[065h 0101 001h] Length : 08
[066h 0102 001h] Processor ID : 07
[067h 0103 001h] Local Apic ID : 16
[068h 0104 004h] Flags (decoded below) : 00000001
Processor Enabled : 1
Runtime Online Capable : 0

[06Ch 0108 001h] Subtable Type : 00 [Processor Local APIC]
[06Dh 0109 001h] Length : 08
[06Eh 0110 001h] Processor ID : 08
[06Fh 0111 001h] Local Apic ID : 18
[070h 0112 004h] Flags (decoded below) : 00000001
Processor Enabled : 1
Runtime Online Capable : 0

[074h 0116 001h] Subtable Type : 00 [Processor Local APIC]
[075h 0117 001h] Length : 08
[076h 0118 001h] Processor ID : 09
[077h 0119 001h] Local Apic ID : 1A
[078h 0120 004h] Flags (decoded below) : 00000001
Processor Enabled : 1
Runtime Online Capable : 0

[07Ch 0124 001h] Subtable Type : 00 [Processor Local APIC]
[07Dh 0125 001h] Length : 08
[07Eh 0126 001h] Processor ID : 0A
[07Fh 0127 001h] Local Apic ID : 1C
[080h 0128 004h] Flags (decoded below) : 00000001
Processor Enabled : 1
Runtime Online Capable : 0

[084h 0132 001h] Subtable Type : 00 [Processor Local APIC]
[085h 0133 001h] Length : 08
[086h 0134 001h] Processor ID : 0B
[087h 0135 001h] Local Apic ID : 1E
[088h 0136 004h] Flags (decoded below) : 00000001
Processor Enabled : 1
Runtime Online Capable : 0

[08Ch 0140 001h] Subtable Type : 00 [Processor Local APIC]
[08Dh 0141 001h] Length : 08
[08Eh 0142 001h] Processor ID : 0C
[08Fh 0143 001h] Local Apic ID : FF
[090h 0144 004h] Flags (decoded below) : 00000000
Processor Enabled : 0
Runtime Online Capable : 0

[094h 0148 001h] Subtable Type : 00 [Processor Local APIC]
[095h 0149 001h] Length : 08
[096h 0150 001h] Processor ID : 0D
[097h 0151 001h] Local Apic ID : FF
[098h 0152 004h] Flags (decoded below) : 00000000
Processor Enabled : 0
Runtime Online Capable : 0

[09Ch 0156 001h] Subtable Type : 00 [Processor Local APIC]
[09Dh 0157 001h] Length : 08
[09Eh 0158 001h] Processor ID : 0E
[09Fh 0159 001h] Local Apic ID : FF
[0A0h 0160 004h] Flags (decoded below) : 00000000
Processor Enabled : 0
Runtime Online Capable : 0

[0A4h 0164 001h] Subtable Type : 00 [Processor Local APIC]
[0A5h 0165 001h] Length : 08
[0A6h 0166 001h] Processor ID : 0F
[0A7h 0167 001h] Local Apic ID : FF
[0A8h 0168 004h] Flags (decoded below) : 00000000
Processor Enabled : 0
Runtime Online Capable : 0

[0ACh 0172 001h] Subtable Type : 00 [Processor Local APIC]
[0ADh 0173 001h] Length : 08
[0AEh 0174 001h] Processor ID : 10
[0AFh 0175 001h] Local Apic ID : FF
[0B0h 0176 004h] Flags (decoded below) : 00000000
Processor Enabled : 0
Runtime Online Capable : 0

[0B4h 0180 001h] Subtable Type : 00 [Processor Local APIC]
[0B5h 0181 001h] Length : 08
[0B6h 0182 001h] Processor ID : 11
[0B7h 0183 001h] Local Apic ID : FF
[0B8h 0184 004h] Flags (decoded below) : 00000000
Processor Enabled : 0
Runtime Online Capable : 0

[0BCh 0188 001h] Subtable Type : 00 [Processor Local APIC]
[0BDh 0189 001h] Length : 08
[0BEh 0190 001h] Processor ID : 12
[0BFh 0191 001h] Local Apic ID : FF
[0C0h 0192 004h] Flags (decoded below) : 00000000
Processor Enabled : 0
Runtime Online Capable : 0

[0C4h 0196 001h] Subtable Type : 00 [Processor Local APIC]
[0C5h 0197 001h] Length : 08
[0C6h 0198 001h] Processor ID : 13
[0C7h 0199 001h] Local Apic ID : FF
[0C8h 0200 004h] Flags (decoded below) : 00000000
Processor Enabled : 0
Runtime Online Capable : 0

[0CCh 0204 001h] Subtable Type : 00 [Processor Local APIC]
[0CDh 0205 001h] Length : 08
[0CEh 0206 001h] Processor ID : 14
[0CFh 0207 001h] Local Apic ID : FF
[0D0h 0208 004h] Flags (decoded below) : 00000000
Processor Enabled : 0
Runtime Online Capable : 0

[0D4h 0212 001h] Subtable Type : 00 [Processor Local APIC]
[0D5h 0213 001h] Length : 08
[0D6h 0214 001h] Processor ID : 15
[0D7h 0215 001h] Local Apic ID : FF
[0D8h 0216 004h] Flags (decoded below) : 00000000
Processor Enabled : 0
Runtime Online Capable : 0

[0DCh 0220 001h] Subtable Type : 00 [Processor Local APIC]
[0DDh 0221 001h] Length : 08
[0DEh 0222 001h] Processor ID : 16
[0DFh 0223 001h] Local Apic ID : FF
[0E0h 0224 004h] Flags (decoded below) : 00000000
Processor Enabled : 0
Runtime Online Capable : 0

[0E4h 0228 001h] Subtable Type : 00 [Processor Local APIC]
[0E5h 0229 001h] Length : 08
[0E6h 0230 001h] Processor ID : 17
[0E7h 0231 001h] Local Apic ID : FF
[0E8h 0232 004h] Flags (decoded below) : 00000000
Processor Enabled : 0
Runtime Online Capable : 0

[0ECh 0236 001h] Subtable Type : 00 [Processor Local APIC]
[0EDh 0237 001h] Length : 08
[0EEh 0238 001h] Processor ID : 18
[0EFh 0239 001h] Local Apic ID : FF
[0F0h 0240 004h] Flags (decoded below) : 00000000
Processor Enabled : 0
Runtime Online Capable : 0

[0F4h 0244 001h] Subtable Type : 00 [Processor Local APIC]
[0F5h 0245 001h] Length : 08
[0F6h 0246 001h] Processor ID : 19
[0F7h 0247 001h] Local Apic ID : FF
[0F8h 0248 004h] Flags (decoded below) : 00000000
Processor Enabled : 0
Runtime Online Capable : 0

[0FCh 0252 001h] Subtable Type : 00 [Processor Local APIC]
[0FDh 0253 001h] Length : 08
[0FEh 0254 001h] Processor ID : 1A
[0FFh 0255 001h] Local Apic ID : FF
[100h 0256 004h] Flags (decoded below) : 00000000
Processor Enabled : 0
Runtime Online Capable : 0

[104h 0260 001h] Subtable Type : 00 [Processor Local APIC]
[105h 0261 001h] Length : 08
[106h 0262 001h] Processor ID : 1B
[107h 0263 001h] Local Apic ID : FF
[108h 0264 004h] Flags (decoded below) : 00000000
Processor Enabled : 0
Runtime Online Capable : 0

[10Ch 0268 001h] Subtable Type : 00 [Processor Local APIC]
[10Dh 0269 001h] Length : 08
[10Eh 0270 001h] Processor ID : 1C
[10Fh 0271 001h] Local Apic ID : FF
[110h 0272 004h] Flags (decoded below) : 00000000
Processor Enabled : 0
Runtime Online Capable : 0

[114h 0276 001h] Subtable Type : 00 [Processor Local APIC]
[115h 0277 001h] Length : 08
[116h 0278 001h] Processor ID : 1D
[117h 0279 001h] Local Apic ID : FF
[118h 0280 004h] Flags (decoded below) : 00000000
Processor Enabled : 0
Runtime Online Capable : 0

[11Ch 0284 001h] Subtable Type : 00 [Processor Local APIC]
[11Dh 0285 001h] Length : 08
[11Eh 0286 001h] Processor ID : 1E
[11Fh 0287 001h] Local Apic ID : FF
[120h 0288 004h] Flags (decoded below) : 00000000
Processor Enabled : 0
Runtime Online Capable : 0

[124h 0292 001h] Subtable Type : 00 [Processor Local APIC]
[125h 0293 001h] Length : 08
[126h 0294 001h] Processor ID : 1F
[127h 0295 001h] Local Apic ID : FF
[128h 0296 004h] Flags (decoded below) : 00000000
Processor Enabled : 0
Runtime Online Capable : 0

[12Ch 0300 001h] Subtable Type : 01 [I/O APIC]
[12Dh 0301 001h] Length : 0C
[12Eh 0302 001h] I/O Apic ID : 02
[12Fh 0303 001h] Reserved : 00
[130h 0304 004h] Address : FEC00000
[134h 0308 004h] Interrupt : 00000000

[138h 0312 001h] Subtable Type : 02 [Interrupt Source Override]
[139h 0313 001h] Length : 0A
[13Ah 0314 001h] Bus : 00
[13Bh 0315 001h] Source : 00
[13Ch 0316 004h] Interrupt : 00000002
[140h 0320 002h] Flags (decoded below) : 0000
Polarity : 0
Trigger Mode : 0

[142h 0322 001h] Subtable Type : 02 [Interrupt Source Override]
[143h 0323 001h] Length : 0A
[144h 0324 001h] Bus : 00
[145h 0325 001h] Source : 09
[146h 0326 004h] Interrupt : 00000009
[14Ah 0330 002h] Flags (decoded below) : 000D
Polarity : 1
Trigger Mode : 3

[14Ch 0332 001h] Subtable Type : 04 [Local APIC NMI]
[14Dh 0333 001h] Length : 06
[14Eh 0334 001h] Processor ID : 01
[14Fh 0335 002h] Flags (decoded below) : 0005
Polarity : 1
Trigger Mode : 1
[151h 0337 001h] Interrupt Input LINT : 01

[152h 0338 001h] Subtable Type : 04 [Local APIC NMI]
[153h 0339 001h] Length : 06
[154h 0340 001h] Processor ID : 02
[155h 0341 002h] Flags (decoded below) : 0005
Polarity : 1
Trigger Mode : 1
[157h 0343 001h] Interrupt Input LINT : 01

[158h 0344 001h] Subtable Type : 04 [Local APIC NMI]
[159h 0345 001h] Length : 06
[15Ah 0346 001h] Processor ID : 03
[15Bh 0347 002h] Flags (decoded below) : 0005
Polarity : 1
Trigger Mode : 1
[15Dh 0349 001h] Interrupt Input LINT : 01

[15Eh 0350 001h] Subtable Type : 04 [Local APIC NMI]
[15Fh 0351 001h] Length : 06
[160h 0352 001h] Processor ID : 04
[161h 0353 002h] Flags (decoded below) : 0005
Polarity : 1
Trigger Mode : 1
[163h 0355 001h] Interrupt Input LINT : 01

[164h 0356 001h] Subtable Type : 04 [Local APIC NMI]
[165h 0357 001h] Length : 06
[166h 0358 001h] Processor ID : 05
[167h 0359 002h] Flags (decoded below) : 0005
Polarity : 1
Trigger Mode : 1
[169h 0361 001h] Interrupt Input LINT : 01

[16Ah 0362 001h] Subtable Type : 04 [Local APIC NMI]
[16Bh 0363 001h] Length : 06
[16Ch 0364 001h] Processor ID : 06
[16Dh 0365 002h] Flags (decoded below) : 0005
Polarity : 1
Trigger Mode : 1
[16Fh 0367 001h] Interrupt Input LINT : 01

[170h 0368 001h] Subtable Type : 04 [Local APIC NMI]
[171h 0369 001h] Length : 06
[172h 0370 001h] Processor ID : 07
[173h 0371 002h] Flags (decoded below) : 0005
Polarity : 1
Trigger Mode : 1
[175h 0373 001h] Interrupt Input LINT : 01

[176h 0374 001h] Subtable Type : 04 [Local APIC NMI]
[177h 0375 001h] Length : 06
[178h 0376 001h] Processor ID : 08
[179h 0377 002h] Flags (decoded below) : 0005
Polarity : 1
Trigger Mode : 1
[17Bh 0379 001h] Interrupt Input LINT : 01

[17Ch 0380 001h] Subtable Type : 04 [Local APIC NMI]
[17Dh 0381 001h] Length : 06
[17Eh 0382 001h] Processor ID : 09
[17Fh 0383 002h] Flags (decoded below) : 0005
Polarity : 1
Trigger Mode : 1
[181h 0385 001h] Interrupt Input LINT : 01

[182h 0386 001h] Subtable Type : 04 [Local APIC NMI]
[183h 0387 001h] Length : 06
[184h 0388 001h] Processor ID : 0A
[185h 0389 002h] Flags (decoded below) : 0005
Polarity : 1
Trigger Mode : 1
[187h 0391 001h] Interrupt Input LINT : 01

[188h 0392 001h] Subtable Type : 04 [Local APIC NMI]
[189h 0393 001h] Length : 06
[18Ah 0394 001h] Processor ID : 0B
[18Bh 0395 002h] Flags (decoded below) : 0005
Polarity : 1
Trigger Mode : 1
[18Dh 0397 001h] Interrupt Input LINT : 01

[18Eh 0398 001h] Subtable Type : 04 [Local APIC NMI]
[18Fh 0399 001h] Length : 06
[190h 0400 001h] Processor ID : 0C
[191h 0401 002h] Flags (decoded below) : 0005
Polarity : 1
Trigger Mode : 1
[193h 0403 001h] Interrupt Input LINT : 01

[194h 0404 001h] Subtable Type : 04 [Local APIC NMI]
[195h 0405 001h] Length : 06
[196h 0406 001h] Processor ID : 0D
[197h 0407 002h] Flags (decoded below) : 0005
Polarity : 1
Trigger Mode : 1
[199h 0409 001h] Interrupt Input LINT : 01

[19Ah 0410 001h] Subtable Type : 04 [Local APIC NMI]
[19Bh 0411 001h] Length : 06
[19Ch 0412 001h] Processor ID : 0E
[19Dh 0413 002h] Flags (decoded below) : 0005
Polarity : 1
Trigger Mode : 1
[19Fh 0415 001h] Interrupt Input LINT : 01

[1A0h 0416 001h] Subtable Type : 04 [Local APIC NMI]
[1A1h 0417 001h] Length : 06
[1A2h 0418 001h] Processor ID : 0F
[1A3h 0419 002h] Flags (decoded below) : 0005
Polarity : 1
Trigger Mode : 1
[1A5h 0421 001h] Interrupt Input LINT : 01

[1A6h 0422 001h] Subtable Type : 04 [Local APIC NMI]
[1A7h 0423 001h] Length : 06
[1A8h 0424 001h] Processor ID : 10
[1A9h 0425 002h] Flags (decoded below) : 0005
Polarity : 1
Trigger Mode : 1
[1ABh 0427 001h] Interrupt Input LINT : 01

[1ACh 0428 001h] Subtable Type : 04 [Local APIC NMI]
[1ADh 0429 001h] Length : 06
[1AEh 0430 001h] Processor ID : 11
[1AFh 0431 002h] Flags (decoded below) : 0005
Polarity : 1
Trigger Mode : 1
[1B1h 0433 001h] Interrupt Input LINT : 01

[1B2h 0434 001h] Subtable Type : 04 [Local APIC NMI]
[1B3h 0435 001h] Length : 06
[1B4h 0436 001h] Processor ID : 12
[1B5h 0437 002h] Flags (decoded below) : 0005
Polarity : 1
Trigger Mode : 1
[1B7h 0439 001h] Interrupt Input LINT : 01

[1B8h 0440 001h] Subtable Type : 04 [Local APIC NMI]
[1B9h 0441 001h] Length : 06
[1BAh 0442 001h] Processor ID : 13
[1BBh 0443 002h] Flags (decoded below) : 0005
Polarity : 1
Trigger Mode : 1
[1BDh 0445 001h] Interrupt Input LINT : 01

[1BEh 0446 001h] Subtable Type : 04 [Local APIC NMI]
[1BFh 0447 001h] Length : 06
[1C0h 0448 001h] Processor ID : 14
[1C1h 0449 002h] Flags (decoded below) : 0005
Polarity : 1
Trigger Mode : 1
[1C3h 0451 001h] Interrupt Input LINT : 01

[1C4h 0452 001h] Subtable Type : 04 [Local APIC NMI]
[1C5h 0453 001h] Length : 06
[1C6h 0454 001h] Processor ID : 15
[1C7h 0455 002h] Flags (decoded below) : 0005
Polarity : 1
Trigger Mode : 1
[1C9h 0457 001h] Interrupt Input LINT : 01

[1CAh 0458 001h] Subtable Type : 04 [Local APIC NMI]
[1CBh 0459 001h] Length : 06
[1CCh 0460 001h] Processor ID : 16
[1CDh 0461 002h] Flags (decoded below) : 0005
Polarity : 1
Trigger Mode : 1
[1CFh 0463 001h] Interrupt Input LINT : 01

[1D0h 0464 001h] Subtable Type : 04 [Local APIC NMI]
[1D1h 0465 001h] Length : 06
[1D2h 0466 001h] Processor ID : 17
[1D3h 0467 002h] Flags (decoded below) : 0005
Polarity : 1
Trigger Mode : 1
[1D5h 0469 001h] Interrupt Input LINT : 01

[1D6h 0470 001h] Subtable Type : 04 [Local APIC NMI]
[1D7h 0471 001h] Length : 06
[1D8h 0472 001h] Processor ID : 00
[1D9h 0473 002h] Flags (decoded below) : 0005
Polarity : 1
Trigger Mode : 1
[1DBh 0475 001h] Interrupt Input LINT : 01

Raw Table Data: Length 476 (0x1DC)

0000: 41 50 49 43 DC 01 00 00 03 70 4C 45 4E 4F 56 4F // APIC.....pLENOVO
0010: 43 42 2D 30 31 20 20 20 01 00 00 00 41 43 50 49 // CB-01 ....ACPI
0020: 00 00 04 00 00 00 E0 FE 01 00 00 00 00 08 00 00 // ................
0030: 01 00 00 00 00 08 01 01 01 00 00 00 00 08 02 08 // ................
0040: 01 00 00 00 00 08 03 09 01 00 00 00 00 08 04 10 // ................
0050: 01 00 00 00 00 08 05 12 01 00 00 00 00 08 06 14 // ................
0060: 01 00 00 00 00 08 07 16 01 00 00 00 00 08 08 18 // ................
0070: 01 00 00 00 00 08 09 1A 01 00 00 00 00 08 0A 1C // ................
0080: 01 00 00 00 00 08 0B 1E 01 00 00 00 00 08 0C FF // ................
0090: 00 00 00 00 00 08 0D FF 00 00 00 00 00 08 0E FF // ................
00A0: 00 00 00 00 00 08 0F FF 00 00 00 00 00 08 10 FF // ................
00B0: 00 00 00 00 00 08 11 FF 00 00 00 00 00 08 12 FF // ................
00C0: 00 00 00 00 00 08 13 FF 00 00 00 00 00 08 14 FF // ................
00D0: 00 00 00 00 00 08 15 FF 00 00 00 00 00 08 16 FF // ................
00E0: 00 00 00 00 00 08 17 FF 00 00 00 00 00 08 18 FF // ................
00F0: 00 00 00 00 00 08 19 FF 00 00 00 00 00 08 1A FF // ................
0100: 00 00 00 00 00 08 1B FF 00 00 00 00 00 08 1C FF // ................
0110: 00 00 00 00 00 08 1D FF 00 00 00 00 00 08 1E FF // ................
0120: 00 00 00 00 00 08 1F FF 00 00 00 00 01 0C 02 00 // ................
0130: 00 00 C0 FE 00 00 00 00 02 0A 00 00 02 00 00 00 // ................
0140: 00 00 02 0A 00 09 09 00 00 00 0D 00 04 06 01 05 // ................
0150: 00 01 04 06 02 05 00 01 04 06 03 05 00 01 04 06 // ................
0160: 04 05 00 01 04 06 05 05 00 01 04 06 06 05 00 01 // ................
0170: 04 06 07 05 00 01 04 06 08 05 00 01 04 06 09 05 // ................
0180: 00 01 04 06 0A 05 00 01 04 06 0B 05 00 01 04 06 // ................
0190: 0C 05 00 01 04 06 0D 05 00 01 04 06 0E 05 00 01 // ................
01A0: 04 06 0F 05 00 01 04 06 10 05 00 01 04 06 11 05 // ................
01B0: 00 01 04 06 12 05 00 01 04 06 13 05 00 01 04 06 // ................
01C0: 14 05 00 01 04 06 15 05 00 01 04 06 16 05 00 01 // ................
01D0: 04 06 17 05 00 01 04 06 00 05 00 01 // ............

[-- Attachment #6: dbg2.dsl --]
[-- Type: text/x-dsl, Size: 2582 bytes --]

/*
* Intel ACPI Component Architecture
* AML/ASL+ Disassembler version 20240927 (64-bit version)
* Copyright (c) 2000 - 2023 Intel Corporation
*
* Disassembly of dbg2.dat
*
* ACPI Data Table [DBG2]
*
* Format: [HexOffset DecimalOffset ByteLength] FieldName : FieldValue (in hex)
*/

[000h 0000 004h] Signature : "DBG2" [Debug Port Table type 2]
[004h 0004 004h] Table Length : 00000054
[008h 0008 001h] Revision : 00
[009h 0009 001h] Checksum : BC
[00Ah 0010 006h] Oem ID : "LENOVO"
[010h 0016 008h] Oem Table ID : "CB-01 "
[018h 0024 004h] Oem Revision : 00000001
[01Ch 0028 004h] Asl Compiler ID : "ACPI"
[020h 0032 004h] Asl Compiler Revision : 00040000

[024h 0036 004h] Info Offset : 0000002C
[028h 0040 004h] Info Count : 00000001

[02Ch 0044 001h] Revision : 00
[02Dh 0045 002h] Length : 0028
[02Fh 0047 001h] Register Count : 01
[030h 0048 002h] Namepath Length : 0002
[032h 0050 002h] Namepath Offset : 0026
[034h 0052 002h] OEM Data Length : 0000 [Optional field not present]
[036h 0054 002h] OEM Data Offset : 0000 [Optional field not present]
[038h 0056 002h] Port Type : 8000
[03Ah 0058 002h] Port Subtype : 0001
[03Ch 0060 002h] Reserved : 0000
[03Eh 0062 002h] Base Address Offset : 0016
[040h 0064 002h] Address Size Offset : 0022

[042h 0066 00Ch] Base Address Register : [Generic Address Structure]
[042h 0066 001h] Space ID : 01 [SystemIO]
[043h 0067 001h] Bit Width : 08
[044h 0068 001h] Bit Offset : 00
[045h 0069 001h] Encoded Access Width : 00 [Undefined/Legacy]
[046h 0070 008h] Address : 00000000000003F8

[04Eh 0078 004h] Address Size : 00000020

[052h 0082 002h] Namepath : "."

Raw Table Data: Length 84 (0x54)

0000: 44 42 47 32 54 00 00 00 00 BC 4C 45 4E 4F 56 4F // DBG2T.....LENOVO
0010: 43 42 2D 30 31 20 20 20 01 00 00 00 41 43 50 49 // CB-01 ....ACPI
0020: 00 00 04 00 2C 00 00 00 01 00 00 00 00 28 00 01 // ....,........(..
0030: 02 00 26 00 00 00 00 00 00 80 01 00 00 00 16 00 // ..&.............
0040: 22 00 01 08 00 00 F8 03 00 00 00 00 00 00 20 00 // "............. .
0050: 00 00 2E 00 // ....

[-- Attachment #7: facs.dsl --]
[-- Type: text/x-dsl, Size: 1351 bytes --]

/*
* Intel ACPI Component Architecture
* AML/ASL+ Disassembler version 20240927 (64-bit version)
* Copyright (c) 2000 - 2023 Intel Corporation
*
* Disassembly of facs.dat
*
* ACPI Data Table [FACS]
*
* Format: [HexOffset DecimalOffset ByteLength] FieldName : FieldValue (in hex)
*/

[000h 0000 004h] Signature : "FACS"
[004h 0004 004h] Length : 00000040
[008h 0008 004h] Hardware Signature : AACFA97F
[00Ch 0012 004h] 32 Firmware Waking Vector : 00000000
[010h 0016 004h] Global Lock : 00000000
[014h 0020 004h] Flags (decoded below) : 00000000
S4BIOS Support Present : 0
64-bit Wake Supported (V2) : 0
[018h 0024 008h] 64 Firmware Waking Vector : 0000000000000000
[020h 0032 001h] Version : 02
[021h 0033 003h] Reserved : 000000
[024h 0036 004h] OspmFlags (decoded below) : 00000000
64-bit Wake Env Required (V2) : 0

Raw Table Data: Length 64 (0x40)

0000: 46 41 43 53 40 00 00 00 7F A9 CF AA 00 00 00 00 // FACS@...........
0010: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 // ................
0020: 02 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 // ................
0030: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 // ................

[-- Attachment #8: facp.dsl --]
[-- Type: text/x-dsl, Size: 10006 bytes --]

/*
* Intel ACPI Component Architecture
* AML/ASL+ Disassembler version 20240927 (64-bit version)
* Copyright (c) 2000 - 2023 Intel Corporation
*
* Disassembly of facp.dat
*
* ACPI Data Table [FACP]
*
* Format: [HexOffset DecimalOffset ByteLength] FieldName : FieldValue (in hex)
*/

[000h 0000 004h] Signature : "FACP" [Fixed ACPI Description Table (FADT)]
[004h 0004 004h] Table Length : 0000010C
[008h 0008 001h] Revision : 05
[009h 0009 001h] Checksum : 05
[00Ah 0010 006h] Oem ID : "LENOVO"
[010h 0016 008h] Oem Table ID : "CB-01 "
[018h 0024 004h] Oem Revision : 00000001
[01Ch 0028 004h] Asl Compiler ID : "ACPI"
[020h 0032 004h] Asl Compiler Revision : 00040000

[024h 0036 004h] FACS Address : 448E3000
[028h 0040 004h] DSDT Address : 44A23000
[02Ch 0044 001h] Model : 00
[02Dh 0045 001h] PM Profile : 02 [Mobile]
[02Eh 0046 002h] SCI Interrupt : 0009
[030h 0048 004h] SMI Command Port : 000000B2
[034h 0052 001h] ACPI Enable Value : A0
[035h 0053 001h] ACPI Disable Value : A1
[036h 0054 001h] S4BIOS Command : 00
[037h 0055 001h] P-State Control : 00
[038h 0056 004h] PM1A Event Block Address : 00001800
[03Ch 0060 004h] PM1B Event Block Address : 00000000
[040h 0064 004h] PM1A Control Block Address : 00001804
[044h 0068 004h] PM1B Control Block Address : 00000000
[048h 0072 004h] PM2 Control Block Address : 00001850
[04Ch 0076 004h] PM Timer Block Address : 00001808
[050h 0080 004h] GPE0 Block Address : 00001860
[054h 0084 004h] GPE1 Block Address : 00000000
[058h 0088 001h] PM1 Event Block Length : 04
[059h 0089 001h] PM1 Control Block Length : 02
[05Ah 0090 001h] PM2 Control Block Length : 01
[05Bh 0091 001h] PM Timer Block Length : 04
[05Ch 0092 001h] GPE0 Block Length : 20
[05Dh 0093 001h] GPE1 Block Length : 00
[05Eh 0094 001h] GPE1 Base Offset : 10
[05Fh 0095 001h] _CST Support : 00
[060h 0096 002h] C2 Latency : 0065
[062h 0098 002h] C3 Latency : 03E9
[064h 0100 002h] CPU Cache Size : 0000
[066h 0102 002h] Cache Flush Stride : 0000
[068h 0104 001h] Duty Cycle Offset : 01
[069h 0105 001h] Duty Cycle Width : 03
[06Ah 0106 001h] RTC Day Alarm Index : 0D
[06Bh 0107 001h] RTC Month Alarm Index : 00
[06Ch 0108 001h] RTC Century Index : 32
[06Dh 0109 002h] Boot Flags (decoded below) : 0003
Legacy Devices Supported (V2) : 1
8042 Present on ports 60/64 (V2) : 1
VGA Not Present (V4) : 0
MSI Not Supported (V4) : 0
PCIe ASPM Not Supported (V4) : 0
CMOS RTC Not Present (V5) : 0
[06Fh 0111 001h] Reserved : 00
[070h 0112 004h] Flags (decoded below) : 0020C4F5
WBINVD instruction is operational (V1) : 1
WBINVD flushes all caches (V1) : 0
All CPUs support C1 (V1) : 1
C2 works on MP system (V1) : 0
Control Method Power Button (V1) : 1
Control Method Sleep Button (V1) : 1
RTC wake not in fixed reg space (V1) : 1
RTC can wake system from S4 (V1) : 1
32-bit PM Timer (V1) : 0
Docking Supported (V1) : 0
Reset Register Supported (V2) : 1
Sealed Case (V3) : 0
Headless - No Video (V3) : 0
Use native instr after SLP_TYPx (V3) : 0
PCIEXP_WAK Bits Supported (V4) : 1
Use Platform Timer (V4) : 1
RTC_STS valid on S4 wake (V4) : 0
Remote Power-on capable (V4) : 0
Use APIC Cluster Model (V4) : 0
Use APIC Physical Destination Mode (V4) : 0
Hardware Reduced (V5) : 0
Low Power S0 Idle (V5) : 1

[074h 0116 00Ch] Reset Register : [Generic Address Structure]
[074h 0116 001h] Space ID : 01 [SystemIO]
[075h 0117 001h] Bit Width : 08
[076h 0118 001h] Bit Offset : 00
[077h 0119 001h] Encoded Access Width : 01 [Byte Access:8]
[078h 0120 008h] Address : 00000000000000B2

[080h 0128 001h] Value to cause reset : FB
[081h 0129 002h] ARM Flags (decoded below) : 0000
PSCI Compliant : 0
Must use HVC for PSCI : 0

[083h 0131 001h] FADT Minor Revision : 03
[084h 0132 008h] FACS Address : 0000000000000000
[08Ch 0140 008h] DSDT Address : 0000000044A23000
[094h 0148 00Ch] PM1A Event Block : [Generic Address Structure]
[094h 0148 001h] Space ID : 01 [SystemIO]
[095h 0149 001h] Bit Width : 20
[096h 0150 001h] Bit Offset : 00
[097h 0151 001h] Encoded Access Width : 02 [Word Access:16]
[098h 0152 008h] Address : 0000000000001800

[0A0h 0160 00Ch] PM1B Event Block : [Generic Address Structure]
[0A0h 0160 001h] Space ID : 01 [SystemIO]
[0A1h 0161 001h] Bit Width : 00
[0A2h 0162 001h] Bit Offset : 00
[0A3h 0163 001h] Encoded Access Width : 02 [Word Access:16]
[0A4h 0164 008h] Address : 0000000000000000

[0ACh 0172 00Ch] PM1A Control Block : [Generic Address Structure]
[0ACh 0172 001h] Space ID : 01 [SystemIO]
[0ADh 0173 001h] Bit Width : 10
[0AEh 0174 001h] Bit Offset : 00
[0AFh 0175 001h] Encoded Access Width : 02 [Word Access:16]
[0B0h 0176 008h] Address : 0000000000001804

[0B8h 0184 00Ch] PM1B Control Block : [Generic Address Structure]
[0B8h 0184 001h] Space ID : 01 [SystemIO]
[0B9h 0185 001h] Bit Width : 00
[0BAh 0186 001h] Bit Offset : 00
[0BBh 0187 001h] Encoded Access Width : 02 [Word Access:16]
[0BCh 0188 008h] Address : 0000000000000000

[0C4h 0196 00Ch] PM2 Control Block : [Generic Address Structure]
[0C4h 0196 001h] Space ID : 01 [SystemIO]
[0C5h 0197 001h] Bit Width : 08
[0C6h 0198 001h] Bit Offset : 00
[0C7h 0199 001h] Encoded Access Width : 01 [Byte Access:8]
[0C8h 0200 008h] Address : 0000000000001850

[0D0h 0208 00Ch] PM Timer Block : [Generic Address Structure]
[0D0h 0208 001h] Space ID : 01 [SystemIO]
[0D1h 0209 001h] Bit Width : 20
[0D2h 0210 001h] Bit Offset : 00
[0D3h 0211 001h] Encoded Access Width : 03 [DWord Access:32]
[0D4h 0212 008h] Address : 0000000000001808

[0DCh 0220 00Ch] GPE0 Block : [Generic Address Structure]
[0DCh 0220 001h] Space ID : 01 [SystemIO]
[0DDh 0221 001h] Bit Width : 00
[0DEh 0222 001h] Bit Offset : 00
[0DFh 0223 001h] Encoded Access Width : 01 [Byte Access:8]
[0E0h 0224 008h] Address : 0000000000001860

[0E8h 0232 00Ch] GPE1 Block : [Generic Address Structure]
[0E8h 0232 001h] Space ID : 01 [SystemIO]
[0E9h 0233 001h] Bit Width : 00
[0EAh 0234 001h] Bit Offset : 00
[0EBh 0235 001h] Encoded Access Width : 01 [Byte Access:8]
[0ECh 0236 008h] Address : 0000000000000000

[0F4h 0244 00Ch] Sleep Control Register : [Generic Address Structure]
[0F4h 0244 001h] Space ID : 00 [SystemMemory]
[0F5h 0245 001h] Bit Width : 00
[0F6h 0246 001h] Bit Offset : 00
[0F7h 0247 001h] Encoded Access Width : 00 [Undefined/Legacy]
[0F8h 0248 008h] Address : 0000000000000000

[100h 0256 00Ch] Sleep Status Register : [Generic Address Structure]
[100h 0256 001h] Space ID : 00 [SystemMemory]
[101h 0257 001h] Bit Width : 00
[102h 0258 001h] Bit Offset : 00
[103h 0259 001h] Encoded Access Width : 00 [Undefined/Legacy]
[104h 0260 008h] Address : 0000000000000000

Raw Table Data: Length 268 (0x10C)

0000: 46 41 43 50 0C 01 00 00 05 05 4C 45 4E 4F 56 4F // FACP......LENOVO
0010: 43 42 2D 30 31 20 20 20 01 00 00 00 41 43 50 49 // CB-01 ....ACPI
0020: 00 00 04 00 00 30 8E 44 00 30 A2 44 00 02 09 00 // .....0.D.0.D....
0030: B2 00 00 00 A0 A1 00 00 00 18 00 00 00 00 00 00 // ................
0040: 04 18 00 00 00 00 00 00 50 18 00 00 08 18 00 00 // ........P.......
0050: 60 18 00 00 00 00 00 00 04 02 01 04 20 00 10 00 // `........... ...
0060: 65 00 E9 03 00 00 00 00 01 03 0D 00 32 03 00 00 // e...........2...
0070: F5 C4 20 00 01 08 00 01 B2 00 00 00 00 00 00 00 // .. .............
0080: FB 00 00 03 00 00 00 00 00 00 00 00 00 30 A2 44 // .............0.D
0090: 00 00 00 00 01 20 00 02 00 18 00 00 00 00 00 00 // ..... ..........
00A0: 01 00 00 02 00 00 00 00 00 00 00 00 01 10 00 02 // ................
00B0: 04 18 00 00 00 00 00 00 01 00 00 02 00 00 00 00 // ................
00C0: 00 00 00 00 01 08 00 01 50 18 00 00 00 00 00 00 // ........P.......
00D0: 01 20 00 03 08 18 00 00 00 00 00 00 01 00 00 01 // . ..............
00E0: 60 18 00 00 00 00 00 00 01 00 00 01 00 00 00 00 // `...............
00F0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 // ................
0100: 00 00 00 00 00 00 00 00 00 00 00 00 // ............

[-- Attachment #9: hpet.dsl --]
[-- Type: text/x-dsl, Size: 1848 bytes --]

/*
* Intel ACPI Component Architecture
* AML/ASL+ Disassembler version 20240927 (64-bit version)
* Copyright (c) 2000 - 2023 Intel Corporation
*
* Disassembly of hpet.dat
*
* ACPI Data Table [HPET]
*
* Format: [HexOffset DecimalOffset ByteLength] FieldName : FieldValue (in hex)
*/

[000h 0000 004h] Signature : "HPET" [High Precision Event Timer Table]
[004h 0004 004h] Table Length : 00000038
[008h 0008 001h] Revision : 01
[009h 0009 001h] Checksum : F7
[00Ah 0010 006h] Oem ID : "LENOVO"
[010h 0016 008h] Oem Table ID : "CB-01 "
[018h 0024 004h] Oem Revision : 00000001
[01Ch 0028 004h] Asl Compiler ID : "ACPI"
[020h 0032 004h] Asl Compiler Revision : 00040000

[024h 0036 004h] Hardware Block ID : 8086A201

[028h 0040 00Ch] Timer Block Register : [Generic Address Structure]
[028h 0040 001h] Space ID : 00 [SystemMemory]
[029h 0041 001h] Bit Width : 40
[02Ah 0042 001h] Bit Offset : 00
[02Bh 0043 001h] Encoded Access Width : 00 [Undefined/Legacy]
[02Ch 0044 008h] Address : 00000000FED00000

[034h 0052 001h] Sequence Number : 00
[035h 0053 002h] Minimum Clock Ticks : 0080
[037h 0055 001h] Flags (decoded below) : 00
4K Page Protect : 0
64K Page Protect : 0

Raw Table Data: Length 56 (0x38)

0000: 48 50 45 54 38 00 00 00 01 F7 4C 45 4E 4F 56 4F // HPET8.....LENOVO
0010: 43 42 2D 30 31 20 20 20 01 00 00 00 41 43 50 49 // CB-01 ....ACPI
0020: 00 00 04 00 01 A2 86 80 00 40 00 00 00 00 D0 FE // .........@......
0030: 00 00 00 00 00 80 00 00 // ........

[-- Attachment #10: fpdt.dsl --]
[-- Type: text/x-dsl, Size: 1787 bytes --]

/*
* Intel ACPI Component Architecture
* AML/ASL+ Disassembler version 20240927 (64-bit version)
* Copyright (c) 2000 - 2023 Intel Corporation
*
* Disassembly of fpdt.dat
*
* ACPI Data Table [FPDT]
*
* Format: [HexOffset DecimalOffset ByteLength] FieldName : FieldValue (in hex)
*/

[000h 0000 004h] Signature : "FPDT" [Firmware Performance Data Table]
[004h 0004 004h] Table Length : 00000044
[008h 0008 001h] Revision : 01
[009h 0009 001h] Checksum : 57
[00Ah 0010 006h] Oem ID : "LENOVO"
[010h 0016 008h] Oem Table ID : "CB-01 "
[018h 0024 004h] Oem Revision : 00000001
[01Ch 0028 004h] Asl Compiler ID : "ACPI"
[020h 0032 004h] Asl Compiler Revision : 00040000

[024h 0036 002h] Subtable Type : 0000
[026h 0038 001h] Length : 10
[027h 0039 001h] Revision : 01
[028h 0040 004h] Reserved : 00000000
[02Ch 0044 008h] FPDT Boot Record Address : 00000000409E0000

[034h 0052 002h] Subtable Type : 0001
[036h 0054 001h] Length : 10
[037h 0055 001h] Revision : 01
[038h 0056 004h] Reserved : 00000000
[03Ch 0060 008h] S3PT Record Address : 00000000409DF000

Raw Table Data: Length 68 (0x44)

0000: 46 50 44 54 44 00 00 00 01 57 4C 45 4E 4F 56 4F // FPDTD....WLENOVO
0010: 43 42 2D 30 31 20 20 20 01 00 00 00 41 43 50 49 // CB-01 ....ACPI
0020: 00 00 04 00 00 00 10 01 00 00 00 00 00 00 9E 40 // ...............@
0030: 00 00 00 00 01 00 10 01 00 00 00 00 00 F0 9D 40 // ...............@
0040: 00 00 00 00 // ....

[-- Attachment #11: msdm.dsl --]
[-- Type: text/x-dsl, Size: 1783 bytes --]

/*
* Intel ACPI Component Architecture
* AML/ASL+ Disassembler version 20240927 (64-bit version)
* Copyright (c) 2000 - 2023 Intel Corporation
*
* Disassembly of msdm.dat
*
* ACPI Data Table [MSDM]
*
* Format: [HexOffset DecimalOffset ByteLength] FieldName : FieldValue (in hex)
*/

[000h 0000 004h] Signature : "MSDM" [Microsoft Data Management Table]
[004h 0004 004h] Table Length : 00000055
[008h 0008 001h] Revision : 03
[009h 0009 001h] Checksum : 2A
[00Ah 0010 006h] Oem ID : "LENOVO"
[010h 0016 008h] Oem Table ID : "CB-01 "
[018h 0024 004h] Oem Revision : 00000001
[01Ch 0028 004h] Asl Compiler ID : "ACPI"
[020h 0032 004h] Asl Compiler Revision : 00040000

[024h 0036 031h] Software Licensing Structure : 01 00 00 00 00 00 00 00 01 00 00 00 00 00 00 00 /* ................ */\
/* 034h 0052 16 */ 1D 00 00 00 58 38 57 57 42 2D 33 4E 37 48 54 2D /* ....X8WWB-3N7HT- */\
/* 044h 0068 16 */ 58 52 57 4A 46 2D 43 38 42 33 52 2D 58 32 46 54 /* XRWJF-C8B3R-X2FT */\
/* 054h 0084 1 */ 47 /* G */\

Raw Table Data: Length 85 (0x55)

0000: 4D 53 44 4D 55 00 00 00 03 2A 4C 45 4E 4F 56 4F // MSDMU....*LENOVO
0010: 43 42 2D 30 31 20 20 20 01 00 00 00 41 43 50 49 // CB-01 ....ACPI
0020: 00 00 04 00 01 00 00 00 00 00 00 00 01 00 00 00 // ................
0030: 00 00 00 00 1D 00 00 00 58 38 57 57 42 2D 33 4E // ........X8WWB-3N
0040: 37 48 54 2D 58 52 57 4A 46 2D 43 38 42 33 52 2D // 7HT-XRWJF-C8B3R-
0050: 58 32 46 54 47 // X2FTG

[-- Attachment #12: lpit.dsl --]
[-- Type: text/x-dsl, Size: 5873 bytes --]

/*
* Intel ACPI Component Architecture
* AML/ASL+ Disassembler version 20240927 (64-bit version)
* Copyright (c) 2000 - 2023 Intel Corporation
*
* Disassembly of lpit.dat
*
* ACPI Data Table [LPIT]
*
* Format: [HexOffset DecimalOffset ByteLength] FieldName : FieldValue (in hex)
*/

[000h 0000 004h] Signature : "LPIT" [Low Power Idle Table]
[004h 0004 004h] Table Length : 000000CC
[008h 0008 001h] Revision : 01
[009h 0009 001h] Checksum : 54
[00Ah 0010 006h] Oem ID : "LENOVO"
[010h 0016 008h] Oem Table ID : "CB-01 "
[018h 0024 004h] Oem Revision : 00000001
[01Ch 0028 004h] Asl Compiler ID : "ACPI"
[020h 0032 004h] Asl Compiler Revision : 00040000

[024h 0036 004h] Subtable Type : 00000000 [Native C-state Idle Structure]
[028h 0040 004h] Length : 00000038
[02Ch 0044 002h] Unique ID : 0000
[02Eh 0046 002h] Reserved : 0000
[030h 0048 004h] Flags (decoded below) : 00000000
State Disabled : 0
No Counter : 0

[034h 0052 00Ch] Entry Trigger : [Generic Address Structure]
[034h 0052 001h] Space ID : 7F [FunctionalFixedHW]
[035h 0053 001h] Bit Width : 01
[036h 0054 001h] Bit Offset : 02
[037h 0055 001h] Encoded Access Width : 00 [Undefined/Legacy]
[038h 0056 008h] Address : 0000000000000060

[040h 0064 004h] Residency : 00007530
[044h 0068 004h] Latency : 00000BB8
[048h 0072 00Ch] Residency Counter : [Generic Address Structure]
[048h 0072 001h] Space ID : 7F [FunctionalFixedHW]
[049h 0073 001h] Bit Width : 40
[04Ah 0074 001h] Bit Offset : 00
[04Bh 0075 001h] Encoded Access Width : 00 [Undefined/Legacy]
[04Ch 0076 008h] Address : 0000000000000632

[054h 0084 008h] Counter Frequency : 0000000000000000

[05Ch 0092 004h] Subtable Type : 00000000 [Native C-state Idle Structure]
[060h 0096 004h] Length : 00000038
[064h 0100 002h] Unique ID : 0001
[066h 0102 002h] Reserved : 0000
[068h 0104 004h] Flags (decoded below) : 00000000
State Disabled : 0
No Counter : 0

[06Ch 0108 00Ch] Entry Trigger : [Generic Address Structure]
[06Ch 0108 001h] Space ID : 7F [FunctionalFixedHW]
[06Dh 0109 001h] Bit Width : 01
[06Eh 0110 001h] Bit Offset : 02
[06Fh 0111 001h] Encoded Access Width : 00 [Undefined/Legacy]
[070h 0112 008h] Address : 0000000000000060

[078h 0120 004h] Residency : 00007530
[07Ch 0124 004h] Latency : 00000BB8
[080h 0128 00Ch] Residency Counter : [Generic Address Structure]
[080h 0128 001h] Space ID : 00 [SystemMemory]
[081h 0129 001h] Bit Width : 20
[082h 0130 001h] Bit Offset : 00
[083h 0131 001h] Encoded Access Width : 03 [DWord Access:32]
[084h 0132 008h] Address : 00000000FE00193C

[08Ch 0140 008h] Counter Frequency : 0000000000002005

[094h 0148 004h] Subtable Type : 00000000 [Native C-state Idle Structure]
[098h 0152 004h] Length : 00000038
[09Ch 0156 002h] Unique ID : 0002
[09Eh 0158 002h] Reserved : 0000
[0A0h 0160 004h] Flags (decoded below) : 00000001
State Disabled : 1
No Counter : 0

[0A4h 0164 00Ch] Entry Trigger : [Generic Address Structure]
[0A4h 0164 001h] Space ID : 7F [FunctionalFixedHW]
[0A5h 0165 001h] Bit Width : 01
[0A6h 0166 001h] Bit Offset : 02
[0A7h 0167 001h] Encoded Access Width : 00 [Undefined/Legacy]
[0A8h 0168 008h] Address : 0000000000000060

[0B0h 0176 004h] Residency : 00007530
[0B4h 0180 004h] Latency : 00000BB8
[0B8h 0184 00Ch] Residency Counter : [Generic Address Structure]
[0B8h 0184 001h] Space ID : 00 [SystemMemory]
[0B9h 0185 001h] Bit Width : 20
[0BAh 0186 001h] Bit Offset : 00
[0BBh 0187 001h] Encoded Access Width : 03 [DWord Access:32]
[0BCh 0188 008h] Address : 00000000000000FF

[0C4h 0196 008h] Counter Frequency : 0000000000000000

Raw Table Data: Length 204 (0xCC)

0000: 4C 50 49 54 CC 00 00 00 01 54 4C 45 4E 4F 56 4F // LPIT.....TLENOVO
0010: 43 42 2D 30 31 20 20 20 01 00 00 00 41 43 50 49 // CB-01 ....ACPI
0020: 00 00 04 00 00 00 00 00 38 00 00 00 00 00 00 00 // ........8.......
0030: 00 00 00 00 7F 01 02 00 60 00 00 00 00 00 00 00 // ........`.......
0040: 30 75 00 00 B8 0B 00 00 7F 40 00 00 32 06 00 00 // 0u.......@..2...
0050: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 // ................
0060: 38 00 00 00 01 00 00 00 00 00 00 00 7F 01 02 00 // 8...............
0070: 60 00 00 00 00 00 00 00 30 75 00 00 B8 0B 00 00 // `.......0u......
0080: 00 20 00 03 3C 19 00 FE 00 00 00 00 05 20 00 00 // . ..<........ ..
0090: 00 00 00 00 00 00 00 00 38 00 00 00 02 00 00 00 // ........8.......
00A0: 01 00 00 00 7F 01 02 00 60 00 00 00 00 00 00 00 // ........`.......
00B0: 30 75 00 00 B8 0B 00 00 00 20 00 03 FF 00 00 00 // 0u....... ......
00C0: 00 00 00 00 00 00 00 00 00 00 00 00 // ............

[-- Attachment #13: mcfg.dsl --]
[-- Type: text/x-dsl, Size: 1509 bytes --]

/*
* Intel ACPI Component Architecture
* AML/ASL+ Disassembler version 20240927 (64-bit version)
* Copyright (c) 2000 - 2023 Intel Corporation
*
* Disassembly of mcfg.dat
*
* ACPI Data Table [MCFG]
*
* Format: [HexOffset DecimalOffset ByteLength] FieldName : FieldValue (in hex)
*/

[000h 0000 004h] Signature : "MCFG" [Memory Mapped Configuration Table]
[004h 0004 004h] Table Length : 0000003C
[008h 0008 001h] Revision : 01
[009h 0009 001h] Checksum : 7F
[00Ah 0010 006h] Oem ID : "LENOVO"
[010h 0016 008h] Oem Table ID : "CB-01 "
[018h 0024 004h] Oem Revision : 00000001
[01Ch 0028 004h] Asl Compiler ID : "ACPI"
[020h 0032 004h] Asl Compiler Revision : 00040000

[024h 0036 008h] Reserved : 0000000000000000

[02Ch 0044 008h] Base Address : 00000000C0000000
[034h 0052 002h] Segment Group Number : 0000
[036h 0054 001h] Start Bus Number : 00
[037h 0055 001h] End Bus Number : FF
[038h 0056 004h] Reserved : 00000000

Raw Table Data: Length 60 (0x3C)

0000: 4D 43 46 47 3C 00 00 00 01 7F 4C 45 4E 4F 56 4F // MCFG<.....LENOVO
0010: 43 42 2D 30 31 20 20 20 01 00 00 00 41 43 50 49 // CB-01 ....ACPI
0020: 00 00 04 00 00 00 00 00 00 00 00 00 00 00 00 C0 // ................
0030: 00 00 00 00 00 00 00 FF 00 00 00 00 // ............

[-- Attachment #14: phat.dsl --]
[-- Type: text/x-dsl, Size: 29316 bytes --]

/*
* Intel ACPI Component Architecture
* AML/ASL+ Disassembler version 20240927 (64-bit version)
* Copyright (c) 2000 - 2023 Intel Corporation
*
* Disassembly of phat.dat
*
* ACPI Data Table [PHAT]
*
* Format: [HexOffset DecimalOffset ByteLength] FieldName : FieldValue (in hex)
*/

[000h 0000 004h] Signature : "PHAT" [Platform Health Assessment Table]
[004h 0004 004h] Table Length : 000008DC
[008h 0008 001h] Revision : 01
[009h 0009 001h] Checksum : D3
[00Ah 0010 006h] Oem ID : "LENOVO"
[010h 0016 008h] Oem Table ID : "CB-01 "
[018h 0024 004h] Oem Revision : 00000001
[01Ch 0028 004h] Asl Compiler ID : "ACPI"
[020h 0032 004h] Asl Compiler Revision : 00040000

[024h 0036 002h] Subtable Type : 0000 [Firmware Version Data]
[026h 0038 002h] Length : 03A8
[028h 0040 001h] Revision : 01
[029h 0041 003h] Reserved : 000000
[02Ch 0044 004h] Element Count : 00000021

/* Version Element #1h Offset 30h */

[030h 0048 010h] GUID : 27097CFD-46E5-4E39-B8E4-33E439A13EAF
[040h 0064 008h] Version Value : 0000000C01C50050
[048h 0072 004h] Producer ID : 43544E49

/* Version Element #2h Offset 4Ch */

[04Ch 0076 010h] GUID : 64C1A63E-BA2D-41DE-9655-2F70FE618F00
[05Ch 0092 008h] Version Value : 0000000800260020
[064h 0100 004h] Producer ID : 43544E49

/* Version Element #3h Offset 68h */

[068h 0104 010h] GUID : 2199CBED-4D3E-45EF-85D1-E1BAD5A370A9
[078h 0120 008h] Version Value : 000000FFFFFFFFFF
[080h 0128 004h] Producer ID : 43544E49

/* Version Element #4h Offset 84h */

[084h 0132 010h] GUID : A83F7361-FEFA-42D6-8B32-95F2989BF6D4
[094h 0148 008h] Version Value : 000000FFFFFFFFFF
[09Ch 0156 004h] Producer ID : 43544E49

/* Version Element #5h Offset A0h */

[0A0h 0160 010h] GUID : D84CA716-7ED3-4C4B-B1D5-2B8C274A19F1
[0B0h 0176 008h] Version Value : 000000FFFFFF0001
[0B8h 0184 004h] Producer ID : 43544E49

/* Version Element #6h Offset BCh */

[0BCh 0188 010h] GUID : E9B095BF-DEE2-4AC9-8778-9E41FB86C436
[0CCh 0204 008h] Version Value : 0000000246000000
[0D4h 0212 004h] Producer ID : 43544E49

/* Version Element #7h Offset D8h */

[0D8h 0216 010h] GUID : E385DD67-8F03-4872-AB47-3CA114BE1E52
[0E8h 0232 008h] Version Value : 0000000400000000
[0F0h 0240 004h] Producer ID : 43544E49

/* Version Element #8h Offset F4h */

[0F4h 0244 010h] GUID : 38D8AF9D-0F3D-4E48-A36B-FAFD686148A0
[104h 0260 008h] Version Value : 0000000800260020
[10Ch 0268 004h] Producer ID : 43544E49

/* Version Element #9h Offset 110h */

[110h 0272 010h] GUID : 73256EE6-A990-4B13-8ABA-76E22C3E993C
[120h 0288 008h] Version Value : 0000000000040093
[128h 0296 004h] Producer ID : 43544E49

/* Version Element #Ah Offset 12Ch */

[12Ch 0300 010h] GUID : FA2B5B12-3124-43DE-84E6-C4114E881F43
[13Ch 0316 008h] Version Value : 0000000800260020
[144h 0324 004h] Producer ID : 43544E49

/* Version Element #Bh Offset 148h */

[148h 0328 010h] GUID : 47A463E7-196D-4577-B536-3B9A85B7384B
[158h 0344 008h] Version Value : 000000FFFFFFFFFF
[160h 0352 004h] Producer ID : 43544E49

/* Version Element #Ch Offset 164h */

[164h 0356 010h] GUID : 3D3CE021-CE65-A2F5-A2F5-008B2BBB0CA2
[174h 0372 008h] Version Value : 0000000000000001
[17Ch 0380 004h] Producer ID : 43544E49

/* Version Element #Dh Offset 180h */

[180h 0384 010h] GUID : 84A3FF3C-CE65-448D-81C4-1A62A8A9C36E
[190h 0400 008h] Version Value : 0000000000000001
[198h 0408 004h] Producer ID : 43544E49

/* Version Element #Eh Offset 19Ch */

[19Ch 0412 010h] GUID : FA50153E-6627-4714-9220-B8C71DAB429A
[1ACh 0428 008h] Version Value : 000000FFFFFFFFFF
[1B4h 0436 004h] Producer ID : 43544E49

/* Version Element #Fh Offset 1B8h */

[1B8h 0440 010h] GUID : 0169518D-0480-5676-A9C1-5A8903C4992B
[1C8h 0456 008h] Version Value : 0000002400060000
[1D0h 0464 004h] Producer ID : 43544E49

/* Version Element #10h Offset 1D4h */

[1D4h 0468 010h] GUID : 0094DFCF-D97B-51A2-8F85-EC2482BD6296
[1E4h 0484 008h] Version Value : 0000000000002042
[1ECh 0492 004h] Producer ID : 43544E49

/* Version Element #11h Offset 1F0h */

[1F0h 0496 010h] GUID : D1ADD6FD-B056-5486-AD96-5163D1B9CCDC
[200h 0512 008h] Version Value : 0000000000000000
[208h 0520 004h] Producer ID : 43544E49

/* Version Element #12h Offset 20Ch */

[20Ch 0524 010h] GUID : 8F90AA30-B959-57DB-98ED-AEDA14BB4F7F
[21Ch 0540 008h] Version Value : 000000FFFFFFFFFF
[224h 0548 004h] Producer ID : 43544E49

/* Version Element #13h Offset 228h */

[228h 0552 010h] GUID : 877778B9-CF22-476A-97A1-27530D9AFE42
[238h 0568 008h] Version Value : 0000000800260020
[240h 0576 004h] Producer ID : 43544E49

/* Version Element #14h Offset 244h */

[244h 0580 010h] GUID : DA72FEF3-782B-4C38-8540-2C90217C1673
[254h 0596 008h] Version Value : 0000000000410021
[25Ch 0604 004h] Producer ID : 43544E49

/* Version Element #15h Offset 260h */

[260h 0608 010h] GUID : EC643DAC-ABB9-465F-83A6-A857E1D03BA2
[270h 0624 008h] Version Value : 000000FFFFFFFFFF
[278h 0632 004h] Producer ID : 43544E49

/* Version Element #16h Offset 27Ch */

[27Ch 0636 010h] GUID : 6858C460-15BA-4EAB-B67C-0053FFCDED54
[28Ch 0652 008h] Version Value : 0000000800260020
[294h 0660 004h] Producer ID : 43544E49

/* Version Element #17h Offset 298h */

[298h 0664 010h] GUID : A62BA25D-FFFC-4AC6-A90E-2457AC0E477E
[2A8h 0680 008h] Version Value : 00000010011B0890
[2B0h 0688 004h] Producer ID : 43544E49

/* Version Element #18h Offset 2B4h */

[2B4h 0692 010h] GUID : C519A3EB-6D2A-47D0-AAD3-5EB006B63121
[2C4h 0708 008h] Version Value : 000000FFFFFFFFFF
[2CCh 0716 004h] Producer ID : 43544E49

/* Version Element #19h Offset 2D0h */

[2D0h 0720 010h] GUID : E1EC257D-43D4-415B-9503-9EC04AC56158
[2E0h 0736 008h] Version Value : 000000FFFFFFFFFF
[2E8h 0744 004h] Producer ID : 43544E49

/* Version Element #1Ah Offset 2ECh */

[2ECh 0748 010h] GUID : E323121F-E60C-43D8-8E0F-69D9D7DAB3A0
[2FCh 0764 008h] Version Value : 000000FFFFFFFFFF
[304h 0772 004h] Producer ID : 43544E49

/* Version Element #1Bh Offset 308h */

[308h 0776 010h] GUID : AB0CDEEF-0B27-4C2B-B6B7-9B734043E3DE
[318h 0792 008h] Version Value : 000000FFFFFFFFFF
[320h 0800 004h] Producer ID : 43544E49

/* Version Element #1Ch Offset 324h */

[324h 0804 010h] GUID : BB11C4EA-6928-4F6C-B348-72C0CFC9D04D
[334h 0820 008h] Version Value : 000000FFFFFFFFFF
[33Ch 0828 004h] Producer ID : 43544E49

/* Version Element #1Dh Offset 340h */

[340h 0832 010h] GUID : 3381C8E3-B92C-4BAC-B6C6-4390911E934D
[350h 0848 008h] Version Value : 000000FFFFFF00FF
[358h 0856 004h] Producer ID : 43544E49

/* Version Element #1Eh Offset 35Ch */

[35Ch 0860 010h] GUID : 427DCDB4-1C33-4F2B-B736-F8DABE9E9ACD
[36Ch 0876 008h] Version Value : 0000000007000000
[374h 0884 004h] Producer ID : 43544E49

/* Version Element #1Fh Offset 378h */

[378h 0888 010h] GUID : CCB0BC86-1BCD-476F-AABE-E19159244BFD
[388h 0904 008h] Version Value : 0000000C00C50050
[390h 0912 004h] Producer ID : 43544E49

/* Version Element #20h Offset 394h */

[394h 0916 010h] GUID : 988C3FD6-92B2-41A0-B5C3-78A5CD4712F7
[3A4h 0932 008h] Version Value : 0000000000000000
[3ACh 0940 004h] Producer ID : 43544E49

/* Version Element #21h Offset 3B0h */

[3B0h 0944 010h] GUID : 03285589-1E37-4B72-A5F9-70D1ADAE5D34
[3C0h 0960 008h] Version Value : 000000011B000000
[3C8h 0968 004h] Producer ID : 43544E49

[3CCh 0972 002h] Subtable Type : 0001 [Firmware Health Data]
[3CEh 0974 002h] Length : 01A7
[3D0h 0976 001h] Revision : 01
[3D1h 0977 002h] Reserved : 0000
[3D3h 0979 001h] Health : 00
[3D4h 0980 010h] Device GUID : 93A41C2F-A09F-E7C2-AC1F-F2488F03EEC3
[3E4h 0996 004h] Device-Specific Offset : 00000074
[3E8h 1000 058h] Device Path : "VenHw(93A41C2F-A09F-E7C2-AC1F-F2488F03EEC3)"
[440h 1088 133h] Device-Specific Data : 01 CC 03 3B 5C 01 00 00 00 B3 68 0C EB 02 00 00 /* ...;\.....h..... */\
/* 450h 1104 16 */ 00 AE 01 00 00 00 00 00 00 00 00 00 00 00 00 00 /* ................ */\
/* 460h 1120 16 */ 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 /* ................ */\
/* 470h 1136 16 */ 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 /* ................ */\
/* 480h 1152 16 */ 00 00 00 FA 8A 89 A9 58 EF FE 48 B0 9A F4 76 AF /* .......X..H...v. */\
/* 490h 1168 16 */ CE 46 7C 00 00 00 00 00 00 00 00 00 00 00 00 00 /* .F|............. */\
/* 4A0h 1184 16 */ 00 00 00 62 81 8C 3B 8C 18 A4 46 AE C9 BE 43 F1 /* ...b..;...F...C. */\
/* 4B0h 1200 16 */ D6 56 97 00 00 00 00 00 00 00 00 00 00 00 00 00 /* .V.............. */\
/* 4C0h 1216 16 */ 00 00 00 2C 32 5D 86 C7 6A 34 47 B4 3E 55 DB 5A /* ...,2]..j4G.>U.Z */\
/* 4D0h 1232 16 */ 55 7D 63 00 00 00 00 00 00 00 00 00 00 00 00 00 /* U}c............. */\
/* 4E0h 1248 16 */ 00 00 00 CE D1 3B 99 D4 03 47 77 85 65 7E BB 67 /* .....;...Gw.e~.g */\
/* 4F0h 1264 16 */ B7 14 FE 00 00 00 00 00 00 00 00 00 00 00 00 00 /* ................ */\
/* 500h 1280 16 */ 00 00 00 C2 8C C6 B9 96 20 46 A8 A7 43 E8 C2 79 /* ........ F..C..y */\
/* 510h 1296 16 */ 5D 97 C9 00 00 00 00 00 00 00 00 00 00 00 00 00 /* ]............... */\
/* 520h 1312 16 */ 00 00 00 9D 50 8A 3B 4A EF 0A 4E BE 64 6A 45 F9 /* ....P.;J..N.djE. */\
/* 530h 1328 16 */ 03 C3 8C 00 00 00 00 00 00 00 00 00 00 00 00 00 /* ................ */\
/* 540h 1344 16 */ 00 00 00 90 F0 2A 83 F9 2E 47 7C 8F 6D B4 05 C8 /* .....*...G|.m... */\
/* 550h 1360 16 */ C7 F1 56 00 00 00 00 00 00 00 00 00 00 00 00 00 /* ..V............. */\
/* 560h 1376 16 */ 00 00 00 23 6B 82 5C AE ED 6A 4D AD 53 A2 42 83 /* ...#k.\..jM.S.B. */\
/* 570h 1392 3 */ 2A AF 4C /* *.L */\

[573h 1395 002h] Subtable Type : 0001 [Firmware Health Data]
[575h 1397 002h] Length : 007D
[577h 1399 001h] Revision : 01
[578h 1400 002h] Reserved : 0000
[57Ah 1402 001h] Health : 01
[57Bh 1403 010h] Device GUID : A30DFF09-56BF-4622-A9E7-399B0A79E7C7
[58Bh 1419 004h] Device-Specific Offset : 00000074
[58Fh 1423 058h] Device Path : "VenHw(A30DFF09-56BF-4622-A9E7-399B0A79E7C7)"
[5E7h 1511 009h] Device-Specific Data : 01 01 05 00 00 00 00 01 00 /* ......... */\

[5F0h 1520 002h] Subtable Type : 0001 [Firmware Health Data]
[5F2h 1522 002h] Length : 00A1
[5F4h 1524 001h] Revision : 01
[5F5h 1525 002h] Reserved : 0000
[5F7h 1527 001h] Health : 01
[5F8h 1528 010h] Device GUID : 46B29808-06F0-4CA0-9F92-5C4967829278
[608h 1544 004h] Device-Specific Offset : 00000074
[60Ch 1548 058h] Device Path : "VenHw(46B29808-06F0-4CA0-9F92-5C4967829278)"
[664h 1636 02Dh] Device-Specific Data : 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 /* ................ */\
/* 674h 1652 16 */ 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 /* ................ */\
/* 684h 1668 13 */ 00 00 00 00 00 00 00 00 00 00 00 00 00 /* ............. */\

[691h 1681 002h] Subtable Type : 0001 [Firmware Health Data]
[693h 1683 002h] Length : 024B
[695h 1685 001h] Revision : 01
[696h 1686 002h] Reserved : 0000
[698h 1688 001h] Health : 01
[699h 1689 010h] Device GUID : 24721FC5-2760-4391-AA5A-5C0324BE9419
[6A9h 1705 004h] Device-Specific Offset : 00000036
[6ADh 1709 01Ah] Device Path : "PciRoot(0x0)"
[6C7h 1735 215h] Device-Specific Data : 01 01 00 00 00 02 00 00 00 FF FF FF FF 00 00 00 /* ................ */\
/* 6D7h 1751 16 */ 00 00 02 00 00 00 46 01 64 0A 00 00 00 00 00 00 /* ......F.d....... */\
/* 6E7h 1767 16 */ 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 /* ................ */\
/* 6F7h 1783 16 */ 00 00 00 00 00 A9 76 65 00 00 00 00 00 00 00 00 /* ......ve........ */\
/* 707h 1799 16 */ 00 00 00 00 00 CA 91 84 00 00 00 00 00 00 00 00 /* ................ */\
/* 717h 1815 16 */ 00 00 00 00 00 1C C7 83 04 00 00 00 00 00 00 00 /* ................ */\
/* 727h 1831 16 */ 00 00 00 00 00 F0 75 2F 04 00 00 00 00 00 00 00 /* ......u/........ */\
/* 737h 1847 16 */ 00 00 00 00 00 4E 0A 00 00 00 00 00 00 00 00 00 /* .....N.......... */\
/* 747h 1863 16 */ 00 00 00 00 00 E8 01 00 00 00 00 00 00 00 00 00 /* ................ */\
/* 757h 1879 16 */ 00 00 00 00 00 B8 0B 00 00 00 00 00 00 00 00 00 /* ................ */\
/* 767h 1895 16 */ 00 00 00 00 00 AF 00 00 00 00 00 00 00 00 00 00 /* ................ */\
/* 777h 1911 16 */ 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 /* ................ */\
/* 787h 1927 16 */ 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 /* ................ */\
/* 797h 1943 16 */ 00 00 00 00 00 00 00 00 00 00 00 00 00 4E 01 46 /* .............N.F */\
/* 7A7h 1959 16 */ 01 00 00 00 00 00 00 00 00 00 00 00 00 2E 00 00 /* ................ */\
/* 7B7h 1975 16 */ 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 /* ................ */\
/* 7C7h 1991 16 */ 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 /* ................ */\
/* 7D7h 2007 16 */ 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 /* ................ */\
/* 7E7h 2023 16 */ 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 /* ................ */\
/* 7F7h 2039 16 */ 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 /* ................ */\
/* 807h 2055 16 */ 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 /* ................ */\
/* 817h 2071 16 */ 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 /* ................ */\
/* 827h 2087 16 */ 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 /* ................ */\
/* 837h 2103 16 */ 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 /* ................ */\
/* 847h 2119 16 */ 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 /* ................ */\
/* 857h 2135 16 */ 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 /* ................ */\
/* 867h 2151 16 */ 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 /* ................ */\
/* 877h 2167 16 */ 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 /* ................ */\
/* 887h 2183 16 */ 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 /* ................ */\
/* 897h 2199 16 */ 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 /* ................ */\
/* 8A7h 2215 16 */ 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 /* ................ */\
/* 8B7h 2231 16 */ 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 /* ................ */\
/* 8C7h 2247 16 */ 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 /* ................ */\
/* 8D7h 2263 5 */ 00 00 00 00 00 /* ..... */\

Raw Table Data: Length 2268 (0x8DC)

0000: 50 48 41 54 DC 08 00 00 01 D3 4C 45 4E 4F 56 4F // PHAT......LENOVO
0010: 43 42 2D 30 31 20 20 20 01 00 00 00 41 43 50 49 // CB-01 ....ACPI
0020: 00 00 04 00 00 00 A8 03 01 00 00 00 21 00 00 00 // ............!...
0030: FD 7C 09 27 E5 46 39 4E B8 E4 33 E4 39 A1 3E AF // .|.'.F9N..3.9.>.
0040: 50 00 C5 01 0C 00 00 00 49 4E 54 43 3E A6 C1 64 // P.......INTC>..d
0050: 2D BA DE 41 96 55 2F 70 FE 61 8F 00 20 00 26 00 // -..A.U/p.a.. .&.
0060: 08 00 00 00 49 4E 54 43 ED CB 99 21 3E 4D EF 45 // ....INTC...!>M.E
0070: 85 D1 E1 BA D5 A3 70 A9 FF FF FF FF FF 00 00 00 // ......p.........
0080: 49 4E 54 43 61 73 3F A8 FA FE D6 42 8B 32 95 F2 // INTCas?....B.2..
0090: 98 9B F6 D4 FF FF FF FF FF 00 00 00 49 4E 54 43 // ............INTC
00A0: 16 A7 4C D8 D3 7E 4B 4C B1 D5 2B 8C 27 4A 19 F1 // ..L..~KL..+.'J..
00B0: 01 00 FF FF FF 00 00 00 49 4E 54 43 BF 95 B0 E9 // ........INTC....
00C0: E2 DE C9 4A 87 78 9E 41 FB 86 C4 36 00 00 00 46 // ...J.x.A...6...F
00D0: 02 00 00 00 49 4E 54 43 67 DD 85 E3 03 8F 72 48 // ....INTCg.....rH
00E0: AB 47 3C A1 14 BE 1E 52 00 00 00 00 04 00 00 00 // .G<....R........
00F0: 49 4E 54 43 9D AF D8 38 3D 0F 48 4E A3 6B FA FD // INTC...8=.HN.k..
0100: 68 61 48 A0 20 00 26 00 08 00 00 00 49 4E 54 43 // haH. .&.....INTC
0110: E6 6E 25 73 90 A9 13 4B 8A BA 76 E2 2C 3E 99 3C // .n%s...K..v.,>.<
0120: 93 00 04 00 00 00 00 00 49 4E 54 43 12 5B 2B FA // ........INTC.[+.
0130: 24 31 DE 43 84 E6 C4 11 4E 88 1F 43 20 00 26 00 // $1.C....N..C .&.
0140: 08 00 00 00 49 4E 54 43 E7 63 A4 47 6D 19 77 45 // ....INTC.c.Gm.wE
0150: B5 36 3B 9A 85 B7 38 4B FF FF FF FF FF 00 00 00 // .6;...8K........
0160: 49 4E 54 43 21 E0 3C 3D 65 CE F5 A2 A2 F5 00 8B // INTC!.<=e.......
0170: 2B BB 0C A2 01 00 00 00 00 00 00 00 49 4E 54 43 // +...........INTC
0180: 3C FF A3 84 65 CE 8D 44 81 C4 1A 62 A8 A9 C3 6E // <...e..D...b...n
0190: 01 00 00 00 00 00 00 00 49 4E 54 43 3E 15 50 FA // ........INTC>.P.
01A0: 27 66 14 47 92 20 B8 C7 1D AB 42 9A FF FF FF FF // 'f.G. ....B.....
01B0: FF 00 00 00 49 4E 54 43 8D 51 69 01 80 04 76 56 // ....INTC.Qi...vV
01C0: A9 C1 5A 89 03 C4 99 2B 00 00 06 00 24 00 00 00 // ..Z....+....$...
01D0: 49 4E 54 43 CF DF 94 00 7B D9 A2 51 8F 85 EC 24 // INTC....{..Q...$
01E0: 82 BD 62 96 42 20 00 00 00 00 00 00 49 4E 54 43 // ..b.B ......INTC
01F0: FD D6 AD D1 56 B0 86 54 AD 96 51 63 D1 B9 CC DC // ....V..T..Qc....
0200: 00 00 00 00 00 00 00 00 49 4E 54 43 30 AA 90 8F // ........INTC0...
0210: 59 B9 DB 57 98 ED AE DA 14 BB 4F 7F FF FF FF FF // Y..W......O.....
0220: FF 00 00 00 49 4E 54 43 B9 78 77 87 22 CF 6A 47 // ....INTC.xw.".jG
0230: 97 A1 27 53 0D 9A FE 42 20 00 26 00 08 00 00 00 // ..'S...B .&.....
0240: 49 4E 54 43 F3 FE 72 DA 2B 78 38 4C 85 40 2C 90 // INTC..r.+x8L.@,.
0250: 21 7C 16 73 21 00 41 00 00 00 00 00 49 4E 54 43 // !|.s!.A.....INTC
0260: AC 3D 64 EC B9 AB 5F 46 83 A6 A8 57 E1 D0 3B A2 // .=d..._F...W..;.
0270: FF FF FF FF FF 00 00 00 49 4E 54 43 60 C4 58 68 // ........INTC`.Xh
0280: BA 15 AB 4E B6 7C 00 53 FF CD ED 54 20 00 26 00 // ...N.|.S...T .&.
0290: 08 00 00 00 49 4E 54 43 5D A2 2B A6 FC FF C6 4A // ....INTC].+....J
02A0: A9 0E 24 57 AC 0E 47 7E 90 08 1B 01 10 00 00 00 // ..$W..G~........
02B0: 49 4E 54 43 EB A3 19 C5 2A 6D D0 47 AA D3 5E B0 // INTC....*m.G..^.
02C0: 06 B6 31 21 FF FF FF FF FF 00 00 00 49 4E 54 43 // ..1!........INTC
02D0: 7D 25 EC E1 D4 43 5B 41 95 03 9E C0 4A C5 61 58 // }%...C[A....J.aX
02E0: FF FF FF FF FF 00 00 00 49 4E 54 43 1F 12 23 E3 // ........INTC..#.
02F0: 0C E6 D8 43 8E 0F 69 D9 D7 DA B3 A0 FF FF FF FF // ...C..i.........
0300: FF 00 00 00 49 4E 54 43 EF DE 0C AB 27 0B 2B 4C // ....INTC....'.+L
0310: B6 B7 9B 73 40 43 E3 DE FF FF FF FF FF 00 00 00 // ...s@C..........
0320: 49 4E 54 43 EA C4 11 BB 28 69 6C 4F B3 48 72 C0 // INTC....(ilO.Hr.
0330: CF C9 D0 4D FF FF FF FF FF 00 00 00 49 4E 54 43 // ...M........INTC
0340: E3 C8 81 33 2C B9 AC 4B B6 C6 43 90 91 1E 93 4D // ...3,..K..C....M
0350: FF 00 FF FF FF 00 00 00 49 4E 54 43 B4 CD 7D 42 // ........INTC..}B
0360: 33 1C 2B 4F B7 36 F8 DA BE 9E 9A CD 00 00 00 07 // 3.+O.6..........
0370: 00 00 00 00 49 4E 54 43 86 BC B0 CC CD 1B 6F 47 // ....INTC......oG
0380: AA BE E1 91 59 24 4B FD 50 00 C5 00 0C 00 00 00 // ....Y$K.P.......
0390: 49 4E 54 43 D6 3F 8C 98 B2 92 A0 41 B5 C3 78 A5 // INTC.?.....A..x.
03A0: CD 47 12 F7 00 00 00 00 00 00 00 00 49 4E 54 43 // .G..........INTC
03B0: 89 55 28 03 37 1E 72 4B A5 F9 70 D1 AD AE 5D 34 // .U(.7.rK..p...]4
03C0: 00 00 00 1B 01 00 00 00 49 4E 54 43 01 00 A7 01 // ........INTC....
03D0: 01 00 00 00 2F 1C A4 93 9F A0 C2 E7 AC 1F F2 48 // ..../..........H
03E0: 8F 03 EE C3 74 00 00 00 56 00 65 00 6E 00 48 00 // ....t...V.e.n.H.
03F0: 77 00 28 00 39 00 33 00 41 00 34 00 31 00 43 00 // w.(.9.3.A.4.1.C.
0400: 32 00 46 00 2D 00 41 00 30 00 39 00 46 00 2D 00 // 2.F.-.A.0.9.F.-.
0410: 45 00 37 00 43 00 32 00 2D 00 41 00 43 00 31 00 // E.7.C.2.-.A.C.1.
0420: 46 00 2D 00 46 00 32 00 34 00 38 00 38 00 46 00 // F.-.F.2.4.8.8.F.
0430: 30 00 33 00 45 00 45 00 43 00 33 00 29 00 00 00 // 0.3.E.E.C.3.)...
0440: 01 CC 03 3B 5C 01 00 00 00 B3 68 0C EB 02 00 00 // ...;\.....h.....
0450: 00 AE 01 00 00 00 00 00 00 00 00 00 00 00 00 00 // ................
0460: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 // ................
0470: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 // ................
0480: 00 00 00 FA 8A 89 A9 58 EF FE 48 B0 9A F4 76 AF // .......X..H...v.
0490: CE 46 7C 00 00 00 00 00 00 00 00 00 00 00 00 00 // .F|.............
04A0: 00 00 00 62 81 8C 3B 8C 18 A4 46 AE C9 BE 43 F1 // ...b..;...F...C.
04B0: D6 56 97 00 00 00 00 00 00 00 00 00 00 00 00 00 // .V..............
04C0: 00 00 00 2C 32 5D 86 C7 6A 34 47 B4 3E 55 DB 5A // ...,2]..j4G.>U.Z
04D0: 55 7D 63 00 00 00 00 00 00 00 00 00 00 00 00 00 // U}c.............
04E0: 00 00 00 CE D1 3B 99 D4 03 47 77 85 65 7E BB 67 // .....;...Gw.e~.g
04F0: B7 14 FE 00 00 00 00 00 00 00 00 00 00 00 00 00 // ................
0500: 00 00 00 C2 8C C6 B9 96 20 46 A8 A7 43 E8 C2 79 // ........ F..C..y
0510: 5D 97 C9 00 00 00 00 00 00 00 00 00 00 00 00 00 // ]...............
0520: 00 00 00 9D 50 8A 3B 4A EF 0A 4E BE 64 6A 45 F9 // ....P.;J..N.djE.
0530: 03 C3 8C 00 00 00 00 00 00 00 00 00 00 00 00 00 // ................
0540: 00 00 00 90 F0 2A 83 F9 2E 47 7C 8F 6D B4 05 C8 // .....*...G|.m...
0550: C7 F1 56 00 00 00 00 00 00 00 00 00 00 00 00 00 // ..V.............
0560: 00 00 00 23 6B 82 5C AE ED 6A 4D AD 53 A2 42 83 // ...#k.\..jM.S.B.
0570: 2A AF 4C 01 00 7D 00 01 00 00 01 09 FF 0D A3 BF // *.L..}..........
0580: 56 22 46 A9 E7 39 9B 0A 79 E7 C7 74 00 00 00 56 // V"F..9..y..t...V
0590: 00 65 00 6E 00 48 00 77 00 28 00 41 00 33 00 30 // .e.n.H.w.(.A.3.0
05A0: 00 44 00 46 00 46 00 30 00 39 00 2D 00 35 00 36 // .D.F.F.0.9.-.5.6
05B0: 00 42 00 46 00 2D 00 34 00 36 00 32 00 32 00 2D // .B.F.-.4.6.2.2.-
05C0: 00 41 00 39 00 45 00 37 00 2D 00 33 00 39 00 39 // .A.9.E.7.-.3.9.9
05D0: 00 42 00 30 00 41 00 37 00 39 00 45 00 37 00 43 // .B.0.A.7.9.E.7.C
05E0: 00 37 00 29 00 00 00 01 01 05 00 00 00 00 01 00 // .7.)............
05F0: 01 00 A1 00 01 00 00 01 08 98 B2 46 F0 06 A0 4C // ...........F...L
0600: 9F 92 5C 49 67 82 92 78 74 00 00 00 56 00 65 00 // ..\Ig..xt...V.e.
0610: 6E 00 48 00 77 00 28 00 34 00 36 00 42 00 32 00 // n.H.w.(.4.6.B.2.
0620: 39 00 38 00 30 00 38 00 2D 00 30 00 36 00 46 00 // 9.8.0.8.-.0.6.F.
0630: 30 00 2D 00 34 00 43 00 41 00 30 00 2D 00 39 00 // 0.-.4.C.A.0.-.9.
0640: 46 00 39 00 32 00 2D 00 35 00 43 00 34 00 39 00 // F.9.2.-.5.C.4.9.
0650: 36 00 37 00 38 00 32 00 39 00 32 00 37 00 38 00 // 6.7.8.2.9.2.7.8.
0660: 29 00 00 00 01 00 00 00 00 00 00 00 00 00 00 00 // )...............
0670: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 // ................
0680: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 // ................
0690: 00 01 00 4B 02 01 00 00 01 C5 1F 72 24 60 27 91 // ...K.......r$`'.
06A0: 43 AA 5A 5C 03 24 BE 94 19 36 00 00 00 50 00 63 // C.Z\.$...6...P.c
06B0: 00 69 00 52 00 6F 00 6F 00 74 00 28 00 30 00 78 // .i.R.o.o.t.(.0.x
06C0: 00 30 00 29 00 00 00 01 01 00 00 00 02 00 00 00 // .0.)............
06D0: FF FF FF FF 00 00 00 00 00 02 00 00 00 46 01 64 // .............F.d
06E0: 0A 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 // ................
06F0: 00 00 00 00 00 00 00 00 00 00 00 00 A9 76 65 00 // .............ve.
0700: 00 00 00 00 00 00 00 00 00 00 00 00 CA 91 84 00 // ................
0710: 00 00 00 00 00 00 00 00 00 00 00 00 1C C7 83 04 // ................
0720: 00 00 00 00 00 00 00 00 00 00 00 00 F0 75 2F 04 // .............u/.
0730: 00 00 00 00 00 00 00 00 00 00 00 00 4E 0A 00 00 // ............N...
0740: 00 00 00 00 00 00 00 00 00 00 00 00 E8 01 00 00 // ................
0750: 00 00 00 00 00 00 00 00 00 00 00 00 B8 0B 00 00 // ................
0760: 00 00 00 00 00 00 00 00 00 00 00 00 AF 00 00 00 // ................
0770: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 // ................
0780: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 // ................
0790: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 // ................
07A0: 00 00 00 00 4E 01 46 01 00 00 00 00 00 00 00 00 // ....N.F.........
07B0: 00 00 00 00 2E 00 00 00 00 00 00 00 00 00 00 00 // ................
07C0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 // ................
07D0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 // ................
07E0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 // ................
07F0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 // ................
0800: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 // ................
0810: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 // ................
0820: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 // ................
0830: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 // ................
0840: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 // ................
0850: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 // ................
0860: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 // ................
0870: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 // ................
0880: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 // ................
0890: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 // ................
08A0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 // ................
08B0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 // ................
08C0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 // ................
08D0: 00 00 00 00 00 00 00 00 00 00 00 00 // ............

[-- Attachment #15: nhlt.dsl --]
[-- Type: text/x-dsl, Size: 4629 bytes --]

/*
* Intel ACPI Component Architecture
* AML/ASL+ Disassembler version 20240927 (64-bit version)
* Copyright (c) 2000 - 2023 Intel Corporation
*
* Disassembly of nhlt.dat
*
* ACPI Data Table [NHLT]
*
* Format: [HexOffset DecimalOffset ByteLength] FieldName : FieldValue (in hex)
*/

[000h 0000 004h] Signature : "NHLT" [Non HD Audio Link Table]
[004h 0004 004h] Table Length : 000002F1
[008h 0008 001h] Revision : 00
[009h 0009 001h] Checksum : 2E
[00Ah 0010 006h] Oem ID : "LENOVO"
[010h 0016 008h] Oem Table ID : "CB-01 "
[018h 0024 004h] Oem Revision : 00000001
[01Ch 0028 004h] Asl Compiler ID : "ACPI"
[020h 0032 004h] Asl Compiler Revision : 00040000

Raw Table Data: Length 753 (0x2F1)

0000: 4E 48 4C 54 F1 02 00 00 00 2E 4C 45 4E 4F 56 4F // NHLT......LENOVO
0010: 43 42 2D 30 31 20 20 20 01 00 00 00 41 43 50 49 // CB-01 ....ACPI
0020: 00 00 04 00 02 AA 01 00 00 03 00 86 80 30 AE 01 // .............0..
0030: 00 01 00 00 00 00 00 02 01 00 00 00 00 03 FE FF // ................
0040: 01 00 40 1F 00 00 80 3E 00 00 02 00 10 00 16 00 // ..@....>........
0050: 10 00 04 00 00 00 01 00 00 00 00 00 10 00 80 00 // ................
0060: 00 AA 00 38 9B 71 54 00 00 00 00 00 00 00 F0 FF // ...8.qT.........
0070: FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 // ................
0080: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 3F 00 // ..............?.
0090: C0 80 00 00 40 D3 00 00 00 00 05 00 00 02 01 00 // ....@...........
00A0: 00 00 01 00 00 00 02 40 00 00 00 00 00 00 00 00 // .......@........
00B0: 02 07 00 00 00 00 01 00 00 00 00 00 00 00 FE FF // ................
00C0: 01 00 80 3E 00 00 00 7D 00 00 02 00 10 00 16 00 // ...>...}........
00D0: 10 00 04 00 00 00 01 00 00 00 00 00 10 00 80 00 // ................
00E0: 00 AA 00 38 9B 71 54 00 00 00 00 00 00 00 F0 FF // ...8.qT.........
00F0: FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 // ................
0100: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 3F 00 // ..............?.
0110: C0 80 00 00 40 D3 00 00 00 00 05 00 00 02 01 00 // ....@...........
0120: 00 00 01 00 00 00 02 40 00 00 00 00 00 00 00 00 // .......@........
0130: 02 07 00 00 00 00 01 00 00 00 00 00 00 00 FE FF // ................
0140: 02 00 80 BB 00 00 00 EE 02 00 04 00 10 00 16 00 // ................
0150: 10 00 03 00 00 00 01 00 00 00 00 00 10 00 80 00 // ................
0160: 00 AA 00 38 9B 71 64 00 00 00 00 00 00 00 10 FF // ...8.qd.........
0170: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF // ................
0180: FF FF FF FF FF FF FF FF FF FF FF FF FF FF 7F 18 // ................
0190: C0 C1 00 00 70 C0 00 00 00 00 05 02 01 02 03 00 // ....p...........
01A0: 00 00 03 00 00 00 02 40 00 00 00 00 00 00 00 0F // .......@........
01B0: 07 07 20 00 00 00 01 00 00 00 FF 0F 00 00 00 00 // .. .............
01C0: 00 00 08 00 00 00 01 00 00 00 01 00 00 00 00 1A // ................
01D0: 01 00 00 03 00 86 80 30 AE 01 00 01 00 00 00 00 // .......0........
01E0: 01 02 01 00 00 00 00 02 FE FF 01 00 40 1F 00 00 // ............@...
01F0: 80 3E 00 00 02 00 10 00 16 00 10 00 04 00 00 00 // .>..............
0200: 01 00 00 00 00 00 10 00 80 00 00 AA 00 38 9B 71 // .............8.q
0210: 54 00 00 00 00 00 00 00 F0 FF FF FF 00 00 00 00 // T...............
0220: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 // ................
0230: 00 00 00 00 00 00 00 00 3F 00 C0 80 00 00 40 D3 // ........?.....@.
0240: 00 00 00 00 05 00 00 02 01 00 00 00 01 00 00 00 // ................
0250: 02 40 00 00 00 00 00 00 00 00 02 07 00 00 00 00 // .@..............
0260: 01 00 00 00 00 00 00 00 FE FF 01 00 80 3E 00 00 // .............>..
0270: 00 7D 00 00 02 00 10 00 16 00 10 00 04 00 00 00 // .}..............
0280: 01 00 00 00 00 00 10 00 80 00 00 AA 00 38 9B 71 // .............8.q
0290: 54 00 00 00 00 00 00 00 F0 FF FF FF 00 00 00 00 // T...............
02A0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 // ................
02B0: 00 00 00 00 00 00 00 00 3F 00 C0 80 00 00 40 D3 // ........?.....@.
02C0: 00 00 00 00 05 00 00 02 01 00 00 00 01 00 00 00 // ................
02D0: 02 40 00 00 00 00 00 00 00 00 02 07 00 00 00 00 // .@..............
02E0: 01 00 00 00 00 00 00 00 00 04 00 00 00 DE AD BE // ................
02F0: EF // .

[-- Attachment #16: dsdt.dsl --]
[-- Type: text/x-dsl, Size: 4474075 bytes --]

/*
* Intel ACPI Component Architecture
* AML/ASL+ Disassembler version 20240927 (64-bit version)
* Copyright (c) 2000 - 2023 Intel Corporation
*
* Disassembling to symbolic ASL+ operators
*
* Disassembly of dsdt.dat
*
* Original Table Header:
* Signature "DSDT"
* Length 0x0009C5F2 (640498)
* Revision 0x02
* Checksum 0x40
* OEM ID "LENOVO"
* OEM Table ID "CB-01 "
* OEM Revision 0x00000001 (1)
* Compiler ID "ACPI"
* Compiler Version 0x00040000 (262144)
*/
DefinitionBlock ("", "DSDT", 2, "LENOVO", "CB-01 ", 0x00000001)
{
/*
* iASL Warning: There were 236 external control methods found during
* disassembly, but only 492 were resolved (4294967040 unresolved). Additional
* ACPI tables may be required to properly disassemble the code. This
* resulting disassembler output file may not compile because the
* disassembler did not know how many arguments to assign to the
* unresolved methods. Note: SSDTs can be dynamically loaded at
* runtime and may or may not be available via the host OS.
*
* To specify the tables needed to resolve external control method
* references, the -e option can be used to specify the filenames.
* Example iASL invocations:
* iasl -e ssdt1.aml ssdt2.aml ssdt3.aml -d dsdt.aml
* iasl -e dsdt.aml ssdt2.aml -d ssdt1.aml
* iasl -e ssdt*.aml -d dsdt.aml
*
* In addition, the -fe option can be used to specify a file containing
* control method external declarations with the associated method
* argument counts. Each line of the file must be of the form:
* External (<method pathname>, MethodObj, <argument count>)
* Invocation:
* iasl -fe refs.txt -d dsdt.aml
*
* The following methods were unresolved and many not compile properly
* because the disassembler had to guess at the number of arguments
* required for each:
*/
External (_GPE.AL6F, MethodObj) // 0 Arguments
External (_GPE.DTIN, MethodObj) // 0 Arguments
External (_GPE.SL61, MethodObj) // 0 Arguments
External (_GPE.SL66, MethodObj) // 0 Arguments
External (_GPE.SL69, MethodObj) // 0 Arguments
External (_GPE.SL6D, MethodObj) // 0 Arguments
External (_GPE.SL6F, MethodObj) // 0 Arguments
External (_SB_.AWAC, DeviceObj)
External (_SB_.AWAC.HOR_, IntObj)
External (_SB_.AWAC.MIN_, IntObj)
External (_SB_.AWAC.WAST, IntObj)
External (_SB_.BGIA, UnknownObj)
External (_SB_.BGMA, UnknownObj)
External (_SB_.BGMS, UnknownObj)
External (_SB_.BTRK, MethodObj) // 1 Arguments
External (_SB_.CPID, UnknownObj)
External (_SB_.CPPC, IntObj)
External (_SB_.GBTR, MethodObj) // 0 Arguments
External (_SB_.GGOV, MethodObj) // 1 Arguments
External (_SB_.IETM, DeviceObj)
External (_SB_.LSKD, UnknownObj)
External (_SB_.NVDR._DSM, MethodObj) // 4 Arguments
External (_SB_.NVDR.NVD1._DSM, MethodObj) // 4 Arguments
External (_SB_.NVDR.NVD1._LSI, MethodObj) // 0 Arguments
External (_SB_.NVDR.NVD1._LSR, MethodObj) // 2 Arguments
External (_SB_.NVDR.NVD1._LSW, MethodObj) // 3 Arguments
External (_SB_.PC00, DeviceObj)
External (_SB_.PC00.CNIP, MethodObj) // 0 Arguments
External (_SB_.PC00.CNVW.BOFC, UnknownObj)
External (_SB_.PC00.CNVW.CRFI, UnknownObj)
External (_SB_.PC00.CNVW.DPRS, UnknownObj)
External (_SB_.PC00.CNVW.FLRC, UnknownObj)
External (_SB_.PC00.CNVW.PRRS, UnknownObj)
External (_SB_.PC00.CNVW.RSTT, UnknownObj)
External (_SB_.PC00.CNVW.RSTY, UnknownObj)
External (_SB_.PC00.DPOF, UnknownObj)
External (_SB_.PC00.GFX0, DeviceObj)
External (_SB_.PC00.GFX0.ALSI, UnknownObj)
External (_SB_.PC00.GFX0.CBLV, UnknownObj)
External (_SB_.PC00.GFX0.CDCK, UnknownObj)
External (_SB_.PC00.GFX0.CLID, UnknownObj)
External (_SB_.PC00.GFX0.DD1F, DeviceObj)
External (_SB_.PC00.GFX0.DD2F, DeviceObj)
External (_SB_.PC00.GFX0.GLID, MethodObj) // 1 Arguments
External (_SB_.PC00.GFX0.GSSE, UnknownObj)
External (_SB_.PC00.GFX0.IPCO, MethodObj) // 0 Arguments
External (_SB_.PC00.GFX0.IUEH, MethodObj) // 1 Arguments
External (_SB_.PC00.GFX0.STAT, UnknownObj)
External (_SB_.PC00.GFX0.TCHE, UnknownObj)
External (_SB_.PC00.HDAS.PPMS, MethodObj) // 1 Arguments
External (_SB_.PC00.HDAS.PS0X, MethodObj) // 0 Arguments
External (_SB_.PC00.HDAS.PS3X, MethodObj) // 0 Arguments
External (_SB_.PC00.HIDW, MethodObj) // 4 Arguments
External (_SB_.PC00.HIWC, MethodObj) // 1 Arguments
External (_SB_.PC00.I2C0, DeviceObj)
External (_SB_.PC00.ITSP, UnknownObj)
External (_SB_.PC00.LPCB.EC0_.MLED, UnknownObj)
External (_SB_.PC00.LPCB.EC0_.SEN1, DeviceObj)
External (_SB_.PC00.LPCB.EC0_.SEN2, DeviceObj)
External (_SB_.PC00.LPCB.EC0_.SEN3, DeviceObj)
External (_SB_.PC00.LPCB.EC0_.SEN4, DeviceObj)
External (_SB_.PC00.LPCB.H_EC.BAT0, DeviceObj)
External (_SB_.PC00.LPCB.H_EC.BAT1, DeviceObj)
External (_SB_.PC00.LPCB.H_EC.BAT2, DeviceObj)
External (_SB_.PC00.LPCB.H_EC.BNUM, IntObj)
External (_SB_.PC00.LPCB.H_EC.CFAN, FieldUnitObj)
External (_SB_.PC00.LPCB.H_EC.LID0, DeviceObj)
External (_SB_.PC00.LPCB.H_EC.LSTE, FieldUnitObj)
External (_SB_.PC00.LPCB.H_EC.ONTM, IntObj)
External (_SB_.PC00.LPCB.H_EC.RPWR, FieldUnitObj)
External (_SB_.PC00.LPCB.H_EC.UTEC, MethodObj) // 2 Arguments
External (_SB_.PC00.LPCB.H_EC.VPWR, FieldUnitObj)
External (_SB_.PC00.LPCB.H_EC.WTMM, FieldUnitObj)
External (_SB_.PC00.LPCB.H_EC.WTMV, FieldUnitObj)
External (_SB_.PC00.LPCB.PNOT, MethodObj) // 0 Arguments
External (_SB_.PC00.M32B, UnknownObj)
External (_SB_.PC00.M32L, UnknownObj)
External (_SB_.PC00.M64B, UnknownObj)
External (_SB_.PC00.M64L, UnknownObj)
External (_SB_.PC00.PAUD.PUAM, MethodObj) // 0 Arguments
External (_SB_.PC00.PC2M, MethodObj) // 1 Arguments
External (_SB_.PC00.PEG0, DeviceObj)
External (_SB_.PC00.PEG0.CPRA, MethodObj) // 0 Arguments
External (_SB_.PC00.PEG0.PEGP.BCCX, UnknownObj)
External (_SB_.PC00.PEG0.PEGP.ISGX, MethodObj) // 0 Arguments
External (_SB_.PC00.PEG0.PEGP.PAHC, MethodObj) // 0 Arguments
External (_SB_.PC00.PEG0.PEGP.PIXX, UnknownObj)
External (_SB_.PC00.PEG0.PEGP.PNVM, MethodObj) // 0 Arguments
External (_SB_.PC00.PEG0.PEGP.PRES, MethodObj) // 0 Arguments
External (_SB_.PC00.PEG0.PEGP.SCCX, UnknownObj)
External (_SB_.PC00.PEG0.PEGP.WIST, MethodObj) // 0 Arguments
External (_SB_.PC00.PEG0.PEGP.WWST, MethodObj) // 0 Arguments
External (_SB_.PC00.PEG0.POFF, MethodObj) // 0 Arguments
External (_SB_.PC00.PEG0.PON_, MethodObj) // 0 Arguments
External (_SB_.PC00.PEG0.PRMV, IntObj)
External (_SB_.PC00.PEG0.PRTP, IntObj)
External (_SB_.PC00.PEG0.RD3C, IntObj)
External (_SB_.PC00.PEG0.SLOT, IntObj)
External (_SB_.PC00.PEG1, DeviceObj)
External (_SB_.PC00.PEG1.CBLV, UnknownObj)
External (_SB_.PC00.PEG1.CLID, UnknownObj)
External (_SB_.PC00.PEG1.CPRA, MethodObj) // 0 Arguments
External (_SB_.PC00.PEG1.DGCE, IntObj)
External (_SB_.PC00.PEG1.DHDW, MethodObj) // 0 Arguments
External (_SB_.PC00.PEG1.PEGP.BCCX, UnknownObj)
External (_SB_.PC00.PEG1.PEGP.ISGX, MethodObj) // 0 Arguments
External (_SB_.PC00.PEG1.PEGP.PAHC, MethodObj) // 0 Arguments
External (_SB_.PC00.PEG1.PEGP.PEGB.PEGE.DEDP, DeviceObj)
External (_SB_.PC00.PEG1.PEGP.PIXX, UnknownObj)
External (_SB_.PC00.PEG1.PEGP.PNVM, MethodObj) // 0 Arguments
External (_SB_.PC00.PEG1.PEGP.PRES, MethodObj) // 0 Arguments
External (_SB_.PC00.PEG1.PEGP.SCCX, UnknownObj)
External (_SB_.PC00.PEG1.PEGP.WIST, MethodObj) // 0 Arguments
External (_SB_.PC00.PEG1.PEGP.WWST, MethodObj) // 0 Arguments
External (_SB_.PC00.PEG1.POFF, MethodObj) // 0 Arguments
External (_SB_.PC00.PEG1.PON_, MethodObj) // 0 Arguments
External (_SB_.PC00.PEG1.PRMV, IntObj)
External (_SB_.PC00.PEG1.PRTP, IntObj)
External (_SB_.PC00.PEG1.RD3C, IntObj)
External (_SB_.PC00.PEG1.SLOT, IntObj)
External (_SB_.PC00.PEG2, DeviceObj)
External (_SB_.PC00.PEG2.CPRA, MethodObj) // 0 Arguments
External (_SB_.PC00.PEG2.PEGP.BCCX, UnknownObj)
External (_SB_.PC00.PEG2.PEGP.ISGX, MethodObj) // 0 Arguments
External (_SB_.PC00.PEG2.PEGP.PAHC, MethodObj) // 0 Arguments
External (_SB_.PC00.PEG2.PEGP.PIXX, UnknownObj)
External (_SB_.PC00.PEG2.PEGP.PNVM, MethodObj) // 0 Arguments
External (_SB_.PC00.PEG2.PEGP.PRES, MethodObj) // 0 Arguments
External (_SB_.PC00.PEG2.PEGP.SCCX, UnknownObj)
External (_SB_.PC00.PEG2.PEGP.WIST, MethodObj) // 0 Arguments
External (_SB_.PC00.PEG2.PEGP.WWST, MethodObj) // 0 Arguments
External (_SB_.PC00.PEG2.POFF, MethodObj) // 0 Arguments
External (_SB_.PC00.PEG2.PON_, MethodObj) // 0 Arguments
External (_SB_.PC00.PEG2.PRMV, IntObj)
External (_SB_.PC00.PEG2.PRTP, IntObj)
External (_SB_.PC00.PEG2.RD3C, IntObj)
External (_SB_.PC00.PEG2.SLOT, IntObj)
External (_SB_.PC00.PEG3.CPRA, MethodObj) // 0 Arguments
External (_SB_.PC00.PEG3.POFF, MethodObj) // 0 Arguments
External (_SB_.PC00.PEG3.PON_, MethodObj) // 0 Arguments
External (_SB_.PC00.PTHT.THEN, MethodObj) // 0 Arguments
External (_SB_.PC00.RP01, DeviceObj)
External (_SB_.PC00.RP01.NFRP, MethodObj) // 0 Arguments
External (_SB_.PC00.RP01.PINI, MethodObj) // 0 Arguments
External (_SB_.PC00.RP01.POFF, MethodObj) // 0 Arguments
External (_SB_.PC00.RP01.PON_, MethodObj) // 0 Arguments
External (_SB_.PC00.RP01.PPBA, MethodObj) // 1 Arguments
External (_SB_.PC00.RP01.PPS0, MethodObj) // 0 Arguments
External (_SB_.PC00.RP01.PPS3, MethodObj) // 0 Arguments
External (_SB_.PC00.RP01.PRMV, IntObj)
External (_SB_.PC00.RP01.PRTP, IntObj)
External (_SB_.PC00.RP01.PXSX.BCCX, UnknownObj)
External (_SB_.PC00.RP01.PXSX.BOFC, UnknownObj)
External (_SB_.PC00.RP01.PXSX.BRMT, IntObj)
External (_SB_.PC00.RP01.PXSX.CRFI, UnknownObj)
External (_SB_.PC00.RP01.PXSX.DPRS, UnknownObj)
External (_SB_.PC00.RP01.PXSX.FDEL, IntObj)
External (_SB_.PC00.RP01.PXSX.FLRC, UnknownObj)
External (_SB_.PC00.RP01.PXSX.ISGX, MethodObj) // 0 Arguments
External (_SB_.PC00.RP01.PXSX.PAHC, MethodObj) // 0 Arguments
External (_SB_.PC00.RP01.PXSX.PDEL, IntObj)
External (_SB_.PC00.RP01.PXSX.PIXX, UnknownObj)
External (_SB_.PC00.RP01.PXSX.PNVM, MethodObj) // 0 Arguments
External (_SB_.PC00.RP01.PXSX.PRES, MethodObj) // 0 Arguments
External (_SB_.PC00.RP01.PXSX.RDLY, IntObj)
External (_SB_.PC00.RP01.PXSX.RSTY, UnknownObj)
External (_SB_.PC00.RP01.PXSX.SCCX, UnknownObj)
External (_SB_.PC00.RP01.PXSX.VDEL, IntObj)
External (_SB_.PC00.RP01.PXSX.WIST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP01.PXSX.WVHO, IntObj)
External (_SB_.PC00.RP01.PXSX.WWST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP01.RD3C, IntObj)
External (_SB_.PC00.RP01.SLOT, IntObj)
External (_SB_.PC00.RP01.UPRD, MethodObj) // 1 Arguments
External (_SB_.PC00.RP01.VDID, FieldUnitObj)
External (_SB_.PC00.RP02, DeviceObj)
External (_SB_.PC00.RP02.PINI, MethodObj) // 0 Arguments
External (_SB_.PC00.RP02.POFF, MethodObj) // 0 Arguments
External (_SB_.PC00.RP02.PON_, MethodObj) // 0 Arguments
External (_SB_.PC00.RP02.PPBA, MethodObj) // 1 Arguments
External (_SB_.PC00.RP02.PPS0, MethodObj) // 0 Arguments
External (_SB_.PC00.RP02.PPS3, MethodObj) // 0 Arguments
External (_SB_.PC00.RP02.PRMV, IntObj)
External (_SB_.PC00.RP02.PRTP, IntObj)
External (_SB_.PC00.RP02.PXSX.BCCX, UnknownObj)
External (_SB_.PC00.RP02.PXSX.BOFC, UnknownObj)
External (_SB_.PC00.RP02.PXSX.BRMT, IntObj)
External (_SB_.PC00.RP02.PXSX.CRFI, UnknownObj)
External (_SB_.PC00.RP02.PXSX.DPRS, UnknownObj)
External (_SB_.PC00.RP02.PXSX.FDEL, IntObj)
External (_SB_.PC00.RP02.PXSX.FLRC, UnknownObj)
External (_SB_.PC00.RP02.PXSX.ISGX, MethodObj) // 0 Arguments
External (_SB_.PC00.RP02.PXSX.PAHC, MethodObj) // 0 Arguments
External (_SB_.PC00.RP02.PXSX.PDEL, IntObj)
External (_SB_.PC00.RP02.PXSX.PIXX, UnknownObj)
External (_SB_.PC00.RP02.PXSX.PNVM, MethodObj) // 0 Arguments
External (_SB_.PC00.RP02.PXSX.PRES, MethodObj) // 0 Arguments
External (_SB_.PC00.RP02.PXSX.RDLY, IntObj)
External (_SB_.PC00.RP02.PXSX.RSTY, UnknownObj)
External (_SB_.PC00.RP02.PXSX.SCCX, UnknownObj)
External (_SB_.PC00.RP02.PXSX.VDEL, IntObj)
External (_SB_.PC00.RP02.PXSX.WIST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP02.PXSX.WVHO, IntObj)
External (_SB_.PC00.RP02.PXSX.WWST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP02.RD3C, IntObj)
External (_SB_.PC00.RP02.SLOT, IntObj)
External (_SB_.PC00.RP02.UPRD, MethodObj) // 1 Arguments
External (_SB_.PC00.RP02.VDID, FieldUnitObj)
External (_SB_.PC00.RP03, DeviceObj)
External (_SB_.PC00.RP03.PINI, MethodObj) // 0 Arguments
External (_SB_.PC00.RP03.POFF, MethodObj) // 0 Arguments
External (_SB_.PC00.RP03.PON_, MethodObj) // 0 Arguments
External (_SB_.PC00.RP03.PPBA, MethodObj) // 1 Arguments
External (_SB_.PC00.RP03.PPS0, MethodObj) // 0 Arguments
External (_SB_.PC00.RP03.PPS3, MethodObj) // 0 Arguments
External (_SB_.PC00.RP03.PRMV, IntObj)
External (_SB_.PC00.RP03.PRTP, IntObj)
External (_SB_.PC00.RP03.PXSX.BCCX, UnknownObj)
External (_SB_.PC00.RP03.PXSX.BOFC, UnknownObj)
External (_SB_.PC00.RP03.PXSX.BRMT, IntObj)
External (_SB_.PC00.RP03.PXSX.CRFI, UnknownObj)
External (_SB_.PC00.RP03.PXSX.DPRS, UnknownObj)
External (_SB_.PC00.RP03.PXSX.FDEL, IntObj)
External (_SB_.PC00.RP03.PXSX.FLRC, UnknownObj)
External (_SB_.PC00.RP03.PXSX.ISGX, MethodObj) // 0 Arguments
External (_SB_.PC00.RP03.PXSX.PAHC, MethodObj) // 0 Arguments
External (_SB_.PC00.RP03.PXSX.PDEL, IntObj)
External (_SB_.PC00.RP03.PXSX.PIXX, UnknownObj)
External (_SB_.PC00.RP03.PXSX.PNVM, MethodObj) // 0 Arguments
External (_SB_.PC00.RP03.PXSX.PRES, MethodObj) // 0 Arguments
External (_SB_.PC00.RP03.PXSX.RDLY, IntObj)
External (_SB_.PC00.RP03.PXSX.RSTY, UnknownObj)
External (_SB_.PC00.RP03.PXSX.SCCX, UnknownObj)
External (_SB_.PC00.RP03.PXSX.VDEL, IntObj)
External (_SB_.PC00.RP03.PXSX.WIST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP03.PXSX.WVHO, IntObj)
External (_SB_.PC00.RP03.PXSX.WWST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP03.RD3C, IntObj)
External (_SB_.PC00.RP03.SLOT, IntObj)
External (_SB_.PC00.RP03.UPRD, MethodObj) // 1 Arguments
External (_SB_.PC00.RP03.VDID, FieldUnitObj)
External (_SB_.PC00.RP04, DeviceObj)
External (_SB_.PC00.RP04.PINI, MethodObj) // 0 Arguments
External (_SB_.PC00.RP04.POFF, MethodObj) // 0 Arguments
External (_SB_.PC00.RP04.PON_, MethodObj) // 0 Arguments
External (_SB_.PC00.RP04.PPBA, MethodObj) // 1 Arguments
External (_SB_.PC00.RP04.PPS0, MethodObj) // 0 Arguments
External (_SB_.PC00.RP04.PPS3, MethodObj) // 0 Arguments
External (_SB_.PC00.RP04.PRMV, IntObj)
External (_SB_.PC00.RP04.PRTP, IntObj)
External (_SB_.PC00.RP04.PXSX.BCCX, UnknownObj)
External (_SB_.PC00.RP04.PXSX.BOFC, UnknownObj)
External (_SB_.PC00.RP04.PXSX.BRMT, IntObj)
External (_SB_.PC00.RP04.PXSX.CRFI, UnknownObj)
External (_SB_.PC00.RP04.PXSX.DPRS, UnknownObj)
External (_SB_.PC00.RP04.PXSX.FDEL, IntObj)
External (_SB_.PC00.RP04.PXSX.FLRC, UnknownObj)
External (_SB_.PC00.RP04.PXSX.ISGX, MethodObj) // 0 Arguments
External (_SB_.PC00.RP04.PXSX.PAHC, MethodObj) // 0 Arguments
External (_SB_.PC00.RP04.PXSX.PDEL, IntObj)
External (_SB_.PC00.RP04.PXSX.PIXX, UnknownObj)
External (_SB_.PC00.RP04.PXSX.PNVM, MethodObj) // 0 Arguments
External (_SB_.PC00.RP04.PXSX.PRES, MethodObj) // 0 Arguments
External (_SB_.PC00.RP04.PXSX.RDLY, IntObj)
External (_SB_.PC00.RP04.PXSX.RSTY, UnknownObj)
External (_SB_.PC00.RP04.PXSX.SCCX, UnknownObj)
External (_SB_.PC00.RP04.PXSX.VDEL, IntObj)
External (_SB_.PC00.RP04.PXSX.WIST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP04.PXSX.WVHO, IntObj)
External (_SB_.PC00.RP04.PXSX.WWST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP04.RD3C, IntObj)
External (_SB_.PC00.RP04.SLOT, IntObj)
External (_SB_.PC00.RP04.UPRD, MethodObj) // 1 Arguments
External (_SB_.PC00.RP04.VDID, FieldUnitObj)
External (_SB_.PC00.RP05, DeviceObj)
External (_SB_.PC00.RP05.NFRP, MethodObj) // 0 Arguments
External (_SB_.PC00.RP05.PINI, MethodObj) // 0 Arguments
External (_SB_.PC00.RP05.POFF, MethodObj) // 0 Arguments
External (_SB_.PC00.RP05.PON_, MethodObj) // 0 Arguments
External (_SB_.PC00.RP05.PPBA, MethodObj) // 1 Arguments
External (_SB_.PC00.RP05.PPS0, MethodObj) // 0 Arguments
External (_SB_.PC00.RP05.PPS3, MethodObj) // 0 Arguments
External (_SB_.PC00.RP05.PRMV, IntObj)
External (_SB_.PC00.RP05.PRTP, IntObj)
External (_SB_.PC00.RP05.PXSX.BCCX, UnknownObj)
External (_SB_.PC00.RP05.PXSX.BOFC, UnknownObj)
External (_SB_.PC00.RP05.PXSX.BRMT, IntObj)
External (_SB_.PC00.RP05.PXSX.CRFI, UnknownObj)
External (_SB_.PC00.RP05.PXSX.DPRS, UnknownObj)
External (_SB_.PC00.RP05.PXSX.FDEL, IntObj)
External (_SB_.PC00.RP05.PXSX.FLRC, UnknownObj)
External (_SB_.PC00.RP05.PXSX.ISGX, MethodObj) // 0 Arguments
External (_SB_.PC00.RP05.PXSX.PAHC, MethodObj) // 0 Arguments
External (_SB_.PC00.RP05.PXSX.PDEL, IntObj)
External (_SB_.PC00.RP05.PXSX.PIXX, UnknownObj)
External (_SB_.PC00.RP05.PXSX.PNVM, MethodObj) // 0 Arguments
External (_SB_.PC00.RP05.PXSX.PRES, MethodObj) // 0 Arguments
External (_SB_.PC00.RP05.PXSX.RDLY, IntObj)
External (_SB_.PC00.RP05.PXSX.RSTY, UnknownObj)
External (_SB_.PC00.RP05.PXSX.SCCX, UnknownObj)
External (_SB_.PC00.RP05.PXSX.VDEL, IntObj)
External (_SB_.PC00.RP05.PXSX.WIST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP05.PXSX.WVHO, IntObj)
External (_SB_.PC00.RP05.PXSX.WWST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP05.RD3C, IntObj)
External (_SB_.PC00.RP05.SLOT, IntObj)
External (_SB_.PC00.RP05.UPRD, MethodObj) // 1 Arguments
External (_SB_.PC00.RP05.VDID, FieldUnitObj)
External (_SB_.PC00.RP06, DeviceObj)
External (_SB_.PC00.RP06.PINI, MethodObj) // 0 Arguments
External (_SB_.PC00.RP06.POFF, MethodObj) // 0 Arguments
External (_SB_.PC00.RP06.PON_, MethodObj) // 0 Arguments
External (_SB_.PC00.RP06.PPBA, MethodObj) // 1 Arguments
External (_SB_.PC00.RP06.PPS0, MethodObj) // 0 Arguments
External (_SB_.PC00.RP06.PPS3, MethodObj) // 0 Arguments
External (_SB_.PC00.RP06.PRMV, IntObj)
External (_SB_.PC00.RP06.PRTP, IntObj)
External (_SB_.PC00.RP06.PXSX.BCCX, UnknownObj)
External (_SB_.PC00.RP06.PXSX.BOFC, UnknownObj)
External (_SB_.PC00.RP06.PXSX.BRMT, IntObj)
External (_SB_.PC00.RP06.PXSX.CRFI, UnknownObj)
External (_SB_.PC00.RP06.PXSX.DPRS, UnknownObj)
External (_SB_.PC00.RP06.PXSX.FDEL, IntObj)
External (_SB_.PC00.RP06.PXSX.FLRC, UnknownObj)
External (_SB_.PC00.RP06.PXSX.ISGX, MethodObj) // 0 Arguments
External (_SB_.PC00.RP06.PXSX.PAHC, MethodObj) // 0 Arguments
External (_SB_.PC00.RP06.PXSX.PDEL, IntObj)
External (_SB_.PC00.RP06.PXSX.PIXX, UnknownObj)
External (_SB_.PC00.RP06.PXSX.PNVM, MethodObj) // 0 Arguments
External (_SB_.PC00.RP06.PXSX.PRES, MethodObj) // 0 Arguments
External (_SB_.PC00.RP06.PXSX.RDLY, IntObj)
External (_SB_.PC00.RP06.PXSX.RSTY, UnknownObj)
External (_SB_.PC00.RP06.PXSX.SCCX, UnknownObj)
External (_SB_.PC00.RP06.PXSX.VDEL, IntObj)
External (_SB_.PC00.RP06.PXSX.WIST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP06.PXSX.WVHO, IntObj)
External (_SB_.PC00.RP06.PXSX.WWST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP06.RD3C, IntObj)
External (_SB_.PC00.RP06.SLOT, IntObj)
External (_SB_.PC00.RP06.UPRD, MethodObj) // 1 Arguments
External (_SB_.PC00.RP06.VDID, FieldUnitObj)
External (_SB_.PC00.RP07, DeviceObj)
External (_SB_.PC00.RP07.PINI, MethodObj) // 0 Arguments
External (_SB_.PC00.RP07.POFF, MethodObj) // 0 Arguments
External (_SB_.PC00.RP07.PON_, MethodObj) // 0 Arguments
External (_SB_.PC00.RP07.PPBA, MethodObj) // 1 Arguments
External (_SB_.PC00.RP07.PPS0, MethodObj) // 0 Arguments
External (_SB_.PC00.RP07.PPS3, MethodObj) // 0 Arguments
External (_SB_.PC00.RP07.PRMV, IntObj)
External (_SB_.PC00.RP07.PRTP, IntObj)
External (_SB_.PC00.RP07.PXSX.BCCX, UnknownObj)
External (_SB_.PC00.RP07.PXSX.BOFC, UnknownObj)
External (_SB_.PC00.RP07.PXSX.BRMT, IntObj)
External (_SB_.PC00.RP07.PXSX.CRFI, UnknownObj)
External (_SB_.PC00.RP07.PXSX.DPRS, UnknownObj)
External (_SB_.PC00.RP07.PXSX.FDEL, IntObj)
External (_SB_.PC00.RP07.PXSX.FLRC, UnknownObj)
External (_SB_.PC00.RP07.PXSX.ISGX, MethodObj) // 0 Arguments
External (_SB_.PC00.RP07.PXSX.PAHC, MethodObj) // 0 Arguments
External (_SB_.PC00.RP07.PXSX.PDEL, IntObj)
External (_SB_.PC00.RP07.PXSX.PIXX, UnknownObj)
External (_SB_.PC00.RP07.PXSX.PNVM, MethodObj) // 0 Arguments
External (_SB_.PC00.RP07.PXSX.PRES, MethodObj) // 0 Arguments
External (_SB_.PC00.RP07.PXSX.RDLY, IntObj)
External (_SB_.PC00.RP07.PXSX.RSTY, UnknownObj)
External (_SB_.PC00.RP07.PXSX.SCCX, UnknownObj)
External (_SB_.PC00.RP07.PXSX.VDEL, IntObj)
External (_SB_.PC00.RP07.PXSX.WIST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP07.PXSX.WVHO, IntObj)
External (_SB_.PC00.RP07.PXSX.WWST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP07.RD3C, IntObj)
External (_SB_.PC00.RP07.SLOT, IntObj)
External (_SB_.PC00.RP07.UPRD, MethodObj) // 1 Arguments
External (_SB_.PC00.RP07.VDID, FieldUnitObj)
External (_SB_.PC00.RP08, DeviceObj)
External (_SB_.PC00.RP08.PINI, MethodObj) // 0 Arguments
External (_SB_.PC00.RP08.POFF, MethodObj) // 0 Arguments
External (_SB_.PC00.RP08.PON_, MethodObj) // 0 Arguments
External (_SB_.PC00.RP08.PPBA, MethodObj) // 1 Arguments
External (_SB_.PC00.RP08.PPS0, MethodObj) // 0 Arguments
External (_SB_.PC00.RP08.PPS3, MethodObj) // 0 Arguments
External (_SB_.PC00.RP08.PRMV, IntObj)
External (_SB_.PC00.RP08.PRTP, IntObj)
External (_SB_.PC00.RP08.PXSX.BCCX, UnknownObj)
External (_SB_.PC00.RP08.PXSX.BOFC, UnknownObj)
External (_SB_.PC00.RP08.PXSX.BRMT, IntObj)
External (_SB_.PC00.RP08.PXSX.CRFI, UnknownObj)
External (_SB_.PC00.RP08.PXSX.DPRS, UnknownObj)
External (_SB_.PC00.RP08.PXSX.FDEL, IntObj)
External (_SB_.PC00.RP08.PXSX.FLRC, UnknownObj)
External (_SB_.PC00.RP08.PXSX.ISGX, MethodObj) // 0 Arguments
External (_SB_.PC00.RP08.PXSX.PAHC, MethodObj) // 0 Arguments
External (_SB_.PC00.RP08.PXSX.PDEL, IntObj)
External (_SB_.PC00.RP08.PXSX.PIXX, UnknownObj)
External (_SB_.PC00.RP08.PXSX.PNVM, MethodObj) // 0 Arguments
External (_SB_.PC00.RP08.PXSX.PRES, MethodObj) // 0 Arguments
External (_SB_.PC00.RP08.PXSX.RDLY, IntObj)
External (_SB_.PC00.RP08.PXSX.RSTY, UnknownObj)
External (_SB_.PC00.RP08.PXSX.SCCX, UnknownObj)
External (_SB_.PC00.RP08.PXSX.VDEL, IntObj)
External (_SB_.PC00.RP08.PXSX.WIST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP08.PXSX.WVHO, IntObj)
External (_SB_.PC00.RP08.PXSX.WWST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP08.RD3C, IntObj)
External (_SB_.PC00.RP08.SLOT, IntObj)
External (_SB_.PC00.RP08.UPRD, MethodObj) // 1 Arguments
External (_SB_.PC00.RP08.VDID, FieldUnitObj)
External (_SB_.PC00.RP09, DeviceObj)
External (_SB_.PC00.RP09.NFRP, MethodObj) // 0 Arguments
External (_SB_.PC00.RP09.PINI, MethodObj) // 0 Arguments
External (_SB_.PC00.RP09.POFF, MethodObj) // 0 Arguments
External (_SB_.PC00.RP09.PON_, MethodObj) // 0 Arguments
External (_SB_.PC00.RP09.PPBA, MethodObj) // 1 Arguments
External (_SB_.PC00.RP09.PPS0, MethodObj) // 0 Arguments
External (_SB_.PC00.RP09.PPS3, MethodObj) // 0 Arguments
External (_SB_.PC00.RP09.PRMV, IntObj)
External (_SB_.PC00.RP09.PRTP, IntObj)
External (_SB_.PC00.RP09.PXSX.BCCX, UnknownObj)
External (_SB_.PC00.RP09.PXSX.BOFC, UnknownObj)
External (_SB_.PC00.RP09.PXSX.BRMT, IntObj)
External (_SB_.PC00.RP09.PXSX.CRFI, UnknownObj)
External (_SB_.PC00.RP09.PXSX.DPRS, UnknownObj)
External (_SB_.PC00.RP09.PXSX.FDEL, IntObj)
External (_SB_.PC00.RP09.PXSX.FLRC, UnknownObj)
External (_SB_.PC00.RP09.PXSX.ISGX, MethodObj) // 0 Arguments
External (_SB_.PC00.RP09.PXSX.PAHC, MethodObj) // 0 Arguments
External (_SB_.PC00.RP09.PXSX.PDEL, IntObj)
External (_SB_.PC00.RP09.PXSX.PIXX, UnknownObj)
External (_SB_.PC00.RP09.PXSX.PNVM, MethodObj) // 0 Arguments
External (_SB_.PC00.RP09.PXSX.PRES, MethodObj) // 0 Arguments
External (_SB_.PC00.RP09.PXSX.RDLY, IntObj)
External (_SB_.PC00.RP09.PXSX.RSTY, UnknownObj)
External (_SB_.PC00.RP09.PXSX.SCCX, UnknownObj)
External (_SB_.PC00.RP09.PXSX.VDEL, IntObj)
External (_SB_.PC00.RP09.PXSX.WIST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP09.PXSX.WVHO, IntObj)
External (_SB_.PC00.RP09.PXSX.WWST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP09.RD3C, IntObj)
External (_SB_.PC00.RP09.SLOT, IntObj)
External (_SB_.PC00.RP09.UPRD, MethodObj) // 1 Arguments
External (_SB_.PC00.RP09.VDID, FieldUnitObj)
External (_SB_.PC00.RP10, DeviceObj)
External (_SB_.PC00.RP10.PINI, MethodObj) // 0 Arguments
External (_SB_.PC00.RP10.POFF, MethodObj) // 0 Arguments
External (_SB_.PC00.RP10.PON_, MethodObj) // 0 Arguments
External (_SB_.PC00.RP10.PPBA, MethodObj) // 1 Arguments
External (_SB_.PC00.RP10.PPS0, MethodObj) // 0 Arguments
External (_SB_.PC00.RP10.PPS3, MethodObj) // 0 Arguments
External (_SB_.PC00.RP10.PRMV, IntObj)
External (_SB_.PC00.RP10.PRTP, IntObj)
External (_SB_.PC00.RP10.PXSX.BCCX, UnknownObj)
External (_SB_.PC00.RP10.PXSX.BOFC, UnknownObj)
External (_SB_.PC00.RP10.PXSX.BRMT, IntObj)
External (_SB_.PC00.RP10.PXSX.CRFI, UnknownObj)
External (_SB_.PC00.RP10.PXSX.DPRS, UnknownObj)
External (_SB_.PC00.RP10.PXSX.FDEL, IntObj)
External (_SB_.PC00.RP10.PXSX.FLRC, UnknownObj)
External (_SB_.PC00.RP10.PXSX.ISGX, MethodObj) // 0 Arguments
External (_SB_.PC00.RP10.PXSX.PAHC, MethodObj) // 0 Arguments
External (_SB_.PC00.RP10.PXSX.PDEL, IntObj)
External (_SB_.PC00.RP10.PXSX.PIXX, UnknownObj)
External (_SB_.PC00.RP10.PXSX.PNVM, MethodObj) // 0 Arguments
External (_SB_.PC00.RP10.PXSX.PRES, MethodObj) // 0 Arguments
External (_SB_.PC00.RP10.PXSX.RDLY, IntObj)
External (_SB_.PC00.RP10.PXSX.RSTY, UnknownObj)
External (_SB_.PC00.RP10.PXSX.SCCX, UnknownObj)
External (_SB_.PC00.RP10.PXSX.VDEL, IntObj)
External (_SB_.PC00.RP10.PXSX.WIST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP10.PXSX.WVHO, IntObj)
External (_SB_.PC00.RP10.PXSX.WWST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP10.RD3C, IntObj)
External (_SB_.PC00.RP10.SLOT, IntObj)
External (_SB_.PC00.RP10.UPRD, MethodObj) // 1 Arguments
External (_SB_.PC00.RP10.VDID, FieldUnitObj)
External (_SB_.PC00.RP11, DeviceObj)
External (_SB_.PC00.RP11.PINI, MethodObj) // 0 Arguments
External (_SB_.PC00.RP11.POFF, MethodObj) // 0 Arguments
External (_SB_.PC00.RP11.PON_, MethodObj) // 0 Arguments
External (_SB_.PC00.RP11.PPBA, MethodObj) // 1 Arguments
External (_SB_.PC00.RP11.PPS0, MethodObj) // 0 Arguments
External (_SB_.PC00.RP11.PPS3, MethodObj) // 0 Arguments
External (_SB_.PC00.RP11.PRMV, IntObj)
External (_SB_.PC00.RP11.PRTP, IntObj)
External (_SB_.PC00.RP11.PXSX.BCCX, UnknownObj)
External (_SB_.PC00.RP11.PXSX.BOFC, UnknownObj)
External (_SB_.PC00.RP11.PXSX.BRMT, IntObj)
External (_SB_.PC00.RP11.PXSX.CRFI, UnknownObj)
External (_SB_.PC00.RP11.PXSX.DPRS, UnknownObj)
External (_SB_.PC00.RP11.PXSX.FDEL, IntObj)
External (_SB_.PC00.RP11.PXSX.FLRC, UnknownObj)
External (_SB_.PC00.RP11.PXSX.ISGX, MethodObj) // 0 Arguments
External (_SB_.PC00.RP11.PXSX.PAHC, MethodObj) // 0 Arguments
External (_SB_.PC00.RP11.PXSX.PDEL, IntObj)
External (_SB_.PC00.RP11.PXSX.PIXX, UnknownObj)
External (_SB_.PC00.RP11.PXSX.PNVM, MethodObj) // 0 Arguments
External (_SB_.PC00.RP11.PXSX.PRES, MethodObj) // 0 Arguments
External (_SB_.PC00.RP11.PXSX.RDLY, IntObj)
External (_SB_.PC00.RP11.PXSX.RSTY, UnknownObj)
External (_SB_.PC00.RP11.PXSX.SCCX, UnknownObj)
External (_SB_.PC00.RP11.PXSX.VDEL, IntObj)
External (_SB_.PC00.RP11.PXSX.WIST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP11.PXSX.WVHO, IntObj)
External (_SB_.PC00.RP11.PXSX.WWST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP11.RD3C, IntObj)
External (_SB_.PC00.RP11.SLOT, IntObj)
External (_SB_.PC00.RP11.UPRD, MethodObj) // 1 Arguments
External (_SB_.PC00.RP11.VDID, FieldUnitObj)
External (_SB_.PC00.RP12, DeviceObj)
External (_SB_.PC00.RP12.PINI, MethodObj) // 0 Arguments
External (_SB_.PC00.RP12.POFF, MethodObj) // 0 Arguments
External (_SB_.PC00.RP12.PON_, MethodObj) // 0 Arguments
External (_SB_.PC00.RP12.PPBA, MethodObj) // 1 Arguments
External (_SB_.PC00.RP12.PPS0, MethodObj) // 0 Arguments
External (_SB_.PC00.RP12.PPS3, MethodObj) // 0 Arguments
External (_SB_.PC00.RP12.PRMV, IntObj)
External (_SB_.PC00.RP12.PRTP, IntObj)
External (_SB_.PC00.RP12.PXSX.BCCX, UnknownObj)
External (_SB_.PC00.RP12.PXSX.BOFC, UnknownObj)
External (_SB_.PC00.RP12.PXSX.BRMT, IntObj)
External (_SB_.PC00.RP12.PXSX.CRFI, UnknownObj)
External (_SB_.PC00.RP12.PXSX.DPRS, UnknownObj)
External (_SB_.PC00.RP12.PXSX.FDEL, IntObj)
External (_SB_.PC00.RP12.PXSX.FLRC, UnknownObj)
External (_SB_.PC00.RP12.PXSX.ISGX, MethodObj) // 0 Arguments
External (_SB_.PC00.RP12.PXSX.PAHC, MethodObj) // 0 Arguments
External (_SB_.PC00.RP12.PXSX.PDEL, IntObj)
External (_SB_.PC00.RP12.PXSX.PIXX, UnknownObj)
External (_SB_.PC00.RP12.PXSX.PNVM, MethodObj) // 0 Arguments
External (_SB_.PC00.RP12.PXSX.PRES, MethodObj) // 0 Arguments
External (_SB_.PC00.RP12.PXSX.RDLY, IntObj)
External (_SB_.PC00.RP12.PXSX.RSTY, UnknownObj)
External (_SB_.PC00.RP12.PXSX.SCCX, UnknownObj)
External (_SB_.PC00.RP12.PXSX.VDEL, IntObj)
External (_SB_.PC00.RP12.PXSX.WIST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP12.PXSX.WVHO, IntObj)
External (_SB_.PC00.RP12.PXSX.WWST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP12.RD3C, IntObj)
External (_SB_.PC00.RP12.SLOT, IntObj)
External (_SB_.PC00.RP12.UPRD, MethodObj) // 1 Arguments
External (_SB_.PC00.RP12.VDID, FieldUnitObj)
External (_SB_.PC00.RP13, DeviceObj)
External (_SB_.PC00.RP13.NFRP, MethodObj) // 0 Arguments
External (_SB_.PC00.RP13.PINI, MethodObj) // 0 Arguments
External (_SB_.PC00.RP13.POFF, MethodObj) // 0 Arguments
External (_SB_.PC00.RP13.PON_, MethodObj) // 0 Arguments
External (_SB_.PC00.RP13.PPBA, MethodObj) // 1 Arguments
External (_SB_.PC00.RP13.PPS0, MethodObj) // 0 Arguments
External (_SB_.PC00.RP13.PPS3, MethodObj) // 0 Arguments
External (_SB_.PC00.RP13.PRMV, IntObj)
External (_SB_.PC00.RP13.PRTP, IntObj)
External (_SB_.PC00.RP13.PXSX.BCCX, UnknownObj)
External (_SB_.PC00.RP13.PXSX.BOFC, UnknownObj)
External (_SB_.PC00.RP13.PXSX.BRMT, IntObj)
External (_SB_.PC00.RP13.PXSX.CRFI, UnknownObj)
External (_SB_.PC00.RP13.PXSX.DPRS, UnknownObj)
External (_SB_.PC00.RP13.PXSX.FDEL, IntObj)
External (_SB_.PC00.RP13.PXSX.FLRC, UnknownObj)
External (_SB_.PC00.RP13.PXSX.ISGX, MethodObj) // 0 Arguments
External (_SB_.PC00.RP13.PXSX.PAHC, MethodObj) // 0 Arguments
External (_SB_.PC00.RP13.PXSX.PDEL, IntObj)
External (_SB_.PC00.RP13.PXSX.PIXX, UnknownObj)
External (_SB_.PC00.RP13.PXSX.PNVM, MethodObj) // 0 Arguments
External (_SB_.PC00.RP13.PXSX.PRES, MethodObj) // 0 Arguments
External (_SB_.PC00.RP13.PXSX.RDLY, IntObj)
External (_SB_.PC00.RP13.PXSX.RSTY, UnknownObj)
External (_SB_.PC00.RP13.PXSX.SCCX, UnknownObj)
External (_SB_.PC00.RP13.PXSX.VDEL, IntObj)
External (_SB_.PC00.RP13.PXSX.WIST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP13.PXSX.WVHO, IntObj)
External (_SB_.PC00.RP13.PXSX.WWST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP13.RD3C, IntObj)
External (_SB_.PC00.RP13.SLOT, IntObj)
External (_SB_.PC00.RP13.UPRD, MethodObj) // 1 Arguments
External (_SB_.PC00.RP13.VDID, FieldUnitObj)
External (_SB_.PC00.RP14, DeviceObj)
External (_SB_.PC00.RP14.PINI, MethodObj) // 0 Arguments
External (_SB_.PC00.RP14.POFF, MethodObj) // 0 Arguments
External (_SB_.PC00.RP14.PON_, MethodObj) // 0 Arguments
External (_SB_.PC00.RP14.PPBA, MethodObj) // 1 Arguments
External (_SB_.PC00.RP14.PPS0, MethodObj) // 0 Arguments
External (_SB_.PC00.RP14.PPS3, MethodObj) // 0 Arguments
External (_SB_.PC00.RP14.PRMV, IntObj)
External (_SB_.PC00.RP14.PRTP, IntObj)
External (_SB_.PC00.RP14.PXSX.BCCX, UnknownObj)
External (_SB_.PC00.RP14.PXSX.BOFC, UnknownObj)
External (_SB_.PC00.RP14.PXSX.BRMT, IntObj)
External (_SB_.PC00.RP14.PXSX.CRFI, UnknownObj)
External (_SB_.PC00.RP14.PXSX.DPRS, UnknownObj)
External (_SB_.PC00.RP14.PXSX.FDEL, IntObj)
External (_SB_.PC00.RP14.PXSX.FLRC, UnknownObj)
External (_SB_.PC00.RP14.PXSX.ISGX, MethodObj) // 0 Arguments
External (_SB_.PC00.RP14.PXSX.PAHC, MethodObj) // 0 Arguments
External (_SB_.PC00.RP14.PXSX.PDEL, IntObj)
External (_SB_.PC00.RP14.PXSX.PIXX, UnknownObj)
External (_SB_.PC00.RP14.PXSX.PNVM, MethodObj) // 0 Arguments
External (_SB_.PC00.RP14.PXSX.PRES, MethodObj) // 0 Arguments
External (_SB_.PC00.RP14.PXSX.RDLY, IntObj)
External (_SB_.PC00.RP14.PXSX.RSTY, UnknownObj)
External (_SB_.PC00.RP14.PXSX.SCCX, UnknownObj)
External (_SB_.PC00.RP14.PXSX.VDEL, IntObj)
External (_SB_.PC00.RP14.PXSX.WIST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP14.PXSX.WVHO, IntObj)
External (_SB_.PC00.RP14.PXSX.WWST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP14.RD3C, IntObj)
External (_SB_.PC00.RP14.SLOT, IntObj)
External (_SB_.PC00.RP14.UPRD, MethodObj) // 1 Arguments
External (_SB_.PC00.RP14.VDID, FieldUnitObj)
External (_SB_.PC00.RP15, DeviceObj)
External (_SB_.PC00.RP15.PINI, MethodObj) // 0 Arguments
External (_SB_.PC00.RP15.POFF, MethodObj) // 0 Arguments
External (_SB_.PC00.RP15.PON_, MethodObj) // 0 Arguments
External (_SB_.PC00.RP15.PPBA, MethodObj) // 1 Arguments
External (_SB_.PC00.RP15.PPS0, MethodObj) // 0 Arguments
External (_SB_.PC00.RP15.PPS3, MethodObj) // 0 Arguments
External (_SB_.PC00.RP15.PRMV, IntObj)
External (_SB_.PC00.RP15.PRTP, IntObj)
External (_SB_.PC00.RP15.PXSX.BCCX, UnknownObj)
External (_SB_.PC00.RP15.PXSX.BOFC, UnknownObj)
External (_SB_.PC00.RP15.PXSX.BRMT, IntObj)
External (_SB_.PC00.RP15.PXSX.CRFI, UnknownObj)
External (_SB_.PC00.RP15.PXSX.DPRS, UnknownObj)
External (_SB_.PC00.RP15.PXSX.FDEL, IntObj)
External (_SB_.PC00.RP15.PXSX.FLRC, UnknownObj)
External (_SB_.PC00.RP15.PXSX.ISGX, MethodObj) // 0 Arguments
External (_SB_.PC00.RP15.PXSX.PAHC, MethodObj) // 0 Arguments
External (_SB_.PC00.RP15.PXSX.PDEL, IntObj)
External (_SB_.PC00.RP15.PXSX.PIXX, UnknownObj)
External (_SB_.PC00.RP15.PXSX.PNVM, MethodObj) // 0 Arguments
External (_SB_.PC00.RP15.PXSX.PRES, MethodObj) // 0 Arguments
External (_SB_.PC00.RP15.PXSX.RDLY, IntObj)
External (_SB_.PC00.RP15.PXSX.RSTY, UnknownObj)
External (_SB_.PC00.RP15.PXSX.SCCX, UnknownObj)
External (_SB_.PC00.RP15.PXSX.VDEL, IntObj)
External (_SB_.PC00.RP15.PXSX.WIST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP15.PXSX.WVHO, IntObj)
External (_SB_.PC00.RP15.PXSX.WWST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP15.RD3C, IntObj)
External (_SB_.PC00.RP15.SLOT, IntObj)
External (_SB_.PC00.RP15.UPRD, MethodObj) // 1 Arguments
External (_SB_.PC00.RP15.VDID, FieldUnitObj)
External (_SB_.PC00.RP16, DeviceObj)
External (_SB_.PC00.RP16.PINI, MethodObj) // 0 Arguments
External (_SB_.PC00.RP16.POFF, MethodObj) // 0 Arguments
External (_SB_.PC00.RP16.PON_, MethodObj) // 0 Arguments
External (_SB_.PC00.RP16.PPBA, MethodObj) // 1 Arguments
External (_SB_.PC00.RP16.PPS0, MethodObj) // 0 Arguments
External (_SB_.PC00.RP16.PPS3, MethodObj) // 0 Arguments
External (_SB_.PC00.RP16.PRMV, IntObj)
External (_SB_.PC00.RP16.PRTP, IntObj)
External (_SB_.PC00.RP16.PXSX.BCCX, UnknownObj)
External (_SB_.PC00.RP16.PXSX.BOFC, UnknownObj)
External (_SB_.PC00.RP16.PXSX.BRMT, IntObj)
External (_SB_.PC00.RP16.PXSX.CRFI, UnknownObj)
External (_SB_.PC00.RP16.PXSX.DPRS, UnknownObj)
External (_SB_.PC00.RP16.PXSX.FDEL, IntObj)
External (_SB_.PC00.RP16.PXSX.FLRC, UnknownObj)
External (_SB_.PC00.RP16.PXSX.ISGX, MethodObj) // 0 Arguments
External (_SB_.PC00.RP16.PXSX.PAHC, MethodObj) // 0 Arguments
External (_SB_.PC00.RP16.PXSX.PDEL, IntObj)
External (_SB_.PC00.RP16.PXSX.PIXX, UnknownObj)
External (_SB_.PC00.RP16.PXSX.PNVM, MethodObj) // 0 Arguments
External (_SB_.PC00.RP16.PXSX.PRES, MethodObj) // 0 Arguments
External (_SB_.PC00.RP16.PXSX.RDLY, IntObj)
External (_SB_.PC00.RP16.PXSX.RSTY, UnknownObj)
External (_SB_.PC00.RP16.PXSX.SCCX, UnknownObj)
External (_SB_.PC00.RP16.PXSX.VDEL, IntObj)
External (_SB_.PC00.RP16.PXSX.WIST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP16.PXSX.WVHO, IntObj)
External (_SB_.PC00.RP16.PXSX.WWST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP16.RD3C, IntObj)
External (_SB_.PC00.RP16.SLOT, IntObj)
External (_SB_.PC00.RP16.UPRD, MethodObj) // 1 Arguments
External (_SB_.PC00.RP16.VDID, FieldUnitObj)
External (_SB_.PC00.RP17, DeviceObj)
External (_SB_.PC00.RP17.NFRP, MethodObj) // 0 Arguments
External (_SB_.PC00.RP17.PINI, MethodObj) // 0 Arguments
External (_SB_.PC00.RP17.POFF, MethodObj) // 0 Arguments
External (_SB_.PC00.RP17.PON_, MethodObj) // 0 Arguments
External (_SB_.PC00.RP17.PPBA, MethodObj) // 1 Arguments
External (_SB_.PC00.RP17.PPS0, MethodObj) // 0 Arguments
External (_SB_.PC00.RP17.PPS3, MethodObj) // 0 Arguments
External (_SB_.PC00.RP17.PRMV, IntObj)
External (_SB_.PC00.RP17.PRTP, IntObj)
External (_SB_.PC00.RP17.PXSX.BCCX, UnknownObj)
External (_SB_.PC00.RP17.PXSX.BOFC, UnknownObj)
External (_SB_.PC00.RP17.PXSX.BRMT, IntObj)
External (_SB_.PC00.RP17.PXSX.CRFI, UnknownObj)
External (_SB_.PC00.RP17.PXSX.DPRS, UnknownObj)
External (_SB_.PC00.RP17.PXSX.FDEL, IntObj)
External (_SB_.PC00.RP17.PXSX.FLRC, UnknownObj)
External (_SB_.PC00.RP17.PXSX.ISGX, MethodObj) // 0 Arguments
External (_SB_.PC00.RP17.PXSX.PAHC, MethodObj) // 0 Arguments
External (_SB_.PC00.RP17.PXSX.PDEL, IntObj)
External (_SB_.PC00.RP17.PXSX.PIXX, UnknownObj)
External (_SB_.PC00.RP17.PXSX.PNVM, MethodObj) // 0 Arguments
External (_SB_.PC00.RP17.PXSX.PRES, MethodObj) // 0 Arguments
External (_SB_.PC00.RP17.PXSX.RDLY, IntObj)
External (_SB_.PC00.RP17.PXSX.RSTY, UnknownObj)
External (_SB_.PC00.RP17.PXSX.SCCX, UnknownObj)
External (_SB_.PC00.RP17.PXSX.VDEL, IntObj)
External (_SB_.PC00.RP17.PXSX.WIST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP17.PXSX.WVHO, IntObj)
External (_SB_.PC00.RP17.PXSX.WWST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP17.RD3C, IntObj)
External (_SB_.PC00.RP17.SLOT, IntObj)
External (_SB_.PC00.RP17.UPRD, MethodObj) // 1 Arguments
External (_SB_.PC00.RP17.VDID, FieldUnitObj)
External (_SB_.PC00.RP18, DeviceObj)
External (_SB_.PC00.RP18.PINI, MethodObj) // 0 Arguments
External (_SB_.PC00.RP18.POFF, MethodObj) // 0 Arguments
External (_SB_.PC00.RP18.PON_, MethodObj) // 0 Arguments
External (_SB_.PC00.RP18.PPBA, MethodObj) // 1 Arguments
External (_SB_.PC00.RP18.PPS0, MethodObj) // 0 Arguments
External (_SB_.PC00.RP18.PPS3, MethodObj) // 0 Arguments
External (_SB_.PC00.RP18.PRMV, IntObj)
External (_SB_.PC00.RP18.PRTP, IntObj)
External (_SB_.PC00.RP18.PXSX.BCCX, UnknownObj)
External (_SB_.PC00.RP18.PXSX.BOFC, UnknownObj)
External (_SB_.PC00.RP18.PXSX.BRMT, IntObj)
External (_SB_.PC00.RP18.PXSX.CRFI, UnknownObj)
External (_SB_.PC00.RP18.PXSX.DPRS, UnknownObj)
External (_SB_.PC00.RP18.PXSX.FDEL, IntObj)
External (_SB_.PC00.RP18.PXSX.FLRC, UnknownObj)
External (_SB_.PC00.RP18.PXSX.ISGX, MethodObj) // 0 Arguments
External (_SB_.PC00.RP18.PXSX.PAHC, MethodObj) // 0 Arguments
External (_SB_.PC00.RP18.PXSX.PDEL, IntObj)
External (_SB_.PC00.RP18.PXSX.PIXX, UnknownObj)
External (_SB_.PC00.RP18.PXSX.PNVM, MethodObj) // 0 Arguments
External (_SB_.PC00.RP18.PXSX.PRES, MethodObj) // 0 Arguments
External (_SB_.PC00.RP18.PXSX.RDLY, IntObj)
External (_SB_.PC00.RP18.PXSX.RSTY, UnknownObj)
External (_SB_.PC00.RP18.PXSX.SCCX, UnknownObj)
External (_SB_.PC00.RP18.PXSX.VDEL, IntObj)
External (_SB_.PC00.RP18.PXSX.WIST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP18.PXSX.WVHO, IntObj)
External (_SB_.PC00.RP18.PXSX.WWST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP18.RD3C, IntObj)
External (_SB_.PC00.RP18.SLOT, IntObj)
External (_SB_.PC00.RP18.UPRD, MethodObj) // 1 Arguments
External (_SB_.PC00.RP18.VDID, FieldUnitObj)
External (_SB_.PC00.RP19, DeviceObj)
External (_SB_.PC00.RP19.PINI, MethodObj) // 0 Arguments
External (_SB_.PC00.RP19.POFF, MethodObj) // 0 Arguments
External (_SB_.PC00.RP19.PON_, MethodObj) // 0 Arguments
External (_SB_.PC00.RP19.PPBA, MethodObj) // 1 Arguments
External (_SB_.PC00.RP19.PPS0, MethodObj) // 0 Arguments
External (_SB_.PC00.RP19.PPS3, MethodObj) // 0 Arguments
External (_SB_.PC00.RP19.PRMV, IntObj)
External (_SB_.PC00.RP19.PRTP, IntObj)
External (_SB_.PC00.RP19.PXSX.BCCX, UnknownObj)
External (_SB_.PC00.RP19.PXSX.BOFC, UnknownObj)
External (_SB_.PC00.RP19.PXSX.BRMT, IntObj)
External (_SB_.PC00.RP19.PXSX.CRFI, UnknownObj)
External (_SB_.PC00.RP19.PXSX.DPRS, UnknownObj)
External (_SB_.PC00.RP19.PXSX.FDEL, IntObj)
External (_SB_.PC00.RP19.PXSX.FLRC, UnknownObj)
External (_SB_.PC00.RP19.PXSX.ISGX, MethodObj) // 0 Arguments
External (_SB_.PC00.RP19.PXSX.PAHC, MethodObj) // 0 Arguments
External (_SB_.PC00.RP19.PXSX.PDEL, IntObj)
External (_SB_.PC00.RP19.PXSX.PIXX, UnknownObj)
External (_SB_.PC00.RP19.PXSX.PNVM, MethodObj) // 0 Arguments
External (_SB_.PC00.RP19.PXSX.PRES, MethodObj) // 0 Arguments
External (_SB_.PC00.RP19.PXSX.RDLY, IntObj)
External (_SB_.PC00.RP19.PXSX.RSTY, UnknownObj)
External (_SB_.PC00.RP19.PXSX.SCCX, UnknownObj)
External (_SB_.PC00.RP19.PXSX.VDEL, IntObj)
External (_SB_.PC00.RP19.PXSX.WIST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP19.PXSX.WVHO, IntObj)
External (_SB_.PC00.RP19.PXSX.WWST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP19.RD3C, IntObj)
External (_SB_.PC00.RP19.SLOT, IntObj)
External (_SB_.PC00.RP19.UPRD, MethodObj) // 1 Arguments
External (_SB_.PC00.RP19.VDID, FieldUnitObj)
External (_SB_.PC00.RP20, DeviceObj)
External (_SB_.PC00.RP20.PINI, MethodObj) // 0 Arguments
External (_SB_.PC00.RP20.POFF, MethodObj) // 0 Arguments
External (_SB_.PC00.RP20.PON_, MethodObj) // 0 Arguments
External (_SB_.PC00.RP20.PPBA, MethodObj) // 1 Arguments
External (_SB_.PC00.RP20.PPS0, MethodObj) // 0 Arguments
External (_SB_.PC00.RP20.PPS3, MethodObj) // 0 Arguments
External (_SB_.PC00.RP20.PRMV, IntObj)
External (_SB_.PC00.RP20.PRTP, IntObj)
External (_SB_.PC00.RP20.PXSX.BCCX, UnknownObj)
External (_SB_.PC00.RP20.PXSX.BOFC, UnknownObj)
External (_SB_.PC00.RP20.PXSX.BRMT, IntObj)
External (_SB_.PC00.RP20.PXSX.CRFI, UnknownObj)
External (_SB_.PC00.RP20.PXSX.DPRS, UnknownObj)
External (_SB_.PC00.RP20.PXSX.FDEL, IntObj)
External (_SB_.PC00.RP20.PXSX.FLRC, UnknownObj)
External (_SB_.PC00.RP20.PXSX.ISGX, MethodObj) // 0 Arguments
External (_SB_.PC00.RP20.PXSX.PAHC, MethodObj) // 0 Arguments
External (_SB_.PC00.RP20.PXSX.PDEL, IntObj)
External (_SB_.PC00.RP20.PXSX.PIXX, UnknownObj)
External (_SB_.PC00.RP20.PXSX.PNVM, MethodObj) // 0 Arguments
External (_SB_.PC00.RP20.PXSX.PRES, MethodObj) // 0 Arguments
External (_SB_.PC00.RP20.PXSX.RDLY, IntObj)
External (_SB_.PC00.RP20.PXSX.RSTY, UnknownObj)
External (_SB_.PC00.RP20.PXSX.SCCX, UnknownObj)
External (_SB_.PC00.RP20.PXSX.VDEL, IntObj)
External (_SB_.PC00.RP20.PXSX.WIST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP20.PXSX.WVHO, IntObj)
External (_SB_.PC00.RP20.PXSX.WWST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP20.RD3C, IntObj)
External (_SB_.PC00.RP20.SLOT, IntObj)
External (_SB_.PC00.RP20.UPRD, MethodObj) // 1 Arguments
External (_SB_.PC00.RP20.VDID, FieldUnitObj)
External (_SB_.PC00.RP21, DeviceObj)
External (_SB_.PC00.RP21.NFRP, MethodObj) // 0 Arguments
External (_SB_.PC00.RP21.PINI, MethodObj) // 0 Arguments
External (_SB_.PC00.RP21.POFF, MethodObj) // 0 Arguments
External (_SB_.PC00.RP21.PON_, MethodObj) // 0 Arguments
External (_SB_.PC00.RP21.PPBA, MethodObj) // 1 Arguments
External (_SB_.PC00.RP21.PPS0, MethodObj) // 0 Arguments
External (_SB_.PC00.RP21.PPS3, MethodObj) // 0 Arguments
External (_SB_.PC00.RP21.PRMV, IntObj)
External (_SB_.PC00.RP21.PRTP, IntObj)
External (_SB_.PC00.RP21.PXSX.BCCX, UnknownObj)
External (_SB_.PC00.RP21.PXSX.BOFC, UnknownObj)
External (_SB_.PC00.RP21.PXSX.BRMT, IntObj)
External (_SB_.PC00.RP21.PXSX.CRFI, UnknownObj)
External (_SB_.PC00.RP21.PXSX.DPRS, UnknownObj)
External (_SB_.PC00.RP21.PXSX.FDEL, IntObj)
External (_SB_.PC00.RP21.PXSX.FLRC, UnknownObj)
External (_SB_.PC00.RP21.PXSX.ISGX, MethodObj) // 0 Arguments
External (_SB_.PC00.RP21.PXSX.PAHC, MethodObj) // 0 Arguments
External (_SB_.PC00.RP21.PXSX.PDEL, IntObj)
External (_SB_.PC00.RP21.PXSX.PIXX, UnknownObj)
External (_SB_.PC00.RP21.PXSX.PNVM, MethodObj) // 0 Arguments
External (_SB_.PC00.RP21.PXSX.PRES, MethodObj) // 0 Arguments
External (_SB_.PC00.RP21.PXSX.RDLY, IntObj)
External (_SB_.PC00.RP21.PXSX.RSTY, UnknownObj)
External (_SB_.PC00.RP21.PXSX.SCCX, UnknownObj)
External (_SB_.PC00.RP21.PXSX.VDEL, IntObj)
External (_SB_.PC00.RP21.PXSX.WIST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP21.PXSX.WVHO, IntObj)
External (_SB_.PC00.RP21.PXSX.WWST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP21.RD3C, IntObj)
External (_SB_.PC00.RP21.SLOT, IntObj)
External (_SB_.PC00.RP21.UPRD, MethodObj) // 1 Arguments
External (_SB_.PC00.RP21.VDID, FieldUnitObj)
External (_SB_.PC00.RP22, DeviceObj)
External (_SB_.PC00.RP22.PINI, MethodObj) // 0 Arguments
External (_SB_.PC00.RP22.POFF, MethodObj) // 0 Arguments
External (_SB_.PC00.RP22.PON_, MethodObj) // 0 Arguments
External (_SB_.PC00.RP22.PPBA, MethodObj) // 1 Arguments
External (_SB_.PC00.RP22.PPS0, MethodObj) // 0 Arguments
External (_SB_.PC00.RP22.PPS3, MethodObj) // 0 Arguments
External (_SB_.PC00.RP22.PRMV, IntObj)
External (_SB_.PC00.RP22.PRTP, IntObj)
External (_SB_.PC00.RP22.PXSX.BCCX, UnknownObj)
External (_SB_.PC00.RP22.PXSX.BOFC, UnknownObj)
External (_SB_.PC00.RP22.PXSX.BRMT, IntObj)
External (_SB_.PC00.RP22.PXSX.CRFI, UnknownObj)
External (_SB_.PC00.RP22.PXSX.DPRS, UnknownObj)
External (_SB_.PC00.RP22.PXSX.FDEL, IntObj)
External (_SB_.PC00.RP22.PXSX.FLRC, UnknownObj)
External (_SB_.PC00.RP22.PXSX.ISGX, MethodObj) // 0 Arguments
External (_SB_.PC00.RP22.PXSX.PAHC, MethodObj) // 0 Arguments
External (_SB_.PC00.RP22.PXSX.PDEL, IntObj)
External (_SB_.PC00.RP22.PXSX.PIXX, UnknownObj)
External (_SB_.PC00.RP22.PXSX.PNVM, MethodObj) // 0 Arguments
External (_SB_.PC00.RP22.PXSX.PRES, MethodObj) // 0 Arguments
External (_SB_.PC00.RP22.PXSX.RDLY, IntObj)
External (_SB_.PC00.RP22.PXSX.RSTY, UnknownObj)
External (_SB_.PC00.RP22.PXSX.SCCX, UnknownObj)
External (_SB_.PC00.RP22.PXSX.VDEL, IntObj)
External (_SB_.PC00.RP22.PXSX.WIST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP22.PXSX.WVHO, IntObj)
External (_SB_.PC00.RP22.PXSX.WWST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP22.RD3C, IntObj)
External (_SB_.PC00.RP22.SLOT, IntObj)
External (_SB_.PC00.RP22.UPRD, MethodObj) // 1 Arguments
External (_SB_.PC00.RP22.VDID, FieldUnitObj)
External (_SB_.PC00.RP23, DeviceObj)
External (_SB_.PC00.RP23.PINI, MethodObj) // 0 Arguments
External (_SB_.PC00.RP23.POFF, MethodObj) // 0 Arguments
External (_SB_.PC00.RP23.PON_, MethodObj) // 0 Arguments
External (_SB_.PC00.RP23.PPBA, MethodObj) // 1 Arguments
External (_SB_.PC00.RP23.PPS0, MethodObj) // 0 Arguments
External (_SB_.PC00.RP23.PPS3, MethodObj) // 0 Arguments
External (_SB_.PC00.RP23.PRMV, IntObj)
External (_SB_.PC00.RP23.PRTP, IntObj)
External (_SB_.PC00.RP23.PXSX.BCCX, UnknownObj)
External (_SB_.PC00.RP23.PXSX.BOFC, UnknownObj)
External (_SB_.PC00.RP23.PXSX.BRMT, IntObj)
External (_SB_.PC00.RP23.PXSX.CRFI, UnknownObj)
External (_SB_.PC00.RP23.PXSX.DPRS, UnknownObj)
External (_SB_.PC00.RP23.PXSX.FDEL, IntObj)
External (_SB_.PC00.RP23.PXSX.FLRC, UnknownObj)
External (_SB_.PC00.RP23.PXSX.ISGX, MethodObj) // 0 Arguments
External (_SB_.PC00.RP23.PXSX.PAHC, MethodObj) // 0 Arguments
External (_SB_.PC00.RP23.PXSX.PDEL, IntObj)
External (_SB_.PC00.RP23.PXSX.PIXX, UnknownObj)
External (_SB_.PC00.RP23.PXSX.PNVM, MethodObj) // 0 Arguments
External (_SB_.PC00.RP23.PXSX.PRES, MethodObj) // 0 Arguments
External (_SB_.PC00.RP23.PXSX.RDLY, IntObj)
External (_SB_.PC00.RP23.PXSX.RSTY, UnknownObj)
External (_SB_.PC00.RP23.PXSX.SCCX, UnknownObj)
External (_SB_.PC00.RP23.PXSX.VDEL, IntObj)
External (_SB_.PC00.RP23.PXSX.WIST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP23.PXSX.WVHO, IntObj)
External (_SB_.PC00.RP23.PXSX.WWST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP23.RD3C, IntObj)
External (_SB_.PC00.RP23.SLOT, IntObj)
External (_SB_.PC00.RP23.UPRD, MethodObj) // 1 Arguments
External (_SB_.PC00.RP23.VDID, FieldUnitObj)
External (_SB_.PC00.RP24, DeviceObj)
External (_SB_.PC00.RP24.PINI, MethodObj) // 0 Arguments
External (_SB_.PC00.RP24.POFF, MethodObj) // 0 Arguments
External (_SB_.PC00.RP24.PON_, MethodObj) // 0 Arguments
External (_SB_.PC00.RP24.PPBA, MethodObj) // 1 Arguments
External (_SB_.PC00.RP24.PPS0, MethodObj) // 0 Arguments
External (_SB_.PC00.RP24.PPS3, MethodObj) // 0 Arguments
External (_SB_.PC00.RP24.PRMV, IntObj)
External (_SB_.PC00.RP24.PRTP, IntObj)
External (_SB_.PC00.RP24.PXSX.BCCX, UnknownObj)
External (_SB_.PC00.RP24.PXSX.BOFC, UnknownObj)
External (_SB_.PC00.RP24.PXSX.BRMT, IntObj)
External (_SB_.PC00.RP24.PXSX.CRFI, UnknownObj)
External (_SB_.PC00.RP24.PXSX.DPRS, UnknownObj)
External (_SB_.PC00.RP24.PXSX.FDEL, IntObj)
External (_SB_.PC00.RP24.PXSX.FLRC, UnknownObj)
External (_SB_.PC00.RP24.PXSX.ISGX, MethodObj) // 0 Arguments
External (_SB_.PC00.RP24.PXSX.PAHC, MethodObj) // 0 Arguments
External (_SB_.PC00.RP24.PXSX.PDEL, IntObj)
External (_SB_.PC00.RP24.PXSX.PIXX, UnknownObj)
External (_SB_.PC00.RP24.PXSX.PNVM, MethodObj) // 0 Arguments
External (_SB_.PC00.RP24.PXSX.PRES, MethodObj) // 0 Arguments
External (_SB_.PC00.RP24.PXSX.RDLY, IntObj)
External (_SB_.PC00.RP24.PXSX.RSTY, UnknownObj)
External (_SB_.PC00.RP24.PXSX.SCCX, UnknownObj)
External (_SB_.PC00.RP24.PXSX.VDEL, IntObj)
External (_SB_.PC00.RP24.PXSX.WIST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP24.PXSX.WVHO, IntObj)
External (_SB_.PC00.RP24.PXSX.WWST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP24.RD3C, IntObj)
External (_SB_.PC00.RP24.SLOT, IntObj)
External (_SB_.PC00.RP24.UPRD, MethodObj) // 1 Arguments
External (_SB_.PC00.RP24.VDID, FieldUnitObj)
External (_SB_.PC00.RP25, DeviceObj)
External (_SB_.PC00.RP25.NFRP, MethodObj) // 0 Arguments
External (_SB_.PC00.RP25.PINI, MethodObj) // 0 Arguments
External (_SB_.PC00.RP25.POFF, MethodObj) // 0 Arguments
External (_SB_.PC00.RP25.PON_, MethodObj) // 0 Arguments
External (_SB_.PC00.RP25.PPBA, MethodObj) // 1 Arguments
External (_SB_.PC00.RP25.PPS0, MethodObj) // 0 Arguments
External (_SB_.PC00.RP25.PPS3, MethodObj) // 0 Arguments
External (_SB_.PC00.RP25.PRMV, IntObj)
External (_SB_.PC00.RP25.PRTP, IntObj)
External (_SB_.PC00.RP25.PXSX.BCCX, UnknownObj)
External (_SB_.PC00.RP25.PXSX.BOFC, UnknownObj)
External (_SB_.PC00.RP25.PXSX.BRMT, IntObj)
External (_SB_.PC00.RP25.PXSX.CRFI, UnknownObj)
External (_SB_.PC00.RP25.PXSX.DPRS, UnknownObj)
External (_SB_.PC00.RP25.PXSX.FDEL, IntObj)
External (_SB_.PC00.RP25.PXSX.FLRC, UnknownObj)
External (_SB_.PC00.RP25.PXSX.ISGX, MethodObj) // 0 Arguments
External (_SB_.PC00.RP25.PXSX.PAHC, MethodObj) // 0 Arguments
External (_SB_.PC00.RP25.PXSX.PDEL, IntObj)
External (_SB_.PC00.RP25.PXSX.PIXX, UnknownObj)
External (_SB_.PC00.RP25.PXSX.PNVM, MethodObj) // 0 Arguments
External (_SB_.PC00.RP25.PXSX.PRES, MethodObj) // 0 Arguments
External (_SB_.PC00.RP25.PXSX.RDLY, IntObj)
External (_SB_.PC00.RP25.PXSX.RSTY, UnknownObj)
External (_SB_.PC00.RP25.PXSX.SCCX, UnknownObj)
External (_SB_.PC00.RP25.PXSX.VDEL, IntObj)
External (_SB_.PC00.RP25.PXSX.WIST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP25.PXSX.WVHO, IntObj)
External (_SB_.PC00.RP25.PXSX.WWST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP25.RD3C, IntObj)
External (_SB_.PC00.RP25.SLOT, IntObj)
External (_SB_.PC00.RP25.UPRD, MethodObj) // 1 Arguments
External (_SB_.PC00.RP25.VDID, FieldUnitObj)
External (_SB_.PC00.RP26, DeviceObj)
External (_SB_.PC00.RP26.PINI, MethodObj) // 0 Arguments
External (_SB_.PC00.RP26.POFF, MethodObj) // 0 Arguments
External (_SB_.PC00.RP26.PON_, MethodObj) // 0 Arguments
External (_SB_.PC00.RP26.PPBA, MethodObj) // 1 Arguments
External (_SB_.PC00.RP26.PPS0, MethodObj) // 0 Arguments
External (_SB_.PC00.RP26.PPS3, MethodObj) // 0 Arguments
External (_SB_.PC00.RP26.PRMV, IntObj)
External (_SB_.PC00.RP26.PRTP, IntObj)
External (_SB_.PC00.RP26.PXSX.BCCX, UnknownObj)
External (_SB_.PC00.RP26.PXSX.BOFC, UnknownObj)
External (_SB_.PC00.RP26.PXSX.BRMT, IntObj)
External (_SB_.PC00.RP26.PXSX.CRFI, UnknownObj)
External (_SB_.PC00.RP26.PXSX.DPRS, UnknownObj)
External (_SB_.PC00.RP26.PXSX.FDEL, IntObj)
External (_SB_.PC00.RP26.PXSX.FLRC, UnknownObj)
External (_SB_.PC00.RP26.PXSX.ISGX, MethodObj) // 0 Arguments
External (_SB_.PC00.RP26.PXSX.PAHC, MethodObj) // 0 Arguments
External (_SB_.PC00.RP26.PXSX.PDEL, IntObj)
External (_SB_.PC00.RP26.PXSX.PIXX, UnknownObj)
External (_SB_.PC00.RP26.PXSX.PNVM, MethodObj) // 0 Arguments
External (_SB_.PC00.RP26.PXSX.PRES, MethodObj) // 0 Arguments
External (_SB_.PC00.RP26.PXSX.RDLY, IntObj)
External (_SB_.PC00.RP26.PXSX.RSTY, UnknownObj)
External (_SB_.PC00.RP26.PXSX.SCCX, UnknownObj)
External (_SB_.PC00.RP26.PXSX.VDEL, IntObj)
External (_SB_.PC00.RP26.PXSX.WIST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP26.PXSX.WVHO, IntObj)
External (_SB_.PC00.RP26.PXSX.WWST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP26.RD3C, IntObj)
External (_SB_.PC00.RP26.SLOT, IntObj)
External (_SB_.PC00.RP26.UPRD, MethodObj) // 1 Arguments
External (_SB_.PC00.RP26.VDID, FieldUnitObj)
External (_SB_.PC00.RP27, DeviceObj)
External (_SB_.PC00.RP27.PINI, MethodObj) // 0 Arguments
External (_SB_.PC00.RP27.POFF, MethodObj) // 0 Arguments
External (_SB_.PC00.RP27.PON_, MethodObj) // 0 Arguments
External (_SB_.PC00.RP27.PPBA, MethodObj) // 1 Arguments
External (_SB_.PC00.RP27.PPS0, MethodObj) // 0 Arguments
External (_SB_.PC00.RP27.PPS3, MethodObj) // 0 Arguments
External (_SB_.PC00.RP27.PRMV, IntObj)
External (_SB_.PC00.RP27.PRTP, IntObj)
External (_SB_.PC00.RP27.PXSX.BCCX, UnknownObj)
External (_SB_.PC00.RP27.PXSX.BOFC, UnknownObj)
External (_SB_.PC00.RP27.PXSX.BRMT, IntObj)
External (_SB_.PC00.RP27.PXSX.CRFI, UnknownObj)
External (_SB_.PC00.RP27.PXSX.DPRS, UnknownObj)
External (_SB_.PC00.RP27.PXSX.FDEL, IntObj)
External (_SB_.PC00.RP27.PXSX.FLRC, UnknownObj)
External (_SB_.PC00.RP27.PXSX.ISGX, MethodObj) // 0 Arguments
External (_SB_.PC00.RP27.PXSX.PAHC, MethodObj) // 0 Arguments
External (_SB_.PC00.RP27.PXSX.PDEL, IntObj)
External (_SB_.PC00.RP27.PXSX.PIXX, UnknownObj)
External (_SB_.PC00.RP27.PXSX.PNVM, MethodObj) // 0 Arguments
External (_SB_.PC00.RP27.PXSX.PRES, MethodObj) // 0 Arguments
External (_SB_.PC00.RP27.PXSX.RDLY, IntObj)
External (_SB_.PC00.RP27.PXSX.RSTY, UnknownObj)
External (_SB_.PC00.RP27.PXSX.SCCX, UnknownObj)
External (_SB_.PC00.RP27.PXSX.VDEL, IntObj)
External (_SB_.PC00.RP27.PXSX.WIST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP27.PXSX.WVHO, IntObj)
External (_SB_.PC00.RP27.PXSX.WWST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP27.RD3C, IntObj)
External (_SB_.PC00.RP27.SLOT, IntObj)
External (_SB_.PC00.RP27.UPRD, MethodObj) // 1 Arguments
External (_SB_.PC00.RP27.VDID, FieldUnitObj)
External (_SB_.PC00.RP28, DeviceObj)
External (_SB_.PC00.RP28.PINI, MethodObj) // 0 Arguments
External (_SB_.PC00.RP28.POFF, MethodObj) // 0 Arguments
External (_SB_.PC00.RP28.PON_, MethodObj) // 0 Arguments
External (_SB_.PC00.RP28.PPBA, MethodObj) // 1 Arguments
External (_SB_.PC00.RP28.PPS0, MethodObj) // 0 Arguments
External (_SB_.PC00.RP28.PPS3, MethodObj) // 0 Arguments
External (_SB_.PC00.RP28.PRMV, IntObj)
External (_SB_.PC00.RP28.PRTP, IntObj)
External (_SB_.PC00.RP28.PXSX.BCCX, UnknownObj)
External (_SB_.PC00.RP28.PXSX.BOFC, UnknownObj)
External (_SB_.PC00.RP28.PXSX.BRMT, IntObj)
External (_SB_.PC00.RP28.PXSX.CRFI, UnknownObj)
External (_SB_.PC00.RP28.PXSX.DPRS, UnknownObj)
External (_SB_.PC00.RP28.PXSX.FDEL, IntObj)
External (_SB_.PC00.RP28.PXSX.FLRC, UnknownObj)
External (_SB_.PC00.RP28.PXSX.ISGX, MethodObj) // 0 Arguments
External (_SB_.PC00.RP28.PXSX.PAHC, MethodObj) // 0 Arguments
External (_SB_.PC00.RP28.PXSX.PDEL, IntObj)
External (_SB_.PC00.RP28.PXSX.PIXX, UnknownObj)
External (_SB_.PC00.RP28.PXSX.PNVM, MethodObj) // 0 Arguments
External (_SB_.PC00.RP28.PXSX.PRES, MethodObj) // 0 Arguments
External (_SB_.PC00.RP28.PXSX.RDLY, IntObj)
External (_SB_.PC00.RP28.PXSX.RSTY, UnknownObj)
External (_SB_.PC00.RP28.PXSX.SCCX, UnknownObj)
External (_SB_.PC00.RP28.PXSX.VDEL, IntObj)
External (_SB_.PC00.RP28.PXSX.WIST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP28.PXSX.WVHO, IntObj)
External (_SB_.PC00.RP28.PXSX.WWST, MethodObj) // 0 Arguments
External (_SB_.PC00.RP28.RD3C, IntObj)
External (_SB_.PC00.RP28.SLOT, IntObj)
External (_SB_.PC00.RP28.UPRD, MethodObj) // 1 Arguments
External (_SB_.PC00.RP28.VDID, FieldUnitObj)
External (_SB_.PC00.SAT0.PRT0, DeviceObj)
External (_SB_.PC00.SAT0.PRT0.PRES, MethodObj) // 0 Arguments
External (_SB_.PC00.SAT0.PRT0.SPOF, MethodObj) // 0 Arguments
External (_SB_.PC00.SAT0.PRT0.SPON, MethodObj) // 0 Arguments
External (_SB_.PC00.SAT0.PRT1, DeviceObj)
External (_SB_.PC00.SAT0.PRT1.PRES, MethodObj) // 0 Arguments
External (_SB_.PC00.SAT0.PRT1.SPOF, MethodObj) // 0 Arguments
External (_SB_.PC00.SAT0.PRT1.SPON, MethodObj) // 0 Arguments
External (_SB_.PC00.SAT0.PRT2, DeviceObj)
External (_SB_.PC00.SAT0.PRT2.PRES, MethodObj) // 0 Arguments
External (_SB_.PC00.SAT0.PRT2.SPOF, MethodObj) // 0 Arguments
External (_SB_.PC00.SAT0.PRT2.SPON, MethodObj) // 0 Arguments
External (_SB_.PC00.SAT0.PRT3, DeviceObj)
External (_SB_.PC00.SAT0.PRT3.PRES, MethodObj) // 0 Arguments
External (_SB_.PC00.SAT0.PRT3.SPOF, MethodObj) // 0 Arguments
External (_SB_.PC00.SAT0.PRT3.SPON, MethodObj) // 0 Arguments
External (_SB_.PC00.SAT0.PRT4, DeviceObj)
External (_SB_.PC00.SAT0.PRT4.PRES, MethodObj) // 0 Arguments
External (_SB_.PC00.SAT0.PRT4.SPOF, MethodObj) // 0 Arguments
External (_SB_.PC00.SAT0.PRT4.SPON, MethodObj) // 0 Arguments
External (_SB_.PC00.SAT0.PRT5, DeviceObj)
External (_SB_.PC00.SAT0.PRT5.PRES, MethodObj) // 0 Arguments
External (_SB_.PC00.SAT0.PRT5.SPOF, MethodObj) // 0 Arguments
External (_SB_.PC00.SAT0.PRT5.SPON, MethodObj) // 0 Arguments
External (_SB_.PC00.SAT0.PRT6, DeviceObj)
External (_SB_.PC00.SAT0.PRT6.PRES, MethodObj) // 0 Arguments
External (_SB_.PC00.SAT0.PRT6.SPOF, MethodObj) // 0 Arguments
External (_SB_.PC00.SAT0.PRT6.SPON, MethodObj) // 0 Arguments
External (_SB_.PC00.SAT0.PRT7, DeviceObj)
External (_SB_.PC00.SAT0.PRT7.PRES, MethodObj) // 0 Arguments
External (_SB_.PC00.SAT0.PRT7.SPOF, MethodObj) // 0 Arguments
External (_SB_.PC00.SAT0.PRT7.SPON, MethodObj) // 0 Arguments
External (_SB_.PC00.SAT0.SATC, MethodObj) // 1 Arguments
External (_SB_.PC00.SAT0.SATD, MethodObj) // 4 Arguments
External (_SB_.PC00.SAT0.ZPOV, MethodObj) // 3 Arguments
External (_SB_.PC00.SWAK, MethodObj) // 2 Arguments
External (_SB_.PC00.TDM0, DeviceObj)
External (_SB_.PC00.TDM0._STA, UnknownObj)
External (_SB_.PC00.TDM0.SCME, UnknownObj)
External (_SB_.PC00.TDM0.STCM, MethodObj) // 2 Arguments
External (_SB_.PC00.TDM1, DeviceObj)
External (_SB_.PC00.TDM1._STA, UnknownObj)
External (_SB_.PC00.TDM1.SCME, UnknownObj)
External (_SB_.PC00.TDM1.STCM, MethodObj) // 2 Arguments
External (_SB_.PC00.THC0, DeviceObj)
External (_SB_.PC00.THC0.CINI, MethodObj) // 2 Arguments
External (_SB_.PC00.THC1, DeviceObj)
External (_SB_.PC00.THC1.CINI, MethodObj) // 2 Arguments
External (_SB_.PC00.TXHC, DeviceObj)
External (_SB_.PC00.UA00.WGAS, IntObj)
External (_SB_.PC00.XHCI.DUAM, MethodObj) // 0 Arguments
External (_SB_.PC00.XHCI.PS0X, MethodObj) // 0 Arguments
External (_SB_.PC00.XHCI.PS3X, MethodObj) // 0 Arguments
External (_SB_.PC00.XHCI.PSLI, MethodObj) // 1 Arguments
External (_SB_.PC00.XHCI.PSLP, MethodObj) // 1 Arguments
External (_SB_.PC00.XHCI.RHUB.HS10.BRMT, IntObj)
External (_SB_.PC00.XHCI.RHUB.HS10.CBTC, IntObj)
External (_SB_.PC00.XHCI.RHUB.HS10.CBTI, IntObj)
External (_SB_.PC00.XHCI.RHUB.HS10.RDLY, UnknownObj)
External (_SB_.PC00.XHCI.RHUB.HS10.WGAS, IntObj)
External (_SB_.PC00.XHCI.RHUB.HS10.WVHO, IntObj)
External (_SB_.PC00.XHCI.RHUB.HS14.BRMT, IntObj)
External (_SB_.PC00.XHCI.RHUB.HS14.CBTC, IntObj)
External (_SB_.PC00.XHCI.RHUB.HS14.CBTI, IntObj)
External (_SB_.PC00.XHCI.RHUB.HS14.RDLY, UnknownObj)
External (_SB_.PC00.XHCI.RHUB.HS14.WGAS, IntObj)
External (_SB_.PC00.XHCI.RHUB.HS14.WVHO, IntObj)
External (_SB_.PC00.XHCI.RHUB.INIR, MethodObj) // 0 Arguments
External (_SB_.PC00.XHCI.RHUB.PS0X, MethodObj) // 0 Arguments
External (_SB_.PC00.XHCI.RHUB.PS2X, MethodObj) // 0 Arguments
External (_SB_.PC00.XHCI.RHUB.PS3X, MethodObj) // 0 Arguments
External (_SB_.PR00.LPSS, PkgObj)
External (_SB_.PR00.TPSS, PkgObj)
External (_SB_.PTHH.THEN, MethodObj) // 0 Arguments
External (_SB_.PWRB, DeviceObj)
External (_SB_.SGOV, MethodObj) // 2 Arguments
External (_SB_.TCWK, MethodObj) // 1 Arguments
External (_SB_.TPM_.PTS_, MethodObj) // 1 Arguments
External (_SB_.TRPD, UnknownObj)
External (_SB_.TRPF, UnknownObj)
External (_SB_.UBTC, DeviceObj)
External (_SB_.UBTC.ECRD, MethodObj) // 0 Arguments
External (_SB_.WM00, DeviceObj)
External (_TZ_.ETMD, IntObj)
External (_TZ_.TZ00, DeviceObj)
External (BGIA, IntObj)
External (BGMA, IntObj)
External (BGMS, IntObj)
External (BIPM, UnknownObj)
External (BPNT, MethodObj) // 0 Arguments
External (BTCA, UnknownObj)
External (CNMT, UnknownObj)
External (DDMS, MethodObj) // 0 Arguments
External (DGBA, UnknownObj)
External (DGDX, UnknownObj)
External (DIDX, UnknownObj)
External (DIDY, UnknownObj)
External (DME0, UnknownObj)
External (DME1, UnknownObj)
External (DPG1, UnknownObj)
External (DPIW, UnknownObj)
External (DPMS, FieldUnitObj)
External (DPRS, IntObj)
External (DSCE, IntObj)
External (DTCM, MethodObj) // 2 Arguments
External (DTFS, UnknownObj)
External (DTRT, UnknownObj)
External (DUWS, UnknownObj)
External (EPTU, FieldUnitObj)
External (ESPC, UnknownObj)
External (GPRV, MethodObj) // 2 Arguments
External (HBCL, FieldUnitObj)
External (HBPL, FieldUnitObj)
External (HGMD, UnknownObj)
External (ISAR, MethodObj) // 4 Arguments
External (ITSP, IntObj)
External (KMOF, MethodObj) // 0 Arguments
External (KMON, MethodObj) // 1 Arguments
External (LSKD, IntObj)
External (M32B, IntObj)
External (M32L, IntObj)
External (M64B, IntObj)
External (M64L, IntObj)
External (P0WK, UnknownObj)
External (P1WK, UnknownObj)
External (P2WK, UnknownObj)
External (P3WK, UnknownObj)
External (PCHS, FieldUnitObj)
External (PCHX, IntObj)
External (PCRA, MethodObj) // 3 Arguments
External (PG3S, UnknownObj)
External (PMRL, FieldUnitObj)
External (PMSA, FieldUnitObj)
External (PSON, UnknownObj)
External (PTHM, FieldUnitObj)
External (PU2C, UnknownObj)
External (PU3C, UnknownObj)
External (RPN0, IntObj)
External (RPN1, IntObj)
External (RPS0, IntObj)
External (RPS1, IntObj)
External (RSTY, IntObj)
External (RTD3, FieldUnitObj)
External (SBIE, MethodObj) // 1 Arguments
External (SIME, UnknownObj)
External (SPNT, MethodObj) // 0 Arguments
External (SPTS, MethodObj) // 1 Arguments
External (STD3, FieldUnitObj)
External (SWAK, MethodObj) // 2 Arguments
External (TBPE, IntObj)
External (TCPN, UnknownObj)
External (TDCE, UnknownObj)
External (THCE, UnknownObj)
External (TOFF, IntObj)
External (TPTS, MethodObj) // 1 Arguments
External (TRE0, UnknownObj)
External (TRE1, UnknownObj)
External (TRE2, UnknownObj)
External (TRE3, UnknownObj)
External (TVCF, MethodObj) // 4 Arguments
External (UF0E, UnknownObj)
External (UF1E, UnknownObj)
External (ULTR, MethodObj) // 1 Arguments
External (VDSD, IntObj)
External (VMCP, UnknownObj)
External (VMDE, FieldUnitObj)
External (VMR1, UnknownObj)
External (VMR2, UnknownObj)
External (VMR3, UnknownObj)
External (VMR4, UnknownObj)
External (XBAS, UnknownObj)
External (ZPPB, FieldUnitObj)

Name (SANB, 0x44904418)
Name (SANL, 0x01BC)
OperationRegion (SANV, SystemMemory, SANB, SANL)
Field (SANV, AnyAcc, Lock, Preserve)
{
ASLB, 32,
IMON, 8,
IGDS, 8,
IBTT, 8,
IPAT, 8,
IPSC, 8,
IBIA, 8,
ISSC, 8,
IF1E, 8,
HVCO, 8,
GSMI, 8,
PAVP, 8,
CADL, 8,
CSTE, 16,
NSTE, 16,
NDID, 8,
DID1, 32,
DID2, 32,
DID3, 32,
DID4, 32,
DID5, 32,
DID6, 32,
DID7, 32,
DID8, 32,
DID9, 32,
DIDA, 32,
DIDB, 32,
DIDC, 32,
DIDD, 32,
DIDE, 32,
DIDF, 32,
DIDX, 32,
NXD1, 32,
NXD2, 32,
NXD3, 32,
NXD4, 32,
NXD5, 32,
NXD6, 32,
NXD7, 32,
NXD8, 32,
NXDX, 32,
LIDS, 8,
KSV0, 32,
KSV1, 8,
BRTL, 8,
ALSE, 8,
ALAF, 8,
LLOW, 8,
LHIH, 8,
ALFP, 8,
IPTP, 8,
EDPV, 8,
HGMD, 8,
HGFL, 8,
SGGP, 8,
HRE0, 8,
HRG0, 32,
HRA0, 8,
PWE0, 8,
PWG0, 32,
PWA0, 8,
P1GP, 8,
HRE1, 8,
HRG1, 32,
HRA1, 8,
PWE1, 8,
PWG1, 32,
PWA1, 8,
P2GP, 8,
HRE2, 8,
HRG2, 32,
HRA2, 8,
PWE2, 8,
PWG2, 32,
PWA2, 8,
P3GP, 8,
HRE3, 8,
HRG3, 32,
HRA3, 8,
PWE3, 8,
PWG3, 32,
PWA3, 8,
P3WK, 32,
DLPW, 16,
DLHR, 16,
EECP, 8,
XBAS, 32,
GBAS, 16,
NVGA, 32,
NVHA, 32,
AMDA, 32,
LTRX, 8,
OBFX, 8,
LTRY, 8,
OBFY, 8,
LTRZ, 8,
OBFZ, 8,
LTRW, 8,
OBFA, 8,
SMSL, 16,
SNSL, 16,
M64B, 64,
M64L, 64,
CPEX, 32,
M32B, 32,
M32L, 32,
P0WK, 32,
P1WK, 32,
P2WK, 32,
VTDS, 8,
VTB1, 32,
VTB2, 32,
VTB3, 32,
VTB4, 32,
VTB5, 32,
VTB6, 32,
VTB7, 32,
VE1V, 16,
VE2V, 16,
RPIN, 8,
RPBA, 32,
CTHM, 8,
SIME, 8,
THCE, 8,
TDCE, 8,
DME0, 8,
DME1, 8,
TRE0, 8,
TRE1, 8,
TRE2, 8,
TRE3, 8,
TPA0, 32,
TPA1, 32,
TPA2, 32,
TPA3, 32,
TCDS, 32,
TCIT, 8,
TCIR, 8,
TRTD, 8,
ITM0, 32,
ITM1, 32,
LTE0, 8,
LTE1, 8,
LTE2, 8,
LTE3, 8,
PSL0, 16,
PSL1, 16,
PSL2, 16,
PSL3, 16,
PNS0, 16,
PNS1, 16,
PNS2, 16,
PNS3, 16,
IMRY, 8,
TIVS, 8,
PG0E, 8,
PG1E, 8,
PG2E, 8,
PG3E, 8,
VMDE, 8,
DIDY, 32,
NXDY, 32,
SLTS, 8,
VMR1, 8,
VMR2, 8,
VMR3, 8,
VMR4, 8,
VMS0, 8,
VMCP, 8,
CPRT, 8,
CSLU, 32,
CSSP, 32,
MPGN, 8,
CMBM, 8,
DPMS, 8,
PMSA, 64,
PMRL, 64,
PBR1, 8,
PBR2, 8,
PBR3, 8,
PPA0, 32,
PPA1, 32,
PPA2, 32,
PPA3, 32,
REGO, 16,
WSCI, 8,
RTBM, 8,
PFG0, 8,
PFG1, 8,
PFG2, 8,
PFG3, 8
}

Name (SS1, Zero)
Name (SS2, Zero)
Name (SS3, Zero)
Name (SS4, One)
OperationRegion (GNVS, SystemMemory, 0x448F9018, 0x0D07)
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,
PWRS, 8,
DBGS, 8,
THOF, 8,
ACT1, 8,
ACTT, 8,
PSVT, 8,
TC1V, 8,
TC2V, 8,
TSPV, 8,
CRTT, 8,
REVN, 8,
APIC, 8,
TCNT, 8,
PCP0, 8,
PCP1, 8,
PPCM, 8,
PPMF, 32,
C67L, 8,
NATP, 8,
CMAP, 8,
CMBP, 8,
LPTP, 8,
FDCP, 8,
CMCP, 8,
CIRP, 8,
SMSC, 8,
W381, 8,
SMC1, 8,
EMAE, 8,
EMAP, 16,
EMAL, 16,
MEFE, 8,
DSTS, 8,
MORD, 8,
TCGP, 8,
PPRP, 32,
PPRQ, 8,
LPPR, 8,
IDEM, 8,
PLID, 8,
BTYP, 8,
OSCC, 8,
NEXP, 8,
SBV1, 8,
SBV2, 8,
ECON, 8,
DSEN, 8,
GPIC, 8,
CTYP, 8,
L01C, 8,
VFN0, 8,
VFN1, 8,
VFN2, 8,
VFN3, 8,
VFN4, 8,
VFN5, 8,
VFN6, 8,
VFN7, 8,
VFN8, 8,
VFN9, 8,
PNHM, 32,
TBAL, 32,
TBAH, 32,
TSOD, 8,
PFLV, 8,
BREV, 16,
PAMT, 8,
AC0F, 8,
AC1F, 8,
XTUB, 32,
XTUS, 32,
XMPB, 32,
DDRF, 8,
RTD3, 8,
PEP0, 8,
PEP3, 8,
DPTF, 8,
DCFE, 16,
SADE, 8,
FND1, 8,
AMBD, 8,
AMAT, 8,
AMPT, 8,
AMCT, 8,
AMHT, 8,
SKDE, 8,
SKAT, 8,
SKPT, 8,
SKCT, 8,
SKHT, 8,
EFDE, 8,
EFAT, 8,
EFPT, 8,
EFCT, 8,
EFHT, 8,
VRDE, 8,
VRAT, 8,
VRPT, 8,
VRCT, 8,
VRHT, 8,
DPAP, 8,
DPPP, 8,
DPCP, 8,
PIDE, 8,
PPSZ, 32,
Offset (0x9C),
CHEN, 8,
S0ID, 8,
CTDB, 8,
DKSM, 8,
SIO1, 16,
SIO2, 16,
SPBA, 16,
Offset (0x1F3),
PG3S, 8,
PWRE, 8,
Offset (0x1F7),
PPPR, 16,
PBPE, 8,
VSPE, 8,
RFIM, 8,
Offset (0x203),
XHPR, 8,
RIC0, 8,
GBSX, 8,
IUBE, 8,
IUCE, 8,
IUDE, 8,
ECNO, 8,
AUDD, 16,
IC0D, 16,
IC1D, 16,
IC1S, 16,
VRRD, 16,
PSCP, 8,
I20D, 16,
I21D, 16,
RCG0, 16,
RCG1, 16,
P2ME, 8,
P2MK, 8,
SSH0, 16,
SSL0, 16,
SSD0, 16,
FMH0, 16,
FML0, 16,
FMD0, 16,
FPH0, 16,
FPL0, 16,
FPD0, 16,
HSH0, 16,
HSL0, 16,
HSD0, 16,
Offset (0x23D),
SSH1, 16,
SSL1, 16,
SSD1, 16,
FMH1, 16,
FML1, 16,
FMD1, 16,
FPH1, 16,
FPL1, 16,
FPD1, 16,
HSH1, 16,
HSL1, 16,
HSD1, 16,
Offset (0x256),
SSH2, 16,
SSL2, 16,
SSD2, 16,
FMH2, 16,
FML2, 16,
FMD2, 16,
FPH2, 16,
FPL2, 16,
FPD2, 16,
HSH2, 16,
HSL2, 16,
HSD2, 16,
Offset (0x26F),
SSH3, 16,
SSL3, 16,
SSD3, 16,
FMH3, 16,
FML3, 16,
FMD3, 16,
FPH3, 16,
FPL3, 16,
FPD3, 16,
HSH3, 16,
HSL3, 16,
HSD3, 16,
Offset (0x288),
SSH4, 16,
SSL4, 16,
SSD4, 16,
FMH4, 16,
FML4, 16,
FMD4, 16,
FPH4, 16,
FPL4, 16,
FPD4, 16,
HSH4, 16,
HSL4, 16,
HSD4, 16,
Offset (0x2A1),
SSH5, 16,
SSL5, 16,
SSD5, 16,
FMH5, 16,
FML5, 16,
FMD5, 16,
FPH5, 16,
FPL5, 16,
FPD5, 16,
HSH5, 16,
HSL5, 16,
HSD5, 16,
Offset (0x2BA),
M0C0, 16,
M1C0, 16,
M0C1, 16,
M1C1, 16,
M0C2, 16,
M1C2, 16,
M0C3, 16,
M1C3, 16,
M0C4, 16,
M1C4, 16,
M0C5, 16,
M1C5, 16,
M0C6, 16,
M1C6, 16,
M0C7, 16,
M1C7, 16,
M0C8, 16,
M1C8, 16,
Offset (0x2DF),
M0C9, 16,
M1C9, 16,
M0CA, 16,
M1CA, 16,
M0CB, 16,
M1CB, 16,
Offset (0x2EC),
GIRQ, 32,
DMTP, 8,
DMTD, 8,
DMSH, 8,
SHSB, 8,
PLCS, 8,
PLVL, 16,
WWSD, 8,
CVSD, 8,
SSDD, 8,
INLD, 8,
IFAT, 8,
IFPT, 8,
IFCT, 8,
IFHT, 8,
USBH, 8,
BCV4, 8,
WTV0, 8,
WTV1, 8,
APFU, 8,
Offset (0x30A),
PEPC, 64,
VRSD, 16,
PB1E, 8,
GNID, 8,
Offset (0x320),
AUPL, 32,
Offset (0x327),
CHGE, 8,
AMC3, 8,
SKC3, 8,
EFC3, 8,
VRC3, 8,
IFC3, 8,
WGC3, 8,
ESPC, 8,
BATR, 8,
IN34, 8,
ECLP, 8,
MEMS, 8,
S1DE, 8,
S2DE, 8,
S3DE, 8,
S4DE, 8,
S5DE, 8,
S1S3, 8,
S2S3, 8,
S3S3, 8,
S4S3, 8,
S5S3, 8,
PSME, 8,
PDT1, 8,
PLM1, 32,
PTW1, 32,
DDT1, 8,
DDP1, 8,
DLI1, 16,
DPL1, 16,
DTW1, 32,
DMI1, 16,
DMA1, 16,
DMT1, 16,
WIFE, 8,
DOM1, 8,
LIM1, 16,
TIM1, 32,
TRD0, 8,
TRL0, 8,
TRD1, 8,
TRL1, 8,
WDM1, 8,
CID1, 16,
Offset (0x3FA),
APPE, 8,
SDS0, 8,
SDS1, 8,
SDS2, 8,
SDS3, 8,
SDS4, 8,
SDS5, 8,
SDS6, 8,
SDS7, 8,
SDS8, 8,
SDS9, 8,
SDSA, 8,
TPLT, 8,
TPLM, 8,
TPLB, 8,
TPLH, 16,
TPLS, 8,
TPDT, 8,
TPDM, 8,
TPDB, 8,
TPDH, 16,
TPDS, 8,
FPTT, 8,
FPTM, 8,
WTVX, 8,
WITX, 8,
GPTD, 8,
GDBT, 16,
UTKX, 8,
SPTD, 8,
Offset (0x42A),
ATLB, 32,
SDM0, 8,
SDM1, 8,
SDM2, 8,
SDM3, 8,
SDM4, 8,
SDM5, 8,
SDM6, 8,
SDM7, 8,
SDM8, 8,
SDM9, 8,
SDMA, 8,
SDMB, 8,
Offset (0x43B),
USTP, 8,
Offset (0x465),
GFPS, 32,
GFPI, 32,
WBBR, 32,
GBTK, 32,
GBTI, 32,
GPDI, 32,
GPLI, 32,
CL00, 8,
CL01, 8,
CL02, 8,
CL03, 8,
CL04, 8,
CL05, 8,
L0EN, 8,
L1EN, 8,
L2EN, 8,
L3EN, 8,
L4EN, 8,
L5EN, 8,
CDIV, 8,
C0VE, 8,
C0TP, 8,
C0CV, 8,
C0IC, 32,
C0GP, 8,
C0IB, 8,
C0IA, 16,
C0P0, 8,
C0P1, 8,
C0P2, 8,
C0P3, 8,
C0P4, 8,
C0P5, 8,
C0G0, 8,
C0G1, 8,
C0G2, 8,
C0G3, 8,
C0G4, 8,
C0G5, 8,
C0F0, 8,
C0F1, 8,
C0F2, 8,
C0F3, 8,
C0F4, 8,
C0F5, 8,
C0A0, 8,
C0A1, 8,
C0A2, 8,
C0A3, 8,
C0A4, 8,
C0A5, 8,
C0I0, 8,
C0I1, 8,
C0I2, 8,
C0I3, 8,
C0I4, 8,
C0I5, 8,
C0PL, 8,
C0W0, 8,
C0W1, 8,
C0W2, 8,
C0W3, 8,
C0SP, 8,
C0W4, 8,
C0W5, 8,
C0CS, 8,
C1VE, 8,
C1TP, 8,
C1CV, 8,
C1IC, 32,
C1GP, 8,
C1IB, 8,
C1IA, 16,
C1P0, 8,
C1P1, 8,
C1P2, 8,
C1P3, 8,
C1P4, 8,
C1P5, 8,
C1G0, 8,
C1G1, 8,
C1G2, 8,
C1G3, 8,
C1G4, 8,
C1G5, 8,
C1F0, 8,
C1F1, 8,
C1F2, 8,
C1F3, 8,
C1F4, 8,
C1F5, 8,
C1A0, 8,
C1A1, 8,
C1A2, 8,
C1A3, 8,
C1A4, 8,
C1A5, 8,
C1I0, 8,
C1I1, 8,
C1I2, 8,
C1I3, 8,
C1I4, 8,
C1I5, 8,
C1PL, 8,
C1W0, 8,
C1W1, 8,
C1W2, 8,
C1W3, 8,
C1SP, 8,
C1W4, 8,
C1W5, 8,
C1CS, 8,
C2VE, 8,
C2TP, 8,
C2CV, 8,
C2IC, 32,
C2GP, 8,
C2IB, 8,
C2IA, 16,
C2P0, 8,
C2P1, 8,
C2P2, 8,
C2P3, 8,
C2P4, 8,
C2P5, 8,
C2G0, 8,
C2G1, 8,
C2G2, 8,
C2G3, 8,
C2G4, 8,
C2G5, 8,
C2F0, 8,
C2F1, 8,
C2F2, 8,
C2F3, 8,
C2F4, 8,
C2F5, 8,
C2A0, 8,
C2A1, 8,
C2A2, 8,
C2A3, 8,
C2A4, 8,
C2A5, 8,
C2I0, 8,
C2I1, 8,
C2I2, 8,
C2I3, 8,
C2I4, 8,
C2I5, 8,
C2PL, 8,
C2W0, 8,
C2W1, 8,
C2W2, 8,
C2W3, 8,
C2SP, 8,
C2W4, 8,
C2W5, 8,
C2CS, 8,
C3VE, 8,
C3TP, 8,
C3CV, 8,
C3IC, 32,
C3GP, 8,
C3IB, 8,
C3IA, 16,
C3P0, 8,
C3P1, 8,
C3P2, 8,
C3P3, 8,
C3P4, 8,
C3P5, 8,
C3G0, 8,
C3G1, 8,
C3G2, 8,
C3G3, 8,
C3G4, 8,
C3G5, 8,
C3F0, 8,
C3F1, 8,
C3F2, 8,
C3F3, 8,
C3F4, 8,
C3F5, 8,
C3A0, 8,
C3A1, 8,
C3A2, 8,
C3A3, 8,
C3A4, 8,
C3A5, 8,
C3I0, 8,
C3I1, 8,
C3I2, 8,
C3I3, 8,
C3I4, 8,
C3I5, 8,
C3PL, 8,
C3W0, 8,
C3W1, 8,
C3W2, 8,
C3W3, 8,
C3SP, 8,
C3W4, 8,
C3W5, 8,
C3CS, 8,
C4VE, 8,
C4TP, 8,
C4CV, 8,
C4IC, 32,
C4GP, 8,
C4IB, 8,
C4IA, 16,
C4P0, 8,
C4P1, 8,
C4P2, 8,
C4P3, 8,
C4P4, 8,
C4P5, 8,
C4G0, 8,
C4G1, 8,
C4G2, 8,
C4G3, 8,
C4G4, 8,
C4G5, 8,
C4F0, 8,
C4F1, 8,
C4F2, 8,
C4F3, 8,
C4F4, 8,
C4F5, 8,
C4A0, 8,
C4A1, 8,
C4A2, 8,
C4A3, 8,
C4A4, 8,
C4A5, 8,
C4I0, 8,
C4I1, 8,
C4I2, 8,
C4I3, 8,
C4I4, 8,
C4I5, 8,
C4PL, 8,
C4W0, 8,
C4W1, 8,
C4W2, 8,
C4W3, 8,
C4SP, 8,
C4W4, 8,
C4W5, 8,
C4CS, 8,
C5VE, 8,
C5TP, 8,
C5CV, 8,
C5IC, 32,
C5GP, 8,
C5IB, 8,
C5IA, 16,
C5P0, 8,
C5P1, 8,
C5P2, 8,
C5P3, 8,
C5P4, 8,
C5P5, 8,
C5G0, 8,
C5G1, 8,
C5G2, 8,
C5G3, 8,
C5G4, 8,
C5G5, 8,
C5F0, 8,
C5F1, 8,
C5F2, 8,
C5F3, 8,
C5F4, 8,
C5F5, 8,
C5A0, 8,
C5A1, 8,
C5A2, 8,
C5A3, 8,
C5A4, 8,
C5A5, 8,
C5I0, 8,
C5I1, 8,
C5I2, 8,
C5I3, 8,
C5I4, 8,
C5I5, 8,
C5PL, 8,
C5W0, 8,
C5W1, 8,
C5W2, 8,
C5W3, 8,
C5SP, 8,
C5W4, 8,
C5W5, 8,
C5CS, 8,
L0SM, 8,
L0H0, 8,
L0H1, 8,
L0H2, 8,
L0H3, 8,
L0H4, 8,
L0H5, 8,
L0H6, 8,
L0H7, 8,
L0H8, 8,
L0PL, 8,
L0M0, 8,
L0M1, 8,
L0M2, 8,
L0M3, 8,
L0M4, 8,
L0M5, 8,
L0M6, 8,
L0M7, 8,
L0M8, 8,
L0M9, 8,
L0MA, 8,
L0MB, 8,
L0MC, 8,
L0MD, 8,
L0ME, 8,
L0MF, 8,
L0DI, 8,
L0BS, 8,
L0A0, 16,
L0A1, 16,
L0A2, 16,
L0A3, 16,
L0A4, 16,
L0A5, 16,
L0A6, 16,
L0A7, 16,
L0A8, 16,
L0A9, 16,
L0AA, 16,
L0AB, 16,
L0D0, 8,
L0D1, 8,
L0D2, 8,
L0D3, 8,
L0D4, 8,
L0D5, 8,
L0D6, 8,
L0D7, 8,
L0D8, 8,
L0D9, 8,
L0DA, 8,
L0DB, 8,
L0DV, 8,
L0CV, 8,
L0LU, 8,
L0NL, 8,
L0EE, 8,
L0VC, 8,
L0FS, 8,
L0LE, 8,
L0DG, 8,
L0CK, 32,
L0CL, 8,
L0PP, 8,
L0VR, 8,
L0FD, 8,
L1SM, 8,
L1H0, 8,
L1H1, 8,
L1H2, 8,
L1H3, 8,
L1H4, 8,
L1H5, 8,
L1H6, 8,
L1H7, 8,
L1H8, 8,
L1PL, 8,
L1M0, 8,
L1M1, 8,
L1M2, 8,
L1M3, 8,
L1M4, 8,
L1M5, 8,
L1M6, 8,
L1M7, 8,
L1M8, 8,
L1M9, 8,
L1MA, 8,
L1MB, 8,
L1MC, 8,
L1MD, 8,
L1ME, 8,
L1MF, 8,
L1DI, 8,
L1BS, 8,
L1A0, 16,
L1A1, 16,
L1A2, 16,
L1A3, 16,
L1A4, 16,
L1A5, 16,
L1A6, 16,
L1A7, 16,
L1A8, 16,
L1A9, 16,
L1AA, 16,
L1AB, 16,
L1D0, 8,
L1D1, 8,
L1D2, 8,
L1D3, 8,
L1D4, 8,
L1D5, 8,
L1D6, 8,
L1D7, 8,
L1D8, 8,
L1D9, 8,
L1DA, 8,
L1DB, 8,
L1DV, 8,
L1CV, 8,
L1LU, 8,
L1NL, 8,
L1EE, 8,
L1VC, 8,
L1FS, 8,
L1LE, 8,
L1DG, 8,
L1CK, 32,
L1CL, 8,
L1PP, 8,
L1VR, 8,
L1FD, 8,
L2SM, 8,
L2H0, 8,
L2H1, 8,
L2H2, 8,
L2H3, 8,
L2H4, 8,
L2H5, 8,
L2H6, 8,
L2H7, 8,
L2H8, 8,
L2PL, 8,
L2M0, 8,
L2M1, 8,
L2M2, 8,
L2M3, 8,
L2M4, 8,
L2M5, 8,
L2M6, 8,
L2M7, 8,
L2M8, 8,
L2M9, 8,
L2MA, 8,
L2MB, 8,
L2MC, 8,
L2MD, 8,
L2ME, 8,
L2MF, 8,
L2DI, 8,
L2BS, 8,
L2A0, 16,
L2A1, 16,
L2A2, 16,
L2A3, 16,
L2A4, 16,
L2A5, 16,
L2A6, 16,
L2A7, 16,
L2A8, 16,
L2A9, 16,
L2AA, 16,
L2AB, 16,
L2D0, 8,
L2D1, 8,
L2D2, 8,
L2D3, 8,
L2D4, 8,
L2D5, 8,
L2D6, 8,
L2D7, 8,
L2D8, 8,
L2D9, 8,
L2DA, 8,
L2DB, 8,
L2DV, 8,
L2CV, 8,
L2LU, 8,
L2NL, 8,
L2EE, 8,
L2VC, 8,
L2FS, 8,
L2LE, 8,
L2DG, 8,
L2CK, 32,
L2CL, 8,
L2PP, 8,
L2VR, 8,
L2FD, 8,
L3SM, 8,
L3H0, 8,
L3H1, 8,
L3H2, 8,
L3H3, 8,
L3H4, 8,
L3H5, 8,
L3H6, 8,
L3H7, 8,
L3H8, 8,
L3PL, 8,
L3M0, 8,
L3M1, 8,
L3M2, 8,
L3M3, 8,
L3M4, 8,
L3M5, 8,
L3M6, 8,
L3M7, 8,
L3M8, 8,
L3M9, 8,
L3MA, 8,
L3MB, 8,
L3MC, 8,
L3MD, 8,
L3ME, 8,
L3MF, 8,
L3DI, 8,
L3BS, 8,
L3A0, 16,
L3A1, 16,
L3A2, 16,
L3A3, 16,
L3A4, 16,
L3A5, 16,
L3A6, 16,
L3A7, 16,
L3A8, 16,
L3A9, 16,
L3AA, 16,
L3AB, 16,
L3D0, 8,
L3D1, 8,
L3D2, 8,
L3D3, 8,
L3D4, 8,
L3D5, 8,
L3D6, 8,
L3D7, 8,
L3D8, 8,
L3D9, 8,
L3DA, 8,
L3DB, 8,
L3DV, 8,
L3CV, 8,
L3LU, 8,
L3NL, 8,
L3EE, 8,
L3VC, 8,
L3FS, 8,
L3LE, 8,
L3DG, 8,
L3CK, 32,
L3CL, 8,
L3PP, 8,
L3VR, 8,
L3FD, 8,
L4SM, 8,
L4H0, 8,
L4H1, 8,
L4H2, 8,
L4H3, 8,
L4H4, 8,
L4H5, 8,
L4H6, 8,
L4H7, 8,
L4H8, 8,
L4PL, 8,
L4M0, 8,
L4M1, 8,
L4M2, 8,
L4M3, 8,
L4M4, 8,
L4M5, 8,
L4M6, 8,
L4M7, 8,
L4M8, 8,
L4M9, 8,
L4MA, 8,
L4MB, 8,
L4MC, 8,
L4MD, 8,
L4ME, 8,
L4MF, 8,
L4DI, 8,
L4BS, 8,
L4A0, 16,
L4A1, 16,
L4A2, 16,
L4A3, 16,
L4A4, 16,
L4A5, 16,
L4A6, 16,
L4A7, 16,
L4A8, 16,
L4A9, 16,
L4AA, 16,
L4AB, 16,
L4D0, 8,
L4D1, 8,
L4D2, 8,
L4D3, 8,
L4D4, 8,
L4D5, 8,
L4D6, 8,
L4D7, 8,
L4D8, 8,
L4D9, 8,
L4DA, 8,
L4DB, 8,
L4DV, 8,
L4CV, 8,
L4LU, 8,
L4NL, 8,
L4EE, 8,
L4VC, 8,
L4FS, 8,
L4LE, 8,
L4DG, 8,
L4CK, 32,
L4CL, 8,
L4PP, 8,
L4VR, 8,
L4FD, 8,
L5SM, 8,
L5H0, 8,
L5H1, 8,
L5H2, 8,
L5H3, 8,
L5H4, 8,
L5H5, 8,
L5H6, 8,
L5H7, 8,
L5H8, 8,
L5PL, 8,
L5M0, 8,
L5M1, 8,
L5M2, 8,
L5M3, 8,
L5M4, 8,
L5M5, 8,
L5M6, 8,
L5M7, 8,
L5M8, 8,
L5M9, 8,
L5MA, 8,
L5MB, 8,
L5MC, 8,
L5MD, 8,
L5ME, 8,
L5MF, 8,
L5DI, 8,
L5BS, 8,
L5A0, 16,
L5A1, 16,
L5A2, 16,
L5A3, 16,
L5A4, 16,
L5A5, 16,
L5A6, 16,
L5A7, 16,
L5A8, 16,
L5A9, 16,
L5AA, 16,
L5AB, 16,
L5D0, 8,
L5D1, 8,
L5D2, 8,
L5D3, 8,
L5D4, 8,
L5D5, 8,
L5D6, 8,
L5D7, 8,
L5D8, 8,
L5D9, 8,
L5DA, 8,
L5DB, 8,
L5DV, 8,
L5CV, 8,
L5LU, 8,
L5NL, 8,
L5EE, 8,
L5VC, 8,
L5FS, 8,
L5LE, 8,
L5DG, 8,
L5CK, 32,
L5CL, 8,
L5PP, 8,
L5VR, 8,
L5FD, 8,
F0FM, 8,
F0MS, 8,
F0M0, 8,
F0M1, 8,
F0M2, 8,
F0M3, 8,
F0M4, 8,
F0M5, 8,
F0M6, 8,
F0M7, 8,
F0M8, 8,
F0M9, 8,
F0MA, 8,
F0MB, 8,
F0MC, 8,
F0MD, 8,
F0ME, 8,
F0MF, 8,
F0BS, 8,
F0AB, 16,
F0GP, 8,
F0GG, 16,
F0AV, 8,
F0IV, 8,
F0OM, 8,
F1FM, 8,
F1MS, 8,
F1M0, 8,
F1M1, 8,
F1M2, 8,
F1M3, 8,
F1M4, 8,
F1M5, 8,
F1M6, 8,
F1M7, 8,
F1M8, 8,
F1M9, 8,
F1MA, 8,
F1MB, 8,
F1MC, 8,
F1MD, 8,
F1ME, 8,
F1MF, 8,
F1BS, 8,
F1AB, 16,
F1GP, 8,
F1GG, 16,
F1AV, 8,
F1IV, 8,
F1OM, 8,
F2FM, 8,
F2MS, 8,
F2M0, 8,
F2M1, 8,
F2M2, 8,
F2M3, 8,
F2M4, 8,
F2M5, 8,
F2M6, 8,
F2M7, 8,
F2M8, 8,
F2M9, 8,
F2MA, 8,
F2MB, 8,
F2MC, 8,
F2MD, 8,
F2ME, 8,
F2MF, 8,
F2BS, 8,
F2AB, 16,
F2GP, 8,
F2GG, 16,
F2AV, 8,
F2IV, 8,
F2OM, 8,
F3FM, 8,
F3MS, 8,
F3M0, 8,
F3M1, 8,
F3M2, 8,
F3M3, 8,
F3M4, 8,
F3M5, 8,
F3M6, 8,
F3M7, 8,
F3M8, 8,
F3M9, 8,
F3MA, 8,
F3MB, 8,
F3MC, 8,
F3MD, 8,
F3ME, 8,
F3MF, 8,
F3BS, 8,
F3AB, 16,
F3GP, 8,
F3GG, 16,
F3AV, 8,
F3IV, 8,
F3OM, 8,
F4FM, 8,
F4MS, 8,
F4M0, 8,
F4M1, 8,
F4M2, 8,
F4M3, 8,
F4M4, 8,
F4M5, 8,
F4M6, 8,
F4M7, 8,
F4M8, 8,
F4M9, 8,
F4MA, 8,
F4MB, 8,
F4MC, 8,
F4MD, 8,
F4ME, 8,
F4MF, 8,
F4BS, 8,
F4AB, 16,
F4GP, 8,
F4GG, 16,
F4AV, 8,
F4IV, 8,
F4OM, 8,
F5FM, 8,
F5MS, 8,
F5M0, 8,
F5M1, 8,
F5M2, 8,
F5M3, 8,
F5M4, 8,
F5M5, 8,
F5M6, 8,
F5M7, 8,
F5M8, 8,
F5M9, 8,
F5MA, 8,
F5MB, 8,
F5MC, 8,
F5MD, 8,
F5ME, 8,
F5MF, 8,
F5BS, 8,
F5AB, 16,
F5GP, 8,
F5GG, 16,
F5AV, 8,
F5IV, 8,
F5OM, 8,
ECR1, 8,
I2SC, 8,
I2SI, 32,
I2SB, 8,
ODV0, 8,
ODV1, 8,
ODV2, 8,
ODV3, 8,
ODV4, 8,
ODV5, 8,
UBCB, 32,
WIFC, 8,
Offset (0x860),
ADPM, 32,
AG1L, 64,
AG1H, 64,
AG2L, 64,
AG2H, 64,
AG3L, 64,
AG3H, 64,
HEFE, 8,
XDCE, 8,
STXE, 8,
ST10, 8,
ST11, 8,
ST12, 8,
ST13, 8,
ST14, 8,
ST15, 8,
ST16, 8,
ST17, 8,
ST18, 8,
ST19, 8,
ENVM, 8,
DHSP, 16,
DSSP, 16,
DSTP, 8,
STDE, 8,
STRS, 8,
ST20, 8,
ST21, 8,
ST22, 8,
ST23, 8,
ST24, 8,
ST25, 8,
ST26, 8,
ST27, 8,
ST28, 8,
ST29, 8,
ST30, 8,
ST31, 8,
ST32, 8,
ST33, 8,
ST34, 8,
ST35, 8,
ST36, 8,
ST37, 8,
ST38, 8,
ST39, 8,
ST40, 8,
ST41, 8,
ST42, 8,
ST43, 8,
ST44, 8,
ST45, 8,
ST46, 8,
ST47, 8,
ST48, 8,
ST49, 8,
SD11, 8,
SD12, 8,
SD13, 8,
SD14, 8,
SD15, 8,
SD16, 8,
SD21, 8,
SD22, 8,
SD23, 8,
SD24, 8,
SD25, 8,
SD26, 8,
SD31, 8,
SD32, 8,
SD33, 8,
SD34, 8,
SD35, 8,
SD36, 8,
Offset (0x902),
SDAA, 8,
SDAB, 8,
BTSE, 8,
BTBR, 8,
BED2, 8,
BED3, 8,
BTLE, 8,
BTL2, 8,
BTLL, 8,
BIPM, 8,
BTCA, 8,
ATDV, 8,
COEM, 8,
RTVM, 8,
USTC, 8,
HEB1, 32,
BATP, 8,
TSDB, 8,
EPTU, 8,
Offset (0x919),
RBY1, 8,
RBY2, 8,
SCSS, 8,
NCTC, 8,
NCTI, 8,
NCTH, 8,
HSIO, 8,
ZPOD, 8,
RGBC, 8,
DPTC, 8,
SRSP, 32,
CEDS, 8,
EHK3, 8,
EHK4, 8,
EHK5, 8,
EHK6, 8,
EHK7, 8,
EHK8, 8,
VBVP, 8,
VBVD, 8,
VBHB, 8,
VBRL, 8,
SMSS, 8,
VBST, 8,
ADAS, 8,
PPBG, 32,
AEAB, 8,
AHDB, 8,
ELPM, 32,
ELPS, 32,
UCMS, 8,
UCG1, 32,
UCG2, 32,
UCG3, 32,
UCG4, 32,
UTCE, 8,
ODV6, 8,
ODV7, 8,
ODV8, 8,
ODV9, 8,
ODVA, 8,
ODVB, 8,
ODVC, 8,
ODVD, 8,
ODVE, 8,
ODVF, 8,
ODVG, 8,
ODVH, 8,
ODVI, 8,
ODVJ, 8,
ODVK, 8,
ODVL, 8,
ODVM, 8,
Offset (0x969),
PCHE, 8,
Offset (0x96D),
UDGF, 8,
UDUP, 8,
DBGF, 8,
DBUP, 8,
TTUP, 8,
TP1T, 8,
TP1P, 8,
TP1D, 8,
TP2T, 8,
TP2P, 8,
TP2D, 8,
TP3T, 8,
TP3P, 8,
TP3D, 8,
TP4T, 8,
TP4P, 8,
TP4D, 8,
TP5T, 8,
TP5P, 8,
TP5D, 8,
TP6T, 8,
TP6P, 8,
TP6D, 8,
STAS, 8,
WRTO, 8,
PRST, 32,
WPRP, 8,
PUIS, 8,
PSWP, 32,
RPNB, 8,
POME, 8,
PSW2, 32,
RPN2, 8,
WFCP, 32,
PFCP, 8,
WBRS, 32,
PBRS, 8,
WWKP, 32,
GPLP, 32,
GPLR, 32,
GPI1, 32,
TPP1, 32,
TPR1, 32,
PPDI, 8,
PPLI, 8,
PPLP, 8,
PPLR, 8,
PPI1, 8,
PPP1, 8,
PPR1, 8,
PSPE, 32,
PPSP, 8,
PSPR, 32,
PPSR, 8,
PSP2, 32,
PS2P, 8,
PSR2, 32,
SR2P, 8,
WLWK, 32,
WLRP, 8,
SATP, 32,
STPP, 8,
SSDP, 32,
SDPP, 8,
SSDR, 32,
SDRP, 8,
SD2P, 32,
SDP1, 8,
SD2R, 32,
SDR1, 8,
SD5P, 32,
SDP5, 8,
SD5R, 32,
SDR5, 8,
DG2P, 32,
DGP2, 8,
DG2R, 32,
DGR2, 8,
DGWP, 32,
SXI1, 8,
SXI2, 8,
SXP1, 8,
SXP2, 8,
TSD0, 8,
WCLK, 8,
CWEF, 8,
CECV, 32,
WWRP, 8,
KMOW, 8,
WAGE, 8,
AGA1, 8,
AGA2, 8,
AGA3, 8,
AGA4, 8,
AGA5, 8,
AGB1, 8,
AGB2, 8,
AGB3, 8,
AGB4, 8,
AGB5, 8,
SGMM, 8,
SG00, 8,
SG01, 8,
SG02, 8,
SG03, 8,
SG04, 8,
SG05, 8,
SG06, 8,
SG07, 8,
SG08, 8,
SG09, 8,
SG10, 8,
SG11, 8,
SG12, 8,
SG13, 8,
SG14, 8,
SG15, 8,
SG16, 8,
SG17, 8,
SG18, 8,
ACSD, 8,
I5BS, 8,
DGVR, 32,
LPMR, 32,
SG19, 8,
SG20, 8,
SG21, 8,
P1PE, 32,
P1PP, 8,
P1RE, 32,
P1RP, 8,
P1WP, 32,
PRP1, 8,
P2PE, 32,
P2PP, 8,
P2RE, 32,
P2RP, 8,
P2WP, 32,
PRP2, 8,
PSP3, 32,
PS3P, 8,
PSR3, 32,
SR3P, 8,
PSW3, 32,
RPN3, 8,
SD3P, 32,
SDP3, 8,
SD3R, 32,
SDR3, 8,
SD4P, 32,
SDP4, 8,
SD4R, 32,
SDR4, 8,
XSMI, 32,
DUWS, 8,
ST50, 8,
ST51, 8,
ST52, 8,
ST53, 8,
ST54, 8,
ST55, 8,
ST56, 8,
ST57, 8,
ST58, 8,
ST59, 8,
ST5A, 8,
ST5B, 8,
ST60, 8,
ST61, 8,
ST62, 8,
ST63, 8,
ST64, 8,
ST65, 8,
ST66, 8,
ST67, 8,
ST68, 8,
ST69, 8,
ST6A, 8,
ST6B, 8,
ST70, 8,
ST71, 8,
ST72, 8,
ST73, 8,
ST74, 8,
ST75, 8,
ST76, 8,
ST77, 8,
ST78, 8,
ST79, 8,
ST7A, 8,
ST7B, 8,
ST80, 8,
ST81, 8,
ST82, 8,
ST83, 8,
ST84, 8,
ST85, 8,
ST86, 8,
ST87, 8,
ST88, 8,
ST89, 8,
ST8A, 8,
ST8B, 8,
SD17, 8,
SD18, 8,
SD19, 8,
SD27, 8,
SD28, 8,
SD29, 8,
SD37, 8,
SD38, 8,
SD39, 8,
AGA6, 8,
AGA7, 8,
AGA8, 8,
AGA9, 8,
AGAA, 8,
AGAB, 8,
AGB6, 8,
AGB7, 8,
AGB8, 8,
AGB9, 8,
AGBA, 8,
AGBB, 8,
UHBS, 32,
AXSU, 8,
AXMU, 8,
AXSR, 8,
AXMR, 8,
CD10, 8,
CD11, 8,
CD12, 8,
CD13, 8,
CD14, 8,
CD15, 8,
CD16, 8,
CD17, 8,
CD18, 8,
CD19, 8,
CD1A, 8,
CD20, 8,
CD21, 8,
CD22, 8,
CD23, 8,
CD24, 8,
CD25, 8,
CD26, 8,
CD27, 8,
CD28, 8,
CD29, 8,
CD2A, 8,
CD30, 8,
CD31, 8,
CD32, 8,
CD33, 8,
CD34, 8,
CD35, 8,
CD36, 8,
CD37, 8,
CD38, 8,
CD39, 8,
CD3A, 8,
CD3B, 8,
CD3C, 8,
CD3D, 8,
CD3E, 8,
CD3F, 8,
CD40, 8,
CD41, 8,
CD42, 8,
CD43, 8,
CD44, 8,
CD45, 8,
CD46, 8,
CD47, 8,
CD48, 8,
CD49, 8,
CD4A, 8,
CD4B, 8,
CD4C, 8,
CD4D, 8,
CD4E, 8,
CD4F, 8,
CD50, 8,
CD51, 8,
CD52, 8,
CD53, 8,
CD54, 8,
CD55, 8,
CD56, 8,
CD57, 8,
CD58, 8,
CD59, 8,
CD5A, 8,
CD5B, 8,
CD5C, 8,
CD5D, 8,
CD5E, 8,
CD5F, 8,
CD60, 8,
CD61, 8,
CD62, 8,
CD63, 8,
CD64, 8,
CD65, 8,
CD66, 8,
CD67, 8,
CD68, 8,
CD69, 8,
CD6A, 8,
CD6B, 8,
CD6C, 8,
CD6D, 8,
CD6E, 8,
CD6F, 8,
CD70, 8,
CD71, 8,
WPFA, 32,
WPFB, 32,
WPFC, 32,
WPFD, 32,
L0LC, 8,
L1LC, 8,
L2LC, 8,
L3LC, 8,
L4LC, 8,
L5LC, 8,
POVP, 32,
PSG1, 32,
PSG2, 32,
PPOE, 32,
FND2, 8,
FND3, 8,
S6DE, 8,
WTSE, 8,
WTLE, 8,
BL01, 16,
BL02, 16,
BL03, 16,
BL04, 16,
BL05, 16,
BL06, 16,
BL07, 16,
BL08, 16,
BL09, 16,
BL10, 16,
BL11, 16,
BL12, 16,
BL13, 16,
BL14, 16,
BL15, 16,
BL16, 16,
CVFS, 8,
CUPN, 8,
DGBA, 64,
DGOP, 32,
TILE, 8,
TIS0, 8,
TS0X, 8,
TIS4, 8,
TIS5, 8,
SLEC, 8,
LEDU, 16,
TAPM, 8,
STD3, 8,
PXDC, 8,
PXAC, 8,
PXWC, 8,
PXUC, 8,
PXFD, 8,
Offset (0xB97),
WWEN, 8,
WFFD, 8,
TN2B, 16,
TB2R, 16,
TR2P, 16,
TB2F, 16,
TFDI, 16,
TBTG, 16,
TBTP, 16,
LSWP, 32,
U4CM, 8,
CMSK, 8,
LP5E, 8,
CLCN, 8,
CLSA, 8,
TP7T, 8,
TP7P, 8,
TP7D, 8,
TP8T, 8,
TP8P, 8,
TP8D, 8,
TP9T, 8,
TP9P, 8,
TP9D, 8,
TPAT, 8,
TPAP, 8,
TPAD, 8,
TP1U, 8,
TP2U, 8,
TP3U, 8,
TP4U, 8,
TP5U, 8,
TP6U, 8,
TP7U, 8,
TP8U, 8,
TP9U, 8,
TPAU, 8,
FVWP, 32,
FVRE, 32,
FVRP, 8,
FVPE, 32,
FVPP, 8,
FVSP, 8,
RPFV, 8,
DPIW, 8,
DPG1, 32,
UDRS, 8,
U4SE, 8,
L0FI, 8,
L1FI, 8,
L2FI, 8,
L3FI, 8,
L4FI, 8,
L5FI, 8,
SSH6, 16,
SSL6, 16,
SSD6, 16,
FMH6, 16,
FML6, 16,
FMD6, 16,
FPH6, 16,
FPL6, 16,
FPD6, 16,
HSH6, 16,
HSL6, 16,
HSD6, 16,
M0CC, 16,
M1CC, 16,
SSH7, 16,
SSL7, 16,
SSD7, 16,
FMH7, 16,
FML7, 16,
FMD7, 16,
FPH7, 16,
FPL7, 16,
FPD7, 16,
HSH7, 16,
HSL7, 16,
HSD7, 16,
M0CD, 16,
M1CD, 16,
TR2B, 16,
ZPDA, 32,
ZDPR, 32,
ZDPW, 32,
ZDPP, 8,
WSID, 16,
WSTO, 16,
HUAR, 8,
BLEC, 8,
BLPD, 8,
BLPI, 8,
WFRC, 32,
WFUC, 32,
UNI4, 32,
WFIC, 32,
R8DC, 8,
OMP1, 32,
OM1P, 8,
OMR1, 32,
MR1P, 8,
OMW1, 32,
RPO1, 8,
OMP2, 32,
OM2P, 8,
OMR2, 32,
MR2P, 8,
OMW2, 32,
RPO2, 8,
WCEN, 8,
R8DS, 8,
WLBI, 8,
WHBI, 8,
SDGN, 8,
SD41, 8,
SD42, 8,
SD43, 8,
SD44, 8,
SD45, 8,
SD46, 8,
SD47, 8,
SD48, 8,
SD49, 8,
SD51, 8,
SD52, 8,
SD53, 8,
SD54, 8,
SD55, 8,
SD56, 8,
SD57, 8,
SD58, 8,
SD59, 8,
SD61, 8,
SD62, 8,
SD63, 8,
SD64, 8,
SD65, 8,
SD66, 8,
SD67, 8,
SD68, 8,
SD69, 8,
SD71, 8,
SD72, 8,
SD73, 8,
SD74, 8,
SD75, 8,
SD76, 8,
SD77, 8,
SD78, 8,
SD79, 8,
SD81, 8,
SD82, 8,
SD83, 8,
SD84, 8,
SD85, 8,
SD86, 8,
SD87, 8,
SD88, 8,
SD89, 8,
R8WR, 8,
WTSV, 32,
EDMX, 32,
DBRL, 8,
DNID, 8,
DGD1, 32,
DGD2, 32,
DGD3, 32,
DGD4, 32,
DGD5, 32,
DGD6, 32,
DGD7, 32,
DGD8, 32,
DGD9, 32,
DGDA, 32,
DGDB, 32,
DGDC, 32,
DGDD, 32,
DGDE, 32,
DGDF, 32,
DGDX, 32,
DGDS, 8,
VTCM, 8,
ZPPB, 8,
LLKI, 32,
LLKE, 8,
HSC0, 8,
TBD3, 8,
WGAS, 8,
WLRT, 32,
WVHO, 32,
WF7C, 32,
WEDT, 32,
WFBS, 32,
CDRM, 8,
DTCV, 32,
U4CL, 8,
SRLD, 8,
DGPV, 16,
OSDP, 8
}

Scope (_SB)
{
Name (PD00, Package (0x2A)
{
Package (0x04)
{
0x001FFFFF,
Zero,
Zero,
0x0B
},

Package (0x04)
{
0x001FFFFF,
One,
Zero,
0x0A
},

Package (0x04)
{
0x001FFFFF,
0x02,
Zero,
0x0B
},

Package (0x04)
{
0x001FFFFF,
0x03,
Zero,
0x0B
},

Package (0x04)
{
0x001DFFFF,
Zero,
Zero,
0x0B
},

Package (0x04)
{
0x001DFFFF,
One,
Zero,
0x0A
},

Package (0x04)
{
0x001DFFFF,
0x02,
Zero,
0x0B
},

Package (0x04)
{
0x001DFFFF,
0x03,
Zero,
0x0B
},

Package (0x04)
{
0x001CFFFF,
Zero,
Zero,
0x0B
},

Package (0x04)
{
0x001CFFFF,
One,
Zero,
0x0A
},

Package (0x04)
{
0x001CFFFF,
0x02,
Zero,
0x0B
},

Package (0x04)
{
0x001CFFFF,
0x03,
Zero,
0x0B
},

Package (0x04)
{
0x001BFFFF,
Zero,
Zero,
0x0B
},

Package (0x04)
{
0x001BFFFF,
One,
Zero,
0x0A
},

Package (0x04)
{
0x001BFFFF,
0x02,
Zero,
0x0B
},

Package (0x04)
{
0x001BFFFF,
0x03,
Zero,
0x0B
},

Package (0x04)
{
0x0017FFFF,
Zero,
Zero,
0x0B
},

Package (0x04)
{
0x0016FFFF,
Zero,
Zero,
0x0B
},

Package (0x04)
{
0x0016FFFF,
One,
Zero,
0x0A
},

Package (0x04)
{
0x0016FFFF,
0x02,
Zero,
0x0B
},

Package (0x04)
{
0x0016FFFF,
0x03,
Zero,
0x0B
},

Package (0x04)
{
0x0014FFFF,
Zero,
Zero,
0x0B
},

Package (0x04)
{
0x0014FFFF,
One,
Zero,
0x0A
},

Package (0x04)
{
0x0014FFFF,
0x02,
Zero,
0x0B
},

Package (0x04)
{
0x0014FFFF,
0x03,
Zero,
0x0B
},

Package (0x04)
{
0x0006FFFF,
Zero,
Zero,
0x0B
},

Package (0x04)
{
0x0006FFFF,
One,
Zero,
0x0A
},

Package (0x04)
{
0x0006FFFF,
0x02,
Zero,
0x0B
},

Package (0x04)
{
0x0006FFFF,
0x03,
Zero,
0x0B
},

Package (0x04)
{
0x0001FFFF,
Zero,
Zero,
0x0B
},

Package (0x04)
{
0x0001FFFF,
One,
Zero,
0x0A
},

Package (0x04)
{
0x0001FFFF,
0x02,
Zero,
0x0B
},

Package (0x04)
{
0x0001FFFF,
0x03,
Zero,
0x0B
},

Package (0x04)
{
0x0002FFFF,
Zero,
Zero,
0x0B
},

Package (0x04)
{
0x0004FFFF,
Zero,
Zero,
0x0B
},

Package (0x04)
{
0x0005FFFF,
Zero,
Zero,
0x0B
},

Package (0x04)
{
0x0008FFFF,
Zero,
Zero,
0x0B
},

Package (0x04)
{
0x000DFFFF,
Zero,
Zero,
0x0B
},

Package (0x04)
{
0x0007FFFF,
Zero,
Zero,
0x0B
},

Package (0x04)
{
0x0007FFFF,
One,
Zero,
0x0A
},

Package (0x04)
{
0x0007FFFF,
0x02,
Zero,
0x0B
},

Package (0x04)
{
0x0007FFFF,
0x03,
Zero,
0x0B
}
})
Name (AR00, Package (0x48)
{
Package (0x04)
{
0x001FFFFF,
Zero,
Zero,
0x10
},

Package (0x04)
{
0x001FFFFF,
One,
Zero,
0x11
},

Package (0x04)
{
0x001FFFFF,
0x02,
Zero,
0x12
},

Package (0x04)
{
0x001FFFFF,
0x03,
Zero,
0x13
},

Package (0x04)
{
0x001EFFFF,
Zero,
Zero,
0x10
},

Package (0x04)
{
0x001EFFFF,
One,
Zero,
0x11
},

Package (0x04)
{
0x001EFFFF,
0x02,
Zero,
0x24
},

Package (0x04)
{
0x001EFFFF,
0x03,
Zero,
0x25
},

Package (0x04)
{
0x001DFFFF,
Zero,
Zero,
0x10
},

Package (0x04)
{
0x001DFFFF,
One,
Zero,
0x11
},

Package (0x04)
{
0x001DFFFF,
0x02,
Zero,
0x12
},

Package (0x04)
{
0x001DFFFF,
0x03,
Zero,
0x13
},

Package (0x04)
{
0x001CFFFF,
Zero,
Zero,
0x10
},

Package (0x04)
{
0x001CFFFF,
One,
Zero,
0x11
},

Package (0x04)
{
0x001CFFFF,
0x02,
Zero,
0x12
},

Package (0x04)
{
0x001CFFFF,
0x03,
Zero,
0x13
},

Package (0x04)
{
0x001BFFFF,
Zero,
Zero,
0x10
},

Package (0x04)
{
0x001BFFFF,
One,
Zero,
0x11
},

Package (0x04)
{
0x001BFFFF,
0x02,
Zero,
0x12
},

Package (0x04)
{
0x001BFFFF,
0x03,
Zero,
0x13
},

Package (0x04)
{
0x001AFFFF,
Zero,
Zero,
0x10
},

Package (0x04)
{
0x001AFFFF,
One,
Zero,
0x11
},

Package (0x04)
{
0x001AFFFF,
0x02,
Zero,
0x12
},

Package (0x04)
{
0x001AFFFF,
0x03,
Zero,
0x13
},

Package (0x04)
{
0x0019FFFF,
Zero,
Zero,
0x1F
},

Package (0x04)
{
0x0019FFFF,
One,
Zero,
0x20
},

Package (0x04)
{
0x0019FFFF,
0x02,
Zero,
0x2A
},

Package (0x04)
{
0x0017FFFF,
Zero,
Zero,
0x10
},

Package (0x04)
{
0x0016FFFF,
Zero,
Zero,
0x10
},

Package (0x04)
{
0x0016FFFF,
One,
Zero,
0x11
},

Package (0x04)
{
0x0016FFFF,
0x02,
Zero,
0x12
},

Package (0x04)
{
0x0016FFFF,
0x03,
Zero,
0x13
},

Package (0x04)
{
0x0015FFFF,
Zero,
Zero,
0x1B
},

Package (0x04)
{
0x0015FFFF,
One,
Zero,
0x28
},

Package (0x04)
{
0x0015FFFF,
0x02,
Zero,
0x1D
},

Package (0x04)
{
0x0015FFFF,
0x03,
Zero,
0x2B
},

Package (0x04)
{
0x0014FFFF,
Zero,
Zero,
0x10
},

Package (0x04)
{
0x0014FFFF,
One,
Zero,
0x11
},

Package (0x04)
{
0x0014FFFF,
0x02,
Zero,
0x12
},

Package (0x04)
{
0x0013FFFF,
Zero,
Zero,
0x14
},

Package (0x04)
{
0x0013FFFF,
One,
Zero,
0x15
},

Package (0x04)
{
0x0013FFFF,
0x02,
Zero,
0x18
},

Package (0x04)
{
0x0013FFFF,
0x03,
Zero,
0x26
},

Package (0x04)
{
0x0012FFFF,
Zero,
Zero,
0x1A
},

Package (0x04)
{
0x0012FFFF,
One,
Zero,
0x27
},

Package (0x04)
{
0x0012FFFF,
0x02,
Zero,
0x12
},

Package (0x04)
{
0x0011FFFF,
Zero,
Zero,
0x19
},

Package (0x04)
{
0x0011FFFF,
One,
Zero,
0x23
},

Package (0x04)
{
0x0011FFFF,
0x02,
Zero,
0x1C
},

Package (0x04)
{
0x0011FFFF,
0x03,
Zero,
0x22
},

Package (0x04)
{
0x0010FFFF,
0x02,
Zero,
0x12
},

Package (0x04)
{
0x0010FFFF,
0x03,
Zero,
0x13
},

Package (0x04)
{
0x0010FFFF,
Zero,
Zero,
0x17
},

Package (0x04)
{
0x0010FFFF,
One,
Zero,
0x16
},

Package (0x04)
{
0x0006FFFF,
Zero,
Zero,
0x10
},

Package (0x04)
{
0x0006FFFF,
One,
Zero,
0x11
},

Package (0x04)
{
0x0006FFFF,
0x02,
Zero,
0x12
},

Package (0x04)
{
0x0006FFFF,
0x03,
Zero,
0x13
},

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

Package (0x04)
{
0x0001FFFF,
One,
Zero,
0x11
},

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

Package (0x04)
{
0x0001FFFF,
0x03,
Zero,
0x13
},

Package (0x04)
{
0x0002FFFF,
Zero,
Zero,
0x10
},

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

Package (0x04)
{
0x0005FFFF,
Zero,
Zero,
0x10
},

Package (0x04)
{
0x0008FFFF,
Zero,
Zero,
0x10
},

Package (0x04)
{
0x000DFFFF,
Zero,
Zero,
0x10
},

Package (0x04)
{
0x000DFFFF,
One,
Zero,
0x11
},

Package (0x04)
{
0x0007FFFF,
Zero,
Zero,
0x10
},

Package (0x04)
{
0x0007FFFF,
One,
Zero,
0x11
},

Package (0x04)
{
0x0007FFFF,
0x02,
Zero,
0x12
},

Package (0x04)
{
0x0007FFFF,
0x03,
Zero,
0x13
}
})
Name (PD04, Package (0x04)
{
Package (0x04)
{
0xFFFF,
Zero,
Zero,
0x0B
},

Package (0x04)
{
0xFFFF,
One,
Zero,
0x0A
},

Package (0x04)
{
0xFFFF,
0x02,
Zero,
0x0B
},

Package (0x04)
{
0xFFFF,
0x03,
Zero,
0x0B
}
})
Name (AR04, Package (0x04)
{
Package (0x04)
{
0xFFFF,
Zero,
Zero,
0x10
},

Package (0x04)
{
0xFFFF,
One,
Zero,
0x11
},

Package (0x04)
{
0xFFFF,
0x02,
Zero,
0x12
},

Package (0x04)
{
0xFFFF,
0x03,
Zero,
0x13
}
})
Name (PD05, Package (0x04)
{
Package (0x04)
{
0xFFFF,
Zero,
Zero,
0x0A
},

Package (0x04)
{
0xFFFF,
One,
Zero,
0x0B
},

Package (0x04)
{
0xFFFF,
0x02,
Zero,
0x0B
},

Package (0x04)
{
0xFFFF,
0x03,
Zero,
0x0B
}
})
Name (AR05, Package (0x04)
{
Package (0x04)
{
0xFFFF,
Zero,
Zero,
0x11
},

Package (0x04)
{
0xFFFF,
One,
Zero,
0x12
},

Package (0x04)
{
0xFFFF,
0x02,
Zero,
0x13
},

Package (0x04)
{
0xFFFF,
0x03,
Zero,
0x10
}
})
Name (PD06, Package (0x04)
{
Package (0x04)
{
0xFFFF,
Zero,
Zero,
0x0B
},

Package (0x04)
{
0xFFFF,
One,
Zero,
0x0B
},

Package (0x04)
{
0xFFFF,
0x02,
Zero,
0x0B
},

Package (0x04)
{
0xFFFF,
0x03,
Zero,
0x0A
}
})
Name (AR06, Package (0x04)
{
Package (0x04)
{
0xFFFF,
Zero,
Zero,
0x12
},

Package (0x04)
{
0xFFFF,
One,
Zero,
0x13
},

Package (0x04)
{
0xFFFF,
0x02,
Zero,
0x10
},

Package (0x04)
{
0xFFFF,
0x03,
Zero,
0x11
}
})
Name (PD07, Package (0x04)
{
Package (0x04)
{
0xFFFF,
Zero,
Zero,
0x0B
},

Package (0x04)
{
0xFFFF,
One,
Zero,
0x0B
},

Package (0x04)
{
0xFFFF,
0x02,
Zero,
0x0A
},

Package (0x04)
{
0xFFFF,
0x03,
Zero,
0x0B
}
})
Name (AR07, Package (0x04)
{
Package (0x04)
{
0xFFFF,
Zero,
Zero,
0x13
},

Package (0x04)
{
0xFFFF,
One,
Zero,
0x10
},

Package (0x04)
{
0xFFFF,
0x02,
Zero,
0x11
},

Package (0x04)
{
0xFFFF,
0x03,
Zero,
0x12
}
})
Name (PD08, Package (0x04)
{
Package (0x04)
{
0xFFFF,
Zero,
Zero,
0x0B
},

Package (0x04)
{
0xFFFF,
One,
Zero,
0x0A
},

Package (0x04)
{
0xFFFF,
0x02,
Zero,
0x0B
},

Package (0x04)
{
0xFFFF,
0x03,
Zero,
0x0B
}
})
Name (AR08, Package (0x04)
{
Package (0x04)
{
0xFFFF,
Zero,
Zero,
0x10
},

Package (0x04)
{
0xFFFF,
One,
Zero,
0x11
},

Package (0x04)
{
0xFFFF,
0x02,
Zero,
0x12
},

Package (0x04)
{
0xFFFF,
0x03,
Zero,
0x13
}
})
Name (PD09, Package (0x04)
{
Package (0x04)
{
0xFFFF,
Zero,
Zero,
0x0A
},

Package (0x04)
{
0xFFFF,
One,
Zero,
0x0B
},

Package (0x04)
{
0xFFFF,
0x02,
Zero,
0x0B
},

Package (0x04)
{
0xFFFF,
0x03,
Zero,
0x0B
}
})
Name (AR09, Package (0x04)
{
Package (0x04)
{
0xFFFF,
Zero,
Zero,
0x11
},

Package (0x04)
{
0xFFFF,
One,
Zero,
0x12
},

Package (0x04)
{
0xFFFF,
0x02,
Zero,
0x13
},

Package (0x04)
{
0xFFFF,
0x03,
Zero,
0x10
}
})
Name (PD0E, Package (0x04)
{
Package (0x04)
{
0xFFFF,
Zero,
Zero,
0x0B
},

Package (0x04)
{
0xFFFF,
One,
Zero,
0x0B
},

Package (0x04)
{
0xFFFF,
0x02,
Zero,
0x0B
},

Package (0x04)
{
0xFFFF,
0x03,
Zero,
0x0A
}
})
Name (AR0E, Package (0x04)
{
Package (0x04)
{
0xFFFF,
Zero,
Zero,
0x12
},

Package (0x04)
{
0xFFFF,
One,
Zero,
0x13
},

Package (0x04)
{
0xFFFF,
0x02,
Zero,
0x10
},

Package (0x04)
{
0xFFFF,
0x03,
Zero,
0x11
}
})
Name (PD0F, Package (0x04)
{
Package (0x04)
{
0xFFFF,
Zero,
Zero,
0x0B
},

Package (0x04)
{
0xFFFF,
One,
Zero,
0x0B
},

Package (0x04)
{
0xFFFF,
0x02,
Zero,
0x0A
},

Package (0x04)
{
0xFFFF,
0x03,
Zero,
0x0B
}
})
Name (AR0F, Package (0x04)
{
Package (0x04)
{
0xFFFF,
Zero,
Zero,
0x13
},

Package (0x04)
{
0xFFFF,
One,
Zero,
0x10
},

Package (0x04)
{
0xFFFF,
0x02,
Zero,
0x11
},

Package (0x04)
{
0xFFFF,
0x03,
Zero,
0x12
}
})
Name (PD02, Package (0x04)
{
Package (0x04)
{
0xFFFF,
Zero,
Zero,
0x0B
},

Package (0x04)
{
0xFFFF,
One,
Zero,
0x0A
},

Package (0x04)
{
0xFFFF,
0x02,
Zero,
0x0B
},

Package (0x04)
{
0xFFFF,
0x03,
Zero,
0x0B
}
})
Name (AR02, Package (0x04)
{
Package (0x04)
{
0xFFFF,
Zero,
Zero,
0x10
},

Package (0x04)
{
0xFFFF,
One,
Zero,
0x11
},

Package (0x04)
{
0xFFFF,
0x02,
Zero,
0x12
},

Package (0x04)
{
0xFFFF,
0x03,
Zero,
0x13
}
})
Name (PD0A, Package (0x04)
{
Package (0x04)
{
0xFFFF,
Zero,
Zero,
0x0A
},

Package (0x04)
{
0xFFFF,
One,
Zero,
0x0B
},

Package (0x04)
{
0xFFFF,
0x02,
Zero,
0x0B
},

Package (0x04)
{
0xFFFF,
0x03,
Zero,
0x0B
}
})
Name (AR0A, Package (0x04)
{
Package (0x04)
{
0xFFFF,
Zero,
Zero,
0x11
},

Package (0x04)
{
0xFFFF,
One,
Zero,
0x12
},

Package (0x04)
{
0xFFFF,
0x02,
Zero,
0x13
},

Package (0x04)
{
0xFFFF,
0x03,
Zero,
0x10
}
})
Name (PD0B, Package (0x04)
{
Package (0x04)
{
0xFFFF,
Zero,
Zero,
0x0B
},

Package (0x04)
{
0xFFFF,
One,
Zero,
0x0B
},

Package (0x04)
{
0xFFFF,
0x02,
Zero,
0x0B
},

Package (0x04)
{
0xFFFF,
0x03,
Zero,
0x0A
}
})
Name (AR0B, Package (0x04)
{
Package (0x04)
{
0xFFFF,
Zero,
Zero,
0x12
},

Package (0x04)
{
0xFFFF,
One,
Zero,
0x13
},

Package (0x04)
{
0xFFFF,
0x02,
Zero,
0x10
},

Package (0x04)
{
0xFFFF,
0x03,
Zero,
0x11
}
})
Name (PD0C, Package (0x04)
{
Package (0x04)
{
0xFFFF,
Zero,
Zero,
0x0B
},

Package (0x04)
{
0xFFFF,
One,
Zero,
0x0B
},

Package (0x04)
{
0xFFFF,
0x02,
Zero,
0x0A
},

Package (0x04)
{
0xFFFF,
0x03,
Zero,
0x0B
}
})
Name (AR0C, Package (0x04)
{
Package (0x04)
{
0xFFFF,
Zero,
Zero,
0x13
},

Package (0x04)
{
0xFFFF,
One,
Zero,
0x10
},

Package (0x04)
{
0xFFFF,
0x02,
Zero,
0x11
},

Package (0x04)
{
0xFFFF,
0x03,
Zero,
0x12
}
})
Device (PC00)
{
Name (_HID, EisaId ("PNP0A08") /* PCI Express Bus */) // _HID: Hardware ID
Name (_CID, EisaId ("PNP0A03") /* PCI Bus */) // _CID: Compatible ID
Name (_SEG, Zero) // _SEG: PCI Segment
Method (^BN00, 0, NotSerialized)
{
Return (Zero)
}

Method (_BBN, 0, NotSerialized) // _BBN: BIOS Bus Number
{
Return (BN00 ())
}

Name (_UID, Zero) // _UID: Unique ID
Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table
{
If (PICM)
{
Return (AR00 ())
}

Return (PD00 ())
}

Device (MC)
{
Name (_ADR, Zero) // _ADR: Address
OperationRegion (HBUS, PCI_Config, Zero, 0x0100)
Field (HBUS, DWordAcc, NoLock, Preserve)
{
Offset (0x40),
EPEN, 1,
, 11,
EPBR, 20,
Offset (0x48),
MHEN, 1,
, 14,
MHBR, 17,
Offset (0x50),
GCLK, 1,
Offset (0x54),
D0EN, 1,
D1F2, 1,
D1F1, 1,
D1F0, 1,
, 9,
D6F0, 1,
Offset (0x60),
PXEN, 1,
PXSZ, 3,
, 22,
PXBR, 6,
Offset (0x68),
DIEN, 1,
, 11,
DIBR, 20,
Offset (0x70),
, 20,
MEBR, 12,
Offset (0x80),
, 4,
PM0H, 2,
Offset (0x81),
PM1L, 2,
, 2,
PM1H, 2,
Offset (0x82),
PM2L, 2,
, 2,
PM2H, 2,
Offset (0x83),
PM3L, 2,
, 2,
PM3H, 2,
Offset (0x84),
PM4L, 2,
, 2,
PM4H, 2,
Offset (0x85),
PM5L, 2,
, 2,
PM5H, 2,
Offset (0x86),
PM6L, 2,
, 2,
PM6H, 2,
Offset (0x87),
Offset (0xA8),
, 20,
TUUD, 19,
Offset (0xBC),
, 20,
TLUD, 12,
Offset (0xC8),
, 7,
HTSE, 1
}
}

Name (BUF0, ResourceTemplate ()
{
WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode,
0x0000, // Granularity
0x0000, // Range Minimum
0x00FF, // Range Maximum
0x0000, // Translation Offset
0x0100, // Length
,, _Y00)
DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
0x00000000, // Granularity
0x00000000, // Range Minimum
0x00000CF7, // Range Maximum
0x00000000, // Translation Offset
0x00000CF8, // Length
,, , TypeStatic, DenseTranslation)
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, DenseTranslation)
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
,, _Y01, AddressRangeMemory, TypeStatic)
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
0x00000000, // Granularity
0x000C4000, // Range Minimum
0x000C7FFF, // Range Maximum
0x00000000, // Translation Offset
0x00004000, // Length
,, _Y02, AddressRangeMemory, TypeStatic)
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
0x00000000, // Granularity
0x000C8000, // Range Minimum
0x000CBFFF, // Range Maximum
0x00000000, // Translation Offset
0x00004000, // Length
,, _Y03, AddressRangeMemory, TypeStatic)
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
0x00000000, // Granularity
0x000CC000, // Range Minimum
0x000CFFFF, // Range Maximum
0x00000000, // Translation Offset
0x00004000, // Length
,, _Y04, AddressRangeMemory, TypeStatic)
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
0x00000000, // Granularity
0x000D0000, // Range Minimum
0x000D3FFF, // Range Maximum
0x00000000, // Translation Offset
0x00004000, // Length
,, _Y05, AddressRangeMemory, TypeStatic)
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
0x00000000, // Granularity
0x000D4000, // Range Minimum
0x000D7FFF, // Range Maximum
0x00000000, // Translation Offset
0x00004000, // Length
,, _Y06, AddressRangeMemory, TypeStatic)
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
0x00000000, // Granularity
0x000D8000, // Range Minimum
0x000DBFFF, // Range Maximum
0x00000000, // Translation Offset
0x00004000, // Length
,, _Y07, AddressRangeMemory, TypeStatic)
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
0x00000000, // Granularity
0x000DC000, // Range Minimum
0x000DFFFF, // Range Maximum
0x00000000, // Translation Offset
0x00004000, // Length
,, _Y08, AddressRangeMemory, TypeStatic)
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
0x00000000, // Granularity
0x000E0000, // Range Minimum
0x000E3FFF, // Range Maximum
0x00000000, // Translation Offset
0x00004000, // Length
,, _Y09, AddressRangeMemory, TypeStatic)
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
0x00000000, // Granularity
0x000E4000, // Range Minimum
0x000E7FFF, // Range Maximum
0x00000000, // Translation Offset
0x00004000, // Length
,, _Y0A, AddressRangeMemory, TypeStatic)
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
0x00000000, // Granularity
0x000E8000, // Range Minimum
0x000EBFFF, // Range Maximum
0x00000000, // Translation Offset
0x00004000, // Length
,, _Y0B, AddressRangeMemory, TypeStatic)
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
0x00000000, // Granularity
0x000EC000, // Range Minimum
0x000EFFFF, // Range Maximum
0x00000000, // Translation Offset
0x00004000, // Length
,, _Y0C, AddressRangeMemory, TypeStatic)
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
0x00000000, // Granularity
0x000F0000, // Range Minimum
0x000FFFFF, // Range Maximum
0x00000000, // Translation Offset
0x00010000, // Length
,, _Y0D, AddressRangeMemory, TypeStatic)
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
0x00000000, // Granularity
0x00000000, // Range Minimum
0xDFFFFFFF, // Range Maximum
0x00000000, // Translation Offset
0xE0000000, // Length
,, _Y0E, AddressRangeMemory, TypeStatic)
QWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
0x0000000000000000, // Granularity
0x0000000000010000, // Range Minimum
0x000000000001FFFF, // Range Maximum
0x0000000000000000, // Translation Offset
0x0000000000010000, // Length
,, _Y0F, AddressRangeMemory, TypeStatic)
})
Name (EP_B, Zero)
Name (MH_B, Zero)
Name (PC_B, Zero)
Name (PC_L, Zero)
Name (DM_B, Zero)
Method (GEPB, 0, Serialized)
{
If ((EP_B == Zero))
{
EP_B = (^MC.EPBR << 0x0C)
}

Return (EP_B) /* \_SB_.PC00.EP_B */
}

Method (GMHB, 0, Serialized)
{
If ((MH_B == Zero))
{
MH_B = (^MC.MHBR << 0x0F)
}

Return (MH_B) /* \_SB_.PC00.MH_B */
}

Method (GPCB, 0, Serialized)
{
If ((PC_B == Zero))
{
PC_B = (^MC.PXBR << 0x1A)
}

Return (PC_B) /* \_SB_.PC00.PC_B */
}

Method (PC2M, 1, Serialized)
{
Local0 = GPCB ()
Local0 += ((Arg0 & 0x001F0000) >> One)
Local0 += ((Arg0 & 0x07) << 0x0C)
Return (Local0)
}

Method (GPCL, 0, Serialized)
{
If ((PC_L == Zero))
{
If ((^MC.PXSZ < 0x03))
{
PC_L = (0x10000000 >> ^MC.PXSZ) /* \_SB_.PC00.MC__.PXSZ */
}
Else
{
PC_L = 0x10000000
}
}

Return (PC_L) /* \_SB_.PC00.PC_L */
}

Method (GDMB, 0, Serialized)
{
If ((DM_B == Zero))
{
DM_B = (^MC.DIBR << 0x0C)
}

Return (DM_B) /* \_SB_.PC00.DM_B */
}

Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings
{
Local0 = GPCL ()
CreateWordField (BUF0, \_SB.PC00._Y00._MAX, PBMX) // _MAX: Maximum Base Address
PBMX = ((Local0 >> 0x14) - 0x02)
CreateWordField (BUF0, \_SB.PC00._Y00._LEN, PBLN) // _LEN: Length
PBLN = ((Local0 >> 0x14) - One)
If (CondRefOf (\VMDE))
{
If (((VMDE == One) && (PBMX > 0xE0)))
{
PBMX = 0xE0
PBLN = 0xE1
}
}

If (^MC.PM1L)
{
CreateDWordField (BUF0, \_SB.PC00._Y01._LEN, C0LN) // _LEN: Length
C0LN = Zero
}

If ((^MC.PM1L == One))
{
CreateBitField (BUF0, \_SB.PC00._Y01._RW, C0RW) // _RW_: Read-Write Status
C0RW = Zero
}

If (^MC.PM1H)
{
CreateDWordField (BUF0, \_SB.PC00._Y02._LEN, C4LN) // _LEN: Length
C4LN = Zero
}

If ((^MC.PM1H == One))
{
CreateBitField (BUF0, \_SB.PC00._Y02._RW, C4RW) // _RW_: Read-Write Status
C4RW = Zero
}

If (^MC.PM2L)
{
CreateDWordField (BUF0, \_SB.PC00._Y03._LEN, C8LN) // _LEN: Length
C8LN = Zero
}

If ((^MC.PM2L == One))
{
CreateBitField (BUF0, \_SB.PC00._Y03._RW, C8RW) // _RW_: Read-Write Status
C8RW = Zero
}

If (^MC.PM2H)
{
CreateDWordField (BUF0, \_SB.PC00._Y04._LEN, CCLN) // _LEN: Length
CCLN = Zero
}

If ((^MC.PM2H == One))
{
CreateBitField (BUF0, \_SB.PC00._Y04._RW, CCRW) // _RW_: Read-Write Status
CCRW = Zero
}

If (^MC.PM3L)
{
CreateDWordField (BUF0, \_SB.PC00._Y05._LEN, D0LN) // _LEN: Length
D0LN = Zero
}

If ((^MC.PM3L == One))
{
CreateBitField (BUF0, \_SB.PC00._Y05._RW, D0RW) // _RW_: Read-Write Status
D0RW = Zero
}

If (^MC.PM3H)
{
CreateDWordField (BUF0, \_SB.PC00._Y06._LEN, D4LN) // _LEN: Length
D4LN = Zero
}

If ((^MC.PM3H == One))
{
CreateBitField (BUF0, \_SB.PC00._Y06._RW, D4RW) // _RW_: Read-Write Status
D4RW = Zero
}

If (^MC.PM4L)
{
CreateDWordField (BUF0, \_SB.PC00._Y07._LEN, D8LN) // _LEN: Length
D8LN = Zero
}

If ((^MC.PM4L == One))
{
CreateBitField (BUF0, \_SB.PC00._Y07._RW, D8RW) // _RW_: Read-Write Status
D8RW = Zero
}

If (^MC.PM4H)
{
CreateDWordField (BUF0, \_SB.PC00._Y08._LEN, DCLN) // _LEN: Length
DCLN = Zero
}

If ((^MC.PM4H == One))
{
CreateBitField (BUF0, \_SB.PC00._Y08._RW, DCRW) // _RW_: Read-Write Status
DCRW = Zero
}

If (^MC.PM5L)
{
CreateDWordField (BUF0, \_SB.PC00._Y09._LEN, E0LN) // _LEN: Length
E0LN = Zero
}

If ((^MC.PM5L == One))
{
CreateBitField (BUF0, \_SB.PC00._Y09._RW, E0RW) // _RW_: Read-Write Status
E0RW = Zero
}

If (^MC.PM5H)
{
CreateDWordField (BUF0, \_SB.PC00._Y0A._LEN, E4LN) // _LEN: Length
E4LN = Zero
}

If ((^MC.PM5H == One))
{
CreateBitField (BUF0, \_SB.PC00._Y0A._RW, E4RW) // _RW_: Read-Write Status
E4RW = Zero
}

If (^MC.PM6L)
{
CreateDWordField (BUF0, \_SB.PC00._Y0B._LEN, E8LN) // _LEN: Length
E8LN = Zero
}

If ((^MC.PM6L == One))
{
CreateBitField (BUF0, \_SB.PC00._Y0B._RW, E8RW) // _RW_: Read-Write Status
E8RW = Zero
}

If (^MC.PM6H)
{
CreateDWordField (BUF0, \_SB.PC00._Y0C._LEN, ECLN) // _LEN: Length
ECLN = Zero
}

If ((^MC.PM6H == One))
{
CreateBitField (BUF0, \_SB.PC00._Y0C._RW, ECRW) // _RW_: Read-Write Status
ECRW = Zero
}

If (^MC.PM0H)
{
CreateDWordField (BUF0, \_SB.PC00._Y0D._LEN, F0LN) // _LEN: Length
F0LN = Zero
}

If ((^MC.PM0H == One))
{
CreateBitField (BUF0, \_SB.PC00._Y0D._RW, F0RW) // _RW_: Read-Write Status
F0RW = Zero
}

CreateDWordField (BUF0, \_SB.PC00._Y0E._MIN, M1MN) // _MIN: Minimum Base Address
CreateDWordField (BUF0, \_SB.PC00._Y0E._MAX, M1MX) // _MAX: Maximum Base Address
CreateDWordField (BUF0, \_SB.PC00._Y0E._LEN, M1LN) // _LEN: Length
M1LN = M32L /* External reference */
M1MN = M32B /* External reference */
M1MX = ((M1MN + M1LN) - One)
If ((M64L == Zero))
{
CreateQWordField (BUF0, \_SB.PC00._Y0F._LEN, MSLN) // _LEN: Length
MSLN = Zero
}
Else
{
CreateQWordField (BUF0, \_SB.PC00._Y0F._LEN, M2LN) // _LEN: Length
CreateQWordField (BUF0, \_SB.PC00._Y0F._MIN, M2MN) // _MIN: Minimum Base Address
CreateQWordField (BUF0, \_SB.PC00._Y0F._MAX, M2MX) // _MAX: Maximum Base Address
M2LN = M64L /* External reference */
M2MN = M64B /* External reference */
M2MX = ((M2MN + M2LN) - One)
}

Return (BUF0) /* \_SB_.PC00.BUF0 */
}

Name (GUID, ToUUID ("33db4d5b-1ff7-401c-9657-7441c03dd766") /* PCI Host Bridge Device */)
Name (SUPP, Zero)
Name (CTRL, Zero)
Name (XCNT, Zero)
Method (_OSC, 4, Serialized) // _OSC: Operating System Capabilities
{
Local0 = Arg3
CreateDWordField (Local0, Zero, CDW1)
CreateDWordField (Local0, 0x04, CDW2)
CreateDWordField (Local0, 0x08, CDW3)
If ((Arg0 == GUID))
{
SUPP = CDW2 /* \_SB_.PC00._OSC.CDW2 */
CTRL = CDW3 /* \_SB_.PC00._OSC.CDW3 */
If (!NEXP)
{
CTRL &= 0xFFFFFFF8
}

If (CondRefOf (ITSP))
{
If (ITSP)
{
CTRL &= 0xFFFFFFF7
}
}

If (~(CDW1 & One))
{
OSCC = CTRL /* \_SB_.PC00.CTRL */
If (CondRefOf (SWAK))
{
SWAK (0xFFFF, Zero)
}
}

If ((Arg1 != One))
{
CDW1 |= 0x08
}

If ((CDW3 != CTRL))
{
CDW1 |= 0x10
}

CDW3 = CTRL /* \_SB_.PC00.CTRL */
OSCC = CTRL /* \_SB_.PC00.CTRL */
Return (Local0)
}
Else
{
CDW1 |= 0x04
Return (Local0)
}
}

Scope (\_SB.PC00)
{
Method (AR00, 0, NotSerialized)
{
Return (^^AR00) /* \_SB_.AR00 */
}

Method (PD00, 0, NotSerialized)
{
Return (^^PD00) /* \_SB_.PD00 */
}

Method (AR04, 0, NotSerialized)
{
Return (^^AR04) /* \_SB_.AR04 */
}

Method (PD04, 0, NotSerialized)
{
Return (^^PD04) /* \_SB_.PD04 */
}

Method (AR05, 0, NotSerialized)
{
Return (^^AR05) /* \_SB_.AR05 */
}

Method (PD05, 0, NotSerialized)
{
Return (^^PD05) /* \_SB_.PD05 */
}

Method (AR06, 0, NotSerialized)
{
Return (^^AR06) /* \_SB_.AR06 */
}

Method (PD06, 0, NotSerialized)
{
Return (^^PD06) /* \_SB_.PD06 */
}

Method (AR07, 0, NotSerialized)
{
Return (^^AR07) /* \_SB_.AR07 */
}

Method (PD07, 0, NotSerialized)
{
Return (^^PD07) /* \_SB_.PD07 */
}

Method (AR08, 0, NotSerialized)
{
Return (^^AR08) /* \_SB_.AR08 */
}

Method (PD08, 0, NotSerialized)
{
Return (^^PD08) /* \_SB_.PD08 */
}

Method (AR09, 0, NotSerialized)
{
Return (^^AR09) /* \_SB_.AR09 */
}

Method (PD09, 0, NotSerialized)
{
Return (^^PD09) /* \_SB_.PD09 */
}

Device (PEG0)
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
Local0 = 0x00060000
If (CondRefOf (\_SB.PC00.PEG0.CPRA))
{
Local0 = CPRA ()
}

Return (Local0)
}

Device (PEGP)
{
Name (_ADR, Zero) // _ADR: Address
}
}

Device (PEG1)
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
Local0 = 0x00010000
If (CondRefOf (\_SB.PC00.PEG1.CPRA))
{
Local0 = CPRA ()
}

Return (Local0)
}

Device (PEGP)
{
Name (_ADR, Zero) // _ADR: Address
}
}

Device (PEG2)
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
Local0 = 0x00010001
If (CondRefOf (\_SB.PC00.PEG2.CPRA))
{
Local0 = CPRA ()
}

Return (Local0)
}

Device (PEGP)
{
Name (_ADR, Zero) // _ADR: Address
}
}

If ((MPGN >= 0x04))
{
Device (PEG3)
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
Local0 = 0x00010002
If (CondRefOf (\_SB.PC00.PEG3.CPRA))
{
Local0 = CPRA ()
}

Return (Local0)
}

Device (PEGP)
{
Name (_ADR, Zero) // _ADR: Address
}
}
}

Device (GFX0)
{
Name (_ADR, 0x00020000) // _ADR: Address
}

Device (TCPU)
{
Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If (PCIC (Arg0))
{
Return (PCID (Arg0, Arg1, Arg2, Arg3))
}

Return (Buffer (One)
{
0x00 // .
})
}

Name (_ADR, 0x00040000) // _ADR: Address
}

Device (IPU0)
{
Name (_ADR, 0x00050000) // _ADR: Address
}

Device (GNA0)
{
Name (_ADR, 0x00080000) // _ADR: Address
}
}
}
}

Scope (_SB)
{
Device (AWAC)
{
Name (_HID, "ACPI000E" /* Time and Alarm Device */) // _HID: Hardware ID
Name (WAST, Zero)
Name (WTTR, Zero)
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake
{
Return (GPRW (0x72, 0x04))
}

Mutex (RTCL, 0x00)
Method (_STA, 0, NotSerialized) // _STA: Status
{
If ((STAS == Zero))
{
Return (0x0F)
}
Else
{
Return (Zero)
}
}

Method (_GCP, 0, NotSerialized) // _GCP: Get Capabilities
{
Return (0xB7)
}

OperationRegion (RTCM, SystemCMOS, Zero, 0x3F)
Field (RTCM, ByteAcc, Lock, Preserve)
{
SEC, 8,
Offset (0x02),
MIN, 8,
Offset (0x04),
HOR, 8,
Offset (0x07),
DAY, 8,
MON, 8,
YEAR, 8,
REGA, 8,
Offset (0x32),
CNTY, 8
}

Method (_GRT, 0, Serialized) // _GRT: Get Real Time
{
Name (BUFF, Buffer (0x10){})
CreateWordField (BUFF, Zero, Y)
CreateByteField (BUFF, 0x02, M)
CreateByteField (BUFF, 0x03, D)
CreateByteField (BUFF, 0x04, H)
CreateByteField (BUFF, 0x05, MIN1)
CreateByteField (BUFF, 0x06, S)
CreateByteField (BUFF, 0x07, V)
CreateWordField (BUFF, 0x0A, TZ)
CreateByteField (BUFF, 0x0C, DL)
Acquire (RTCL, 0xFFFF)
Local1 = Zero
Name (TOUT, 0x000186A0)
TOUT /= 0x0A
While (((REGA & 0x80) && (Local1 < TOUT)))
{
Stall (0x0A)
Local1 += 0x0A
}

If ((Local1 >= TOUT))
{
ADBG ("_GRT timeout fail")
}

FromBCD (YEAR, Local5)
FromBCD (CNTY, Local6)
Y = ((Local6 * 0x64) + Local5)
FromBCD (MON, M) /* \_SB_.AWAC._GRT.M___ */
FromBCD (DAY, D) /* \_SB_.AWAC._GRT.D___ */
FromBCD (HOR, H) /* \_SB_.AWAC._GRT.H___ */
FromBCD (MIN, MIN1) /* \_SB_.AWAC._GRT.MIN1 */
FromBCD (SEC, S) /* \_SB_.AWAC._GRT.S___ */
Release (RTCL)
TZ = 0x07FF
DL = Zero
V = One
Return (BUFF) /* \_SB_.AWAC._GRT.BUFF */
}

Method (_SRT, 1, NotSerialized) // _SRT: Set Real Time
{
CreateWordField (Arg0, Zero, Y)
CreateByteField (Arg0, 0x02, M)
CreateByteField (Arg0, 0x03, D)
CreateByteField (Arg0, 0x04, H)
CreateByteField (Arg0, 0x05, MIN1)
CreateByteField (Arg0, 0x06, S)
Acquire (RTCL, 0xFFFF)
Local1 = Zero
Name (TOUT, 0x000186A0)
TOUT /= 0x0A
While (((REGA & 0x80) && (Local1 < TOUT)))
{
Stall (0x0A)
Local1 += 0x0A
}

If ((Local1 >= TOUT))
{
ADBG ("_SRT timeout fail")
Release (RTCL)
Return (0xFFFFFFFF)
}

Divide (Y, 0x64, Local5, Local4)
ToBCD (Local4, CNTY) /* \_SB_.AWAC.CNTY */
ToBCD (Local5, YEAR) /* \_SB_.AWAC.YEAR */
ToBCD (M, MON) /* \_SB_.AWAC.MON_ */
ToBCD (D, DAY) /* \_SB_.AWAC.DAY_ */
ToBCD (H, HOR) /* \_SB_.AWAC.HOR_ */
ToBCD (MIN1, MIN) /* \_SB_.AWAC.MIN_ */
ToBCD (S, SEC) /* \_SB_.AWAC.SEC_ */
Release (RTCL)
Return (Zero)
}

Method (_GWS, 1, Serialized) // _GWS: Get Wake Status
{
Local0 = Zero
If ((Arg0 == Zero))
{
If (((ACWA == 0xFFFFFFFF) && (One & WTTR)))
{
Local0 |= One
WTTR ^= One /* \_SB_.AWAC.WTTR */
}
}
ElseIf (((DCWA == 0xFFFFFFFF) && (0x02 & WTTR)))
{
Local0 |= One
WTTR ^= 0x02 /* \_SB_.AWAC.WTTR */
}

If (WAST)
{
Local0 |= 0x02
WAST = Zero
}

Return (Local0)
}

Method (_CWS, 1, NotSerialized) // _CWS: Clear Wake Alarm Status
{
Return (Zero)
}

Method (_STP, 2, NotSerialized) // _STP: Set Expired Timer Wake Policy
{
If ((Arg0 == Zero))
{
ACET = Arg1
}
Else
{
DCET = Arg1
}

Return (Zero)
}

Method (_STV, 2, Serialized) // _STV: Set Timer Value
{
If ((Arg0 == Zero))
{
ACWA = Arg1
WTTR |= One /* \_SB_.AWAC.WTTR */
}
Else
{
DCWA = Arg1
WTTR |= 0x02 /* \_SB_.AWAC.WTTR */
}

Return (Zero)
}

Method (_TIP, 1, NotSerialized) // _TIP: Expired Timer Wake Policy
{
If ((Arg0 == Zero))
{
Return (ACET) /* \ACET */
}
Else
{
Return (DCET) /* \DCET */
}
}

Method (_TIV, 1, NotSerialized) // _TIV: Timer Values
{
If ((Arg0 == Zero))
{
Return (ACWA) /* \ACWA */
}
Else
{
Return (DCWA) /* \DCWA */
}
}
}
}

Scope (\)
{
Method (ASRT, 2, NotSerialized)
{
Local1 = (Arg0 & 0xFF)
While (One)
{
Local0 = 0x09
P8XH (Zero, Local1)
While ((Local0 > Zero))
{
P8XH (One, Local0)
Local0--
Local2 = 0x2710
While ((Local2 > Zero))
{
Stall (0x64)
Local2--
}
}

P8XH (Zero, 0xB6)
P8XH (One, 0xAD)
Sleep (0xEA60)
}
}
}

OperationRegion (OGNS, SystemMemory, 0x44904D18, 0x0000000C)
Field (OGNS, AnyAcc, Lock, Preserve)
{
OG00, 8,
OG01, 8,
OG02, 8,
OG03, 8,
OG04, 8,
OG05, 8,
OG06, 8,
OG07, 8,
OG08, 8,
OG09, 8,
OG10, 8,
ECFG, 8
}

Name (BUFN, Zero)
Name (MBUF, Buffer (0x1000){})
OperationRegion (MDBG, SystemMemory, 0x448E1018, 0x00001004)
Field (MDBG, AnyAcc, Lock, Preserve)
{
MDG0, 32768
}

Method (DB2H, 1, Serialized)
{
If (SRLD)
{
SHOW (Arg0)
MDGC (0x20)
MDG0 = MBUF /* \MBUF */
}
Else
{
Return (Zero)
}
}

Method (DW2H, 1, Serialized)
{
Local0 = Arg0
Local1 = (Arg0 >> 0x08)
Local0 &= 0xFF
Local1 &= 0xFF
DB2H (Local1)
BUFN--
DB2H (Local0)
}

Method (DD2H, 1, Serialized)
{
Local0 = Arg0
Local1 = (Arg0 >> 0x10)
Local0 &= 0xFFFF
Local1 &= 0xFFFF
DW2H (Local1)
BUFN--
DW2H (Local0)
}

Method (MBGS, 1, Serialized)
{
If (SRLD)
{
Local0 = SizeOf (Arg0)
Name (BUFS, Buffer (Local0){})
BUFS = Arg0
MDGC (0x20)
While (Local0)
{
MDGC (DerefOf (BUFS [(SizeOf (Arg0) - Local0)]))
Local0--
}

MDG0 = MBUF /* \MBUF */
}
Else
{
Return (Zero)
}
}

Method (SDBG, 1, Serialized)
{
Switch (OSDP)
{
Case (Zero)
{
OperationRegion (U3F8, SystemIO, 0x03F8, 0x10)
Field (U3F8, ByteAcc, Lock, Preserve)
{
TXBF, 8,
DLM, 8,
FCR, 8,
LCR, 8
}

LCR = 0x83
TXBF = One
DLM = Zero
FCR = 0xE1
LCR = 0x03
DLM = Zero
ToHexString (Arg0, Local3)
Local4 = SizeOf (Local3)
Local5 = Zero
While ((Local5 < Local4))
{
Mid (Local3, Local5, One, TXBF) /* \SDBG.TXBF */
Stall (0x64)
Local5++
}

Stall (0x64)
TXBF = 0x0D
Stall (0x64)
TXBF = 0x0A
}
Case (0x03)
{
OperationRegion (U2CF, SystemMemory, UC02, 0x20)
Field (U2CF, AnyAcc, NoLock, Preserve)
{
Offset (0x10),
BAR0, 64
}

OperationRegion (U2B0, SystemMemory, (BAR0 & 0xFFFFFFFFFFFFF000), 0x10)
Field (U2B0, ByteAcc, Lock, Preserve)
{
U2TX, 8,
U2DH, 8,
U2FC, 8,
U2LC, 8
}

U2LC = 0x83
U2TX = One
U2DH = Zero
U2FC = 0xE1
U2LC = 0x03
U2DH = Zero
ToHexString (Arg0, Local3)
Local4 = SizeOf (Local3)
Local5 = Zero
While ((Local5 < Local4))
{
Mid (Local3, Local5, One, U2TX) /* \SDBG.U2TX */
Stall (0x64)
Local5++
}

Stall (0x64)
U2TX = 0x0D
Stall (0x64)
U2TX = 0x0A
}

}
}

Method (ADBG, 1, Serialized)
{
If ((SRLD & One))
{
If ((SRLD & 0x02))
{
SDBG (Arg0)
}

ToHexString (Arg0, Local1)
Local0 = SizeOf (Local1)
Name (BUFS, Buffer (Local0){})
BUFS = Local1
MDGC (0x20)
While (Local0)
{
MDGC (DerefOf (BUFS [(SizeOf (Local1) - Local0)]))
Local0--
}

MDG0 = MBUF /* \MBUF */
}
}

Method (SHOW, 1, Serialized)
{
MDGC (NTOC ((Arg0 >> 0x04)))
MDGC (NTOC (Arg0))
}

Method (LINE, 0, Serialized)
{
Local0 = BUFN /* \BUFN */
Local0 &= 0x0F
While (Local0)
{
MDGC (Zero)
Local0++
Local0 &= 0x0F
}
}

Method (MDGC, 1, Serialized)
{
MBUF [BUFN] = Arg0
BUFN += One
If ((BUFN > 0x0FFF))
{
BUFN &= 0x0FFF
UP_L (0x0F)
}
}

Method (UP_L, 1, Serialized)
{
Local2 = Arg0
Local2 <<= 0x04
MOVE (Local2)
Local3 = (0x1000 - Local2)
While (Local2)
{
MBUF [Local3] = Zero
Local3++
Local2--
}
}

Method (MOVE, 1, Serialized)
{
Local4 = Arg0
BUFN = Zero
Local5 = (0x1000 - Local4)
While (Local5)
{
Local5--
MBUF [BUFN] = DerefOf (MBUF [Local4])
BUFN++
Local4++
}
}

Method (NTOC, 1, Serialized)
{
Local0 = (Arg0 & 0x0F)
If ((Local0 < 0x0A))
{
Local0 += 0x30
}
Else
{
Local0 += 0x37
}

Return (Local0)
}

If ((ECR1 == One))
{
Scope (_SB.PC00)
{
Name (PCIG, ToUUID ("e5c937d0-3553-4d7a-9117-ea4d19c3434d") /* Device Labeling Interface */)
Method (PCID, 4, Serialized)
{
If ((Arg0 == PCIG))
{
If ((Arg1 >= 0x03))
{
If ((Arg2 == Zero))
{
Return (Buffer (0x02)
{
0x01, 0x03 // ..
})
}

If ((Arg2 == 0x08))
{
Return (One)
}

If ((Arg2 == 0x09))
{
Return (Package (0x05)
{
0xC350,
Ones,
Ones,
0xC350,
Ones
})
}
}
}

Return (Buffer (One)
{
0x00 // .
})
}
}
}

Scope (_SB.PC00)
{
Method (PCIC, 1, Serialized)
{
If ((ECR1 == One))
{
If ((Arg0 == PCIG))
{
Return (One)
}
}

Return (Zero)
}

Method (IICB, 2, Serialized)
{
Switch (ToInteger (Arg1))
{
Case (Zero)
{
Name (IIC0, ResourceTemplate ()
{
I2cSerialBusV2 (0x0000, ControllerInitiated, 0x00061A80,
AddressingMode7Bit, "\\_SB.PC00.I2C0",
0x00, ResourceConsumer, _Y10, Exclusive,
)
})
CreateWordField (IIC0, \_SB.PC00.IICB._Y10._ADR, DAD0) // _ADR: Address
DAD0 = Arg0
Return (IIC0) /* \_SB_.PC00.IICB.IIC0 */
}
Case (One)
{
Name (IIC1, ResourceTemplate ()
{
I2cSerialBusV2 (0x0000, ControllerInitiated, 0x00061A80,
AddressingMode7Bit, "\\_SB.PC00.I2C1",
0x00, ResourceConsumer, _Y11, Exclusive,
)
})
CreateWordField (IIC1, \_SB.PC00.IICB._Y11._ADR, DAD1) // _ADR: Address
DAD1 = Arg0
Return (IIC1) /* \_SB_.PC00.IICB.IIC1 */
}
Case (0x02)
{
Name (IIC2, ResourceTemplate ()
{
I2cSerialBusV2 (0x0000, ControllerInitiated, 0x00061A80,
AddressingMode7Bit, "\\_SB.PC00.I2C2",
0x00, ResourceConsumer, _Y12, Exclusive,
)
})
CreateWordField (IIC2, \_SB.PC00.IICB._Y12._ADR, DAD2) // _ADR: Address
DAD2 = Arg0
Return (IIC2) /* \_SB_.PC00.IICB.IIC2 */
}
Case (0x03)
{
Name (IIC3, ResourceTemplate ()
{
I2cSerialBusV2 (0x0000, ControllerInitiated, 0x00061A80,
AddressingMode7Bit, "\\_SB.PC00.I2C3",
0x00, ResourceConsumer, _Y13, Exclusive,
)
})
CreateWordField (IIC3, \_SB.PC00.IICB._Y13._ADR, DAD3) // _ADR: Address
DAD3 = Arg0
Return (IIC3) /* \_SB_.PC00.IICB.IIC3 */
}
Case (0x04)
{
Name (IIC4, ResourceTemplate ()
{
I2cSerialBusV2 (0x0000, ControllerInitiated, 0x00061A80,
AddressingMode7Bit, "\\_SB.PC00.I2C4",
0x00, ResourceConsumer, _Y14, Exclusive,
)
})
CreateWordField (IIC4, \_SB.PC00.IICB._Y14._ADR, DAD4) // _ADR: Address
DAD4 = Arg0
Return (IIC4) /* \_SB_.PC00.IICB.IIC4 */
}
Case (0x05)
{
Name (IIC5, ResourceTemplate ()
{
I2cSerialBusV2 (0x0000, ControllerInitiated, 0x00061A80,
AddressingMode7Bit, "\\_SB.PC00.I2C5",
0x00, ResourceConsumer, _Y15, Exclusive,
)
})
CreateWordField (IIC5, \_SB.PC00.IICB._Y15._ADR, DAD5) // _ADR: Address
DAD5 = Arg0
Return (IIC5) /* \_SB_.PC00.IICB.IIC5 */
}
Case (0x06)
{
Name (IIC6, ResourceTemplate ()
{
I2cSerialBusV2 (0x0000, ControllerInitiated, 0x00061A80,
AddressingMode7Bit, "\\_SB.PC00.I2C6",
0x00, ResourceConsumer, _Y16, Exclusive,
)
})
CreateWordField (IIC6, \_SB.PC00.IICB._Y16._ADR, DAD6) // _ADR: Address
DAD6 = Arg0
Return (IIC6) /* \_SB_.PC00.IICB.IIC6 */
}
Case (0x07)
{
Name (IIC7, ResourceTemplate ()
{
I2cSerialBusV2 (0x0000, ControllerInitiated, 0x00061A80,
AddressingMode7Bit, "\\_SB.PC00.I2C7",
0x00, ResourceConsumer, _Y17, Exclusive,
)
})
CreateWordField (IIC7, \_SB.PC00.IICB._Y17._ADR, DAD7) // _ADR: Address
DAD7 = Arg0
Return (IIC7) /* \_SB_.PC00.IICB.IIC7 */
}
Default
{
Return (Zero)
}

}
}

Method (VIIC, 2, Serialized)
{
Switch (ToInteger (Arg1))
{
Case (Zero)
{
Name (VI00, ResourceTemplate ()
{
I2cSerialBusV2 (0x0000, ControllerInitiated, 0x00061A80,
AddressingMode7Bit, "\\_SB.PC00.XHCI.RHUB.HS07.VIC0",
0x00, ResourceConsumer, _Y19, Exclusive,
)
})
Name (VI01, ResourceTemplate ()
{
I2cSerialBusV2 (0x0000, ControllerInitiated, 0x00061A80,
AddressingMode7Bit, "\\_SB.PC00.XHCI.RHUB.HS06.VIC0",
0x00, ResourceConsumer, _Y18, Exclusive,
)
})
Name (VI02, ResourceTemplate ()
{
I2cSerialBusV2 (0x0000, ControllerInitiated, 0x00061A80,
AddressingMode7Bit, "\\_SB.PC00.XHCI.RHUB.HS08.VIC0",
0x00, ResourceConsumer, _Y1A, Exclusive,
)
})
Name (VI03, ResourceTemplate ()
{
I2cSerialBusV2 (0x0000, ControllerInitiated, 0x00061A80,
AddressingMode7Bit, "\\_SB.PC00.XHCI.RHUB.HS03.VIC0",
0x00, ResourceConsumer, _Y1B, Exclusive,
)
})
If ((CUPN == 0x06))
{
CreateWordField (VI01, \_SB.PC00.VIIC._Y18._ADR, DAQ0) // _ADR: Address
DAQ0 = Arg0
Return (VI01) /* \_SB_.PC00.VIIC.VI01 */
}
ElseIf ((CUPN == 0x07))
{
CreateWordField (VI00, \_SB.PC00.VIIC._Y19._ADR, DAR0) // _ADR: Address
DAR0 = Arg0
Return (VI00) /* \_SB_.PC00.VIIC.VI00 */
}
ElseIf ((CUPN == 0x08))
{
CreateWordField (VI02, \_SB.PC00.VIIC._Y1A._ADR, DAS0) // _ADR: Address
DAS0 = Arg0
Return (VI02) /* \_SB_.PC00.VIIC.VI02 */
}
ElseIf ((CUPN == 0x03))
{
CreateWordField (VI03, \_SB.PC00.VIIC._Y1B._ADR, DAT0) // _ADR: Address
DAT0 = Arg0
Return (VI03) /* \_SB_.PC00.VIIC.VI03 */
}

Return (ResourceTemplate ()
{
I2cSerialBusV2 (0x0000, ControllerInitiated, 0x00061A80,
AddressingMode7Bit, "\\_SB.PC00.XHCI.RHUB.HSXX.VIC0",
0x00, ResourceConsumer, , Exclusive,
)
})
}
Case (One)
{
Name (VI10, ResourceTemplate ()
{
I2cSerialBusV2 (0x0000, ControllerInitiated, 0x00061A80,
AddressingMode7Bit, "\\_SB.PC00.XHCI.RHUB.HS07.VIC1",
0x00, ResourceConsumer, _Y1D, Exclusive,
)
})
Name (VI11, ResourceTemplate ()
{
I2cSerialBusV2 (0x0000, ControllerInitiated, 0x00061A80,
AddressingMode7Bit, "\\_SB.PC00.XHCI.RHUB.HS06.VIC1",
0x00, ResourceConsumer, _Y1C, Exclusive,
)
})
Name (VI12, ResourceTemplate ()
{
I2cSerialBusV2 (0x0000, ControllerInitiated, 0x00061A80,
AddressingMode7Bit, "\\_SB.PC00.XHCI.RHUB.HS08.VIC1",
0x00, ResourceConsumer, _Y1E, Exclusive,
)
})
Name (VI13, ResourceTemplate ()
{
I2cSerialBusV2 (0x0000, ControllerInitiated, 0x00061A80,
AddressingMode7Bit, "\\_SB.PC00.XHCI.RHUB.HS03.VIC1",
0x00, ResourceConsumer, _Y1F, Exclusive,
)
})
If ((CUPN == 0x06))
{
CreateWordField (VI11, \_SB.PC00.VIIC._Y1C._ADR, DAQ1) // _ADR: Address
DAQ1 = Arg0
Return (VI11) /* \_SB_.PC00.VIIC.VI11 */
}
ElseIf ((CUPN == 0x07))
{
CreateWordField (VI10, \_SB.PC00.VIIC._Y1D._ADR, DAR1) // _ADR: Address
DAR1 = Arg0
Return (VI10) /* \_SB_.PC00.VIIC.VI10 */
}
ElseIf ((CUPN == 0x08))
{
CreateWordField (VI12, \_SB.PC00.VIIC._Y1E._ADR, DAS1) // _ADR: Address
DAS1 = Arg0
Return (VI12) /* \_SB_.PC00.VIIC.VI12 */
}
ElseIf ((CUPN == 0x03))
{
CreateWordField (VI13, \_SB.PC00.VIIC._Y1F._ADR, DAT1) // _ADR: Address
DAT1 = Arg0
Return (VI13) /* \_SB_.PC00.VIIC.VI13 */
}

Return (ResourceTemplate ()
{
I2cSerialBusV2 (0x0000, ControllerInitiated, 0x00061A80,
AddressingMode7Bit, "\\_SB.PC00.XHCI.RHUB.HSXX.VIC1",
0x00, ResourceConsumer, , Exclusive,
)
})
}
Default
{
Return (ResourceTemplate ()
{
I2cSerialBusV2 (0x0000, ControllerInitiated, 0x00061A80,
AddressingMode7Bit, "\\_SB.PC00.XHCI.RHUB.HSXX.VICX",
0x00, ResourceConsumer, , Exclusive,
)
})
}

}
}

Method (INTB, 3, Serialized)
{
Name (INTR, ResourceTemplate ()
{
Interrupt (ResourceConsumer, Level, ActiveLow, ExclusiveAndWake, ,, _Y20)
{
0x00000000,
}
})
CreateDWordField (INTR, \_SB.PC00.INTB._Y20._INT, NUMI) // _INT: Interrupts
NUMI = INUM (Arg0)
CreateBitField (INTR, \_SB.PC00.INTB._Y20._HE, LEVI) // _HE_: High-Edge
LEVI = Arg1
CreateBitField (INTR, \_SB.PC00.INTB._Y20._LL, ACTI) // _LL_: Low Level
ACTI = Arg2
Return (INTR) /* \_SB_.PC00.INTB.INTR */
}
}

Name (PNVB, 0x44904018)
Name (PNVL, 0x037B)
OperationRegion (PNVA, SystemMemory, PNVB, PNVL)
Field (PNVA, AnyAcc, Lock, Preserve)
{
PCHS, 16,
PCHG, 16,
PSTP, 16,
RPA1, 32,
RPA2, 32,
RPA3, 32,
RPA4, 32,
RPA5, 32,
RPA6, 32,
RPA7, 32,
RPA8, 32,
RPA9, 32,
RPAA, 32,
RPAB, 32,
RPAC, 32,
RPAD, 32,
RPAE, 32,
RPAF, 32,
RPAG, 32,
RPAH, 32,
RPAI, 32,
RPAJ, 32,
RPAK, 32,
RPAL, 32,
RPAM, 32,
RPAN, 32,
RPAO, 32,
RPAP, 32,
RPAQ, 32,
RPAR, 32,
RPAS, 32,
NHLA, 64,
NHLL, 32,
ADFM, 32,
SWQ0, 8,
SWQ1, 8,
SWQ2, 8,
SWQ3, 8,
ACS0, 8,
ACS1, 8,
ACS2, 8,
ACS3, 8,
DAI0, 8,
DAI1, 8,
DAI2, 8,
DAI3, 8,
DOD0, 8,
DOD1, 8,
DOD2, 8,
DOD3, 8,
SWMC, 8,
XTAL, 32,
AFDF, 8,
SBRG, 32,
GEI0, 8,
GEI1, 8,
GEI2, 8,
GED0, 8,
GED1, 8,
GED2, 8,
PML1, 16,
PML2, 16,
PML3, 16,
PML4, 16,
PML5, 16,
PML6, 16,
PML7, 16,
PML8, 16,
PML9, 16,
PMLA, 16,
PMLB, 16,
PMLC, 16,
PMLD, 16,
PMLE, 16,
PMLF, 16,
PMLG, 16,
PMLH, 16,
PMLI, 16,
PMLJ, 16,
PMLK, 16,
PMLL, 16,
PMLM, 16,
PMLN, 16,
PMLO, 16,
PMLP, 16,
PMLQ, 16,
PMLR, 16,
PMLS, 16,
PNL1, 16,
PNL2, 16,
PNL3, 16,
PNL4, 16,
PNL5, 16,
PNL6, 16,
PNL7, 16,
PNL8, 16,
PNL9, 16,
PNLA, 16,
PNLB, 16,
PNLC, 16,
PNLD, 16,
PNLE, 16,
PNLF, 16,
PNLG, 16,
PNLH, 16,
PNLI, 16,
PNLJ, 16,
PNLK, 16,
PNLL, 16,
PNLM, 16,
PNLN, 16,
PNLO, 16,
PNLP, 16,
PNLQ, 16,
PNLR, 16,
PNLS, 16,
XHPC, 8,
XRPC, 8,
XSPC, 8,
XSPA, 8,
HPTB, 32,
HPTE, 8,
SM00, 8,
SM01, 8,
SM02, 8,
SM03, 8,
SM04, 8,
SM05, 8,
SM06, 8,
SC00, 64,
SC01, 64,
SC02, 64,
SC03, 64,
SC04, 64,
SC05, 64,
SC06, 64,
IM00, 8,
IM01, 8,
IM02, 8,
IM03, 8,
IM04, 8,
IM05, 8,
IM06, 8,
IM07, 8,
IC00, 64,
IC01, 64,
IC02, 64,
IC03, 64,
IC04, 64,
IC05, 64,
IC06, 64,
IC07, 64,
UM00, 8,
UM01, 8,
UM02, 8,
UM03, 8,
UM04, 8,
UM05, 8,
UM06, 8,
UC00, 64,
UC01, 64,
UC02, 64,
UC03, 64,
UC04, 64,
UC05, 64,
UC06, 64,
UD00, 8,
UD01, 8,
UD02, 8,
UD03, 8,
UD04, 8,
UD05, 8,
UD06, 8,
UP00, 8,
UP01, 8,
UP02, 8,
UP03, 8,
UP04, 8,
UP05, 8,
UP06, 8,
UI00, 8,
UI01, 8,
UI02, 8,
UI03, 8,
UI04, 8,
UI05, 8,
UI06, 8,
SGIR, 8,
GPHD, 8,
NIT1, 8,
NIT2, 8,
NIT3, 8,
NPM1, 8,
NPM2, 8,
NPM3, 8,
NPC1, 8,
NPC2, 8,
NPC3, 8,
NL11, 16,
NL12, 16,
NL13, 16,
ND21, 8,
ND22, 8,
ND23, 8,
ND11, 32,
ND12, 32,
ND13, 32,
NLR1, 16,
NLR2, 16,
NLR3, 16,
NLD1, 32,
NLD2, 32,
NLD3, 32,
NEA1, 16,
NEA2, 16,
NEA3, 16,
NEB1, 16,
NEB2, 16,
NEB3, 16,
NEC1, 16,
NEC2, 16,
NEC3, 16,
NRA1, 16,
NRA2, 16,
NRA3, 16,
NMB1, 32,
NMB2, 32,
NMB3, 32,
NMV1, 32,
NMV2, 32,
NMV3, 32,
NPB1, 32,
NPB2, 32,
NPB3, 32,
NPV1, 32,
NPV2, 32,
NPV3, 32,
NRP1, 32,
NRP2, 32,
NRP3, 32,
EMH4, 8,
EMDS, 8,
CSKU, 8,
ITA0, 16,
ITA1, 16,
ITA2, 16,
ITA3, 16,
ITS0, 8,
ITS1, 8,
ITS2, 8,
ITS3, 8,
PMBS, 16,
PWRM, 32,
CNVI, 8,
CBTC, 8,
CBTA, 8,
CVPR, 8,
CRFI, 8,
CRFP, 8,
PTHM, 8,
PSON, 8,
LTR1, 8,
LTR2, 8,
LTR3, 8,
LTR4, 8,
LTR5, 8,
LTR6, 8,
LTR7, 8,
LTR8, 8,
LTR9, 8,
LTRA, 8,
LTRB, 8,
LTRC, 8,
LTRD, 8,
LTRE, 8,
LTRF, 8,
LTRG, 8,
LTRH, 8,
LTRI, 8,
LTRJ, 8,
LTRK, 8,
LTRL, 8,
LTRM, 8,
LTRN, 8,
LTRO, 8,
LTRP, 8,
LTRQ, 8,
LTRR, 8,
LTRS, 8,
GBES, 8,
PPDS, 32,
EMCE, 8,
SDCE, 8,
TGEA, 8,
TGEB, 8,
CR00, 8,
CR01, 8,
CR02, 8,
CR03, 8,
CR04, 8,
CR05, 8,
CR06, 8,
CR07, 8,
CR08, 8,
CR09, 8,
CR10, 8,
CR11, 8,
CR12, 8,
CR13, 8,
CR14, 8,
CR15, 8,
CR16, 8,
CR17, 8,
TCOB, 16,
ICKP, 16,
PCNV, 16,
HBSL, 32,
PU2C, 8,
PU3C, 8,
SPPR, 8,
IPCC, 8,
CQ00, 8,
CQ01, 8,
CQ02, 8,
CQ03, 8,
CQ04, 8,
CQ05, 8,
CQ06, 8,
CQ07, 8,
CQ08, 8,
CQ09, 8,
CQ10, 8,
CQ11, 8,
CQ12, 8,
CQ13, 8,
CQ14, 8,
CQ15, 8,
CQ16, 8,
CQ17, 8,
TIN0, 32,
TIN1, 32,
TMD0, 16,
TMD1, 16,
UF0E, 8,
UF1E, 8,
UAOE, 8,
T010, 32,
T011, 32,
T020, 8,
T021, 8,
T030, 32,
T031, 32,
T040, 32,
T041, 32,
T050, 32,
T051, 32,
T060, 32,
T061, 32,
T070, 32,
T071, 32,
T080, 32,
T081, 32,
T090, 32,
T091, 32,
T0A0, 32,
T0A1, 32,
T0B0, 32,
T0B1, 32,
T0C0, 32,
T0C1, 32,
T0D0, 32,
T0D1, 32,
HBCL, 32,
HBPL, 32,
AL6D, 32,
T0E0, 32,
T0E1, 32,
HDBO, 16
}

Scope (_SB)
{
Method (PSD3, 1, Serialized)
{
Local0 = Zero
If (((SIME == One) || !IMPS ()))
{
Return (Zero)
}

Switch ((Zero + Arg0--))
{
Case (Zero)
{
RAA0 = One
While (((APA0 == Zero) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}
Case (One)
{
RAA1 = One
While (((APA1 == Zero) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}
Case (0x02)
{
RAA2 = One
While (((APA2 == Zero) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}
Case (0x03)
{
RAA3 = One
While (((APA3 == Zero) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}
Case (0x04)
{
RPB0 = One
While (((APB0 == Zero) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}
Case (0x05)
{
RPB1 = One
While (((APB1 == Zero) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}
Case (0x06)
{
RPB2 = One
While (((APB2 == Zero) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}
Case (0x07)
{
RPB3 = One
While (((APB3 == Zero) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}
Case (0x08)
{
RPC0 = One
While (((APC0 == Zero) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}
Case (0x09)
{
RPC1 = One
While (((APC1 == Zero) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}
Case (0x0A)
{
RPC2 = One
While (((APC2 == Zero) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}
Case (0x0B)
{
RPC3 = One
While (((APC3 == Zero) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}
Case (0x0C)
{
RPD0 = One
While (((APD0 == Zero) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}
Case (0x0D)
{
RPD1 = One
While (((APD1 == Zero) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}
Case (0x0E)
{
RPD2 = One
While (((APD2 == Zero) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}
Case (0x0F)
{
RPD3 = One
While (((APD3 == Zero) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}
Case (0x10)
{
RPE0 = One
While (((APE0 == Zero) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}
Case (0x11)
{
RPE1 = One
While (((APE1 == Zero) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}
Case (0x12)
{
RPE2 = One
While (((APE2 == Zero) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}
Case (0x13)
{
RPE3 = One
While (((APE3 == Zero) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}

}

If ((Local0 >= 0x2710))
{
ADBG ("Error: Timeout occurred")
}
}

Method (PSD0, 1, Serialized)
{
Local0 = Zero
If (((SIME == One) || !IMPS ()))
{
Return (Zero)
}

Switch ((Zero + Arg0--))
{
Case (Zero)
{
RAA0 = Zero
While (((APA0 == One) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}
Case (One)
{
RAA1 = Zero
While (((APA1 == One) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}
Case (0x02)
{
RAA2 = Zero
While (((APA2 == One) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}
Case (0x03)
{
RAA3 = Zero
While (((APA3 == One) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}
Case (0x04)
{
RPB0 = Zero
While (((APB0 == One) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}
Case (0x05)
{
RPB1 = Zero
While (((APB1 == One) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}
Case (0x06)
{
RPB2 = Zero
While (((APB2 == One) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}
Case (0x07)
{
RPB3 = Zero
While (((APB3 == One) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}
Case (0x08)
{
RPC0 = Zero
While (((APC0 == One) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}
Case (0x09)
{
RPC1 = Zero
While (((APC1 == One) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}
Case (0x0A)
{
RPC2 = Zero
While (((APC2 == One) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}
Case (0x0B)
{
RPC3 = Zero
While (((APC3 == One) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}
Case (0x0C)
{
RPD0 = Zero
While (((APD0 == One) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}
Case (0x0D)
{
RPD1 = Zero
While (((APD1 == One) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}
Case (0x0E)
{
RPD2 = Zero
While (((APD2 == One) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}
Case (0x0F)
{
RPD3 = Zero
While (((APD3 == One) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}
Case (0x10)
{
RPE0 = Zero
While (((APE0 == One) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}
Case (0x11)
{
RPE1 = Zero
While (((APE1 == One) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}
Case (0x12)
{
RPE2 = Zero
While (((APE2 == One) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}
Case (0x13)
{
RPE3 = Zero
While (((APE3 == One) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}

}

If ((Local0 >= 0x2710))
{
ADBG ("Error: Timeout occurred")
}
}

Method (CSD3, 1, Serialized)
{
Local0 = Zero
If (((SIME == One) || !IMPS ()))
{
Return (Zero)
}

Switch (ToInteger (Arg0))
{
Case (0x14)
{
RSAT = One
While (((ASAT == Zero) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}
Case (0x15)
{
RGBE = One
While (((AGBE == Zero) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}
Case (0x16)
{
RXHC = One
While (((AXHC == Zero) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}
Case (0x17)
{
RXDC = One
While (((AXDC == Zero) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}
Case (0x18)
{
RUFS = One
While (((AUFS == Zero) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}

}

If ((Local0 >= 0x2710))
{
ADBG ("Error: Timeout occurred")
}
}

Method (CSD0, 1, Serialized)
{
Local0 = Zero
If (((SIME == One) || !IMPS ()))
{
Return (Zero)
}

Switch (ToInteger (Arg0))
{
Case (0x14)
{
RSAT = Zero
While (((ASAT == One) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}
Case (0x15)
{
RGBE = Zero
While (((AGBE == One) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}
Case (0x16)
{
RXHC = Zero
While (((AXHC == One) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}
Case (0x17)
{
RXDC = Zero
While (((AXDC == One) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}
Case (0x18)
{
RUFS = Zero
While (((AUFS == One) && (Local0 < 0x2710)))
{
Local0++
Sleep (One)
}
}

}

If ((Local0 >= 0x2710))
{
ADBG ("Error: Timeout occurred")
}
}
}

Name (THMN, 0x48)
Name (THCN, 0x0E)
Name (CNPM, 0x80)
Name (FMSN, 0x10)
Scope (\)
{
Method (THDA, 2, Serialized)
{
Local0 = 0xFE200000
Local0 += (0x40 * (CNPM * (Arg0 - FMSN)))
Local0 += (0x40 * Arg1)
Return (Local0)
}

Method (STRD, 3, Serialized)
{
If (((Arg1 + Arg2) > SizeOf (Arg0)))
{
Return (Zero)
}

ToBuffer (Arg0, Local3)
Local0 = Zero
Local1 = Zero
While ((Local1 < Arg2))
{
Local2 = DerefOf (Local3 [(Arg1 + Local1)])
Local0 += (Local2 << (0x08 * Local1))
Local1++
}

Return (Local0)
}

Method (THDS, 1, Serialized)
{
If ((PTHM == Zero))
{
Return (Zero)
}
ElseIf ((PTHM == One))
{
If (!\_SB.PC00.PTHT.THEN ())
{
Return (Zero)
}
}
ElseIf ((PTHM == 0x02))
{
If (!\_SB.PTHH.THEN ())
{
Return (Zero)
}
}
Else
{
Return (Zero)
}

Concatenate (Arg0, "\n", Local2)
Local0 = SizeOf (Local2)
Local1 = THDA (THMN, THCN)
OperationRegion (THBA, SystemMemory, Local1, 0x40)
Field (THBA, QWordAcc, NoLock, WriteAsZeros)
{
QO00, 64
}

Field (THBA, DWordAcc, NoLock, WriteAsZeros)
{
DO00, 32,
Offset (0x10),
DO10, 32,
Offset (0x30),
DO30, 32
}

Field (THBA, WordAcc, NoLock, WriteAsZeros)
{
WO00, 16
}

Field (THBA, ByteAcc, NoLock, WriteAsZeros)
{
BO00, 8
}

DO10 = 0x01000242
WO00 = Local0
Local6 = Zero
Local7 = Local0
While ((Local7 >= 0x08))
{
QO00 = STRD (Local2, Local6, 0x08)
Local6 += 0x08
Local7 -= 0x08
}

If ((Local7 >= 0x04))
{
DO00 = STRD (Local2, Local6, 0x04)
Local6 += 0x04
Local7 -= 0x04
}

If ((Local7 >= 0x02))
{
WO00 = STRD (Local2, Local6, 0x02)
Local6 += 0x02
Local7 -= 0x02
}

If ((Local7 >= One))
{
BO00 = STRD (Local2, Local6, One)
Local6 += One
Local7 -= One
}

DO30 = Zero
}

Method (THDH, 1, Serialized)
{
THDS (ToHexString (Arg0))
}

Method (THDD, 1, Serialized)
{
THDS (ToDecimalString (Arg0))
}
}

Name (PCHH, One)
Name (PCHN, 0x03)
Name (PCHL, 0x02)
Name (PCHP, 0x05)
Name (PCHM, 0x06)
Name (PCHX, 0x04)
Scope (_SB)
{
Method (PWAK, 1, NotSerialized)
{
If ((Arg0 == 0x03))
{
S23W ()
}
}

Name (HDAA, One)
Name (DISA, One)
Name (CIWF, One)
Name (CIBT, One)
Name (S23C, Zero)
Method (S23W, 0, NotSerialized)
{
HDAA = One
DISA = One
CIWF = One
CIBT = One
}

Method (DION, 0, NotSerialized)
{
S023 (One, One)
}

Method (DIOF, 0, NotSerialized)
{
S023 (One, Zero)
}

Method (S023, 2, Serialized)
{
}

Device (PRRE)
{
Name (_HID, EisaId ("PNP0C02") /* PNP Motherboard Resources */) // _HID: Hardware ID
Name (_UID, "PCHRESV") // _UID: Unique ID
Name (_STA, 0x08) // _STA: Status
Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings
{
Name (BUF0, ResourceTemplate ()
{
Memory32Fixed (ReadWrite,
0xFE000000, // Address Base
0x00020000, // Address Length
)
Memory32Fixed (ReadWrite,
0xFE04C000, // Address Base
0x00004000, // Address Length
)
Memory32Fixed (ReadWrite,
0xFE050000, // Address Base
0x00060000, // Address Length
)
Memory32Fixed (ReadWrite,
0xFE0D0000, // Address Base
0x00030000, // Address Length
)
Memory32Fixed (ReadWrite,
0xFE200000, // Address Base
0x00600000, // Address Length
)
Memory32Fixed (ReadOnly,
0xFF000000, // Address Base
0x01000000, // Address Length
)
IO (Decode16,
0x0000, // Range Minimum
0x0000, // Range Maximum
0x01, // Alignment
0xFF, // Length
_Y21)
})
CreateWordField (BUF0, \_SB.PRRE._CRS._Y21._MIN, AMIN) // _MIN: Minimum Base Address
CreateWordField (BUF0, \_SB.PRRE._CRS._Y21._MAX, AMAX) // _MAX: Maximum Base Address
AMIN = PMBS /* \PMBS */
AMAX = PMBS /* \PMBS */
Name (SBR0, ResourceTemplate ()
{
Memory32Fixed (ReadWrite,
0x00000000, // Address Base
0x00690000, // Address Length
_Y22)
})
CreateDWordField (SBR0, \_SB.PRRE._CRS._Y22._BAS, BAS0) // _BAS: Base Address
BAS0 = SBRG /* \SBRG */
ConcatenateResTemplate (BUF0, SBR0, Local0)
If (((PCHS == PCHH) || (PCHS == 0x04)))
{
Name (SBRS, ResourceTemplate ()
{
Memory32Fixed (ReadWrite,
0x00000000, // Address Base
0x00000000, // Address Length
_Y23)
})
CreateDWordField (SBRS, \_SB.PRRE._CRS._Y23._BAS, BAS1) // _BAS: Base Address
CreateDWordField (SBRS, \_SB.PRRE._CRS._Y23._LEN, LEN1) // _LEN: Length
BAS1 = (SBRG + 0x006C0000)
LEN1 = 0x00010000
ConcatenateResTemplate (Local0, SBRS, Local1)
}
Else
{
Name (SBRL, ResourceTemplate ()
{
Memory32Fixed (ReadWrite,
0x00000000, // Address Base
0x00000000, // Address Length
_Y24)
})
CreateDWordField (SBRL, \_SB.PRRE._CRS._Y24._BAS, BAS2) // _BAS: Base Address
CreateDWordField (SBRL, \_SB.PRRE._CRS._Y24._LEN, LEN2) // _LEN: Length
BAS2 = (SBRG + 0x006B0000)
LEN2 = 0x00020000
ConcatenateResTemplate (Local0, SBRL, Local1)
}

Name (SBRE, ResourceTemplate ()
{
Memory32Fixed (ReadWrite,
0x00000000, // Address Base
0x00000000, // Address Length
_Y25)
})
CreateDWordField (SBRE, \_SB.PRRE._CRS._Y25._BAS, BAS3) // _BAS: Base Address
CreateDWordField (SBRE, \_SB.PRRE._CRS._Y25._LEN, LEN3) // _LEN: Length
BAS3 = (SBRG + 0x006F0000)
If ((PCHS == 0x04))
{
LEN3 = ((SBRG + 0x10000000) - BAS3)
}
Else
{
LEN3 = ((SBRG + 0x01000000) - BAS3)
}

ConcatenateResTemplate (Local1, SBRE, Local2)
Return (Local2)
}
}

Device (IOTR)
{
Name (_HID, EisaId ("PNP0C02") /* PNP Motherboard Resources */) // _HID: Hardware ID
Name (_UID, "IoTraps") // _UID: Unique ID
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings
{
Name (BUF0, ResourceTemplate ()
{
IO (Decode16,
0x0000, // Range Minimum
0x0000, // Range Maximum
0x01, // Alignment
0xFF, // Length
_Y26)
})
Name (BUF1, ResourceTemplate ()
{
IO (Decode16,
0x0000, // Range Minimum
0x0000, // Range Maximum
0x01, // Alignment
0xFF, // Length
_Y27)
})
Name (BUF2, ResourceTemplate ()
{
IO (Decode16,
0x0000, // Range Minimum
0x0000, // Range Maximum
0x01, // Alignment
0xFF, // Length
_Y28)
})
Name (BUF3, ResourceTemplate ()
{
IO (Decode16,
0x0000, // Range Minimum
0x0000, // Range Maximum
0x01, // Alignment
0xFF, // Length
_Y29)
})
CreateWordField (BUF0, \_SB.IOTR._CRS._Y26._MIN, AMI0) // _MIN: Minimum Base Address
CreateWordField (BUF0, \_SB.IOTR._CRS._Y26._MAX, AMA0) // _MAX: Maximum Base Address
CreateWordField (BUF1, \_SB.IOTR._CRS._Y27._MIN, AMI1) // _MIN: Minimum Base Address
CreateWordField (BUF1, \_SB.IOTR._CRS._Y27._MAX, AMA1) // _MAX: Maximum Base Address
CreateWordField (BUF2, \_SB.IOTR._CRS._Y28._MIN, AMI2) // _MIN: Minimum Base Address
CreateWordField (BUF2, \_SB.IOTR._CRS._Y28._MAX, AMA2) // _MAX: Maximum Base Address
CreateWordField (BUF3, \_SB.IOTR._CRS._Y29._MIN, AMI3) // _MIN: Minimum Base Address
CreateWordField (BUF3, \_SB.IOTR._CRS._Y29._MAX, AMA3) // _MAX: Maximum Base Address
Local2 = Zero
If ((ITS0 == One))
{
AMI0 = ITA0 /* \ITA0 */
AMA0 = ITA0 /* \ITA0 */
Local0 = BUF0 /* \_SB_.IOTR._CRS.BUF0 */
Local2 = One
}

If ((ITS1 == One))
{
AMI1 = ITA1 /* \ITA1 */
AMA1 = ITA1 /* \ITA1 */
If ((Local2 == One))
{
ConcatenateResTemplate (BUF1, Local0, Local1)
Local0 = Local1
}
Else
{
Local0 = BUF1 /* \_SB_.IOTR._CRS.BUF1 */
Local2 = One
}
}

If ((ITS2 == One))
{
AMI2 = ITA2 /* \ITA2 */
AMA2 = ITA2 /* \ITA2 */
If ((Local2 == One))
{
ConcatenateResTemplate (BUF2, Local0, Local1)
Local0 = Local1
}
Else
{
Local0 = BUF2 /* \_SB_.IOTR._CRS.BUF2 */
Local2 = One
}
}

If ((ITS3 == One))
{
AMI3 = ITA3 /* \ITA3 */
AMA3 = ITA3 /* \ITA3 */
If ((Local2 == One))
{
ConcatenateResTemplate (BUF3, Local0, Local1)
Local0 = Local1
}
Else
{
Local0 = BUF3 /* \_SB_.IOTR._CRS.BUF3 */
Local2 = One
}
}

If ((Local2 == One))
{
Return (Local0)
}
Else
{
Return (Buffer (0x02)
{
0x79, 0x00 // y.
})
}
}
}
}

Scope (_SB.PC00)
{
Name (TEMP, Zero)
Device (LPCB)
{
Name (_ADR, 0x001F0000) // _ADR: Address
Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If (PCIC (Arg0))
{
Return (PCID (Arg0, Arg1, Arg2, Arg3))
}

Return (Buffer (One)
{
0x00 // .
})
}

OperationRegion (LPC, PCI_Config, Zero, 0x0100)
Field (LPC, AnyAcc, NoLock, Preserve)
{
Offset (0x02),
CDID, 16,
Offset (0x08),
CRID, 8,
Offset (0x80),
IOD0, 8,
IOD1, 8,
Offset (0xA0),
, 9,
PRBL, 1,
Offset (0xDC),
, 2,
ESPI, 1
}
}

Device (SBUS)
{
Name (_ADR, 0x001F0004) // _ADR: Address
Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If (PCIC (Arg0))
{
Return (PCID (Arg0, Arg1, Arg2, Arg3))
}

Return (Buffer (One)
{
0x00 // .
})
}
}
}

Scope (\)
{
Name (TMOV, 0x0A)
Method (TMVA, 1, Serialized)
{
TMOV = 0x0A
If ((Arg0 > 0x0A))
{
TMOV = Arg0
}
}

Method (IPCS, 7, Serialized)
{
Name (RPKG, Package (0x05)
{
Zero,
Zero,
Zero,
Zero,
Zero
})
If ((Arg2 > 0x10))
{
RPKG [Zero] = One
Return (RPKG) /* \IPCS.RPKG */
}

IWB0 = Arg3
IWB1 = Arg4
IWB2 = Arg5
IWB3 = Arg6
Local0 = Zero
Local0 += (Arg0 << Zero)
Local0 += (Arg1 << 0x0C)
Local0 += (Arg2 << 0x10)
CMDR = Local0
Local0 = Zero
Local1 = TMOV /* \TMOV */
While (One)
{
If ((!IBSY || (IERR == One)))
{
Break
}

If ((Local0 > Local1))
{
RPKG [Zero] = 0x03
Return (RPKG) /* \IPCS.RPKG */
}

Sleep (One)
Local0++
}

If ((IERR == One))
{
RPKG [Zero] = 0x02
Return (RPKG) /* \IPCS.RPKG */
}

RPKG [One] = IRB0 /* \IRB0 */
RPKG [0x02] = IRB1 /* \IRB1 */
RPKG [0x03] = IRB2 /* \IRB2 */
RPKG [0x04] = IRB3 /* \IRB3 */
Return (RPKG) /* \IPCS.RPKG */
}

Method (ULTR, 1, Serialized)
{
LTRU = Arg0
}

Method (TCBS, 0, NotSerialized)
{
Return (TCOB) /* \TCOB */
}

OperationRegion (PMIO, SystemIO, PMBS, 0x80)
Field (PMIO, ByteAcc, NoLock, Preserve)
{
Offset (0x01),
PBSS, 1,
Offset (0x40),
, 17,
GPEC, 1,
Offset (0x6C),
, 19,
CPWS, 1,
Offset (0x7C),
, 18,
WAEN, 1,
CPWE, 1
}

OperationRegion (TCBA, SystemIO, TCBS (), 0x10)
Field (TCBA, ByteAcc, NoLock, Preserve)
{
Offset (0x04),
, 9,
CPSC, 1
}

OperationRegion (PWMR, SystemMemory, PWRM, 0x1E30)
Field (PWMR, DWordAcc, NoLock, Preserve)
{
CMDR, 32,
IBSY, 1,
IERR, 1,
, 1,
, 1,
Offset (0x05),
Offset (0x06),
IERC, 8,
Offset (0x08),
Offset (0x80),
IWB0, 32,
IWB1, 32,
IWB2, 32,
IWB3, 32,
IRB0, 32,
IRB1, 32,
IRB2, 32,
IRB3, 32,
Offset (0x10D0),
RAA0, 1,
RAA1, 1,
RAA2, 1,
RAA3, 1,
RPB0, 1,
RPB1, 1,
RPB2, 1,
RPB3, 1,
RPC0, 1,
RPC1, 1,
RPC2, 1,
RPC3, 1,
RSAT, 1,
RGBE, 1,
RXHC, 1,
RXDC, 1,
RUFS, 1,
RPD0, 1,
RPD1, 1,
RPD2, 1,
RPD3, 1,
RPE0, 1,
RPE1, 1,
RPE2, 1,
RPE3, 1,
Offset (0x10D4),
APA0, 1,
APA1, 1,
APA2, 1,
APA3, 1,
APB0, 1,
APB1, 1,
APB2, 1,
APB3, 1,
APC0, 1,
APC1, 1,
APC2, 1,
APC3, 1,
ASAT, 1,
AGBE, 1,
AXHC, 1,
AXDC, 1,
AUFS, 1,
APD0, 1,
APD1, 1,
APD2, 1,
APD3, 1,
APE0, 1,
APE1, 1,
APE2, 1,
APE3, 1,
Offset (0x1800),
ACWA, 32,
DCWA, 32,
ACET, 32,
DCET, 32,
Offset (0x18E8),
, 31,
CECE, 1,
Offset (0x1B0C),
, 2,
ISAT, 1,
, 18,
LTRU, 1,
Offset (0x1B1C),
, 22,
XSQD, 1,
Offset (0x1BD0),
, 31,
CPPM, 1,
Offset (0x1E20),
GBED, 1,
Offset (0x1E28),
, 22,
SCFD, 1
}

Method (PSOC, 1, Serialized)
{
If (PSON)
{
If (Arg0)
{
CECE = One
}
Else
{
CECE = Zero
}
}
}

Method (PSOS, 0, NotSerialized)
{
If (CECE)
{
Return (One)
}
Else
{
Return (Zero)
}
}

Method (CFAE, 1, NotSerialized)
{
If (DerefOf (Arg0 [Zero]))
{
ADBG ("CPPM Forced Alignment Disable")
CPPM = Zero
Return (Buffer (One)
{
0x00 // .
})
}
Else
{
ADBG ("CPPM Forced Alignment Enable")
CPPM = One
Return (Buffer (One)
{
0x00 // .
})
}
}

Method (IMPS, 0, NotSerialized)
{
If ((PCHS == 0x04))
{
Return (Zero)
}
Else
{
Return (One)
}
}
}

Scope (_SB.PC00)
{
Name (LTEN, Zero)
Name (LMSL, Zero)
Name (LNSL, Zero)
}

If ((GBES != Zero))
{
Scope (_SB.PC00)
{
Device (GLAN)
{
Name (_ADR, 0x001F0006) // _ADR: Address
Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If (PCIC (Arg0))
{
Return (PCID (Arg0, Arg1, Arg2, Arg3))
}

Return (Buffer (One)
{
0x00 // .
})
}

Name (_S0W, 0x03) // _S0W: S0 Device Wake State
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake
{
Return (GPRW (0x6D, 0x03))
}

OperationRegion (LANR, PCI_Config, Zero, 0x0100)
Field (LANR, ByteAcc, NoLock, Preserve)
{
DVID, 16,
Offset (0xCC),
Offset (0xCD),
PMEE, 1,
, 6,
PMES, 1
}

Method (GPEH, 0, NotSerialized)
{
If ((DVID == 0xFFFF))
{
Return (Zero)
}

If ((PMES == One))
{
Notify (GLAN, 0x02) // Device Wake
}
}

Method (_DSW, 3, NotSerialized) // _DSW: Device Sleep Wake
{
}
}
}
}

Scope (_SB.PC00)
{
Device (XHCI)
{
Name (_ADR, 0x00140000) // _ADR: Address
OperationRegion (XPRT, PCI_Config, Zero, 0x0100)
Field (XPRT, AnyAcc, NoLock, Preserve)
{
DVID, 16,
Offset (0x10),
XADL, 32,
XADH, 32,
Offset (0x74),
Offset (0x75),
PMEE, 1,
, 6,
PMES, 1,
Offset (0xA2),
, 2,
D3HE, 1
}

Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
ADBG ("XHCI _DSM")
If (PCIC (Arg0))
{
Return (PCID (Arg0, Arg1, Arg2, Arg3))
}

Return (Buffer (One)
{
0x00 // .
})
}

Method (_S3D, 0, NotSerialized) // _S3D: S3 Device State
{
Return (0x03)
}

Method (_S4D, 0, NotSerialized) // _S4D: S4 Device State
{
Return (0x03)
}

Method (_S3W, 0, NotSerialized) // _S3W: S3 Device Wake State
{
Return (0x03)
}

Method (_S4W, 0, NotSerialized) // _S4W: S4 Device Wake State
{
Return (0x03)
}

Method (_S0W, 0, NotSerialized) // _S0W: S0 Device Wake State
{
Return (0x03)
}

Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake
{
If (CondRefOf (DUWS))
{
Return (GPRW (0x6D, DUWS))
}
Else
{
Return (GPRW (0x6D, 0x03))
}
}

Method (GPEH, 0, NotSerialized)
{
If ((DVID == 0xFFFF))
{
Return (Zero)
}

If ((PMES == One))
{
Notify (XHCI, 0x02) // Device Wake
}
}

Method (_DSW, 3, NotSerialized) // _DSW: Device Sleep Wake
{
}

Method (_INI, 0, NotSerialized) // _INI: Initialize
{
If (CondRefOf (\_SB.PC00.XHCI.RHUB.INIR))
{
^RHUB.INIR ()
}
}

Method (USRA, 1, Serialized)
{
Return ((PU2C + Arg0))
}

Method (SSPA, 1, Serialized)
{
Return ((PU2C + (0x02 + Arg0)))
}

Method (_PS0, 0, Serialized) // _PS0: Power State 0
{
ADBG ("XHCI D0")
If ((DVID == 0xFFFF))
{
Return (Zero)
}

If (CondRefOf (\_SB.PC00.XHCI.PS0X))
{
PS0X ()
}
}

Method (_PS3, 0, Serialized) // _PS3: Power State 3
{
ADBG ("XHCI D3")
If ((DVID == 0xFFFF))
{
Return (Zero)
}

If (CondRefOf (\_SB.PC00.XHCI.PS3X))
{
PS3X ()
}
}

Method (CUID, 1, Serialized)
{
If ((Arg0 == ToUUID ("7c9512a9-1705-4cb4-af7d-506a2423ab71") /* Unknown UUID */))
{
Return (One)
}

Return (Zero)
}

Device (RHUB)
{
Name (_ADR, Zero) // _ADR: Address
Method (_PS0, 0, Serialized) // _PS0: Power State 0
{
ADBG ("XHCI RHUB PS0")
If ((DVID == 0xFFFF))
{
Return (Zero)
}

If (CondRefOf (\_SB.PC00.XHCI.RHUB.PS0X))
{
ADBG ("XHCI CSD0")
CSD0 (0x16)
PS0X ()
}
}

Method (_PS2, 0, Serialized) // _PS2: Power State 2
{
ADBG ("XHCI RHUB PS2")
If ((DVID == 0xFFFF))
{
Return (Zero)
}

If (CondRefOf (\_SB.PC00.XHCI.RHUB.PS2X))
{
PS2X ()
ADBG ("XHCI CSD3")
CSD3 (0x16)
}
}

Method (_PS3, 0, Serialized) // _PS3: Power State 3
{
ADBG ("XHCI RHUB PS3")
If ((DVID == 0xFFFF))
{
Return (Zero)
}

If (CondRefOf (\_SB.PC00.XHCI.RHUB.PS3X))
{
PS3X ()
ADBG ("XHCI CSD3")
CSD3 (0x16)
}
}
}
}
}

If (CondRefOf (PU2C))
{
Scope (_SB.PC00.XHCI.RHUB)
{
If ((One <= PU2C))
{
Device (HS01)
{
Name (_ADR, One) // _ADR: Address
Name (_UPC, Package (0x04) // _UPC: USB Port Capabilities
{
0xFF,
Zero,
Zero,
Zero
})
Name (_PLD, Package (0x01) // _PLD: Physical Location of Device
{
ToPLD (
PLD_Revision = 0x2,
PLD_IgnoreColor = 0x1,
PLD_Red = 0x0,
PLD_Green = 0x0,
PLD_Blue = 0x0,
PLD_Width = 0x0,
PLD_Height = 0x0,
PLD_UserVisible = 0x1,
PLD_Dock = 0x0,
PLD_Lid = 0x0,
PLD_Panel = "UNKNOWN",
PLD_VerticalPosition = "UPPER",
PLD_HorizontalPosition = "LEFT",
PLD_Shape = "UNKNOWN",
PLD_GroupOrientation = 0x0,
PLD_GroupToken = 0x0,
PLD_GroupPosition = 0x1,
PLD_Bay = 0x0,
PLD_Ejectable = 0x0,
PLD_EjectRequired = 0x0,
PLD_CabinetNumber = 0x0,
PLD_CardCageNumber = 0x0,
PLD_Reference = 0x0,
PLD_Rotation = 0x0,
PLD_Order = 0x0)

})
}
}

If ((0x02 <= PU2C))
{
Device (HS02)
{
Name (_ADR, 0x02) // _ADR: Address
Name (_UPC, Package (0x04) // _UPC: USB Port Capabilities
{
0xFF,
0x0A,
Zero,
Zero
})
Name (_PLD, Package (0x01) // _PLD: Physical Location of Device
{
ToPLD (
PLD_Revision = 0x2,
PLD_IgnoreColor = 0x1,
PLD_Red = 0x0,
PLD_Green = 0x0,
PLD_Blue = 0x0,
PLD_Width = 0x0,
PLD_Height = 0x0,
PLD_UserVisible = 0x1,
PLD_Dock = 0x0,
PLD_Lid = 0x0,
PLD_Panel = "UNKNOWN",
PLD_VerticalPosition = "UPPER",
PLD_HorizontalPosition = "LEFT",
PLD_Shape = "UNKNOWN",
PLD_GroupOrientation = 0x0,
PLD_GroupToken = 0x0,
PLD_GroupPosition = 0x2,
PLD_Bay = 0x0,
PLD_Ejectable = 0x0,
PLD_EjectRequired = 0x0,
PLD_CabinetNumber = 0x0,
PLD_CardCageNumber = 0x0,
PLD_Reference = 0x0,
PLD_Rotation = 0x0,
PLD_Order = 0x0)

})
}
}

If ((0x03 <= PU2C))
{
Device (HS03)
{
Name (_ADR, 0x03) // _ADR: Address
Name (_UPC, Package (0x04) // _UPC: USB Port Capabilities
{
Zero,
Zero,
Zero,
Zero
})
}
}

If ((0x04 <= PU2C))
{
Device (HS04)
{
Name (_ADR, 0x04) // _ADR: Address
Name (_UPC, Package (0x04) // _UPC: USB Port Capabilities
{
Zero,
Zero,
Zero,
Zero
})
}
}

If ((0x05 <= PU2C))
{
Device (HS05)
{
Name (_ADR, 0x05) // _ADR: Address
Name (_UPC, Package (0x04) // _UPC: USB Port Capabilities
{
Zero,
Zero,
Zero,
Zero
})
}
}

If ((0x06 <= PU2C))
{
Device (HS06)
{
Name (_ADR, 0x06) // _ADR: Address
Name (_UPC, Package (0x04) // _UPC: USB Port Capabilities
{
0xFF,
0xFF,
Zero,
Zero
})
Name (_PLD, Package (0x01) // _PLD: Physical Location of Device
{
ToPLD (
PLD_Revision = 0x2,
PLD_IgnoreColor = 0x1,
PLD_Red = 0x0,
PLD_Green = 0x0,
PLD_Blue = 0x0,
PLD_Width = 0x0,
PLD_Height = 0x0,
PLD_UserVisible = 0x0,
PLD_Dock = 0x0,
PLD_Lid = 0x0,
PLD_Panel = "UNKNOWN",
PLD_VerticalPosition = "UPPER",
PLD_HorizontalPosition = "LEFT",
PLD_Shape = "VERTICALRECTANGLE",
PLD_GroupOrientation = 0x0,
PLD_GroupToken = 0x0,
PLD_GroupPosition = 0x3,
PLD_Bay = 0x0,
PLD_Ejectable = 0x0,
PLD_EjectRequired = 0x0,
PLD_CabinetNumber = 0x0,
PLD_CardCageNumber = 0x0,
PLD_Reference = 0x0,
PLD_Rotation = 0x0,
PLD_Order = 0x0)

})
}
}

If ((0x07 <= PU2C))
{
Device (HS07)
{
Name (_ADR, 0x07) // _ADR: Address
Name (_UPC, Package (0x04) // _UPC: USB Port Capabilities
{
Zero,
Zero,
Zero,
Zero
})
}
}

If ((0x08 <= PU2C))
{
Device (HS08)
{
Name (_ADR, 0x08) // _ADR: Address
Name (_UPC, Package (0x04) // _UPC: USB Port Capabilities
{
0xFF,
0xFF,
Zero,
Zero
})
Name (_PLD, Package (0x01) // _PLD: Physical Location of Device
{
ToPLD (
PLD_Revision = 0x2,
PLD_IgnoreColor = 0x1,
PLD_Red = 0x0,
PLD_Green = 0x0,
PLD_Blue = 0x0,
PLD_Width = 0x0,
PLD_Height = 0x0,
PLD_UserVisible = 0x0,
PLD_Dock = 0x0,
PLD_Lid = 0x1,
PLD_Panel = "FRONT",
PLD_VerticalPosition = "UPPER",
PLD_HorizontalPosition = "CENTER",
PLD_Shape = "ROUND",
PLD_GroupOrientation = 0x0,
PLD_GroupToken = 0x0,
PLD_GroupPosition = 0x4,
PLD_Bay = 0x0,
PLD_Ejectable = 0x0,
PLD_EjectRequired = 0x0,
PLD_CabinetNumber = 0x0,
PLD_CardCageNumber = 0x0,
PLD_Reference = 0x0,
PLD_Rotation = 0x0,
PLD_Order = 0x0,
PLD_VerticalOffset = 0xC3,
PLD_HorizontalOffset = 0xC3)

})
Device (CAMA)
{
Name (_ADR, 0x08) // _ADR: Address
Name (_UPC, Package (0x04) // _UPC: USB Port Capabilities
{
0xFF,
0xFF,
Zero,
Zero
})
Name (_PLD, Package (0x01) // _PLD: Physical Location of Device
{
ToPLD (
PLD_Revision = 0x2,
PLD_IgnoreColor = 0x1,
PLD_Red = 0x0,
PLD_Green = 0x0,
PLD_Blue = 0x0,
PLD_Width = 0x0,
PLD_Height = 0x0,
PLD_UserVisible = 0x0,
PLD_Dock = 0x0,
PLD_Lid = 0x1,
PLD_Panel = "FRONT",
PLD_VerticalPosition = "UPPER",
PLD_HorizontalPosition = "CENTER",
PLD_Shape = "ROUND",
PLD_GroupOrientation = 0x0,
PLD_GroupToken = 0x0,
PLD_GroupPosition = 0x4,
PLD_Bay = 0x0,
PLD_Ejectable = 0x0,
PLD_EjectRequired = 0x0,
PLD_CabinetNumber = 0x0,
PLD_CardCageNumber = 0x0,
PLD_Reference = 0x0,
PLD_Rotation = 0x0,
PLD_Order = 0x0,
PLD_VerticalOffset = 0xC3,
PLD_HorizontalOffset = 0xC3)

})
}
}
}

If ((0x09 <= PU2C))
{
Device (HS09)
{
Name (_ADR, 0x09) // _ADR: Address
Name (_UPC, Package (0x04) // _UPC: USB Port Capabilities
{
0xFF,
0x03,
Zero,
Zero
})
Name (_PLD, Package (0x01) // _PLD: Physical Location of Device
{
ToPLD (
PLD_Revision = 0x2,
PLD_IgnoreColor = 0x1,
PLD_Red = 0x0,
PLD_Green = 0x0,
PLD_Blue = 0x0,
PLD_Width = 0x0,
PLD_Height = 0x0,
PLD_UserVisible = 0x1,
PLD_Dock = 0x0,
PLD_Lid = 0x0,
PLD_Panel = "UNKNOWN",
PLD_VerticalPosition = "UPPER",
PLD_HorizontalPosition = "LEFT",
PLD_Shape = "UNKNOWN",
PLD_GroupOrientation = 0x0,
PLD_GroupToken = 0x0,
PLD_GroupPosition = 0x5,
PLD_Bay = 0x0,
PLD_Ejectable = 0x0,
PLD_EjectRequired = 0x0,
PLD_CabinetNumber = 0x0,
PLD_CardCageNumber = 0x0,
PLD_Reference = 0x0,
PLD_Rotation = 0x0,
PLD_Order = 0x0)

})
}
}

If ((0x0A <= PU2C))
{
Device (HS10)
{
Name (_ADR, 0x0A) // _ADR: Address
Name (_UPC, Package (0x04) // _UPC: USB Port Capabilities
{
0xFF,
0xFF,
Zero,
Zero
})
Name (_PLD, Package (0x01) // _PLD: Physical Location of Device
{
ToPLD (
PLD_Revision = 0x2,
PLD_IgnoreColor = 0x1,
PLD_Red = 0x0,
PLD_Green = 0x0,
PLD_Blue = 0x0,
PLD_Width = 0x0,
PLD_Height = 0x0,
PLD_UserVisible = 0x0,
PLD_Dock = 0x0,
PLD_Lid = 0x0,
PLD_Panel = "RIGHT",
PLD_VerticalPosition = "CENTER",
PLD_HorizontalPosition = "RIGHT",
PLD_Shape = "UNKNOWN",
PLD_GroupOrientation = 0x0,
PLD_GroupToken = 0x0,
PLD_GroupPosition = 0x6,
PLD_Bay = 0x0,
PLD_Ejectable = 0x0,
PLD_EjectRequired = 0x0,
PLD_CabinetNumber = 0x0,
PLD_CardCageNumber = 0x0,
PLD_Reference = 0x0,
PLD_Rotation = 0x0,
PLD_Order = 0x0)

})
Method (_S3D, 0, NotSerialized) // _S3D: S3 Device State
{
Return (0x03)
}

Method (_S4D, 0, NotSerialized) // _S4D: S4 Device State
{
Return (0x03)
}
}
}

If ((0x0B <= PU2C))
{
Device (HS11)
{
Name (_ADR, 0x0B) // _ADR: Address
Name (_UPC, Package (0x04) // _UPC: USB Port Capabilities
{
Zero,
Zero,
Zero,
Zero
})
}
}

If ((0x0C <= PU2C))
{
Device (HS12)
{
Name (_ADR, 0x0C) // _ADR: Address
Name (_UPC, Package (0x04) // _UPC: USB Port Capabilities
{
Zero,
Zero,
Zero,
Zero
})
}
}

If ((0x0D <= PU2C))
{
Device (HS13)
{
Name (_ADR, 0x0D) // _ADR: Address
Name (_UPC, Package (0x04) // _UPC: USB Port Capabilities
{
Zero,
Zero,
Zero,
Zero
})
}
}

If ((0x0E <= PU2C))
{
Device (HS14)
{
Name (_ADR, 0x0E) // _ADR: Address
Name (_UPC, Package (0x04) // _UPC: USB Port Capabilities
{
Zero,
Zero,
Zero,
Zero
})
}
}
}
}

If (CondRefOf (PU3C))
{
Scope (_SB.PC00.XHCI.RHUB)
{
If ((One <= PU3C))
{
Device (SS01)
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
Return (SSPA (One))
}

Name (_UPC, Package (0x04) // _UPC: USB Port Capabilities
{
0xFF,
0x03,
Zero,
Zero
})
Name (_PLD, Package (0x01) // _PLD: Physical Location of Device
{
ToPLD (
PLD_Revision = 0x2,
PLD_IgnoreColor = 0x1,
PLD_Red = 0x0,
PLD_Green = 0x0,
PLD_Blue = 0x0,
PLD_Width = 0x0,
PLD_Height = 0x0,
PLD_UserVisible = 0x1,
PLD_Dock = 0x0,
PLD_Lid = 0x0,
PLD_Panel = "UNKNOWN",
PLD_VerticalPosition = "UPPER",
PLD_HorizontalPosition = "LEFT",
PLD_Shape = "UNKNOWN",
PLD_GroupOrientation = 0x0,
PLD_GroupToken = 0x0,
PLD_GroupPosition = 0x5,
PLD_Bay = 0x0,
PLD_Ejectable = 0x0,
PLD_EjectRequired = 0x0,
PLD_CabinetNumber = 0x0,
PLD_CardCageNumber = 0x0,
PLD_Reference = 0x0,
PLD_Rotation = 0x0,
PLD_Order = 0x0)

})
}
}

If ((0x02 <= PU3C))
{
Device (SS02)
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
Return (SSPA (0x02))
}

Name (_UPC, Package (0x04) // _UPC: USB Port Capabilities
{
Zero,
Zero,
Zero,
Zero
})
}
}

If ((0x03 <= PU3C))
{
Device (SS03)
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
Return (SSPA (0x03))
}

Name (_UPC, Package (0x04) // _UPC: USB Port Capabilities
{
Zero,
Zero,
Zero,
Zero
})
}
}

If ((0x04 <= PU3C))
{
Device (SS04)
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
Return (SSPA (0x04))
}

Name (_UPC, Package (0x04) // _UPC: USB Port Capabilities
{
Zero,
Zero,
Zero,
Zero
})
}
}

If ((0x05 <= PU3C))
{
Device (SS05)
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
Return (SSPA (0x05))
}

Name (_UPC, Package (0x04) // _UPC: USB Port Capabilities
{
Zero,
Zero,
Zero,
Zero
})
}
}

If ((0x06 <= PU3C))
{
Device (SS06)
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
Return (SSPA (0x06))
}

Name (_UPC, Package (0x04) // _UPC: USB Port Capabilities
{
Zero,
Zero,
Zero,
Zero
})
}
}

If ((0x07 <= PU3C))
{
Device (SS07)
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
Return (SSPA (0x07))
}

Name (_UPC, Package (0x04) // _UPC: USB Port Capabilities
{
Zero,
Zero,
Zero,
Zero
})
}
}

If ((0x08 <= PU3C))
{
Device (SS08)
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
Return (SSPA (0x08))
}

Name (_UPC, Package (0x04) // _UPC: USB Port Capabilities
{
Zero,
Zero,
Zero,
Zero
})
}
}

If ((0x09 <= PU3C))
{
Device (SS09)
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
Return (SSPA (0x09))
}

Name (_UPC, Package (0x04) // _UPC: USB Port Capabilities
{
Zero,
Zero,
Zero,
Zero
})
}
}

If ((0x0A <= PU3C))
{
Device (SS10)
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
Return (SSPA (0x0A))
}

Name (_UPC, Package (0x04) // _UPC: USB Port Capabilities
{
Zero,
Zero,
Zero,
Zero
})
}
}
}
}

Scope (_SB.PC00)
{
Device (XDCI)
{
Name (_ADR, 0x00140001) // _ADR: Address
OperationRegion (OTGD, PCI_Config, Zero, 0x0100)
Field (OTGD, DWordAcc, NoLock, Preserve)
{
DVID, 16,
Offset (0x10),
XDCB, 64
}

Field (OTGD, ByteAcc, NoLock, Preserve)
{
Offset (0x84),
D0I3, 2,
Offset (0x85),
PMEE, 1,
, 6,
PMES, 1
}

Method (XDBA, 0, NotSerialized)
{
Return ((XDCB & 0xFFFFFFFFFFFFFF00))
}

Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If (PCIC (Arg0))
{
Return (PCID (Arg0, Arg1, Arg2, Arg3))
}

ADBG ("XDCI DSM")
If ((Arg0 == ToUUID ("732b85d5-b7a7-4a1b-9ba0-4bbd00ffd511") /* Unknown UUID */))
{
If ((Arg1 == One))
{
Method (SPPS, 2, Serialized)
{
OperationRegion (XDBW, SystemMemory, XDBA (), 0x00110000)
Field (XDBW, WordAcc, NoLock, Preserve)
{
Offset (0x10F810),
Offset (0x10F811),
U2CP, 2,
U3CP, 2,
Offset (0x10F818),
PUPS, 2,
, 1,
PURC, 1,
Offset (0x10F81A),
Offset (0x10F81C),
, 3,
UXPE, 2,
Offset (0x10F81E)
}

Local1 = Arg0
Local2 = Arg1
If ((Local1 == Zero))
{
ADBG ("PMU D0")
UXPE = Zero
Local0 = Zero
While ((Local0 < 0x0A))
{
Stall (0x64)
Local0++
}

PUPS = Zero
Local0 = Zero
While ((Local0 < 0x07D0))
{
Stall (0x64)
If (((U2CP == Zero) && (U3CP == Zero)))
{
Break
}

Local0++
}

If ((U2CP != Zero))
{
ADBG ("U2 not in D0")
}

If ((U3CP != Zero))
{
ADBG ("U3 not in D0")
}

Return (Zero)
}

If ((Local1 == 0x03))
{
ADBG ("PMU D3")
If ((U2CP != Zero))
{
ADBG ("U2 not in D0")
}

If ((U3CP != Zero))
{
ADBG ("U3 not in D0")
}

PUPS = 0x03
Local0 = Zero
While ((Local0 < 0x07D0))
{
Stall (0x64)
If (((U2CP == 0x03) && (U3CP == 0x03)))
{
Break
}

Local0++
}

If ((U2CP != 0x03))
{
ADBG ("U2 not in D3")
}

If ((U3CP != 0x03))
{
ADBG ("U3 not in D3")
}

UXPE = Local2
Return (Zero)
}

Return (Zero)
}

Switch (ToInteger (Arg2))
{
Case (Zero)
{
ADBG ("XDCI Fn0")
Return (Buffer (0x02)
{
0xB3, 0x03 // ..
})
}
Case (One)
{
ADBG ("XDCI Fn1")
Return (One)
}
Case (0x04)
{
ADBG ("XDCI Fn4")
Local1 = DerefOf (Arg3 [Zero])
ADBG (Local1)
SPPS (Local1, Zero)
}
Case (0x05)
{
ADBG ("XDCI Fn5")
Return (Zero)
}
Case (0x07)
{
ADBG ("XDCI Fn7")
OperationRegion (XD22, SystemMemory, XDBA (), 0x00110000)
Field (XD22, WordAcc, NoLock, Preserve)
{
Offset (0x10F818),
P2PS, 2,
Offset (0x10F81A)
}

Local0 = P2PS /* \_SB_.PC00.XDCI._DSM.P2PS */
Return (Local0)
}
Case (0x08)
{
ADBG ("XDCI Fn8")
Return (One)
}
Case (0x09)
{
ADBG ("XDCI Fn9")
OperationRegion (XGCT, SystemMemory, XDBA (), 0x00110000)
Field (XGCT, WordAcc, NoLock, Preserve)
{
Offset (0xC110),
GCTL, 32
}

Local1 = (PPDS & 0xFFF80000)
Local1 >>= 0x13
ADBG (Concatenate ("PCH XDCI: Func9 Return Val = ", ToHexString (Local1)))
Return (Local1)
}

}
}
}

Return (Buffer (One)
{
0x00 // .
})
}

Name (_DDN, "ICL PCH XDCI controller") // _DDN: DOS Device Name
Name (_STR, Unicode ("ICL PCH XDCI controller")) // _STR: Description String
Method (_S0W, 0, NotSerialized) // _S0W: S0 Device Wake State
{
Return (0x03)
}

Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake
{
Return (GPRW (0x6D, 0x03))
}

Method (GPEH, 0, NotSerialized)
{
If ((DVID == 0xFFFF))
{
Return (Zero)
}

If ((PMES == One))
{
Notify (XDCI, 0x02) // Device Wake
}
}

Method (_DSW, 3, NotSerialized) // _DSW: Device Sleep Wake
{
}
}
}

Scope (_SB.PC00)
{
Device (HDAS)
{
Name (_ADR, 0x001F0003) // _ADR: Address
OperationRegion (HDAR, PCI_Config, Zero, 0x0100)
Field (HDAR, WordAcc, NoLock, Preserve)
{
VDID, 32,
Offset (0x54),
Offset (0x55),
PMEE, 1,
, 6,
PMES, 1
}

Name (_S0W, 0x03) // _S0W: S0 Device Wake State
Method (_DSW, 3, NotSerialized) // _DSW: Device Sleep Wake
{
}

Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake
{
Return (GPRW (0x6D, 0x03))
}

Method (GPEH, 0, NotSerialized)
{
If ((VDID == 0xFFFFFFFF))
{
Return (Zero)
}

If ((PMES == One))
{
Notify (HDAS, 0x02) // Device Wake
}
}

Method (_PS0, 0, Serialized) // _PS0: Power State 0
{
S023 (Zero, One)
If (CondRefOf (\_SB.PC00.HDAS.PS0X))
{
PS0X ()
}
}

Method (_PS3, 0, Serialized) // _PS3: Power State 3
{
S023 (Zero, Zero)
If (CondRefOf (\_SB.PC00.HDAS.PS3X))
{
PS3X ()
}
}

Name (NBUF, ResourceTemplate ()
{
QWordMemory (ResourceConsumer, PosDecode, MinNotFixed, MaxNotFixed, NonCacheable, ReadOnly,
0x0000000000000001, // Granularity
0x0000000000000000, // Range Minimum
0x0000000000000000, // Range Maximum
0x0000000000000000, // Translation Offset
0x0000000000000000, // Length
,, _Y2A, AddressRangeACPI, TypeStatic)
})
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
CreateQWordField (NBUF, \_SB.PC00.HDAS._Y2A._MIN, NBAS) // _MIN: Minimum Base Address
CreateQWordField (NBUF, \_SB.PC00.HDAS._Y2A._MAX, NMAS) // _MAX: Maximum Base Address
CreateQWordField (NBUF, \_SB.PC00.HDAS._Y2A._LEN, NLEN) // _LEN: Length
NBAS = NHLA /* \NHLA */
NMAS = (NHLA + (NHLL - One))
NLEN = NHLL /* \NHLL */
}

Name (_DSD, Package (0x02) // _DSD: Device-Specific Data
{
ToUUID ("daffd814-6eba-4d8c-8a91-bc9bbf4aa301") /* Device Properties for _DSD */,
Package (0x01)
{
Package (0x02)
{
"nhlt-version",
"1.8-0"
}
}
})
}

Scope (HDAS)
{
Device (IDA)
{
Name (_ADR, 0x10000000) // _ADR: Address
Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If (PCIC (Arg0))
{
Return (PCID (Arg0, Arg1, Arg2, Arg3))
}

If ((Arg0 == ToUUID ("a69f886e-6ceb-4594-a41f-7b5dce24c553") /* Unknown UUID */))
{
Switch (ToInteger (Arg2))
{
Case (Zero)
{
Return (Buffer (One)
{
0xCF // .
})
}
Case (One)
{
Return (NBUF) /* \_SB_.PC00.HDAS.NBUF */
}
Case (0x02)
{
Return (ADFM) /* \ADFM */
}
Case (0x03)
{
If (CondRefOf (\_SB.PC00.HDAS.PPMS))
{
Return (PPMS (Arg3))
}

Return (Zero)
}
Case (0x06)
{
Return (XTAL) /* \XTAL */
}
Case (0x07)
{
ADBG ("_DSM Fun 7 HDBO")
ADBG (HDBO)
Return (HDBO) /* \HDBO */
}
Default
{
Return (Buffer (One)
{
0x00 // .
})
}

}
}

If (CondRefOf (HIWC))
{
If (HIWC (Arg0))
{
If (CondRefOf (HIDW))
{
Return (HIDW (Arg0, Arg1, Arg2, Arg3))
}
}
}

Return (Buffer (One)
{
0x00 // .
})
}
}
}

Scope (HDAS.IDA)
{
Device (SNDW)
{
Name (_ADR, 0x40000000) // _ADR: Address
Name (_CID, Package (0x02) // _CID: Compatible ID
{
"PRP00001",
"PNP0A05" /* Generic Container Device */
})
Method (_STA, 0, NotSerialized) // _STA: Status
{
Return (0x0F)
}

Method (QCFG, 3, NotSerialized)
{
DerefOf (DerefOf (Arg0 [One]) [Zero]) [One]
= Arg1
DerefOf (DerefOf (Arg0 [One]) [0x04]) [One]
= Arg2
}

Method (XCFG, 2, NotSerialized)
{
If ((Arg1 == 0x016E3600))
{
Local0 = 0x016E3600
Local1 = 0x005B8D80
Local2 = 0x7D
Local3 = 0x02
}
ElseIf ((Arg1 == 0x0249F000))
{
Local0 = 0x0249F000
Local1 = 0x00493E00
Local2 = 0x32
Local3 = 0x04
}
ElseIf ((Arg1 == 0x0124F800))
{
Local0 = 0x0124F800
Local1 = 0x00493E00
Local2 = 0x32
Local3 = 0x04
}
Else
{
Local0 = Zero
Local1 = Zero
Local2 = Zero
Local3 = Zero
}

DerefOf (DerefOf (Arg0 [One]) [One]) [One]
= Local0
DerefOf (DerefOf (DerefOf (Arg0 [One]) [0x07]
) [One]) [Zero] = Local1
DerefOf (DerefOf (Arg0 [One]) [0x09]) [One]
= Local2
DerefOf (DerefOf (Arg0 [One]) [0x0A]) [One]
= Local3
}

Method (DCFG, 3, NotSerialized)
{
DerefOf (DerefOf (Arg0 [One]) [0x02]) [One]
= Arg1
DerefOf (DerefOf (Arg0 [One]) [0x03]) [One]
= Arg2
}

Method (SDWU, 1, NotSerialized)
{
DerefOf (DerefOf (_DSD [One]) [One]) [One]
= Arg0
}

Method (_INI, 0, NotSerialized) // _INI: Initialize
{
SDWU (SWMC)
QCFG (LNK0, SWQ0, ACS0)
QCFG (LNK1, SWQ1, ACS1)
QCFG (LNK2, SWQ2, ACS2)
QCFG (LNK3, SWQ3, ACS3)
XCFG (LNK0, XTAL)
XCFG (LNK1, XTAL)
XCFG (LNK2, XTAL)
XCFG (LNK3, XTAL)
DCFG (LNK0, DAI0, DOD0)
DCFG (LNK1, DAI1, DOD1)
DCFG (LNK2, DAI2, DOD2)
DCFG (LNK3, DAI3, DOD3)
}

Name (_DSD, Package (0x04) // _DSD: Device-Specific Data
{
ToUUID ("daffd814-6eba-4d8c-8a91-bc9bbf4aa301") /* Device Properties for _DSD */,
Package (0x02)
{
Package (0x02)
{
"mipi-sdw-sw-interface-revision",
0x00010000
},

Package (0x02)
{
"mipi-sdw-master-count",
0x04
}
},

ToUUID ("dbb8e3e6-5886-4ba6-8795-1319f52a966b") /* Hierarchical Data Extension */,
Package (0x04)
{
Package (0x02)
{
"mipi-sdw-link-0-subproperties",
"LNK0"
},

Package (0x02)
{
"mipi-sdw-link-1-subproperties",
"LNK1"
},

Package (0x02)
{
"mipi-sdw-link-2-subproperties",
"LNK2"
},

Package (0x02)
{
"mipi-sdw-link-3-subproperties",
"LNK3"
}
}
})
Name (LNK0, Package (0x02)
{
ToUUID ("daffd814-6eba-4d8c-8a91-bc9bbf4aa301") /* Device Properties for _DSD */,
Package (0x0D)
{
Package (0x02)
{
"intel-quirk-mask",
Zero
},

Package (0x02)
{
"intel-sdw-ip-clock",
0x0249F000
},

Package (0x02)
{
"intel-sdw-doais",
One
},

Package (0x02)
{
"intel-sdw-dods",
One
},

Package (0x02)
{
"intel-autonomous-clock-stop",
Zero
},

Package (0x02)
{
"mipi-sdw-clock-stop-mode0-supported",
One
},

Package (0x02)
{
"mipi-sdw-clock-stop-mode1-supported",
One
},

Package (0x02)
{
"mipi-sdw-clock-frequencies-supported",
Package (0x01)
{
0x00493E00
}
},

Package (0x02)
{
"mipi-sdw-default-frame-rate",
0xBB80
},

Package (0x02)
{
"mipi-sdw-default-frame-row-size",
0x32
},

Package (0x02)
{
"mipi-sdw-default-frame-col-size",
0x04
},

Package (0x02)
{
"mipi-sdw-dynamic-frame-shape",
One
},

Package (0x02)
{
"mipi-sdw-command-error-threshold",
0x10
}
}
})
Name (LNK1, Package (0x02)
{
ToUUID ("daffd814-6eba-4d8c-8a91-bc9bbf4aa301") /* Device Properties for _DSD */,
Package (0x0D)
{
Package (0x02)
{
"intel-quirk-mask",
Zero
},

Package (0x02)
{
"intel-sdw-ip-clock",
0x0249F000
},

Package (0x02)
{
"intel-sdw-doais",
One
},

Package (0x02)
{
"intel-sdw-dods",
One
},

Package (0x02)
{
"intel-autonomous-clock-stop",
Zero
},

Package (0x02)
{
"mipi-sdw-clock-stop-mode0-supported",
One
},

Package (0x02)
{
"mipi-sdw-clock-stop-mode1-supported",
One
},

Package (0x02)
{
"mipi-sdw-clock-frequencies-supported",
Package (0x01)
{
0x00493E00
}
},

Package (0x02)
{
"mipi-sdw-default-frame-rate",
0xBB80
},

Package (0x02)
{
"mipi-sdw-default-frame-row-size",
0x32
},

Package (0x02)
{
"mipi-sdw-default-frame-col-size",
0x04
},

Package (0x02)
{
"mipi-sdw-dynamic-frame-shape",
One
},

Package (0x02)
{
"mipi-sdw-command-error-threshold",
0x10
}
}
})
Name (LNK2, Package (0x02)
{
ToUUID ("daffd814-6eba-4d8c-8a91-bc9bbf4aa301") /* Device Properties for _DSD */,
Package (0x0D)
{
Package (0x02)
{
"intel-quirk-mask",
Zero
},

Package (0x02)
{
"intel-sdw-ip-clock",
0x0249F000
},

Package (0x02)
{
"intel-sdw-doais",
One
},

Package (0x02)
{
"intel-sdw-dods",
One
},

Package (0x02)
{
"intel-autonomous-clock-stop",
Zero
},

Package (0x02)
{
"mipi-sdw-clock-stop-mode0-supported",
One
},

Package (0x02)
{
"mipi-sdw-clock-stop-mode1-supported",
One
},

Package (0x02)
{
"mipi-sdw-clock-frequencies-supported",
Package (0x01)
{
0x00493E00
}
},

Package (0x02)
{
"mipi-sdw-default-frame-rate",
0xBB80
},

Package (0x02)
{
"mipi-sdw-default-frame-row-size",
0x32
},

Package (0x02)
{
"mipi-sdw-default-frame-col-size",
0x04
},

Package (0x02)
{
"mipi-sdw-dynamic-frame-shape",
One
},

Package (0x02)
{
"mipi-sdw-command-error-threshold",
0x10
}
}
})
Name (LNK3, Package (0x02)
{
ToUUID ("daffd814-6eba-4d8c-8a91-bc9bbf4aa301") /* Device Properties for _DSD */,
Package (0x0D)
{
Package (0x02)
{
"intel-quirk-mask",
Zero
},

Package (0x02)
{
"intel-sdw-ip-clock",
0x0249F000
},

Package (0x02)
{
"intel-sdw-doais",
One
},

Package (0x02)
{
"intel-sdw-dods",
One
},

Package (0x02)
{
"intel-autonomous-clock-stop",
Zero
},

Package (0x02)
{
"mipi-sdw-clock-stop-mode0-supported",
One
},

Package (0x02)
{
"mipi-sdw-clock-stop-mode1-supported",
One
},

Package (0x02)
{
"mipi-sdw-clock-frequencies-supported",
Package (0x01)
{
0x00493E00
}
},

Package (0x02)
{
"mipi-sdw-default-frame-rate",
0xBB80
},

Package (0x02)
{
"mipi-sdw-default-frame-row-size",
0x32
},

Package (0x02)
{
"mipi-sdw-default-frame-col-size",
0x04
},

Package (0x02)
{
"mipi-sdw-dynamic-frame-shape",
One
},

Package (0x02)
{
"mipi-sdw-command-error-threshold",
0x10
}
}
})
}
}

If ((UAOE != Zero))
{
Scope (HDAS.IDA)
{
Device (UAOL)
{
Name (_ADR, 0x50000000) // _ADR: Address
Name (_CID, Package (0x02) // _CID: Compatible ID
{
"PRP00001",
"PNP0A05" /* Generic Container Device */
})
Method (_STA, 0, NotSerialized) // _STA: Status
{
Return (0x0B)
}

Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
ADBG ("UAOL _DSM")
If ((Arg0 == ToUUID ("2e60aefc-1ba8-467a-b8cc-5727b98cecb7") /* Unknown UUID */))
{
Switch (ToInteger (Arg2))
{
Case (Zero)
{
Return (Buffer (One)
{
0x03 // .
})
}
Case (One)
{
Return (CFAE (Arg3))
}

}
}

Return (Buffer (One)
{
0x00 // .
})
}

Name (_DSD, Package (0x04) // _DSD: Device-Specific Data
{
ToUUID ("daffd814-6eba-4d8c-8a91-bc9bbf4aa301") /* Device Properties for _DSD */,
Package (0x01)
{
Package (0x02)
{
"uaol-ctrl-count",
0x02
}
},

ToUUID ("dbb8e3e6-5886-4ba6-8795-1319f52a966b") /* Hierarchical Data Extension */,
Package (0x02)
{
Package (0x02)
{
"uaol-descriptor-0",
"UAO0"
},

Package (0x02)
{
"uaol-descriptor-1",
"UAO1"
}
}
})
Name (UAO0, Package (0x02)
{
ToUUID ("daffd814-6eba-4d8c-8a91-bc9bbf4aa301") /* Device Properties for _DSD */,
Package (0x03)
{
Package (0x02)
{
"uaol-instance-number",
Zero
},

Package (0x02)
{
"bdf-routing-enabled",
Zero
},

Package (0x02)
{
"peer-integrated-controller-identifier",
0x98ED
}
}
})
Name (UAO1, Package (0x02)
{
ToUUID ("daffd814-6eba-4d8c-8a91-bc9bbf4aa301") /* Device Properties for _DSD */,
Package (0x03)
{
Package (0x02)
{
"uaol-instance-number",
One
},

Package (0x02)
{
"bdf-routing-enabled",
Zero
},

Package (0x02)
{
"peer-integrated-controller-identifier",
0xABCD
}
}
})
}
}
}
}

Scope (_SB.PC00)
{
Scope (\_SB.PC00)
{
Method (SOD3, 3, Serialized)
{
OperationRegion (ICB1, SystemMemory, (GPCB () + Arg0), 0x88)
If (Arg1)
{
Field (ICB1, ByteAcc, NoLock, Preserve)
{
Offset (0x84),
PMEC, 8
}

PMEC = 0x03
PMEC |= Zero
}

If ((Arg1 && Arg2))
{
Field (ICB1, AnyAcc, NoLock, Preserve)
{
Offset (0x10),
BAR0, 64
}

BAR0 = Zero
}
}
}

Method (I2CH, 1, Serialized)
{
OperationRegion (ICB1, SystemMemory, Arg0, 0x20)
Field (ICB1, AnyAcc, NoLock, Preserve)
{
Offset (0x10),
BAR0, 64,
BAR1, 64
}

Name (BUF0, ResourceTemplate ()
{
Memory32Fixed (ReadWrite,
0x00000000, // Address Base
0x00001000, // Address Length
_Y2B)
})
Name (BUF1, ResourceTemplate ()
{
Memory32Fixed (ReadWrite,
0x00000000, // Address Base
0x00001000, // Address Length
_Y2C)
})
CreateDWordField (BUF0, \_SB.PC00.I2CH._Y2B._BAS, ADR0) // _BAS: Base Address
CreateDWordField (BUF1, \_SB.PC00.I2CH._Y2C._BAS, ADR1) // _BAS: Base Address
ADR0 = (BAR0 & 0xFFFFFFFFFFFFF000)
ADR1 = (BAR1 & 0xFFFFFFFFFFFFF000)
ConcatenateResTemplate (BUF0, BUF1, Local0)
Return (Local0)
}

Device (I2C0)
{
If ((IM00 == 0x02))
{
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings
{
Return (I2CH (IC00))
}

Name (_STA, 0x08) // _STA: Status
}

If ((IM00 == One))
{
Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If (PCIC (Arg0))
{
Return (PCID (Arg0, Arg1, Arg2, Arg3))
}

Return (Buffer (One)
{
0x00 // .
})
}

Method (_PS3, 0, NotSerialized) // _PS3: Power State 3
{
SOD3 (IC00, One, One)
}

Method (_PS0, 0, NotSerialized) // _PS0: Power State 0
{
}
}

If (((IM00 == One) || (IM00 == Zero)))
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
Return (0x00150000)
}
}
}

Device (I2C1)
{
If ((IM01 == 0x02))
{
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings
{
Return (I2CH (IC01))
}

Name (_STA, 0x08) // _STA: Status
}

If ((IM01 == One))
{
Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If (PCIC (Arg0))
{
Return (PCID (Arg0, Arg1, Arg2, Arg3))
}

Return (Buffer (One)
{
0x00 // .
})
}

Method (_PS3, 0, NotSerialized) // _PS3: Power State 3
{
SOD3 (IC01, One, One)
}

Method (_PS0, 0, NotSerialized) // _PS0: Power State 0
{
}
}

If (((IM01 == One) || (IM01 == Zero)))
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
Return (0x00150001)
}
}
}

Device (I2C2)
{
If ((IM02 == 0x02))
{
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings
{
Return (I2CH (IC02))
}

Name (_STA, 0x08) // _STA: Status
}

If ((IM02 == One))
{
Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If (PCIC (Arg0))
{
Return (PCID (Arg0, Arg1, Arg2, Arg3))
}

Return (Buffer (One)
{
0x00 // .
})
}

Method (_PS3, 0, NotSerialized) // _PS3: Power State 3
{
SOD3 (IC02, One, One)
}

Method (_PS0, 0, NotSerialized) // _PS0: Power State 0
{
}
}

If (((IM02 == One) || (IM02 == Zero)))
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
Return (0x00150002)
}
}
}

Device (I2C3)
{
If ((IM03 == 0x02))
{
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings
{
Return (I2CH (IC03))
}

Name (_STA, 0x08) // _STA: Status
}

If ((IM03 == One))
{
Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If (PCIC (Arg0))
{
Return (PCID (Arg0, Arg1, Arg2, Arg3))
}

Return (Buffer (One)
{
0x00 // .
})
}

Method (_PS3, 0, NotSerialized) // _PS3: Power State 3
{
SOD3 (IC03, One, One)
}

Method (_PS0, 0, NotSerialized) // _PS0: Power State 0
{
}
}

If (((IM03 == One) || (IM03 == Zero)))
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
Return (0x00150003)
}
}
}

Device (I2C4)
{
If ((IM04 == 0x02))
{
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings
{
Return (I2CH (IC04))
}

Name (_STA, 0x08) // _STA: Status
}

If ((IM04 == One))
{
Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If (PCIC (Arg0))
{
Return (PCID (Arg0, Arg1, Arg2, Arg3))
}

Return (Buffer (One)
{
0x00 // .
})
}

Method (_PS3, 0, NotSerialized) // _PS3: Power State 3
{
SOD3 (IC04, One, One)
}

Method (_PS0, 0, NotSerialized) // _PS0: Power State 0
{
}
}

If (((IM04 == One) || (IM04 == Zero)))
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
Return (0x00190000)
}
}
}

Device (I2C5)
{
If ((IM05 == 0x02))
{
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings
{
Return (I2CH (IC05))
}

Name (_STA, 0x08) // _STA: Status
}

If ((IM05 == One))
{
Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If (PCIC (Arg0))
{
Return (PCID (Arg0, Arg1, Arg2, Arg3))
}

Return (Buffer (One)
{
0x00 // .
})
}

Method (_PS3, 0, NotSerialized) // _PS3: Power State 3
{
SOD3 (IC05, One, One)
}

Method (_PS0, 0, NotSerialized) // _PS0: Power State 0
{
}
}

If (((IM05 == One) || (IM05 == Zero)))
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
Return (0x00190001)
}
}
}

Device (I2C6)
{
If ((IM06 == 0x02))
{
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings
{
Return (I2CH (IC06))
}

Name (_STA, 0x08) // _STA: Status
}

If ((IM06 == One))
{
Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If (PCIC (Arg0))
{
Return (PCID (Arg0, Arg1, Arg2, Arg3))
}

Return (Buffer (One)
{
0x00 // .
})
}

Method (_PS3, 0, NotSerialized) // _PS3: Power State 3
{
SOD3 (IC06, One, One)
}

Method (_PS0, 0, NotSerialized) // _PS0: Power State 0
{
}
}

If (((IM06 == One) || (IM06 == Zero)))
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
Return (0x00100000)
}
}
}

Device (I2C7)
{
If ((IM07 == 0x02))
{
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings
{
Return (I2CH (IC07))
}

Name (_STA, 0x08) // _STA: Status
}

If ((IM07 == One))
{
Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If (PCIC (Arg0))
{
Return (PCID (Arg0, Arg1, Arg2, Arg3))
}

Return (Buffer (One)
{
0x00 // .
})
}

Method (_PS3, 0, NotSerialized) // _PS3: Power State 3
{
SOD3 (IC07, One, One)
}

Method (_PS0, 0, NotSerialized) // _PS0: Power State 0
{
}
}

If (((IM07 == One) || (IM07 == Zero)))
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
Return (0x00100001)
}
}
}

Method (SPIH, 1, Serialized)
{
OperationRegion (ICB1, SystemMemory, Arg0, 0x20)
Field (ICB1, AnyAcc, NoLock, Preserve)
{
Offset (0x10),
BAR0, 64,
BAR1, 64
}

Name (BUF0, ResourceTemplate ()
{
Memory32Fixed (ReadWrite,
0x00000000, // Address Base
0x00001000, // Address Length
_Y2D)
})
Name (BUF1, ResourceTemplate ()
{
Memory32Fixed (ReadWrite,
0x00000000, // Address Base
0x00001000, // Address Length
_Y2E)
})
CreateDWordField (BUF0, \_SB.PC00.SPIH._Y2D._BAS, ADR0) // _BAS: Base Address
CreateDWordField (BUF1, \_SB.PC00.SPIH._Y2E._BAS, ADR1) // _BAS: Base Address
ADR0 = (BAR0 & 0xFFFFFFFFFFFFF000)
ADR1 = (BAR1 & 0xFFFFFFFFFFFFF000)
ConcatenateResTemplate (BUF0, BUF1, Local0)
Return (Local0)
}

Device (SPI0)
{
If ((SM00 == 0x02))
{
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings
{
Return (SPIH (SC00))
}

Name (_STA, 0x08) // _STA: Status
}

If ((SM00 == One))
{
Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If (PCIC (Arg0))
{
Return (PCID (Arg0, Arg1, Arg2, Arg3))
}

Return (Buffer (One)
{
0x00 // .
})
}

Method (_PS3, 0, NotSerialized) // _PS3: Power State 3
{
SOD3 (SC00, One, One)
}

Method (_PS0, 0, NotSerialized) // _PS0: Power State 0
{
}
}

If (((SM00 == One) || (SM00 == Zero)))
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
Return (0x001E0002)
}
}
}

Device (SPI1)
{
If ((SM01 == 0x02))
{
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings
{
Return (SPIH (SC01))
}

Name (_STA, 0x08) // _STA: Status
}

If ((SM01 == One))
{
Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If (PCIC (Arg0))
{
Return (PCID (Arg0, Arg1, Arg2, Arg3))
}

Return (Buffer (One)
{
0x00 // .
})
}

Method (_PS3, 0, NotSerialized) // _PS3: Power State 3
{
SOD3 (SC01, One, One)
}

Method (_PS0, 0, NotSerialized) // _PS0: Power State 0
{
}
}

If (((SM01 == One) || (SM01 == Zero)))
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
Return (0x001E0003)
}
}
}

Device (SPI2)
{
If ((SM02 == 0x02))
{
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings
{
Return (SPIH (SC02))
}

Name (_STA, 0x08) // _STA: Status
}

If ((SM02 == One))
{
Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If (PCIC (Arg0))
{
Return (PCID (Arg0, Arg1, Arg2, Arg3))
}

Return (Buffer (One)
{
0x00 // .
})
}

Method (_PS3, 0, NotSerialized) // _PS3: Power State 3
{
SOD3 (SC02, One, One)
}

Method (_PS0, 0, NotSerialized) // _PS0: Power State 0
{
}
}

If (((SM02 == One) || (SM02 == Zero)))
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
Return (0x00120006)
}
}
}

Device (SPI3)
{
If ((SM03 == 0x02))
{
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings
{
Return (SPIH (SC03))
}

Name (_STA, 0x08) // _STA: Status
}

If ((SM03 == One))
{
Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If (PCIC (Arg0))
{
Return (PCID (Arg0, Arg1, Arg2, Arg3))
}

Return (Buffer (One)
{
0x00 // .
})
}

Method (_PS3, 0, NotSerialized) // _PS3: Power State 3
{
SOD3 (SC03, One, One)
}

Method (_PS0, 0, NotSerialized) // _PS0: Power State 0
{
}
}

If (((SM03 == One) || (SM03 == Zero)))
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
Return (0x00130000)
}
}
}

Device (SPI4)
{
If ((SM04 == 0x02))
{
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings
{
Return (SPIH (SC04))
}

Name (_STA, 0x08) // _STA: Status
}

If ((SM04 == One))
{
Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If (PCIC (Arg0))
{
Return (PCID (Arg0, Arg1, Arg2, Arg3))
}

Return (Buffer (One)
{
0x00 // .
})
}

Method (_PS3, 0, NotSerialized) // _PS3: Power State 3
{
SOD3 (SC04, One, One)
}

Method (_PS0, 0, NotSerialized) // _PS0: Power State 0
{
}
}

If (((SM04 == One) || (SM04 == Zero)))
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
Return (0x00130001)
}
}
}

Device (SPI5)
{
If ((SM05 == 0x02))
{
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings
{
Return (SPIH (SC05))
}

Name (_STA, 0x08) // _STA: Status
}

If ((SM05 == One))
{
Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If (PCIC (Arg0))
{
Return (PCID (Arg0, Arg1, Arg2, Arg3))
}

Return (Buffer (One)
{
0x00 // .
})
}

Method (_PS3, 0, NotSerialized) // _PS3: Power State 3
{
SOD3 (SC05, One, One)
}

Method (_PS0, 0, NotSerialized) // _PS0: Power State 0
{
}
}

If (((SM05 == One) || (SM05 == Zero)))
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
Return (0x00130002)
}
}
}

Device (SPI6)
{
If ((SM06 == 0x02))
{
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings
{
Return (SPIH (SC06))
}

Name (_STA, 0x08) // _STA: Status
}

If ((SM06 == One))
{
Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If (PCIC (Arg0))
{
Return (PCID (Arg0, Arg1, Arg2, Arg3))
}

Return (Buffer (One)
{
0x00 // .
})
}

Method (_PS3, 0, NotSerialized) // _PS3: Power State 3
{
SOD3 (SC06, One, One)
}

Method (_PS0, 0, NotSerialized) // _PS0: Power State 0
{
}
}

If (((SM06 == One) || (SM06 == Zero)))
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
Return (0x00130003)
}
}
}
}

Scope (_SB.PC00)
{
Method (UDSM, 1, Serialized)
{
If ((Arg0 == ToUUID ("f7af8347-a966-49fe-9022-7a9deeebdb27") /* Unknown UUID */))
{
Return (One)
}

Return (Zero)
}

Method (UDMA, 2, Serialized)
{
Switch (ToInteger (Arg0))
{
Case (Zero)
{
Return (Buffer (0x08)
{
0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // ........
})
}
Case (One)
{
Return (ToInteger (Arg1))
}

}

Return (Buffer (0x08)
{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // ........
})
}
}

Scope (_SB)
{
Device (URSC)
{
Name (_HID, EisaId ("PNP0C02") /* PNP Motherboard Resources */) // _HID: Hardware ID
Name (_STA, 0x03) // _STA: Status
Name (_UID, 0x05) // _UID: Unique ID
Method (UARB, 2, Serialized)
{
If (((Arg0 == 0x02) || (Arg0 == 0x03)))
{
OperationRegion (UACF, SystemMemory, Arg1, 0x20)
Field (UACF, AnyAcc, NoLock, Preserve)
{
Offset (0x10),
BAR0, 64,
BAR1, 64
}

Name (BUF1, ResourceTemplate ()
{
Memory32Fixed (ReadWrite,
0x00000000, // Address Base
0x00000FF8, // Address Length
_Y2F)
})
Name (BUF2, ResourceTemplate ()
{
Memory32Fixed (ReadWrite,
0x00000000, // Address Base
0x00001000, // Address Length
_Y30)
})
CreateDWordField (BUF1, \_SB.URSC.UARB._Y2F._BAS, ADR1) // _BAS: Base Address
CreateDWordField (BUF2, \_SB.URSC.UARB._Y30._BAS, ADR2) // _BAS: Base Address
Local1 = (BAR0 & 0xFFFFFFFFFFFFF000)
ADR1 = (Local1 + 0x08)
ADR2 = (BAR1 & 0xFFFFFFFFFFFFF000)
ConcatenateResTemplate (BUF1, BUF2, Local0)
Return (Local0)
}

Return (Buffer (0x02)
{
0x79, 0x00 // y.
})
}
}

Method (UARH, 2, Serialized)
{
OperationRegion (UACF, SystemMemory, Arg0, 0x18)
Field (UACF, AnyAcc, NoLock, Preserve)
{
Offset (0x10),
BAR0, 64
}

Name (BUF0, ResourceTemplate ()
{
Memory32Fixed (ReadWrite,
0x00000000, // Address Base
0x00000008, // Address Length
_Y31)
})
Name (IBUF, ResourceTemplate ()
{
Interrupt (ResourceConsumer, Level, ActiveLow, Shared, ,, _Y32)
{
0x00000014,
}
})
CreateDWordField (BUF0, \_SB.UARH._Y31._BAS, ADR0) // _BAS: Base Address
CreateDWordField (IBUF, \_SB.UARH._Y32._INT, IRQN) // _INT: Interrupts
Local0 = (BAR0 & 0xFFFFFFFFFFFFF000)
ADR0 = Local0
IRQN = Arg1
ConcatenateResTemplate (BUF0, IBUF, Local1)
Return (Local1)
}

Method (UAPG, 3, Serialized)
{
If ((Arg1 != 0x02))
{
Return (Arg1)
}

OperationRegion (UACF, SystemMemory, Arg2, 0x18)
Field (UACF, AnyAcc, NoLock, Preserve)
{
Offset (0x10),
BAR0, 64
}

OperationRegion (UAB0, SystemMemory, (BAR0 & 0xFFFFFFFFFFFFF000), 0x10)
Field (UAB0, ByteAcc, Lock, Preserve)
{
DLL, 8,
DLH, 8,
FCR, 8,
LCR, 8
}

Local0 = LCR /* \_SB_.UAPG.LCR_ */
If ((Local0 && 0x7F))
{
Return (Zero)
}

Return (One)
}

Method (UHID, 1, Serialized)
{
If ((Arg0 == 0x03))
{
Return (0x0105D041)
}

Return (0x020CD041)
}

Method (UPS3, 2, Serialized)
{
If ((Arg0 == One))
{
OperationRegion (UACF, SystemMemory, Arg1, 0x88)
Field (UACF, AnyAcc, NoLock, Preserve)
{
Offset (0x10),
BAR0, 64
}

Field (UACF, ByteAcc, NoLock, Preserve)
{
Offset (0x84),
PMEC, 8
}

OperationRegion (UAB0, SystemMemory, (BAR0 & 0xFFFFFFFFFFFFF000), 0x82)
Field (UAB0, ByteAcc, NoLock, Preserve)
{
Offset (0x81),
PPRR, 8
}

PPRR = Zero
PMEC = 0x03
PMEC |= Zero
}
}

Method (UPS0, 2, Serialized)
{
If ((Arg0 == One))
{
OperationRegion (UACF, SystemMemory, Arg1, 0x88)
Field (UACF, AnyAcc, NoLock, Preserve)
{
Offset (0x10),
BAR0, 64
}

Field (UACF, ByteAcc, NoLock, Preserve)
{
Offset (0x84),
PMEC, 8
}

PMEC = Zero
PMEC |= Zero
OperationRegion (UAB0, SystemMemory, (BAR0 & 0xFFFFFFFFFFFFF000), 0x82)
Field (UAB0, ByteAcc, NoLock, Preserve)
{
Offset (0x81),
PPRR, 8
}

PPRR = 0x07
}
}

Method (UPSC, 1, Serialized)
{
OperationRegion (UACF, SystemMemory, (Arg0 + 0x84), 0x04)
Field (UACF, ByteAcc, NoLock, Preserve)
{
PMEC, 8
}

Return ((PMEC & 0x03))
}
}

Scope (_SB.URSC)
{
Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings
{
Local0 = UARB (UM00, UC00)
ConcatenateResTemplate (Local0, UARB (UM01, UC01), Local1)
Local0 = Local1
ConcatenateResTemplate (Local0, UARB (UM02, UC02), Local1)
Local0 = Local1
ConcatenateResTemplate (Local0, UARB (UM03, UC03), Local1)
Local0 = Local1
ConcatenateResTemplate (Local0, UARB (UM04, UC04), Local1)
Local0 = Local1
ConcatenateResTemplate (Local0, UARB (UM05, UC05), Local1)
Local0 = Local1
ConcatenateResTemplate (Local0, UARB (UM06, UC06), Local1)
Local0 = Local1
Return (Local0)
}
}

Scope (_SB.PC00)
{
Device (UA00)
{
Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If (PCIC (Arg0))
{
Return (PCID (Arg0, Arg1, Arg2, Arg3))
}

If (UDSM (Arg0))
{
Return (UDMA (Arg2, UD00))
}

Return (Buffer (One)
{
0x00 // .
})
}

Method (_ADR, 0, NotSerialized) // _ADR: Address
{
Return (0x001E0000)
}

Method (_PS3, 0, NotSerialized) // _PS3: Power State 3
{
SOD3 (UC00, One, One)
}

Method (_PS0, 0, NotSerialized) // _PS0: Power State 0
{
}
}
}

Scope (_SB)
{
If (((UM00 == 0x02) || (UM00 == 0x03)))
{
Device (UAH0)
{
Name (_DDN, "SerialIoUart0") // _DDN: DOS Device Name
Name (_UID, "SerialIoUart0") // _UID: Unique ID
Method (_HID, 0, NotSerialized) // _HID: Hardware ID
{
Return (UHID (UM00))
}

Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings
{
Return (UARH (UC00, UI00))
}

Method (_STA, 0, NotSerialized) // _STA: Status
{
If ((UM00 == 0x03))
{
If ((UP00 == 0x02))
{
UP00 = UAPG (UM00, UP00, UC00)
}

Return (0x0F)
}

Return (0x08)
}

If ((UM00 == 0x03))
{
Method (_PSC, 0, NotSerialized) // _PSC: Power State Current
{
Return (UPSC (UC00))
}

Method (_PS3, 0, NotSerialized) // _PS3: Power State 3
{
UPS3 (UP00, UC00)
}

Method (_PS0, 0, NotSerialized) // _PS0: Power State 0
{
UPS0 (UP00, UC00)
}
}
}
}
}

Scope (_SB.PC00)
{
Device (UA01)
{
Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If (PCIC (Arg0))
{
Return (PCID (Arg0, Arg1, Arg2, Arg3))
}

If (UDSM (Arg0))
{
Return (UDMA (Arg2, UD01))
}

Return (Buffer (One)
{
0x00 // .
})
}

Method (_ADR, 0, NotSerialized) // _ADR: Address
{
Return (0x001E0001)
}

Method (_PS3, 0, NotSerialized) // _PS3: Power State 3
{
SOD3 (UC01, One, One)
}

Method (_PS0, 0, NotSerialized) // _PS0: Power State 0
{
}
}
}

Scope (_SB)
{
If (((UM01 == 0x02) || (UM01 == 0x03)))
{
Device (UAH1)
{
Name (_DDN, "SerialIoUart1") // _DDN: DOS Device Name
Name (_UID, "SerialIoUart1") // _UID: Unique ID
Method (_HID, 0, NotSerialized) // _HID: Hardware ID
{
Return (UHID (UM01))
}

Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings
{
Return (UARH (UC01, UI01))
}

Method (_STA, 0, NotSerialized) // _STA: Status
{
If ((UM01 == 0x03))
{
If ((UP01 == 0x02))
{
UP01 = UAPG (UM01, UP01, UC01)
}

Return (0x0F)
}

Return (0x08)
}

If ((UM01 == 0x03))
{
Method (_PSC, 0, NotSerialized) // _PSC: Power State Current
{
Return (UPSC (UC01))
}

Method (_PS3, 0, NotSerialized) // _PS3: Power State 3
{
UPS3 (UP01, UC01)
}

Method (_PS0, 0, NotSerialized) // _PS0: Power State 0
{
UPS0 (UP01, UC01)
}
}
}
}
}

Scope (_SB.PC00)
{
Device (UA02)
{
Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If (PCIC (Arg0))
{
Return (PCID (Arg0, Arg1, Arg2, Arg3))
}

If (UDSM (Arg0))
{
Return (UDMA (Arg2, UD02))
}

Return (Buffer (One)
{
0x00 // .
})
}

Method (_ADR, 0, NotSerialized) // _ADR: Address
{
Return (0x00190002)
}

Method (_PS3, 0, NotSerialized) // _PS3: Power State 3
{
SOD3 (UC02, One, One)
}

Method (_PS0, 0, NotSerialized) // _PS0: Power State 0
{
}
}
}

Scope (_SB)
{
If (((UM02 == 0x02) || (UM02 == 0x03)))
{
Device (UAH2)
{
Name (_DDN, "SerialIoUart2") // _DDN: DOS Device Name
Name (_UID, "SerialIoUart2") // _UID: Unique ID
Method (_HID, 0, NotSerialized) // _HID: Hardware ID
{
Return (UHID (UM02))
}

Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings
{
Return (UARH (UC02, UI02))
}

Method (_STA, 0, NotSerialized) // _STA: Status
{
If ((UM02 == 0x03))
{
If ((UP02 == 0x02))
{
UP02 = UAPG (UM02, UP02, UC02)
}

Return (0x0F)
}

Return (0x08)
}

If ((UM02 == 0x03))
{
Method (_PSC, 0, NotSerialized) // _PSC: Power State Current
{
Return (UPSC (UC02))
}

Method (_PS3, 0, NotSerialized) // _PS3: Power State 3
{
UPS3 (UP02, UC02)
}

Method (_PS0, 0, NotSerialized) // _PS0: Power State 0
{
UPS0 (UP02, UC02)
}
}
}
}
}

Scope (_SB.PC00)
{
Device (UA03)
{
Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If (PCIC (Arg0))
{
Return (PCID (Arg0, Arg1, Arg2, Arg3))
}

If (UDSM (Arg0))
{
Return (UDMA (Arg2, UD03))
}

Return (Buffer (One)
{
0x00 // .
})
}

Method (_ADR, 0, NotSerialized) // _ADR: Address
{
Return (0x00110000)
}

Method (_PS3, 0, NotSerialized) // _PS3: Power State 3
{
SOD3 (UC03, One, One)
}

Method (_PS0, 0, NotSerialized) // _PS0: Power State 0
{
}
}
}

Scope (_SB)
{
If (((UM03 == 0x02) || (UM03 == 0x03)))
{
Device (UAH3)
{
Name (_DDN, "SerialIoUart3") // _DDN: DOS Device Name
Name (_UID, "SerialIoUart3") // _UID: Unique ID
Method (_HID, 0, NotSerialized) // _HID: Hardware ID
{
Return (UHID (UM03))
}

Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings
{
Return (UARH (UC03, UI03))
}

Method (_STA, 0, NotSerialized) // _STA: Status
{
If ((UM03 == 0x03))
{
If ((UP03 == 0x02))
{
UP03 = UAPG (UM03, UP03, UC03)
}

Return (0x0F)
}

Return (0x08)
}

If ((UM03 == 0x03))
{
Method (_PSC, 0, NotSerialized) // _PSC: Power State Current
{
Return (UPSC (UC03))
}

Method (_PS3, 0, NotSerialized) // _PS3: Power State 3
{
UPS3 (UP03, UC03)
}

Method (_PS0, 0, NotSerialized) // _PS0: Power State 0
{
UPS0 (UP03, UC03)
}
}
}
}
}

Scope (_SB.PC00)
{
Device (UA04)
{
Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If (PCIC (Arg0))
{
Return (PCID (Arg0, Arg1, Arg2, Arg3))
}

If (UDSM (Arg0))
{
Return (UDMA (Arg2, UD04))
}

Return (Buffer (One)
{
0x00 // .
})
}

Method (_ADR, 0, NotSerialized) // _ADR: Address
{
Return (0x00110001)
}

Method (_PS3, 0, NotSerialized) // _PS3: Power State 3
{
SOD3 (UC04, One, One)
}

Method (_PS0, 0, NotSerialized) // _PS0: Power State 0
{
}
}
}

Scope (_SB)
{
If (((UM04 == 0x02) || (UM04 == 0x03)))
{
Device (UAH4)
{
Name (_DDN, "SerialIoUart4") // _DDN: DOS Device Name
Name (_UID, "SerialIoUart4") // _UID: Unique ID
Method (_HID, 0, NotSerialized) // _HID: Hardware ID
{
Return (UHID (UM04))
}

Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings
{
Return (UARH (UC04, UI04))
}

Method (_STA, 0, NotSerialized) // _STA: Status
{
If ((UM04 == 0x03))
{
If ((UP04 == 0x02))
{
UP04 = UAPG (UM04, UP04, UC04)
}

Return (0x0F)
}

Return (0x08)
}

If ((UM04 == 0x03))
{
Method (_PSC, 0, NotSerialized) // _PSC: Power State Current
{
Return (UPSC (UC04))
}

Method (_PS3, 0, NotSerialized) // _PS3: Power State 3
{
UPS3 (UP04, UC04)
}

Method (_PS0, 0, NotSerialized) // _PS0: Power State 0
{
UPS0 (UP04, UC04)
}
}
}
}
}

Scope (_SB.PC00)
{
Device (UA05)
{
Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If (PCIC (Arg0))
{
Return (PCID (Arg0, Arg1, Arg2, Arg3))
}

If (UDSM (Arg0))
{
Return (UDMA (Arg2, UD05))
}

Return (Buffer (One)
{
0x00 // .
})
}

Method (_ADR, 0, NotSerialized) // _ADR: Address
{
Return (0x00110002)
}

Method (_PS3, 0, NotSerialized) // _PS3: Power State 3
{
SOD3 (UC05, One, One)
}

Method (_PS0, 0, NotSerialized) // _PS0: Power State 0
{
}
}
}

Scope (_SB)
{
If (((UM05 == 0x02) || (UM05 == 0x03)))
{
Device (UAH5)
{
Name (_DDN, "SerialIoUart5") // _DDN: DOS Device Name
Name (_UID, "SerialIoUart5") // _UID: Unique ID
Method (_HID, 0, NotSerialized) // _HID: Hardware ID
{
Return (UHID (UM05))
}

Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings
{
Return (UARH (UC05, UI05))
}

Method (_STA, 0, NotSerialized) // _STA: Status
{
If ((UM05 == 0x03))
{
If ((UP05 == 0x02))
{
UP05 = UAPG (UM05, UP05, UC05)
}

Return (0x0F)
}

Return (0x08)
}

If ((UM05 == 0x03))
{
Method (_PSC, 0, NotSerialized) // _PSC: Power State Current
{
Return (UPSC (UC05))
}

Method (_PS3, 0, NotSerialized) // _PS3: Power State 3
{
UPS3 (UP05, UC05)
}

Method (_PS0, 0, NotSerialized) // _PS0: Power State 0
{
UPS0 (UP05, UC05)
}
}
}
}
}

Scope (_SB.PC00)
{
Device (UA06)
{
Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If (PCIC (Arg0))
{
Return (PCID (Arg0, Arg1, Arg2, Arg3))
}

If (UDSM (Arg0))
{
Return (UDMA (Arg2, UD06))
}

Return (Buffer (One)
{
0x00 // .
})
}

Method (_ADR, 0, NotSerialized) // _ADR: Address
{
Return (0x00110003)
}

Method (_PS3, 0, NotSerialized) // _PS3: Power State 3
{
SOD3 (UC06, One, One)
}

Method (_PS0, 0, NotSerialized) // _PS0: Power State 0
{
}
}
}

Scope (_SB)
{
If (((UM06 == 0x02) || (UM06 == 0x03)))
{
Device (UAH6)
{
Name (_DDN, "SerialIoUart6") // _DDN: DOS Device Name
Name (_UID, "SerialIoUart6") // _UID: Unique ID
Method (_HID, 0, NotSerialized) // _HID: Hardware ID
{
Return (UHID (UM06))
}

Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings
{
Return (UARH (UC06, UI06))
}

Method (_STA, 0, NotSerialized) // _STA: Status
{
If ((UM06 == 0x03))
{
If ((UP06 == 0x02))
{
UP06 = UAPG (UM06, UP06, UC06)
}

Return (0x0F)
}

Return (0x08)
}

If ((UM06 == 0x03))
{
Method (_PSC, 0, NotSerialized) // _PSC: Power State Current
{
Return (UPSC (UC06))
}

Method (_PS3, 0, NotSerialized) // _PS3: Power State 3
{
UPS3 (UP06, UC06)
}

Method (_PS0, 0, NotSerialized) // _PS0: Power State 0
{
UPS0 (UP06, UC06)
}
}
}
}
}

Scope (_SB)
{
Device (GPI0)
{
Method (_HID, 0, NotSerialized) // _HID: Hardware ID
{
If ((GPHD == One))
{
Return ("PNP0C02")
}

Return ("INTC1055")
}

Name (LINK, "\\_SB.GPI0")
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings
{
Name (RBFL, ResourceTemplate ()
{
Interrupt (ResourceConsumer, Level, ActiveLow, Shared, ,, _Y33)
{
0x0000000E,
}
Memory32Fixed (ReadWrite,
0x00000000, // Address Base
0x00010000, // Address Length
_Y34)
Memory32Fixed (ReadWrite,
0x00000000, // Address Base
0x00010000, // Address Length
_Y35)
Memory32Fixed (ReadWrite,
0x00000000, // Address Base
0x00010000, // Address Length
_Y36)
Memory32Fixed (ReadWrite,
0x00000000, // Address Base
0x00010000, // Address Length
_Y37)
})
CreateDWordField (RBFL, \_SB.GPI0._CRS._Y33._INT, INTL) // _INT: Interrupts
INTL = SGIR /* \SGIR */
CreateDWordField (RBFL, \_SB.GPI0._CRS._Y34._BAS, CML0) // _BAS: Base Address
CML0 = (SBRG + 0x006E0000)
CreateDWordField (RBFL, \_SB.GPI0._CRS._Y35._BAS, CML1) // _BAS: Base Address
CML1 = (SBRG + 0x006D0000)
CreateDWordField (RBFL, \_SB.GPI0._CRS._Y36._BAS, CML4) // _BAS: Base Address
CML4 = (SBRG + 0x006A0000)
CreateDWordField (RBFL, \_SB.GPI0._CRS._Y37._BAS, CML5) // _BAS: Base Address
CML5 = (SBRG + 0x00690000)
Return (RBFL) /* \_SB_.GPI0._CRS.RBFL */
}

Method (_STA, 0, NotSerialized) // _STA: Status
{
If ((GPHD == One))
{
Return (0x08)
}

Return (0x0F)
}
}
}

Scope (_SB)
{
Name (GPCL, Package (0x12)
{
Package (0x09)
{
0x006E0000,
0x1A,
0x0700,
0xB0,
0x20,
0x0140,
0x80,
0x84,
Zero
},

Package (0x09)
{
0x006E0000,
0x10,
0x08A0,
0xB4,
0x30,
0x0144,
0x88,
0x8C,
0x20
},

Package (0x09)
{
0x006E0000,
0x19,
0x09A0,
0xB8,
0x38,
0x0148,
0x90,
0x94,
0x40
},

Package (0x09)
{
0x00690000,
0x08,
0x0700,
0xB0,
0x20,
0x0140,
0x80,
0x84,
0x0160
},

Package (0x09)
{
0x00690000,
0x09,
0x0780,
0xB4,
0x24,
0xFFFF,
0x88,
0x8C,
0xFFFF
},

Package (0x09)
{
0x006C0000,
0x11,
0x0700,
0xB0,
0x20,
0x0140,
0x80,
0x84,
0xFFFF
},

Package (0x09)
{
0x006D0000,
0x08,
0x0700,
0xB0,
0x20,
0x0140,
0x80,
0x84,
0x60
},

Package (0x09)
{
0x006D0000,
0x18,
0x0780,
0xB4,
0x24,
0x0144,
0x88,
0x8C,
0x80
},

Package (0x09)
{
0x006D0000,
0x15,
0x0900,
0xB8,
0x30,
0x0148,
0x90,
0x94,
0xA0
},

Package (0x09)
{
0x006D0000,
0x18,
0x0A50,
0xBC,
0x3C,
0x014C,
0x98,
0x9C,
0xC0
},

Package (0x09)
{
0x006D0000,
0x1D,
0x0BD0,
0xC0,
0x48,
0x0150,
0xA0,
0xA4,
0xE0
},

Package (0x09)
{
0x006A0000,
0x18,
0x0700,
0xB0,
0x20,
0x0140,
0x80,
0x84,
0x0100
},

Package (0x09)
{
0x006A0000,
0x19,
0x0880,
0xB4,
0x2C,
0x0144,
0x88,
0x8C,
0x0120
},

Package (0x09)
{
0x006A0000,
0x06,
0x0A10,
0xB8,
0x3C,
0xFFFF,
0x90,
0x94,
0xFFFF
},

Package (0x09)
{
0x006A0000,
0x19,
0x0A70,
0xBC,
0x40,
0x014C,
0x98,
0x9C,
0x0140
},

Package (0x09)
{
0x006A0000,
0x0A,
0x0C00,
0xC0,
0x50,
0xFFFF,
0xA0,
0xA4,
0xFFFF
},

Package (0x09)
{
0x006B0000,
0x0F,
0x0700,
0xB0,
0x20,
0xFFFF,
0x80,
0x84,
0xFFFF
},

Package (0x09)
{
0x006B0000,
0x5B,
0x07F0,
0xB4,
0x28,
0xFFFF,
0x88,
0x8C,
0xFFFF
}
})
Name (RXEV, Package (0x12)
{
Buffer (0x1A){},
Buffer (0x10){},
Buffer (0x19){},
Buffer (0x08){},
Buffer (0x09){},
Buffer (0x11){},
Buffer (0x08){},
Buffer (0x18){},
Buffer (0x15){},
Buffer (0x18){},
Buffer (0x1D){},
Buffer (0x18){},
Buffer (0x19){},
Buffer (0x06){},
Buffer (0x19){},
Buffer (0x0A){},
Buffer (0x0F){},
Buffer (0x5B){}
})
}

Scope (_SB)
{
Method (GINF, 2, NotSerialized)
{
Return (DerefOf (DerefOf (GPCL [Arg0]) [Arg1]))
}

Method (GMXG, 0, NotSerialized)
{
Return (0x12)
}
}

Scope (_SB)
{
Method (GADR, 2, NotSerialized)
{
Local0 = (GINF (Arg0, Zero) + SBRG)
Local1 = GINF (Arg0, Arg1)
Return ((Local0 + Local1))
}

Method (GNUM, 1, NotSerialized)
{
Local0 = GNMB (Arg0)
Local1 = GGRP (Arg0)
Return ((GINF (Local1, 0x08) + Local0))
}

Method (INUM, 1, NotSerialized)
{
Return ((GPC1 (Arg0) & 0x7F))
}

Method (GGRP, 1, Serialized)
{
Local0 = ((Arg0 & 0x00FF0000) >> 0x10)
Return (Local0)
}

Method (GNMB, 1, Serialized)
{
Return ((Arg0 & 0xFFFF))
}

Method (GGPE, 1, NotSerialized)
{
Local0 = GGRP (Arg0)
Local1 = GNMB (Arg0)
Local2 = (Local1 >> 0x05)
If (!((((GEI0 == Local0) && (GED0 == Local2)) | (
(GEI1 == Local0) && (GED1 == Local2))) | ((GEI2 == Local0) && (GED2 ==
Local2))))
{
Return (0x6F)
}
Else
{
If (((GEI0 == Local0) && (GED0 == Local2)))
{
Local3 = Zero
}
ElseIf (((GEI1 == Local0) && (GED1 == Local2)))
{
Local3 = One
}
ElseIf (((GEI2 == Local0) && (GED2 == Local2)))
{
Local3 = 0x02
}
Else
{
BreakPoint
Return (Zero)
}

Return ((((Local3 - Local2) * 0x20) + Local1))
}
}

Method (GPC0, 1, Serialized)
{
Local0 = GGRP (Arg0)
Local1 = GNMB (Arg0)
Local2 = (GADR (Local0, 0x02) + (Local1 * 0x10))
OperationRegion (PDW0, SystemMemory, Local2, 0x04)
Field (PDW0, AnyAcc, NoLock, Preserve)
{
TEMP, 32
}

Return (TEMP) /* \_SB_.GPC0.TEMP */
}

Method (SPC0, 2, Serialized)
{
Local0 = GGRP (Arg0)
Local1 = GNMB (Arg0)
Local2 = (GADR (Local0, 0x02) + (Local1 * 0x10))
OperationRegion (PDW0, SystemMemory, Local2, 0x04)
Field (PDW0, AnyAcc, NoLock, Preserve)
{
TEMP, 32
}

TEMP = Arg1
}

Method (GPC1, 1, Serialized)
{
Local0 = GGRP (Arg0)
Local1 = GNMB (Arg0)
Local2 = ((GADR (Local0, 0x02) + (Local1 * 0x10)) +
0x04)
OperationRegion (PDW1, SystemMemory, Local2, 0x04)
Field (PDW1, AnyAcc, NoLock, Preserve)
{
TEMP, 32
}

Return (TEMP) /* \_SB_.GPC1.TEMP */
}

Method (SPC1, 2, Serialized)
{
Local0 = GGRP (Arg0)
Local1 = GNMB (Arg0)
Local2 = ((GADR (Local0, 0x02) + (Local1 * 0x10)) +
0x04)
OperationRegion (PDW1, SystemMemory, Local2, 0x04)
Field (PDW1, AnyAcc, NoLock, Preserve)
{
TEMP, 32
}

TEMP = Arg1
}

Method (SRXO, 2, Serialized)
{
Local0 = GGRP (Arg0)
Local1 = GNMB (Arg0)
Local2 = (GADR (Local0, 0x02) + (Local1 * 0x10))
OperationRegion (PDW0, SystemMemory, Local2, 0x04)
Field (PDW0, AnyAcc, NoLock, Preserve)
{
, 28,
TEMP, 1,
Offset (0x04)
}

TEMP = Arg1
}

Method (GGIV, 1, Serialized)
{
Local0 = GGRP (Arg0)
Local1 = GNMB (Arg0)
Local2 = (GADR (Local0, 0x02) + (Local1 * 0x10))
OperationRegion (PDW0, SystemMemory, Local2, 0x04)
Field (PDW0, AnyAcc, NoLock, Preserve)
{
, 1,
TEMP, 1,
Offset (0x04)
}

Return (TEMP) /* \_SB_.GGIV.TEMP */
}

Method (GGOV, 1, Serialized)
{
Local0 = GGRP (Arg0)
Local1 = GNMB (Arg0)
Local2 = (GADR (Local0, 0x02) + (Local1 * 0x10))
OperationRegion (PDW0, SystemMemory, Local2, 0x04)
Field (PDW0, AnyAcc, NoLock, Preserve)
{
TEMP, 1,
Offset (0x04)
}

Return (TEMP) /* \_SB_.GGOV.TEMP */
}

Method (SGOV, 2, Serialized)
{
Local0 = GGRP (Arg0)
Local1 = GNMB (Arg0)
Local2 = (GADR (Local0, 0x02) + (Local1 * 0x10))
OperationRegion (PDW0, SystemMemory, Local2, 0x04)
Field (PDW0, AnyAcc, NoLock, Preserve)
{
TEMP, 1,
Offset (0x04)
}

TEMP = Arg1
}

Method (GGII, 1, Serialized)
{
Local0 = GGRP (Arg0)
Local1 = GNMB (Arg0)
Local2 = (GADR (Local0, 0x02) + (Local1 * 0x10))
OperationRegion (PDW0, SystemMemory, Local2, 0x04)
Field (PDW0, AnyAcc, NoLock, Preserve)
{
, 23,
TEMP, 1,
Offset (0x04)
}

Return (TEMP) /* \_SB_.GGII.TEMP */
}

Method (SGII, 2, Serialized)
{
Local0 = GGRP (Arg0)
Local1 = GNMB (Arg0)
Local2 = (GADR (Local0, 0x02) + (Local1 * 0x10))
OperationRegion (PDW0, SystemMemory, Local2, 0x04)
Field (PDW0, AnyAcc, NoLock, Preserve)
{
, 23,
TEMP, 1,
Offset (0x04)
}

TEMP = Arg1
}

Method (GPMV, 1, Serialized)
{
Local0 = GGRP (Arg0)
Local1 = GNMB (Arg0)
Local2 = (GADR (Local0, 0x02) + (Local1 * 0x10))
OperationRegion (PDW0, SystemMemory, Local2, 0x04)
Field (PDW0, AnyAcc, NoLock, Preserve)
{
, 10,
TEMP, 3,
Offset (0x04)
}

Return (TEMP) /* \_SB_.GPMV.TEMP */
}

Method (SPMV, 2, Serialized)
{
Local0 = GGRP (Arg0)
Local1 = GNMB (Arg0)
Local2 = (GADR (Local0, 0x02) + (Local1 * 0x10))
OperationRegion (PDW0, SystemMemory, Local2, 0x04)
Field (PDW0, AnyAcc, NoLock, Preserve)
{
, 10,
TEMP, 3,
Offset (0x04)
}

TEMP = Arg1
}

Method (GHPO, 1, Serialized)
{
Local0 = GGRP (Arg0)
Local1 = GNMB (Arg0)
Local3 = (GADR (Local0, 0x03) + ((Local1 >> 0x05) * 0x04))
Local4 = (Local1 & 0x1F)
OperationRegion (PREG, SystemMemory, Local3, 0x04)
Field (PREG, AnyAcc, NoLock, Preserve)
{
TEMP, 32
}

Return (((TEMP >> Local4) & One))
}

Method (SHPO, 2, Serialized)
{
Local0 = GGRP (Arg0)
Local1 = GNMB (Arg0)
Local3 = (GADR (Local0, 0x03) + ((Local1 >> 0x05) * 0x04))
Local4 = (Local1 & 0x1F)
OperationRegion (PREG, SystemMemory, Local3, 0x04)
Field (PREG, AnyAcc, NoLock, Preserve)
{
TEMP, 32
}

If (Arg1)
{
TEMP |= (One << Local4)
}
Else
{
TEMP &= ~(One << Local4)
}
}

Method (GGPO, 1, Serialized)
{
Local0 = GGRP (Arg0)
Local1 = GNMB (Arg0)
Local2 = (GADR (Local0, 0x04) + ((Local1 >> 0x03) * 0x04
))
OperationRegion (PREG, SystemMemory, Local2, 0x04)
Field (PREG, AnyAcc, NoLock, Preserve)
{
TEMP, 32
}

Return (((TEMP >> ((Local1 & 0x07) * 0x04)) &
0x03))
}

Method (SGRA, 2, Serialized)
{
Local0 = GGRP (Arg0)
Local1 = GNMB (Arg0)
Local2 = (GADR (Local0, 0x02) + (Local1 * 0x10))
OperationRegion (PDW0, SystemMemory, Local2, 0x04)
Field (PDW0, AnyAcc, NoLock, Preserve)
{
, 20,
TEMP, 1,
Offset (0x04)
}

TEMP = Arg1
}

Method (SGWP, 2, Serialized)
{
Local0 = GGRP (Arg0)
Local1 = GNMB (Arg0)
Local2 = ((GADR (Local0, 0x02) + (Local1 * 0x10)) +
0x04)
OperationRegion (PDW0, SystemMemory, Local2, 0x04)
Field (PDW0, AnyAcc, NoLock, Preserve)
{
, 10,
TEMP, 4,
Offset (0x04)
}

TEMP = Arg1
}

Method (CAGS, 1, Serialized)
{
Local0 = GGRP (Arg0)
Local1 = GNMB (Arg0)
Local4 = (Local1 >> 0x05)
If (!((((GEI0 == Local0) && (GED0 == Local4)) | (
(GEI1 == Local0) && (GED1 == Local4))) | ((GEI2 == Local0) && (GED2 ==
Local4))))
{
Local3 = GADR (Local0, 0x05)
If (((Local3 & 0xFFFF) != 0xFFFF))
{
OperationRegion (GPPX, SystemMemory, (Local3 + (Local4 * 0x04)), 0x04)
Field (GPPX, AnyAcc, NoLock, Preserve)
{
STSX, 32
}

Local2 = (One << (Local1 % 0x20))
STSX = Local2
}
}
}

Method (ISME, 1, Serialized)
{
Local0 = GGRP (Arg0)
Local1 = GNMB (Arg0)
Local4 = (Local1 >> 0x05)
If (!!((((GEI0 == Local0) && (GED0 == Local4)) |
((GEI1 == Local0) && (GED1 == Local4))) | ((GEI2 == Local0) && (
GED2 == Local4))))
{
Return (Zero)
}

If (((GADR (Local0, 0x05) & 0xFFFF) == 0xFFFF))
{
Return (Zero)
}

Local2 = (GADR (Local0, 0x05) + (Local4 * 0x04))
Local3 = (Local1 & 0x1F)
OperationRegion (GPPX, SystemMemory, Local2, 0x24)
Field (GPPX, AnyAcc, NoLock, Preserve)
{
STSX, 32,
Offset (0x20),
GENX, 32
}

Return ((((STSX & GENX) >> Local3) & One))
}

Method (DIPI, 1, Serialized)
{
Local0 = GGRP (Arg0)
Local1 = GNMB (Arg0)
Local2 = (GADR (Local0, 0x02) + (Local1 * 0x10))
OperationRegion (PDW0, SystemMemory, Local2, 0x04)
Field (PDW0, AnyAcc, NoLock, Preserve)
{
, 9,
RDIS, 1,
, 15,
RCFG, 2,
Offset (0x04)
}

If ((RCFG != 0x02))
{
DerefOf (RXEV [Local0]) [Local1] = RCFG /* \_SB_.DIPI.RCFG */
RCFG = 0x02
RDIS = One
}
}

Method (UIPI, 1, Serialized)
{
Local0 = GGRP (Arg0)
Local1 = GNMB (Arg0)
Local2 = (GADR (Local0, 0x02) + (Local1 * 0x10))
OperationRegion (PDW0, SystemMemory, Local2, 0x04)
Field (PDW0, AnyAcc, NoLock, Preserve)
{
, 9,
RDIS, 1,
, 15,
RCFG, 2,
Offset (0x04)
}

Local3 = DerefOf (DerefOf (RXEV [Local0]) [Local1])
If ((Local3 != 0x02))
{
RDIS = Zero
RCFG = Local3
}
}

Method (GRXE, 2, Serialized)
{
Local0 = GGRP (Arg0)
Local1 = GNMB (Arg0)
Local2 = (GADR (Local0, 0x02) + (Local1 * 0x10))
OperationRegion (PDW0, SystemMemory, Local2, 0x04)
Field (PDW0, AnyAcc, NoLock, Preserve)
{
, 25,
RCFG, 2,
Offset (0x04)
}

RCFG = Arg1
}

Method (GLOC, 2, Serialized)
{
Local0 = GGRP (Arg0)
Local1 = GNMB (Arg0)
Local2 = GADR (Local0, 0x06)
OperationRegion (PREG, SystemMemory, Local2, 0x04)
Field (PREG, AnyAcc, NoLock, Preserve)
{
TEMP, 32
}

Return (((TEMP >> Local1) & One))
}

Method (GLOT, 2, Serialized)
{
Local0 = GGRP (Arg0)
Local1 = GNMB (Arg0)
Local2 = GADR (Local0, 0x07)
OperationRegion (PREG, SystemMemory, Local2, 0x04)
Field (PREG, AnyAcc, NoLock, Preserve)
{
TEMP, 32
}

Return (((TEMP >> Local1) & One))
}
}

Scope (_SB.PC00)
{
Method (OCPD, 0, Serialized)
{
PCRA (0x50, 0x4020, Zero)
PCRA (0x50, 0x4820, Zero)
PCRA (0x50, 0x5C20, Zero)
PCRA (0x50, 0x5820, Zero)
PCRA (0x50, 0x1078, Zero)
}

If ((UF0E == One))
{
Device (PUF0)
{
Name (_ADR, 0x00120005) // _ADR: Address
Name (_DDN, "Intel(R) UFS Controller 0") // _DDN: DOS Device Name
OperationRegion (SCSR, PCI_Config, Zero, 0x0100)
Field (SCSR, ByteAcc, NoLock, Preserve)
{
Offset (0x84),
PSTA, 32,
Offset (0xA2),
, 2,
PGEN, 1
}

Method (_PS0, 0, Serialized) // _PS0: Power State 0
{
PGEN = Zero
PSTA &= 0xFFFFFFFC
TEMP = PSTA /* \_SB_.PC00.PUF0.PSTA */
ULTR (Zero)
OCPD ()
}

Method (_PS3, 0, Serialized) // _PS3: Power State 3
{
ULTR (One)
PGEN = One
}

Device (CARD)
{
Name (_ADR, 0x08) // _ADR: Address
Method (_RMV, 0, NotSerialized) // _RMV: Removal Status
{
Return (Zero)
}
}
}
}

If ((UF1E == One))
{
Device (PUF1)
{
Name (_ADR, 0x00120007) // _ADR: Address
Name (_DDN, "Intel(R) UFS Controller 1") // _DDN: DOS Device Name
OperationRegion (SCSR, PCI_Config, Zero, 0x0100)
Field (SCSR, ByteAcc, NoLock, Preserve)
{
Offset (0x84),
PSTA, 32,
Offset (0xA2),
, 2,
PGEN, 1
}

Method (_PS0, 0, Serialized) // _PS0: Power State 0
{
PGEN = Zero
PSTA &= 0xFFFFFFFC
TEMP = PSTA /* \_SB_.PC00.PUF1.PSTA */
ULTR (Zero)
OCPD ()
}

Method (_PS3, 0, Serialized) // _PS3: Power State 3
{
ULTR (One)
PGEN = One
}

Device (CARD)
{
Name (_ADR, 0x08) // _ADR: Address
Method (_RMV, 0, NotSerialized) // _RMV: Removal Status
{
Return (Zero)
}
}
}
}
}

Scope (_SB.PC00)
{
Device (CNVW)
{
Name (_ADR, 0x00140003) // _ADR: Address
Name (RSTT, Zero)
Name (PRRS, Zero)
OperationRegion (CWAR, SystemMemory, (GPCB () + 0x000A3000), 0x0100)
Field (CWAR, WordAcc, NoLock, Preserve)
{
VDID, 32,
, 1,
WMSE, 1,
WBME, 1,
Offset (0x10),
WBR0, 64,
Offset (0x44),
, 28,
WFLR, 1,
Offset (0x48),
, 15,
WIFR, 1,
Offset (0xCC),
WPMS, 32
}

Field (CWAR, ByteAcc, NoLock, Preserve)
{
Offset (0xCC),
Offset (0xCD),
PMEE, 1,
, 6,
PMES, 1
}

Method (_S0W, 0, NotSerialized) // _S0W: S0 Device Wake State
{
Return (0x03)
}

Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake
{
Return (GPRW (0x6D, 0x03))
}

Method (GPEH, 0, NotSerialized)
{
If ((VDID == 0xFFFFFFFF))
{
Return (Zero)
}

If ((PMES == One))
{
Notify (CNVW, 0x02) // Device Wake
}
}

Method (_PS0, 0, Serialized) // _PS0: Power State 0
{
If ((VDID != 0xFFFFFFFF))
{
S023 (0x02, One)
}
}

Method (_PS3, 0, Serialized) // _PS3: Power State 3
{
If ((VDID != 0xFFFFFFFF))
{
Local0 = PCRR (PCNV, 0x8100)
If (((Local0 & 0x7F) == 0x4C))
{
S023 (0x02, Zero)
}
}
}

Method (_DSW, 3, NotSerialized) // _DSW: Device Sleep Wake
{
}

Name (_PRR, Package (0x01) // _PRR: Power Resource for Reset
{
WRST
})
}

Method (CNIP, 0, NotSerialized)
{
If (((^CNVW.VDID != 0xFFFFFFFF) || (CRFP == One)))
{
Return (One)
}
Else
{
Return (Zero)
}
}

Method (SBTE, 1, Serialized)
{
If ((GBTP () != Zero))
{
Local0 = GBTP ()
SGOV (Local0, Arg0)
S023 (0x03, Arg0)
}
}

Method (GBTE, 0, NotSerialized)
{
If ((GBTP () != Zero))
{
Local0 = GBTP ()
Return (GGOV (Local0))
}
Else
{
Return (Zero)
}
}

Method (AOLX, 0, NotSerialized)
{
Name (AODS, Package (0x03)
{
Zero,
0x12,
Zero
})
If ((CBTA == One))
{
If ((CNIP () == Zero))
{
If ((HDBO && One))
{
AODS [0x02] = One
}
}
Else
{
AODS [0x02] = One
}
}

Return (AODS) /* \_SB_.PC00.AOLX.AODS */
}
}

Scope (_SB)
{
Method (GBTP, 0, Serialized)
{
If (((PCHS == 0x05) || (PCHS == 0x03)))
{
Return (0x090A0000)
}
ElseIf ((PCHS == 0x04))
{
Return (0x08030000)
}
Else
{
Return (Zero)
}
}
}

If (((PCHS == 0x02) || ((PCHS == 0x05) || (PCHS == 0x03))))
{
Scope (_SB.PC00.XHCI.RHUB.HS10)
{
Method (AOLD, 0, NotSerialized)
{
Return (AOLX ())
}
}
}
ElseIf (((PCHS == One) || (PCHS == 0x04)))
{
Scope (_SB.PC00.XHCI.RHUB.HS14)
{
Method (AOLD, 0, NotSerialized)
{
Return (AOLX ())
}
}
}

Scope (_SB.PC00.CNVW)
{
Name (PLRB, Zero)
PowerResource (WRST, 0x05, 0x0000)
{
Method (_STA, 0, NotSerialized) // _STA: Status
{
Return (One)
}

Method (_ON, 0, NotSerialized) // _ON_: Power On
{
}

Method (_OFF, 0, NotSerialized) // _OFF: Power Off
{
}

Method (_RST, 0, NotSerialized) // _RST: Device Reset
{
Local0 = Acquire (CNMT, 0x03E8)
If ((Local0 == Zero))
{
CFLR ()
PRRS = One
If ((CondRefOf (\_SB.PC00.CNVW.RSTT) && (RSTT == One)))
{
If ((PCHS == 0x04))
{
PLRB = 0x44
}
Else
{
PLRB = 0x80
}

If (((PCRR (PCNV, PLRB) & 0x02) == Zero))
{
If ((GBTR () == One))
{
BTRK (Zero)
Sleep (0x69)
Local2 = One
}

PCRO (PCNV, PLRB, 0x03)
Sleep (0x0A)
Local1 = PCRR (PCNV, PLRB)
If ((((Local1 & 0x02) == Zero) && (Local1 & 0x04)))
{
PRRS = 0x02
If ((Local2 == One))
{
BTRK (One)
Sleep (0x69)
}
}
Else
{
PRRS = 0x04
BTRK (One)
}
}
Else
{
PRRS = 0x03
}
}

Release (CNMT)
}
}
}

Method (CFLR, 0, NotSerialized)
{
If ((WFLR == One))
{
WIFR = One
}
}
}

Scope (_SB.PC00)
{
Name (SIPV, Zero)
Method (GSIP, 0, NotSerialized)
{
If (((PCHS == 0x05) || (PCHS == 0x03)))
{
Return (0x0E)
}
Else
{
Return (0x11)
}
}

Device (RP01)
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
If ((RPA1 != Zero))
{
Return (RPA1) /* \RPA1 */
}
Else
{
Return (0x001C0000)
}
}

Name (SLOT, One)
Name (LTEN, Zero)
Name (LMSL, Zero)
Name (LNSL, Zero)
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
LTEN = LTR1 /* \LTR1 */
LMSL = PML1 /* \PML1 */
LNSL = PNL1 /* \PNL1 */
If ((HBSL & One))
{
HBCS = One
}

If ((CondRefOf (VMR1) && CondRefOf (VMDE)))
{
If (((VMDE == One) && ((VMR1 & One) != Zero)))
{
PRMV = One
}
}

If (PRES ())
{
If (CondRefOf (PINI))
{
PINI ()
}
}

If (CondRefOf (\_SB.PC00.RP01))
{
If ((VDID != 0xFFFFFFFF))
{
If (CondRefOf (\STD3))
{
If (CondRefOf (\_SB.PC00.RP01.PRMV))
{
If ((PRMV == One))
{
RD3C = STD3 /* \STD3 */
}
}

If ((^PXSX.PNVM () || ^PXSX.PAHC ()))
{
RD3C = STD3 /* \STD3 */
}
}
}
}
}

SIPV = GSIP ()
Name (PRTP, 0x02)
OperationRegion (PXCS, SystemMemory, PC2M (_ADR ()), 0x0480)
Field (PXCS, AnyAcc, NoLock, Preserve)
{
VDID, 32,
Offset (0x50),
L0SE, 1,
, 3,
LDIS, 1,
Offset (0x51),
Offset (0x52),
, 13,
LASX, 1,
Offset (0x5A),
ABPX, 1,
, 2,
PDCX, 1,
, 2,
PDSX, 1,
Offset (0x5B),
Offset (0x60),
Offset (0x62),
PSPX, 1,
Offset (0xA4),
D3HT, 2,
Offset (0xD8),
, 30,
HPEX, 1,
PMEX, 1,
Offset (0xE0),
SCB0, 1,
, 6,
NCB7, 1,
Offset (0xE2),
, 2,
L23E, 1,
L23R, 1,
Offset (0x328),
, 19,
LNKS, 4
}

Field (PXCS, AnyAcc, NoLock, WriteAsZeros)
{
Offset (0xDC),
, 30,
HPSX, 1,
PMSX, 1
}

Method (L23D, 0, Serialized)
{
If ((SIPV < 0x10))
{
If ((NCB7 != One))
{
Return (Zero)
}
}
ElseIf ((SCB0 != One))
{
Return (Zero)
}

L23R = One
Local0 = Zero
While (L23R)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = Zero
}
Else
{
SCB0 = Zero
}

Local0 = Zero
While ((LASX == Zero))
{
If ((Local0 > 0x08))
{
Break
}

Sleep (0x10)
Local0++
}
}

Method (DL23, 0, Serialized)
{
L23E = One
Sleep (0x10)
Local0 = Zero
While (L23E)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = One
}
Else
{
SCB0 = One
}
}

Name (LTRV, Package (0x04)
{
Zero,
Zero,
Zero,
Zero
})
Name (HBCS, Zero)
Name (PRMV, Zero)
Name (RD3C, 0x02)
Method (PRES, 0, NotSerialized)
{
If ((VDID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If ((Arg0 == ToUUID ("e5c937d0-3553-4d7a-9117-ea4d19c3434d") /* Device Labeling Interface */))
{
Switch (ToInteger (Arg2))
{
Case (Zero)
{
Name (OPTS, Buffer (0x02)
{
0x00, 0x00 // ..
})
CreateBitField (OPTS, Zero, FUN0)
CreateBitField (OPTS, 0x06, FUN6)
CreateBitField (OPTS, 0x08, FUN8)
CreateBitField (OPTS, 0x09, FUN9)
CreateBitField (OPTS, 0x0A, FUNA)
CreateBitField (OPTS, 0x0B, FUNB)
If ((Arg1 >= 0x02))
{
FUN0 = One
If ((LTEN != Zero))
{
FUN6 = One
}

If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
FUN8 = One
FUN9 = One
}
}
}
}

If ((Arg1 >= 0x04))
{
If (CondRefOf (PPBA))
{
FUNA = One
}

If (CondRefOf (UPRD))
{
FUNB = One
}
}

Return (OPTS) /* \_SB_.PC00.RP01._DSM.OPTS */
}
Case (0x06)
{
If ((Arg1 >= 0x02))
{
LTRV [Zero] = ((LMSL >> 0x0A) & 0x07)
LTRV [One] = (LMSL & 0x03FF)
LTRV [0x02] = ((LNSL >> 0x0A) & 0x07)
LTRV [0x03] = (LNSL & 0x03FF)
Return (LTRV) /* \_SB_.PC00.RP01.LTRV */
}
}
Case (0x08)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (One)
}
}
}
}
Case (0x09)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (Package (0x05)
{
0xC350,
Ones,
Ones,
0xC350,
Ones
})
}
}
}
}
Case (0x0A)
{
If (CondRefOf (PPBA))
{
Return (PPBA (Arg3))
}
}
Case (0x0B)
{
If (CondRefOf (UPRD))
{
Return (UPRD (Arg3))
}
}

}
}

Return (Buffer (One)
{
0x00 // .
})
}

Device (PXSX)
{
Name (_ADR, Zero) // _ADR: Address
OperationRegion (PCCX, PCI_Config, Zero, 0x10)
Field (PCCX, ByteAcc, NoLock, Preserve)
{
DVID, 32,
Offset (0x09),
PIXX, 8,
SCCX, 8,
BCCX, 8
}

Method (PAHC, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x06))
{
If ((PIXX == One))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PNVM, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x08))
{
If ((PIXX == 0x02))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PRES, 0, Serialized)
{
If ((DVID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (ISGX, 0, Serialized)
{
If ((BCCX == 0x03))
{
Return (One)
}

Return (Zero)
}

If (CondRefOf (\STD3))
{
If ((STD3 != Zero))
{
Method (_DSD, 0, NotSerialized) // _DSD: Device-Specific Data
{
If ((PAHC () || PNVM ()))
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
One
}
}
})
}
Else
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
Zero
}
}
})
}
}
}
}

Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake
{
Return (GPRW (0x69, 0x03))
}
}

Method (_PS0, 0, Serialized) // _PS0: Power State 0
{
If (CondRefOf (PPS0))
{
PPS0 ()
}
}

Method (_PS3, 0, Serialized) // _PS3: Power State 3
{
If (CondRefOf (PPS3))
{
PPS3 ()
}
}

Method (HPME, 0, Serialized)
{
If (((VDID != 0xFFFFFFFF) && (PMSX == One)))
{
Notify (PXSX, 0x02) // Device Wake
PMSX = One
PSPX = One
}
}

Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table
{
If (CondRefOf (PICM))
{
If (PICM)
{
Return (AR04 ())
}
}

Return (PD04 ())
}
}

Device (RP02)
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
If ((RPA2 != Zero))
{
Return (RPA2) /* \RPA2 */
}
Else
{
Return (0x001C0001)
}
}

Name (SLOT, 0x02)
Name (LTEN, Zero)
Name (LMSL, Zero)
Name (LNSL, Zero)
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
LTEN = LTR2 /* \LTR2 */
LMSL = PML2 /* \PML2 */
LNSL = PNL2 /* \PNL2 */
If ((HBSL & One))
{
HBCS = One
}

If ((CondRefOf (VMR1) && CondRefOf (VMDE)))
{
If (((VMDE == One) && ((VMR1 & 0x02) != Zero)))
{
PRMV = One
}
}

If (PRES ())
{
If (CondRefOf (PINI))
{
PINI ()
}
}

If (CondRefOf (\_SB.PC00.RP02))
{
If ((VDID != 0xFFFFFFFF))
{
If (CondRefOf (\STD3))
{
If (CondRefOf (\_SB.PC00.RP02.PRMV))
{
If ((PRMV == One))
{
RD3C = STD3 /* \STD3 */
}
}

If ((^PXSX.PNVM () || ^PXSX.PAHC ()))
{
RD3C = STD3 /* \STD3 */
}
}
}
}
}

SIPV = GSIP ()
Name (PRTP, 0x02)
OperationRegion (PXCS, SystemMemory, PC2M (_ADR ()), 0x0480)
Field (PXCS, AnyAcc, NoLock, Preserve)
{
VDID, 32,
Offset (0x50),
L0SE, 1,
, 3,
LDIS, 1,
Offset (0x51),
Offset (0x52),
, 13,
LASX, 1,
Offset (0x5A),
ABPX, 1,
, 2,
PDCX, 1,
, 2,
PDSX, 1,
Offset (0x5B),
Offset (0x60),
Offset (0x62),
PSPX, 1,
Offset (0xA4),
D3HT, 2,
Offset (0xD8),
, 30,
HPEX, 1,
PMEX, 1,
Offset (0xE0),
SCB0, 1,
, 6,
NCB7, 1,
Offset (0xE2),
, 2,
L23E, 1,
L23R, 1,
Offset (0x328),
, 19,
LNKS, 4
}

Field (PXCS, AnyAcc, NoLock, WriteAsZeros)
{
Offset (0xDC),
, 30,
HPSX, 1,
PMSX, 1
}

Method (L23D, 0, Serialized)
{
If ((SIPV < 0x10))
{
If ((NCB7 != One))
{
Return (Zero)
}
}
ElseIf ((SCB0 != One))
{
Return (Zero)
}

L23R = One
Local0 = Zero
While (L23R)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = Zero
}
Else
{
SCB0 = Zero
}

Local0 = Zero
While ((LASX == Zero))
{
If ((Local0 > 0x08))
{
Break
}

Sleep (0x10)
Local0++
}
}

Method (DL23, 0, Serialized)
{
L23E = One
Sleep (0x10)
Local0 = Zero
While (L23E)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = One
}
Else
{
SCB0 = One
}
}

Name (LTRV, Package (0x04)
{
Zero,
Zero,
Zero,
Zero
})
Name (HBCS, Zero)
Name (PRMV, Zero)
Name (RD3C, 0x02)
Method (PRES, 0, NotSerialized)
{
If ((VDID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If ((Arg0 == ToUUID ("e5c937d0-3553-4d7a-9117-ea4d19c3434d") /* Device Labeling Interface */))
{
Switch (ToInteger (Arg2))
{
Case (Zero)
{
Name (OPTS, Buffer (0x02)
{
0x00, 0x00 // ..
})
CreateBitField (OPTS, Zero, FUN0)
CreateBitField (OPTS, 0x06, FUN6)
CreateBitField (OPTS, 0x08, FUN8)
CreateBitField (OPTS, 0x09, FUN9)
CreateBitField (OPTS, 0x0A, FUNA)
CreateBitField (OPTS, 0x0B, FUNB)
If ((Arg1 >= 0x02))
{
FUN0 = One
If ((LTEN != Zero))
{
FUN6 = One
}

If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
FUN8 = One
FUN9 = One
}
}
}
}

If ((Arg1 >= 0x04))
{
If (CondRefOf (PPBA))
{
FUNA = One
}

If (CondRefOf (UPRD))
{
FUNB = One
}
}

Return (OPTS) /* \_SB_.PC00.RP02._DSM.OPTS */
}
Case (0x06)
{
If ((Arg1 >= 0x02))
{
LTRV [Zero] = ((LMSL >> 0x0A) & 0x07)
LTRV [One] = (LMSL & 0x03FF)
LTRV [0x02] = ((LNSL >> 0x0A) & 0x07)
LTRV [0x03] = (LNSL & 0x03FF)
Return (LTRV) /* \_SB_.PC00.RP02.LTRV */
}
}
Case (0x08)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (One)
}
}
}
}
Case (0x09)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (Package (0x05)
{
0xC350,
Ones,
Ones,
0xC350,
Ones
})
}
}
}
}
Case (0x0A)
{
If (CondRefOf (PPBA))
{
Return (PPBA (Arg3))
}
}
Case (0x0B)
{
If (CondRefOf (UPRD))
{
Return (UPRD (Arg3))
}
}

}
}

Return (Buffer (One)
{
0x00 // .
})
}

Device (PXSX)
{
Name (_ADR, Zero) // _ADR: Address
OperationRegion (PCCX, PCI_Config, Zero, 0x10)
Field (PCCX, ByteAcc, NoLock, Preserve)
{
DVID, 32,
Offset (0x09),
PIXX, 8,
SCCX, 8,
BCCX, 8
}

Method (PAHC, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x06))
{
If ((PIXX == One))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PNVM, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x08))
{
If ((PIXX == 0x02))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PRES, 0, Serialized)
{
If ((DVID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (ISGX, 0, Serialized)
{
If ((BCCX == 0x03))
{
Return (One)
}

Return (Zero)
}

If (CondRefOf (\STD3))
{
If ((STD3 != Zero))
{
Method (_DSD, 0, NotSerialized) // _DSD: Device-Specific Data
{
If ((PAHC () || PNVM ()))
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
One
}
}
})
}
Else
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
Zero
}
}
})
}
}
}
}

Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake
{
Return (GPRW (0x69, 0x03))
}
}

Method (_PS0, 0, Serialized) // _PS0: Power State 0
{
If (CondRefOf (PPS0))
{
PPS0 ()
}
}

Method (_PS3, 0, Serialized) // _PS3: Power State 3
{
If (CondRefOf (PPS3))
{
PPS3 ()
}
}

Method (HPME, 0, Serialized)
{
If (((VDID != 0xFFFFFFFF) && (PMSX == One)))
{
Notify (PXSX, 0x02) // Device Wake
PMSX = One
PSPX = One
}
}

Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table
{
If (CondRefOf (PICM))
{
If (PICM)
{
Return (AR05 ())
}
}

Return (PD05 ())
}
}

Device (RP03)
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
If ((RPA3 != Zero))
{
Return (RPA3) /* \RPA3 */
}
Else
{
Return (0x001C0002)
}
}

Name (SLOT, 0x03)
Name (LTEN, Zero)
Name (LMSL, Zero)
Name (LNSL, Zero)
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
LTEN = LTR3 /* \LTR3 */
LMSL = PML3 /* \PML3 */
LNSL = PNL3 /* \PNL3 */
If ((HBSL & One))
{
HBCS = One
}

If ((CondRefOf (VMR1) && CondRefOf (VMDE)))
{
If (((VMDE == One) && ((VMR1 & 0x04) != Zero)))
{
PRMV = One
}
}

If (PRES ())
{
If (CondRefOf (PINI))
{
PINI ()
}
}

If (CondRefOf (\_SB.PC00.RP03))
{
If ((VDID != 0xFFFFFFFF))
{
If (CondRefOf (\STD3))
{
If (CondRefOf (\_SB.PC00.RP03.PRMV))
{
If ((PRMV == One))
{
RD3C = STD3 /* \STD3 */
}
}

If ((^PXSX.PNVM () || ^PXSX.PAHC ()))
{
RD3C = STD3 /* \STD3 */
}
}
}
}
}

SIPV = GSIP ()
Name (PRTP, 0x02)
OperationRegion (PXCS, SystemMemory, PC2M (_ADR ()), 0x0480)
Field (PXCS, AnyAcc, NoLock, Preserve)
{
VDID, 32,
Offset (0x50),
L0SE, 1,
, 3,
LDIS, 1,
Offset (0x51),
Offset (0x52),
, 13,
LASX, 1,
Offset (0x5A),
ABPX, 1,
, 2,
PDCX, 1,
, 2,
PDSX, 1,
Offset (0x5B),
Offset (0x60),
Offset (0x62),
PSPX, 1,
Offset (0xA4),
D3HT, 2,
Offset (0xD8),
, 30,
HPEX, 1,
PMEX, 1,
Offset (0xE0),
SCB0, 1,
, 6,
NCB7, 1,
Offset (0xE2),
, 2,
L23E, 1,
L23R, 1,
Offset (0x328),
, 19,
LNKS, 4
}

Field (PXCS, AnyAcc, NoLock, WriteAsZeros)
{
Offset (0xDC),
, 30,
HPSX, 1,
PMSX, 1
}

Method (L23D, 0, Serialized)
{
If ((SIPV < 0x10))
{
If ((NCB7 != One))
{
Return (Zero)
}
}
ElseIf ((SCB0 != One))
{
Return (Zero)
}

L23R = One
Local0 = Zero
While (L23R)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = Zero
}
Else
{
SCB0 = Zero
}

Local0 = Zero
While ((LASX == Zero))
{
If ((Local0 > 0x08))
{
Break
}

Sleep (0x10)
Local0++
}
}

Method (DL23, 0, Serialized)
{
L23E = One
Sleep (0x10)
Local0 = Zero
While (L23E)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = One
}
Else
{
SCB0 = One
}
}

Name (LTRV, Package (0x04)
{
Zero,
Zero,
Zero,
Zero
})
Name (HBCS, Zero)
Name (PRMV, Zero)
Name (RD3C, 0x02)
Method (PRES, 0, NotSerialized)
{
If ((VDID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If ((Arg0 == ToUUID ("e5c937d0-3553-4d7a-9117-ea4d19c3434d") /* Device Labeling Interface */))
{
Switch (ToInteger (Arg2))
{
Case (Zero)
{
Name (OPTS, Buffer (0x02)
{
0x00, 0x00 // ..
})
CreateBitField (OPTS, Zero, FUN0)
CreateBitField (OPTS, 0x06, FUN6)
CreateBitField (OPTS, 0x08, FUN8)
CreateBitField (OPTS, 0x09, FUN9)
CreateBitField (OPTS, 0x0A, FUNA)
CreateBitField (OPTS, 0x0B, FUNB)
If ((Arg1 >= 0x02))
{
FUN0 = One
If ((LTEN != Zero))
{
FUN6 = One
}

If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
FUN8 = One
FUN9 = One
}
}
}
}

If ((Arg1 >= 0x04))
{
If (CondRefOf (PPBA))
{
FUNA = One
}

If (CondRefOf (UPRD))
{
FUNB = One
}
}

Return (OPTS) /* \_SB_.PC00.RP03._DSM.OPTS */
}
Case (0x06)
{
If ((Arg1 >= 0x02))
{
LTRV [Zero] = ((LMSL >> 0x0A) & 0x07)
LTRV [One] = (LMSL & 0x03FF)
LTRV [0x02] = ((LNSL >> 0x0A) & 0x07)
LTRV [0x03] = (LNSL & 0x03FF)
Return (LTRV) /* \_SB_.PC00.RP03.LTRV */
}
}
Case (0x08)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (One)
}
}
}
}
Case (0x09)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (Package (0x05)
{
0xC350,
Ones,
Ones,
0xC350,
Ones
})
}
}
}
}
Case (0x0A)
{
If (CondRefOf (PPBA))
{
Return (PPBA (Arg3))
}
}
Case (0x0B)
{
If (CondRefOf (UPRD))
{
Return (UPRD (Arg3))
}
}

}
}

Return (Buffer (One)
{
0x00 // .
})
}

Device (PXSX)
{
Name (_ADR, Zero) // _ADR: Address
OperationRegion (PCCX, PCI_Config, Zero, 0x10)
Field (PCCX, ByteAcc, NoLock, Preserve)
{
DVID, 32,
Offset (0x09),
PIXX, 8,
SCCX, 8,
BCCX, 8
}

Method (PAHC, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x06))
{
If ((PIXX == One))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PNVM, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x08))
{
If ((PIXX == 0x02))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PRES, 0, Serialized)
{
If ((DVID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (ISGX, 0, Serialized)
{
If ((BCCX == 0x03))
{
Return (One)
}

Return (Zero)
}

If (CondRefOf (\STD3))
{
If ((STD3 != Zero))
{
Method (_DSD, 0, NotSerialized) // _DSD: Device-Specific Data
{
If ((PAHC () || PNVM ()))
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
One
}
}
})
}
Else
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
Zero
}
}
})
}
}
}
}

Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake
{
Return (GPRW (0x69, 0x03))
}
}

Method (_PS0, 0, Serialized) // _PS0: Power State 0
{
If (CondRefOf (PPS0))
{
PPS0 ()
}
}

Method (_PS3, 0, Serialized) // _PS3: Power State 3
{
If (CondRefOf (PPS3))
{
PPS3 ()
}
}

Method (HPME, 0, Serialized)
{
If (((VDID != 0xFFFFFFFF) && (PMSX == One)))
{
Notify (PXSX, 0x02) // Device Wake
PMSX = One
PSPX = One
}
}

Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table
{
If (CondRefOf (PICM))
{
If (PICM)
{
Return (AR06 ())
}
}

Return (PD06 ())
}
}

Device (RP04)
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
If ((RPA4 != Zero))
{
Return (RPA4) /* \RPA4 */
}
Else
{
Return (0x001C0003)
}
}

Name (SLOT, 0x04)
Name (LTEN, Zero)
Name (LMSL, Zero)
Name (LNSL, Zero)
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
LTEN = LTR4 /* \LTR4 */
LMSL = PML4 /* \PML4 */
LNSL = PNL4 /* \PNL4 */
If ((HBSL & One))
{
HBCS = One
}

If ((CondRefOf (VMR1) && CondRefOf (VMDE)))
{
If (((VMDE == One) && ((VMR1 & 0x08) != Zero)))
{
PRMV = One
}
}

If (PRES ())
{
If (CondRefOf (PINI))
{
PINI ()
}
}

If (CondRefOf (\_SB.PC00.RP04))
{
If ((VDID != 0xFFFFFFFF))
{
If (CondRefOf (\STD3))
{
If (CondRefOf (\_SB.PC00.RP04.PRMV))
{
If ((PRMV == One))
{
RD3C = STD3 /* \STD3 */
}
}

If ((^PXSX.PNVM () || ^PXSX.PAHC ()))
{
RD3C = STD3 /* \STD3 */
}
}
}
}
}

SIPV = GSIP ()
Name (PRTP, 0x02)
OperationRegion (PXCS, SystemMemory, PC2M (_ADR ()), 0x0480)
Field (PXCS, AnyAcc, NoLock, Preserve)
{
VDID, 32,
Offset (0x50),
L0SE, 1,
, 3,
LDIS, 1,
Offset (0x51),
Offset (0x52),
, 13,
LASX, 1,
Offset (0x5A),
ABPX, 1,
, 2,
PDCX, 1,
, 2,
PDSX, 1,
Offset (0x5B),
Offset (0x60),
Offset (0x62),
PSPX, 1,
Offset (0xA4),
D3HT, 2,
Offset (0xD8),
, 30,
HPEX, 1,
PMEX, 1,
Offset (0xE0),
SCB0, 1,
, 6,
NCB7, 1,
Offset (0xE2),
, 2,
L23E, 1,
L23R, 1,
Offset (0x328),
, 19,
LNKS, 4
}

Field (PXCS, AnyAcc, NoLock, WriteAsZeros)
{
Offset (0xDC),
, 30,
HPSX, 1,
PMSX, 1
}

Method (L23D, 0, Serialized)
{
If ((SIPV < 0x10))
{
If ((NCB7 != One))
{
Return (Zero)
}
}
ElseIf ((SCB0 != One))
{
Return (Zero)
}

L23R = One
Local0 = Zero
While (L23R)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = Zero
}
Else
{
SCB0 = Zero
}

Local0 = Zero
While ((LASX == Zero))
{
If ((Local0 > 0x08))
{
Break
}

Sleep (0x10)
Local0++
}
}

Method (DL23, 0, Serialized)
{
L23E = One
Sleep (0x10)
Local0 = Zero
While (L23E)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = One
}
Else
{
SCB0 = One
}
}

Name (LTRV, Package (0x04)
{
Zero,
Zero,
Zero,
Zero
})
Name (HBCS, Zero)
Name (PRMV, Zero)
Name (RD3C, 0x02)
Method (PRES, 0, NotSerialized)
{
If ((VDID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If ((Arg0 == ToUUID ("e5c937d0-3553-4d7a-9117-ea4d19c3434d") /* Device Labeling Interface */))
{
Switch (ToInteger (Arg2))
{
Case (Zero)
{
Name (OPTS, Buffer (0x02)
{
0x00, 0x00 // ..
})
CreateBitField (OPTS, Zero, FUN0)
CreateBitField (OPTS, 0x06, FUN6)
CreateBitField (OPTS, 0x08, FUN8)
CreateBitField (OPTS, 0x09, FUN9)
CreateBitField (OPTS, 0x0A, FUNA)
CreateBitField (OPTS, 0x0B, FUNB)
If ((Arg1 >= 0x02))
{
FUN0 = One
If ((LTEN != Zero))
{
FUN6 = One
}

If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
FUN8 = One
FUN9 = One
}
}
}
}

If ((Arg1 >= 0x04))
{
If (CondRefOf (PPBA))
{
FUNA = One
}

If (CondRefOf (UPRD))
{
FUNB = One
}
}

Return (OPTS) /* \_SB_.PC00.RP04._DSM.OPTS */
}
Case (0x06)
{
If ((Arg1 >= 0x02))
{
LTRV [Zero] = ((LMSL >> 0x0A) & 0x07)
LTRV [One] = (LMSL & 0x03FF)
LTRV [0x02] = ((LNSL >> 0x0A) & 0x07)
LTRV [0x03] = (LNSL & 0x03FF)
Return (LTRV) /* \_SB_.PC00.RP04.LTRV */
}
}
Case (0x08)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (One)
}
}
}
}
Case (0x09)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (Package (0x05)
{
0xC350,
Ones,
Ones,
0xC350,
Ones
})
}
}
}
}
Case (0x0A)
{
If (CondRefOf (PPBA))
{
Return (PPBA (Arg3))
}
}
Case (0x0B)
{
If (CondRefOf (UPRD))
{
Return (UPRD (Arg3))
}
}

}
}

Return (Buffer (One)
{
0x00 // .
})
}

Device (PXSX)
{
Name (_ADR, Zero) // _ADR: Address
OperationRegion (PCCX, PCI_Config, Zero, 0x10)
Field (PCCX, ByteAcc, NoLock, Preserve)
{
DVID, 32,
Offset (0x09),
PIXX, 8,
SCCX, 8,
BCCX, 8
}

Method (PAHC, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x06))
{
If ((PIXX == One))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PNVM, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x08))
{
If ((PIXX == 0x02))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PRES, 0, Serialized)
{
If ((DVID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (ISGX, 0, Serialized)
{
If ((BCCX == 0x03))
{
Return (One)
}

Return (Zero)
}

If (CondRefOf (\STD3))
{
If ((STD3 != Zero))
{
Method (_DSD, 0, NotSerialized) // _DSD: Device-Specific Data
{
If ((PAHC () || PNVM ()))
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
One
}
}
})
}
Else
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
Zero
}
}
})
}
}
}
}

Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake
{
Return (GPRW (0x69, 0x03))
}
}

Method (_PS0, 0, Serialized) // _PS0: Power State 0
{
If (CondRefOf (PPS0))
{
PPS0 ()
}
}

Method (_PS3, 0, Serialized) // _PS3: Power State 3
{
If (CondRefOf (PPS3))
{
PPS3 ()
}
}

Method (HPME, 0, Serialized)
{
If (((VDID != 0xFFFFFFFF) && (PMSX == One)))
{
Notify (PXSX, 0x02) // Device Wake
PMSX = One
PSPX = One
}
}

Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table
{
If (CondRefOf (PICM))
{
If (PICM)
{
Return (AR07 ())
}
}

Return (PD07 ())
}
}

Device (RP05)
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
If ((RPA5 != Zero))
{
Return (RPA5) /* \RPA5 */
}
Else
{
Return (0x001C0004)
}
}

Name (SLOT, 0x05)
Name (LTEN, Zero)
Name (LMSL, Zero)
Name (LNSL, Zero)
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
LTEN = LTR5 /* \LTR5 */
LMSL = PML5 /* \PML5 */
LNSL = PNL5 /* \PNL5 */
If ((HBSL & 0x02))
{
HBCS = One
}

If ((CondRefOf (VMR1) && CondRefOf (VMDE)))
{
If (((VMDE == One) && ((VMR1 & 0x10) != Zero)))
{
PRMV = One
}
}

If (PRES ())
{
If (CondRefOf (PINI))
{
PINI ()
}
}

If (CondRefOf (\_SB.PC00.RP05))
{
If ((VDID != 0xFFFFFFFF))
{
If (CondRefOf (\STD3))
{
If (CondRefOf (\_SB.PC00.RP05.PRMV))
{
If ((PRMV == One))
{
RD3C = STD3 /* \STD3 */
}
}

If ((^PXSX.PNVM () || ^PXSX.PAHC ()))
{
RD3C = STD3 /* \STD3 */
}
}
}
}
}

SIPV = GSIP ()
Name (PRTP, 0x02)
OperationRegion (PXCS, SystemMemory, PC2M (_ADR ()), 0x0480)
Field (PXCS, AnyAcc, NoLock, Preserve)
{
VDID, 32,
Offset (0x50),
L0SE, 1,
, 3,
LDIS, 1,
Offset (0x51),
Offset (0x52),
, 13,
LASX, 1,
Offset (0x5A),
ABPX, 1,
, 2,
PDCX, 1,
, 2,
PDSX, 1,
Offset (0x5B),
Offset (0x60),
Offset (0x62),
PSPX, 1,
Offset (0xA4),
D3HT, 2,
Offset (0xD8),
, 30,
HPEX, 1,
PMEX, 1,
Offset (0xE0),
SCB0, 1,
, 6,
NCB7, 1,
Offset (0xE2),
, 2,
L23E, 1,
L23R, 1,
Offset (0x328),
, 19,
LNKS, 4
}

Field (PXCS, AnyAcc, NoLock, WriteAsZeros)
{
Offset (0xDC),
, 30,
HPSX, 1,
PMSX, 1
}

Method (L23D, 0, Serialized)
{
If ((SIPV < 0x10))
{
If ((NCB7 != One))
{
Return (Zero)
}
}
ElseIf ((SCB0 != One))
{
Return (Zero)
}

L23R = One
Local0 = Zero
While (L23R)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = Zero
}
Else
{
SCB0 = Zero
}

Local0 = Zero
While ((LASX == Zero))
{
If ((Local0 > 0x08))
{
Break
}

Sleep (0x10)
Local0++
}
}

Method (DL23, 0, Serialized)
{
L23E = One
Sleep (0x10)
Local0 = Zero
While (L23E)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = One
}
Else
{
SCB0 = One
}
}

Name (LTRV, Package (0x04)
{
Zero,
Zero,
Zero,
Zero
})
Name (HBCS, Zero)
Name (PRMV, Zero)
Name (RD3C, 0x02)
Method (PRES, 0, NotSerialized)
{
If ((VDID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If ((Arg0 == ToUUID ("e5c937d0-3553-4d7a-9117-ea4d19c3434d") /* Device Labeling Interface */))
{
Switch (ToInteger (Arg2))
{
Case (Zero)
{
Name (OPTS, Buffer (0x02)
{
0x00, 0x00 // ..
})
CreateBitField (OPTS, Zero, FUN0)
CreateBitField (OPTS, 0x06, FUN6)
CreateBitField (OPTS, 0x08, FUN8)
CreateBitField (OPTS, 0x09, FUN9)
CreateBitField (OPTS, 0x0A, FUNA)
CreateBitField (OPTS, 0x0B, FUNB)
If ((Arg1 >= 0x02))
{
FUN0 = One
If ((LTEN != Zero))
{
FUN6 = One
}

If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
FUN8 = One
FUN9 = One
}
}
}
}

If ((Arg1 >= 0x04))
{
If (CondRefOf (PPBA))
{
FUNA = One
}

If (CondRefOf (UPRD))
{
FUNB = One
}
}

Return (OPTS) /* \_SB_.PC00.RP05._DSM.OPTS */
}
Case (0x06)
{
If ((Arg1 >= 0x02))
{
LTRV [Zero] = ((LMSL >> 0x0A) & 0x07)
LTRV [One] = (LMSL & 0x03FF)
LTRV [0x02] = ((LNSL >> 0x0A) & 0x07)
LTRV [0x03] = (LNSL & 0x03FF)
Return (LTRV) /* \_SB_.PC00.RP05.LTRV */
}
}
Case (0x08)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (One)
}
}
}
}
Case (0x09)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (Package (0x05)
{
0xC350,
Ones,
Ones,
0xC350,
Ones
})
}
}
}
}
Case (0x0A)
{
If (CondRefOf (PPBA))
{
Return (PPBA (Arg3))
}
}
Case (0x0B)
{
If (CondRefOf (UPRD))
{
Return (UPRD (Arg3))
}
}

}
}

Return (Buffer (One)
{
0x00 // .
})
}

Device (PXSX)
{
Name (_ADR, Zero) // _ADR: Address
OperationRegion (PCCX, PCI_Config, Zero, 0x10)
Field (PCCX, ByteAcc, NoLock, Preserve)
{
DVID, 32,
Offset (0x09),
PIXX, 8,
SCCX, 8,
BCCX, 8
}

Method (PAHC, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x06))
{
If ((PIXX == One))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PNVM, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x08))
{
If ((PIXX == 0x02))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PRES, 0, Serialized)
{
If ((DVID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (ISGX, 0, Serialized)
{
If ((BCCX == 0x03))
{
Return (One)
}

Return (Zero)
}

If (CondRefOf (\STD3))
{
If ((STD3 != Zero))
{
Method (_DSD, 0, NotSerialized) // _DSD: Device-Specific Data
{
If ((PAHC () || PNVM ()))
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
One
}
}
})
}
Else
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
Zero
}
}
})
}
}
}
}

Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake
{
Return (GPRW (0x69, 0x03))
}
}

Method (_PS0, 0, Serialized) // _PS0: Power State 0
{
If (CondRefOf (PPS0))
{
PPS0 ()
}
}

Method (_PS3, 0, Serialized) // _PS3: Power State 3
{
If (CondRefOf (PPS3))
{
PPS3 ()
}
}

Method (HPME, 0, Serialized)
{
If (((VDID != 0xFFFFFFFF) && (PMSX == One)))
{
Notify (PXSX, 0x02) // Device Wake
PMSX = One
PSPX = One
}
}

Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table
{
If (CondRefOf (PICM))
{
If (PICM)
{
Return (AR04 ())
}
}

Return (PD04 ())
}
}

Device (RP06)
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
If ((RPA6 != Zero))
{
Return (RPA6) /* \RPA6 */
}
Else
{
Return (0x001C0005)
}
}

Name (SLOT, 0x06)
Name (LTEN, Zero)
Name (LMSL, Zero)
Name (LNSL, Zero)
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
LTEN = LTR6 /* \LTR6 */
LMSL = PML6 /* \PML6 */
LNSL = PNL6 /* \PNL6 */
If ((HBSL & 0x02))
{
HBCS = One
}

If ((CondRefOf (VMR1) && CondRefOf (VMDE)))
{
If (((VMDE == One) && ((VMR1 & 0x20) != Zero)))
{
PRMV = One
}
}

If (PRES ())
{
If (CondRefOf (PINI))
{
PINI ()
}
}

If (CondRefOf (\_SB.PC00.RP06))
{
If ((VDID != 0xFFFFFFFF))
{
If (CondRefOf (\STD3))
{
If (CondRefOf (\_SB.PC00.RP06.PRMV))
{
If ((PRMV == One))
{
RD3C = STD3 /* \STD3 */
}
}

If ((^PXSX.PNVM () || ^PXSX.PAHC ()))
{
RD3C = STD3 /* \STD3 */
}
}
}
}
}

SIPV = GSIP ()
Name (PRTP, 0x02)
OperationRegion (PXCS, SystemMemory, PC2M (_ADR ()), 0x0480)
Field (PXCS, AnyAcc, NoLock, Preserve)
{
VDID, 32,
Offset (0x50),
L0SE, 1,
, 3,
LDIS, 1,
Offset (0x51),
Offset (0x52),
, 13,
LASX, 1,
Offset (0x5A),
ABPX, 1,
, 2,
PDCX, 1,
, 2,
PDSX, 1,
Offset (0x5B),
Offset (0x60),
Offset (0x62),
PSPX, 1,
Offset (0xA4),
D3HT, 2,
Offset (0xD8),
, 30,
HPEX, 1,
PMEX, 1,
Offset (0xE0),
SCB0, 1,
, 6,
NCB7, 1,
Offset (0xE2),
, 2,
L23E, 1,
L23R, 1,
Offset (0x328),
, 19,
LNKS, 4
}

Field (PXCS, AnyAcc, NoLock, WriteAsZeros)
{
Offset (0xDC),
, 30,
HPSX, 1,
PMSX, 1
}

Method (L23D, 0, Serialized)
{
If ((SIPV < 0x10))
{
If ((NCB7 != One))
{
Return (Zero)
}
}
ElseIf ((SCB0 != One))
{
Return (Zero)
}

L23R = One
Local0 = Zero
While (L23R)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = Zero
}
Else
{
SCB0 = Zero
}

Local0 = Zero
While ((LASX == Zero))
{
If ((Local0 > 0x08))
{
Break
}

Sleep (0x10)
Local0++
}
}

Method (DL23, 0, Serialized)
{
L23E = One
Sleep (0x10)
Local0 = Zero
While (L23E)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = One
}
Else
{
SCB0 = One
}
}

Name (LTRV, Package (0x04)
{
Zero,
Zero,
Zero,
Zero
})
Name (HBCS, Zero)
Name (PRMV, Zero)
Name (RD3C, 0x02)
Method (PRES, 0, NotSerialized)
{
If ((VDID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If ((Arg0 == ToUUID ("e5c937d0-3553-4d7a-9117-ea4d19c3434d") /* Device Labeling Interface */))
{
Switch (ToInteger (Arg2))
{
Case (Zero)
{
Name (OPTS, Buffer (0x02)
{
0x00, 0x00 // ..
})
CreateBitField (OPTS, Zero, FUN0)
CreateBitField (OPTS, 0x06, FUN6)
CreateBitField (OPTS, 0x08, FUN8)
CreateBitField (OPTS, 0x09, FUN9)
CreateBitField (OPTS, 0x0A, FUNA)
CreateBitField (OPTS, 0x0B, FUNB)
If ((Arg1 >= 0x02))
{
FUN0 = One
If ((LTEN != Zero))
{
FUN6 = One
}

If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
FUN8 = One
FUN9 = One
}
}
}
}

If ((Arg1 >= 0x04))
{
If (CondRefOf (PPBA))
{
FUNA = One
}

If (CondRefOf (UPRD))
{
FUNB = One
}
}

Return (OPTS) /* \_SB_.PC00.RP06._DSM.OPTS */
}
Case (0x06)
{
If ((Arg1 >= 0x02))
{
LTRV [Zero] = ((LMSL >> 0x0A) & 0x07)
LTRV [One] = (LMSL & 0x03FF)
LTRV [0x02] = ((LNSL >> 0x0A) & 0x07)
LTRV [0x03] = (LNSL & 0x03FF)
Return (LTRV) /* \_SB_.PC00.RP06.LTRV */
}
}
Case (0x08)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (One)
}
}
}
}
Case (0x09)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (Package (0x05)
{
0xC350,
Ones,
Ones,
0xC350,
Ones
})
}
}
}
}
Case (0x0A)
{
If (CondRefOf (PPBA))
{
Return (PPBA (Arg3))
}
}
Case (0x0B)
{
If (CondRefOf (UPRD))
{
Return (UPRD (Arg3))
}
}

}
}

Return (Buffer (One)
{
0x00 // .
})
}

Device (PXSX)
{
Name (_ADR, Zero) // _ADR: Address
OperationRegion (PCCX, PCI_Config, Zero, 0x10)
Field (PCCX, ByteAcc, NoLock, Preserve)
{
DVID, 32,
Offset (0x09),
PIXX, 8,
SCCX, 8,
BCCX, 8
}

Method (PAHC, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x06))
{
If ((PIXX == One))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PNVM, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x08))
{
If ((PIXX == 0x02))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PRES, 0, Serialized)
{
If ((DVID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (ISGX, 0, Serialized)
{
If ((BCCX == 0x03))
{
Return (One)
}

Return (Zero)
}

If (CondRefOf (\STD3))
{
If ((STD3 != Zero))
{
Method (_DSD, 0, NotSerialized) // _DSD: Device-Specific Data
{
If ((PAHC () || PNVM ()))
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
One
}
}
})
}
Else
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
Zero
}
}
})
}
}
}
}

Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake
{
Return (GPRW (0x69, 0x03))
}
}

Method (_PS0, 0, Serialized) // _PS0: Power State 0
{
If (CondRefOf (PPS0))
{
PPS0 ()
}
}

Method (_PS3, 0, Serialized) // _PS3: Power State 3
{
If (CondRefOf (PPS3))
{
PPS3 ()
}
}

Method (HPME, 0, Serialized)
{
If (((VDID != 0xFFFFFFFF) && (PMSX == One)))
{
Notify (PXSX, 0x02) // Device Wake
PMSX = One
PSPX = One
}
}

Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table
{
If (CondRefOf (PICM))
{
If (PICM)
{
Return (AR05 ())
}
}

Return (PD05 ())
}
}

Device (RP07)
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
If ((RPA7 != Zero))
{
Return (RPA7) /* \RPA7 */
}
Else
{
Return (0x001C0006)
}
}

Name (SLOT, 0x07)
Name (LTEN, Zero)
Name (LMSL, Zero)
Name (LNSL, Zero)
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
LTEN = LTR7 /* \LTR7 */
LMSL = PML7 /* \PML7 */
LNSL = PNL7 /* \PNL7 */
If ((HBSL & 0x02))
{
HBCS = One
}

If ((CondRefOf (VMR1) && CondRefOf (VMDE)))
{
If (((VMDE == One) && ((VMR1 & 0x40) != Zero)))
{
PRMV = One
}
}

If (PRES ())
{
If (CondRefOf (PINI))
{
PINI ()
}
}

If (CondRefOf (\_SB.PC00.RP07))
{
If ((VDID != 0xFFFFFFFF))
{
If (CondRefOf (\STD3))
{
If (CondRefOf (\_SB.PC00.RP07.PRMV))
{
If ((PRMV == One))
{
RD3C = STD3 /* \STD3 */
}
}

If ((^PXSX.PNVM () || ^PXSX.PAHC ()))
{
RD3C = STD3 /* \STD3 */
}
}
}
}
}

SIPV = GSIP ()
Name (PRTP, 0x02)
OperationRegion (PXCS, SystemMemory, PC2M (_ADR ()), 0x0480)
Field (PXCS, AnyAcc, NoLock, Preserve)
{
VDID, 32,
Offset (0x50),
L0SE, 1,
, 3,
LDIS, 1,
Offset (0x51),
Offset (0x52),
, 13,
LASX, 1,
Offset (0x5A),
ABPX, 1,
, 2,
PDCX, 1,
, 2,
PDSX, 1,
Offset (0x5B),
Offset (0x60),
Offset (0x62),
PSPX, 1,
Offset (0xA4),
D3HT, 2,
Offset (0xD8),
, 30,
HPEX, 1,
PMEX, 1,
Offset (0xE0),
SCB0, 1,
, 6,
NCB7, 1,
Offset (0xE2),
, 2,
L23E, 1,
L23R, 1,
Offset (0x328),
, 19,
LNKS, 4
}

Field (PXCS, AnyAcc, NoLock, WriteAsZeros)
{
Offset (0xDC),
, 30,
HPSX, 1,
PMSX, 1
}

Method (L23D, 0, Serialized)
{
If ((SIPV < 0x10))
{
If ((NCB7 != One))
{
Return (Zero)
}
}
ElseIf ((SCB0 != One))
{
Return (Zero)
}

L23R = One
Local0 = Zero
While (L23R)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = Zero
}
Else
{
SCB0 = Zero
}

Local0 = Zero
While ((LASX == Zero))
{
If ((Local0 > 0x08))
{
Break
}

Sleep (0x10)
Local0++
}
}

Method (DL23, 0, Serialized)
{
L23E = One
Sleep (0x10)
Local0 = Zero
While (L23E)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = One
}
Else
{
SCB0 = One
}
}

Name (LTRV, Package (0x04)
{
Zero,
Zero,
Zero,
Zero
})
Name (HBCS, Zero)
Name (PRMV, Zero)
Name (RD3C, 0x02)
Method (PRES, 0, NotSerialized)
{
If ((VDID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If ((Arg0 == ToUUID ("e5c937d0-3553-4d7a-9117-ea4d19c3434d") /* Device Labeling Interface */))
{
Switch (ToInteger (Arg2))
{
Case (Zero)
{
Name (OPTS, Buffer (0x02)
{
0x00, 0x00 // ..
})
CreateBitField (OPTS, Zero, FUN0)
CreateBitField (OPTS, 0x06, FUN6)
CreateBitField (OPTS, 0x08, FUN8)
CreateBitField (OPTS, 0x09, FUN9)
CreateBitField (OPTS, 0x0A, FUNA)
CreateBitField (OPTS, 0x0B, FUNB)
If ((Arg1 >= 0x02))
{
FUN0 = One
If ((LTEN != Zero))
{
FUN6 = One
}

If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
FUN8 = One
FUN9 = One
}
}
}
}

If ((Arg1 >= 0x04))
{
If (CondRefOf (PPBA))
{
FUNA = One
}

If (CondRefOf (UPRD))
{
FUNB = One
}
}

Return (OPTS) /* \_SB_.PC00.RP07._DSM.OPTS */
}
Case (0x06)
{
If ((Arg1 >= 0x02))
{
LTRV [Zero] = ((LMSL >> 0x0A) & 0x07)
LTRV [One] = (LMSL & 0x03FF)
LTRV [0x02] = ((LNSL >> 0x0A) & 0x07)
LTRV [0x03] = (LNSL & 0x03FF)
Return (LTRV) /* \_SB_.PC00.RP07.LTRV */
}
}
Case (0x08)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (One)
}
}
}
}
Case (0x09)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (Package (0x05)
{
0xC350,
Ones,
Ones,
0xC350,
Ones
})
}
}
}
}
Case (0x0A)
{
If (CondRefOf (PPBA))
{
Return (PPBA (Arg3))
}
}
Case (0x0B)
{
If (CondRefOf (UPRD))
{
Return (UPRD (Arg3))
}
}

}
}

Return (Buffer (One)
{
0x00 // .
})
}

Device (PXSX)
{
Name (_ADR, Zero) // _ADR: Address
OperationRegion (PCCX, PCI_Config, Zero, 0x10)
Field (PCCX, ByteAcc, NoLock, Preserve)
{
DVID, 32,
Offset (0x09),
PIXX, 8,
SCCX, 8,
BCCX, 8
}

Method (PAHC, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x06))
{
If ((PIXX == One))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PNVM, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x08))
{
If ((PIXX == 0x02))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PRES, 0, Serialized)
{
If ((DVID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (ISGX, 0, Serialized)
{
If ((BCCX == 0x03))
{
Return (One)
}

Return (Zero)
}

If (CondRefOf (\STD3))
{
If ((STD3 != Zero))
{
Method (_DSD, 0, NotSerialized) // _DSD: Device-Specific Data
{
If ((PAHC () || PNVM ()))
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
One
}
}
})
}
Else
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
Zero
}
}
})
}
}
}
}

Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake
{
Return (GPRW (0x69, 0x03))
}
}

Method (_PS0, 0, Serialized) // _PS0: Power State 0
{
If (CondRefOf (PPS0))
{
PPS0 ()
}
}

Method (_PS3, 0, Serialized) // _PS3: Power State 3
{
If (CondRefOf (PPS3))
{
PPS3 ()
}
}

Method (HPME, 0, Serialized)
{
If (((VDID != 0xFFFFFFFF) && (PMSX == One)))
{
Notify (PXSX, 0x02) // Device Wake
PMSX = One
PSPX = One
}
}

Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table
{
If (CondRefOf (PICM))
{
If (PICM)
{
Return (AR06 ())
}
}

Return (PD06 ())
}
}

Device (RP08)
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
If ((RPA8 != Zero))
{
Return (RPA8) /* \RPA8 */
}
Else
{
Return (0x001C0007)
}
}

Name (SLOT, 0x08)
Name (LTEN, Zero)
Name (LMSL, Zero)
Name (LNSL, Zero)
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
LTEN = LTR8 /* \LTR8 */
LMSL = PML8 /* \PML8 */
LNSL = PNL8 /* \PNL8 */
If ((HBSL & 0x02))
{
HBCS = One
}

If ((CondRefOf (VMR1) && CondRefOf (VMDE)))
{
If (((VMDE == One) && ((VMR1 & 0x80) != Zero)))
{
PRMV = One
}
}

If (PRES ())
{
If (CondRefOf (PINI))
{
PINI ()
}
}

If (CondRefOf (\_SB.PC00.RP08))
{
If ((VDID != 0xFFFFFFFF))
{
If (CondRefOf (\STD3))
{
If (CondRefOf (\_SB.PC00.RP08.PRMV))
{
If ((PRMV == One))
{
RD3C = STD3 /* \STD3 */
}
}

If ((^PXSX.PNVM () || ^PXSX.PAHC ()))
{
RD3C = STD3 /* \STD3 */
}
}
}
}
}

SIPV = GSIP ()
Name (PRTP, 0x02)
OperationRegion (PXCS, SystemMemory, PC2M (_ADR ()), 0x0480)
Field (PXCS, AnyAcc, NoLock, Preserve)
{
VDID, 32,
Offset (0x50),
L0SE, 1,
, 3,
LDIS, 1,
Offset (0x51),
Offset (0x52),
, 13,
LASX, 1,
Offset (0x5A),
ABPX, 1,
, 2,
PDCX, 1,
, 2,
PDSX, 1,
Offset (0x5B),
Offset (0x60),
Offset (0x62),
PSPX, 1,
Offset (0xA4),
D3HT, 2,
Offset (0xD8),
, 30,
HPEX, 1,
PMEX, 1,
Offset (0xE0),
SCB0, 1,
, 6,
NCB7, 1,
Offset (0xE2),
, 2,
L23E, 1,
L23R, 1,
Offset (0x328),
, 19,
LNKS, 4
}

Field (PXCS, AnyAcc, NoLock, WriteAsZeros)
{
Offset (0xDC),
, 30,
HPSX, 1,
PMSX, 1
}

Method (L23D, 0, Serialized)
{
If ((SIPV < 0x10))
{
If ((NCB7 != One))
{
Return (Zero)
}
}
ElseIf ((SCB0 != One))
{
Return (Zero)
}

L23R = One
Local0 = Zero
While (L23R)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = Zero
}
Else
{
SCB0 = Zero
}

Local0 = Zero
While ((LASX == Zero))
{
If ((Local0 > 0x08))
{
Break
}

Sleep (0x10)
Local0++
}
}

Method (DL23, 0, Serialized)
{
L23E = One
Sleep (0x10)
Local0 = Zero
While (L23E)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = One
}
Else
{
SCB0 = One
}
}

Name (LTRV, Package (0x04)
{
Zero,
Zero,
Zero,
Zero
})
Name (HBCS, Zero)
Name (PRMV, Zero)
Name (RD3C, 0x02)
Method (PRES, 0, NotSerialized)
{
If ((VDID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If ((Arg0 == ToUUID ("e5c937d0-3553-4d7a-9117-ea4d19c3434d") /* Device Labeling Interface */))
{
Switch (ToInteger (Arg2))
{
Case (Zero)
{
Name (OPTS, Buffer (0x02)
{
0x00, 0x00 // ..
})
CreateBitField (OPTS, Zero, FUN0)
CreateBitField (OPTS, 0x06, FUN6)
CreateBitField (OPTS, 0x08, FUN8)
CreateBitField (OPTS, 0x09, FUN9)
CreateBitField (OPTS, 0x0A, FUNA)
CreateBitField (OPTS, 0x0B, FUNB)
If ((Arg1 >= 0x02))
{
FUN0 = One
If ((LTEN != Zero))
{
FUN6 = One
}

If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
FUN8 = One
FUN9 = One
}
}
}
}

If ((Arg1 >= 0x04))
{
If (CondRefOf (PPBA))
{
FUNA = One
}

If (CondRefOf (UPRD))
{
FUNB = One
}
}

Return (OPTS) /* \_SB_.PC00.RP08._DSM.OPTS */
}
Case (0x06)
{
If ((Arg1 >= 0x02))
{
LTRV [Zero] = ((LMSL >> 0x0A) & 0x07)
LTRV [One] = (LMSL & 0x03FF)
LTRV [0x02] = ((LNSL >> 0x0A) & 0x07)
LTRV [0x03] = (LNSL & 0x03FF)
Return (LTRV) /* \_SB_.PC00.RP08.LTRV */
}
}
Case (0x08)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (One)
}
}
}
}
Case (0x09)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (Package (0x05)
{
0xC350,
Ones,
Ones,
0xC350,
Ones
})
}
}
}
}
Case (0x0A)
{
If (CondRefOf (PPBA))
{
Return (PPBA (Arg3))
}
}
Case (0x0B)
{
If (CondRefOf (UPRD))
{
Return (UPRD (Arg3))
}
}

}
}

Return (Buffer (One)
{
0x00 // .
})
}

Device (PXSX)
{
Name (_ADR, Zero) // _ADR: Address
OperationRegion (PCCX, PCI_Config, Zero, 0x10)
Field (PCCX, ByteAcc, NoLock, Preserve)
{
DVID, 32,
Offset (0x09),
PIXX, 8,
SCCX, 8,
BCCX, 8
}

Method (PAHC, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x06))
{
If ((PIXX == One))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PNVM, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x08))
{
If ((PIXX == 0x02))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PRES, 0, Serialized)
{
If ((DVID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (ISGX, 0, Serialized)
{
If ((BCCX == 0x03))
{
Return (One)
}

Return (Zero)
}

If (CondRefOf (\STD3))
{
If ((STD3 != Zero))
{
Method (_DSD, 0, NotSerialized) // _DSD: Device-Specific Data
{
If ((PAHC () || PNVM ()))
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
One
}
}
})
}
Else
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
Zero
}
}
})
}
}
}
}

Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake
{
Return (GPRW (0x69, 0x03))
}
}

Method (_PS0, 0, Serialized) // _PS0: Power State 0
{
If (CondRefOf (PPS0))
{
PPS0 ()
}
}

Method (_PS3, 0, Serialized) // _PS3: Power State 3
{
If (CondRefOf (PPS3))
{
PPS3 ()
}
}

Method (HPME, 0, Serialized)
{
If (((VDID != 0xFFFFFFFF) && (PMSX == One)))
{
Notify (PXSX, 0x02) // Device Wake
PMSX = One
PSPX = One
}
}

Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table
{
If (CondRefOf (PICM))
{
If (PICM)
{
Return (AR07 ())
}
}

Return (PD07 ())
}
}

Device (RP09)
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
If ((RPA9 != Zero))
{
Return (RPA9) /* \RPA9 */
}
Else
{
Return (0x001D0000)
}
}

Name (SLOT, 0x09)
Name (LTEN, Zero)
Name (LMSL, Zero)
Name (LNSL, Zero)
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
LTEN = LTR9 /* \LTR9 */
LMSL = PML9 /* \PML9 */
LNSL = PNL9 /* \PNL9 */
If ((HBSL & 0x04))
{
HBCS = One
}

If ((CondRefOf (VMR2) && CondRefOf (VMDE)))
{
If (((VMDE == One) && ((VMR2 & One) != Zero)))
{
PRMV = One
}
}

If (PRES ())
{
If (CondRefOf (PINI))
{
PINI ()
}
}

If (CondRefOf (\_SB.PC00.RP09))
{
If ((VDID != 0xFFFFFFFF))
{
If (CondRefOf (\STD3))
{
If (CondRefOf (\_SB.PC00.RP09.PRMV))
{
If ((PRMV == One))
{
RD3C = STD3 /* \STD3 */
}
}

If ((^PXSX.PNVM () || ^PXSX.PAHC ()))
{
RD3C = STD3 /* \STD3 */
}
}
}
}
}

SIPV = GSIP ()
Name (PRTP, 0x02)
OperationRegion (PXCS, SystemMemory, PC2M (_ADR ()), 0x0480)
Field (PXCS, AnyAcc, NoLock, Preserve)
{
VDID, 32,
Offset (0x50),
L0SE, 1,
, 3,
LDIS, 1,
Offset (0x51),
Offset (0x52),
, 13,
LASX, 1,
Offset (0x5A),
ABPX, 1,
, 2,
PDCX, 1,
, 2,
PDSX, 1,
Offset (0x5B),
Offset (0x60),
Offset (0x62),
PSPX, 1,
Offset (0xA4),
D3HT, 2,
Offset (0xD8),
, 30,
HPEX, 1,
PMEX, 1,
Offset (0xE0),
SCB0, 1,
, 6,
NCB7, 1,
Offset (0xE2),
, 2,
L23E, 1,
L23R, 1,
Offset (0x328),
, 19,
LNKS, 4
}

Field (PXCS, AnyAcc, NoLock, WriteAsZeros)
{
Offset (0xDC),
, 30,
HPSX, 1,
PMSX, 1
}

Method (L23D, 0, Serialized)
{
If ((SIPV < 0x10))
{
If ((NCB7 != One))
{
Return (Zero)
}
}
ElseIf ((SCB0 != One))
{
Return (Zero)
}

L23R = One
Local0 = Zero
While (L23R)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = Zero
}
Else
{
SCB0 = Zero
}

Local0 = Zero
While ((LASX == Zero))
{
If ((Local0 > 0x08))
{
Break
}

Sleep (0x10)
Local0++
}
}

Method (DL23, 0, Serialized)
{
L23E = One
Sleep (0x10)
Local0 = Zero
While (L23E)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = One
}
Else
{
SCB0 = One
}
}

Name (LTRV, Package (0x04)
{
Zero,
Zero,
Zero,
Zero
})
Name (HBCS, Zero)
Name (PRMV, Zero)
Name (RD3C, 0x02)
Method (PRES, 0, NotSerialized)
{
If ((VDID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If ((Arg0 == ToUUID ("e5c937d0-3553-4d7a-9117-ea4d19c3434d") /* Device Labeling Interface */))
{
Switch (ToInteger (Arg2))
{
Case (Zero)
{
Name (OPTS, Buffer (0x02)
{
0x00, 0x00 // ..
})
CreateBitField (OPTS, Zero, FUN0)
CreateBitField (OPTS, 0x06, FUN6)
CreateBitField (OPTS, 0x08, FUN8)
CreateBitField (OPTS, 0x09, FUN9)
CreateBitField (OPTS, 0x0A, FUNA)
CreateBitField (OPTS, 0x0B, FUNB)
If ((Arg1 >= 0x02))
{
FUN0 = One
If ((LTEN != Zero))
{
FUN6 = One
}

If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
FUN8 = One
FUN9 = One
}
}
}
}

If ((Arg1 >= 0x04))
{
If (CondRefOf (PPBA))
{
FUNA = One
}

If (CondRefOf (UPRD))
{
FUNB = One
}
}

Return (OPTS) /* \_SB_.PC00.RP09._DSM.OPTS */
}
Case (0x06)
{
If ((Arg1 >= 0x02))
{
LTRV [Zero] = ((LMSL >> 0x0A) & 0x07)
LTRV [One] = (LMSL & 0x03FF)
LTRV [0x02] = ((LNSL >> 0x0A) & 0x07)
LTRV [0x03] = (LNSL & 0x03FF)
Return (LTRV) /* \_SB_.PC00.RP09.LTRV */
}
}
Case (0x08)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (One)
}
}
}
}
Case (0x09)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (Package (0x05)
{
0xC350,
Ones,
Ones,
0xC350,
Ones
})
}
}
}
}
Case (0x0A)
{
If (CondRefOf (PPBA))
{
Return (PPBA (Arg3))
}
}
Case (0x0B)
{
If (CondRefOf (UPRD))
{
Return (UPRD (Arg3))
}
}

}
}

Return (Buffer (One)
{
0x00 // .
})
}

Device (PXSX)
{
Name (_ADR, Zero) // _ADR: Address
OperationRegion (PCCX, PCI_Config, Zero, 0x10)
Field (PCCX, ByteAcc, NoLock, Preserve)
{
DVID, 32,
Offset (0x09),
PIXX, 8,
SCCX, 8,
BCCX, 8
}

Method (PAHC, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x06))
{
If ((PIXX == One))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PNVM, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x08))
{
If ((PIXX == 0x02))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PRES, 0, Serialized)
{
If ((DVID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (ISGX, 0, Serialized)
{
If ((BCCX == 0x03))
{
Return (One)
}

Return (Zero)
}

If (CondRefOf (\STD3))
{
If ((STD3 != Zero))
{
Method (_DSD, 0, NotSerialized) // _DSD: Device-Specific Data
{
If ((PAHC () || PNVM ()))
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
One
}
}
})
}
Else
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
Zero
}
}
})
}
}
}
}

Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake
{
Return (GPRW (0x69, 0x03))
}
}

Method (_PS0, 0, Serialized) // _PS0: Power State 0
{
If (CondRefOf (PPS0))
{
PPS0 ()
}
}

Method (_PS3, 0, Serialized) // _PS3: Power State 3
{
If (CondRefOf (PPS3))
{
PPS3 ()
}
}

Method (HPME, 0, Serialized)
{
If (((VDID != 0xFFFFFFFF) && (PMSX == One)))
{
Notify (PXSX, 0x02) // Device Wake
PMSX = One
PSPX = One
}
}

Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table
{
If (CondRefOf (PICM))
{
If (PICM)
{
Return (AR04 ())
}
}

Return (PD04 ())
}
}

Device (RP10)
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
If ((RPAA != Zero))
{
Return (RPAA) /* \RPAA */
}
Else
{
Return (0x001D0001)
}
}

Name (SLOT, 0x0A)
Name (LTEN, Zero)
Name (LMSL, Zero)
Name (LNSL, Zero)
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
LTEN = LTRA /* \LTRA */
LMSL = PMLA /* \PMLA */
LNSL = PNLA /* \PNLA */
If ((HBSL & 0x04))
{
HBCS = One
}

If ((CondRefOf (VMR2) && CondRefOf (VMDE)))
{
If (((VMDE == One) && ((VMR2 & 0x02) != Zero)))
{
PRMV = One
}
}

If (PRES ())
{
If (CondRefOf (PINI))
{
PINI ()
}
}

If (CondRefOf (\_SB.PC00.RP10))
{
If ((VDID != 0xFFFFFFFF))
{
If (CondRefOf (\STD3))
{
If (CondRefOf (\_SB.PC00.RP10.PRMV))
{
If ((PRMV == One))
{
RD3C = STD3 /* \STD3 */
}
}

If ((^PXSX.PNVM () || ^PXSX.PAHC ()))
{
RD3C = STD3 /* \STD3 */
}
}
}
}
}

SIPV = GSIP ()
Name (PRTP, 0x02)
OperationRegion (PXCS, SystemMemory, PC2M (_ADR ()), 0x0480)
Field (PXCS, AnyAcc, NoLock, Preserve)
{
VDID, 32,
Offset (0x50),
L0SE, 1,
, 3,
LDIS, 1,
Offset (0x51),
Offset (0x52),
, 13,
LASX, 1,
Offset (0x5A),
ABPX, 1,
, 2,
PDCX, 1,
, 2,
PDSX, 1,
Offset (0x5B),
Offset (0x60),
Offset (0x62),
PSPX, 1,
Offset (0xA4),
D3HT, 2,
Offset (0xD8),
, 30,
HPEX, 1,
PMEX, 1,
Offset (0xE0),
SCB0, 1,
, 6,
NCB7, 1,
Offset (0xE2),
, 2,
L23E, 1,
L23R, 1,
Offset (0x328),
, 19,
LNKS, 4
}

Field (PXCS, AnyAcc, NoLock, WriteAsZeros)
{
Offset (0xDC),
, 30,
HPSX, 1,
PMSX, 1
}

Method (L23D, 0, Serialized)
{
If ((SIPV < 0x10))
{
If ((NCB7 != One))
{
Return (Zero)
}
}
ElseIf ((SCB0 != One))
{
Return (Zero)
}

L23R = One
Local0 = Zero
While (L23R)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = Zero
}
Else
{
SCB0 = Zero
}

Local0 = Zero
While ((LASX == Zero))
{
If ((Local0 > 0x08))
{
Break
}

Sleep (0x10)
Local0++
}
}

Method (DL23, 0, Serialized)
{
L23E = One
Sleep (0x10)
Local0 = Zero
While (L23E)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = One
}
Else
{
SCB0 = One
}
}

Name (LTRV, Package (0x04)
{
Zero,
Zero,
Zero,
Zero
})
Name (HBCS, Zero)
Name (PRMV, Zero)
Name (RD3C, 0x02)
Method (PRES, 0, NotSerialized)
{
If ((VDID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If ((Arg0 == ToUUID ("e5c937d0-3553-4d7a-9117-ea4d19c3434d") /* Device Labeling Interface */))
{
Switch (ToInteger (Arg2))
{
Case (Zero)
{
Name (OPTS, Buffer (0x02)
{
0x00, 0x00 // ..
})
CreateBitField (OPTS, Zero, FUN0)
CreateBitField (OPTS, 0x06, FUN6)
CreateBitField (OPTS, 0x08, FUN8)
CreateBitField (OPTS, 0x09, FUN9)
CreateBitField (OPTS, 0x0A, FUNA)
CreateBitField (OPTS, 0x0B, FUNB)
If ((Arg1 >= 0x02))
{
FUN0 = One
If ((LTEN != Zero))
{
FUN6 = One
}

If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
FUN8 = One
FUN9 = One
}
}
}
}

If ((Arg1 >= 0x04))
{
If (CondRefOf (PPBA))
{
FUNA = One
}

If (CondRefOf (UPRD))
{
FUNB = One
}
}

Return (OPTS) /* \_SB_.PC00.RP10._DSM.OPTS */
}
Case (0x06)
{
If ((Arg1 >= 0x02))
{
LTRV [Zero] = ((LMSL >> 0x0A) & 0x07)
LTRV [One] = (LMSL & 0x03FF)
LTRV [0x02] = ((LNSL >> 0x0A) & 0x07)
LTRV [0x03] = (LNSL & 0x03FF)
Return (LTRV) /* \_SB_.PC00.RP10.LTRV */
}
}
Case (0x08)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (One)
}
}
}
}
Case (0x09)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (Package (0x05)
{
0xC350,
Ones,
Ones,
0xC350,
Ones
})
}
}
}
}
Case (0x0A)
{
If (CondRefOf (PPBA))
{
Return (PPBA (Arg3))
}
}
Case (0x0B)
{
If (CondRefOf (UPRD))
{
Return (UPRD (Arg3))
}
}

}
}

Return (Buffer (One)
{
0x00 // .
})
}

Device (PXSX)
{
Name (_ADR, Zero) // _ADR: Address
OperationRegion (PCCX, PCI_Config, Zero, 0x10)
Field (PCCX, ByteAcc, NoLock, Preserve)
{
DVID, 32,
Offset (0x09),
PIXX, 8,
SCCX, 8,
BCCX, 8
}

Method (PAHC, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x06))
{
If ((PIXX == One))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PNVM, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x08))
{
If ((PIXX == 0x02))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PRES, 0, Serialized)
{
If ((DVID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (ISGX, 0, Serialized)
{
If ((BCCX == 0x03))
{
Return (One)
}

Return (Zero)
}

If (CondRefOf (\STD3))
{
If ((STD3 != Zero))
{
Method (_DSD, 0, NotSerialized) // _DSD: Device-Specific Data
{
If ((PAHC () || PNVM ()))
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
One
}
}
})
}
Else
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
Zero
}
}
})
}
}
}
}

Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake
{
Return (GPRW (0x69, 0x03))
}
}

Method (_PS0, 0, Serialized) // _PS0: Power State 0
{
If (CondRefOf (PPS0))
{
PPS0 ()
}
}

Method (_PS3, 0, Serialized) // _PS3: Power State 3
{
If (CondRefOf (PPS3))
{
PPS3 ()
}
}

Method (HPME, 0, Serialized)
{
If (((VDID != 0xFFFFFFFF) && (PMSX == One)))
{
Notify (PXSX, 0x02) // Device Wake
PMSX = One
PSPX = One
}
}

Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table
{
If (CondRefOf (PICM))
{
If (PICM)
{
Return (AR05 ())
}
}

Return (PD05 ())
}
}

Device (RP11)
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
If ((RPAB != Zero))
{
Return (RPAB) /* \RPAB */
}
Else
{
Return (0x001D0002)
}
}

Name (SLOT, 0x0B)
Name (LTEN, Zero)
Name (LMSL, Zero)
Name (LNSL, Zero)
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
LTEN = LTRB /* \LTRB */
LMSL = PMLB /* \PMLB */
LNSL = PNLB /* \PNLB */
If ((HBSL & 0x04))
{
HBCS = One
}

If ((CondRefOf (VMR2) && CondRefOf (VMDE)))
{
If (((VMDE == One) && ((VMR2 & 0x04) != Zero)))
{
PRMV = One
}
}

If (PRES ())
{
If (CondRefOf (PINI))
{
PINI ()
}
}

If (CondRefOf (\_SB.PC00.RP11))
{
If ((VDID != 0xFFFFFFFF))
{
If (CondRefOf (\STD3))
{
If (CondRefOf (\_SB.PC00.RP11.PRMV))
{
If ((PRMV == One))
{
RD3C = STD3 /* \STD3 */
}
}

If ((^PXSX.PNVM () || ^PXSX.PAHC ()))
{
RD3C = STD3 /* \STD3 */
}
}
}
}
}

SIPV = GSIP ()
Name (PRTP, 0x02)
OperationRegion (PXCS, SystemMemory, PC2M (_ADR ()), 0x0480)
Field (PXCS, AnyAcc, NoLock, Preserve)
{
VDID, 32,
Offset (0x50),
L0SE, 1,
, 3,
LDIS, 1,
Offset (0x51),
Offset (0x52),
, 13,
LASX, 1,
Offset (0x5A),
ABPX, 1,
, 2,
PDCX, 1,
, 2,
PDSX, 1,
Offset (0x5B),
Offset (0x60),
Offset (0x62),
PSPX, 1,
Offset (0xA4),
D3HT, 2,
Offset (0xD8),
, 30,
HPEX, 1,
PMEX, 1,
Offset (0xE0),
SCB0, 1,
, 6,
NCB7, 1,
Offset (0xE2),
, 2,
L23E, 1,
L23R, 1,
Offset (0x328),
, 19,
LNKS, 4
}

Field (PXCS, AnyAcc, NoLock, WriteAsZeros)
{
Offset (0xDC),
, 30,
HPSX, 1,
PMSX, 1
}

Method (L23D, 0, Serialized)
{
If ((SIPV < 0x10))
{
If ((NCB7 != One))
{
Return (Zero)
}
}
ElseIf ((SCB0 != One))
{
Return (Zero)
}

L23R = One
Local0 = Zero
While (L23R)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = Zero
}
Else
{
SCB0 = Zero
}

Local0 = Zero
While ((LASX == Zero))
{
If ((Local0 > 0x08))
{
Break
}

Sleep (0x10)
Local0++
}
}

Method (DL23, 0, Serialized)
{
L23E = One
Sleep (0x10)
Local0 = Zero
While (L23E)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = One
}
Else
{
SCB0 = One
}
}

Name (LTRV, Package (0x04)
{
Zero,
Zero,
Zero,
Zero
})
Name (HBCS, Zero)
Name (PRMV, Zero)
Name (RD3C, 0x02)
Method (PRES, 0, NotSerialized)
{
If ((VDID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If ((Arg0 == ToUUID ("e5c937d0-3553-4d7a-9117-ea4d19c3434d") /* Device Labeling Interface */))
{
Switch (ToInteger (Arg2))
{
Case (Zero)
{
Name (OPTS, Buffer (0x02)
{
0x00, 0x00 // ..
})
CreateBitField (OPTS, Zero, FUN0)
CreateBitField (OPTS, 0x06, FUN6)
CreateBitField (OPTS, 0x08, FUN8)
CreateBitField (OPTS, 0x09, FUN9)
CreateBitField (OPTS, 0x0A, FUNA)
CreateBitField (OPTS, 0x0B, FUNB)
If ((Arg1 >= 0x02))
{
FUN0 = One
If ((LTEN != Zero))
{
FUN6 = One
}

If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
FUN8 = One
FUN9 = One
}
}
}
}

If ((Arg1 >= 0x04))
{
If (CondRefOf (PPBA))
{
FUNA = One
}

If (CondRefOf (UPRD))
{
FUNB = One
}
}

Return (OPTS) /* \_SB_.PC00.RP11._DSM.OPTS */
}
Case (0x06)
{
If ((Arg1 >= 0x02))
{
LTRV [Zero] = ((LMSL >> 0x0A) & 0x07)
LTRV [One] = (LMSL & 0x03FF)
LTRV [0x02] = ((LNSL >> 0x0A) & 0x07)
LTRV [0x03] = (LNSL & 0x03FF)
Return (LTRV) /* \_SB_.PC00.RP11.LTRV */
}
}
Case (0x08)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (One)
}
}
}
}
Case (0x09)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (Package (0x05)
{
0xC350,
Ones,
Ones,
0xC350,
Ones
})
}
}
}
}
Case (0x0A)
{
If (CondRefOf (PPBA))
{
Return (PPBA (Arg3))
}
}
Case (0x0B)
{
If (CondRefOf (UPRD))
{
Return (UPRD (Arg3))
}
}

}
}

Return (Buffer (One)
{
0x00 // .
})
}

Device (PXSX)
{
Name (_ADR, Zero) // _ADR: Address
OperationRegion (PCCX, PCI_Config, Zero, 0x10)
Field (PCCX, ByteAcc, NoLock, Preserve)
{
DVID, 32,
Offset (0x09),
PIXX, 8,
SCCX, 8,
BCCX, 8
}

Method (PAHC, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x06))
{
If ((PIXX == One))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PNVM, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x08))
{
If ((PIXX == 0x02))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PRES, 0, Serialized)
{
If ((DVID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (ISGX, 0, Serialized)
{
If ((BCCX == 0x03))
{
Return (One)
}

Return (Zero)
}

If (CondRefOf (\STD3))
{
If ((STD3 != Zero))
{
Method (_DSD, 0, NotSerialized) // _DSD: Device-Specific Data
{
If ((PAHC () || PNVM ()))
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
One
}
}
})
}
Else
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
Zero
}
}
})
}
}
}
}

Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake
{
Return (GPRW (0x69, 0x03))
}
}

Method (_PS0, 0, Serialized) // _PS0: Power State 0
{
If (CondRefOf (PPS0))
{
PPS0 ()
}
}

Method (_PS3, 0, Serialized) // _PS3: Power State 3
{
If (CondRefOf (PPS3))
{
PPS3 ()
}
}

Method (HPME, 0, Serialized)
{
If (((VDID != 0xFFFFFFFF) && (PMSX == One)))
{
Notify (PXSX, 0x02) // Device Wake
PMSX = One
PSPX = One
}
}

Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table
{
If (CondRefOf (PICM))
{
If (PICM)
{
Return (AR06 ())
}
}

Return (PD06 ())
}
}

Device (RP12)
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
If ((RPAC != Zero))
{
Return (RPAC) /* \RPAC */
}
Else
{
Return (0x001D0003)
}
}

Name (SLOT, 0x0C)
Name (LTEN, Zero)
Name (LMSL, Zero)
Name (LNSL, Zero)
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
LTEN = LTRC /* \LTRC */
LMSL = PMLC /* \PMLC */
LNSL = PNLC /* \PNLC */
If ((HBSL & 0x04))
{
HBCS = One
}

If ((CondRefOf (VMR2) && CondRefOf (VMDE)))
{
If (((VMDE == One) && ((VMR2 & 0x08) != Zero)))
{
PRMV = One
}
}

If (PRES ())
{
If (CondRefOf (PINI))
{
PINI ()
}
}

If (CondRefOf (\_SB.PC00.RP12))
{
If ((VDID != 0xFFFFFFFF))
{
If (CondRefOf (\STD3))
{
If (CondRefOf (\_SB.PC00.RP12.PRMV))
{
If ((PRMV == One))
{
RD3C = STD3 /* \STD3 */
}
}

If ((^PXSX.PNVM () || ^PXSX.PAHC ()))
{
RD3C = STD3 /* \STD3 */
}
}
}
}
}

SIPV = GSIP ()
Name (PRTP, 0x02)
OperationRegion (PXCS, SystemMemory, PC2M (_ADR ()), 0x0480)
Field (PXCS, AnyAcc, NoLock, Preserve)
{
VDID, 32,
Offset (0x50),
L0SE, 1,
, 3,
LDIS, 1,
Offset (0x51),
Offset (0x52),
, 13,
LASX, 1,
Offset (0x5A),
ABPX, 1,
, 2,
PDCX, 1,
, 2,
PDSX, 1,
Offset (0x5B),
Offset (0x60),
Offset (0x62),
PSPX, 1,
Offset (0xA4),
D3HT, 2,
Offset (0xD8),
, 30,
HPEX, 1,
PMEX, 1,
Offset (0xE0),
SCB0, 1,
, 6,
NCB7, 1,
Offset (0xE2),
, 2,
L23E, 1,
L23R, 1,
Offset (0x328),
, 19,
LNKS, 4
}

Field (PXCS, AnyAcc, NoLock, WriteAsZeros)
{
Offset (0xDC),
, 30,
HPSX, 1,
PMSX, 1
}

Method (L23D, 0, Serialized)
{
If ((SIPV < 0x10))
{
If ((NCB7 != One))
{
Return (Zero)
}
}
ElseIf ((SCB0 != One))
{
Return (Zero)
}

L23R = One
Local0 = Zero
While (L23R)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = Zero
}
Else
{
SCB0 = Zero
}

Local0 = Zero
While ((LASX == Zero))
{
If ((Local0 > 0x08))
{
Break
}

Sleep (0x10)
Local0++
}
}

Method (DL23, 0, Serialized)
{
L23E = One
Sleep (0x10)
Local0 = Zero
While (L23E)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = One
}
Else
{
SCB0 = One
}
}

Name (LTRV, Package (0x04)
{
Zero,
Zero,
Zero,
Zero
})
Name (HBCS, Zero)
Name (PRMV, Zero)
Name (RD3C, 0x02)
Method (PRES, 0, NotSerialized)
{
If ((VDID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If ((Arg0 == ToUUID ("e5c937d0-3553-4d7a-9117-ea4d19c3434d") /* Device Labeling Interface */))
{
Switch (ToInteger (Arg2))
{
Case (Zero)
{
Name (OPTS, Buffer (0x02)
{
0x00, 0x00 // ..
})
CreateBitField (OPTS, Zero, FUN0)
CreateBitField (OPTS, 0x06, FUN6)
CreateBitField (OPTS, 0x08, FUN8)
CreateBitField (OPTS, 0x09, FUN9)
CreateBitField (OPTS, 0x0A, FUNA)
CreateBitField (OPTS, 0x0B, FUNB)
If ((Arg1 >= 0x02))
{
FUN0 = One
If ((LTEN != Zero))
{
FUN6 = One
}

If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
FUN8 = One
FUN9 = One
}
}
}
}

If ((Arg1 >= 0x04))
{
If (CondRefOf (PPBA))
{
FUNA = One
}

If (CondRefOf (UPRD))
{
FUNB = One
}
}

Return (OPTS) /* \_SB_.PC00.RP12._DSM.OPTS */
}
Case (0x06)
{
If ((Arg1 >= 0x02))
{
LTRV [Zero] = ((LMSL >> 0x0A) & 0x07)
LTRV [One] = (LMSL & 0x03FF)
LTRV [0x02] = ((LNSL >> 0x0A) & 0x07)
LTRV [0x03] = (LNSL & 0x03FF)
Return (LTRV) /* \_SB_.PC00.RP12.LTRV */
}
}
Case (0x08)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (One)
}
}
}
}
Case (0x09)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (Package (0x05)
{
0xC350,
Ones,
Ones,
0xC350,
Ones
})
}
}
}
}
Case (0x0A)
{
If (CondRefOf (PPBA))
{
Return (PPBA (Arg3))
}
}
Case (0x0B)
{
If (CondRefOf (UPRD))
{
Return (UPRD (Arg3))
}
}

}
}

Return (Buffer (One)
{
0x00 // .
})
}

Device (PXSX)
{
Name (_ADR, Zero) // _ADR: Address
OperationRegion (PCCX, PCI_Config, Zero, 0x10)
Field (PCCX, ByteAcc, NoLock, Preserve)
{
DVID, 32,
Offset (0x09),
PIXX, 8,
SCCX, 8,
BCCX, 8
}

Method (PAHC, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x06))
{
If ((PIXX == One))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PNVM, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x08))
{
If ((PIXX == 0x02))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PRES, 0, Serialized)
{
If ((DVID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (ISGX, 0, Serialized)
{
If ((BCCX == 0x03))
{
Return (One)
}

Return (Zero)
}

If (CondRefOf (\STD3))
{
If ((STD3 != Zero))
{
Method (_DSD, 0, NotSerialized) // _DSD: Device-Specific Data
{
If ((PAHC () || PNVM ()))
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
One
}
}
})
}
Else
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
Zero
}
}
})
}
}
}
}

Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake
{
Return (GPRW (0x69, 0x03))
}
}

Method (_PS0, 0, Serialized) // _PS0: Power State 0
{
If (CondRefOf (PPS0))
{
PPS0 ()
}
}

Method (_PS3, 0, Serialized) // _PS3: Power State 3
{
If (CondRefOf (PPS3))
{
PPS3 ()
}
}

Method (HPME, 0, Serialized)
{
If (((VDID != 0xFFFFFFFF) && (PMSX == One)))
{
Notify (PXSX, 0x02) // Device Wake
PMSX = One
PSPX = One
}
}

Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table
{
If (CondRefOf (PICM))
{
If (PICM)
{
Return (AR07 ())
}
}

Return (PD07 ())
}
}

Device (RP13)
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
If ((RPAD != Zero))
{
Return (RPAD) /* \RPAD */
}
Else
{
Return (0x001D0004)
}
}

Name (SLOT, 0x0D)
Name (LTEN, Zero)
Name (LMSL, Zero)
Name (LNSL, Zero)
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
LTEN = LTRD /* \LTRD */
LMSL = PMLD /* \PMLD */
LNSL = PNLD /* \PNLD */
If ((HBSL & 0x08))
{
HBCS = One
}

If ((CondRefOf (VMR2) && CondRefOf (VMDE)))
{
If (((VMDE == One) && ((VMR2 & 0x10) != Zero)))
{
PRMV = One
}
}

If (PRES ())
{
If (CondRefOf (PINI))
{
PINI ()
}
}

If (CondRefOf (\_SB.PC00.RP13))
{
If ((VDID != 0xFFFFFFFF))
{
If (CondRefOf (\STD3))
{
If (CondRefOf (\_SB.PC00.RP13.PRMV))
{
If ((PRMV == One))
{
RD3C = STD3 /* \STD3 */
}
}

If ((^PXSX.PNVM () || ^PXSX.PAHC ()))
{
RD3C = STD3 /* \STD3 */
}
}
}
}
}

SIPV = GSIP ()
Name (PRTP, 0x02)
OperationRegion (PXCS, SystemMemory, PC2M (_ADR ()), 0x0480)
Field (PXCS, AnyAcc, NoLock, Preserve)
{
VDID, 32,
Offset (0x50),
L0SE, 1,
, 3,
LDIS, 1,
Offset (0x51),
Offset (0x52),
, 13,
LASX, 1,
Offset (0x5A),
ABPX, 1,
, 2,
PDCX, 1,
, 2,
PDSX, 1,
Offset (0x5B),
Offset (0x60),
Offset (0x62),
PSPX, 1,
Offset (0xA4),
D3HT, 2,
Offset (0xD8),
, 30,
HPEX, 1,
PMEX, 1,
Offset (0xE0),
SCB0, 1,
, 6,
NCB7, 1,
Offset (0xE2),
, 2,
L23E, 1,
L23R, 1,
Offset (0x328),
, 19,
LNKS, 4
}

Field (PXCS, AnyAcc, NoLock, WriteAsZeros)
{
Offset (0xDC),
, 30,
HPSX, 1,
PMSX, 1
}

Method (L23D, 0, Serialized)
{
If ((SIPV < 0x10))
{
If ((NCB7 != One))
{
Return (Zero)
}
}
ElseIf ((SCB0 != One))
{
Return (Zero)
}

L23R = One
Local0 = Zero
While (L23R)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = Zero
}
Else
{
SCB0 = Zero
}

Local0 = Zero
While ((LASX == Zero))
{
If ((Local0 > 0x08))
{
Break
}

Sleep (0x10)
Local0++
}
}

Method (DL23, 0, Serialized)
{
L23E = One
Sleep (0x10)
Local0 = Zero
While (L23E)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = One
}
Else
{
SCB0 = One
}
}

Name (LTRV, Package (0x04)
{
Zero,
Zero,
Zero,
Zero
})
Name (HBCS, Zero)
Name (PRMV, Zero)
Name (RD3C, 0x02)
Method (PRES, 0, NotSerialized)
{
If ((VDID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If ((Arg0 == ToUUID ("e5c937d0-3553-4d7a-9117-ea4d19c3434d") /* Device Labeling Interface */))
{
Switch (ToInteger (Arg2))
{
Case (Zero)
{
Name (OPTS, Buffer (0x02)
{
0x00, 0x00 // ..
})
CreateBitField (OPTS, Zero, FUN0)
CreateBitField (OPTS, 0x06, FUN6)
CreateBitField (OPTS, 0x08, FUN8)
CreateBitField (OPTS, 0x09, FUN9)
CreateBitField (OPTS, 0x0A, FUNA)
CreateBitField (OPTS, 0x0B, FUNB)
If ((Arg1 >= 0x02))
{
FUN0 = One
If ((LTEN != Zero))
{
FUN6 = One
}

If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
FUN8 = One
FUN9 = One
}
}
}
}

If ((Arg1 >= 0x04))
{
If (CondRefOf (PPBA))
{
FUNA = One
}

If (CondRefOf (UPRD))
{
FUNB = One
}
}

Return (OPTS) /* \_SB_.PC00.RP13._DSM.OPTS */
}
Case (0x06)
{
If ((Arg1 >= 0x02))
{
LTRV [Zero] = ((LMSL >> 0x0A) & 0x07)
LTRV [One] = (LMSL & 0x03FF)
LTRV [0x02] = ((LNSL >> 0x0A) & 0x07)
LTRV [0x03] = (LNSL & 0x03FF)
Return (LTRV) /* \_SB_.PC00.RP13.LTRV */
}
}
Case (0x08)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (One)
}
}
}
}
Case (0x09)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (Package (0x05)
{
0xC350,
Ones,
Ones,
0xC350,
Ones
})
}
}
}
}
Case (0x0A)
{
If (CondRefOf (PPBA))
{
Return (PPBA (Arg3))
}
}
Case (0x0B)
{
If (CondRefOf (UPRD))
{
Return (UPRD (Arg3))
}
}

}
}

Return (Buffer (One)
{
0x00 // .
})
}

Device (PXSX)
{
Name (_ADR, Zero) // _ADR: Address
OperationRegion (PCCX, PCI_Config, Zero, 0x10)
Field (PCCX, ByteAcc, NoLock, Preserve)
{
DVID, 32,
Offset (0x09),
PIXX, 8,
SCCX, 8,
BCCX, 8
}

Method (PAHC, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x06))
{
If ((PIXX == One))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PNVM, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x08))
{
If ((PIXX == 0x02))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PRES, 0, Serialized)
{
If ((DVID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (ISGX, 0, Serialized)
{
If ((BCCX == 0x03))
{
Return (One)
}

Return (Zero)
}

If (CondRefOf (\STD3))
{
If ((STD3 != Zero))
{
Method (_DSD, 0, NotSerialized) // _DSD: Device-Specific Data
{
If ((PAHC () || PNVM ()))
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
One
}
}
})
}
Else
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
Zero
}
}
})
}
}
}
}

Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake
{
Return (GPRW (0x69, 0x03))
}
}

Method (_PS0, 0, Serialized) // _PS0: Power State 0
{
If (CondRefOf (PPS0))
{
PPS0 ()
}
}

Method (_PS3, 0, Serialized) // _PS3: Power State 3
{
If (CondRefOf (PPS3))
{
PPS3 ()
}
}

Method (HPME, 0, Serialized)
{
If (((VDID != 0xFFFFFFFF) && (PMSX == One)))
{
Notify (PXSX, 0x02) // Device Wake
PMSX = One
PSPX = One
}
}

Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table
{
If (CondRefOf (PICM))
{
If (PICM)
{
Return (AR04 ())
}
}

Return (PD04 ())
}
}

Device (RP14)
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
If ((RPAE != Zero))
{
Return (RPAE) /* \RPAE */
}
Else
{
Return (0x001D0005)
}
}

Name (SLOT, 0x0E)
Name (LTEN, Zero)
Name (LMSL, Zero)
Name (LNSL, Zero)
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
LTEN = LTRE /* \LTRE */
LMSL = PMLE /* \PMLE */
LNSL = PNLE /* \PNLE */
If ((HBSL & 0x08))
{
HBCS = One
}

If ((CondRefOf (VMR2) && CondRefOf (VMDE)))
{
If (((VMDE == One) && ((VMR2 & 0x20) != Zero)))
{
PRMV = One
}
}

If (PRES ())
{
If (CondRefOf (PINI))
{
PINI ()
}
}

If (CondRefOf (\_SB.PC00.RP14))
{
If ((VDID != 0xFFFFFFFF))
{
If (CondRefOf (\STD3))
{
If (CondRefOf (\_SB.PC00.RP14.PRMV))
{
If ((PRMV == One))
{
RD3C = STD3 /* \STD3 */
}
}

If ((^PXSX.PNVM () || ^PXSX.PAHC ()))
{
RD3C = STD3 /* \STD3 */
}
}
}
}
}

SIPV = GSIP ()
Name (PRTP, 0x02)
OperationRegion (PXCS, SystemMemory, PC2M (_ADR ()), 0x0480)
Field (PXCS, AnyAcc, NoLock, Preserve)
{
VDID, 32,
Offset (0x50),
L0SE, 1,
, 3,
LDIS, 1,
Offset (0x51),
Offset (0x52),
, 13,
LASX, 1,
Offset (0x5A),
ABPX, 1,
, 2,
PDCX, 1,
, 2,
PDSX, 1,
Offset (0x5B),
Offset (0x60),
Offset (0x62),
PSPX, 1,
Offset (0xA4),
D3HT, 2,
Offset (0xD8),
, 30,
HPEX, 1,
PMEX, 1,
Offset (0xE0),
SCB0, 1,
, 6,
NCB7, 1,
Offset (0xE2),
, 2,
L23E, 1,
L23R, 1,
Offset (0x328),
, 19,
LNKS, 4
}

Field (PXCS, AnyAcc, NoLock, WriteAsZeros)
{
Offset (0xDC),
, 30,
HPSX, 1,
PMSX, 1
}

Method (L23D, 0, Serialized)
{
If ((SIPV < 0x10))
{
If ((NCB7 != One))
{
Return (Zero)
}
}
ElseIf ((SCB0 != One))
{
Return (Zero)
}

L23R = One
Local0 = Zero
While (L23R)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = Zero
}
Else
{
SCB0 = Zero
}

Local0 = Zero
While ((LASX == Zero))
{
If ((Local0 > 0x08))
{
Break
}

Sleep (0x10)
Local0++
}
}

Method (DL23, 0, Serialized)
{
L23E = One
Sleep (0x10)
Local0 = Zero
While (L23E)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = One
}
Else
{
SCB0 = One
}
}

Name (LTRV, Package (0x04)
{
Zero,
Zero,
Zero,
Zero
})
Name (HBCS, Zero)
Name (PRMV, Zero)
Name (RD3C, 0x02)
Method (PRES, 0, NotSerialized)
{
If ((VDID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If ((Arg0 == ToUUID ("e5c937d0-3553-4d7a-9117-ea4d19c3434d") /* Device Labeling Interface */))
{
Switch (ToInteger (Arg2))
{
Case (Zero)
{
Name (OPTS, Buffer (0x02)
{
0x00, 0x00 // ..
})
CreateBitField (OPTS, Zero, FUN0)
CreateBitField (OPTS, 0x06, FUN6)
CreateBitField (OPTS, 0x08, FUN8)
CreateBitField (OPTS, 0x09, FUN9)
CreateBitField (OPTS, 0x0A, FUNA)
CreateBitField (OPTS, 0x0B, FUNB)
If ((Arg1 >= 0x02))
{
FUN0 = One
If ((LTEN != Zero))
{
FUN6 = One
}

If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
FUN8 = One
FUN9 = One
}
}
}
}

If ((Arg1 >= 0x04))
{
If (CondRefOf (PPBA))
{
FUNA = One
}

If (CondRefOf (UPRD))
{
FUNB = One
}
}

Return (OPTS) /* \_SB_.PC00.RP14._DSM.OPTS */
}
Case (0x06)
{
If ((Arg1 >= 0x02))
{
LTRV [Zero] = ((LMSL >> 0x0A) & 0x07)
LTRV [One] = (LMSL & 0x03FF)
LTRV [0x02] = ((LNSL >> 0x0A) & 0x07)
LTRV [0x03] = (LNSL & 0x03FF)
Return (LTRV) /* \_SB_.PC00.RP14.LTRV */
}
}
Case (0x08)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (One)
}
}
}
}
Case (0x09)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (Package (0x05)
{
0xC350,
Ones,
Ones,
0xC350,
Ones
})
}
}
}
}
Case (0x0A)
{
If (CondRefOf (PPBA))
{
Return (PPBA (Arg3))
}
}
Case (0x0B)
{
If (CondRefOf (UPRD))
{
Return (UPRD (Arg3))
}
}

}
}

Return (Buffer (One)
{
0x00 // .
})
}

Device (PXSX)
{
Name (_ADR, Zero) // _ADR: Address
OperationRegion (PCCX, PCI_Config, Zero, 0x10)
Field (PCCX, ByteAcc, NoLock, Preserve)
{
DVID, 32,
Offset (0x09),
PIXX, 8,
SCCX, 8,
BCCX, 8
}

Method (PAHC, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x06))
{
If ((PIXX == One))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PNVM, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x08))
{
If ((PIXX == 0x02))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PRES, 0, Serialized)
{
If ((DVID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (ISGX, 0, Serialized)
{
If ((BCCX == 0x03))
{
Return (One)
}

Return (Zero)
}

If (CondRefOf (\STD3))
{
If ((STD3 != Zero))
{
Method (_DSD, 0, NotSerialized) // _DSD: Device-Specific Data
{
If ((PAHC () || PNVM ()))
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
One
}
}
})
}
Else
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
Zero
}
}
})
}
}
}
}

Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake
{
Return (GPRW (0x69, 0x03))
}
}

Method (_PS0, 0, Serialized) // _PS0: Power State 0
{
If (CondRefOf (PPS0))
{
PPS0 ()
}
}

Method (_PS3, 0, Serialized) // _PS3: Power State 3
{
If (CondRefOf (PPS3))
{
PPS3 ()
}
}

Method (HPME, 0, Serialized)
{
If (((VDID != 0xFFFFFFFF) && (PMSX == One)))
{
Notify (PXSX, 0x02) // Device Wake
PMSX = One
PSPX = One
}
}

Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table
{
If (CondRefOf (PICM))
{
If (PICM)
{
Return (AR05 ())
}
}

Return (PD05 ())
}
}

Device (RP15)
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
If ((RPAF != Zero))
{
Return (RPAF) /* \RPAF */
}
Else
{
Return (0x001D0006)
}
}

Name (SLOT, 0x0F)
Name (LTEN, Zero)
Name (LMSL, Zero)
Name (LNSL, Zero)
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
LTEN = LTRF /* \LTRF */
LMSL = PMLF /* \PMLF */
LNSL = PNLF /* \PNLF */
If ((HBSL & 0x08))
{
HBCS = One
}

If ((CondRefOf (VMR2) && CondRefOf (VMDE)))
{
If (((VMDE == One) && ((VMR2 & 0x40) != Zero)))
{
PRMV = One
}
}

If (PRES ())
{
If (CondRefOf (PINI))
{
PINI ()
}
}

If (CondRefOf (\_SB.PC00.RP15))
{
If ((VDID != 0xFFFFFFFF))
{
If (CondRefOf (\STD3))
{
If (CondRefOf (\_SB.PC00.RP15.PRMV))
{
If ((PRMV == One))
{
RD3C = STD3 /* \STD3 */
}
}

If ((^PXSX.PNVM () || ^PXSX.PAHC ()))
{
RD3C = STD3 /* \STD3 */
}
}
}
}
}

SIPV = GSIP ()
Name (PRTP, 0x02)
OperationRegion (PXCS, SystemMemory, PC2M (_ADR ()), 0x0480)
Field (PXCS, AnyAcc, NoLock, Preserve)
{
VDID, 32,
Offset (0x50),
L0SE, 1,
, 3,
LDIS, 1,
Offset (0x51),
Offset (0x52),
, 13,
LASX, 1,
Offset (0x5A),
ABPX, 1,
, 2,
PDCX, 1,
, 2,
PDSX, 1,
Offset (0x5B),
Offset (0x60),
Offset (0x62),
PSPX, 1,
Offset (0xA4),
D3HT, 2,
Offset (0xD8),
, 30,
HPEX, 1,
PMEX, 1,
Offset (0xE0),
SCB0, 1,
, 6,
NCB7, 1,
Offset (0xE2),
, 2,
L23E, 1,
L23R, 1,
Offset (0x328),
, 19,
LNKS, 4
}

Field (PXCS, AnyAcc, NoLock, WriteAsZeros)
{
Offset (0xDC),
, 30,
HPSX, 1,
PMSX, 1
}

Method (L23D, 0, Serialized)
{
If ((SIPV < 0x10))
{
If ((NCB7 != One))
{
Return (Zero)
}
}
ElseIf ((SCB0 != One))
{
Return (Zero)
}

L23R = One
Local0 = Zero
While (L23R)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = Zero
}
Else
{
SCB0 = Zero
}

Local0 = Zero
While ((LASX == Zero))
{
If ((Local0 > 0x08))
{
Break
}

Sleep (0x10)
Local0++
}
}

Method (DL23, 0, Serialized)
{
L23E = One
Sleep (0x10)
Local0 = Zero
While (L23E)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = One
}
Else
{
SCB0 = One
}
}

Name (LTRV, Package (0x04)
{
Zero,
Zero,
Zero,
Zero
})
Name (HBCS, Zero)
Name (PRMV, Zero)
Name (RD3C, 0x02)
Method (PRES, 0, NotSerialized)
{
If ((VDID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If ((Arg0 == ToUUID ("e5c937d0-3553-4d7a-9117-ea4d19c3434d") /* Device Labeling Interface */))
{
Switch (ToInteger (Arg2))
{
Case (Zero)
{
Name (OPTS, Buffer (0x02)
{
0x00, 0x00 // ..
})
CreateBitField (OPTS, Zero, FUN0)
CreateBitField (OPTS, 0x06, FUN6)
CreateBitField (OPTS, 0x08, FUN8)
CreateBitField (OPTS, 0x09, FUN9)
CreateBitField (OPTS, 0x0A, FUNA)
CreateBitField (OPTS, 0x0B, FUNB)
If ((Arg1 >= 0x02))
{
FUN0 = One
If ((LTEN != Zero))
{
FUN6 = One
}

If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
FUN8 = One
FUN9 = One
}
}
}
}

If ((Arg1 >= 0x04))
{
If (CondRefOf (PPBA))
{
FUNA = One
}

If (CondRefOf (UPRD))
{
FUNB = One
}
}

Return (OPTS) /* \_SB_.PC00.RP15._DSM.OPTS */
}
Case (0x06)
{
If ((Arg1 >= 0x02))
{
LTRV [Zero] = ((LMSL >> 0x0A) & 0x07)
LTRV [One] = (LMSL & 0x03FF)
LTRV [0x02] = ((LNSL >> 0x0A) & 0x07)
LTRV [0x03] = (LNSL & 0x03FF)
Return (LTRV) /* \_SB_.PC00.RP15.LTRV */
}
}
Case (0x08)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (One)
}
}
}
}
Case (0x09)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (Package (0x05)
{
0xC350,
Ones,
Ones,
0xC350,
Ones
})
}
}
}
}
Case (0x0A)
{
If (CondRefOf (PPBA))
{
Return (PPBA (Arg3))
}
}
Case (0x0B)
{
If (CondRefOf (UPRD))
{
Return (UPRD (Arg3))
}
}

}
}

Return (Buffer (One)
{
0x00 // .
})
}

Device (PXSX)
{
Name (_ADR, Zero) // _ADR: Address
OperationRegion (PCCX, PCI_Config, Zero, 0x10)
Field (PCCX, ByteAcc, NoLock, Preserve)
{
DVID, 32,
Offset (0x09),
PIXX, 8,
SCCX, 8,
BCCX, 8
}

Method (PAHC, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x06))
{
If ((PIXX == One))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PNVM, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x08))
{
If ((PIXX == 0x02))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PRES, 0, Serialized)
{
If ((DVID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (ISGX, 0, Serialized)
{
If ((BCCX == 0x03))
{
Return (One)
}

Return (Zero)
}

If (CondRefOf (\STD3))
{
If ((STD3 != Zero))
{
Method (_DSD, 0, NotSerialized) // _DSD: Device-Specific Data
{
If ((PAHC () || PNVM ()))
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
One
}
}
})
}
Else
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
Zero
}
}
})
}
}
}
}

Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake
{
Return (GPRW (0x69, 0x03))
}
}

Method (_PS0, 0, Serialized) // _PS0: Power State 0
{
If (CondRefOf (PPS0))
{
PPS0 ()
}
}

Method (_PS3, 0, Serialized) // _PS3: Power State 3
{
If (CondRefOf (PPS3))
{
PPS3 ()
}
}

Method (HPME, 0, Serialized)
{
If (((VDID != 0xFFFFFFFF) && (PMSX == One)))
{
Notify (PXSX, 0x02) // Device Wake
PMSX = One
PSPX = One
}
}

Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table
{
If (CondRefOf (PICM))
{
If (PICM)
{
Return (AR06 ())
}
}

Return (PD06 ())
}
}

Device (RP16)
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
If ((RPAG != Zero))
{
Return (RPAG) /* \RPAG */
}
Else
{
Return (0x001D0007)
}
}

Name (SLOT, 0x10)
Name (LTEN, Zero)
Name (LMSL, Zero)
Name (LNSL, Zero)
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
LTEN = LTRG /* \LTRG */
LMSL = PMLG /* \PMLG */
LNSL = PNLG /* \PNLG */
If ((HBSL & 0x08))
{
HBCS = One
}

If ((CondRefOf (VMR2) && CondRefOf (VMDE)))
{
If (((VMDE == One) && ((VMR2 & 0x80) != Zero)))
{
PRMV = One
}
}

If (PRES ())
{
If (CondRefOf (PINI))
{
PINI ()
}
}

If (CondRefOf (\_SB.PC00.RP16))
{
If ((VDID != 0xFFFFFFFF))
{
If (CondRefOf (\STD3))
{
If (CondRefOf (\_SB.PC00.RP16.PRMV))
{
If ((PRMV == One))
{
RD3C = STD3 /* \STD3 */
}
}

If ((^PXSX.PNVM () || ^PXSX.PAHC ()))
{
RD3C = STD3 /* \STD3 */
}
}
}
}
}

SIPV = GSIP ()
Name (PRTP, 0x02)
OperationRegion (PXCS, SystemMemory, PC2M (_ADR ()), 0x0480)
Field (PXCS, AnyAcc, NoLock, Preserve)
{
VDID, 32,
Offset (0x50),
L0SE, 1,
, 3,
LDIS, 1,
Offset (0x51),
Offset (0x52),
, 13,
LASX, 1,
Offset (0x5A),
ABPX, 1,
, 2,
PDCX, 1,
, 2,
PDSX, 1,
Offset (0x5B),
Offset (0x60),
Offset (0x62),
PSPX, 1,
Offset (0xA4),
D3HT, 2,
Offset (0xD8),
, 30,
HPEX, 1,
PMEX, 1,
Offset (0xE0),
SCB0, 1,
, 6,
NCB7, 1,
Offset (0xE2),
, 2,
L23E, 1,
L23R, 1,
Offset (0x328),
, 19,
LNKS, 4
}

Field (PXCS, AnyAcc, NoLock, WriteAsZeros)
{
Offset (0xDC),
, 30,
HPSX, 1,
PMSX, 1
}

Method (L23D, 0, Serialized)
{
If ((SIPV < 0x10))
{
If ((NCB7 != One))
{
Return (Zero)
}
}
ElseIf ((SCB0 != One))
{
Return (Zero)
}

L23R = One
Local0 = Zero
While (L23R)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = Zero
}
Else
{
SCB0 = Zero
}

Local0 = Zero
While ((LASX == Zero))
{
If ((Local0 > 0x08))
{
Break
}

Sleep (0x10)
Local0++
}
}

Method (DL23, 0, Serialized)
{
L23E = One
Sleep (0x10)
Local0 = Zero
While (L23E)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = One
}
Else
{
SCB0 = One
}
}

Name (LTRV, Package (0x04)
{
Zero,
Zero,
Zero,
Zero
})
Name (HBCS, Zero)
Name (PRMV, Zero)
Name (RD3C, 0x02)
Method (PRES, 0, NotSerialized)
{
If ((VDID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If ((Arg0 == ToUUID ("e5c937d0-3553-4d7a-9117-ea4d19c3434d") /* Device Labeling Interface */))
{
Switch (ToInteger (Arg2))
{
Case (Zero)
{
Name (OPTS, Buffer (0x02)
{
0x00, 0x00 // ..
})
CreateBitField (OPTS, Zero, FUN0)
CreateBitField (OPTS, 0x06, FUN6)
CreateBitField (OPTS, 0x08, FUN8)
CreateBitField (OPTS, 0x09, FUN9)
CreateBitField (OPTS, 0x0A, FUNA)
CreateBitField (OPTS, 0x0B, FUNB)
If ((Arg1 >= 0x02))
{
FUN0 = One
If ((LTEN != Zero))
{
FUN6 = One
}

If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
FUN8 = One
FUN9 = One
}
}
}
}

If ((Arg1 >= 0x04))
{
If (CondRefOf (PPBA))
{
FUNA = One
}

If (CondRefOf (UPRD))
{
FUNB = One
}
}

Return (OPTS) /* \_SB_.PC00.RP16._DSM.OPTS */
}
Case (0x06)
{
If ((Arg1 >= 0x02))
{
LTRV [Zero] = ((LMSL >> 0x0A) & 0x07)
LTRV [One] = (LMSL & 0x03FF)
LTRV [0x02] = ((LNSL >> 0x0A) & 0x07)
LTRV [0x03] = (LNSL & 0x03FF)
Return (LTRV) /* \_SB_.PC00.RP16.LTRV */
}
}
Case (0x08)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (One)
}
}
}
}
Case (0x09)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (Package (0x05)
{
0xC350,
Ones,
Ones,
0xC350,
Ones
})
}
}
}
}
Case (0x0A)
{
If (CondRefOf (PPBA))
{
Return (PPBA (Arg3))
}
}
Case (0x0B)
{
If (CondRefOf (UPRD))
{
Return (UPRD (Arg3))
}
}

}
}

Return (Buffer (One)
{
0x00 // .
})
}

Device (PXSX)
{
Name (_ADR, Zero) // _ADR: Address
OperationRegion (PCCX, PCI_Config, Zero, 0x10)
Field (PCCX, ByteAcc, NoLock, Preserve)
{
DVID, 32,
Offset (0x09),
PIXX, 8,
SCCX, 8,
BCCX, 8
}

Method (PAHC, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x06))
{
If ((PIXX == One))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PNVM, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x08))
{
If ((PIXX == 0x02))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PRES, 0, Serialized)
{
If ((DVID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (ISGX, 0, Serialized)
{
If ((BCCX == 0x03))
{
Return (One)
}

Return (Zero)
}

If (CondRefOf (\STD3))
{
If ((STD3 != Zero))
{
Method (_DSD, 0, NotSerialized) // _DSD: Device-Specific Data
{
If ((PAHC () || PNVM ()))
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
One
}
}
})
}
Else
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
Zero
}
}
})
}
}
}
}

Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake
{
Return (GPRW (0x69, 0x03))
}
}

Method (_PS0, 0, Serialized) // _PS0: Power State 0
{
If (CondRefOf (PPS0))
{
PPS0 ()
}
}

Method (_PS3, 0, Serialized) // _PS3: Power State 3
{
If (CondRefOf (PPS3))
{
PPS3 ()
}
}

Method (HPME, 0, Serialized)
{
If (((VDID != 0xFFFFFFFF) && (PMSX == One)))
{
Notify (PXSX, 0x02) // Device Wake
PMSX = One
PSPX = One
}
}

Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table
{
If (CondRefOf (PICM))
{
If (PICM)
{
Return (AR07 ())
}
}

Return (PD07 ())
}
}

Device (RP17)
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
If ((RPAH != Zero))
{
Return (RPAH) /* \RPAH */
}
Else
{
Return (0x001B0000)
}
}

Name (SLOT, 0x11)
Name (LTEN, Zero)
Name (LMSL, Zero)
Name (LNSL, Zero)
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
LTEN = LTRH /* \LTRH */
LMSL = PMLH /* \PMLH */
LNSL = PNLH /* \PNLH */
If ((HBSL & 0x10))
{
HBCS = One
}

If ((CondRefOf (VMR3) && CondRefOf (VMDE)))
{
If (((VMDE == One) && ((VMR3 & One) != Zero)))
{
PRMV = One
}
}

If (PRES ())
{
If (CondRefOf (PINI))
{
PINI ()
}
}

If (CondRefOf (\_SB.PC00.RP17))
{
If ((VDID != 0xFFFFFFFF))
{
If (CondRefOf (\STD3))
{
If (CondRefOf (\_SB.PC00.RP17.PRMV))
{
If ((PRMV == One))
{
RD3C = STD3 /* \STD3 */
}
}

If ((^PXSX.PNVM () || ^PXSX.PAHC ()))
{
RD3C = STD3 /* \STD3 */
}
}
}
}
}

SIPV = GSIP ()
Name (PRTP, 0x02)
OperationRegion (PXCS, SystemMemory, PC2M (_ADR ()), 0x0480)
Field (PXCS, AnyAcc, NoLock, Preserve)
{
VDID, 32,
Offset (0x50),
L0SE, 1,
, 3,
LDIS, 1,
Offset (0x51),
Offset (0x52),
, 13,
LASX, 1,
Offset (0x5A),
ABPX, 1,
, 2,
PDCX, 1,
, 2,
PDSX, 1,
Offset (0x5B),
Offset (0x60),
Offset (0x62),
PSPX, 1,
Offset (0xA4),
D3HT, 2,
Offset (0xD8),
, 30,
HPEX, 1,
PMEX, 1,
Offset (0xE0),
SCB0, 1,
, 6,
NCB7, 1,
Offset (0xE2),
, 2,
L23E, 1,
L23R, 1,
Offset (0x328),
, 19,
LNKS, 4
}

Field (PXCS, AnyAcc, NoLock, WriteAsZeros)
{
Offset (0xDC),
, 30,
HPSX, 1,
PMSX, 1
}

Method (L23D, 0, Serialized)
{
If ((SIPV < 0x10))
{
If ((NCB7 != One))
{
Return (Zero)
}
}
ElseIf ((SCB0 != One))
{
Return (Zero)
}

L23R = One
Local0 = Zero
While (L23R)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = Zero
}
Else
{
SCB0 = Zero
}

Local0 = Zero
While ((LASX == Zero))
{
If ((Local0 > 0x08))
{
Break
}

Sleep (0x10)
Local0++
}
}

Method (DL23, 0, Serialized)
{
L23E = One
Sleep (0x10)
Local0 = Zero
While (L23E)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = One
}
Else
{
SCB0 = One
}
}

Name (LTRV, Package (0x04)
{
Zero,
Zero,
Zero,
Zero
})
Name (HBCS, Zero)
Name (PRMV, Zero)
Name (RD3C, 0x02)
Method (PRES, 0, NotSerialized)
{
If ((VDID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If ((Arg0 == ToUUID ("e5c937d0-3553-4d7a-9117-ea4d19c3434d") /* Device Labeling Interface */))
{
Switch (ToInteger (Arg2))
{
Case (Zero)
{
Name (OPTS, Buffer (0x02)
{
0x00, 0x00 // ..
})
CreateBitField (OPTS, Zero, FUN0)
CreateBitField (OPTS, 0x06, FUN6)
CreateBitField (OPTS, 0x08, FUN8)
CreateBitField (OPTS, 0x09, FUN9)
CreateBitField (OPTS, 0x0A, FUNA)
CreateBitField (OPTS, 0x0B, FUNB)
If ((Arg1 >= 0x02))
{
FUN0 = One
If ((LTEN != Zero))
{
FUN6 = One
}

If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
FUN8 = One
FUN9 = One
}
}
}
}

If ((Arg1 >= 0x04))
{
If (CondRefOf (PPBA))
{
FUNA = One
}

If (CondRefOf (UPRD))
{
FUNB = One
}
}

Return (OPTS) /* \_SB_.PC00.RP17._DSM.OPTS */
}
Case (0x06)
{
If ((Arg1 >= 0x02))
{
LTRV [Zero] = ((LMSL >> 0x0A) & 0x07)
LTRV [One] = (LMSL & 0x03FF)
LTRV [0x02] = ((LNSL >> 0x0A) & 0x07)
LTRV [0x03] = (LNSL & 0x03FF)
Return (LTRV) /* \_SB_.PC00.RP17.LTRV */
}
}
Case (0x08)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (One)
}
}
}
}
Case (0x09)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (Package (0x05)
{
0xC350,
Ones,
Ones,
0xC350,
Ones
})
}
}
}
}
Case (0x0A)
{
If (CondRefOf (PPBA))
{
Return (PPBA (Arg3))
}
}
Case (0x0B)
{
If (CondRefOf (UPRD))
{
Return (UPRD (Arg3))
}
}

}
}

Return (Buffer (One)
{
0x00 // .
})
}

Device (PXSX)
{
Name (_ADR, Zero) // _ADR: Address
OperationRegion (PCCX, PCI_Config, Zero, 0x10)
Field (PCCX, ByteAcc, NoLock, Preserve)
{
DVID, 32,
Offset (0x09),
PIXX, 8,
SCCX, 8,
BCCX, 8
}

Method (PAHC, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x06))
{
If ((PIXX == One))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PNVM, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x08))
{
If ((PIXX == 0x02))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PRES, 0, Serialized)
{
If ((DVID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (ISGX, 0, Serialized)
{
If ((BCCX == 0x03))
{
Return (One)
}

Return (Zero)
}

If (CondRefOf (\STD3))
{
If ((STD3 != Zero))
{
Method (_DSD, 0, NotSerialized) // _DSD: Device-Specific Data
{
If ((PAHC () || PNVM ()))
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
One
}
}
})
}
Else
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
Zero
}
}
})
}
}
}
}

Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake
{
Return (GPRW (0x69, 0x03))
}
}

Method (_PS0, 0, Serialized) // _PS0: Power State 0
{
If (CondRefOf (PPS0))
{
PPS0 ()
}
}

Method (_PS3, 0, Serialized) // _PS3: Power State 3
{
If (CondRefOf (PPS3))
{
PPS3 ()
}
}

Method (HPME, 0, Serialized)
{
If (((VDID != 0xFFFFFFFF) && (PMSX == One)))
{
Notify (PXSX, 0x02) // Device Wake
PMSX = One
PSPX = One
}
}

Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table
{
If (CondRefOf (PICM))
{
If (PICM)
{
Return (AR04 ())
}
}

Return (PD04 ())
}
}

Device (RP18)
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
If ((RPAI != Zero))
{
Return (RPAI) /* \RPAI */
}
Else
{
Return (0x001B0001)
}
}

Name (SLOT, 0x12)
Name (LTEN, Zero)
Name (LMSL, Zero)
Name (LNSL, Zero)
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
LTEN = LTRI /* \LTRI */
LMSL = PMLI /* \PMLI */
LNSL = PNLI /* \PNLI */
If ((HBSL & 0x10))
{
HBCS = One
}

If ((CondRefOf (VMR3) && CondRefOf (VMDE)))
{
If (((VMDE == One) && ((VMR3 & 0x02) != Zero)))
{
PRMV = One
}
}

If (PRES ())
{
If (CondRefOf (PINI))
{
PINI ()
}
}

If (CondRefOf (\_SB.PC00.RP18))
{
If ((VDID != 0xFFFFFFFF))
{
If (CondRefOf (\STD3))
{
If (CondRefOf (\_SB.PC00.RP18.PRMV))
{
If ((PRMV == One))
{
RD3C = STD3 /* \STD3 */
}
}

If ((^PXSX.PNVM () || ^PXSX.PAHC ()))
{
RD3C = STD3 /* \STD3 */
}
}
}
}
}

SIPV = GSIP ()
Name (PRTP, 0x02)
OperationRegion (PXCS, SystemMemory, PC2M (_ADR ()), 0x0480)
Field (PXCS, AnyAcc, NoLock, Preserve)
{
VDID, 32,
Offset (0x50),
L0SE, 1,
, 3,
LDIS, 1,
Offset (0x51),
Offset (0x52),
, 13,
LASX, 1,
Offset (0x5A),
ABPX, 1,
, 2,
PDCX, 1,
, 2,
PDSX, 1,
Offset (0x5B),
Offset (0x60),
Offset (0x62),
PSPX, 1,
Offset (0xA4),
D3HT, 2,
Offset (0xD8),
, 30,
HPEX, 1,
PMEX, 1,
Offset (0xE0),
SCB0, 1,
, 6,
NCB7, 1,
Offset (0xE2),
, 2,
L23E, 1,
L23R, 1,
Offset (0x328),
, 19,
LNKS, 4
}

Field (PXCS, AnyAcc, NoLock, WriteAsZeros)
{
Offset (0xDC),
, 30,
HPSX, 1,
PMSX, 1
}

Method (L23D, 0, Serialized)
{
If ((SIPV < 0x10))
{
If ((NCB7 != One))
{
Return (Zero)
}
}
ElseIf ((SCB0 != One))
{
Return (Zero)
}

L23R = One
Local0 = Zero
While (L23R)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = Zero
}
Else
{
SCB0 = Zero
}

Local0 = Zero
While ((LASX == Zero))
{
If ((Local0 > 0x08))
{
Break
}

Sleep (0x10)
Local0++
}
}

Method (DL23, 0, Serialized)
{
L23E = One
Sleep (0x10)
Local0 = Zero
While (L23E)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = One
}
Else
{
SCB0 = One
}
}

Name (LTRV, Package (0x04)
{
Zero,
Zero,
Zero,
Zero
})
Name (HBCS, Zero)
Name (PRMV, Zero)
Name (RD3C, 0x02)
Method (PRES, 0, NotSerialized)
{
If ((VDID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If ((Arg0 == ToUUID ("e5c937d0-3553-4d7a-9117-ea4d19c3434d") /* Device Labeling Interface */))
{
Switch (ToInteger (Arg2))
{
Case (Zero)
{
Name (OPTS, Buffer (0x02)
{
0x00, 0x00 // ..
})
CreateBitField (OPTS, Zero, FUN0)
CreateBitField (OPTS, 0x06, FUN6)
CreateBitField (OPTS, 0x08, FUN8)
CreateBitField (OPTS, 0x09, FUN9)
CreateBitField (OPTS, 0x0A, FUNA)
CreateBitField (OPTS, 0x0B, FUNB)
If ((Arg1 >= 0x02))
{
FUN0 = One
If ((LTEN != Zero))
{
FUN6 = One
}

If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
FUN8 = One
FUN9 = One
}
}
}
}

If ((Arg1 >= 0x04))
{
If (CondRefOf (PPBA))
{
FUNA = One
}

If (CondRefOf (UPRD))
{
FUNB = One
}
}

Return (OPTS) /* \_SB_.PC00.RP18._DSM.OPTS */
}
Case (0x06)
{
If ((Arg1 >= 0x02))
{
LTRV [Zero] = ((LMSL >> 0x0A) & 0x07)
LTRV [One] = (LMSL & 0x03FF)
LTRV [0x02] = ((LNSL >> 0x0A) & 0x07)
LTRV [0x03] = (LNSL & 0x03FF)
Return (LTRV) /* \_SB_.PC00.RP18.LTRV */
}
}
Case (0x08)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (One)
}
}
}
}
Case (0x09)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (Package (0x05)
{
0xC350,
Ones,
Ones,
0xC350,
Ones
})
}
}
}
}
Case (0x0A)
{
If (CondRefOf (PPBA))
{
Return (PPBA (Arg3))
}
}
Case (0x0B)
{
If (CondRefOf (UPRD))
{
Return (UPRD (Arg3))
}
}

}
}

Return (Buffer (One)
{
0x00 // .
})
}

Device (PXSX)
{
Name (_ADR, Zero) // _ADR: Address
OperationRegion (PCCX, PCI_Config, Zero, 0x10)
Field (PCCX, ByteAcc, NoLock, Preserve)
{
DVID, 32,
Offset (0x09),
PIXX, 8,
SCCX, 8,
BCCX, 8
}

Method (PAHC, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x06))
{
If ((PIXX == One))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PNVM, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x08))
{
If ((PIXX == 0x02))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PRES, 0, Serialized)
{
If ((DVID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (ISGX, 0, Serialized)
{
If ((BCCX == 0x03))
{
Return (One)
}

Return (Zero)
}

If (CondRefOf (\STD3))
{
If ((STD3 != Zero))
{
Method (_DSD, 0, NotSerialized) // _DSD: Device-Specific Data
{
If ((PAHC () || PNVM ()))
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
One
}
}
})
}
Else
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
Zero
}
}
})
}
}
}
}

Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake
{
Return (GPRW (0x69, 0x03))
}
}

Method (_PS0, 0, Serialized) // _PS0: Power State 0
{
If (CondRefOf (PPS0))
{
PPS0 ()
}
}

Method (_PS3, 0, Serialized) // _PS3: Power State 3
{
If (CondRefOf (PPS3))
{
PPS3 ()
}
}

Method (HPME, 0, Serialized)
{
If (((VDID != 0xFFFFFFFF) && (PMSX == One)))
{
Notify (PXSX, 0x02) // Device Wake
PMSX = One
PSPX = One
}
}

Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table
{
If (CondRefOf (PICM))
{
If (PICM)
{
Return (AR05 ())
}
}

Return (PD05 ())
}
}

Device (RP19)
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
If ((RPAJ != Zero))
{
Return (RPAJ) /* \RPAJ */
}
Else
{
Return (0x001B0002)
}
}

Name (SLOT, 0x13)
Name (LTEN, Zero)
Name (LMSL, Zero)
Name (LNSL, Zero)
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
LTEN = LTRJ /* \LTRJ */
LMSL = PMLJ /* \PMLJ */
LNSL = PNLJ /* \PNLJ */
If ((HBSL & 0x10))
{
HBCS = One
}

If ((CondRefOf (VMR3) && CondRefOf (VMDE)))
{
If (((VMDE == One) && ((VMR3 & 0x04) != Zero)))
{
PRMV = One
}
}

If (PRES ())
{
If (CondRefOf (PINI))
{
PINI ()
}
}

If (CondRefOf (\_SB.PC00.RP19))
{
If ((VDID != 0xFFFFFFFF))
{
If (CondRefOf (\STD3))
{
If (CondRefOf (\_SB.PC00.RP19.PRMV))
{
If ((PRMV == One))
{
RD3C = STD3 /* \STD3 */
}
}

If ((^PXSX.PNVM () || ^PXSX.PAHC ()))
{
RD3C = STD3 /* \STD3 */
}
}
}
}
}

SIPV = GSIP ()
Name (PRTP, 0x02)
OperationRegion (PXCS, SystemMemory, PC2M (_ADR ()), 0x0480)
Field (PXCS, AnyAcc, NoLock, Preserve)
{
VDID, 32,
Offset (0x50),
L0SE, 1,
, 3,
LDIS, 1,
Offset (0x51),
Offset (0x52),
, 13,
LASX, 1,
Offset (0x5A),
ABPX, 1,
, 2,
PDCX, 1,
, 2,
PDSX, 1,
Offset (0x5B),
Offset (0x60),
Offset (0x62),
PSPX, 1,
Offset (0xA4),
D3HT, 2,
Offset (0xD8),
, 30,
HPEX, 1,
PMEX, 1,
Offset (0xE0),
SCB0, 1,
, 6,
NCB7, 1,
Offset (0xE2),
, 2,
L23E, 1,
L23R, 1,
Offset (0x328),
, 19,
LNKS, 4
}

Field (PXCS, AnyAcc, NoLock, WriteAsZeros)
{
Offset (0xDC),
, 30,
HPSX, 1,
PMSX, 1
}

Method (L23D, 0, Serialized)
{
If ((SIPV < 0x10))
{
If ((NCB7 != One))
{
Return (Zero)
}
}
ElseIf ((SCB0 != One))
{
Return (Zero)
}

L23R = One
Local0 = Zero
While (L23R)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = Zero
}
Else
{
SCB0 = Zero
}

Local0 = Zero
While ((LASX == Zero))
{
If ((Local0 > 0x08))
{
Break
}

Sleep (0x10)
Local0++
}
}

Method (DL23, 0, Serialized)
{
L23E = One
Sleep (0x10)
Local0 = Zero
While (L23E)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = One
}
Else
{
SCB0 = One
}
}

Name (LTRV, Package (0x04)
{
Zero,
Zero,
Zero,
Zero
})
Name (HBCS, Zero)
Name (PRMV, Zero)
Name (RD3C, 0x02)
Method (PRES, 0, NotSerialized)
{
If ((VDID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If ((Arg0 == ToUUID ("e5c937d0-3553-4d7a-9117-ea4d19c3434d") /* Device Labeling Interface */))
{
Switch (ToInteger (Arg2))
{
Case (Zero)
{
Name (OPTS, Buffer (0x02)
{
0x00, 0x00 // ..
})
CreateBitField (OPTS, Zero, FUN0)
CreateBitField (OPTS, 0x06, FUN6)
CreateBitField (OPTS, 0x08, FUN8)
CreateBitField (OPTS, 0x09, FUN9)
CreateBitField (OPTS, 0x0A, FUNA)
CreateBitField (OPTS, 0x0B, FUNB)
If ((Arg1 >= 0x02))
{
FUN0 = One
If ((LTEN != Zero))
{
FUN6 = One
}

If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
FUN8 = One
FUN9 = One
}
}
}
}

If ((Arg1 >= 0x04))
{
If (CondRefOf (PPBA))
{
FUNA = One
}

If (CondRefOf (UPRD))
{
FUNB = One
}
}

Return (OPTS) /* \_SB_.PC00.RP19._DSM.OPTS */
}
Case (0x06)
{
If ((Arg1 >= 0x02))
{
LTRV [Zero] = ((LMSL >> 0x0A) & 0x07)
LTRV [One] = (LMSL & 0x03FF)
LTRV [0x02] = ((LNSL >> 0x0A) & 0x07)
LTRV [0x03] = (LNSL & 0x03FF)
Return (LTRV) /* \_SB_.PC00.RP19.LTRV */
}
}
Case (0x08)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (One)
}
}
}
}
Case (0x09)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (Package (0x05)
{
0xC350,
Ones,
Ones,
0xC350,
Ones
})
}
}
}
}
Case (0x0A)
{
If (CondRefOf (PPBA))
{
Return (PPBA (Arg3))
}
}
Case (0x0B)
{
If (CondRefOf (UPRD))
{
Return (UPRD (Arg3))
}
}

}
}

Return (Buffer (One)
{
0x00 // .
})
}

Device (PXSX)
{
Name (_ADR, Zero) // _ADR: Address
OperationRegion (PCCX, PCI_Config, Zero, 0x10)
Field (PCCX, ByteAcc, NoLock, Preserve)
{
DVID, 32,
Offset (0x09),
PIXX, 8,
SCCX, 8,
BCCX, 8
}

Method (PAHC, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x06))
{
If ((PIXX == One))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PNVM, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x08))
{
If ((PIXX == 0x02))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PRES, 0, Serialized)
{
If ((DVID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (ISGX, 0, Serialized)
{
If ((BCCX == 0x03))
{
Return (One)
}

Return (Zero)
}

If (CondRefOf (\STD3))
{
If ((STD3 != Zero))
{
Method (_DSD, 0, NotSerialized) // _DSD: Device-Specific Data
{
If ((PAHC () || PNVM ()))
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
One
}
}
})
}
Else
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
Zero
}
}
})
}
}
}
}

Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake
{
Return (GPRW (0x69, 0x03))
}
}

Method (_PS0, 0, Serialized) // _PS0: Power State 0
{
If (CondRefOf (PPS0))
{
PPS0 ()
}
}

Method (_PS3, 0, Serialized) // _PS3: Power State 3
{
If (CondRefOf (PPS3))
{
PPS3 ()
}
}

Method (HPME, 0, Serialized)
{
If (((VDID != 0xFFFFFFFF) && (PMSX == One)))
{
Notify (PXSX, 0x02) // Device Wake
PMSX = One
PSPX = One
}
}

Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table
{
If (CondRefOf (PICM))
{
If (PICM)
{
Return (AR06 ())
}
}

Return (PD06 ())
}
}

Device (RP20)
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
If ((RPAK != Zero))
{
Return (RPAK) /* \RPAK */
}
Else
{
Return (0x001B0003)
}
}

Name (SLOT, 0x14)
Name (LTEN, Zero)
Name (LMSL, Zero)
Name (LNSL, Zero)
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
LTEN = LTRK /* \LTRK */
LMSL = PMLK /* \PMLK */
LNSL = PNLK /* \PNLK */
If ((HBSL & 0x10))
{
HBCS = One
}

If ((CondRefOf (VMR3) && CondRefOf (VMDE)))
{
If (((VMDE == One) && ((VMR3 & 0x08) != Zero)))
{
PRMV = One
}
}

If (PRES ())
{
If (CondRefOf (PINI))
{
PINI ()
}
}

If (CondRefOf (\_SB.PC00.RP20))
{
If ((VDID != 0xFFFFFFFF))
{
If (CondRefOf (\STD3))
{
If (CondRefOf (\_SB.PC00.RP20.PRMV))
{
If ((PRMV == One))
{
RD3C = STD3 /* \STD3 */
}
}

If ((^PXSX.PNVM () || ^PXSX.PAHC ()))
{
RD3C = STD3 /* \STD3 */
}
}
}
}
}

SIPV = GSIP ()
Name (PRTP, 0x02)
OperationRegion (PXCS, SystemMemory, PC2M (_ADR ()), 0x0480)
Field (PXCS, AnyAcc, NoLock, Preserve)
{
VDID, 32,
Offset (0x50),
L0SE, 1,
, 3,
LDIS, 1,
Offset (0x51),
Offset (0x52),
, 13,
LASX, 1,
Offset (0x5A),
ABPX, 1,
, 2,
PDCX, 1,
, 2,
PDSX, 1,
Offset (0x5B),
Offset (0x60),
Offset (0x62),
PSPX, 1,
Offset (0xA4),
D3HT, 2,
Offset (0xD8),
, 30,
HPEX, 1,
PMEX, 1,
Offset (0xE0),
SCB0, 1,
, 6,
NCB7, 1,
Offset (0xE2),
, 2,
L23E, 1,
L23R, 1,
Offset (0x328),
, 19,
LNKS, 4
}

Field (PXCS, AnyAcc, NoLock, WriteAsZeros)
{
Offset (0xDC),
, 30,
HPSX, 1,
PMSX, 1
}

Method (L23D, 0, Serialized)
{
If ((SIPV < 0x10))
{
If ((NCB7 != One))
{
Return (Zero)
}
}
ElseIf ((SCB0 != One))
{
Return (Zero)
}

L23R = One
Local0 = Zero
While (L23R)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = Zero
}
Else
{
SCB0 = Zero
}

Local0 = Zero
While ((LASX == Zero))
{
If ((Local0 > 0x08))
{
Break
}

Sleep (0x10)
Local0++
}
}

Method (DL23, 0, Serialized)
{
L23E = One
Sleep (0x10)
Local0 = Zero
While (L23E)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = One
}
Else
{
SCB0 = One
}
}

Name (LTRV, Package (0x04)
{
Zero,
Zero,
Zero,
Zero
})
Name (HBCS, Zero)
Name (PRMV, Zero)
Name (RD3C, 0x02)
Method (PRES, 0, NotSerialized)
{
If ((VDID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If ((Arg0 == ToUUID ("e5c937d0-3553-4d7a-9117-ea4d19c3434d") /* Device Labeling Interface */))
{
Switch (ToInteger (Arg2))
{
Case (Zero)
{
Name (OPTS, Buffer (0x02)
{
0x00, 0x00 // ..
})
CreateBitField (OPTS, Zero, FUN0)
CreateBitField (OPTS, 0x06, FUN6)
CreateBitField (OPTS, 0x08, FUN8)
CreateBitField (OPTS, 0x09, FUN9)
CreateBitField (OPTS, 0x0A, FUNA)
CreateBitField (OPTS, 0x0B, FUNB)
If ((Arg1 >= 0x02))
{
FUN0 = One
If ((LTEN != Zero))
{
FUN6 = One
}

If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
FUN8 = One
FUN9 = One
}
}
}
}

If ((Arg1 >= 0x04))
{
If (CondRefOf (PPBA))
{
FUNA = One
}

If (CondRefOf (UPRD))
{
FUNB = One
}
}

Return (OPTS) /* \_SB_.PC00.RP20._DSM.OPTS */
}
Case (0x06)
{
If ((Arg1 >= 0x02))
{
LTRV [Zero] = ((LMSL >> 0x0A) & 0x07)
LTRV [One] = (LMSL & 0x03FF)
LTRV [0x02] = ((LNSL >> 0x0A) & 0x07)
LTRV [0x03] = (LNSL & 0x03FF)
Return (LTRV) /* \_SB_.PC00.RP20.LTRV */
}
}
Case (0x08)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (One)
}
}
}
}
Case (0x09)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (Package (0x05)
{
0xC350,
Ones,
Ones,
0xC350,
Ones
})
}
}
}
}
Case (0x0A)
{
If (CondRefOf (PPBA))
{
Return (PPBA (Arg3))
}
}
Case (0x0B)
{
If (CondRefOf (UPRD))
{
Return (UPRD (Arg3))
}
}

}
}

Return (Buffer (One)
{
0x00 // .
})
}

Device (PXSX)
{
Name (_ADR, Zero) // _ADR: Address
OperationRegion (PCCX, PCI_Config, Zero, 0x10)
Field (PCCX, ByteAcc, NoLock, Preserve)
{
DVID, 32,
Offset (0x09),
PIXX, 8,
SCCX, 8,
BCCX, 8
}

Method (PAHC, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x06))
{
If ((PIXX == One))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PNVM, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x08))
{
If ((PIXX == 0x02))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PRES, 0, Serialized)
{
If ((DVID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (ISGX, 0, Serialized)
{
If ((BCCX == 0x03))
{
Return (One)
}

Return (Zero)
}

If (CondRefOf (\STD3))
{
If ((STD3 != Zero))
{
Method (_DSD, 0, NotSerialized) // _DSD: Device-Specific Data
{
If ((PAHC () || PNVM ()))
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
One
}
}
})
}
Else
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
Zero
}
}
})
}
}
}
}

Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake
{
Return (GPRW (0x69, 0x03))
}
}

Method (_PS0, 0, Serialized) // _PS0: Power State 0
{
If (CondRefOf (PPS0))
{
PPS0 ()
}
}

Method (_PS3, 0, Serialized) // _PS3: Power State 3
{
If (CondRefOf (PPS3))
{
PPS3 ()
}
}

Method (HPME, 0, Serialized)
{
If (((VDID != 0xFFFFFFFF) && (PMSX == One)))
{
Notify (PXSX, 0x02) // Device Wake
PMSX = One
PSPX = One
}
}

Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table
{
If (CondRefOf (PICM))
{
If (PICM)
{
Return (AR07 ())
}
}

Return (PD07 ())
}
}

Device (RP21)
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
If ((RPAL != Zero))
{
Return (RPAL) /* \RPAL */
}
Else
{
Return (0x001B0004)
}
}

Name (SLOT, 0x15)
Name (LTEN, Zero)
Name (LMSL, Zero)
Name (LNSL, Zero)
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
LTEN = LTRL /* \LTRL */
LMSL = PMLL /* \PMLL */
LNSL = PNLL /* \PNLL */
If ((HBSL & 0x20))
{
HBCS = One
}

If ((CondRefOf (VMR3) && CondRefOf (VMDE)))
{
If (((VMDE == One) && ((VMR3 & 0x10) != Zero)))
{
PRMV = One
}
}

If (PRES ())
{
If (CondRefOf (PINI))
{
PINI ()
}
}

If (CondRefOf (\_SB.PC00.RP21))
{
If ((VDID != 0xFFFFFFFF))
{
If (CondRefOf (\STD3))
{
If (CondRefOf (\_SB.PC00.RP21.PRMV))
{
If ((PRMV == One))
{
RD3C = STD3 /* \STD3 */
}
}

If ((^PXSX.PNVM () || ^PXSX.PAHC ()))
{
RD3C = STD3 /* \STD3 */
}
}
}
}
}

SIPV = GSIP ()
Name (PRTP, 0x02)
OperationRegion (PXCS, SystemMemory, PC2M (_ADR ()), 0x0480)
Field (PXCS, AnyAcc, NoLock, Preserve)
{
VDID, 32,
Offset (0x50),
L0SE, 1,
, 3,
LDIS, 1,
Offset (0x51),
Offset (0x52),
, 13,
LASX, 1,
Offset (0x5A),
ABPX, 1,
, 2,
PDCX, 1,
, 2,
PDSX, 1,
Offset (0x5B),
Offset (0x60),
Offset (0x62),
PSPX, 1,
Offset (0xA4),
D3HT, 2,
Offset (0xD8),
, 30,
HPEX, 1,
PMEX, 1,
Offset (0xE0),
SCB0, 1,
, 6,
NCB7, 1,
Offset (0xE2),
, 2,
L23E, 1,
L23R, 1,
Offset (0x328),
, 19,
LNKS, 4
}

Field (PXCS, AnyAcc, NoLock, WriteAsZeros)
{
Offset (0xDC),
, 30,
HPSX, 1,
PMSX, 1
}

Method (L23D, 0, Serialized)
{
If ((SIPV < 0x10))
{
If ((NCB7 != One))
{
Return (Zero)
}
}
ElseIf ((SCB0 != One))
{
Return (Zero)
}

L23R = One
Local0 = Zero
While (L23R)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = Zero
}
Else
{
SCB0 = Zero
}

Local0 = Zero
While ((LASX == Zero))
{
If ((Local0 > 0x08))
{
Break
}

Sleep (0x10)
Local0++
}
}

Method (DL23, 0, Serialized)
{
L23E = One
Sleep (0x10)
Local0 = Zero
While (L23E)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = One
}
Else
{
SCB0 = One
}
}

Name (LTRV, Package (0x04)
{
Zero,
Zero,
Zero,
Zero
})
Name (HBCS, Zero)
Name (PRMV, Zero)
Name (RD3C, 0x02)
Method (PRES, 0, NotSerialized)
{
If ((VDID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If ((Arg0 == ToUUID ("e5c937d0-3553-4d7a-9117-ea4d19c3434d") /* Device Labeling Interface */))
{
Switch (ToInteger (Arg2))
{
Case (Zero)
{
Name (OPTS, Buffer (0x02)
{
0x00, 0x00 // ..
})
CreateBitField (OPTS, Zero, FUN0)
CreateBitField (OPTS, 0x06, FUN6)
CreateBitField (OPTS, 0x08, FUN8)
CreateBitField (OPTS, 0x09, FUN9)
CreateBitField (OPTS, 0x0A, FUNA)
CreateBitField (OPTS, 0x0B, FUNB)
If ((Arg1 >= 0x02))
{
FUN0 = One
If ((LTEN != Zero))
{
FUN6 = One
}

If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
FUN8 = One
FUN9 = One
}
}
}
}

If ((Arg1 >= 0x04))
{
If (CondRefOf (PPBA))
{
FUNA = One
}

If (CondRefOf (UPRD))
{
FUNB = One
}
}

Return (OPTS) /* \_SB_.PC00.RP21._DSM.OPTS */
}
Case (0x06)
{
If ((Arg1 >= 0x02))
{
LTRV [Zero] = ((LMSL >> 0x0A) & 0x07)
LTRV [One] = (LMSL & 0x03FF)
LTRV [0x02] = ((LNSL >> 0x0A) & 0x07)
LTRV [0x03] = (LNSL & 0x03FF)
Return (LTRV) /* \_SB_.PC00.RP21.LTRV */
}
}
Case (0x08)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (One)
}
}
}
}
Case (0x09)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (Package (0x05)
{
0xC350,
Ones,
Ones,
0xC350,
Ones
})
}
}
}
}
Case (0x0A)
{
If (CondRefOf (PPBA))
{
Return (PPBA (Arg3))
}
}
Case (0x0B)
{
If (CondRefOf (UPRD))
{
Return (UPRD (Arg3))
}
}

}
}

Return (Buffer (One)
{
0x00 // .
})
}

Device (PXSX)
{
Name (_ADR, Zero) // _ADR: Address
OperationRegion (PCCX, PCI_Config, Zero, 0x10)
Field (PCCX, ByteAcc, NoLock, Preserve)
{
DVID, 32,
Offset (0x09),
PIXX, 8,
SCCX, 8,
BCCX, 8
}

Method (PAHC, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x06))
{
If ((PIXX == One))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PNVM, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x08))
{
If ((PIXX == 0x02))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PRES, 0, Serialized)
{
If ((DVID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (ISGX, 0, Serialized)
{
If ((BCCX == 0x03))
{
Return (One)
}

Return (Zero)
}

If (CondRefOf (\STD3))
{
If ((STD3 != Zero))
{
Method (_DSD, 0, NotSerialized) // _DSD: Device-Specific Data
{
If ((PAHC () || PNVM ()))
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
One
}
}
})
}
Else
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
Zero
}
}
})
}
}
}
}

Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake
{
Return (GPRW (0x69, 0x03))
}
}

Method (_PS0, 0, Serialized) // _PS0: Power State 0
{
If (CondRefOf (PPS0))
{
PPS0 ()
}
}

Method (_PS3, 0, Serialized) // _PS3: Power State 3
{
If (CondRefOf (PPS3))
{
PPS3 ()
}
}

Method (HPME, 0, Serialized)
{
If (((VDID != 0xFFFFFFFF) && (PMSX == One)))
{
Notify (PXSX, 0x02) // Device Wake
PMSX = One
PSPX = One
}
}

Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table
{
If (CondRefOf (PICM))
{
If (PICM)
{
Return (AR04 ())
}
}

Return (PD04 ())
}
}

Device (RP22)
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
If ((RPAM != Zero))
{
Return (RPAM) /* \RPAM */
}
Else
{
Return (0x001B0005)
}
}

Name (SLOT, 0x16)
Name (LTEN, Zero)
Name (LMSL, Zero)
Name (LNSL, Zero)
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
LTEN = LTRM /* \LTRM */
LMSL = PMLM /* \PMLM */
LNSL = PNLM /* \PNLM */
If ((HBSL & 0x20))
{
HBCS = One
}

If ((CondRefOf (VMR3) && CondRefOf (VMDE)))
{
If (((VMDE == One) && ((VMR3 & 0x20) != Zero)))
{
PRMV = One
}
}

If (PRES ())
{
If (CondRefOf (PINI))
{
PINI ()
}
}

If (CondRefOf (\_SB.PC00.RP22))
{
If ((VDID != 0xFFFFFFFF))
{
If (CondRefOf (\STD3))
{
If (CondRefOf (\_SB.PC00.RP22.PRMV))
{
If ((PRMV == One))
{
RD3C = STD3 /* \STD3 */
}
}

If ((^PXSX.PNVM () || ^PXSX.PAHC ()))
{
RD3C = STD3 /* \STD3 */
}
}
}
}
}

SIPV = GSIP ()
Name (PRTP, 0x02)
OperationRegion (PXCS, SystemMemory, PC2M (_ADR ()), 0x0480)
Field (PXCS, AnyAcc, NoLock, Preserve)
{
VDID, 32,
Offset (0x50),
L0SE, 1,
, 3,
LDIS, 1,
Offset (0x51),
Offset (0x52),
, 13,
LASX, 1,
Offset (0x5A),
ABPX, 1,
, 2,
PDCX, 1,
, 2,
PDSX, 1,
Offset (0x5B),
Offset (0x60),
Offset (0x62),
PSPX, 1,
Offset (0xA4),
D3HT, 2,
Offset (0xD8),
, 30,
HPEX, 1,
PMEX, 1,
Offset (0xE0),
SCB0, 1,
, 6,
NCB7, 1,
Offset (0xE2),
, 2,
L23E, 1,
L23R, 1,
Offset (0x328),
, 19,
LNKS, 4
}

Field (PXCS, AnyAcc, NoLock, WriteAsZeros)
{
Offset (0xDC),
, 30,
HPSX, 1,
PMSX, 1
}

Method (L23D, 0, Serialized)
{
If ((SIPV < 0x10))
{
If ((NCB7 != One))
{
Return (Zero)
}
}
ElseIf ((SCB0 != One))
{
Return (Zero)
}

L23R = One
Local0 = Zero
While (L23R)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = Zero
}
Else
{
SCB0 = Zero
}

Local0 = Zero
While ((LASX == Zero))
{
If ((Local0 > 0x08))
{
Break
}

Sleep (0x10)
Local0++
}
}

Method (DL23, 0, Serialized)
{
L23E = One
Sleep (0x10)
Local0 = Zero
While (L23E)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = One
}
Else
{
SCB0 = One
}
}

Name (LTRV, Package (0x04)
{
Zero,
Zero,
Zero,
Zero
})
Name (HBCS, Zero)
Name (PRMV, Zero)
Name (RD3C, 0x02)
Method (PRES, 0, NotSerialized)
{
If ((VDID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If ((Arg0 == ToUUID ("e5c937d0-3553-4d7a-9117-ea4d19c3434d") /* Device Labeling Interface */))
{
Switch (ToInteger (Arg2))
{
Case (Zero)
{
Name (OPTS, Buffer (0x02)
{
0x00, 0x00 // ..
})
CreateBitField (OPTS, Zero, FUN0)
CreateBitField (OPTS, 0x06, FUN6)
CreateBitField (OPTS, 0x08, FUN8)
CreateBitField (OPTS, 0x09, FUN9)
CreateBitField (OPTS, 0x0A, FUNA)
CreateBitField (OPTS, 0x0B, FUNB)
If ((Arg1 >= 0x02))
{
FUN0 = One
If ((LTEN != Zero))
{
FUN6 = One
}

If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
FUN8 = One
FUN9 = One
}
}
}
}

If ((Arg1 >= 0x04))
{
If (CondRefOf (PPBA))
{
FUNA = One
}

If (CondRefOf (UPRD))
{
FUNB = One
}
}

Return (OPTS) /* \_SB_.PC00.RP22._DSM.OPTS */
}
Case (0x06)
{
If ((Arg1 >= 0x02))
{
LTRV [Zero] = ((LMSL >> 0x0A) & 0x07)
LTRV [One] = (LMSL & 0x03FF)
LTRV [0x02] = ((LNSL >> 0x0A) & 0x07)
LTRV [0x03] = (LNSL & 0x03FF)
Return (LTRV) /* \_SB_.PC00.RP22.LTRV */
}
}
Case (0x08)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (One)
}
}
}
}
Case (0x09)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (Package (0x05)
{
0xC350,
Ones,
Ones,
0xC350,
Ones
})
}
}
}
}
Case (0x0A)
{
If (CondRefOf (PPBA))
{
Return (PPBA (Arg3))
}
}
Case (0x0B)
{
If (CondRefOf (UPRD))
{
Return (UPRD (Arg3))
}
}

}
}

Return (Buffer (One)
{
0x00 // .
})
}

Device (PXSX)
{
Name (_ADR, Zero) // _ADR: Address
OperationRegion (PCCX, PCI_Config, Zero, 0x10)
Field (PCCX, ByteAcc, NoLock, Preserve)
{
DVID, 32,
Offset (0x09),
PIXX, 8,
SCCX, 8,
BCCX, 8
}

Method (PAHC, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x06))
{
If ((PIXX == One))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PNVM, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x08))
{
If ((PIXX == 0x02))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PRES, 0, Serialized)
{
If ((DVID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (ISGX, 0, Serialized)
{
If ((BCCX == 0x03))
{
Return (One)
}

Return (Zero)
}

If (CondRefOf (\STD3))
{
If ((STD3 != Zero))
{
Method (_DSD, 0, NotSerialized) // _DSD: Device-Specific Data
{
If ((PAHC () || PNVM ()))
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
One
}
}
})
}
Else
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
Zero
}
}
})
}
}
}
}

Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake
{
Return (GPRW (0x69, 0x03))
}
}

Method (_PS0, 0, Serialized) // _PS0: Power State 0
{
If (CondRefOf (PPS0))
{
PPS0 ()
}
}

Method (_PS3, 0, Serialized) // _PS3: Power State 3
{
If (CondRefOf (PPS3))
{
PPS3 ()
}
}

Method (HPME, 0, Serialized)
{
If (((VDID != 0xFFFFFFFF) && (PMSX == One)))
{
Notify (PXSX, 0x02) // Device Wake
PMSX = One
PSPX = One
}
}

Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table
{
If (CondRefOf (PICM))
{
If (PICM)
{
Return (AR05 ())
}
}

Return (PD05 ())
}
}

Device (RP23)
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
If ((RPAN != Zero))
{
Return (RPAN) /* \RPAN */
}
Else
{
Return (0x001B0006)
}
}

Name (SLOT, 0x17)
Name (LTEN, Zero)
Name (LMSL, Zero)
Name (LNSL, Zero)
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
LTEN = LTRN /* \LTRN */
LMSL = PMLN /* \PMLN */
LNSL = PNLN /* \PNLN */
If ((HBSL & 0x20))
{
HBCS = One
}

If ((CondRefOf (VMR3) && CondRefOf (VMDE)))
{
If (((VMDE == One) && ((VMR3 & 0x40) != Zero)))
{
PRMV = One
}
}

If (PRES ())
{
If (CondRefOf (PINI))
{
PINI ()
}
}

If (CondRefOf (\_SB.PC00.RP23))
{
If ((VDID != 0xFFFFFFFF))
{
If (CondRefOf (\STD3))
{
If (CondRefOf (\_SB.PC00.RP23.PRMV))
{
If ((PRMV == One))
{
RD3C = STD3 /* \STD3 */
}
}

If ((^PXSX.PNVM () || ^PXSX.PAHC ()))
{
RD3C = STD3 /* \STD3 */
}
}
}
}
}

SIPV = GSIP ()
Name (PRTP, 0x02)
OperationRegion (PXCS, SystemMemory, PC2M (_ADR ()), 0x0480)
Field (PXCS, AnyAcc, NoLock, Preserve)
{
VDID, 32,
Offset (0x50),
L0SE, 1,
, 3,
LDIS, 1,
Offset (0x51),
Offset (0x52),
, 13,
LASX, 1,
Offset (0x5A),
ABPX, 1,
, 2,
PDCX, 1,
, 2,
PDSX, 1,
Offset (0x5B),
Offset (0x60),
Offset (0x62),
PSPX, 1,
Offset (0xA4),
D3HT, 2,
Offset (0xD8),
, 30,
HPEX, 1,
PMEX, 1,
Offset (0xE0),
SCB0, 1,
, 6,
NCB7, 1,
Offset (0xE2),
, 2,
L23E, 1,
L23R, 1,
Offset (0x328),
, 19,
LNKS, 4
}

Field (PXCS, AnyAcc, NoLock, WriteAsZeros)
{
Offset (0xDC),
, 30,
HPSX, 1,
PMSX, 1
}

Method (L23D, 0, Serialized)
{
If ((SIPV < 0x10))
{
If ((NCB7 != One))
{
Return (Zero)
}
}
ElseIf ((SCB0 != One))
{
Return (Zero)
}

L23R = One
Local0 = Zero
While (L23R)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = Zero
}
Else
{
SCB0 = Zero
}

Local0 = Zero
While ((LASX == Zero))
{
If ((Local0 > 0x08))
{
Break
}

Sleep (0x10)
Local0++
}
}

Method (DL23, 0, Serialized)
{
L23E = One
Sleep (0x10)
Local0 = Zero
While (L23E)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = One
}
Else
{
SCB0 = One
}
}

Name (LTRV, Package (0x04)
{
Zero,
Zero,
Zero,
Zero
})
Name (HBCS, Zero)
Name (PRMV, Zero)
Name (RD3C, 0x02)
Method (PRES, 0, NotSerialized)
{
If ((VDID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If ((Arg0 == ToUUID ("e5c937d0-3553-4d7a-9117-ea4d19c3434d") /* Device Labeling Interface */))
{
Switch (ToInteger (Arg2))
{
Case (Zero)
{
Name (OPTS, Buffer (0x02)
{
0x00, 0x00 // ..
})
CreateBitField (OPTS, Zero, FUN0)
CreateBitField (OPTS, 0x06, FUN6)
CreateBitField (OPTS, 0x08, FUN8)
CreateBitField (OPTS, 0x09, FUN9)
CreateBitField (OPTS, 0x0A, FUNA)
CreateBitField (OPTS, 0x0B, FUNB)
If ((Arg1 >= 0x02))
{
FUN0 = One
If ((LTEN != Zero))
{
FUN6 = One
}

If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
FUN8 = One
FUN9 = One
}
}
}
}

If ((Arg1 >= 0x04))
{
If (CondRefOf (PPBA))
{
FUNA = One
}

If (CondRefOf (UPRD))
{
FUNB = One
}
}

Return (OPTS) /* \_SB_.PC00.RP23._DSM.OPTS */
}
Case (0x06)
{
If ((Arg1 >= 0x02))
{
LTRV [Zero] = ((LMSL >> 0x0A) & 0x07)
LTRV [One] = (LMSL & 0x03FF)
LTRV [0x02] = ((LNSL >> 0x0A) & 0x07)
LTRV [0x03] = (LNSL & 0x03FF)
Return (LTRV) /* \_SB_.PC00.RP23.LTRV */
}
}
Case (0x08)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (One)
}
}
}
}
Case (0x09)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (Package (0x05)
{
0xC350,
Ones,
Ones,
0xC350,
Ones
})
}
}
}
}
Case (0x0A)
{
If (CondRefOf (PPBA))
{
Return (PPBA (Arg3))
}
}
Case (0x0B)
{
If (CondRefOf (UPRD))
{
Return (UPRD (Arg3))
}
}

}
}

Return (Buffer (One)
{
0x00 // .
})
}

Device (PXSX)
{
Name (_ADR, Zero) // _ADR: Address
OperationRegion (PCCX, PCI_Config, Zero, 0x10)
Field (PCCX, ByteAcc, NoLock, Preserve)
{
DVID, 32,
Offset (0x09),
PIXX, 8,
SCCX, 8,
BCCX, 8
}

Method (PAHC, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x06))
{
If ((PIXX == One))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PNVM, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x08))
{
If ((PIXX == 0x02))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PRES, 0, Serialized)
{
If ((DVID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (ISGX, 0, Serialized)
{
If ((BCCX == 0x03))
{
Return (One)
}

Return (Zero)
}

If (CondRefOf (\STD3))
{
If ((STD3 != Zero))
{
Method (_DSD, 0, NotSerialized) // _DSD: Device-Specific Data
{
If ((PAHC () || PNVM ()))
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
One
}
}
})
}
Else
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
Zero
}
}
})
}
}
}
}

Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake
{
Return (GPRW (0x69, 0x03))
}
}

Method (_PS0, 0, Serialized) // _PS0: Power State 0
{
If (CondRefOf (PPS0))
{
PPS0 ()
}
}

Method (_PS3, 0, Serialized) // _PS3: Power State 3
{
If (CondRefOf (PPS3))
{
PPS3 ()
}
}

Method (HPME, 0, Serialized)
{
If (((VDID != 0xFFFFFFFF) && (PMSX == One)))
{
Notify (PXSX, 0x02) // Device Wake
PMSX = One
PSPX = One
}
}

Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table
{
If (CondRefOf (PICM))
{
If (PICM)
{
Return (AR06 ())
}
}

Return (PD06 ())
}
}

Device (RP24)
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
If ((RPAO != Zero))
{
Return (RPAO) /* \RPAO */
}
Else
{
Return (0x001B0007)
}
}

Name (SLOT, 0x18)
Name (LTEN, Zero)
Name (LMSL, Zero)
Name (LNSL, Zero)
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
LTEN = LTRO /* \LTRO */
LMSL = PMLO /* \PMLO */
LNSL = PNLO /* \PNLO */
If ((HBSL & 0x20))
{
HBCS = One
}

If ((CondRefOf (VMR3) && CondRefOf (VMDE)))
{
If (((VMDE == One) && ((VMR3 & 0x80) != Zero)))
{
PRMV = One
}
}

If (PRES ())
{
If (CondRefOf (PINI))
{
PINI ()
}
}

If (CondRefOf (\_SB.PC00.RP24))
{
If ((VDID != 0xFFFFFFFF))
{
If (CondRefOf (\STD3))
{
If (CondRefOf (\_SB.PC00.RP24.PRMV))
{
If ((PRMV == One))
{
RD3C = STD3 /* \STD3 */
}
}

If ((^PXSX.PNVM () || ^PXSX.PAHC ()))
{
RD3C = STD3 /* \STD3 */
}
}
}
}
}

SIPV = GSIP ()
Name (PRTP, 0x02)
OperationRegion (PXCS, SystemMemory, PC2M (_ADR ()), 0x0480)
Field (PXCS, AnyAcc, NoLock, Preserve)
{
VDID, 32,
Offset (0x50),
L0SE, 1,
, 3,
LDIS, 1,
Offset (0x51),
Offset (0x52),
, 13,
LASX, 1,
Offset (0x5A),
ABPX, 1,
, 2,
PDCX, 1,
, 2,
PDSX, 1,
Offset (0x5B),
Offset (0x60),
Offset (0x62),
PSPX, 1,
Offset (0xA4),
D3HT, 2,
Offset (0xD8),
, 30,
HPEX, 1,
PMEX, 1,
Offset (0xE0),
SCB0, 1,
, 6,
NCB7, 1,
Offset (0xE2),
, 2,
L23E, 1,
L23R, 1,
Offset (0x328),
, 19,
LNKS, 4
}

Field (PXCS, AnyAcc, NoLock, WriteAsZeros)
{
Offset (0xDC),
, 30,
HPSX, 1,
PMSX, 1
}

Method (L23D, 0, Serialized)
{
If ((SIPV < 0x10))
{
If ((NCB7 != One))
{
Return (Zero)
}
}
ElseIf ((SCB0 != One))
{
Return (Zero)
}

L23R = One
Local0 = Zero
While (L23R)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = Zero
}
Else
{
SCB0 = Zero
}

Local0 = Zero
While ((LASX == Zero))
{
If ((Local0 > 0x08))
{
Break
}

Sleep (0x10)
Local0++
}
}

Method (DL23, 0, Serialized)
{
L23E = One
Sleep (0x10)
Local0 = Zero
While (L23E)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = One
}
Else
{
SCB0 = One
}
}

Name (LTRV, Package (0x04)
{
Zero,
Zero,
Zero,
Zero
})
Name (HBCS, Zero)
Name (PRMV, Zero)
Name (RD3C, 0x02)
Method (PRES, 0, NotSerialized)
{
If ((VDID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If ((Arg0 == ToUUID ("e5c937d0-3553-4d7a-9117-ea4d19c3434d") /* Device Labeling Interface */))
{
Switch (ToInteger (Arg2))
{
Case (Zero)
{
Name (OPTS, Buffer (0x02)
{
0x00, 0x00 // ..
})
CreateBitField (OPTS, Zero, FUN0)
CreateBitField (OPTS, 0x06, FUN6)
CreateBitField (OPTS, 0x08, FUN8)
CreateBitField (OPTS, 0x09, FUN9)
CreateBitField (OPTS, 0x0A, FUNA)
CreateBitField (OPTS, 0x0B, FUNB)
If ((Arg1 >= 0x02))
{
FUN0 = One
If ((LTEN != Zero))
{
FUN6 = One
}

If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
FUN8 = One
FUN9 = One
}
}
}
}

If ((Arg1 >= 0x04))
{
If (CondRefOf (PPBA))
{
FUNA = One
}

If (CondRefOf (UPRD))
{
FUNB = One
}
}

Return (OPTS) /* \_SB_.PC00.RP24._DSM.OPTS */
}
Case (0x06)
{
If ((Arg1 >= 0x02))
{
LTRV [Zero] = ((LMSL >> 0x0A) & 0x07)
LTRV [One] = (LMSL & 0x03FF)
LTRV [0x02] = ((LNSL >> 0x0A) & 0x07)
LTRV [0x03] = (LNSL & 0x03FF)
Return (LTRV) /* \_SB_.PC00.RP24.LTRV */
}
}
Case (0x08)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (One)
}
}
}
}
Case (0x09)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (Package (0x05)
{
0xC350,
Ones,
Ones,
0xC350,
Ones
})
}
}
}
}
Case (0x0A)
{
If (CondRefOf (PPBA))
{
Return (PPBA (Arg3))
}
}
Case (0x0B)
{
If (CondRefOf (UPRD))
{
Return (UPRD (Arg3))
}
}

}
}

Return (Buffer (One)
{
0x00 // .
})
}

Device (PXSX)
{
Name (_ADR, Zero) // _ADR: Address
OperationRegion (PCCX, PCI_Config, Zero, 0x10)
Field (PCCX, ByteAcc, NoLock, Preserve)
{
DVID, 32,
Offset (0x09),
PIXX, 8,
SCCX, 8,
BCCX, 8
}

Method (PAHC, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x06))
{
If ((PIXX == One))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PNVM, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x08))
{
If ((PIXX == 0x02))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PRES, 0, Serialized)
{
If ((DVID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (ISGX, 0, Serialized)
{
If ((BCCX == 0x03))
{
Return (One)
}

Return (Zero)
}

If (CondRefOf (\STD3))
{
If ((STD3 != Zero))
{
Method (_DSD, 0, NotSerialized) // _DSD: Device-Specific Data
{
If ((PAHC () || PNVM ()))
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
One
}
}
})
}
Else
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
Zero
}
}
})
}
}
}
}

Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake
{
Return (GPRW (0x69, 0x03))
}
}

Method (_PS0, 0, Serialized) // _PS0: Power State 0
{
If (CondRefOf (PPS0))
{
PPS0 ()
}
}

Method (_PS3, 0, Serialized) // _PS3: Power State 3
{
If (CondRefOf (PPS3))
{
PPS3 ()
}
}

Method (HPME, 0, Serialized)
{
If (((VDID != 0xFFFFFFFF) && (PMSX == One)))
{
Notify (PXSX, 0x02) // Device Wake
PMSX = One
PSPX = One
}
}

Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table
{
If (CondRefOf (PICM))
{
If (PICM)
{
Return (AR07 ())
}
}

Return (PD07 ())
}
}

If ((PCHS == 0x04))
{
Device (RP25)
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
If ((RPAP != Zero))
{
Return (RPAP) /* \RPAP */
}
Else
{
Return (0x001A0000)
}
}

Name (SLOT, 0x19)
Name (LTEN, Zero)
Name (LMSL, Zero)
Name (LNSL, Zero)
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
LTEN = LTRP /* \LTRP */
LMSL = PMLP /* \PMLP */
LNSL = PNLP /* \PNLP */
If ((HBSL & 0x40))
{
HBCS = One
}

If ((CondRefOf (VMR4) && CondRefOf (VMDE)))
{
If (((VMDE == One) && ((VMR4 & One) != Zero)))
{
PRMV = One
}
}

If (PRES ())
{
If (CondRefOf (PINI))
{
PINI ()
}
}

If (CondRefOf (\_SB.PC00.RP25))
{
If ((VDID != 0xFFFFFFFF))
{
If (CondRefOf (\STD3))
{
If (CondRefOf (\_SB.PC00.RP25.PRMV))
{
If ((PRMV == One))
{
RD3C = STD3 /* \STD3 */
}
}

If ((^PXSX.PNVM () || ^PXSX.PAHC ()))
{
RD3C = STD3 /* \STD3 */
}
}
}
}
}

SIPV = GSIP ()
Name (PRTP, 0x02)
OperationRegion (PXCS, SystemMemory, PC2M (_ADR ()), 0x0480)
Field (PXCS, AnyAcc, NoLock, Preserve)
{
VDID, 32,
Offset (0x50),
L0SE, 1,
, 3,
LDIS, 1,
Offset (0x51),
Offset (0x52),
, 13,
LASX, 1,
Offset (0x5A),
ABPX, 1,
, 2,
PDCX, 1,
, 2,
PDSX, 1,
Offset (0x5B),
Offset (0x60),
Offset (0x62),
PSPX, 1,
Offset (0xA4),
D3HT, 2,
Offset (0xD8),
, 30,
HPEX, 1,
PMEX, 1,
Offset (0xE0),
SCB0, 1,
, 6,
NCB7, 1,
Offset (0xE2),
, 2,
L23E, 1,
L23R, 1,
Offset (0x328),
, 19,
LNKS, 4
}

Field (PXCS, AnyAcc, NoLock, WriteAsZeros)
{
Offset (0xDC),
, 30,
HPSX, 1,
PMSX, 1
}

Method (L23D, 0, Serialized)
{
If ((SIPV < 0x10))
{
If ((NCB7 != One))
{
Return (Zero)
}
}
ElseIf ((SCB0 != One))
{
Return (Zero)
}

L23R = One
Local0 = Zero
While (L23R)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = Zero
}
Else
{
SCB0 = Zero
}

Local0 = Zero
While ((LASX == Zero))
{
If ((Local0 > 0x08))
{
Break
}

Sleep (0x10)
Local0++
}
}

Method (DL23, 0, Serialized)
{
L23E = One
Sleep (0x10)
Local0 = Zero
While (L23E)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = One
}
Else
{
SCB0 = One
}
}

Name (LTRV, Package (0x04)
{
Zero,
Zero,
Zero,
Zero
})
Name (HBCS, Zero)
Name (PRMV, Zero)
Name (RD3C, 0x02)
Method (PRES, 0, NotSerialized)
{
If ((VDID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If ((Arg0 == ToUUID ("e5c937d0-3553-4d7a-9117-ea4d19c3434d") /* Device Labeling Interface */))
{
Switch (ToInteger (Arg2))
{
Case (Zero)
{
Name (OPTS, Buffer (0x02)
{
0x00, 0x00 // ..
})
CreateBitField (OPTS, Zero, FUN0)
CreateBitField (OPTS, 0x06, FUN6)
CreateBitField (OPTS, 0x08, FUN8)
CreateBitField (OPTS, 0x09, FUN9)
CreateBitField (OPTS, 0x0A, FUNA)
CreateBitField (OPTS, 0x0B, FUNB)
If ((Arg1 >= 0x02))
{
FUN0 = One
If ((LTEN != Zero))
{
FUN6 = One
}

If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
FUN8 = One
FUN9 = One
}
}
}
}

If ((Arg1 >= 0x04))
{
If (CondRefOf (PPBA))
{
FUNA = One
}

If (CondRefOf (UPRD))
{
FUNB = One
}
}

Return (OPTS) /* \_SB_.PC00.RP25._DSM.OPTS */
}
Case (0x06)
{
If ((Arg1 >= 0x02))
{
LTRV [Zero] = ((LMSL >> 0x0A) & 0x07)
LTRV [One] = (LMSL & 0x03FF)
LTRV [0x02] = ((LNSL >> 0x0A) & 0x07)
LTRV [0x03] = (LNSL & 0x03FF)
Return (LTRV) /* \_SB_.PC00.RP25.LTRV */
}
}
Case (0x08)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (One)
}
}
}
}
Case (0x09)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (Package (0x05)
{
0xC350,
Ones,
Ones,
0xC350,
Ones
})
}
}
}
}
Case (0x0A)
{
If (CondRefOf (PPBA))
{
Return (PPBA (Arg3))
}
}
Case (0x0B)
{
If (CondRefOf (UPRD))
{
Return (UPRD (Arg3))
}
}

}
}

Return (Buffer (One)
{
0x00 // .
})
}

Device (PXSX)
{
Name (_ADR, Zero) // _ADR: Address
OperationRegion (PCCX, PCI_Config, Zero, 0x10)
Field (PCCX, ByteAcc, NoLock, Preserve)
{
DVID, 32,
Offset (0x09),
PIXX, 8,
SCCX, 8,
BCCX, 8
}

Method (PAHC, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x06))
{
If ((PIXX == One))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PNVM, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x08))
{
If ((PIXX == 0x02))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PRES, 0, Serialized)
{
If ((DVID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (ISGX, 0, Serialized)
{
If ((BCCX == 0x03))
{
Return (One)
}

Return (Zero)
}

If (CondRefOf (\STD3))
{
If ((STD3 != Zero))
{
Method (_DSD, 0, NotSerialized) // _DSD: Device-Specific Data
{
If ((PAHC () || PNVM ()))
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
One
}
}
})
}
Else
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
Zero
}
}
})
}
}
}
}

Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake
{
Return (GPRW (0x69, 0x03))
}
}

Method (_PS0, 0, Serialized) // _PS0: Power State 0
{
If (CondRefOf (PPS0))
{
PPS0 ()
}
}

Method (_PS3, 0, Serialized) // _PS3: Power State 3
{
If (CondRefOf (PPS3))
{
PPS3 ()
}
}

Method (HPME, 0, Serialized)
{
If (((VDID != 0xFFFFFFFF) && (PMSX == One)))
{
Notify (PXSX, 0x02) // Device Wake
PMSX = One
PSPX = One
}
}

Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table
{
If (CondRefOf (PICM))
{
If (PICM)
{
Return (AR04 ())
}
}

Return (PD04 ())
}
}

Device (RP26)
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
If ((RPAQ != Zero))
{
Return (RPAQ) /* \RPAQ */
}
Else
{
Return (0x001A0001)
}
}

Name (SLOT, 0x1A)
Name (LTEN, Zero)
Name (LMSL, Zero)
Name (LNSL, Zero)
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
LTEN = LTRQ /* \LTRQ */
LMSL = PMLQ /* \PMLQ */
LNSL = PNLQ /* \PNLQ */
If ((HBSL & 0x40))
{
HBCS = One
}

If ((CondRefOf (VMR4) && CondRefOf (VMDE)))
{
If (((VMDE == One) && ((VMR4 & 0x02) != Zero)))
{
PRMV = One
}
}

If (PRES ())
{
If (CondRefOf (PINI))
{
PINI ()
}
}

If (CondRefOf (\_SB.PC00.RP26))
{
If ((VDID != 0xFFFFFFFF))
{
If (CondRefOf (\STD3))
{
If (CondRefOf (\_SB.PC00.RP26.PRMV))
{
If ((PRMV == One))
{
RD3C = STD3 /* \STD3 */
}
}

If ((^PXSX.PNVM () || ^PXSX.PAHC ()))
{
RD3C = STD3 /* \STD3 */
}
}
}
}
}

SIPV = GSIP ()
Name (PRTP, 0x02)
OperationRegion (PXCS, SystemMemory, PC2M (_ADR ()), 0x0480)
Field (PXCS, AnyAcc, NoLock, Preserve)
{
VDID, 32,
Offset (0x50),
L0SE, 1,
, 3,
LDIS, 1,
Offset (0x51),
Offset (0x52),
, 13,
LASX, 1,
Offset (0x5A),
ABPX, 1,
, 2,
PDCX, 1,
, 2,
PDSX, 1,
Offset (0x5B),
Offset (0x60),
Offset (0x62),
PSPX, 1,
Offset (0xA4),
D3HT, 2,
Offset (0xD8),
, 30,
HPEX, 1,
PMEX, 1,
Offset (0xE0),
SCB0, 1,
, 6,
NCB7, 1,
Offset (0xE2),
, 2,
L23E, 1,
L23R, 1,
Offset (0x328),
, 19,
LNKS, 4
}

Field (PXCS, AnyAcc, NoLock, WriteAsZeros)
{
Offset (0xDC),
, 30,
HPSX, 1,
PMSX, 1
}

Method (L23D, 0, Serialized)
{
If ((SIPV < 0x10))
{
If ((NCB7 != One))
{
Return (Zero)
}
}
ElseIf ((SCB0 != One))
{
Return (Zero)
}

L23R = One
Local0 = Zero
While (L23R)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = Zero
}
Else
{
SCB0 = Zero
}

Local0 = Zero
While ((LASX == Zero))
{
If ((Local0 > 0x08))
{
Break
}

Sleep (0x10)
Local0++
}
}

Method (DL23, 0, Serialized)
{
L23E = One
Sleep (0x10)
Local0 = Zero
While (L23E)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = One
}
Else
{
SCB0 = One
}
}

Name (LTRV, Package (0x04)
{
Zero,
Zero,
Zero,
Zero
})
Name (HBCS, Zero)
Name (PRMV, Zero)
Name (RD3C, 0x02)
Method (PRES, 0, NotSerialized)
{
If ((VDID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If ((Arg0 == ToUUID ("e5c937d0-3553-4d7a-9117-ea4d19c3434d") /* Device Labeling Interface */))
{
Switch (ToInteger (Arg2))
{
Case (Zero)
{
Name (OPTS, Buffer (0x02)
{
0x00, 0x00 // ..
})
CreateBitField (OPTS, Zero, FUN0)
CreateBitField (OPTS, 0x06, FUN6)
CreateBitField (OPTS, 0x08, FUN8)
CreateBitField (OPTS, 0x09, FUN9)
CreateBitField (OPTS, 0x0A, FUNA)
CreateBitField (OPTS, 0x0B, FUNB)
If ((Arg1 >= 0x02))
{
FUN0 = One
If ((LTEN != Zero))
{
FUN6 = One
}

If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
FUN8 = One
FUN9 = One
}
}
}
}

If ((Arg1 >= 0x04))
{
If (CondRefOf (PPBA))
{
FUNA = One
}

If (CondRefOf (UPRD))
{
FUNB = One
}
}

Return (OPTS) /* \_SB_.PC00.RP26._DSM.OPTS */
}
Case (0x06)
{
If ((Arg1 >= 0x02))
{
LTRV [Zero] = ((LMSL >> 0x0A) & 0x07)
LTRV [One] = (LMSL & 0x03FF)
LTRV [0x02] = ((LNSL >> 0x0A) & 0x07)
LTRV [0x03] = (LNSL & 0x03FF)
Return (LTRV) /* \_SB_.PC00.RP26.LTRV */
}
}
Case (0x08)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (One)
}
}
}
}
Case (0x09)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (Package (0x05)
{
0xC350,
Ones,
Ones,
0xC350,
Ones
})
}
}
}
}
Case (0x0A)
{
If (CondRefOf (PPBA))
{
Return (PPBA (Arg3))
}
}
Case (0x0B)
{
If (CondRefOf (UPRD))
{
Return (UPRD (Arg3))
}
}

}
}

Return (Buffer (One)
{
0x00 // .
})
}

Device (PXSX)
{
Name (_ADR, Zero) // _ADR: Address
OperationRegion (PCCX, PCI_Config, Zero, 0x10)
Field (PCCX, ByteAcc, NoLock, Preserve)
{
DVID, 32,
Offset (0x09),
PIXX, 8,
SCCX, 8,
BCCX, 8
}

Method (PAHC, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x06))
{
If ((PIXX == One))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PNVM, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x08))
{
If ((PIXX == 0x02))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PRES, 0, Serialized)
{
If ((DVID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (ISGX, 0, Serialized)
{
If ((BCCX == 0x03))
{
Return (One)
}

Return (Zero)
}

If (CondRefOf (\STD3))
{
If ((STD3 != Zero))
{
Method (_DSD, 0, NotSerialized) // _DSD: Device-Specific Data
{
If ((PAHC () || PNVM ()))
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
One
}
}
})
}
Else
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
Zero
}
}
})
}
}
}
}

Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake
{
Return (GPRW (0x69, 0x03))
}
}

Method (_PS0, 0, Serialized) // _PS0: Power State 0
{
If (CondRefOf (PPS0))
{
PPS0 ()
}
}

Method (_PS3, 0, Serialized) // _PS3: Power State 3
{
If (CondRefOf (PPS3))
{
PPS3 ()
}
}

Method (HPME, 0, Serialized)
{
If (((VDID != 0xFFFFFFFF) && (PMSX == One)))
{
Notify (PXSX, 0x02) // Device Wake
PMSX = One
PSPX = One
}
}

Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table
{
If (CondRefOf (PICM))
{
If (PICM)
{
Return (AR05 ())
}
}

Return (PD05 ())
}
}

Device (RP27)
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
If ((RPAR != Zero))
{
Return (RPAR) /* \RPAR */
}
Else
{
Return (0x001A0002)
}
}

Name (SLOT, 0x1B)
Name (LTEN, Zero)
Name (LMSL, Zero)
Name (LNSL, Zero)
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
LTEN = LTRR /* \LTRR */
LMSL = PMLR /* \PMLR */
LNSL = PNLR /* \PNLR */
If ((HBSL & 0x40))
{
HBCS = One
}

If ((CondRefOf (VMR4) && CondRefOf (VMDE)))
{
If (((VMDE == One) && ((VMR4 & 0x04) != Zero)))
{
PRMV = One
}
}

If (PRES ())
{
If (CondRefOf (PINI))
{
PINI ()
}
}

If (CondRefOf (\_SB.PC00.RP27))
{
If ((VDID != 0xFFFFFFFF))
{
If (CondRefOf (\STD3))
{
If (CondRefOf (\_SB.PC00.RP27.PRMV))
{
If ((PRMV == One))
{
RD3C = STD3 /* \STD3 */
}
}

If ((^PXSX.PNVM () || ^PXSX.PAHC ()))
{
RD3C = STD3 /* \STD3 */
}
}
}
}
}

SIPV = GSIP ()
Name (PRTP, 0x02)
OperationRegion (PXCS, SystemMemory, PC2M (_ADR ()), 0x0480)
Field (PXCS, AnyAcc, NoLock, Preserve)
{
VDID, 32,
Offset (0x50),
L0SE, 1,
, 3,
LDIS, 1,
Offset (0x51),
Offset (0x52),
, 13,
LASX, 1,
Offset (0x5A),
ABPX, 1,
, 2,
PDCX, 1,
, 2,
PDSX, 1,
Offset (0x5B),
Offset (0x60),
Offset (0x62),
PSPX, 1,
Offset (0xA4),
D3HT, 2,
Offset (0xD8),
, 30,
HPEX, 1,
PMEX, 1,
Offset (0xE0),
SCB0, 1,
, 6,
NCB7, 1,
Offset (0xE2),
, 2,
L23E, 1,
L23R, 1,
Offset (0x328),
, 19,
LNKS, 4
}

Field (PXCS, AnyAcc, NoLock, WriteAsZeros)
{
Offset (0xDC),
, 30,
HPSX, 1,
PMSX, 1
}

Method (L23D, 0, Serialized)
{
If ((SIPV < 0x10))
{
If ((NCB7 != One))
{
Return (Zero)
}
}
ElseIf ((SCB0 != One))
{
Return (Zero)
}

L23R = One
Local0 = Zero
While (L23R)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = Zero
}
Else
{
SCB0 = Zero
}

Local0 = Zero
While ((LASX == Zero))
{
If ((Local0 > 0x08))
{
Break
}

Sleep (0x10)
Local0++
}
}

Method (DL23, 0, Serialized)
{
L23E = One
Sleep (0x10)
Local0 = Zero
While (L23E)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = One
}
Else
{
SCB0 = One
}
}

Name (LTRV, Package (0x04)
{
Zero,
Zero,
Zero,
Zero
})
Name (HBCS, Zero)
Name (PRMV, Zero)
Name (RD3C, 0x02)
Method (PRES, 0, NotSerialized)
{
If ((VDID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If ((Arg0 == ToUUID ("e5c937d0-3553-4d7a-9117-ea4d19c3434d") /* Device Labeling Interface */))
{
Switch (ToInteger (Arg2))
{
Case (Zero)
{
Name (OPTS, Buffer (0x02)
{
0x00, 0x00 // ..
})
CreateBitField (OPTS, Zero, FUN0)
CreateBitField (OPTS, 0x06, FUN6)
CreateBitField (OPTS, 0x08, FUN8)
CreateBitField (OPTS, 0x09, FUN9)
CreateBitField (OPTS, 0x0A, FUNA)
CreateBitField (OPTS, 0x0B, FUNB)
If ((Arg1 >= 0x02))
{
FUN0 = One
If ((LTEN != Zero))
{
FUN6 = One
}

If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
FUN8 = One
FUN9 = One
}
}
}
}

If ((Arg1 >= 0x04))
{
If (CondRefOf (PPBA))
{
FUNA = One
}

If (CondRefOf (UPRD))
{
FUNB = One
}
}

Return (OPTS) /* \_SB_.PC00.RP27._DSM.OPTS */
}
Case (0x06)
{
If ((Arg1 >= 0x02))
{
LTRV [Zero] = ((LMSL >> 0x0A) & 0x07)
LTRV [One] = (LMSL & 0x03FF)
LTRV [0x02] = ((LNSL >> 0x0A) & 0x07)
LTRV [0x03] = (LNSL & 0x03FF)
Return (LTRV) /* \_SB_.PC00.RP27.LTRV */
}
}
Case (0x08)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (One)
}
}
}
}
Case (0x09)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (Package (0x05)
{
0xC350,
Ones,
Ones,
0xC350,
Ones
})
}
}
}
}
Case (0x0A)
{
If (CondRefOf (PPBA))
{
Return (PPBA (Arg3))
}
}
Case (0x0B)
{
If (CondRefOf (UPRD))
{
Return (UPRD (Arg3))
}
}

}
}

Return (Buffer (One)
{
0x00 // .
})
}

Device (PXSX)
{
Name (_ADR, Zero) // _ADR: Address
OperationRegion (PCCX, PCI_Config, Zero, 0x10)
Field (PCCX, ByteAcc, NoLock, Preserve)
{
DVID, 32,
Offset (0x09),
PIXX, 8,
SCCX, 8,
BCCX, 8
}

Method (PAHC, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x06))
{
If ((PIXX == One))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PNVM, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x08))
{
If ((PIXX == 0x02))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PRES, 0, Serialized)
{
If ((DVID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (ISGX, 0, Serialized)
{
If ((BCCX == 0x03))
{
Return (One)
}

Return (Zero)
}

If (CondRefOf (\STD3))
{
If ((STD3 != Zero))
{
Method (_DSD, 0, NotSerialized) // _DSD: Device-Specific Data
{
If ((PAHC () || PNVM ()))
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
One
}
}
})
}
Else
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
Zero
}
}
})
}
}
}
}

Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake
{
Return (GPRW (0x69, 0x03))
}
}

Method (_PS0, 0, Serialized) // _PS0: Power State 0
{
If (CondRefOf (PPS0))
{
PPS0 ()
}
}

Method (_PS3, 0, Serialized) // _PS3: Power State 3
{
If (CondRefOf (PPS3))
{
PPS3 ()
}
}

Method (HPME, 0, Serialized)
{
If (((VDID != 0xFFFFFFFF) && (PMSX == One)))
{
Notify (PXSX, 0x02) // Device Wake
PMSX = One
PSPX = One
}
}

Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table
{
If (CondRefOf (PICM))
{
If (PICM)
{
Return (AR06 ())
}
}

Return (PD06 ())
}
}

Device (RP28)
{
Method (_ADR, 0, NotSerialized) // _ADR: Address
{
If ((RPAS != Zero))
{
Return (RPAS) /* \RPAS */
}
Else
{
Return (0x001A0003)
}
}

Name (SLOT, 0x1C)
Name (LTEN, Zero)
Name (LMSL, Zero)
Name (LNSL, Zero)
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
LTEN = LTRS /* \LTRS */
LMSL = PMLS /* \PMLS */
LNSL = PNLS /* \PNLS */
If ((HBSL & 0x40))
{
HBCS = One
}

If ((CondRefOf (VMR4) && CondRefOf (VMDE)))
{
If (((VMDE == One) && ((VMR4 & 0x08) != Zero)))
{
PRMV = One
}
}

If (PRES ())
{
If (CondRefOf (PINI))
{
PINI ()
}
}

If (CondRefOf (\_SB.PC00.RP28))
{
If ((VDID != 0xFFFFFFFF))
{
If (CondRefOf (\STD3))
{
If (CondRefOf (\_SB.PC00.RP28.PRMV))
{
If ((PRMV == One))
{
RD3C = STD3 /* \STD3 */
}
}

If ((^PXSX.PNVM () || ^PXSX.PAHC ()))
{
RD3C = STD3 /* \STD3 */
}
}
}
}
}

SIPV = GSIP ()
Name (PRTP, 0x02)
OperationRegion (PXCS, SystemMemory, PC2M (_ADR ()), 0x0480)
Field (PXCS, AnyAcc, NoLock, Preserve)
{
VDID, 32,
Offset (0x50),
L0SE, 1,
, 3,
LDIS, 1,
Offset (0x51),
Offset (0x52),
, 13,
LASX, 1,
Offset (0x5A),
ABPX, 1,
, 2,
PDCX, 1,
, 2,
PDSX, 1,
Offset (0x5B),
Offset (0x60),
Offset (0x62),
PSPX, 1,
Offset (0xA4),
D3HT, 2,
Offset (0xD8),
, 30,
HPEX, 1,
PMEX, 1,
Offset (0xE0),
SCB0, 1,
, 6,
NCB7, 1,
Offset (0xE2),
, 2,
L23E, 1,
L23R, 1,
Offset (0x328),
, 19,
LNKS, 4
}

Field (PXCS, AnyAcc, NoLock, WriteAsZeros)
{
Offset (0xDC),
, 30,
HPSX, 1,
PMSX, 1
}

Method (L23D, 0, Serialized)
{
If ((SIPV < 0x10))
{
If ((NCB7 != One))
{
Return (Zero)
}
}
ElseIf ((SCB0 != One))
{
Return (Zero)
}

L23R = One
Local0 = Zero
While (L23R)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = Zero
}
Else
{
SCB0 = Zero
}

Local0 = Zero
While ((LASX == Zero))
{
If ((Local0 > 0x08))
{
Break
}

Sleep (0x10)
Local0++
}
}

Method (DL23, 0, Serialized)
{
L23E = One
Sleep (0x10)
Local0 = Zero
While (L23E)
{
If ((Local0 > 0x04))
{
Break
}

Sleep (0x10)
Local0++
}

If ((SIPV < 0x10))
{
NCB7 = One
}
Else
{
SCB0 = One
}
}

Name (LTRV, Package (0x04)
{
Zero,
Zero,
Zero,
Zero
})
Name (HBCS, Zero)
Name (PRMV, Zero)
Name (RD3C, 0x02)
Method (PRES, 0, NotSerialized)
{
If ((VDID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If ((Arg0 == ToUUID ("e5c937d0-3553-4d7a-9117-ea4d19c3434d") /* Device Labeling Interface */))
{
Switch (ToInteger (Arg2))
{
Case (Zero)
{
Name (OPTS, Buffer (0x02)
{
0x00, 0x00 // ..
})
CreateBitField (OPTS, Zero, FUN0)
CreateBitField (OPTS, 0x06, FUN6)
CreateBitField (OPTS, 0x08, FUN8)
CreateBitField (OPTS, 0x09, FUN9)
CreateBitField (OPTS, 0x0A, FUNA)
CreateBitField (OPTS, 0x0B, FUNB)
If ((Arg1 >= 0x02))
{
FUN0 = One
If ((LTEN != Zero))
{
FUN6 = One
}

If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
FUN8 = One
FUN9 = One
}
}
}
}

If ((Arg1 >= 0x04))
{
If (CondRefOf (PPBA))
{
FUNA = One
}

If (CondRefOf (UPRD))
{
FUNB = One
}
}

Return (OPTS) /* \_SB_.PC00.RP28._DSM.OPTS */
}
Case (0x06)
{
If ((Arg1 >= 0x02))
{
LTRV [Zero] = ((LMSL >> 0x0A) & 0x07)
LTRV [One] = (LMSL & 0x03FF)
LTRV [0x02] = ((LNSL >> 0x0A) & 0x07)
LTRV [0x03] = (LNSL & 0x03FF)
Return (LTRV) /* \_SB_.PC00.RP28.LTRV */
}
}
Case (0x08)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (One)
}
}
}
}
Case (0x09)
{
If (CondRefOf (ECR1))
{
If ((ECR1 == One))
{
If ((Arg1 >= 0x03))
{
Return (Package (0x05)
{
0xC350,
Ones,
Ones,
0xC350,
Ones
})
}
}
}
}
Case (0x0A)
{
If (CondRefOf (PPBA))
{
Return (PPBA (Arg3))
}
}
Case (0x0B)
{
If (CondRefOf (UPRD))
{
Return (UPRD (Arg3))
}
}

}
}

Return (Buffer (One)
{
0x00 // .
})
}

Device (PXSX)
{
Name (_ADR, Zero) // _ADR: Address
OperationRegion (PCCX, PCI_Config, Zero, 0x10)
Field (PCCX, ByteAcc, NoLock, Preserve)
{
DVID, 32,
Offset (0x09),
PIXX, 8,
SCCX, 8,
BCCX, 8
}

Method (PAHC, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x06))
{
If ((PIXX == One))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PNVM, 0, Serialized)
{
If ((BCCX == One))
{
If ((SCCX == 0x08))
{
If ((PIXX == 0x02))
{
Return (One)
}
}
}

Return (Zero)
}

Method (PRES, 0, Serialized)
{
If ((DVID == 0xFFFFFFFF))
{
Return (Zero)
}
Else
{
Return (One)
}
}

Method (ISGX, 0, Serialized)
{
If ((BCCX == 0x03))
{
Return (One)
}

Return (Zero)
}

If (CondRefOf (\STD3))
{
If ((STD3 != Zero))
{
Method (_DSD, 0, NotSerialized) // _DSD: Device-Specific Data
{
If ((PAHC () || PNVM ()))
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
One
}
}
})
}
Else
{
Return (Package (0x02)
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
Zero
}
}
})
}
}
}
}

Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake
{
Return (GPRW (0x69, 0x03))
}
}

Method (_PS0, 0, Serialized) // _PS0: Power State 0
{
If (CondRefOf (PPS0))
{
PPS0 ()
}
}

Method (_PS3, 0, Serialized) // _PS3: Power State 3
{
If (CondRefOf (PPS3))
{
PPS3 ()
}
}

Method (HPME, 0, Serialized)
{
If (((VDID != 0xFFFFFFFF) && (PMSX == One)))
{
Notify (PXSX, 0x02) // Device Wake
PMSX = One
PSPX = One
}
}

Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table
{
If (CondRefOf (PICM))
{
If (PICM)
{
Return (AR07 ())
}
}

Return (PD07 ())
}
}
}
}

Scope (_SB)
{
Device (ICLK)
{
Name (_HID, EisaId ("PNP0C02") /* PNP Motherboard Resources */) // _HID: Hardware ID
Name (_UID, "ISCLK") // _UID: Unique ID
OperationRegion (CKOR, SystemMemory, (SBRG + ((ICKP << 0x10) + 0x8000)), 0x40)
Field (CKOR, AnyAcc, Lock, Preserve)
{
CLK0, 8,
Offset (0x0C),
CLK1, 8,
Offset (0x18),
CLK2, 8,
Offset (0x24),
CLK3, 8,
Offset (0x30),
CLK4, 8,
Offset (0x3C),
CLK5, 8
}

Method (NCLK, 0, NotSerialized)
{
If ((PCHS == PCHP))
{
Return (0x06)
}
ElseIf ((PCHS == PCHN))
{
Return (0x04)
}
Else
{
Return (Zero)
}
}

Method (CLKC, 2, Serialized)
{
If (((Arg0 < NCLK ()) && (PCHS == PCHP)))
{
Switch (ToInteger (Arg0))
{
Case (Zero)
{
Local0 = CLK0 /* \_SB_.ICLK.CLK0 */
CLK0 = ((Local0 & 0xFFFFFFFFFFFFFFFD) | (Arg1 << One))
}
Case (One)
{
Local0 = CLK1 /* \_SB_.ICLK.CLK1 */
CLK1 = ((Local0 & 0xFFFFFFFFFFFFFFFD) | (Arg1 << One))
}
Case (0x02)
{
Local0 = CLK2 /* \_SB_.ICLK.CLK2 */
CLK2 = ((Local0 & 0xFFFFFFFFFFFFFFFD) | (Arg1 << One))
}
Case (0x03)
{
Local0 = CLK3 /* \_SB_.ICLK.CLK3 */
CLK3 = ((Local0 & 0xFFFFFFFFFFFFFFFD) | (Arg1 << One))
}
Case (0x04)
{
Local0 = CLK4 /* \_SB_.ICLK.CLK4 */
CLK4 = ((Local0 & 0xFFFFFFFFFFFFFFFD) | (Arg1 << One))
}
Case (0x05)
{
Local0 = CLK5 /* \_SB_.ICLK.CLK5 */
CLK5 = ((Local0 & 0xFFFFFFFFFFFFFFFD) | (Arg1 << One))
}

}
}
ElseIf (((Arg0 < NCLK ()) && (PCHS == PCHN)))
{
Switch (ToInteger (Arg0))
{
Case (Zero)
{
Local0 = CLK0 /* \_SB_.ICLK.CLK0 */
CLK0 = ((Local0 & 0xFFFFFFFFFFFFFFFD) | (Arg1 << One))
}
Case (One)
{
Local0 = CLK1 /* \_SB_.ICLK.CLK1 */
CLK1 = ((Local0 & 0xFFFFFFFFFFFFFFFD) | (Arg1 << One))
}
Case (0x02)
{
Local0 = CLK2 /* \_SB_.ICLK.CLK2 */
CLK2 = ((Local0 & 0xFFFFFFFFFFFFFFFD) | (Arg1 << One))
}
Case (0x03)
{
Local0 = CLK3 /* \_SB_.ICLK.CLK3 */
CLK3 = ((Local0 & 0xFFFFFFFFFFFFFFFD) | (Arg1 << One))
}

}
}
}

Method (CLKF, 2, Serialized)
{
If (((Arg0 < NCLK ()) && (PCHS == PCHP)))
{
Switch (ToInteger (Arg0))
{
Case (Zero)
{
Local0 = CLK0 /* \_SB_.ICLK.CLK0 */
CLK0 = ((Local0 & 0xFFFFFFFFFFFFFFFE) | Arg1)
}
Case (One)
{
Local0 = CLK1 /* \_SB_.ICLK.CLK1 */
CLK1 = ((Local0 & 0xFFFFFFFFFFFFFFFE) | Arg1)
}
Case (0x02)
{
Local0 = CLK2 /* \_SB_.ICLK.CLK2 */
CLK2 = ((Local0 & 0xFFFFFFFFFFFFFFFE) | Arg1)
}
Case (0x03)
{
Local0 = CLK3 /* \_SB_.ICLK.CLK3 */
CLK3 = ((Local0 & 0xFFFFFFFFFFFFFFFE) | Arg1)
}
Case (0x04)
{
Local0 = CLK4 /* \_SB_.ICLK.CLK4 */
CLK4 = ((Local0 & 0xFFFFFFFFFFFFFFFE) | Arg1)
}
Case (0x05)
{
Local0 = CLK5 /* \_SB_.ICLK.CLK5 */
CLK5 = ((Local0 & 0xFFFFFFFFFFFFFFFE) | Arg1)
}

}
}
ElseIf (((Arg0 < NCLK ()) && (PCHS == PCHN)))
{
Switch (ToInteger (Arg0))
{
Case (Zero)
{
Local0 = CLK0 /* \_SB_.ICLK.CLK0 */
CLK0 = ((Local0 & 0xFFFFFFFFFFFFFFFE) | Arg1)
}
Case (One)
{
Local0 = CLK1 /* \_SB_.ICLK.CLK1 */
CLK1 = ((Local0 & 0xFFFFFFFFFFFFFFFE) | Arg1)
}
Case (0x02)
{
Local0 = CLK2 /* \_SB_.ICLK.CLK2 */
CLK2 = ((Local0 & 0xFFFFFFFFFFFFFFFE) | Arg1)
}
Case (0x03)
{
Local0 = CLK3 /* \_SB_.ICLK.CLK3 */
CLK3 = ((Local0 & 0xFFFFFFFFFFFFFFFE) | Arg1)
}

}
}
}

Method (_STA, 0, NotSerialized) // _STA: Status
{
Return (0x03)
}
}
}

Scope (\)
{
Method (MCUI, 2, Serialized)
{
Name (PRPI, Zero)
Local0 = (One << Arg0)
Local1 = (Arg1 << Arg0)
PRPI = CTRP (Arg0)
If ((PRPI < 0x1C))
{
Local2 = (One << PRPI) /* \MCUI.PRPI */
Local3 = (Arg1 << PRPI) /* \MCUI.PRPI */
}
Else
{
Local2 = (One << PRPI) /* \MCUI.PRPI */
Local3 = (Arg1 << PRPI) /* \MCUI.PRPI */
Local2 <<= 0x18
Local3 <<= 0x18
}

ADBG ("Calling IPCS method with command V_PMC_PWRM_IPC_SRC_CLK_PORT_MAPPING_CMD")
ADBG (Concatenate ("Local0 =", Local0))
ADBG (Concatenate ("Local1 =", Local1))
ADBG (Concatenate ("Local2 =", Local2))
ADBG (Concatenate ("Local3 =", Local3))
IPCS (0xAC, Zero, 0x10, Local0, Local1, Local2, Local3)
}

Method (SPCO, 2, Serialized)
{
ADBG ("Calling SPCO method to configure PCIe ClkReq Override")
Name (CLKU, Zero)
If ((IPCC != Zero))
{
ADBG ("Calling TMVA method to restore IPC1 Command Timeout default Value 10ms")
TMVA (0x0A)
MCUI (Arg0, Arg1)
}
Else
{
CLKU = CTRP (Arg0)
If ((Arg1 == One))
{
If ((Arg0 > 0x06))
{
Local1 = (Arg0 + One)
Local1 -= 0x07
PCRO (0xAD, 0x8084, (One << Local1))
}
Else
{
Local1 = (Arg0 + 0x02)
PCRO (0xAD, 0x8080, (One << Local1))
}
}
ElseIf ((Arg0 > 0x06))
{
Local1 = (Arg0 + One)
Local1 -= 0x07
PCRA (0xAD, 0x8084, ~(One << Local1))
}
Else
{
Local1 = (Arg0 + 0x02)
PCRA (0xAD, 0x8080, ~(One << Local1))
}
}
}

Method (SPCX, 3, Serialized)
{
ADBG ("Calling SPCX method to configure PCIe ClkReq Override")
If ((IPCC != Zero))
{
ADBG ("Calling TMVA method to override IPC1 Command Timeout Value")
TMVA (Arg2)
MCUI (Arg0, Arg1)
}
Else
{
SPCO (Arg0, Arg1)
}
}

Method (HBCM, 2, Serialized)
{
ADBG ("mask/unmask Hybrid Partner CLKREQ")
Name (HPRI, Zero)
HPRI = Arg0
If ((HPRI < 0x1C))
{
Local0 = (One << HPRI) /* \HBCM.HPRI */
Local1 = (Arg1 << HPRI) /* \HBCM.HPRI */
}
Else
{
Local0 = Zero
Local1 = Zero
}

ADBG ("Calling IPCS method for Hybrid Partner with command V_PMC_PWRM_IPC_SRC_CLK_PORT_MAPPING_CMD")
ADBG (Concatenate ("Port number of Hybrid Partner =", HPRI))
ADBG (Concatenate ("Local0 of Hybrid Partner =", Local0))
ADBG (Concatenate ("Local1 of Hybrid Partner =", Local1))
IPCS (0xAC, Zero, 0x10, Zero, Zero, Local0, Local1)
}

Method (CTRP, 1, Serialized)
{
Switch (ToInteger (Arg0))
{
Case (Zero)
{
Return (CR00) /* \CR00 */
}
Case (One)
{
Return (CR01) /* \CR01 */
}
Case (0x02)
{
Return (CR02) /* \CR02 */
}
Case (0x03)
{
Return (CR03) /* \CR03 */
}
Case (0x04)
{
Return (CR04) /* \CR04 */
}
Case (0x05)
{
Return (CR05) /* \CR05 */
}
Case (0x06)
{
Return (CR06) /* \CR06 */
}
Case (0x07)
{
Return (CR07) /* \CR07 */
}
Case (0x08)
{
Return (CR08) /* \CR08 */
}
Case (0x09)
{
Return (CR09) /* \CR09 */
}
Case (0x0A)
{
Return (CR10) /* \CR10 */
}
Case (0x0B)
{
Return (CR11) /* \CR11 */
}
Case (0x0C)
{
Return (CR12) /* \CR12 */
}
Case (0x0D)
{
Return (CR13) /* \CR13 */
}
Case (0x0E)
{
Return (CR14) /* \CR14 */
}
Case (0x0F)
{
Return (CR15) /* \CR15 */
}
Case (0x10)
{
Return (CR16) /* \CR16 */
}
Case (0x11)
{
Return (CR17) /* \CR17 */
}
Default
{
Return (0xFF)
}

}
}

Method (CTRQ, 1, Serialized)
{
Switch (ToInteger (Arg0))
{
Case (Zero)
{
Return (CQ00) /* \CQ00 */
}
Case (One)
{
Return (CQ01) /* \CQ01 */
}
Case (0x02)
{
Return (CQ02) /* \CQ02 */
}
Case (0x03)
{
Return (CQ03) /* \CQ03 */
}
Case (0x04)
{
Return (CQ04) /* \CQ04 */
}
Case (0x05)
{
Return (CQ05) /* \CQ05 */
}
Case (0x06)
{
Return (CQ06) /* \CQ06 */
}
Case (0x07)
{
Return (CQ07) /* \CQ07 */
}
Case (0x08)
{
Return (CQ08) /* \CQ08 */
}
Case (0x09)
{
Return (CQ09) /* \CQ09 */
}
Case (0x0A)
{
Return (CQ10) /* \CQ10 */
}
Case (0x0B)
{
Return (CQ11) /* \CQ11 */
}
Case (0x0C)
{
Return (CQ12) /* \CQ12 */
}
Case (0x0D)
{
Return (CQ13) /* \CQ13 */
}
Case (0x0E)
{
Return (CQ14) /* \CQ14 */
}
Case (0x0F)
{
Return (CQ15) /* \CQ15 */
}
Case (0x10)
{
Return (CQ16) /* \CQ16 */
}
Case (0x11)
{
Return (CQ17) /* \CQ17 */
}
Default
{
Return (0xFF)
}

}
}
}

Scope (_SB.PC00)
{
Device (SAT0)
{
Name (_ADR, 0x00170000) // _ADR: Address
Method (_PS0, 0, Serialized) // _PS0: Power State 0
{
If (((PCHS == PCHP) || (PCHS == PCHN)))
{
If (!SCFD)
{
CSD0 (0x14)
}
}

ISAT = Zero
}

Method (_PS3, 0, Serialized) // _PS3: Power State 3
{
ISAT = One
If (((PCHS == PCHP) || (PCHS == PCHN)))
{
CSD3 (0x14)
}
}

If (CondRefOf (\STD3))
{
If ((STD3 != Zero))
{
Name (_DSD, Package (0x02) // _DSD: Device-Specific Data
{
ToUUID ("5025030f-842f-4ab4-a561-99a5189762d0") /* Unknown UUID */,
Package (0x01)
{
Package (0x02)
{
"StorageD3Enable",
One
}
}
})
}
}

Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If (PCIC (Arg0))
{
Return (PCID (Arg0, Arg1, Arg2, Arg3))
}

If ((CondRefOf (SATC) && CondRefOf (SATD)))
{
If (SATC (Arg0))
{
Return (SATD (Arg0, Arg1, Arg2, Arg3))
}
}

Return (Buffer (One)
{
0x00 // .
})
}

Method (_S0W, 0, NotSerialized) // _S0W: S0 Device Wake State
{
Return (0x03)
}

Device (PRT0)
{
Name (_ADR, 0xFFFF) // _ADR: Address
Method (PRES, 0, NotSerialized)
{
If ((SPPR & One))
{
Return (One)
}
Else
{
Return (Zero)
}
}
}

Device (PRT1)
{
Name (_ADR, 0x0001FFFF) // _ADR: Address
Method (PRES, 0, NotSerialized)
{
If ((SPPR & 0x02))
{
Return (One)
}
Else
{
Return (Zero)
}
}
}

Device (PRT2)
{
Name (_ADR, 0x0002FFFF) // _ADR: Address
Method (PRES, 0, NotSerialized)
{
If ((SPPR & 0x04))
{
Return (One)
}
Else
{
Return (Zero)
}
}
}

Device (PRT3)
{
Name (_ADR, 0x0003FFFF) // _ADR: Address
Method (PRES, 0, NotSerialized)
{
If ((SPPR & 0x08))
{
Return (One)
}
Else
{
Return (Zero)
}
}
}

Device (PRT4)
{
Name (_ADR, 0x0004FFFF) // _ADR: Address
Method (PRES, 0, NotSerialized)
{
If ((SPPR & 0x10))
{
Return (One)
}
Else
{
Return (Zero)
}
}
}

Device (PRT5)
{
Name (_ADR, 0x0005FFFF) // _ADR: Address
Method (PRES, 0, NotSerialized)
{
If ((SPPR & 0x20))
{
Return (One)
}
Else
{
Return (Zero)
}
}
}

Device (PRT6)
{
Name (_ADR, 0x0006FFFF) // _ADR: Address
Method (PRES, 0, NotSerialized)
{
If ((SPPR & 0x40))
{
Return (One)
}
Else
{
Return (Zero)
}
}
}

Device (PRT7)
{
Name (_ADR, 0x0007FFFF) // _ADR: Address
Method (PRES, 0, NotSerialized)
{
If ((SPPR & 0x80))
{
Return (One)
}
Else
{
Return (Zero)
}
}
}
}
}

Scope (_SB.PC00)
{
Method (TINT, 1, Serialized)
{
Name (TINR, ResourceTemplate ()
{
GpioInt (Level, ActiveLow, ExclusiveAndWake, PullUp, 0x0000,
"\\_SB.GPI0", 0x00, ResourceConsumer, ,
)
{ // Pin list
0x0000
}
})
CreateWordField (TINR, 0x17, INT1)
INT1 = GNUM (Arg0)
Return (TINR) /* \_SB_.PC00.TINT.TINR */
}

Device (THC0)
{
Name (_ADR, 0x00100006) // _ADR: Address
Name (RSTL, Zero)
OperationRegion (THCR, PCI_Config, Zero, 0x0100)
Field (THCR, ByteAcc, NoLock, Preserve)
{
VDID, 32
}

If ((VDID != 0xFFFFFFFF))
{
Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If (PCIC (Arg0))
{
Return (PCID (Arg0, Arg1, Arg2, Arg3))
}

If ((TMD0 == One))
{
If ((Arg0 == ToUUID ("6e2ac436-0fcf-41af-a265-b32a220dcfab") /* Unknown UUID */))
{
Switch (ToInteger (Arg2))
{
Case (Zero)
{
Switch (ToInteger (Arg1))
{
Case (0x02)
{
Return (Buffer (One)
{
0x7F // .
})
}
Default
{
Return (Buffer (One)
{
0x00 // .
})
}

}
}
Case (One)
{
ADBG ("THC THC_INPUT_REPORT_HEADER_ADDRESS")
Return (ToInteger (T040))
}
Case (0x02)
{
ADBG ("THC THC_INPUT_REPORT_BODY_ADDRESS")
Return (ToInteger (T050))
}
Case (0x03)
{
ADBG ("THC THC_OUTPUT_REPORT_ADDRESS")
Return (ToInteger (T060))
}
Case (0x04)
{
ADBG ("THC THC_READ_OPCODE")
Name (BUF4, Buffer (One){})
Local0 = ToBuffer (T070)
BUF4 [Zero] = DerefOf (Local0 [Zero])
Return (BUF4) /* \_SB_.PC00.THC0._DSM.BUF4 */
}
Case (0x05)
{
ADBG ("THC THC_WRITE_OPCODE")
Name (BUF5, Buffer (One){})
Local1 = ToBuffer (T080)
BUF5 [Zero] = DerefOf (Local1 [Zero])
Return (BUF5) /* \_SB_.PC00.THC0._DSM.BUF5 */
}
Case (0x06)
{
ADBG ("THC THC_FLAGS")
Return (ToInteger (T090))
}
Default
{
Return (Buffer (One)
{
0x00 // .
})
}

}

Return (Buffer (One)
{
0x00 // .
})
}

If ((Arg0 == ToUUID ("300d35b7-ac20-413e-8e9c-92e4dafd0afe") /* Unknown UUID */))
{
Switch (ToInteger (Arg2))
{
Case (Zero)
{
Return (Buffer (One)
{
0x07 // .
})
}
Case (One)
{
ADBG ("THC THC_CONNECTION_SPEED")
Return (ToInteger (T030))
}
Case (0x02)
{
ADBG ("THC THC_LIMIT_PACKET_SIZE")
Return (ToInteger (T0C0))
}
Case (0x03)
{
ADBG ("THC THC_PERFORMANCE_LIMITATION")
Return (ToInteger (T0D0))
}
Default
{
Return (Buffer (One)
{
0x00 // .
})
}

}
}
}

If ((Arg0 == ToUUID ("84005682-5b71-41a4-8d66-8130f787a138") /* Unknown UUID */))
{
Switch (ToInteger (Arg2))
{
Case (Zero)
{
Return (Buffer (One)
{
0x03 // .
})
}
Case (One)
{
ADBG ("THC THC_ACTIVE_LTR")
Return (ToInteger (T0A0))
}
Case (0x02)
{
ADBG ("THC THC_IDLE_LTR")
Return (ToInteger (T0B0))
}
Default
{
Return (Buffer (One)
{
0x00 // .
})
}

}
}

Return (Buffer (Zero){})
}

If ((TIN0 != Zero))
{
Name (_S0W, 0x03) // _S0W: S0 Device Wake State
}

If ((TIN0 != Zero))
{
Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings
{
Return (TINT (TIN0))
}
}

If ((TMD0 == One))
{
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
ADBG ("THC _INI")
SHPO (T010, One)
SPMV (T010, Zero)
SPC0 (T010, (0x42000200 | (~(T020 & One) & One
)))
If (CondRefOf (^CINI))
{
CINI (T010, T0E0)
}
}

Method (_RST, 0, Serialized) // _RST: Device Reset
{
ADBG ("THC _RST")
While ((RSTL == One))
{
Sleep (0x0A)
}

RSTL = One
SGOV (T010, (T020 & One))
Sleep (T0E0)
SGOV (T010, (~(T020 & One) & One))
RSTL = Zero
}
}
}
}

Device (THC1)
{
Name (_ADR, 0x00100007) // _ADR: Address
Name (RSTL, Zero)
OperationRegion (THCR, PCI_Config, Zero, 0x0100)
Field (THCR, ByteAcc, NoLock, Preserve)
{
VDID, 32
}

If ((VDID != 0xFFFFFFFF))
{
Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If (PCIC (Arg0))
{
Return (PCID (Arg0, Arg1, Arg2, Arg3))
}

If ((TMD1 == One))
{
If ((Arg0 == ToUUID ("6e2ac436-0fcf-41af-a265-b32a220dcfab") /* Unknown UUID */))
{
Switch (ToInteger (Arg2))
{
Case (Zero)
{
Switch (ToInteger (Arg1))
{
Case (0x02)
{
Return (Buffer (One)
{
0x7F // .
})
}
Default
{
Return (Buffer (One)
{
0x00 // .
})
}

}
}
Case (One)
{
ADBG ("THC THC_INPUT_REPORT_HEADER_ADDRESS")
Return (ToInteger (T041))
}
Case (0x02)
{
ADBG ("THC THC_INPUT_REPORT_BODY_ADDRESS")
Return (ToInteger (T051))
}
Case (0x03)
{
ADBG ("THC THC_OUTPUT_REPORT_ADDRESS")
Return (ToInteger (T061))
}
Case (0x04)
{
ADBG ("THC THC_READ_OPCODE")
Name (BUF4, Buffer (One){})
Local0 = ToBuffer (T071)
BUF4 [Zero] = DerefOf (Local0 [Zero])
Return (BUF4) /* \_SB_.PC00.THC1._DSM.BUF4 */
}
Case (0x05)
{
ADBG ("THC THC_WRITE_OPCODE")
Name (BUF5, Buffer (One){})
Local1 = ToBuffer (T081)
BUF5 [Zero] = DerefOf (Local1 [Zero])
Return (BUF5) /* \_SB_.PC00.THC1._DSM.BUF5 */
}
Case (0x06)
{
ADBG ("THC THC_FLAGS")
Return (ToInteger (T091))
}
Default
{
Return (Buffer (One)
{
0x00 // .
})
}

}

Return (Buffer (One)
{
0x00 // .
})
}

If ((Arg0 == ToUUID ("300d35b7-ac20-413e-8e9c-92e4dafd0afe") /* Unknown UUID */))
{
Switch (ToInteger (Arg2))
{
Case (Zero)
{
Return (Buffer (One)
{
0x07 // .
})
}
Case (One)
{
ADBG ("THC THC_CONNECTION_SPEED")
Return (ToInteger (T031))
}
Case (0x02)
{
ADBG ("THC THC_LIMIT_PACKET_SIZE")
Return (ToInteger (T0C1))
}
Case (0x03)
{
ADBG ("THC THC_PERFORMANCE_LIMITATION")
Return (ToInteger (T0D1))
}
Default
{
Return (Buffer (One)
{
0x00 // .
})
}

}
}
}

If ((Arg0 == ToUUID ("84005682-5b71-41a4-8d66-8130f787a138") /* Unknown UUID */))
{
Switch (ToInteger (Arg2))
{
Case (Zero)
{
Return (Buffer (One)
{
0x03 // .
})
}
Case (One)
{
ADBG ("THC THC_ACTIVE_LTR")
Return (ToInteger (T0A1))
}
Case (0x02)
{
ADBG ("THC THC_IDLE_LTR")
Return (ToInteger (T0B1))
}
Default
{
Return (Buffer (One)
{
0x00 // .
})
}

}
}

Return (Buffer (Zero){})
}

If ((TIN1 != Zero))
{
Name (_S0W, 0x03) // _S0W: S0 Device Wake State
}

If ((TIN1 != Zero))
{
Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings
{
Return (TINT (TIN1))
}
}

If ((TMD1 == One))
{
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
ADBG ("THC _INI")
SHPO (T011, One)
SPMV (T011, Zero)
SPC0 (T011, (0x42000200 | (~(T021 & One) & One
)))
If (CondRefOf (^CINI))
{
CINI (T011, T0E1)
}
}

Method (_RST, 0, Serialized) // _RST: Device Reset
{
ADBG ("THC _RST")
While ((RSTL == One))
{
Sleep (0x0A)
}

RSTL = One
SGOV (T011, (T021 & One))
Sleep (T0E1)
SGOV (T011, (~(T021 & One) & One))
RSTL = Zero
}
}
}
}
}

Scope (\)
{
Method (PCRR, 2, Serialized)
{
Local1 = (Arg1 & 0xFFFF)
Local2 = ((Arg1 & 0x000F0000) << 0x08)
Local0 = ((Arg0 << 0x10) + Local1)
Local0 = ((Local2 + Local0) + SBRG) /* \SBRG */
OperationRegion (PCR0, SystemMemory, Local0, 0x04)
Field (PCR0, DWordAcc, Lock, Preserve)
{
DAT0, 32
}

Return (DAT0) /* \PCRR.DAT0 */
}

Method (PCRW, 3, Serialized)
{
Local1 = (Arg1 & 0xFFFF)
Local2 = ((Arg1 & 0x000F0000) << 0x08)
Local0 = ((Arg0 << 0x10) + Local1)
Local0 = ((Local2 + Local0) + SBRG) /* \SBRG */
OperationRegion (PCR0, SystemMemory, Local0, 0x04)
Field (PCR0, DWordAcc, Lock, Preserve)
{
DAT0, 32
}

DAT0 = Arg2
}

Method (PCRO, 3, Serialized)
{
Local0 = PCRR (Arg0, Arg1)
Local1 = (Local0 | Arg2)
PCRW (Arg0, Arg1, Local1)
}

Method (PCRA, 3, Serialized)
{
Local0 = PCRR (Arg0, Arg1)
Local1 = (Local0 & Arg2)
PCRW (Arg0, Arg1, Local1)
}

Method (PCAO, 4, Serialized)
{
Local0 = PCRR (Arg0, Arg1)
Local1 = ((Local0 & Arg2) | Arg3)
PCRW (Arg0, Arg1, Local1)
}
}

Scope (_SB.PC00)
{
Device (ISHD)
{
Name (_ADR, 0x00120000) // _ADR: Address
}
}

Scope (_SB.PC00)
{
Device (HECI)
{
Name (_ADR, 0x00160000) // _ADR: Address
Method (_DSM, 4, NotSerialized) // _DSM: Device-Specific Method
{
If (PCIC (Arg0))
{
Return (PCID (Arg0, Arg1, Arg2, Arg3))
}

If (CondRefOf (HIWC))
{
If (HIWC (Arg0))
{
If (CondRefOf (HIDW))
{
Return (HIDW (Arg0, Arg1, Arg2, Arg3))
}
}
}

Return (Buffer (One)
{
0x00 // .
})
}
}

Device (HEC3)
{
Name (_ADR, 0x00160004) // _ADR: Address
Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
If (PCIC (Arg0))
{
Return (PCID (Arg0, Arg1, Arg2, Arg3))
}

Return (Buffer (One)
{
0x00 // .
})
}
}
}

Scope (_SB.PC00)
{
Device (PTHT)
{
Name (_ADR, 0x001F0007) // _ADR: Address
Method (_STA, 0, Serialized) // _STA: Status
{
If ((PTHM == One))
{
Return (0x0F)
}
Else
{
Return (Zero)
}
}

OperationRegion (PTHR, PCI_Config, Zero, 0x20)
Field (PTHR, AnyAcc, NoLock, Preserve)
{
Offset (0x10),
MTBL, 32,
MTBH, 32
}

Method (THEN, 0, Serialized)
{
OperationRegion (RMTB, SystemMemory, ((MTBH << 0x20) + (MTBL & 0xFFF00000)), 0x0100)
Field (RMTB, AnyAcc, NoLock, Preserve)
{
Offset (0xE8),
BTTH, 1
}

If ((BTTH == One))
{
Return (One)
}
Else
{
Return (Zero)
}
}
}
}

Scope (_SB)
{
Device (PTHH)
{
Name (_HID, "INTC1001") // _HID: Hardware ID
Method (_STA, 0, Serialized) // _STA: Status
{
If ((PTHM == 0x02))
{
Return (0x0F)
}
Else
{
Return (Zero)
}
}

Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings
{
Memory32Fixed (ReadWrite,
0xFE100000, // Address Base
0x00100000, // Address Length
)
Memory32Fixed (ReadWrite,
0xFC800000, // Address Base
0x00800000, // Address Length
)
})
OperationRegion (MTBR, SystemMemory, 0xFE100000, 0x0100)
Field (MTBR, AnyAcc, NoLock, Preserve)
{
Offset (0xE8),
BHTH, 1
}

Method (THEN, 0, Serialized)
{
If ((BHTH == One))
{
Return (One)
}
Else
{
Return (Zero)
}
}
}
}

Scope (_SB.PC00.RP08.PXSX)
{
Name (_S0W, 0x03) // _S0W: S0 Device Wake State
}

Scope (_SB.PC00.LPCB)
{
Scope (^GFX0)
{
OperationRegion (GFXF, PCI_Config, Zero, 0x04)
Field (GFXF, AnyAcc, NoLock, Preserve)
{
VIDG, 16,
DIDG, 16
}
}

Scope (\)
{
Name (DDTS, Zero)
}

Device (EC0)
{
Name (_HID, EisaId ("PNP0C09") /* Embedded Controller Device */) // _HID: Hardware ID
Name (_UID, One) // _UID: Unique ID
Name (ECAV, Zero)
Name (WEID, Zero)
Mutex (LFCM, 0x00)
Mutex (HGCT, 0x00)
Name (_GPE, 0x6E) // _GPE: General Purpose Events
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings
{
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) /* \_SB_.PC00.LPCB.EC0_._CRS.BFFR */
}

Method (_STA, 0, NotSerialized) // _STA: Status
{
Return (0x0F)
}

OperationRegion (ERAM, EmbeddedControl, Zero, 0xFF)
Field (ERAM, ByteAcc, Lock, Preserve)
{
VCMD, 8,
Offset (0x60),
SMPR, 8
}

OperationRegion (ECB2, SystemMemory, 0xFE0B0520, 0xFF)
Field (ECB2, AnyAcc, Lock, Preserve)
{
BAR1, 184,
BAR2, 80
}

OperationRegion (ERAX, SystemMemory, 0xFE0B0400, 0xFF)
Field (ERAX, ByteAcc, Lock, Preserve)
{
Offset (0x01),
VDAT, 8,
VSTA, 8,
BNMF, 1,
BNMS, 1,
Offset (0x06),
FANS, 8,
BUSG, 1,
BLEG, 1,
BATF, 1,
BNSM, 1,
BTST, 1,
BBAD, 1,
AUTO, 1,
FCHG, 1,
STMM, 8,
STMH, 8,
EDCC, 1,
, 1,
CDMB, 1,
CCSB, 1,
BTSM, 1,
BTCM, 1,
, 1,
Offset (0x0B),
SGST, 1,
HDMI, 1,
, 1,
, 1,
, 1,
, 1,
, 1,
Offset (0x0C),
ODPO, 1,
EODD, 1,
ODPK, 1,
CMEX, 1,
CMON, 1,
SODD, 1,
ODFB, 1,
EODS, 1,
RTMP, 8,
SBTS, 8,
MPTS, 8,
PINF, 3,
SUPR, 1,
GTMP, 1,
QUIT, 1,
LS35, 1,
Offset (0x11),
RMBT, 1,
RSBT, 1,
, 2,
Offset (0x12),
FUSL, 8,
FUSH, 8,
FWBT, 64,
Offset (0x1D),
XXXX, 8,
TMCB, 8,
LSKV, 8,
FCMO, 8,
BTFW, 8,
Offset (0x24),
BACT, 16,
KBGS, 32,
FEPL, 8,
FEPH, 8,
KBSS, 32,
Offset (0x31),
GIRT, 8,
PIRT, 8,
KIRT, 8,
IRTI, 8,
Offset (0x36),
DGPU, 8,
GUST, 8,
GDST, 8,
FCST, 8,
Offset (0x40),
HT0L, 8,
HT0H, 8,
Offset (0x43),
ECTP, 8,
Offset (0x45),
KBGC, 32,
Offset (0x4A),
ESMC, 1,
Offset (0x4B),
EMOD, 8,
BFUD, 16,
Offset (0x54),
, 3,
PDMD, 1,
Offset (0x55),
, 1,
TPMD, 1,
Offset (0x56),
Offset (0x57),
, 5,
BTSB, 3,
BTHT, 4,
BTTP, 4,
BTLF, 4,
Offset (0x5A),
Offset (0x5D),
EXSI, 8,
EXSB, 8,
EXND, 8,
Offset (0x61),
SMST, 8,
SMAD, 8,
SMCM, 8,
SMDA, 256,
BCNT, 8,
SMAA, 8,
SAD0, 8,
SAD1, 8,
, 1,
, 1,
, 1,
, 1,
FBDC, 1,
FBFG, 1,
Offset (0x8A),
KBLO, 1,
UCHE, 1,
KLCH, 1,
, 1,
KLFS, 1,
KLOR, 1,
CIBM, 1,
UCER, 1,
TPDV, 3,
Offset (0x8C),
QCHO, 1,
BKLT, 1,
BSFU, 1,
, 1,
, 1,
OKBS, 1,
, 1,
QCBX, 1,
FLBT, 1,
MLED, 1,
, 1,
LESR, 1,
, 1,
UQMF, 1,
Offset (0x8E),
YGAM, 8,
BMN0, 72,
BDN0, 64,
IBTL, 1,
IBCL, 1,
ISS0, 1,
IRTC, 1,
ISUP, 1,
ISC2, 1,
IWAK, 1,
Offset (0xA1),
FPFC, 1,
VOUT, 1,
TPAD, 1,
HKDB, 1,
NUML, 1,
CAPL, 1,
CCPW, 1,
EECP, 1,
Offset (0xA3),
OSTY, 3,
, 1,
ADPI, 2,
, 1,
ADPT, 1,
PMEW, 1,
MODW, 1,
LANW, 1,
RTCW, 1,
WLAW, 1,
USBW, 1,
KEYW, 1,
TPWK, 1,
CHCR, 1,
ADPP, 1,
LERN, 1,
ACMD, 1,
BOVP, 1,
LEAK, 1,
AIRP, 1,
ACOF, 1,
Offset (0xA7),
Offset (0xA8),
Offset (0xA9),
THRT, 8,
Offset (0xAB),
Offset (0xAC),
Offset (0xAD),
Offset (0xAE),
TLVL, 4,
, 2,
THSW, 1,
TPIN, 1,
Offset (0xB0),
CPUT, 8,
CPUS, 8,
PCHS, 8,
GPUS, 8,
GPUT, 8,
STPS, 8,
PCHT, 8,
CHIS, 8,
, 1,
LSTE, 1,
PMEE, 1,
PWBE, 1,
RNGE, 1,
BTWE, 1,
Offset (0xB9),
LCBV, 8,
Offset (0xBB),
WLAN, 1,
BLUE, 1,
WEXT, 1,
BEXT, 1,
KILL, 1,
WLOK, 1,
EN3G, 1,
EX3G, 1,
Offset (0xBD),
CTYP, 3,
CORE, 3,
GATY, 2,
BA1P, 1,
BA2P, 1,
, 2,
B1CH, 1,
B2CH, 1,
Offset (0xBF),
PBY1, 1,
PBY2, 1,
, 2,
SMB1, 1,
SMB2, 1,
Offset (0xC0),
B1TY, 1,
B1MD, 1,
B1LW, 1,
, 1,
B1MF, 3,
Offset (0xC1),
B1ST, 8,
B1RC, 16,
B1SN, 16,
B1FV, 16,
B1DV, 16,
B1DC, 16,
B1FC, 16,
B1GS, 8,
Offset (0xD0),
B1CR, 16,
B1AC, 16,
B1PC, 8,
B1VL, 8,
B1TM, 8,
B1AT, 8,
B1CC, 16,
B1TC, 8,
B1CI, 8,
B1CU, 8,
B1CA, 8,
B1SM, 16,
B1VC, 8,
B1FA, 8,
B1VA, 8,
B1C1, 16,
B1C2, 16,
B1C3, 16,
B1C4, 16,
Offset (0xEC),
MAXE, 16,
B1CT, 16,
B1EX, 1,
B1FL, 1,
B1EP, 1,
B1FI, 1,
, 2,
B1RE, 1,
Offset (0xF1),
B1LL, 1,
B1CE, 1,
B1SE, 1,
B1S5, 1,
B1SR, 1,
B1SC, 1,
Offset (0xF2),
B1TO, 1,
B1BC, 1,
B1CF, 1,
B1CS, 1,
B1SG, 1,
B1SU, 1,
B1OV, 1,
B1OT, 1,
B1TT, 1,
B1SA, 1,
B1SS, 1,
, 1,
B1SF, 1,
B1WN, 1,
Offset (0xF4),
B1DA, 16,
Offset (0xF8),
B1CN, 8,
ITMD, 1,
Offset (0xFA),
Offset (0xFB),
Offset (0xFE),
FA2S, 8
}

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

Method (RECM, 1, Serialized)
{
INDX = Arg0
Return (DATA) /* \_SB_.PC00.LPCB.EC0_.DATA */
}

Method (WECM, 2, Serialized)
{
INDX = Arg0
DATA = Arg1
}

OperationRegion (CMDE, SystemIO, 0x62, 0x0B)
Field (CMDE, ByteAcc, Lock, Preserve)
{
EC62, 8,
Offset (0x02),
Offset (0x03),
Offset (0x04),
EC66, 8,
Offset (0x06),
EC68, 8,
Offset (0x08),
Offset (0x09),
Offset (0x0A),
EC6C, 8
}

Method (WIBE, 1, Serialized)
{
Local0 = 0x00010000
While (Local0)
{
If ((Arg0 == One))
{
Local1 = EC66 /* \_SB_.PC00.LPCB.EC0_.EC66 */
}
ElseIf ((Arg0 == 0x02))
{
Local1 = EC6C /* \_SB_.PC00.LPCB.EC0_.EC6C */
}
Else
{
Return (0x02)
}

If (((Local1 & 0x02) == Zero))
{
Return (Zero)
}

Stall (0x0A)
Local0--
}

Return (One)
}

Method (WOBF, 1, Serialized)
{
Local0 = 0x00010000
While (Local0)
{
If ((Arg0 == One))
{
Local1 = EC66 /* \_SB_.PC00.LPCB.EC0_.EC66 */
}
ElseIf ((Arg0 == 0x02))
{
Local1 = EC6C /* \_SB_.PC00.LPCB.EC0_.EC6C */
}
Else
{
Return (0x02)
}

If (((Local1 & One) == One))
{
Return (Zero)
}

Stall (0x0A)
Local0--
}

Return (One)
}

Method (WOBE, 1, Serialized)
{
Local0 = 0x00010000
While (Local0)
{
If ((Arg0 == One))
{
Local1 = EC66 /* \_SB_.PC00.LPCB.EC0_.EC66 */
}
ElseIf ((Arg0 == 0x02))
{
Local1 = EC6C /* \_SB_.PC00.LPCB.EC0_.EC6C */
}
Else
{
Return (0x02)
}

If (((Local1 & One) == One))
{
If ((Arg0 == One))
{
Local2 = EC62 /* \_SB_.PC00.LPCB.EC0_.EC62 */
}
ElseIf ((Arg0 == 0x02))
{
Local2 = EC68 /* \_SB_.PC00.LPCB.EC0_.EC68 */
}
Else
{
Return (0x02)
}
}
Else
{
Return (Zero)
}

Stall (0x0A)
Local0--
}

Return (One)
}

Method (MBEI, 3, Serialized)
{
If ((WIBE (0x02) != Zero))
{
Return (One)
}

If ((WOBE (0x02) != Zero))
{
Return (One)
}

EC6C = Arg0
If ((WIBE (0x02) != Zero))
{
Return (One)
}

EC68 = Arg1
If ((WIBE (0x02) != Zero))
{
Return (One)
}

EC68 = Arg2
If ((WIBE (0x02) != Zero))
{
Return (One)
}

If ((WOBF (0x02) != Zero))
{
Return (One)
}

Local0 = EC68 /* \_SB_.PC00.LPCB.EC0_.EC68 */
Return (Local0)
}

Method (LCMD, 2, Serialized)
{
Name (LBUF, Buffer (0x1E)
{
0x00 // .
})
If ((WIBE (0x02) != Zero))
{
Return (One)
}

If ((WOBE (0x02) != Zero))
{
Return (One)
}

EC6C = Arg0
If ((WIBE (0x02) != Zero))
{
Return (One)
}

If (((Arg1 != Zero) && (Arg1 != 0xFF)))
{
EC68 = Arg1
If ((WIBE (0x02) != Zero))
{
Return (One)
}
}

If ((WOBF (0x02) != Zero))
{
Return (One)
}

Local0 = EC68 /* \_SB_.PC00.LPCB.EC0_.EC68 */
Local1 = Zero
While (Local0)
{
If ((WOBF (0x02) != Zero))
{
Return (One)
}

LBUF [Local1] = EC68 /* \_SB_.PC00.LPCB.EC0_.EC68 */
Local1++
Local0--
}

Return (LBUF) /* \_SB_.PC00.LPCB.EC0_.LCMD.LBUF */
}

Method (NCMD, 2, Serialized)
{
If ((WIBE (0x02) != Zero))
{
Return (One)
}

If ((WOBE (0x02) != Zero))
{
Return (One)
}

EC6C = Arg0
If ((WIBE (0x02) != Zero))
{
Return (One)
}

If (((Arg1 != Zero) && (Arg1 != 0xFF)))
{
EC68 = Arg1
If ((WIBE (0x02) != Zero))
{
Return (One)
}
}

Return (Zero)
}

Method (SCMD, 2, Serialized)
{
Name (LBUF, Buffer (0x1E)
{
0x00 // .
})
If ((WIBE (One) != Zero))
{
Return (One)
}

If ((WOBE (One) != Zero))
{
Return (One)
}

EC66 = Arg0
If ((WIBE (One) != Zero))
{
Return (One)
}

If (((Arg1 != Zero) && (Arg1 != 0xFF)))
{
EC62 = Arg1
If ((WIBE (One) != Zero))
{
Return (One)
}
}

If ((WOBF (One) != Zero))
{
Return (One)
}

Local0 = EC62 /* \_SB_.PC00.LPCB.EC0_.EC62 */
Local1 = Zero
While (Local0)
{
If ((WOBF (One) != Zero))
{
Return (One)
}

LBUF [Local1] = EC62 /* \_SB_.PC00.LPCB.EC0_.EC62 */
Local1++
Local0--
}

Return (LBUF) /* \_SB_.PC00.LPCB.EC0_.SCMD.LBUF */
}

Method (TCMD, 2, Serialized)
{
If ((WIBE (One) != Zero))
{
Return (One)
}

If ((WOBE (One) != Zero))
{
Return (One)
}

EC66 = Arg0
If ((WIBE (One) != Zero))
{
Return (One)
}

If (((Arg1 != Zero) && (Arg1 != 0xFF)))
{
EC62 = Arg1
If ((WIBE (One) != Zero))
{
Return (One)
}
}

Return (Zero)
}

Method (LRAM, 2, Serialized)
{
If ((WIBE (0x02) != Zero))
{
Return (One)
}

If ((WOBE (0x02) != Zero))
{
Return (One)
}

EC6C = 0x7E
If ((WIBE (0x02) != Zero))
{
Return (One)
}

EC68 = Arg0
If ((WIBE (0x02) != Zero))
{
Return (One)
}

EC68 = Arg1
If ((WIBE (0x02) != Zero))
{
Return (One)
}

If ((WOBF (0x02) != Zero))
{
Return (One)
}

Return (EC68) /* \_SB_.PC00.LPCB.EC0_.EC68 */
}

Method (SRAM, 2, Serialized)
{
If ((WIBE (One) != Zero))
{
Return (One)
}

If ((WOBE (One) != Zero))
{
Return (One)
}

EC66 = 0x7E
If ((WIBE (One) != Zero))
{
Return (One)
}

EC62 = Arg0
If ((WIBE (One) != Zero))
{
Return (One)
}

EC62 = Arg1
If ((WIBE (One) != Zero))
{
Return (One)
}

If ((WOBF (One) != Zero))
{
Return (One)
}

Return (EC62) /* \_SB_.PC00.LPCB.EC0_.EC62 */
}

Device (BAT0)
{
Name (_HID, EisaId ("PNP0C0A") /* Control Method Battery */) // _HID: Hardware ID
Name (_UID, One) // _UID: Unique ID
Name (_PCL, Package (0x01) // _PCL: Power Consumer List
{
_SB
})
Name (PBIF, Package (0x0D)
{
Zero,
0xFFFFFFFF,
0xFFFFFFFF,
One,
0xFFFFFFFF,
Zero,
Zero,
0x64,
Zero,
"LCFC",
"BAT20101001",
"LiP",
"LENOVO"
})
Name (XBIF, Package (0x15)
{
One,
Zero,
0xFFFFFFFF,
0xFFFFFFFF,
One,
0xFFFFFFFF,
Zero,
Zero,
Zero,
0x00017318,
0xFFFFFFFF,
0xFFFFFFFF,
0x03E8,
0x03E8,
0x64,
Zero,
"LCFC",
"BAT20101001",
"LiP",
"LENOVO",
One
})
Name (PBST, Package (0x04)
{
One,
0x0A90,
0x1000,
0x2A30
})
Method (_STA, 0, NotSerialized) // _STA: Status
{
If (ECAV)
{
If ((Acquire (LFCM, 0xA000) == Zero))
{
Local0 = BA1P /* \_SB_.PC00.LPCB.EC0_.BA1P */
Release (LFCM)
}
}

If ((Local0 & One))
{
Return (0x1F)
}
Else
{
Return (0x0F)
}
}

Method (_BIF, 0, NotSerialized) // _BIF: Battery Information
{
If ((ECAV == One))
{
If ((Acquire (LFCM, 0xA000) == Zero))
{
Local0 = B1DC /* \_SB_.PC00.LPCB.EC0_.B1DC */
Local0 *= 0x0A
PBIF [One] = Local0
Local0 = B1FC /* \_SB_.PC00.LPCB.EC0_.B1FC */
Local0 *= 0x0A
PBIF [0x02] = Local0
PBIF [0x04] = B1DV /* \_SB_.PC00.LPCB.EC0_.B1DV */
If (B1FC)
{
PBIF [0x05] = ((B1FC * 0x0A) / 0x0A)
PBIF [0x07] = ((B1DC * 0x0A) / 0x64)
}

PBIF [0x09] = ""
PBIF [0x0A] = ""
PBIF [0x0B] = ""
PBIF [0x0C] = ""
Name (BDNT, Buffer (0x09)
{
0x00 // .
})
BDNT = BDN0 /* \_SB_.PC00.LPCB.EC0_.BDN0 */
PBIF [0x09] = ToString (BDNT, Ones)
Local0 = B1SN /* \_SB_.PC00.LPCB.EC0_.B1SN */
Name (SERN, Buffer (0x06)
{
" "
})
Local2 = 0x04
While (Local0)
{
Divide (Local0, 0x0A, Local1, Local0)
SERN [Local2] = (Local1 + 0x30)
Local2--
}

PBIF [0x0A] = SERN /* \_SB_.PC00.LPCB.EC0_.BAT0._BIF.SERN */
Name (DCH0, Buffer (0x0A)
{
0x00 // .
})
Name (DCH1, "LION")
Name (DCH2, "LiP")
If ((B1TY == One))
{
DCH0 = DCH1 /* \_SB_.PC00.LPCB.EC0_.BAT0._BIF.DCH1 */
PBIF [0x0B] = ToString (DCH0, Ones)
}
Else
{
DCH0 = DCH2 /* \_SB_.PC00.LPCB.EC0_.BAT0._BIF.DCH2 */
PBIF [0x0B] = ToString (DCH0, Ones)
}

Name (BMNT, Buffer (0x0A)
{
0x00 // .
})
BMNT = BMN0 /* \_SB_.PC00.LPCB.EC0_.BMN0 */
PBIF [0x0C] = ToString (BMNT, Ones)
Release (LFCM)
}
}

Return (PBIF) /* \_SB_.PC00.LPCB.EC0_.BAT0.PBIF */
}

Method (_BIX, 0, NotSerialized) // _BIX: Battery Information Extended
{
If ((ECAV == One))
{
If ((Acquire (LFCM, 0xA000) == Zero))
{
Local0 = B1DC /* \_SB_.PC00.LPCB.EC0_.B1DC */
Local0 *= 0x0A
XBIF [0x02] = Local0
Local0 = B1FC /* \_SB_.PC00.LPCB.EC0_.B1FC */
Local0 *= 0x0A
XBIF [0x03] = Local0
XBIF [0x05] = B1DV /* \_SB_.PC00.LPCB.EC0_.B1DV */
If (B1FC)