From owner-acpi-jp@jp.FreeBSD.org Mon Jul 28 11:46:34 2003
Received: (from daemon@localhost)
	by castle.jp.FreeBSD.org (8.11.6p2+3.4W/8.11.3) id h6S2kY475932;
	Mon, 28 Jul 2003 11:46:34 +0900 (JST)
	(envelope-from owner-acpi-jp@jp.FreeBSD.org)
Received: from gate1.comp.sd.keio.ac.jp (gate1.comp.sd.keio.ac.jp [131.113.98.71])
	by castle.jp.FreeBSD.org (8.11.6p2+3.4W/8.11.3) with SMTP/inet id h6S2kWT75927
	for <acpi-jp@jp.FreeBSD.org>; Mon, 28 Jul 2003 11:46:32 +0900 (JST)
	(envelope-from yakoh@sd.keio.ac.jp)
Received: (qmail 63351 invoked by uid 1110); 28 Jul 2003 02:46:26 -0000
From: Takahiro Yakoh <yakoh@sd.keio.ac.jp>
To: acpi-jp@jp.FreeBSD.org
Message-ID: <20030728024626.GA62765%yakoh@sd.keio.ac.jp>
Mime-Version: 1.0
Content-Type: multipart/mixed; boundary="Dxnq1zWXvFF0Q93v"
Content-Disposition: inline
User-Agent: Mutt/1.5.3i-ja.1
Reply-To: acpi-jp@jp.FreeBSD.org
Precedence: list
Date: Mon, 28 Jul 2003 11:46:26 +0900
X-Sequence: acpi-jp 2510
Subject: [acpi-jp 2510] Problem report on Victor InterLink MP-XP7310
Sender: owner-acpi-jp@jp.FreeBSD.org
X-Originator: yakoh@sd.keio.ac.jp
X-Distribute: distribute version 2.1 (Alpha) patchlevel 24e+030702


--Dxnq1zWXvFF0Q93v
Content-Type: text/plain; charset=us-ascii
Content-Disposition: inline

Hi,

This is a problem report about thermal control system on the new PC.
ACPI subsystem in 5.1-RELEASE can't read thermal state from this PC.
Since dynamic cooling system does not work, the PC always hangs
during make buildworld.  So I can't try with -CURRENT yet.
# Though building ports XFree86-4 is successed without hanging...
I want to know how to cool the PC automatically.

The following attachments are dmesg, acpi kernel state, and asl code.

	T.Yakoh

--Dxnq1zWXvFF0Q93v
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment; filename="xp7310.asl"

/*
RSD PTR: Checksum=163, OEMID=ACPIAM, RsdtAddress=0x1f740000
 */
/*
RSDT: Length=48, Revision=1, Checksum=66,
	OEMID=A M I, OEM Table ID=OEMRSDT, OEM Revision=0x7000301,
	Creator ID=MSFT, Creator Revision=0x97
 */
/*
	Entries={ 0x1f740200, 0x1f740300, 0x1f750040 }
 */
/*
	DSDT=0x1f740360
	INT_MODEL=APIC
	SCI_INT=9
	SMI_CMD=0xb2, ACPI_ENABLE=0xe1, ACPI_DISABLE=0x1e, S4BIOS_REQ=0x0
	PM1a_EVT_BLK=0xe400-0xe403
	PM1a_CNT_BLK=0xe404-0xe405
	PM2_CNT_BLK=0xe420-0xe420
	PM2_TMR_BLK=0xe408-0xe40b
	PM2_GPE0_BLK=0xe428-0xe42f
	P_LVL2_LAT=1ms, P_LVL3_LAT=101ms
	FLUSH_SIZE=1024, FLUSH_STRIDE=16
	DUTY_OFFSET=1, DUTY_WIDTH=3
	DAY_ALRM=13, MON_ALRM=0, CENTURY=0
	Flags={WBINVD,PROC_C1,SLP_BUTTON,RTC_S4}
 */
/*
DSDT: Length=25723, Revision=1, Checksum=252,
	OEMID=0ABBD, OEM Table ID=0ABBD001, OEM Revision=0x1,
	Creator ID=MSFT, Creator Revision=0x100000e
 */
DefinitionBlock (
    "acpi_dsdt.aml",	//Output filename
    "DSDT",		//Signature
    0x1,		//DSDT Revision
    "0ABBD",		//OEMID
    "0ABBD001",		//TABLE ID
    0x1		//OEM Revision
)

{
OperationRegion(BIOS, SystemMemory, 0x1f750064, 0xff)
Field(BIOS, ByteAcc, NoLock, Preserve) {
    SS1_,	1,
    SS2_,	1,
    SS3_,	1,
    SS4_,	1,
    Offset(0x1),
    IOST,	16,
    TOPM,	32,
    ROMS,	32,
    MG1B,	32,
    MG1L,	32,
    MG2B,	32,
    MG2L,	32
}
Name(SPIO, 0xffffffff)
Name(PMBS, 0xe400)
Name(PMLN, 0x80)
Name(WFAT, 0x90)
Name(WNVR, 0x91)
Name(RNVR, 0x92)
Name(SWFR, 0x93)
Name(STDD, 0x94)
Name(GTDD, 0x95)
Name(ADBR, 0x96)
Name(CGPS, 0x97)
Name(CGWK, 0x98)
Name(ISWP, 0x99)
Name(GPBS, 0xec00)
Name(GPLN, 0x40)
Name(SMBS, 0xe800)
Name(SMBL, 0x10)
Name(APCB, 0xfec00000)
Name(APCL, 0x00100000)
Method(RRIO, 4) {
    Store("RRIO", Debug)
}
Method(RDMA, 3) {
    Store("rDMA", Debug)
}
Name(PICM, 0x0)
Method(_PIC, 1) {
    If(Arg0) {
        Store(0xaa, DBG8)
    }
    Else {
        Store(0x55, DBG8)
    }
    Store(Arg0, PICM)
}
Method(OSFL) {
    Store(0x1, Local0)
    If(MCTH(\_OS_, "Microsoft Windows NT")) {
        Store(0x0, Local0)
    }
    Return(Local0)
}
Method(MCTH, 2) {
    If(LLess(SizeOf(Arg0), SizeOf(Arg1))) {
        Return(Zero)
    }
    Add(SizeOf(Arg0), 0x1, Local0)
    Name(BUF0, Buffer(Local0) { })
    Name(BUF1, Buffer(Local0) { })
    Store(Arg0, BUF0)
    Store(Arg1, BUF1)
    While(Local0) {
        Decrement(Local0)
        If(LNot(LEqual(DerefOf(Index(BUF0, Local0, )), DerefOf(Index(BUF1, Local0, ))))) {
            Return(Zero)
        }
    }
    Return(One)
}
Method(GPRW, 2) {
    Name(PRWP, Package(0x2) {
        0x0,
        0x0,
    })
    Store(Arg0, Index(PRWP, 0x0, ))
    Store(Arg1, Index(PRWP, 0x1, ))
    Store(0x0, Local0)
    Or(Local0, ShiftLeft(SS1_, 0x1, ), Local0)
    Or(Local0, ShiftLeft(SS2_, 0x2, ), Local0)
    Or(Local0, ShiftLeft(SS3_, 0x3, ), Local0)
    Or(Local0, ShiftLeft(SS4_, 0x4, ), Local0)
    If(And(ShiftLeft(0x1, Arg1, ), Local0, )) {
    }
    Else {
        ShiftRight(Local0, 0x1, Local0)
        Store(OSFL(), Local1)
        If(LOr(LEqual(Local1, 0x1), LEqual(Local1, 0x2))) {
            FindSetLeftBit(Local0, Index(PRWP, 0x1, ))
        }
        Else {
            FindSetRightBit(Local0, Index(PRWP, 0x1, ))
        }
    }
    Return(PRWP)
}
Name(WAKP, Package(0x2) {
    0x0,
    0x0,
})
OperationRegion(DEB0, SystemIO, 0x80, 0x1)
Field(DEB0, ByteAcc, NoLock, Preserve) {
    DBG8,	8
}
OperationRegion(DEB1, SystemIO, 0x90, 0x2)
Field(DEB1, WordAcc, NoLock, Preserve) {
    DBG9,	16
}
Scope(\_PR_) {
    Processor(CPU1, 1, 0xe410, 0x6) {
    }
}
Scope(\_SB_) {
    Name(PR01, Package(0x5) {
        Package(0x4) {
            0x0008ffff,
            0x0,
            LNKE,
            0x0,
        },
        Package(0x4) {
            0x0003ffff,
            0x0,
            LNKB,
            0x0,
        },
        Package(0x4) {
            0x0003ffff,
            0x1,
            LNKC,
            0x0,
        },
        Package(0x4) {
            0x0005ffff,
            0x0,
            LNKC,
            0x0,
        },
        Package(0x4) {
            0x0005ffff,
            0x1,
            LNKD,
            0x0,
        },
    })
    Name(AR01, Package(0x5) {
        Package(0x4) {
            0x0008ffff,
            0x0,
            0x0,
            0x14,
        },
        Package(0x4) {
            0x0003ffff,
            0x0,
            0x0,
            0x11,
        },
        Package(0x4) {
            0x0003ffff,
            0x1,
            0x0,
            0x12,
        },
        Package(0x4) {
            0x0005ffff,
            0x0,
            0x0,
            0x12,
        },
        Package(0x4) {
            0x0005ffff,
            0x1,
            0x0,
            0x13,
        },
    })
    Name(PR00, Package(0x7) {
        Package(0x4) {
            0x0002ffff,
            0x0,
            LNKA,
            0x0,
        },
        Package(0x4) {
            0x001fffff,
            0x0,
            LNKC,
            0x0,
        },
        Package(0x4) {
            0x001fffff,
            0x1,
            LNKB,
            0x0,
        },
        Package(0x4) {
            0x001dffff,
            0x0,
            LNKA,
            0x0,
        },
        Package(0x4) {
            0x001dffff,
            0x1,
            LNKD,
            0x0,
        },
        Package(0x4) {
            0x001dffff,
            0x2,
            LNKC,
            0x0,
        },
        Package(0x4) {
            0x001dffff,
            0x3,
            LNKH,
            0x0,
        },
    })
    Name(AR00, Package(0x7) {
        Package(0x4) {
            0x0002ffff,
            0x0,
            0x0,
            0x10,
        },
        Package(0x4) {
            0x001fffff,
            0x0,
            0x0,
            0x12,
        },
        Package(0x4) {
            0x001fffff,
            0x1,
            0x0,
            0x11,
        },
        Package(0x4) {
            0x001dffff,
            0x0,
            0x0,
            0x10,
        },
        Package(0x4) {
            0x001dffff,
            0x1,
            0x0,
            0x13,
        },
        Package(0x4) {
            0x001dffff,
            0x2,
            0x0,
            0x12,
        },
        Package(0x4) {
            0x001dffff,
            0x3,
            0x0,
            0x17,
        },
    })
    Name(PRSA, Buffer(0x6) {0x23, 0xf8, 0x18, 0x18, 0x79, 0x0 })
    Name(PRSB, Buffer(0x6) {0x23, 0xf8, 0x10, 0x18, 0x79, 0x0 })
    Alias(PRSB, PRSC)
    Alias(PRSB, PRSD)
    Alias(PRSB, PRSE)
    Alias(PRSB, PRSF)
    Alias(PRSB, PRSG)
    Alias(PRSB, PRSH)
    Device(PCI0) {
        Name(_HID, 0x030ad041)
        Name(_ADR, 0x0)
        Name(_BBN, 0x0)
        Name(_UID, 0x0)
        Method(_PRT) {
            If(PICM) {
                Return(AR00)
            }
            Return(PR00)
        }
        Device(P0P1) {
            Name(_ADR, 0x001e0000)
            Method(_PRW) {
                Return(GPRW(0xb, 0x4))
            }
            Method(_PRT) {
                If(PICM) {
                    Return(AR01)
                }
                Return(PR01)
            }
            Device(LAN0) {
                Name(_ADR, 0x00080000)
                Method(_PRW) {
                    Return(GPRW(0xb, 0x4))
                }
            }
            Device(CBS0) {
                Name(_ADR, 0x00030000)
                OperationRegion(CBSP, PCI_Config, 0x0, 0xf0)
                Field(CBSP, DWordAcc, NoLock, Preserve) {
                    Offset(0x4),
                    CB04,	8,
                    Offset(0x14),
                    CB14,	8,
                    Offset(0x3c),
                    CB3C,	8,
                    Offset(0x3e),
                    CB3E,	8,
                    Offset(0x44),
                    CB44,	32,
                    Offset(0xe0),
                    PME0,	8,
                    PME1,	8
                }
                Method(_INI) {
                    Store(Zero, CB44)
                }
                Method(CBSW, 1) {
                    If(LEqual(Arg0, 0x3)) {
                        Store(Zero, CB44)
                    }
                }
                Method(CBSR) {
                    And(PME1, 0x80, Local1)
                    If(Local1) {
                        And(PME0, 0xfc, PME0)
                        Store(PME1, Local2)
                        Store(Local2, PME1)
                    }
                    Return(Local1)
                }
                Method(_PRW) {
                    Return(GPRW(0xb, 0x3))
                }
            }
            Device(P394) {
                Name(_ADR, 0x00030001)
                Method(_PRW) {
                    Return(GPRW(0xb, 0x3))
                }
            }
            Device(MPCI) {
                Name(_ADR, 0x00050000)
                OperationRegion(MINP, PCI_Config, 0x0, 0x68)
                Field(MINP, ByteAcc, NoLock, Preserve) {
                    VNUM,	32,
                    Offset(0x2c),
                    SNUM,	32,
                    Offset(0x34)
                }
                Method(MPDP) {
                    If(LEqual(SNUM, 0x04621668)) {
                        Return(0x1)
                    }
                    If(LEqual(SNUM, 0x25228086)) {
                        Return(0x2)
                    }
                    If(LEqual(SNUM, 0x25278086)) {
                        Return(0x2)
                    }
                    Return(0x0)
                }
                Method(_PRW) {
                    Return(GPRW(0xb, 0x3))
                }
            }
        }
        Device(SBRG) {
            Name(_ADR, 0x001f0000)
            Device(PIC_) {
                Name(_HID, 0xd041)
                Name(_CRS, Buffer(0x15) {0x47, 0x1, 0x20, 0x0, 0x20, 0x0, 0x0, 0x2, 0x47, 0x1, 0xa0, 0x0, 0xa0, 0x0, 0x0, 0x2, 0x22, 0x4, 0x0, 0x79, 0x0 })
            }
            Device(DMAD) {
                Name(_HID, 0x0002d041)
                Name(_CRS, Buffer(0x35) {0x2a, 0x10, 0x4, 0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x10, 0x47, 0x1, 0x81, 0x0, 0x81, 0x0, 0x0, 0x3, 0x47, 0x1, 0x87, 0x0, 0x87, 0x0, 0x0, 0x1, 0x47, 0x1, 0x89, 0x0, 0x89, 0x0, 0x0, 0x3, 0x47, 0x1, 0x8f, 0x0, 0x8f, 0x0, 0x0, 0x1, 0x47, 0x1, 0xc0, 0x0, 0xc0, 0x0, 0x0, 0x20, 0x79, 0x0 })
            }
            Device(TMR_) {
                Name(_HID, 0x0001d041)
                Name(_CRS, Buffer(0xd) {0x47, 0x1, 0x40, 0x0, 0x40, 0x0, 0x0, 0x4, 0x22, 0x1, 0x0, 0x79, 0x0 })
            }
            Device(RTC0) {
                Name(_HID, 0x000bd041)
                Name(_CRS, Buffer(0xd) {0x47, 0x1, 0x70, 0x0, 0x70, 0x0, 0x0, 0x2, 0x22, 0x0, 0x1, 0x79, 0x0 })
            }
            Device(PS2K) {
                Name(_HID, 0x0303d041)
                Name(_CID, 0x0b03d041)
                Method(_STA) {
                    ShiftLeft(0x1, 0xa, Local0)
                    If(And(IOST, Local0, )) {
                        Return(0xf)
                    }
                    Return(0x0)
                }
                Name(_CRS, Buffer(0x15) {0x47, 0x1, 0x60, 0x0, 0x60, 0x0, 0x0, 0x1, 0x47, 0x1, 0x64, 0x0, 0x64, 0x0, 0x0, 0x1, 0x22, 0x2, 0x0, 0x79, 0x0 })
            }
            Device(PS2M) {
                Name(_HID, 0x030fd041)
                Name(_CID, 0x130fd041)
                Method(_STA) {
                    ShiftLeft(0x1, 0xc, Local0)
                    If(And(IOST, Local0, )) {
                        Return(0xf)
                    }
                    Return(0x0)
                }
                Name(CRS1, Buffer(0x5) {0x22, 0x0, 0x10, 0x79, 0x0 })
                Name(CRS2, Buffer(0x15) {0x47, 0x1, 0x60, 0x0, 0x60, 0x0, 0x0, 0x1, 0x47, 0x1, 0x64, 0x0, 0x64, 0x0, 0x0, 0x1, 0x22, 0x0, 0x10, 0x79, 0x0 })
                Method(_CRS) {
                    ShiftLeft(0x1, 0xa, Local0)
                    If(And(IOST, Local0, )) {
                        Return(CRS1)
                    }
                    Else {
                        Return(CRS2)
                    }
                }
            }
            Device(SPKR) {
                Name(_HID, 0x0008d041)
                Name(_CRS, Buffer(0xa) {0x47, 0x1, 0x61, 0x0, 0x61, 0x0, 0x0, 0x1, 0x79, 0x0 })
            }
            Device(COPR) {
                Name(_HID, 0x040cd041)
                Name(_CRS, Buffer(0xd) {0x47, 0x1, 0xf0, 0x0, 0xf0, 0x0, 0x0, 0x10, 0x22, 0x0, 0x20, 0x79, 0x0 })
            }
            Device(RMSC) {
                Name(_HID, 0x020cd041)
                Name(_UID, 0x10)
                Name(CRS_, Buffer(0x8a) {0x47, 0x1, 0x10, 0x0, 0x10, 0x0, 0x0, 0x10, 0x47, 0x1, 0x22, 0x0, 0x22, 0x0, 0x0, 0x1e, 0x47, 0x1, 0x44, 0x0, 0x44, 0x0, 0x0, 0x1c, 0x47, 0x1, 0x63, 0x0, 0x63, 0x0, 0x0, 0x1, 0x47, 0x1, 0x65, 0x0, 0x65, 0x0, 0x0, 0x1, 0x47, 0x1, 0x67, 0x0, 0x67, 0x0, 0x0, 0x9, 0x47, 0x1, 0x72, 0x0, 0x72, 0x0, 0x0, 0xe, 0x47, 0x1, 0x80, 0x0, 0x80, 0x0, 0x0, 0x1, 0x47, 0x1, 0x84, 0x0, 0x84, 0x0, 0x0, 0x3, 0x47, 0x1, 0x88, 0x0, 0x88, 0x0, 0x0, 0x1, 0x47, 0x1, 0x8c, 0x0, 0x8c, 0x0, 0x0, 0x3, 0x47, 0x1, 0x90, 0x0, 0x90, 0x0, 0x0, 0x10, 0x47, 0x1, 0xa2, 0x0, 0xa2, 0x0, 0x0, 0x1e, 0x47, 0x1, 0xe0, 0x0, 0xe0, 0x0, 0x0, 0x10, 0x47, 0x1, 0xd0, 0x4, 0xd0, 0x4, 0x0, 0x2, 0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x0 })
                Method(_CRS) {
                    CreateWordField(CRS_, 0x7a, GP00)
                    CreateWordField(CRS_, 0x7c, GP01)
                    CreateByteField(CRS_, 0x7f, GP0L)
                    Store(PMBS, GP00)
                    Store(PMBS, GP01)
                    Store(PMLN, GP0L)
                    If(GPBS) {
                        CreateWordField(CRS_, 0x82, GP20)
                        CreateWordField(CRS_, 0x84, GP21)
                        CreateByteField(CRS_, 0x87, GP2L)
                        Store(GPBS, GP20)
                        Store(GPBS, GP21)
                        Store(GPLN, GP2L)
                    }
                    Return(CRS_)
                }
            }
            Device(OMSC) {
                Name(_HID, 0x020cd041)
                Name(_UID, 0x0)
                Name(CRS_, Buffer(0x1a) {0x86, 0x9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x86, 0x9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x0 })
                Method(_CRS) {
                    If(APCB) {
                        CreateDWordField(CRS_, 0x8, ML01)
                        CreateDWordField(CRS_, 0x4, MB01)
                        CreateDWordField(CRS_, 0x14, ML02)
                        CreateDWordField(CRS_, 0x10, MB02)
                        Store(APCB, MB01)
                        Store(APCL, ML01)
                        Store(0xfee00000, MB02)
                        Store(0x1000, ML02)
                    }
                    Return(CRS_)
                }
            }
            Device(\_SB_.RMEM) {
                Name(_HID, 0x010cd041)
                Name(_UID, 0x1)
                Name(CRS_, Buffer(0x3e) {0x86, 0x9, 0x0, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0x0, 0x86, 0x9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x86, 0x9, 0x0, 0x0, 0x0, 0x0, 0xe, 0x0, 0x0, 0x0, 0x2, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0, 0x0, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x86, 0x9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x0 })
                Method(_CRS) {
                    CreateDWordField(CRS_, 0x10, BAS1)
                    CreateDWordField(CRS_, 0x14, LEN1)
                    CreateDWordField(CRS_, 0x1c, BAS2)
                    CreateDWordField(CRS_, 0x20, LEN2)
                    CreateDWordField(CRS_, 0x2c, LEN3)
                    CreateDWordField(CRS_, 0x34, BAS4)
                    CreateDWordField(CRS_, 0x38, LEN4)
                    If(OSFL()) {
                    }
                    Else {
                        If(MG1B) {
                            If(LGreater(MG1B, 0x000c0000)) {
                                Store(0x000c0000, BAS1)
                                Subtract(MG1B, BAS1, LEN1)
                            }
                        }
                        Else {
                            Store(0x000c0000, BAS1)
                            Store(0x00020000, LEN1)
                        }
                        If(Add(MG1B, MG1L, Local0)) {
                            Store(Local0, BAS2)
                            Subtract(0x00100000, BAS2, LEN2)
                        }
                    }
                    Subtract(MG2B, 0x00100000, LEN3)
                    Return(CRS_)
                }
            }
            Scope(\) {
                OperationRegion(\GPSC, SystemIO, 0xb2, 0x2)
                Field(\GPSC, ByteAcc, NoLock, Preserve) {
                    SMCM,	8,
                    SMST,	8
                }
                Method(\ISMI, 1, Serialized) {
                    Store(Arg0, SMCM)
                }
                Method(\DIAG, 1) {
                    Store(Arg0, DBG8)
                }
                OperationRegion(\PMIO, SystemIO, PMBS, 0x80)
                Field(\PMIO, ByteAcc, NoLock, Preserve) {
                    Offset(0x10),
                    ,	1,
                    TDTY,	3,
                    TENA,	1,
                    TTDT,	3,
                    FRCT,	1,
                    ,	8,
                    THLS,	1,
                    Offset(0x28),
                    ,	11,
                    SBPS,	1,
                    Offset(0x2a),
                    Offset(0x2b),
                    G08S,	1,
                    ,	2,
                    G11S,	1,
                    G12S,	1,
                    FLPS,	1,
                    Offset(0x2c),
                    ,	2,
                    TPOL,	1,
                    Offset(0x2d),
                    Offset(0x2e),
                    Offset(0x2f),
                    G08E,	1,
                    ,	2,
                    G11E,	1,
                    G12E,	1,
                    Offset(0x30),
                    ,	4,
                    SLPE,	1,
                    Offset(0x31),
                    Offset(0x34),
                    ,	4,
                    SLPS,	1,
                    Offset(0x35)
                }
                OperationRegion(\GPIO, SystemIO, GPBS, 0x40)
                Field(\GPIO, ByteAcc, NoLock, Preserve) {
                    Offset(0xc),
                    ,	25,
                    ,	1,
                    ,	1,
                    BKLT,	1,
                    IPWR,	1,
                    Offset(0x2c),
                    ,	11,
                    LIDL,	1,
                    ,	1,
                    FLPL,	1,
                    Offset(0x38),
                    ,	1,
                    SBAY,	2,
                    FS02,	3,
                    FS56,	2
                }
                OperationRegion(\ECMS, SystemIO, 0x72, 0x2)
                Field(\ECMS, ByteAcc, Lock, Preserve) {
                    EIND,	8,
                    EDAT,	8
                }
                IndexField(EIND, EDAT, ByteAcc, NoLock, Preserve) {
                    Offset(0x10),
                    IKFG,	8,
                    FRPN,	16,
                    RAMB,	32,
                    AVOL,	8,
                    LBTN,	8,
                    CKLN,	8,
                    CK00,	8,
                    CK01,	8,
                    CK02,	8,
                    CK03,	8,
                    CK04,	8,
                    CK05,	8,
                    CK06,	8,
                    CK07,	8,
                    CK08,	8,
                    CK09,	8,
                    CK10,	8,
                    CK11,	8,
                    CK12,	8,
                    CK13,	8,
                    CK14,	8,
                    CK15,	8,
                    CK16,	8,
                    CK17,	8,
                    CK18,	8,
                    CK19,	8,
                    CK20,	8,
                    CK21,	8,
                    CK22,	8,
                    CK23,	8,
                    CK24,	8,
                    CK25,	8,
                    CK26,	8,
                    CK27,	8,
                    CK28,	8,
                    CK29,	8,
                    ERRF,	8,
                    OCLK,	8,
                    WIDE,	1,
                    OVCK,	2,
                    S42K,	3,
                    Offset(0x3b),
                    CPUR,	6,
                    CPUF,	2,
                    LBT2,	8
                }
                OperationRegion(\RAMW, SystemMemory, RAMB, 0xff)
                Field(\RAMW, ByteAcc, NoLock, Preserve) {
                    Offset(0xb0),
                    TRTY,	8,
                    FSFN,	8,
                    FSTA,	16,
                    FADR,	32,
                    FSIZ,	16,
                    ACTD,	8,
                    AVLD,	8,
                    SETD,	8,
                    ACPF,	1,
                    DCPF,	1,
                    CHGF,	1,
                    DCP2,	1,
                    CHG2,	1,
                    Offset(0xbe),
                    PADL,	16,
                    CADL,	16,
                    CSTE,	16,
                    NSTE,	16,
                    SSTE,	16,
                    SFUN,	8,
                    TSAD,	8,
                    TAC3,	8,
                    TAC2,	8,
                    TAC1,	8,
                    TAC0,	8,
                    TPSV,	8,
                    TCRT,	8,
                    F1L0,	8,
                    F2L0,	8,
                    F1L1,	8,
                    F2L1,	8,
                    F1L2,	8,
                    F2L2,	8,
                    F1L3,	8,
                    F2L3,	8,
                    F1L4,	8,
                    F2L4,	8,
                    SLPT,	8,
                    DBRD,	32,
                    AIBF,	1,
                    Offset(0xe0),
                    PPSV,	8,
                    PAC0,	8
                }
                Name(OSFG, 0x0)
                Name(OS9X, 0x1)
                Name(OS98, 0x2)
                Name(OSME, 0x4)
                Name(OS2K, 0x8)
                Name(OSXP, 0x10)
                Method(OSVR) {
                    If(CondRefOf(\_OSI, Local0)) {
                        Store(OSXP, OSFG)
                    }
                    Else {
                        If(MCTH(\_OS_, "Microsoft Windows")) {
                            Store(OS98, OSFG)
                        }
                        Else {
                            If(MCTH(\_OS_, "Microsoft WindowsME: Millennium Edition")) {
                                Store(OSME, OSFG)
                            }
                            Else {
                                If(MCTH(\_OS_, "Microsoft Windows NT")) {
                                    Store(OS2K, OSFG)
                                }
                                Else {
                                    Store(OSXP, OSFG)
                                }
                            }
                        }
                    }
                    Return(OSFG)
                }
                Method(\DBGR, 1) {
                    Store(Arg0, DBRD)
                    \ISMI(\ADBR)
                }
                Name(MNAM, "J2N")
                Name(ONAM, "VICTOR COMPANY OF JAPAN, LIMITED")
            }
            Scope(\_SB_.PCI0) {
                Method(_INI) {
                    \OSVR()
                }
            }
            Scope(\_SB_.PCI0.SBRG) {
                OperationRegion(GPMC, PCI_Config, 0xa0, 0x60)
                Field(GPMC, ByteAcc, NoLock, Preserve) {
                    ,	7,
                    C4EN,	1
                }
                Method(_INI) {
                    C4C3()
                }
                Method(C4C3) {
                    XOr(\ACPF, One, Local0)
                    Store(Local0, C4EN)
                }
            }
            Scope(\_SB_.PCI0.SBRG) {
                Device(EC0_) {
                    Name(_HID, 0x090cd041)
                    Name(_CRS, Buffer(0x12) {0x47, 0x1, 0x62, 0x0, 0x62, 0x0, 0x0, 0x1, 0x47, 0x1, 0x66, 0x0, 0x66, 0x0, 0x0, 0x1, 0x79, 0x0 })
                    Name(_GPE, 0x1c)
                    Mutex(MUEC, 0)
                    Name(ECFL, Zero)
                    Method(ECAV) {
                        Return(ECFL)
                    }
                    OperationRegion(ECOR, EmbeddedControl, 0x0, 0x80)
                    Field(ECOR, ByteAcc, Lock, Preserve) {
                        Offset(0x4),
                        CMD1,	8,
                        CDT1,	8,
                        CDT2,	8,
                        CDT3,	8,
                        Offset(0x43),
                        P50I,	1,
                        ,	1,
                        ,	1,
                        P43I,	1,
                        P54I,	1,
                        P55I,	1,
                        ,	1,
                        Offset(0x44),
                        P54D,	8,
                        P55D,	8,
                        Offset(0x48),
                        P54S,	8,
                        P55S,	8,
                        P50S,	8,
                        P43S,	8,
                        P54T,	8,
                        P55T,	8,
                        P50T,	8,
                        P43T,	8,
                        P60S,	8,
                        P61S,	8,
                        P62S,	8,
                        P63S,	8,
                        P64S,	8,
                        P65S,	8,
                        P66S,	8,
                        P67S,	8,
                        P60T,	8,
                        P61T,	8,
                        P62T,	8,
                        P63T,	8,
                        P64T,	8,
                        P65T,	8,
                        P66T,	8,
                        P67T,	8,
                        Offset(0x78),
                        P60I,	1,
                        P61I,	1,
                        P62I,	1,
                        P63I,	1,
                        P64I,	1,
                        P65I,	1,
                        P66I,	1,
                        P67I,	1
                    }
                    Name(SMBF, 0x0)
                    OperationRegion(SMBX, EmbeddedControl, 0x18, 0x28)
                    Field(SMBX, ByteAcc, NoLock, Preserve) {
                        PRTC,	8,
                        SSTS,	5,
                        ,	1,
                        ALFG,	1,
                        CDFG,	1,
                        ADDR,	8,
                        CMDB,	8,
                        BDAT,	256,
                        BCNT,	8,
                        ,	1,
                        ALAD,	7,
                        ALD0,	8,
                        ALD1,	8
                    }
                    Field(SMBX, ByteAcc, NoLock, Preserve) {
                        Offset(0x4),
                        DAT0,	8,
                        DAT1,	8
                    }
                    Field(SMBX, ByteAcc, NoLock, Preserve) {
                        Offset(0x4),
                        DT2B,	16
                    }
                    OperationRegion(NSBS, EmbeddedControl, 0x40, 0x4)
                    Field(NSBS, ByteAcc, NoLock, Preserve) {
                        A2AD,	8,
                        A2D0,	8,
                        A2D1,	8,
                        A3AD,	8
                    }
                    Method(_INI) {
                        If(LNot(LGreater(\OSFG, \OSME))) {
                            Store(One, ECFL)
                        }
                    }
                    Method(_REG, 2) {
                        If(LEqual(Arg0, 0x3)) {
                            Store(Arg1, ECFL)
                        }
                    }
                    Method(_Q01) {
                        If(\_SB_.ATKP) {
                            Notify(\_SB_.ATKD, 0x52)
                        }
                    }
                    Method(_Q02) {
                        If(\_SB_.ATKP) {
                            Notify(\_SB_.ATKD, 0x53)
                        }
                    }
                    Method(_Q03) {
                        If(\_SB_.ATKP) {
                            Notify(\_SB_.ATKD, 0x54)
                        }
                    }
                    Method(_Q04) {
                        If(\_SB_.ATKP) {
                            Notify(\_SB_.ATKD, 0x55)
                        }
                    }
                    Method(_Q05) {
                        If(\_SB_.ATKP) {
                            Notify(\_SB_.ATKD, 0x56)
                        }
                    }
                    Method(_Q0A) {
                        If(\_SB_.ATKP) {
                            Notify(\_SB_.ATKD, 0x6c)
                        }
                    }
                    Method(_Q0B) {
                    }
                    Method(_Q0D) {
                        If(\_SB_.ATKP) {
                            Notify(\_SB_.ATKD, 0x6d)
                        }
                    }
                    Method(_Q0E) {
                        If(\ACPF) {
                            If(LGreater(LBTN, 0x0)) {
                                Decrement(LBTN)
                            }
                            If(LGreater(LBTN, 0xf)) {
                                Store(0xf, LBTN)
                            }
                            STBR()
                            If(\_SB_.ATKP) {
                                Notify(\_SB_.ATKD, Add(LBTN, 0x20, ))
                            }
                        }
                        Else {
                            If(LGreater(LBT2, 0x0)) {
                                Decrement(LBT2)
                            }
                            If(LGreater(LBT2, 0xf)) {
                                Store(0xf, LBT2)
                            }
                            STBR()
                            If(\_SB_.ATKP) {
                                Notify(\_SB_.ATKD, Add(LBT2, 0x20, ))
                            }
                        }
                    }
                    Method(_Q0F) {
                        If(\ACPF) {
                            If(LLess(LBTN, 0xf)) {
                                Increment(LBTN)
                            }
                            Else {
                                Store(0xf, LBTN)
                            }
                            STBR()
                            If(\_SB_.ATKP) {
                                Notify(\_SB_.ATKD, Add(LBTN, 0x10, ))
                            }
                        }
                        Else {
                            If(LLess(LBT2, 0xf)) {
                                Increment(LBT2)
                            }
                            Else {
                                Store(0xf, LBT2)
                            }
                            STBR()
                            If(\_SB_.ATKP) {
                                Notify(\_SB_.ATKD, Add(LBT2, 0x10, ))
                            }
                        }
                    }
                    Method(_Q10) {
                        Store(\BKLT, Local0)
                        XOr(Local0, 0x1, Local0)
                        Store(Local0, \BKLT)
                        If(\_SB_.ATKP) {
                            Subtract(0x34, \BKLT, Local0)
                            Notify(\_SB_.ATKD, Local0)
                        }
                    }
                    Method(_Q11) {
                        FHKW()
                        Store(\ADVG(), Local0)
                        If(\NATK()) {
                            Add(Local0, 0x34, Local1)
                            If(\_SB_.ATKP) {
                                Notify(\_SB_.ATKD, Local1)
                            }
                        }
                        Else {
                            \SWHG(Local0)
                        }
                        FHKS()
                    }
                    Name(FHKM, One)
                    Method(FHKW, 0, Serialized) {
                        While(LNot(FHKM)) {
                            Sleep(0xa)
                        }
                        Store(Zero, FHKM)
                    }
                    Method(FHKS, 0, Serialized) {
                        Store(One, FHKM)
                    }
                    Method(_Q13) {
                        If(\_SB_.ATKP) {
                            Notify(\_SB_.ATKD, 0x32)
                        }
                    }
                    Method(_Q14) {
                        If(LLess(\AVOL, 0xf)) {
                            Increment(\AVOL)
                        }
                        If(\_SB_.ATKP) {
                            Notify(\_SB_.ATKD, 0x31)
                        }
                    }
                    Method(_Q15) {
                        If(LGreater(\AVOL, 0x0)) {
                            Decrement(\AVOL)
                        }
                        If(\_SB_.ATKP) {
                            Notify(\_SB_.ATKD, 0x30)
                        }
                    }
                    Method(_Q20) {
                        If(CDFG) {
                            Store(One, SMBF)
                            Store(Zero, CDFG)
                        }
                        If(ALFG) {
                            Store(Zero, ALFG)
                        }
                    }
                    Method(_Q30) {
                        If(\_SB_.ATKP) {
                            Notify(\_SB_.ATKD, 0x50)
                        }
                    }
                    Method(_Q31) {
                        If(\_SB_.ATKP) {
                            Notify(\_SB_.ATKD, 0x51)
                        }
                    }
                    Method(_Q32) {
                        If(\_SB_.ATKP) {
                            Notify(\_SB_.ATKD, 0x52)
                        }
                    }
                    Method(_Q33) {
                        If(\_SB_.ATKP) {
                            Notify(\_SB_.ATKD, 0x5c)
                        }
                    }
                    Name(LEDS, Ones)
                    Method(EC0S, 1) {
                        If(LEqual(Arg0, 0x3)) {
                            STC5(0x2c)
                        }
                        If(Arg0) {
                            If(LLess(Arg0, 0x4)) {
                                Store(RDC3(0x2), Local0)
                                And(Local0, 0xe0, LEDS)
                                And(LEDS, 0x80, Local1)
                                If(LNot(Local1)) {
                                    STC5(0x2f)
                                }
                                And(LEDS, 0x40, Local1)
                                If(LNot(Local1)) {
                                    STC5(0x2e)
                                }
                                And(LEDS, 0x20, Local1)
                                If(LNot(Local1)) {
                                    STC5(0x2d)
                                }
                                WCMD(0xcb)
                                Store(0x01f4, Local0)
                                While(Local0) {
                                    Stall(0xa)
                                    Decrement(Local0)
                                }
                            }
                        }
                    }
                    Method(EC0W, 1) {
                        If(LEqual(Arg0, 0x3)) {
                            STC5(0x4c)
                        }
                        If(LNot(LGreater(Arg0, 0x4))) {
                            Store(ACAP(), \ACPF)
                        }
                        If(Arg0) {
                            If(LLess(Arg0, 0x4)) {
                                And(LEDS, 0x80, Local1)
                                If(LNot(Local1)) {
                                    STC5(0x4f)
                                }
                                And(LEDS, 0x40, Local1)
                                If(LNot(Local1)) {
                                    STC5(0x4e)
                                }
                                And(LEDS, 0x20, Local1)
                                If(LNot(Local1)) {
                                    STC5(0x4d)
                                }
                            }
                        }
                    }
                }
            }
            Scope(\_SB_.PCI0.SBRG.EC0_) {
                Method(WCMD, 1, Serialized) {
                    If(ECAV()) {
                        If(LEqual(Acquire(MUEC, 0xffff), 0x0)) {
                            Store(Arg0, CMD1)
                            Release(MUEC)
                        }
                    }
                    Else {
                        If(LEqual(Acquire(MUEC, 0xffff), 0x0)) {
                            ECWC(Arg0)
                            Release(MUEC)
                        }
                    }
                }
                Method(DLY0, 1, Serialized) {
                    If(LNot(ECAV())) {
                        Return(Ones)
                    }
                    Store(Ones, Local0)
                    If(LEqual(Acquire(MUEC, 0xffff), 0x0)) {
                        Store(Arg0, CDT1)
                        Store(0x6b, CDT2)
                        Store(0x0, CDT3)
                        Store(0xbb, CMD1)
                        Store(0x7f, Local1)
                        While(LAnd(Local1, CMD1)) {
                            Sleep(0x1)
                            Decrement(Local1)
                        }
                        If(LEqual(CMD1, Zero)) {
                            Store(CDT1, Local0)
                        }
                        Release(MUEC)
                    }
                    Return(Local0)
                }
                Name(PWAC, Buffer(0x10) {0x3, 0x13, 0x16, 0x19, 0x1c, 0x1f, 0x22, 0x25, 0x28, 0x2b, 0x2e, 0x31, 0x34, 0x37, 0x3a, 0x3d })
                Alias(PWAC, PWDC)
                Method(STBR, 0, Serialized) {
                    If(ACAP()) {
                        Store(DerefOf(Index(PWAC, LBTN, )), Local0)
                    }
                    Else {
                        Store(DerefOf(Index(PWDC, LBT2, )), Local0)
                    }
                    STDC(Local0)
                }
                Method(STDA, 1, Serialized) {
                    If(ECAV()) {
                        If(LEqual(Acquire(MUEC, 0xffff), 0x0)) {
                            Store(Arg0, CDT1)
                            Store(0xd0, CDT2)
                            Store(0xda, CMD1)
                            Store(0x7f, Local0)
                            While(LAnd(Local0, CMD1)) {
                                Sleep(0x1)
                                Decrement(Local0)
                            }
                            If(LEqual(CMD1, Zero)) {
                                Store(CDT1, Local0)
                            }
                            Else {
                                Store(Ones, Local0)
                            }
                            Release(MUEC)
                            Return(Local0)
                        }
                    }
                    Return(Ones)
                }
                Method(STDC, 1, Serialized) {
                    If(ECAV()) {
                        If(LEqual(Acquire(MUEC, 0xffff), 0x0)) {
                            Store(Arg0, CDT1)
                            Store(0xd0, CDT2)
                            Store(0xdc, CMD1)
                            Store(0x7f, Local0)
                            While(LAnd(Local0, CMD1)) {
                                Sleep(0x1)
                                Decrement(Local0)
                            }
                            If(LEqual(CMD1, Zero)) {
                                Store(CDT1, Local0)
                            }
                            Else {
                                Store(Ones, Local0)
                            }
                            Release(MUEC)
                            Return(Local0)
                        }
                    }
                    Return(Ones)
                }
                Method(ACAP, 0, Serialized) {
                    Return(\ACPF)
                }
                Method(ACPS, 0, Serialized) {
                    If(ECAV()) {
                        Store(RDC3(0x6), Local0)
                        While(LEqual(Local0, Ones)) {
                            Store(RDC3(0x6), Local0)
                        }
                        And(Local0, 0x10, Local0)
                        ShiftRight(Local0, 0x4, Local0)
                        XOr(Local0, 0x1, Local0)
                        Return(Local0)
                    }
                    Else {
                        If(LEqual(Acquire(MUEC, 0xffff), 0x0)) {
                            Store(ECRP(0x6), Local0)
                            ShiftRight(Local0, 0x4, Local0)
                            And(Local0, 0x1, Local0)
                            XOr(Local0, 0x1, Local0)
                            Release(MUEC)
                            Return(Local0)
                        }
                    }
                }
                Method(BATP, 1, Serialized) {
                    If(Arg0) {
                        Return(\DCP2)
                    }
                    Else {
                        Return(\DCPF)
                    }
                }
                Method(DCPS, 1, Serialized) {
                    If(ECAV()) {
                        If(Arg0) {
                            Store(RDC3(0x4), Local0)
                            While(LEqual(Local0, Ones)) {
                                Store(RDC3(0x4), Local0)
                            }
                            And(Local0, 0x8, Local0)
                        }
                        Else {
                            Store(RDC3(0x5), Local0)
                            While(LEqual(Local0, Ones)) {
                                Store(RDC3(0x5), Local0)
                            }
                            And(Local0, 0x20, Local0)
                        }
                        If(Local0) {
                            Return(Zero)
                        }
                        Else {
                            Return(One)
                        }
                    }
                    Else {
                        If(LEqual(Acquire(MUEC, 0xffff), 0x0)) {
                            If(Arg0) {
                                Store(ECRP(0x4), Local0)
                                ShiftRight(Local0, 0x3, Local0)
                            }
                            Else {
                                Store(ECRP(0x5), Local0)
                                ShiftRight(Local0, 0x5, Local0)
                            }
                            And(Local0, 0x1, Local0)
                            Release(MUEC)
                            If(Local0) {
                                Return(Zero)
                            }
                            Else {
                                Return(One)
                            }
                        }
                    }
                }
                Method(CHGS, 1, Serialized) {
                    Store(RBAT(0x1, Arg0), Local0)
                    If(LEqual(Local0, Ones)) {
                        Return(\ACPF)
                    }
                    ShiftRight(Local0, 0x7, Local0)
                    And(Local0, 0x1, Local0)
                    Return(Local0)
                }
                Method(STC5, 1, Serialized) {
                    If(ECAV()) {
                        If(LEqual(Acquire(MUEC, 0xffff), 0x0)) {
                            Store(Arg0, CDT1)
                            Store(0xc5, CMD1)
                            Store(0x7f, Local0)
                            While(LAnd(Local0, CMD1)) {
                                Sleep(0x1)
                                Decrement(Local0)
                            }
                            If(LEqual(CMD1, Zero)) {
                                Store(CDT1, Local0)
                            }
                            Else {
                                Store(Ones, Local0)
                            }
                            Release(MUEC)
                            Return(Local0)
                        }
                    }
                    Else {
                        If(LEqual(Acquire(MUEC, 0xffff), 0x0)) {
                            ECSP(Arg0)
                            Release(MUEC)
                            Return(One)
                        }
                    }
                    Return(Ones)
                }
                Method(RDC3, 1, Serialized) {
                    If(ECAV()) {
                        If(LEqual(Acquire(MUEC, 0xffff), 0x0)) {
                            Store(Arg0, CDT1)
                            Store(0xc3, CMD1)
                            Store(0x7f, Local0)
                            While(LAnd(Local0, CMD1)) {
                                Sleep(0x1)
                                Decrement(Local0)
                            }
                            If(LEqual(CMD1, Zero)) {
                                Store(CDT1, Local0)
                            }
                            Else {
                                Store(Ones, Local0)
                            }
                            Release(MUEC)
                            Return(Local0)
                        }
                    }
                    Else {
                        If(LEqual(Acquire(MUEC, 0xffff), 0x0)) {
                            Store(ECRP(Arg0), Local0)
                            Release(MUEC)
                            Return(Local0)
                        }
                    }
                    Return(Ones)
                }
                Method(RBAT, 2, Serialized) {
                    If(LNot(ECAV())) {
                        Return(Ones)
                    }
                    If(LEqual(Acquire(MUEC, 0xffff), 0x0)) {
                        Store(0x3, Local0)
                        While(Local0) {
                            Store(Arg0, CDT2)
                            Store(Arg1, Local1)
                            ShiftLeft(Local1, 0x1, Local1)
                            Add(Local1, 0xda, Local1)
                            Store(Local1, CMD1)
                            Store(0x7f, Local1)
                            While(LAnd(CMD1, Local1)) {
                                Decrement(Local1)
                                Sleep(0x1)
                            }
                            If(LEqual(CMD1, 0x0)) {
                                Store(CDT1, Local1)
                                Store(Zero, Local0)
                            }
                            Else {
                                Store(Ones, Local1)
                                Decrement(Local0)
                            }
                        }
                        Release(MUEC)
                        Return(Local1)
                    }
                    Return(Ones)
                }
                Method(FNCT, 2, Serialized) {
                    If(ECAV()) {
                        If(LEqual(Acquire(MUEC, 0xffff), 0x0)) {
                            Store(Arg0, CDT2)
                            Store(Arg1, CDT1)
                            Store(0xc4, CMD1)
                            Store(0x7f, Local0)
                            While(LAnd(Local0, CMD1)) {
                                Sleep(0x1)
                                Decrement(Local0)
                            }
                            Release(MUEC)
                        }
                    }
                }
                Name(WRQK, 0x2)
                Name(RDQK, 0x3)
                Name(SDBT, 0x4)
                Name(RCBT, 0x5)
                Name(WRBT, 0x6)
                Name(RDBT, 0x7)
                Name(WRWD, 0x8)
                Name(RDWD, 0x9)
                Name(WRBL, 0xa)
                Name(RDBL, 0xb)
                Name(PCLL, 0xc)
                Name(GOOD, 0x0)
                Name(UKER, 0x7)
                Name(DAER, 0x10)
                Name(CMDN, 0x12)
                Name(UKE2, 0x13)
                Name(DADN, 0x17)
                Name(SBTO, 0x18)
                Name(USPT, 0x19)
                Name(SBBY, 0x1a)
                Method(SWTC, 1) {
                    Store(UKER, Local0)
                    Store(Arg0, Local1)
                    And(Local1, 0xffff, Local1)
                    While(Local1) {
                        If(LEqual(SMBF, 0x0)) {
                            Sleep(0xa)
                            If(LNot(LEqual(Local1, 0xffff))) {
                                Subtract(Local1, 0xa, Local1)
                            }
                        }
                        Else {
                            Store(Zero, Local1)
                            Store(SSTS, Local0)
                            Store(Zero, SMBF)
                        }
                    }
                    Return(Local0)
                }
                Method(SMBR, 3) {
                    Store(Package(0x3) {
                        0x7,
                        0x0,
                        0x0,
                    }, Local0)
                    If(LNot(ECAV())) {
                        Return(Local0)
                    }
                    If(LNot(LEqual(Arg0, RDBL))) {
                        If(LNot(LEqual(Arg0, RDWD))) {
                            If(LNot(LEqual(Arg0, RDBT))) {
                                If(LNot(LEqual(Arg0, RCBT))) {
                                    If(LNot(LEqual(Arg0, RDQK))) {
                                        Return(Local0)
                                    }
                                }
                            }
                        }
                    }
                    If(LEqual(Acquire(MUEC, 0xffff), 0x0)) {
                        Store(PRTC, Local1)
                        Store(Zero, Local2)
                        While(LNot(LEqual(Local1, 0x0))) {
                            Stall(0xa)
                            Increment(Local2)
                            If(LGreater(Local2, 0x03e8)) {
                                Store(SBBY, Index(Local0, 0x0, ))
                                Store(Zero, Local1)
                            }
                            Else {
                                Store(PRTC, Local1)
                            }
                        }
                        If(LNot(LGreater(Local2, 0x03e8))) {
                            ShiftLeft(Arg1, 0x1, Local3)
                            Or(Local3, 0x1, Local3)
                            Store(Local3, ADDR)
                            If(LNot(LEqual(Arg0, RDQK))) {
                                If(LNot(LEqual(Arg0, RCBT))) {
                                    Store(Arg2, CMDB)
                                }
                            }
                            Store(Arg0, PRTC)
                            Store(SWTC(0x07d0), Index(Local0, 0x0, ))
                            If(LEqual(DerefOf(Index(Local0, 0x0, )), 0x0)) {
                                If(LEqual(Arg0, RDBL)) {
                                    Store(BCNT, Index(Local0, 0x1, ))
                                    Store(BDAT, Index(Local0, 0x2, ))
                                }
                                If(LEqual(Arg0, RDWD)) {
                                    Store(0x2, Index(Local0, 0x1, ))
                                    Store(DT2B, Index(Local0, 0x2, ))
                                }
                                If(LEqual(Arg0, RDBT)) {
                                    Store(0x1, Index(Local0, 0x1, ))
                                    Store(DAT0, Index(Local0, 0x2, ))
                                }
                                If(LEqual(Arg0, RCBT)) {
                                    Store(0x1, Index(Local0, 0x1, ))
                                    Store(DAT0, Index(Local0, 0x2, ))
                                }
                            }
                        }
                        Release(MUEC)
                    }
                    Return(Local0)
                }
                Method(SMBW, 5) {
                    Store(Package(0x1) {
                        0x7,
                    }, Local0)
                    If(LNot(ECAV())) {
                        Return(Local0)
                    }
                    If(LNot(LEqual(Arg0, WRBL))) {
                        If(LNot(LEqual(Arg0, WRWD))) {
                            If(LNot(LEqual(Arg0, WRBT))) {
                                If(LNot(LEqual(Arg0, SDBT))) {
                                    If(LNot(LEqual(Arg0, WRQK))) {
                                        Return(Local0)
                                    }
                                }
                            }
                        }
                    }
                    If(LEqual(Acquire(MUEC, 0xffff), 0x0)) {
                        Store(PRTC, Local1)
                        Store(Zero, Local2)
                        While(LNot(LEqual(Local1, 0x0))) {
                            Stall(0xa)
                            Increment(Local2)
                            If(LGreater(Local2, 0x03e8)) {
                                Store(SBBY, Index(Local0, 0x0, ))
                                Store(Zero, Local1)
                            }
                            Else {
                                Store(PRTC, Local1)
                            }
                        }
                        If(LNot(LGreater(Local2, 0x03e8))) {
                            ShiftLeft(Arg1, 0x1, Local3)
                            Store(Local3, ADDR)
                            If(LNot(LEqual(Arg0, WRQK))) {
                                If(LNot(LEqual(Arg0, SDBT))) {
                                    Store(Arg2, CMDB)
                                }
                            }
                            If(LEqual(Arg0, WRBL)) {
                                Store(Arg3, BCNT)
                                Store(Arg4, BDAT)
                            }
                            If(LEqual(Arg0, WRWD)) {
                                Store(Arg4, DT2B)
                            }
                            If(LEqual(Arg0, WRBT)) {
                                Store(Arg4, DAT0)
                            }
                            If(LEqual(Arg0, SDBT)) {
                                Store(Arg4, DAT0)
                            }
                            Store(Arg0, PRTC)
                            Store(SWTC(0x07d0), Index(Local0, 0x0, ))
                        }
                        Release(MUEC)
                    }
                    Return(Local0)
                }
                OperationRegion(K62P, SystemIO, 0x62, 0x1)
                Field(K62P, ByteAcc, NoLock, Preserve) {
                    EC62,	8
                }
                OperationRegion(K66P, SystemIO, 0x66, 0x1)
                Field(K66P, ByteAcc, NoLock, Preserve) {
                    EC66,	8
                }
                Alias(\G12E, KSCE)
                Alias(\G12S, KSCS)
                Method(WEIE) {
                    Store(0x4000, Local0)
                    And(EC66, 0x2, Local1)
                    While(LAnd(LNot(LEqual(Local0, Zero)), LEqual(Local1, 0x2))) {
                        And(EC66, 0x2, Local1)
                        Decrement(Local0)
                    }
                }
                Method(WEOF) {
                    Store(0x4000, Local0)
                    And(EC66, 0x1, Local1)
                    While(LAnd(LNot(LEqual(Local0, Zero)), LEqual(Local1, 0x0))) {
                        And(EC66, 0x1, Local1)
                        Decrement(Local0)
                    }
                }
                Method(ECRD, 1) {
                    Store(KSCE, Local1)
                    Store(Zero, KSCE)
                    WEIE()
                    Store(0x80, EC66)
                    WEIE()
                    Store(Arg0, EC62)
                    WEOF()
                    Store(EC62, Local0)
                    While(KSCS) {
                        Store(One, KSCS)
                    }
                    Store(Local1, KSCE)
                    Return(Local0)
                }
                Method(ECWR, 2) {
                    Store(KSCE, Local1)
                    Store(Zero, KSCE)
                    WEIE()
                    Store(0x81, EC66)
                    WEIE()
                    Store(Arg0, EC62)
                    WEIE()
                    Store(Arg1, EC62)
                    WEIE()
                    While(KSCS) {
                        Store(One, KSCS)
                    }
                    Store(Local1, KSCE)
                }
                Method(ECWC, 1) {
                    Store(KSCE, Local1)
                    Store(Zero, KSCE)
                    WEIE()
                    Store(0x81, EC66)
                    WEIE()
                    Store(0x4, EC62)
                    WEIE()
                    Store(Arg0, EC62)
                    While(KSCS) {
                        Store(One, KSCS)
                    }
                    Store(Local1, KSCE)
                }
                Method(ECQR) {
                    Store(KSCE, Local1)
                    Store(Zero, KSCE)
                    WEIE()
                    Store(0x84, EC66)
                    WEIE()
                    WEOF()
                    Store(EC62, Local0)
                    While(KSCS) {
                        Store(One, KSCS)
                    }
                    Store(Local1, KSCE)
                    Return(Local0)
                }
                Method(ECRP, 1) {
                    ECWR(0x5, Arg0)
                    ECWR(0x4, 0xc3)
                    While(ECRD(0x4)) {
                    }
                    Return(ECRD(0x5))
                }
                Method(ECSP, 1) {
                    ECWR(0x5, Arg0)
                    ECWR(0x4, 0xc5)
                    While(ECRD(0x4)) {
                    }
                }
            }
            Scope(\_SB_.PCI0.SBRG.EC0_) {
                Method(_Q69) {
                    If(\_SB_.ATKP) {
                        Notify(\_SB_.ATKD, 0x40)
                    }
                }
                Method(_Q6A) {
                    If(\_SB_.ATKP) {
                        Notify(\_SB_.ATKD, 0x41)
                    }
                }
                Method(_Q6B) {
                    If(\_SB_.ATKP) {
                        Notify(\_SB_.ATKD, 0x43)
                    }
                }
                Method(_Q6C) {
                    If(\_SB_.ATKP) {
                        Notify(\_SB_.ATKD, 0x45)
                    }
                }
            }
            Scope(\_SB_.PCI0) {
                Name(ACWA, 0x0)
                Device(AC0_) {
                    Name(_HID, "ACPI0003")
                    Method(_PSR) {
                        Return(\_SB_.PCI0.SBRG.EC0_.ACAP())
                    }
                    Name(_PCL, Package(0x1) {
                        \_SB_.PCI0,
                    })
                }
            }
            Scope(\_SB_.PCI0.SBRG.EC0_) {
                Method(_Q34) {
                    If(ACPS()) {
                        Store(0x2, ACWA)
                        Store(One, \ACPF)
                        Store(0x58, Local0)
                    }
                    Else {
                        Store(Zero, \ACPF)
                        Store(0x57, Local0)
                    }
                    If(LEqual(Acquire(MUEC, 0xffff), 0x0)) {
                        XOr(P64S, 0x10, P64S)
                        Release(MUEC)
                    }
                    STBR()
                    Notify(\_SB_.PCI0.AC0_, 0x80)
                    NBAT(0x80)
                    \_SB_.PCI0.SBRG.C4C3()
                    If(\_SB_.ATKP) {
                        Notify(\_SB_.ATKD, Local0)
                    }
                    Notify(\_PR_.CPU1, 0x80)
                    Notify(\_PR_.CPU1, 0x81)
                }
            }
            Scope(\_SB_.PCI0) {
                Name(SCIV, 0x0140)
                Name(SENR, 0x14)
                Name(VSBF, 0x38)
                Name(DVOT, 0xe)
                Method(VSRC, 1) {
                    And(Arg0, 0xffff, Local0)
                    And(Local0, 0x8000, Local1)
                    If(Local1) {
                        Not(Local0, Local0)
                        And(Local0, 0xffff, Local0)
                        Add(Local0, 0x1, Local0)
                    }
                    Multiply(Local0, 0x03e8, Local0)
                    Multiply(0x8, SENR, Local1)
                    Divide(Local0, Local1, Local2, Local3)
                    Multiply(Local3, DVOT, Local3)
                    Return(Local3)
                }
                Method(PFCC, 1) {
                    Store(Arg0, Local0)
                    Multiply(Local0, 0x03e8, Local0)
                    Multiply(SCIV, SENR, Local1)
                    Divide(Local0, Local1, Local2, Local3)
                    Multiply(Local3, DVOT, Local3)
                    Return(Local3)
                }
                Method(PFCS, 1) {
                    Store(\_SB_.PCI0.SBRG.EC0_.RBAT(0x7, Arg0), Local0)
                    Store(\_SB_.PCI0.SBRG.EC0_.RBAT(0x8, Arg0), Local1)
                    And(Local0, 0x8, Local2)
                    And(Local0, 0x4, Local3)
                    And(Local1, 0x4, Local4)
                    If(Local2) {
                        If(Local3) {
                            Return(0x0140)
                        }
                        If(Local4) {
                            Return(0x50)
                        }
                        Return(0xa0)
                    }
                    Else {
                        If(Local3) {
                            Return(0x0a00)
                        }
                        If(Local4) {
                            Return(0x0280)
                        }
                        Return(0x0500)
                    }
                }
                Device(BAT0) {
                    Name(_HID, 0x0a0cd041)
                    Name(_UID, 0x0)
                    Name(_PCL, Package(0x1) {
                        \_SB_.PCI0,
                    })
                    Method(_STA) {
                        If(\_SB_.PCI0.SBRG.EC0_.BATP(0x0)) {
                            Return(0x1f)
                        }
                        Else {
                            Return(0xf)
                        }
                    }
                    Name(CAPD, 0xdac0)
                    Name(CAPG, 0x0118)
                    Name(NBIF, Package(0xd) {
                        0x0,
                        0xffffffff,
                        0xffffffff,
                        0x1,
                        0xffffffff,
                        0xffffffff,
                        0xffffffff,
                        0xffffffff,
                        0xffffffff,
                        " ",
                        " ",
                        " ",
                        " ",
                    })
                    Name(PBIF, Package(0xd) {
                        0x0,
                        0xdac0,
                        0xdac0,
                        0x1,
                        0x36b0,
                        0x15e0,
                        0x0af0,
                        0x1c,
                        0x050a,
                        "L3000",
                        " ",
                        "LIon",
                        "ASUSTeK",
                    })
                    Method(_BIF) {
                        If(LNot(\_SB_.PCI0.SBRG.EC0_.BATP(0x0))) {
                            Return(NBIF)
                        }
                        Store(\MNAM, Index(PBIF, 0x9, ))
                        Store("", Index(PBIF, 0x9, ))
                        Store("Build-in battery                                                                                     ", Index(PBIF, 0xa, ))
                        Store(\ONAM, Index(PBIF, 0xc, ))
                        Store(PFCS(0x0), SCIV)
                        Store(\_SB_.PCI0.SBRG.EC0_.RBAT(0x5, 0x0), Local0)
                        If(LNot(LEqual(Local0, Ones))) {
                            ShiftLeft(Local0, 0x8, Local0)
                            Store(PFCC(Local0), Local0)
                            Store(Local0, CAPD)
                            Store(Local0, Index(PBIF, 0x1, ))
                            Store(Local0, Index(PBIF, 0x2, ))
                            Divide(Local0, 0xa, Local1, Local2)
                            Store(Local2, Index(PBIF, 0x5, ))
                            Subtract(Local0, Local2, Local3)
                            Store(Local3, Index(PBIF, 0x7, ))
                            Divide(Local0, 0x14, Local1, Local2)
                            Store(Local2, Index(PBIF, 0x6, ))
                            Subtract(Local3, Local2, Local3)
                            Store(Local3, Index(PBIF, 0x8, ))
                            Divide(Local0, 0xc8, Local1, CAPG)
                        }
                        Return(PBIF)
                    }
                    Name(PBST, Package(0x4) {
                        0x0,
                        0x8000,
                        0x8000,
                        0x36b0,
                    })
                    Method(_BST) {
                        If(LNot(\_SB_.PCI0.SBRG.EC0_.BATP(0x0))) {
                            Store(Zero, Index(PBST, 0x0, ))
                            Store(Ones, Index(PBST, 0x1, ))
                            Store(Ones, Index(PBST, 0x2, ))
                            Store(Ones, Index(PBST, 0x3, ))
                            Return(PBST)
                        }
                        If(\MES4) {
                            Decrement(\MES4)
                            Return(PBST)
                        }
                        Store(One, Local0)
                        If(\_SB_.PCI0.SBRG.EC0_.ACAP()) {
                            If(\_SB_.PCI0.SBRG.EC0_.CHGS(0x0)) {
                                Store(0x2, Local0)
                            }
                        }
                        If(ACWA) {
                            Store(0x2, Local0)
                            Decrement(ACWA)
                        }
                        Store(Local0, Index(PBST, 0x0, ))
                        Store(\_SB_.PCI0.SBRG.EC0_.RBAT(0x12, 0x0), Local1)
                        If(LNot(LEqual(Local1, Ones))) {
                            Store(\_SB_.PCI0.SBRG.EC0_.RBAT(0x13, 0x0), Local2)
                            If(LNot(LEqual(Local2, Ones))) {
                                And(Local1, 0xff, Local1)
                                And(Local2, 0xff, Local2)
                                ShiftLeft(Local1, 0x8, Local1)
                                Add(Local1, Local2, Local1)
                                Store(VSRC(Local1), Index(PBST, 0x1, ))
                                If(LEqual(Local1, Zero)) {
                                    If(\_SB_.PCI0.SBRG.EC0_.ACAP()) {
                                        Store(Zero, Index(PBST, 0x0, ))
                                    }
                                }
                            }
                        }
                        Store(\_SB_.PCI0.SBRG.EC0_.RBAT(0x3, 0x0), Local1)
                        If(LNot(LEqual(Local1, Ones))) {
                            Store(\_SB_.PCI0.SBRG.EC0_.RBAT(0x17, 0x0), Local2)
                            If(LNot(LEqual(Local2, Ones))) {
                                And(Local1, 0xff, Local1)
                                And(Local2, 0xff, Local2)
                                ShiftLeft(Local1, 0x8, Local1)
                                Add(Local1, Local2, Local1)
                                Store(PFCC(Local1), Local2)
                                If(LLess(Local2, CAPD)) {
                                    Subtract(CAPD, Local2, Local3)
                                    If(LLess(Local3, CAPG)) {
                                        Store(CAPD, Local2)
                                    }
                                }
                                Store(Local2, Index(PBST, 0x2, ))
                            }
                        }
                        Store(\_SB_.PCI0.SBRG.EC0_.RBAT(0xb, 0x0), Local1)
                        If(LNot(LEqual(Local1, Ones))) {
                            Multiply(Local1, VSBF, Local1)
                            Store(Local1, Index(PBST, 0x3, ))
                        }
                        Store(DerefOf(Index(PBST, 0x1, )), Local1)
                        Store(DerefOf(Index(PBST, 0x2, )), Local2)
                        Divide(Local2, 0xa, Local3, Local4)
                        If(LLess(Local1, Local4)) {
                            Store(Local4, Index(PBST, 0x1, ))
                        }
                        Return(PBST)
                    }
                }
                Device(BAT1) {
                    Name(_HID, 0x0a0cd041)
                    Name(_UID, 0x1)
                    Name(_PCL, Package(0x1) {
                        \_SB_.PCI0,
                    })
                    Method(_STA) {
                        If(\_SB_.PCI0.SBRG.EC0_.BATP(0x1)) {
                            Return(0x1f)
                        }
                        Else {
                            Return(0xf)
                        }
                    }
                    Name(SCIV, 0x0140)
                    Method(PFCC, 1) {
                        Store(Arg0, Local0)
                        Multiply(Local0, 0x03e8, Local0)
                        Multiply(SCIV, SENR, Local1)
                        Divide(Local0, Local1, Local2, Local3)
                        Multiply(Local3, DVOT, Local3)
                        Return(Local3)
                    }
                    Name(CAPD, 0xdac0)
                    Name(CAPG, 0x0118)
                    Name(NBIF, Package(0xd) {
                        0x0,
                        0xffffffff,
                        0xffffffff,
                        0x1,
                        0xffffffff,
                        0xffffffff,
                        0xffffffff,
                        0xffffffff,
                        0xffffffff,
                        " ",
                        " ",
                        " ",
                        " ",
                    })
                    Name(PBIF, Package(0xd) {
                        0x0,
                        0xdac0,
                        0xdac0,
                        0x1,
                        0x36b0,
                        0x15e0,
                        0x0af0,
                        0x1c,
                        0x050a,
                        "L3000",
                        " ",
                        "LIon",
                        "ASUSTeK",
                    })
                    Method(_BIF) {
                        If(LNot(\_SB_.PCI0.SBRG.EC0_.BATP(0x1))) {
                            Return(NBIF)
                        }
                        Store(\MNAM, Index(PBIF, 0x9, ))
                        Store("", Index(PBIF, 0x9, ))
                        Store(\_SB_.PCI0.SBRG.EC0_.RBAT(0x8, 0x1), Local0)
                        And(Local0, 0x2, Local0)
                        If(Local0) {
                            Store("BN-LL22                                                                                              ", Index(PBIF, 0xa, ))
                        }
                        Else {
                            Store("BN-LS11/LS12                                                                                         ", Index(PBIF, 0xa, ))
                        }
                        Store(\ONAM, Index(PBIF, 0xc, ))
                        Store(PFCS(0x1), SCIV)
                        Store(\_SB_.PCI0.SBRG.EC0_.RBAT(0x5, 0x1), Local0)
                        If(LNot(LEqual(Local0, Ones))) {
                            ShiftLeft(Local0, 0x8, Local0)
                            Store(PFCC(Local0), Local0)
                            Store(Local0, CAPD)
                            Store(Local0, Index(PBIF, 0x1, ))
                            Store(Local0, Index(PBIF, 0x2, ))
                            Divide(Local0, 0xa, Local1, Local2)
                            Store(Local2, Index(PBIF, 0x5, ))
                            Subtract(Local0, Local2, Local3)
                            Store(Local3, Index(PBIF, 0x7, ))
                            Divide(Local0, 0x14, Local1, Local2)
                            Store(Local2, Index(PBIF, 0x6, ))
                            Subtract(Local3, Local2, Local3)
                            Store(Local3, Index(PBIF, 0x8, ))
                            Divide(Local0, 0xc8, Local1, CAPG)
                        }
                        Return(PBIF)
                    }
                    Name(PBST, Package(0x4) {
                        0x0,
                        0x8000,
                        0x8000,
                        0x36b0,
                    })
                    Method(_BST) {
                        If(LNot(\_SB_.PCI0.SBRG.EC0_.BATP(0x1))) {
                            Store(Zero, Index(PBST, 0x0, ))
                            Store(Ones, Index(PBST, 0x1, ))
                            Store(Ones, Index(PBST, 0x2, ))
                            Store(Ones, Index(PBST, 0x3, ))
                            Return(PBST)
                        }
                        If(\MES4) {
                            Decrement(\MES4)
                            Return(PBST)
                        }
                        Store(One, Local0)
                        If(\_SB_.PCI0.SBRG.EC0_.ACAP()) {
                            If(\_SB_.PCI0.SBRG.EC0_.CHGS(0x1)) {
                                Store(0x2, Local0)
                            }
                        }
                        Store(Local0, Index(PBST, 0x0, ))
                        Store(\_SB_.PCI0.SBRG.EC0_.RBAT(0x12, 0x1), Local1)
                        If(LNot(LEqual(Local1, Ones))) {
                            Store(\_SB_.PCI0.SBRG.EC0_.RBAT(0x13, 0x1), Local2)
                            If(LNot(LEqual(Local2, Ones))) {
                                And(Local1, 0xff, Local1)
                                And(Local2, 0xff, Local2)
                                ShiftLeft(Local1, 0x8, Local1)
                                Add(Local1, Local2, Local1)
                                Store(VSRC(Local1), Index(PBST, 0x1, ))
                                If(LEqual(Local1, Zero)) {
                                    If(\_SB_.PCI0.SBRG.EC0_.ACAP()) {
                                        Store(Zero, Index(PBST, 0x0, ))
                                    }
                                }
                            }
                        }
                        Store(\_SB_.PCI0.SBRG.EC0_.RBAT(0x3, 0x1), Local1)
                        If(LNot(LEqual(Local1, Ones))) {
                            Store(\_SB_.PCI0.SBRG.EC0_.RBAT(0x17, 0x1), Local2)
                            If(LNot(LEqual(Local2, Ones))) {
                                And(Local1, 0xff, Local1)
                                And(Local2, 0xff, Local2)
                                ShiftLeft(Local1, 0x8, Local1)
                                Add(Local1, Local2, Local1)
                                Store(PFCC(Local1), Local2)
                                If(LLess(Local2, CAPD)) {
                                    Subtract(CAPD, Local2, Local3)
                                    If(LLess(Local3, CAPG)) {
                                        Store(CAPD, Local2)
                                    }
                                }
                                Store(Local2, Index(PBST, 0x2, ))
                            }
                        }
                        Store(\_SB_.PCI0.SBRG.EC0_.RBAT(0xb, 0x1), Local1)
                        If(LNot(LEqual(Local1, Ones))) {
                            Multiply(Local1, VSBF, Local1)
                            Store(Local1, Index(PBST, 0x3, ))
                        }
                        Return(PBST)
                    }
                }
            }
            Scope(\_SB_.PCI0.SBRG.EC0_) {
                Method(_Q2F) {
                    If(LNot(DCPS(0x0))) {
                        Store(Zero, \DCPF)
                        If(LEqual(Acquire(MUEC, 0xffff), 0x0)) {
                            And(P55S, 0xef, P55S)
                            Release(MUEC)
                        }
                    }
                    Else {
                        Store(One, \DCPF)
                        If(LEqual(Acquire(MUEC, 0xffff), 0x0)) {
                            Or(P55S, 0x10, P55S)
                            Release(MUEC)
                        }
                    }
                    Notify(\_SB_.PCI0.BAT0, 0x1)
                    Notify(\_SB_.PCI0.BAT0, 0x81)
                    Notify(\_SB_.PCI0.AC0_, 0x80)
                }
                Method(_Q51) {
                    If(LNot(DCPS(0x1))) {
                        Store(Zero, \DCP2)
                        If(LEqual(Acquire(MUEC, 0xffff), 0x0)) {
                            And(P43S, 0xef, P43S)
                            Release(MUEC)
                        }
                    }
                    Else {
                        Store(One, \DCP2)
                        If(LEqual(Acquire(MUEC, 0xffff), 0x0)) {
                            Or(P43S, 0x10, P43S)
                            Release(MUEC)
                        }
                    }
                    Notify(\_SB_.PCI0.BAT1, 0x1)
                    Notify(\_SB_.PCI0.BAT1, 0x81)
                    Notify(\_SB_.PCI0.AC0_, 0x80)
                }
                Method(_Q50) {
                    If(\_SB_.ATKP) {
                        Notify(\_SB_.ATKD, 0x6e)
                    }
                    Else {
                        If(BATP(0x0)) {
                            Notify(\_SB_.PCI0.BAT0, 0x80)
                        }
                        If(BATP(0x1)) {
                            Notify(\_SB_.PCI0.BAT1, 0x80)
                        }
                    }
                }
                Method(NBAT, 1) {
                    If(BATP(0x0)) {
                        Notify(\_SB_.PCI0.BAT0, Arg0)
                    }
                    If(BATP(0x1)) {
                        Notify(\_SB_.PCI0.BAT1, Arg0)
                    }
                }
            }
            Scope(\_SB_) {
                Device(SLPB) {
                    Name(_HID, 0x0c0cd041)
                    Method(_PRW) {
                        Return(Package(0x2) {
                            0xa,
                            0x4,
                        })
                    }
                }
            }
            Scope(\_GPE) {
                Method(_L0A) {
                }
            }
            Scope(\_SB_) {
                Device(LID_) {
                    Name(_HID, 0x0d0cd041)
                    Method(_LID) {
                        Return(\LIDL)
                    }
                }
            }
            Scope(\_GPE) {
                Method(_L1B, 0, Serialized) {
                    XOr(\LIDL, 0x1, \LIDL)
                    Notify(\_SB_.LID_, 0x80)
                }
            }
            Scope(\) {
                OperationRegion(SMB0, SystemIO, SMBS, 0x10)
                Field(SMB0, ByteAcc, NoLock, Preserve) {
                    HSTS,	8,
                    SSTS,	8,
                    HSTC,	8,
                    HCMD,	8,
                    HADR,	8,
                    HDT0,	8,
                    HDT1,	8,
                    BLKD,	8,
                    SLCT,	8,
                    SHCM,	8,
                    SLEV,	16,
                    SLDT,	16,
                    SCFG,	8,
                    SADR,	8
                }
                Name(RBUF, Package(0x20) {
                })
                Method(HBSY) {
                    Store(0x00ffffff, Local0)
                    While(Local0) {
                        And(HSTS, 0x1, Local1)
                        If(LNot(Local1)) {
                            Return(Zero)
                        }
                        Decrement(Local0)
                    }
                    Return(One)
                }
                Method(WTSB) {
                    Store(0x00ffffff, Local0)
                    While(Local0) {
                        Decrement(Local0)
                        And(HSTS, 0x1e, Local1)
                        If(LEqual(Local1, 0x2)) {
                            Return(One)
                        }
                        If(Local1) {
                            Return(Zero)
                        }
                    }
                    Return(Zero)
                }
                Mutex(\P4SM, 0)
                Method(SBYT, 2, Serialized) {
                    If(LNot(LEqual(Acquire(\P4SM, 0xffff), 0x0))) {
                        Return(Ones)
                    }
                    Store(0x5, Local0)
                    While(Local0) {
                        If(HBSY()) {
                            Decrement(Local0)
                        }
                        Else {
                            Store(Arg0, HADR)
                            Store(Arg1, HCMD)
                            Store(0xff, HSTS)
                            Store(0x44, HSTC)
                            If(WTSB()) {
                                Release(\P4SM)
                                Return(One)
                            }
                            Else {
                                Decrement(Local0)
                            }
                        }
                    }
                    Release(\P4SM)
                    Return(Ones)
                }
                Method(WBYT, 3, Serialized) {
                    If(LNot(LEqual(Acquire(\P4SM, 0xffff), 0x0))) {
                        Return(Ones)
                    }
                    Store(0x5, Local0)
                    While(Local0) {
                        If(HBSY()) {
                            Decrement(Local0)
                        }
                        Else {
                            Store(Arg0, HADR)
                            Store(Arg1, HCMD)
                            Store(Arg2, HDT0)
                            Store(0xff, HSTS)
                            Store(0x48, HSTC)
                            If(WTSB()) {
                                Release(\P4SM)
                                Return(One)
                            }
                            Else {
                                Decrement(Local0)
                            }
                        }
                    }
                    Release(\P4SM)
                    Return(Ones)
                }
                Method(WWRD, 4, Serialized) {
                    If(LNot(LEqual(Acquire(\P4SM, 0xffff), 0x0))) {
                        Return(Ones)
                    }
                    Store(0x5, Local0)
                    While(Local0) {
                        If(HBSY()) {
                            Decrement(Local0)
                        }
                        Else {
                            Store(Arg0, HADR)
                            Store(Arg1, HCMD)
                            And(Arg2, 0xff, Local1)
                            ShiftRight(Arg2, 0x8, Local2)
                            And(Local2, 0xff, Local2)
                            Store(Local2, HDT0)
                            Store(Local1, HDT1)
                            Store(0xff, HSTS)
                            Store(0x4c, HSTC)
                            If(WTSB()) {
                                Release(\P4SM)
                                Return(One)
                            }
                            Else {
                                Decrement(Local0)
                            }
                        }
                    }
                    Release(\P4SM)
                    Return(Ones)
                }
                Method(WBLK, 4, Serialized) {
                    If(LNot(LEqual(Acquire(\P4SM, 0xffff), 0x0))) {
                        Return(Ones)
                    }
                    Store(0x5, Local0)
                    While(Local0) {
                        If(HBSY()) {
                            Decrement(Local0)
                        }
                        Else {
                            Store(Arg0, HADR)
                            Store(Arg1, HCMD)
                            Store(HSTC, Local1)
                            Store(Arg2, Local2)
                            Store(0x0, Local1)
                            While(Local2) {
                                Store(DerefOf(Index(Arg3, Local1, )), BLKD)
                                Decrement(Local2)
                                Increment(Local1)
                            }
                            Store(Arg2, HDT0)
                            Store(HSTC, Local1)
                            Store(0xff, HSTS)
                            Store(0x54, HSTC)
                            If(WTSB()) {
                                Release(\P4SM)
                                Return(One)
                            }
                            Else {
                                Decrement(Local0)
                            }
                        }
                    }
                    Release(\P4SM)
                    Return(Ones)
                }
                Method(RSBT, 2, Serialized) {
                    If(LNot(LEqual(Acquire(\P4SM, 0xffff), 0x0))) {
                        Return(Ones)
                    }
                    Store(0x5, Local0)
                    While(Local0) {
                        If(HBSY()) {
                            Decrement(Local0)
                        }
                        Else {
                            Or(Arg0, 0x1, HADR)
                            Store(Arg1, HCMD)
                            Store(0xff, HSTS)
                            Store(0x44, HSTC)
                            If(WTSB()) {
                                Release(\P4SM)
                                Return(HDT0)
                            }
                            Else {
                                Decrement(Local0)
                            }
                        }
                    }
                    Release(\P4SM)
                    Return(Ones)
                }
                Method(RBYT, 2, Serialized) {
                    If(LNot(LEqual(Acquire(\P4SM, 0xffff), 0x0))) {
                        Return(Ones)
                    }
                    Store(0x5, Local0)
                    While(Local0) {
                        If(HBSY()) {
                            Decrement(Local0)
                        }
                        Else {
                            Or(Arg0, 0x1, HADR)
                            Store(Arg1, HCMD)
                            Store(0xff, HSTS)
                            Store(0x48, HSTC)
                            If(WTSB()) {
                                Release(\P4SM)
                                Return(HDT0)
                            }
                            Else {
                                Decrement(Local0)
                            }
                        }
                    }
                    Release(\P4SM)
                    Return(Ones)
                }
                Method(RWRD, 2, Serialized) {
                    If(LNot(LEqual(Acquire(\P4SM, 0xffff), 0x0))) {
                        Return(Ones)
                    }
                    Store(0x5, Local0)
                    While(Local0) {
                        If(HBSY()) {
                            Decrement(Local0)
                        }
                        Else {
                            Or(Arg0, 0x1, HADR)
                            Store(Arg1, HCMD)
                            Store(0xff, HSTS)
                            Store(0x4c, HSTC)
                            If(WTSB()) {
                                Store(HDT0, Local1)
                                ShiftLeft(Local1, 0x8, Local1)
                                Store(HDT1, Local2)
                                Add(Local1, Local2, Local1)
                                Release(\P4SM)
                                Return(Local1)
                            }
                            Else {
                                Decrement(Local0)
                            }
                        }
                    }
                    Release(\P4SM)
                    Return(Ones)
                }
                Method(RBLK, 3, Serialized) {
                    If(LNot(LEqual(Acquire(\P4SM, 0xffff), 0x0))) {
                        Return(Ones)
                    }
                    Store(0x5, Local0)
                    While(Local0) {
                        If(HBSY()) {
                            Decrement(Local0)
                        }
                        Else {
                            Or(Arg0, 0x1, HADR)
                            Store(Arg1, HCMD)
                            Store(0xff, HSTS)
                            Store(0x54, HSTC)
                            If(WTSB()) {
                                Store(HSTC, Local1)
                                Store(HDT0, Local2)
                                Store(Local2, Local3)
                                Store(0x0, RBUF)
                                Store(0x0, Local1)
                                While(Local2) {
                                    Store(BLKD, Index(RBUF, Local1, ))
                                    Decrement(Local2)
                                    Increment(Local1)
                                }
                                Release(\P4SM)
                                Return(Local3)
                            }
                            Else {
                                Decrement(Local0)
                            }
                        }
                    }
                    Release(\P4SM)
                    Return(Ones)
                }
            }
            Scope(\) {
                Name(FAN1, 0x0)
                Name(FAN2, 0x0)
                Device(FN00) {
                    Name(_HID, 0x0b0cd041)
                    Name(_PR0, Package(0x1) {
                        GFAN,
                    })
                }
                PowerResource(GFAN, 0, 0) {
                    Method(_STA) {
                        Return(FAN1)
                    }
                    Method(_ON_) {
                        Store(0x1, FAN1)
                    }
                    Method(_OFF) {
                        Store(0x0, FAN1)
                    }
                }
                Name(\_SB_.PCI0.SBRG._PR0, Package(0x1) {
                    GFAN,
                })
                Method(FANW, 1) {
                    Noop
                }
                Method(FANS, 1) {
                    If(Arg0) {
                        \GFAN._OFF()
                    }
                }
            }
            Scope(\) {
                Name(TSP_, 0xa)
                Name(TC1_, 0x2)
                Name(TC2_, 0xa)
            }
            Scope(\_TZ_) {
                Method(KELV, 1) {
                    And(Arg0, 0xff, Local0)
                    Multiply(Local0, 0xa, Local0)
                    Add(Local0, 0x0aac, Local0)
                    Return(Local0)
                }
                Method(CELC, 1) {
                    Subtract(Arg0, 0x0aac, Local0)
                    Divide(Local0, 0xa, Local1, Local0)
                    Return(Local0)
                }
                Name(PLCY, 0x0)
                ThermalZone(THRM) {
                    Method(_CRT) {
                        Return(KELV(TCRT))
                    }
                    Method(_TMP) {
                        Store(0x5, Local1)
                        While(Local1) {
                            Store(RTMP(), Local0)
                            If(LGreater(Local0, TCRT)) {
                                Decrement(Local1)
                            }
                            Else {
                                Store(0x0, Local1)
                            }
                        }
                        Return(KELV(Local0))
                    }
                    Name(_PSL, Package(0x1) {
                        \_PR_.CPU1,
                    })
                    Method(_TSP) {
                        Multiply(TSP_, 0xa, Local0)
                        Return(Local0)
                    }
                    Method(_TC1) {
                        Return(TC1_)
                    }
                    Method(_TC2) {
                        Return(TC2_)
                    }
                    Method(_PSV) {
                        If(PLCY) {
                            Return(KELV(PPSV))
                        }
                        Else {
                            Return(KELV(TPSV))
                        }
                    }
                    Name(_AL0, Package(0x1) {
                        FN00,
                    })
                    Method(_AC0) {
                        If(PLCY) {
                            Return(KELV(PAC0))
                        }
                        Else {
                            Return(KELV(TAC3))
                        }
                    }
                    Method(_SCP, 1) {
                        Notify(THRM, 0x81)
                    }
                }
                Method(TRMS, 1) {
                    If(Arg0) {
                        \_TZ_.TMSS(Arg0)
                    }
                }
                Method(TRMW, 1) {
                    If(Arg0) {
                        If(LLess(Arg0, 0x4)) {
                            \_TZ_.TMSW(Arg0)
                            \_TZ_.TCHG()
                        }
                    }
                }
            }
            Scope(\_GPE) {
                Method(_L00, 0, Serialized) {
                    \_TZ_.TCHG()
                    Notify(\_TZ_.THRM, 0x80)
                }
            }
            Scope(\_TZ_) {
                Name(LTMP, 0x3c)
                Name(HLMT, 0x46)
                Name(LLMT, 0x32)
                Name(ELMT, 0x2)
                Alias(\F1L0, TRNG)
                Alias(\F2L0, TMIN)
                Alias(\F1L1, TLMT)
                Alias(\F2L1, FTYP)
                Alias(\F1L2, FPLS)
                Method(TMSW, 1) {
                    If(Arg0) {
                        If(LLess(Arg0, 0x4)) {
                            WBYT(TSAD, 0x5c, 0xd)
                            WBYT(TSAD, 0x5f, TRNG)
                            WBYT(TSAD, 0x62, 0x8)
                            WBYT(TSAD, 0x64, 0x33)
                            WBYT(TSAD, 0x67, TMIN)
                            WBYT(TSAD, 0x6d, 0x55)
                            WBYT(TSAD, 0x6a, TLMT)
                            WBYT(TSAD, 0x6b, TLMT)
                            WBYT(TSAD, 0x6c, TLMT)
                            WBYT(TSAD, 0x74, 0x65)
                            WBYT(TSAD, 0x75, 0xfc)
                            WBYT(TSAD, 0x78, 0x11)
                            WBYT(TSAD, 0x73, FTYP)
                            WBYT(TSAD, 0x7b, FPLS)
                            WBYT(TSAD, 0x4f, 0x7f)
                            WBYT(TSAD, 0x4e, 0x80)
                            RBYT(TSAD, 0x41)
                            RBYT(TSAD, 0x42)
                            WBYT(TSAD, 0x40, 0x5)
                            WBYT(TSAD, 0x5d, 0x80)
                            WBYT(TSAD, 0x5e, 0x80)
                        }
                    }
                }
                Method(TMSS, 1) {
                    If(LNot(LGreater(Arg0, 0x3))) {
                        WBYT(TSAD, 0x4f, 0x7f)
                        WBYT(TSAD, 0x4e, 0x80)
                        RBYT(TSAD, 0x41)
                        RBYT(TSAD, 0x42)
                    }
                }
                Name(PPLY, 0x0)
                Method(TCHG) {
                    RTMP()
                    If(LNot(LLess(LTMP, 0x80))) {
                        Store(0x0, LTMP)
                    }
                    If(PLCY) {
                        Store(\_TZ_.THRM._PSV(), Local0)
                        Store(CELC(Local0), Local0)
                        Store(\_TZ_.THRM._AC0(), Local1)
                        Store(CELC(Local1), Local1)
                        If(LGreater(LTMP, TCRT)) {
                            Store(0x7f, HLMT)
                            Store(TCRT, LLMT)
                        }
                        Else {
                            If(LGreater(LTMP, Local1)) {
                                Store(TCRT, HLMT)
                                Store(Local1, LLMT)
                            }
                            Else {
                                If(LGreater(LTMP, Local0)) {
                                    Store(Local1, HLMT)
                                    Store(Local0, LLMT)
                                }
                                Else {
                                    Store(Local0, HLMT)
                                    Store(0x80, LLMT)
                                }
                            }
                        }
                    }
                    Else {
                        If(LGreater(LTMP, TCRT)) {
                            Store(0x7f, HLMT)
                            Store(TCRT, LLMT)
                        }
                        Else {
                            If(LGreater(LTMP, TPSV)) {
                                Store(TCRT, HLMT)
                                Store(TPSV, LLMT)
                            }
                            Else {
                                If(LGreater(LTMP, TAC0)) {
                                    Store(TPSV, HLMT)
                                    Store(TAC0, LLMT)
                                }
                                Else {
                                    If(LGreater(LTMP, TAC1)) {
                                        Store(TAC0, HLMT)
                                        Store(TAC1, LLMT)
                                    }
                                    Else {
                                        If(LGreater(LTMP, TAC2)) {
                                            Store(TAC1, HLMT)
                                            Store(TAC2, LLMT)
                                        }
                                        Else {
                                            If(LGreater(LTMP, TAC3)) {
                                                Store(TAC2, HLMT)
                                                Store(TAC3, LLMT)
                                            }
                                            Else {
                                                Store(TAC3, HLMT)
                                                Store(0x80, LLMT)
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    If(LGreater(HLMT, 0x7d)) {
                        Store(0x7f, HLMT)
                    }
                    Else {
                        Add(HLMT, ELMT, HLMT)
                    }
                    If(LLess(LLMT, 0x80)) {
                        Subtract(LLMT, ELMT, LLMT)
                    }
                    WBYT(TSAD, 0x4f, HLMT)
                    WBYT(TSAD, 0x4e, LLMT)
                    RBYT(TSAD, 0x41)
                    RBYT(TSAD, 0x42)
                    If(LNot(LEqual(PPLY, PLCY))) {
                        Store(PLCY, PPLY)
                        Store(\_TZ_.THRM._AC0(), Local0)
                        Store(CELC(Local0), Local0)
                        WBYT(TSAD, 0x67, Local0)
                    }
                }
                Method(RTMP) {
                    Store(RBYT(TSAD, 0x25), Local0)
                    If(Not(Local0, )) {
                        Store(Local0, LTMP)
                    }
                    Return(LTMP)
                }
                Method(RFAN) {
                    Store(RBYT(TSAD, 0x28), Local0)
                    Store(RBYT(TSAD, 0x29), Local1)
                    ShiftLeft(Local1, 0x8, Local1)
                    Add(Local1, Local0, Local0)
                    If(LEqual(Local0, 0xffff)) {
                        Return(0x0)
                    }
                    Else {
                        If(LNot(LGreater(Local0, 0xc8))) {
                            Return(0xfe)
                        }
                    }
                    Store(0x005265c0, Local2)
                    Divide(Local2, Local0, Local3, Local4)
                    Divide(Local4, 0x64, Local3, Local4)
                    Return(Local4)
                }
                Method(THDL) {
                    TCHG()
                }
            }
            Scope(\_SB_.PCI0) {
                Device(VGA_) {
                    Name(_ADR, 0x00020000)
                    Name(LCDM, 0x0808)
                    Name(CRTM, 0x0101)
                    Name(TVOM, 0x0202)
                    Name(DONE, Zero)
                    Name(DOSF, One)
                    Method(_INI) {
                        GCAD()
                        Store(\CADL, \PADL)
                        GCDD()
                        GNDD()
                    }
                    Method(_DOS, 1) {
                        Store(Arg0, DOSF)
                    }
                    Method(_DOD) {
                        Return(Package(0x2) {
                            0x00010100,
                            0x00010400,
                        })
                    }
                    Device(CRTD) {
                        Name(_ADR, 0x0100)
                        Method(_DCS) {
                            If(And(\CSTE, CRTM, )) {
                                Return(0x1f)
                            }
                            Return(0x1d)
                        }
                        Method(_DGS) {
                            If(And(\NSTE, CRTM, )) {
                                Return(0x1)
                            }
                            Return(0x0)
                        }
                        Method(_DSS, 1) {
                            If(And(Arg0, 0x40000000, )) {
                                If(And(Arg0, 0x80000000, )) {
                                    Store(\NSTE, \CSTE)
                                    Store(One, DONE)
                                }
                            }
                        }
                    }
                    Device(LCDD) {
                        Name(_ADR, 0x0400)
                        Method(_DCS) {
                            If(And(\CSTE, LCDM, )) {
                                Return(0x1f)
                            }
                            Return(0x1d)
                        }
                        Method(_DGS) {
                            If(And(\NSTE, LCDM, )) {
                                Return(0x1)
                            }
                            Return(0x0)
                        }
                        Method(_DSS, 1) {
                            If(And(Arg0, 0x40000000, )) {
                                If(And(Arg0, 0x80000000, )) {
                                    Store(\NSTE, \CSTE)
                                    Store(One, DONE)
                                }
                            }
                        }
                    }
                    Method(SWHD, 1, Serialized) {
                        If(DOSF) {
                            Store(0x4, \SFUN)
                            Store(Arg0, \SSTE)
                            If(\NATK()) {
                                Store(\NSTE, \SSTE)
                            }
                            ISMI(\STDD)
                            Notify(\_SB_.PCI0.VGA_, 0x81)
                        }
                        Else {
                            If(LNot(LEqual(\CADL, \PADL))) {
                                Store(\CADL, \PADL)
                                If(LEqual(OSFG, OSXP)) {
                                    Notify(\_SB_.PCI0, 0x0)
                                }
                                Else {
                                    Notify(\_SB_.PCI0.VGA_, 0x0)
                                }
                                Sleep(0x03e8)
                            }
                            Notify(\_SB_.PCI0.VGA_, 0x80)
                        }
                    }
                    Method(GCDD) {
                        Store(0x1, \SFUN)
                        ISMI(\GTDD)
                        Return(\CSTE)
                    }
                    Method(GNDD) {
                        Store(0x5, \SFUN)
                        ISMI(\GTDD)
                        Return(\NSTE)
                    }
                    Method(GCAD) {
                        Store(0x2, \SFUN)
                        ISMI(\GTDD)
                        Return(\CADL)
                    }
                    Method(ADVD) {
                        GCDD()
                        GCAD()
                        Return(GNDD())
                    }
                }
            }
            Scope(\) {
                Method(ADVG) {
                    If(NATK()) {
                        Store(\_SB_.PCI0.VGA_.ADVD(), Local0)
                        Store(Zero, Local1)
                        If(And(Local0, \_SB_.PCI0.VGA_.LCDM, )) {
                            Add(Local1, 0x1, Local1)
                        }
                        If(And(Local0, \_SB_.PCI0.VGA_.CRTM, )) {
                            Add(Local1, 0x2, Local1)
                        }
                        If(And(Local0, \_SB_.PCI0.VGA_.TVOM, )) {
                            Add(Local1, 0x4, Local1)
                        }
                        Return(Local1)
                    }
                    Return(\_SB_.PCI0.VGA_.ADVD())
                }
                Method(SWHG, 1, Serialized) {
                    Store(Zero, \_SB_.PCI0.VGA_.DONE)
                    If(LNot(\NATK())) {
                        Store(Arg0, Local0)
                        Store(Zero, Local1)
                        If(And(Local0, 0x0808, )) {
                            Add(Local1, 0x1, Local1)
                        }
                        If(And(Local0, 0x0101, )) {
                            Add(Local1, 0x2, Local1)
                        }
                        If(And(Local0, 0x0202, )) {
                            Add(Local1, 0x4, Local1)
                        }
                        Add(Local1, 0x34, Local1)
                        If(\_SB_.ATKP) {
                            Notify(\_SB_.ATKD, Local1)
                            Store(0xc8, Local2)
                            While(Local2) {
                                Sleep(0xa)
                                Decrement(Local2)
                            }
                        }
                    }
                    \_SB_.PCI0.VGA_.SWHD(Arg0)
                    If(LNot(\_SB_.PCI0.VGA_.DOSF)) {
                        Store(0x01f4, Local0)
                        While(Local0) {
                            If(\_SB_.PCI0.VGA_.DONE) {
                                Store(Zero, Local0)
                            }
                            Else {
                                Sleep(0xa)
                                Decrement(Local0)
                            }
                        }
                    }
                }
                Method(NATK) {
                    Return(Zero)
                }
            }
            Scope(\_SB_) {
                Name(ATKP, Zero)
                Device(ATKD) {
                    Name(_HID, "ATK0100")
                    Name(_UID, 0x01010100)
                    Method(INIT, 1) {
                        Store(One, ATKP)
                        Return(\MNAM)
                    }
                    Method(BSTS) {
                        Store(\IKFG, Local0)
                        If(\_SB_.PCI0.SBRG.EC0_.ACAP()) {
                            And(Local0, 0x7f, Local0)
                        }
                        Return(Local0)
                    }
                    Method(MLED, 1) {
                        If(Arg0) {
                            Store(0x31, Local0)
                        }
                        Else {
                            Store(0x51, Local0)
                        }
                        \_SB_.PCI0.SBRG.EC0_.STC5(Local0)
                    }
                    Method(TMPR) {
                        Store(\_TZ_.RTMP(), Local0)
                        Store(\_TZ_.RFAN(), Local1)
                        ShiftLeft(Local1, 0x10, Local1)
                        Add(\_TZ_.KELV(Local0), Local1, Local0)
                        Store(Zero, Local2)
                        If(\TENA) {
                            Store(\TDTY, Local2)
                        }
                        Else {
                            If(\THLS) {
                                Store(\TTDT, Local2)
                            }
                        }
                        ShiftLeft(Local2, 0x18, Local2)
                        Add(Local0, Local2, Local0)
                        Return(Local0)
                    }
                    Method(SFUN) {
                        Store(0x37, Local0)
                        Or(Local0, 0x0240, Local0)
                        If(LEqual(\_SB_.PCI0.P0P1.MPCI.MPDP(), 0x1)) {
                            Or(Local0, 0x0100, Local0)
                        }
                        If(LGreater(\_SB_.PCI0.P0P1.MPCI.MPDP(), 0x1)) {
                            Or(Local0, 0x0800, Local0)
                        }
                        Return(Local0)
                    }
                    Name(FMST, Package(0x4) {
                        Package(0x4) {
                            Package(0x5) {
                                Package(0x2) {
                                    0x55,
                                    0x2,
                                },
                                Package(0x2) {
                                    0x64,
                                    0x4,
                                },
                                Package(0x2) {
                                    0x69,
                                    0x5,
                                },
                                Package(0x2) {
                                    0x6e,
                                    0x6,
                                },
                                Package(0x2) {
                                    0x73,
                                    0x7,
                                },
                            },
                            Package(0x5) {
                                Package(0x2) {
                                    0x71,
                                    0x2,
                                },
                                Package(0x2) {
                                    0x85,
                                    0x4,
                                },
                                Package(0x2) {
                                    0x8c,
                                    0x5,
                                },
                                Package(0x2) {
                                    0x93,
                                    0x6,
                                },
                                Package(0x2) {
                                    0x99,
                                    0x7,
                                },
                            },
                            Package(0x5) {
                                Package(0x2) {
                                    0x8d,
                                    0x2,
                                },
                                Package(0x2) {
                                    0xa6,
                                    0x4,
                                },
                                Package(0x2) {
                                    0xaf,
                                    0x5,
                                },
                                Package(0x2) {
                                    0xb7,
                                    0x6,
                                },
                                Package(0x2) {
                                    0xbf,
                                    0x7,
                                },
                            },
                            Package(0x5) {
                                Package(0x2) {
                                    0xaa,
                                    0x2,
                                },
                                Package(0x2) {
                                    0xc8,
                                    0x4,
                                },
                                Package(0x2) {
                                    0xd2,
                                    0x5,
                                },
                                Package(0x2) {
                                    0xdc,
                                    0x6,
                                },
                                Package(0x2) {
                                    0xe6,
                                    0x7,
                                },
                            },
                        },
                        Package(0x4) {
                            Package(0x5) {
                                Package(0x2) {
                                    0x5a,
                                    0x3,
                                },
                                Package(0x2) {
                                    0x64,
                                    0x4,
                                },
                                Package(0x2) {
                                    0x6e,
                                    0x5,
                                },
                                Package(0x2) {
                                    0x78,
                                    0x6,
                                },
                                Package(0x2) {
                                    0x82,
                                    0x7,
                                },
                            },
                            Package(0x5) {
                                Package(0x2) {
                                    0x78,
                                    0x3,
                                },
                                Package(0x2) {
                                    0x85,
                                    0x4,
                                },
                                Package(0x2) {
                                    0x93,
                                    0x5,
                                },
                                Package(0x2) {
                                    0xa0,
                                    0x6,
                                },
                                Package(0x2) {
                                    0xad,
                                    0x7,
                                },
                            },
                            Package(0x5) {
                                Package(0x2) {
                                    0x96,
                                    0x3,
                                },
                                Package(0x2) {
                                    0xa6,
                                    0x4,
                                },
                                Package(0x2) {
                                    0xb7,
                                    0x5,
                                },
                                Package(0x2) {
                                    0xc7,
                                    0x6,
                                },
                                Package(0x2) {
                                    0xd9,
                                    0x7,
                                },
                            },
                            Package(0x5) {
                                Package(0x2) {
                                    0xb4,
                                    0x3,
                                },
                                Package(0x2) {
                                    0xc8,
                                    0x4,
                                },
                                Package(0x2) {
                                    0xdc,
                                    0x5,
                                },
                                Package(0x2) {
                                    0xf0,
                                    0x5,
                                },
                                Package(0x2) {
                                    0x0104,
                                    0x7,
                                },
                            },
                        },
                        Package(0x4) {
                            Package(0x5) {
                                Package(0x2) {
                                    0x5a,
                                    0x0,
                                },
                                Package(0x2) {
                                    0x64,
                                    0x1,
                                },
                                Package(0x2) {
                                    0x69,
                                    0x2,
                                },
                                Package(0x2) {
                                    0x6e,
                                    0x3,
                                },
                                Package(0x2) {
                                    0x73,
                                    0x4,
                                },
                            },
                            Package(0x5) {
                                Package(0x2) {
                                    0x78,
                                    0x0,
                                },
                                Package(0x2) {
                                    0x85,
                                    0x1,
                                },
                                Package(0x2) {
                                    0x8c,
                                    0x2,
                                },
                                Package(0x2) {
                                    0x93,
                                    0x3,
                                },
                                Package(0x2) {
                                    0x99,
                                    0x4,
                                },
                            },
                            Package(0x5) {
                                Package(0x2) {
                                    0x96,
                                    0x0,
                                },
                                Package(0x2) {
                                    0xa6,
                                    0x1,
                                },
                                Package(0x2) {
                                    0xaf,
                                    0x2,
                                },
                                Package(0x2) {
                                    0xb7,
                                    0x3,
                                },
                                Package(0x2) {
                                    0xbf,
                                    0x4,
                                },
                            },
                            Package(0x5) {
                                Package(0x2) {
                                    0xb4,
                                    0x0,
                                },
                                Package(0x2) {
                                    0xc8,
                                    0x1,
                                },
                                Package(0x2) {
                                    0xd2,
                                    0x2,
                                },
                                Package(0x2) {
                                    0xdc,
                                    0x3,
                                },
                                Package(0x2) {
                                    0xe6,
                                    0x4,
                                },
                            },
                        },
                        Package(0x4) {
                            Package(0x5) {
                                Package(0x2) {
                                    0x5a,
                                    0x2,
                                },
                                Package(0x2) {
                                    0x64,
                                    0x4,
                                },
                                Package(0x2) {
                                    0x78,
                                    0x5,
                                },
                                Package(0x2) {
                                    0x7d,
                                    0x6,
                                },
                                Package(0x2) {
                                    0x82,
                                    0x7,
                                },
                            },
                            Package(0x5) {
                                Package(0x2) {
                                    0x78,
                                    0x2,
                                },
                                Package(0x2) {
                                    0x85,
                                    0x4,
                                },
                                Package(0x2) {
                                    0xa0,
                                    0x5,
                                },
                                Package(0x2) {
                                    0xa7,
                                    0x6,
                                },
                                Package(0x2) {
                                    0xad,
                                    0x7,
                                },
                            },
                            Package(0x5) {
                                Package(0x2) {
                                    0x96,
                                    0x2,
                                },
                                Package(0x2) {
                                    0xa6,
                                    0x4,
                                },
                                Package(0x2) {
                                    0xc8,
                                    0x5,
                                },
                                Package(0x2) {
                                    0xd0,
                                    0x6,
                                },
                                Package(0x2) {
                                    0xd9,
                                    0x7,
                                },
                            },
                            Package(0x5) {
                                Package(0x2) {
                                    0xb4,
                                    0x2,
                                },
                                Package(0x2) {
                                    0xc8,
                                    0x4,
                                },
                                Package(0x2) {
                                    0xf0,
                                    0x5,
                                },
                                Package(0x2) {
                                    0xfa,
                                    0x6,
                                },
                                Package(0x2) {
                                    0x0104,
                                    0x7,
                                },
                            },
                        },
                    })
                    Method(GFRQ, 1) {
                        If(LEqual(\OVCK, 0x0)) {
                            If(LNot(LEqual(Arg0, 0x1))) {
                                Return(0x0)
                            }
                        }
                        Store(DerefOf(Index(FMST, \FS56, )), Local0)
                        Store(DerefOf(Index(Local0, \CPUF, )), Local1)
                        Store(Arg0, Local5)
                        If(LEqual(Local5, 0x2)) {
                            If(\OVCK) {
                                Subtract(\OVCK, 0x1, Local6)
                                Add(Local5, Local6, Local5)
                            }
                        }
                        Store(DerefOf(Index(Local1, Local5, )), Local2)
                        Store(DerefOf(Index(Local2, 0x0, )), Local3)
                        Multiply(Local3, \CPUR, Local4)
                        Return(Local4)
                    }
                    Method(SFRQ, 1) {
                        Store(DerefOf(Index(FMST, \FS56, )), Local0)
                        Store(DerefOf(Index(Local0, \CPUF, )), Local1)
                        Store(Arg0, Local5)
                        If(LEqual(Local5, 0x2)) {
                            If(\OVCK) {
                                Subtract(\OVCK, 0x1, Local6)
                                Add(Local5, Local6, Local5)
                            }
                        }
                        Store(DerefOf(Index(Local1, Local5, )), Local2)
                        Store(DerefOf(Index(Local2, 0x1, )), Local3)
                        Store(Local3, \FS02)
                        Return(One)
                    }
                    Method(WDEV) {
                        Return(\_SB_.PCI0.P0P1.MPCI.MPDP())
                    }
                    Method(OSVR, 1) {
                        Store(Arg0, \OSFG)
                    }
                    Method(GPLV) {
                        If(LNot(\ACPF)) {
                            Return(\LBT2)
                        }
                        Return(\LBTN)
                    }
                    Method(SPLV, 1) {
                        If(\ACPF) {
                            Store(Arg0, \LBTN)
                        }
                        Else {
                            Store(Arg0, \LBT2)
                        }
                        \_SB_.PCI0.SBRG.EC0_.STBR()
                    }
                    Method(WLED, 1) {
                    }
                    Method(SDSP, 1) {
                        If(\NATK()) {
                            \SWHG(Arg0)
                        }
                    }
                }
            }
            Scope(\) {
                Name(PMEW, Zero)
                Name(MES4, Zero)
                Method(OEMS, 1) {
                    If(LEqual(Arg0, 0x3)) {
                        If(LNot(LGreater(\OSFG, \OSME))) {
                            Store(One, \WIDE)
                        }
                        Else {
                            Store(Zero, \WIDE)
                        }
                    }
                    \_SB_.PCI0.USB1.USBS(Arg0)
                    \_SB_.PCI0.USB2.USBS(Arg0)
                    \_SB_.PCI0.USB3.USBS(Arg0)
                    \_SB_.PCI0.SBRG.EC0_.EC0S(Arg0)
                    If(LEqual(Arg0, 0x4)) {
                        If(LEqual(OSFG, OS2K)) {
                            Store(Arg0, S42K)
                        }
                    }
                    Add(Arg0, 0xd0, DBG8)
                }
                Method(OEMW, 1) {
                    \_SB_.PCI0.SBRG.EC0_.EC0W(Arg0)
                    \_SB_.PCI0.SBRG.C4C3()
                    If(LEqual(Arg0, 0x4)) {
                        If(LNot(LGreater(\OSFG, \OSME))) {
                            Store(0x2, MES4)
                        }
                        Else {
                            Store(Zero, MES4)
                        }
                    }
                    \_SB_.PCI0.P0P1.CBS0.CBSW(Arg0)
                    Store(\SBPS, \PMEW)
                    \_SB_.PCI0.USB1.USBW(Arg0)
                    \_SB_.PCI0.USB2.USBW(Arg0)
                    \_SB_.PCI0.USB3.USBW(Arg0)
                    If(LEqual(Arg0, 0x4)) {
                        Notify(\_SB_.SLPB, 0x2)
                    }
                    Add(Arg0, 0xf0, DBG8)
                }
            }
            Scope(\_GPE) {
                Method(_L03, 0, Serialized) {
                    Notify(\_SB_.PCI0.USB1, 0x2)
                    Notify(\_SB_.SLPB, 0x2)
                }
                Method(_L04, 0, Serialized) {
                    Notify(\_SB_.PCI0.USB2, 0x2)
                    Notify(\_SB_.SLPB, 0x2)
                }
                Method(_L0C, 0, Serialized) {
                    Notify(\_SB_.PCI0.USB3, 0x2)
                    Notify(\_SB_.SLPB, 0x2)
                }
                Method(_L0D, 0, Serialized) {
                    Notify(\_SB_.PCI0.EHCI, 0x2)
                    Notify(\_SB_.SLPB, 0x2)
                }
                Method(_L05, 0, Serialized) {
                    Notify(\_SB_.PCI0.MODM, 0x2)
                    Notify(\_SB_.SLPB, 0x2)
                }
                Method(_L0B, 0, Serialized) {
                    If(\PMEW) {
                        Notify(\_SB_.PCI0.P0P1, 0x2)
                        Notify(\_SB_.SLPB, 0x2)
                        Store(Zero, \PMEW)
                    }
                    Else {
                        If(\_SB_.PCI0.P0P1.CBS0.CBSR()) {
                            Notify(\_SB_.PCI0.P0P1.CBS0, 0x2)
                        }
                    }
                }
            }
            Scope(\_SB_.ATKD) {
                Method(FSMI, 1) {
                    Store(Arg0, \FSFN)
                    Or(Arg0, 0xa0, Local0)
                    Store(Local0, \DBG8)
                    ISMI(\WFAT)
                    Return(\FSTA)
                }
                Method(FLSH, 1) {
                    Store(Arg0, \FSTA)
                    FSMI(0x0)
                }
                Method(FINI, 1) {
                    Store(Arg0, \FADR)
                    Return(FSMI(0x1))
                }
                Method(FERS, 1) {
                    Store(Arg0, \FSTA)
                    Return(FSMI(0x2))
                }
                Method(FWRI, 1) {
                    Store(Arg0, \FADR)
                    Store(0x1000, \FSIZ)
                    Return(Subtract(0x1000, FSMI(0x3), ))
                }
                Method(FWRP) {
                    Store(0x0, \FSIZ)
                    Return(Subtract(0x1000, FSMI(0x3), ))
                }
            }
            Device(FWH_) {
                Name(_HID, 0x020cd041)
                Name(_UID, 0x2)
                Name(CRS_, Buffer(0x1a) {0x86, 0x9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x86, 0x9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x0 })
                CreateDWordField(CRS_, 0x4, BS00)
                CreateDWordField(CRS_, 0x8, BL00)
                CreateDWordField(CRS_, 0x10, BS10)
                CreateDWordField(CRS_, 0x14, BL10)
                Method(_CRS) {
                    Store(0xff800000, Local0)
                    FindSetRightBit(FHD0, Local1)
                    Decrement(Local1)
                    If(Local1) {
                        Multiply(Local1, 0x00080000, Local1)
                    }
                    Add(Local0, Local1, Local2)
                    Store(Local2, BS00)
                    Add(BS00, 0x00400000, BS10)
                    Subtract(0x0, BS10, BL00)
                    Store(BL00, BL10)
                    Return(CRS_)
                }
            }
            Device(FWHE) {
                Name(_HID, 0x020cd041)
                Name(_UID, 0x3)
                Name(CRS_, Buffer(0xe) {0x86, 0x9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x0 })
                Method(_CRS) {
                    CreateDWordField(CRS_, 0x4, BS00)
                    CreateDWordField(CRS_, 0x8, BL00)
                    If(LEqual(^^FWH_.BS00, 0x0)) {
                        ^^FWH_._CRS()
                    }
                    Add(^^FWH_.BS00, ^^FWH_.BL00, BS00)
                    Subtract(^^FWH_.BS10, BS00, BL00)
                    Return(CRS_)
                }
            }
            OperationRegion(FHR0, PCI_Config, 0xe3, 0x1)
            Field(FHR0, ByteAcc, NoLock, Preserve) {
                FHD0,	8
            }
        }
        Device(IDE0) {
            Name(_ADR, 0x001f0001)
            Name(REGF, 0x1)
            Method(_REG, 2) {
                If(LEqual(Arg0, 0x2)) {
                    Store(Arg1, REGF)
                }
            }
            OperationRegion(BAR0, PCI_Config, 0x0, 0x0100)
            Field(BAR0, DWordAcc, NoLock, Preserve) {
                Offset(0x40),
                TIMP,	16,
                TIMS,	16,
                STMP,	4,
                STMS,	4,
                Offset(0x48),
                UDMP,	2,
                UDMS,	2,
                Offset(0x4a),
                UDTP,	6,
                Offset(0x4b),
                UDTS,	6,
                Offset(0x54),
                PCB0,	2,
                SCB0,	2,
                PCA0,	2,
                SCA0,	2,
                ,	4,
                FPB0,	2,
                FSB0,	2,
                PSIG,	2,
                SSIG,	2
            }
            Name(TIM0, Package(0x9) {
                Package(0x4) {
                    0x78,
                    0xb4,
                    0xf0,
                    0x0384,
                },
                Package(0x4) {
                    0x23,
                    0x21,
                    0x10,
                    0x0,
                },
                Package(0x4) {
                    0xb,
                    0x9,
                    0x4,
                    0x0,
                },
                Package(0x6) {
                    0x70,
                    0x49,
                    0x36,
                    0x27,
                    0x19,
                    0xf,
                },
                Package(0x6) {
                    0x0,
                    0x1,
                    0x2,
                    0x1,
                    0x2,
                    0x1,
                },
                Package(0x6) {
                    0x0,
                    0x0,
                    0x0,
                    0x1,
                    0x1,
                    0x1,
                },
                Package(0x6) {
                    0x0,
                    0x0,
                    0x0,
                    0x0,
                    0x0,
                    0x1,
                },
                Package(0x4) {
                    0x4,
                    0x3,
                    0x2,
                    0x0,
                },
                Package(0x4) {
                    0x2,
                    0x1,
                    0x0,
                    0x0,
                },
            })
            Name(TMD0, Buffer(0x14) { })
            CreateDWordField(TMD0, 0x0, PIO0)
            CreateDWordField(TMD0, 0x4, DMA0)
            CreateDWordField(TMD0, 0x8, PIO1)
            CreateDWordField(TMD0, 0xc, DMA1)
            CreateDWordField(TMD0, 0x10, CHNF)
            Name(GTIM, 0x0)
            Name(GSTM, 0x0)
            Name(GUDM, 0x0)
            Name(GUDT, 0x0)
            Name(GCB0, 0x0)
            Name(GFB0, 0x0)
            Device(CHN0) {
                Name(_ADR, 0x0)
                Method(_GTM) {
                    Return(GTM_(TIMP, STMP, UDMP, UDTP, PCB0, FPB0))
                }
                Method(_STM, 3) {
                    Store(Arg0, Debug)
                    Store(Arg0, TMD0)
                    Store(TIMP, GTIM)
                    Store(UDTP, GUDT)
                    If(STM_()) {
                        Store(GTIM, TIMP)
                        Store(GSTM, STMP)
                        Store(GUDM, UDMP)
                        Store(GUDT, UDTP)
                        Store(GCB0, PCB0)
                        Store(GFB0, FPB0)
                    }
                    Store(GTF_(0x0, Arg1), ATA0)
                    Store(GTF_(0x1, Arg2), ATA1)
                }
                Device(DRV0) {
                    Name(_ADR, 0x0)
                    Method(_GTF) {
                        Return(RATA(ATA0))
                    }
                }
                Device(DRV1) {
                    Name(_ADR, 0x1)
                    Method(_GTF) {
                        Return(RATA(ATA1))
                    }
                }
            }
            Device(CHN1) {
                Name(_ADR, 0x1)
                Method(_GTM) {
                    Return(GTM_(TIMS, STMS, UDMS, UDTS, SCB0, FSB0))
                }
                Method(_STM, 3) {
                    Store(Arg0, Debug)
                    Store(Arg0, TMD0)
                    Store(TIMS, GTIM)
                    Store(UDTS, GUDT)
                    If(STM_()) {
                        Store(GTIM, TIMS)
                        Store(GSTM, STMS)
                        Store(GUDM, UDMS)
                        Store(GUDT, UDTS)
                        Store(GCB0, SCB0)
                        Store(GFB0, FSB0)
                    }
                    Store(GTF_(0x0, Arg1), ATA2)
                    Store(GTF_(0x1, Arg2), ATA3)
                }
                Device(DRV0) {
                    Name(_ADR, 0x0)
                    Method(_GTF) {
                        Return(RATA(ATA2))
                    }
                }
                Device(DRV1) {
                    Name(_ADR, 0x1)
                    Method(_GTF) {
                        Return(RATA(ATA3))
                    }
                }
            }
            Method(GTM_, 6, Serialized) {
                Store(Ones, PIO0)
                Store(PIO0, PIO1)
                Store(PIO0, DMA0)
                Store(PIO0, DMA1)
                Store(Zero, CHNF)
                If(REGF) {
                }
                Else {
                    Return(TMD0)
                }
                If(And(Arg0, 0x2, )) {
                    Or(CHNF, 0x2, CHNF)
                }
                ShiftRight(And(Arg0, 0x3300, ), 0x8, Local5)
                Store(Match(DerefOf(Index(TIM0, 0x1, )), MLE, Local5, MTR, 0x0, 0x0), Local6)
                Store(DerefOf(Index(DerefOf(Index(TIM0, 0x0, )), Local6, )), Local7)
                Store(Local7, DMA0)
                If(And(Arg0, 0x8, )) {
                    Store(0x0384, PIO0)
                }
                Else {
                    Store(Local7, PIO0)
                }
                If(And(Arg0, 0x20, )) {
                    Or(CHNF, 0x8, CHNF)
                }
                If(And(Arg0, 0x4000, )) {
                    Or(CHNF, 0x10, CHNF)
                    Store(Match(DerefOf(Index(TIM0, 0x2, )), MLE, Arg1, MTR, 0x0, 0x0), Local5)
                    Store(DerefOf(Index(DerefOf(Index(TIM0, 0x0, )), Local5, )), Local6)
                    Store(Local6, DMA1)
                    If(And(Arg0, 0x80, )) {
                        Store(0x0384, PIO1)
                    }
                    Else {
                        Store(Local6, PIO1)
                    }
                }
                If(And(Arg2, 0x1, )) {
                    And(Arg3, 0x3, Local5)
                    If(LAnd(And(Arg5, 0x1, ), LEqual(Local5, 0x1))) {
                        Add(Local5, 0x4, Local5)
                    }
                    Else {
                        If(And(Arg4, 0x1, )) {
                            Add(Local5, 0x2, Local5)
                        }
                    }
                    Store(DerefOf(Index(DerefOf(Index(TIM0, 0x3, )), Local5, )), DMA0)
                    Or(CHNF, 0x1, CHNF)
                }
                If(And(Arg2, 0x2, )) {
                    And(ShiftRight(Arg3, 0x4, ), 0x3, Local5)
                    If(LAnd(And(Arg5, 0x2, ), LEqual(Local5, 0x1))) {
                        Add(Local5, 0x4, Local5)
                    }
                    Else {
                        If(And(Arg4, 0x2, )) {
                            Add(Local5, 0x2, Local5)
                        }
                    }
                    Store(DerefOf(Index(DerefOf(Index(TIM0, 0x3, )), Local5, )), DMA1)
                    Or(CHNF, 0x4, CHNF)
                }
                Store(TMD0, Debug)
                Return(TMD0)
            }
            Method(STM_, 0, Serialized) {
                If(REGF) {
                }
                Else {
                    Return(0x0)
                }
                And(GTIM, 0x8044, GTIM)
                Store(0x0, GSTM)
                Store(0x0, GUDM)
                Store(0x0, GCB0)
                And(GUDT, 0xcc, GUDT)
                Store(0x0, GFB0)
                If(And(CHNF, 0x1, )) {
                    Store(Match(DerefOf(Index(TIM0, 0x3, )), MLE, DMA0, MTR, 0x0, 0x0), Local0)
                    If(LGreater(Local0, 0x5)) {
                        Store(0x5, Local0)
                    }
                    Or(GUDT, DerefOf(Index(DerefOf(Index(TIM0, 0x4, )), Local0, )), GUDT)
                    Or(GCB0, DerefOf(Index(DerefOf(Index(TIM0, 0x5, )), Local0, )), GCB0)
                    Or(GFB0, DerefOf(Index(DerefOf(Index(TIM0, 0x6, )), Local0, )), GFB0)
                    Or(GUDM, 0x1, GUDM)
                }
                Else {
                    If(Or(LEqual(PIO0, Ones), LEqual(PIO0, 0x0), )) {
                        If(And(LLess(DMA0, Ones), LGreater(DMA0, 0x0), )) {
                            Store(DMA0, PIO0)
                            Or(GTIM, 0x8, GTIM)
                        }
                    }
                }
                If(And(CHNF, 0x4, )) {
                    Store(Match(DerefOf(Index(TIM0, 0x3, )), MLE, DMA1, MTR, 0x0, 0x0), Local0)
                    If(LGreater(Local0, 0x5)) {
                        Store(0x5, Local0)
                    }
                    Or(GUDT, ShiftLeft(DerefOf(Index(DerefOf(Index(TIM0, 0x4, )), Local0, )), 0x4, ), GUDT)
                    Or(GCB0, ShiftLeft(DerefOf(Index(DerefOf(Index(TIM0, 0x5, )), Local0, )), 0x1, ), GCB0)
                    Or(GFB0, ShiftLeft(DerefOf(Index(DerefOf(Index(TIM0, 0x6, )), Local0, )), 0x1, ), GFB0)
                    Or(GUDM, 0x2, GUDM)
                }
                Else {
                    If(Or(LEqual(PIO1, Ones), LEqual(PIO1, 0x0), )) {
                        If(And(LLess(DMA1, Ones), LGreater(DMA1, 0x0), )) {
                            Store(DMA1, PIO1)
                            Or(GTIM, 0x80, GTIM)
                        }
                    }
                }
                If(And(CHNF, 0x2, )) {
                    Or(GTIM, 0x3, GTIM)
                }
                If(And(CHNF, 0x8, )) {
                    Or(GTIM, 0x30, GTIM)
                }
                And(Match(DerefOf(Index(TIM0, 0x0, )), MGE, PIO0, MTR, 0x0, 0x0), 0x3, Local0)
                Store(DerefOf(Index(DerefOf(Index(TIM0, 0x1, )), Local0, )), Local1)
                ShiftLeft(Local1, 0x8, Local2)
                Or(GTIM, Local2, GTIM)
                If(And(CHNF, 0x10, )) {
                    Or(GTIM, 0x4000, GTIM)
                    And(Match(DerefOf(Index(TIM0, 0x0, )), MGE, PIO1, MTR, 0x0, 0x0), 0x3, Local0)
                    Store(DerefOf(Index(DerefOf(Index(TIM0, 0x2, )), Local0, )), GSTM)
                }
                Return(0x1)
            }
            Name(AT01, Buffer(0x7) {0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0xef })
            Name(AT02, Buffer(0x7) {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x90 })
            Name(AT03, Buffer(0x7) {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc6 })
            Name(AT04, Buffer(0x7) {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x91 })
            Name(ATA0, Buffer(0x1d) { })
            Name(ATA1, Buffer(0x1d) { })
            Name(ATA2, Buffer(0x1d) { })
            Name(ATA3, Buffer(0x1d) { })
            Name(ATAB, Buffer(0x1d) { })
            CreateByteField(ATAB, 0x0, CMDC)
            Method(GTFB, 3, Serialized) {
                Multiply(CMDC, 0x38, Local0)
                Add(Local0, 0x8, Local1)
                CreateField(ATAB, Local1, 0x38, CMDX)
                Multiply(CMDC, 0x7, Local0)
                CreateByteField(ATAB, Add(Local0, 0x2, ), A001)
                CreateByteField(ATAB, Add(Local0, 0x6, ), A005)
                Store(Arg0, CMDX)
                Store(Arg1, A001)
                Store(Arg2, A005)
                Increment(CMDC)
            }
            Method(GTF_, 2, Serialized) {
                Store(Arg1, Debug)
                Store(0x0, CMDC)
                Name(ID49, 0x0c00)
                Name(ID59, 0x0)
                Name(ID53, 0x4)
                Name(ID63, 0x0f00)
                Name(ID88, 0x0f00)
                Name(IRDY, 0x1)
                Name(PIOT, 0x0)
                Name(DMAT, 0x0)
                If(LEqual(SizeOf(Arg1), 0x0200)) {
                    CreateWordField(Arg1, 0x62, IW49)
                    Store(IW49, ID49)
                    CreateWordField(Arg1, 0x6a, IW53)
                    Store(IW53, ID53)
                    CreateWordField(Arg1, 0x7e, IW63)
                    Store(IW63, ID63)
                    CreateWordField(Arg1, 0x76, IW59)
                    Store(IW59, ID59)
                    CreateWordField(Arg1, 0xb0, IW88)
                    Store(IW88, ID88)
                }
                Store(0xa0, Local7)
                If(Arg0) {
                    Store(0xb0, Local7)
                    And(CHNF, 0x8, IRDY)
                    If(And(CHNF, 0x10, )) {
                        Store(PIO1, PIOT)
                    }
                    Else {
                        Store(PIO0, PIOT)
                    }
                    If(And(CHNF, 0x4, )) {
                        If(And(CHNF, 0x10, )) {
                            Store(DMA1, DMAT)
                        }
                        Else {
                            Store(DMA0, DMAT)
                        }
                    }
                }
                Else {
                    And(CHNF, 0x2, IRDY)
                    Store(PIO0, PIOT)
                    If(And(CHNF, 0x1, )) {
                        Store(DMA0, DMAT)
                    }
                }
                If(LAnd(LAnd(And(ID53, 0x4, ), And(ID88, 0xff00, )), DMAT)) {
                    Store(Match(DerefOf(Index(TIM0, 0x3, )), MLE, DMAT, MTR, 0x0, 0x0), Local1)
                    If(LGreater(Local1, 0x5)) {
                        Store(0x5, Local1)
                    }
                    GTFB(AT01, Or(0x40, Local1, ), Local7)
                }
                Else {
                    If(LAnd(And(ID63, 0xff00, ), PIOT)) {
                        And(Match(DerefOf(Index(TIM0, 0x0, )), MGE, PIOT, MTR, 0x0, 0x0), 0x3, Local0)
                        Or(0x20, DerefOf(Index(DerefOf(Index(TIM0, 0x8, )), Local0, )), Local1)
                        GTFB(AT01, Local1, Local7)
                    }
                }
                If(IRDY) {
                    And(Match(DerefOf(Index(TIM0, 0x0, )), MGE, PIOT, MTR, 0x0, 0x0), 0x3, Local0)
                    Or(0x8, DerefOf(Index(DerefOf(Index(TIM0, 0x7, )), Local0, )), Local1)
                    GTFB(AT01, Local1, Local7)
                }
                Else {
                    If(And(ID49, 0x0400, )) {
                        GTFB(AT01, 0x1, Local7)
                    }
                }
                If(LAnd(And(ID59, 0x0100, ), And(ID59, 0xff, ))) {
                    GTFB(AT03, And(ID59, 0xff, ), Local7)
                }
                Store(ATAB, Debug)
                Return(ATAB)
            }
            Method(RATA, 1) {
                CreateByteField(Arg0, 0x0, CMDN)
                Multiply(CMDN, 0x38, Local0)
                CreateField(Arg0, 0x8, Local0, RETB)
                Store(RETB, Debug)
                Return(RETB)
            }
        }
        Device(SMBC) {
            Name(_ADR, 0x001f0003)
        }
        Device(MODM) {
            Name(_ADR, 0x001f0006)
            Method(_PRW) {
                Return(GPRW(0x5, 0x3))
            }
        }
        Device(USB1) {
            Name(_ADR, 0x001d0000)
            OperationRegion(BAR0, PCI_Config, 0xc0, 0x5)
            Field(BAR0, ByteAcc, NoLock, Preserve) {
                UBL1,	16,
                Offset(0x4),
                P0WE,	1,
                P1WE,	1,
                Offset(0x5)
            }
            Method(_PSW, 1) {
                If(Arg0) {
                    Store(0x1, P0WE)
                    Store(0x1, P1WE)
                }
                Else {
                    Store(0x0, P0WE)
                    Store(0x0, P1WE)
                }
            }
            Method(UPAC, 1) {
                Store(Zero, Local0)
                If(LEqual(OSFG, OS9X)) {
                    Store(One, Local0)
                }
                Else {
                    If(LEqual(OSFG, OS98)) {
                        Store(One, Local0)
                    }
                }
                If(Local0) {
                    If(LEqual(Arg0, 0x3)) {
                        Return(One)
                    }
                }
                Return(Zero)
            }
            OperationRegion(UPCI, PCI_Config, 0x20, 0x4)
            Field(UPCI, ByteAcc, NoLock, Preserve) {
                UBAS,	32
            }
            Name(BASA, 0xb400)
            Name(P0ST, Zero)
            Name(P1ST, Zero)
            Method(SSTA) {
                Store(UBAS, BASA)
                And(BASA, 0xfffffffe, BASA)
                OperationRegion(UHCI, SystemIO, BASA, 0x20)
                Field(UHCI, ByteAcc, NoLock, Preserve) {
                    RSTP,	1,
                    HRST,	1,
                    GRST,	1,
                    Offset(0x10),
                    CCS0,	1,
                    CSC0,	1,
                    PED0,	1,
                    Offset(0x12),
                    CCS1,	1,
                    CSC1,	1,
                    PED1,	1
                }
                Store(CCS0, P0ST)
                Store(CCS1, P1ST)
            }
            Method(RSTA) {
                Store(BASA, UBAS)
                OperationRegion(UHCI, SystemIO, BASA, 0x20)
                Field(UHCI, ByteAcc, NoLock, Preserve) {
                    RSTP,	1,
                    HRST,	1,
                    GRST,	1,
                    Offset(0x10),
                    CCS0,	1,
                    CSC0,	1,
                    PED0,	1,
                    Offset(0x12),
                    CCS1,	1,
                    CSC1,	1,
                    PED1,	1
                }
            }
            Method(USBS, 1) {
                If(UPAC(Arg0)) {
                    SSTA()
                }
            }
            Method(USBW, 1) {
                If(UPAC(Arg0)) {
                    RSTA()
                }
            }
            Method(_PRW) {
                Return(GPRW(0x3, 0x3))
            }
        }
        Device(USB2) {
            Name(_ADR, 0x001d0001)
            OperationRegion(BAR0, PCI_Config, 0xc0, 0x5)
            Field(BAR0, ByteAcc, NoLock, Preserve) {
                UBL1,	16,
                Offset(0x4),
                P0WE,	1,
                P1WE,	1,
                Offset(0x5)
            }
            Method(_PSW, 1) {
                If(Arg0) {
                    Store(0x1, P0WE)
                    Store(0x1, P1WE)
                }
                Else {
                    Store(0x0, P0WE)
                    Store(0x0, P1WE)
                }
            }
            Method(UPAC, 1) {
                Store(Zero, Local0)
                If(LEqual(OSFG, OS9X)) {
                    Store(One, Local0)
                }
                Else {
                    If(LEqual(OSFG, OS98)) {
                        Store(One, Local0)
                    }
                }
                If(Local0) {
                    If(LEqual(Arg0, 0x3)) {
                        Return(One)
                    }
                }
                Return(Zero)
            }
            OperationRegion(UPCI, PCI_Config, 0x20, 0x4)
            Field(UPCI, ByteAcc, NoLock, Preserve) {
                UBAS,	32
            }
            Name(BASA, 0xb400)
            Name(P0ST, Zero)
            Name(P1ST, Zero)
            Method(SSTA) {
                Store(UBAS, BASA)
                And(BASA, 0xfffffffe, BASA)
                OperationRegion(UHCI, SystemIO, BASA, 0x20)
                Field(UHCI, ByteAcc, NoLock, Preserve) {
                    RSTP,	1,
                    HRST,	1,
                    GRST,	1,
                    Offset(0x10),
                    CCS0,	1,
                    CSC0,	1,
                    PED0,	1,
                    Offset(0x12),
                    CCS1,	1,
                    CSC1,	1,
                    PED1,	1
                }
                Store(CCS0, P0ST)
                Store(CCS1, P1ST)
            }
            Method(RSTA) {
                Store(BASA, UBAS)
                OperationRegion(UHCI, SystemIO, BASA, 0x20)
                Field(UHCI, ByteAcc, NoLock, Preserve) {
                    RSTP,	1,
                    HRST,	1,
                    GRST,	1,
                    Offset(0x10),
                    CCS0,	1,
                    CSC0,	1,
                    PED0,	1,
                    Offset(0x12),
                    CCS1,	1,
                    CSC1,	1,
                    PED1,	1
                }
            }
            Method(USBS, 1) {
                If(UPAC(Arg0)) {
                    SSTA()
                }
            }
            Method(USBW, 1) {
                If(UPAC(Arg0)) {
                    RSTA()
                }
            }
            Method(_PRW) {
                Return(GPRW(0x4, 0x3))
            }
        }
        Device(USB3) {
            Name(_ADR, 0x001d0002)
            OperationRegion(BAR0, PCI_Config, 0xc0, 0x5)
            Field(BAR0, ByteAcc, NoLock, Preserve) {
                UBL1,	16,
                Offset(0x4),
                P0WE,	1,
                P1WE,	1,
                Offset(0x5)
            }
            Method(_PSW, 1) {
                If(Arg0) {
                    Store(0x1, P0WE)
                    Store(0x1, P1WE)
                }
                Else {
                    Store(0x0, P0WE)
                    Store(0x0, P1WE)
                }
            }
            Method(UPAC, 1) {
                Store(Zero, Local0)
                If(LEqual(OSFG, OS9X)) {
                    Store(One, Local0)
                }
                Else {
                    If(LEqual(OSFG, OS98)) {
                        Store(One, Local0)
                    }
                }
                If(Local0) {
                    If(LEqual(Arg0, 0x3)) {
                        Return(One)
                    }
                }
                Return(Zero)
            }
            OperationRegion(UPCI, PCI_Config, 0x20, 0x4)
            Field(UPCI, ByteAcc, NoLock, Preserve) {
                UBAS,	32
            }
            Name(BASA, 0xb400)
            Name(P0ST, Zero)
            Name(P1ST, Zero)
            Method(SSTA) {
                Store(UBAS, BASA)
                And(BASA, 0xfffffffe, BASA)
                OperationRegion(UHCI, SystemIO, BASA, 0x20)
                Field(UHCI, ByteAcc, NoLock, Preserve) {
                    RSTP,	1,
                    HRST,	1,
                    GRST,	1,
                    Offset(0x10),
                    CCS0,	1,
                    CSC0,	1,
                    PED0,	1,
                    Offset(0x12),
                    CCS1,	1,
                    CSC1,	1,
                    PED1,	1
                }
                Store(CCS0, P0ST)
                Store(CCS1, P1ST)
            }
            Method(RSTA) {
                Store(BASA, UBAS)
                OperationRegion(UHCI, SystemIO, BASA, 0x20)
                Field(UHCI, ByteAcc, NoLock, Preserve) {
                    RSTP,	1,
                    HRST,	1,
                    GRST,	1,
                    Offset(0x10),
                    CCS0,	1,
                    CSC0,	1,
                    PED0,	1,
                    Offset(0x12),
                    CCS1,	1,
                    CSC1,	1,
                    PED1,	1
                }
            }
            Method(USBS, 1) {
                If(UPAC(Arg0)) {
                    SSTA()
                }
            }
            Method(USBW, 1) {
                If(UPAC(Arg0)) {
                    RSTA()
                }
            }
            Method(_PRW) {
                Return(GPRW(0xc, 0x3))
            }
        }
        Device(EHCI) {
            Name(_ADR, 0x001d0007)
            OperationRegion(U20P, PCI_Config, 0x0, 0x0100)
            Field(U20P, ByteAcc, NoLock, Preserve) {
                Offset(0x4),
                ,	1,
                MSPE,	1,
                Offset(0x6),
                Offset(0x10),
                MBAS,	32,
                Offset(0x54),
                PSTA,	2,
                Offset(0x55),
                PMEE,	1,
                ,	6,
                PMES,	1
            }
            Method(_PSW, 1) {
                Store(MBAS, Local0)
                And(Local0, 0xfffffff0, Local0)
                OperationRegion(MMIO, SystemMemory, Local0, 0x0100)
                Field(MMIO, ByteAcc, NoLock, Preserve) {
                    Offset(0x64),
                    P0SC,	32,
                    P1SC,	32,
                    P2SC,	32,
                    P3SC,	32,
                    P4SC,	32,
                    P5SC,	32
                }
                If(LNot(Local0)) {
                    Store(PSTA, Local2)
                    Store(Zero, PSTA)
                    Store(MSPE, Local3)
                    Store(One, MSPE)
                    If(Arg0) {
                        Store(P0SC, Local4)
                        Or(Local4, 0x00300000, Local4)
                        Store(Local4, P0SC)
                        Store(P1SC, Local4)
                        Or(Local4, 0x00300000, Local4)
                        Store(Local4, P1SC)
                        Store(P2SC, Local4)
                        Or(Local4, 0x00300000, Local4)
                        Store(Local4, P2SC)
                        Store(P3SC, Local4)
                        Or(Local4, 0x00300000, Local4)
                        Store(Local4, P3SC)
                        Store(P4SC, Local4)
                        Or(Local4, 0x00300000, Local4)
                        Store(Local4, P4SC)
                        Store(P5SC, Local4)
                        Or(Local4, 0x00300000, Local4)
                        Store(Local4, P5SC)
                        Store(One, PMES)
                        Store(One, PMEE)
                    }
                    Else {
                        Store(P0SC, Local4)
                        And(Local4, 0xffcfffff, Local4)
                        Store(Local4, P0SC)
                        Store(P1SC, Local4)
                        And(Local4, 0xffcfffff, Local4)
                        Store(Local4, P1SC)
                        Store(P2SC, Local4)
                        And(Local4, 0xffcfffff, Local4)
                        Store(Local4, P2SC)
                        Store(P3SC, Local4)
                        And(Local4, 0xffcfffff, Local4)
                        Store(Local4, P3SC)
                        Store(P4SC, Local4)
                        And(Local4, 0xffcfffff, Local4)
                        Store(Local4, P4SC)
                        Store(P5SC, Local4)
                        And(Local4, 0xffcfffff, Local4)
                        Store(Local4, P5SC)
                        Store(One, PMES)
                        Store(Zero, PMEE)
                    }
                    Store(Local3, MSPE)
                    Store(Local2, PSTA)
                }
            }
            Method(_PRW) {
                Return(GPRW(0xd, 0x3))
            }
        }
    }
}
Scope(\_PR_.CPU1) {
    Name(TYPE, 0x0)
    Name(PDCR, 0x1)
    Name(PDCM, 0x1)
    Method(_PDC, 1) {
        Store(SizeOf(Arg0), Local0)
        Name(PDCB, Buffer(Local0) { })
        Store(Arg0, PDCB)
        CreateDWordField(PDCB, 0x0, REV_)
        CreateDWordField(PDCB, 0x4, SIZE)
        If(LNot(LEqual(REV_, PDCR))) {
            Return(0x0)
        }
        If(LLess(SIZE, 0x1)) {
            Return(0x0)
        }
        CreateDWordField(PDCB, 0x8, DAT0)
        If(And(DAT0, PDCM, )) {
            Store(0x1, TYPE)
        }
        Return(0x1)
    }
    Name(MPCT, Package(0x2) {
        Buffer(0x11) {0x82, 0xc, 0x0, 0x7f, 0x40, 0x0, 0x0, 0x99, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x0 },
        Buffer(0x11) {0x82, 0xc, 0x0, 0x7f, 0x10, 0x0, 0x0, 0x98, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x0 },
    })
    Name(PPCT, Package(0x2) {
        Buffer(0x11) {0x82, 0xc, 0x0, 0x1, 0x10, 0x0, 0x0, 0xb2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x0 },
        Buffer(0x11) {0x82, 0xc, 0x0, 0x1, 0x8, 0x0, 0x0, 0xb3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x0 },
    })
    Method(_PCT) {
        If(TYPE) {
            Return(MPCT)
        }
        Else {
            Return(PPCT)
        }
    }
    Name(MPSS, Package(0xa) {
        Package(0x6) {
            0x03e8,
            0x1b58,
            0xa,
            0xa,
            0x0a13,
            0x0a13,
        },
        Package(0x6) {
            0x03e8,
            0x1b58,
            0xa,
            0xa,
            0x0a13,
            0x0a13,
        },
        Package(0x6) {
            0x03e8,
            0x1b58,
            0xa,
            0xa,
            0x0a13,
            0x0a13,
        },
        Package(0x6) {
            0x03e8,
            0x1b58,
            0xa,
            0xa,
            0x0a13,
            0x0a13,
        },
        Package(0x6) {
            0x03e8,
            0x1b58,
            0xa,
            0xa,
            0x0a13,
            0x0a13,
        },
        Package(0x6) {
            0x03e8,
            0x1b58,
            0xa,
            0xa,
            0x0a13,
            0x0a13,
        },
        Package(0x6) {
            0x03e8,
            0x1b58,
            0xa,
            0xa,
            0x0a13,
            0x0a13,
        },
        Package(0x6) {
            0x0384,
            0x186a,
            0xa,
            0xa,
            0x0912,
            0x0912,
        },
        Package(0x6) {
            0x0320,
            0x157c,
            0xa,
            0xa,
            0x0811,
            0x0811,
        },
        Package(0x6) {
            0x0258,
            0x0fa0,
            0xa,
            0xa,
            0x0609,
            0x0609,
        },
    })
    Name(PPSS, Package(0xa) {
        Package(0x6) {
            0x03e8,
            0x1b58,
            0xa,
            0x6e,
            0x86,
            0x0,
        },
        Package(0x6) {
            0x03e8,
            0x1b58,
            0xa,
            0x6e,
            0x86,
            0x0,
        },
        Package(0x6) {
            0x03e8,
            0x1b58,
            0xa,
            0x6e,
            0x86,
            0x0,
        },
        Package(0x6) {
            0x03e8,
            0x1b58,
            0xa,
            0x6e,
            0x86,
            0x0,
        },
        Package(0x6) {
            0x03e8,
            0x1b58,
            0xa,
            0x6e,
            0x0086,
            0x0,
        },
        Package(0x6) {
            0x03e8,
            0x1b58,
            0xa,
            0x6e,
            0x0086,
            0x0,
        },
        Package(0x6) {
            0x03e8,
            0x1b58,
            0xa,
            0x6e,
            0x0086,
            0x0,
        },
        Package(0x6) {
            0x0384,
            0x186a,
            0xa,
            0x6e,
            0x0186,
            0x1,
        },
        Package(0x6) {
            0x0320,
            0x157c,
            0xa,
            0x6e,
            0x0286,
            0x2,
        },
        Package(0x6) {
            0x0258,
            0x0fa0,
            0xa,
            0x6e,
            0x0386,
            0x3,
        },
    })
    Name(NPSS, 0x4)
    Method(_PSS) {
        If(TYPE) {
            Return(MPSS)
        }
        Else {
            Return(PPSS)
        }
    }
    Method(_PPC) {
        If(LNot(LGreater(SizeOf(PPSS), NPSS))) {
            Return(0x0)
        }
        Else {
            Return(Subtract(SizeOf(PPSS), NPSS, ))
        }
    }
}
Scope(\_SB_) {
    OperationRegion(\_SB_.PCI0.SBRG.IROR, PCI_Config, 0x0, 0xff)
    Field(\_SB_.PCI0.SBRG.IROR, ByteAcc, NoLock, Preserve) {
        Offset(0x60),
        PIRA,	8,
        PIRB,	8,
        PIRC,	8,
        PIRD,	8,
        Offset(0x68),
        PIRE,	8,
        PIRF,	8,
        PIRG,	8,
        PIRH,	8
    }
    Name(BUFA, Buffer(0x6) {0x23, 0x0, 0x80, 0x18, 0x79, 0x0 })
    CreateWordField(BUFA, 0x1, ICRS)
    Method(LSTA, 1) {
        And(Arg0, 0x80, Local0)
        If(Local0) {
            Return(0x9)
        }
        Else {
            Return(0xb)
        }
    }
    Method(LCRS, 1) {
        And(Arg0, 0xf, Local0)
        ShiftLeft(0x1, Local0, ICRS)
        Return(BUFA)
    }
    Method(LSRS, 1) {
        CreateWordField(Arg0, 0x1, ISRS)
        FindSetRightBit(ISRS, Local0)
        Return(Decrement(Local0))
    }
    Method(LDIS, 1) {
        Return(Or(Arg0, 0x80, ))
    }
    Device(LNKA) {
        Name(_HID, 0x0f0cd041)
        Name(_UID, 0x1)
        Method(_STA) {
            Return(LSTA(PIRA))
        }
        Method(_PRS) {
            Return(PRSA)
        }
        Method(_DIS) {
            Store(LDIS(PIRA), PIRA)
        }
        Method(_CRS) {
            Return(LCRS(PIRA))
        }
        Method(_SRS, 1) {
            Store(LSRS(Arg0), PIRA)
        }
    }
    Device(LNKB) {
        Name(_HID, 0x0f0cd041)
        Name(_UID, 0x2)
        Method(_STA) {
            Return(LSTA(PIRB))
        }
        Method(_PRS) {
            Return(PRSB)
        }
        Method(_DIS) {
            Store(LDIS(PIRB), PIRB)
        }
        Method(_CRS) {
            Return(LCRS(PIRB))
        }
        Method(_SRS, 1) {
            Store(LSRS(Arg0), PIRB)
        }
    }
    Device(LNKC) {
        Name(_HID, 0x0f0cd041)
        Name(_UID, 0x3)
        Method(_STA) {
            Return(LSTA(PIRC))
        }
        Method(_PRS) {
            Return(PRSC)
        }
        Method(_DIS) {
            Store(LDIS(PIRC), PIRC)
        }
        Method(_CRS) {
            Return(LCRS(PIRC))
        }
        Method(_SRS, 1) {
            Store(LSRS(Arg0), PIRC)
        }
    }
    Device(LNKD) {
        Name(_HID, 0x0f0cd041)
        Name(_UID, 0x4)
        Method(_STA) {
            Return(LSTA(PIRD))
        }
        Method(_PRS) {
            Return(PRSD)
        }
        Method(_DIS) {
            Store(LDIS(PIRD), PIRD)
        }
        Method(_CRS) {
            Return(LCRS(PIRD))
        }
        Method(_SRS, 1) {
            Store(LSRS(Arg0), PIRD)
        }
    }
    Device(LNKE) {
        Name(_HID, 0x0f0cd041)
        Name(_UID, 0x5)
        Method(_STA) {
            Return(LSTA(PIRE))
        }
        Method(_PRS) {
            Return(PRSE)
        }
        Method(_DIS) {
            Store(LDIS(PIRE), PIRE)
        }
        Method(_CRS) {
            Return(LCRS(PIRE))
        }
        Method(_SRS, 1) {
            Store(LSRS(Arg0), PIRE)
        }
    }
    Device(LNKF) {
        Name(_HID, 0x0f0cd041)
        Name(_UID, 0x6)
        Method(_STA) {
            Return(LSTA(PIRF))
        }
        Method(_PRS) {
            Return(PRSF)
        }
        Method(_DIS) {
            Store(LDIS(PIRF), PIRF)
        }
        Method(_CRS) {
            Return(LCRS(PIRF))
        }
        Method(_SRS, 1) {
            Store(LSRS(Arg0), PIRF)
        }
    }
    Device(LNKG) {
        Name(_HID, 0x0f0cd041)
        Name(_UID, 0x7)
        Method(_STA) {
            Return(LSTA(PIRG))
        }
        Method(_PRS) {
            Return(PRSG)
        }
        Method(_DIS) {
            Store(LDIS(PIRG), PIRG)
        }
        Method(_CRS) {
            Return(LCRS(PIRG))
        }
        Method(_SRS, 1) {
            Store(LSRS(Arg0), PIRG)
        }
    }
    Device(LNKH) {
        Name(_HID, 0x0f0cd041)
        Name(_UID, 0x8)
        Method(_STA) {
            Return(LSTA(PIRH))
        }
        Method(_PRS) {
            Return(PRSH)
        }
        Method(_DIS) {
            Store(LDIS(PIRH), PIRH)
        }
        Method(_CRS) {
            Return(LCRS(PIRH))
        }
        Method(_SRS, 1) {
            Store(LSRS(Arg0), PIRH)
        }
    }
}
Scope(\_SB_) {
    Scope(PCI0) {
        Name(CRS_, Buffer(0x88) {0x88, 0xd, 0x0, 0x2, 0xc, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x1, 0x47, 0x1, 0xf8, 0xc, 0xf8, 0xc, 0x1, 0x8, 0x88, 0xd, 0x0, 0x1, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0xf7, 0xc, 0x0, 0x0, 0xf8, 0xc, 0x88, 0xd, 0x0, 0x1, 0xc, 0x3, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x0, 0x0, 0x0, 0xf3, 0x87, 0x17, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0x0, 0xff, 0xff, 0xb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x0, 0x87, 0x17, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x87, 0x17, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x0 })
        CreateDWordField(CRS_, 0x5c, MIN5)
        CreateDWordField(CRS_, 0x60, MAX5)
        CreateDWordField(CRS_, 0x68, LEN5)
        CreateDWordField(CRS_, 0x76, MIN6)
        CreateDWordField(CRS_, 0x7a, MAX6)
        CreateDWordField(CRS_, 0x82, LEN6)
        Method(_CRS) {
            Store(MG1B, MIN5)
            Store(MG1L, LEN5)
            Store(MG1L, Local0)
            If(Local0) {
                Add(MIN5, Decrement(Local0), MAX5)
            }
            Store(MG2B, MIN6)
            Store(MG2L, LEN6)
            Store(MG2L, Local0)
            Add(MIN6, Decrement(Local0), MAX6)
            Return(CRS_)
        }
    }
}
If(SS1_) {
    Name(\_SB_.PCI0._S1D, 0x2)
    Name(\_SB_.PCI0.P0P1._S1D, 0x2)
    Name(\_SB_.PCI0.USB1._S1D, 0x2)
    Name(\_SB_.PCI0.USB2._S1D, 0x2)
    Name(\_SB_.PCI0.USB3._S1D, 0x2)
}
If(SS3_) {
    Name(\_SB_.PCI0._S3D, 0x2)
    Name(\_SB_.PCI0.P0P1._S3D, 0x2)
    Name(\_SB_.PCI0.USB1._S3D, 0x2)
    Name(\_SB_.PCI0.USB2._S3D, 0x2)
    Name(\_SB_.PCI0.USB3._S3D, 0x2)
}
If(SS4_) {
    Name(\_SB_.PCI0._S4D, 0x2)
    Name(\_SB_.PCI0.P0P1._S4D, 0x2)
}
Method(_PTS, 1) {
    Store(Arg0, DBG8)
    PTS_(Arg0)
    Store(0x0, Index(WAKP, 0x0, ))
    Store(0x0, Index(WAKP, 0x1, ))
}
Name(SLID, 0x1)
Method(_WAK, 1) {
    ShiftLeft(Arg0, 0x4, DBG8)
    Store(0x1, SLID)
    WAK_(Arg0)
    If(DerefOf(Index(WAKP, 0x0, ))) {
        Store(0x0, Index(WAKP, 0x1, ))
    }
    Else {
        Store(Arg0, Index(WAKP, 0x1, ))
    }
    Return(WAKP)
}
Name(_S0_, Package(0x4) {
    0x0,
    0x0,
    0x0,
    0x0,
})
If(SS1_) {
    Name(_S1_, Package(0x4) {
        0x2,
        0x0,
        0x0,
        0x0,
    })
}
If(SS3_) {
    Name(_S3_, Package(0x4) {
        0x5,
        0x0,
        0x0,
        0x0,
    })
}
If(SS4_) {
    Name(_S4_, Package(0x4) {
        0x6,
        0x0,
        0x0,
        0x0,
    })
}
Name(_S5_, Package(0x4) {
    0x7,
    0x0,
    0x0,
    0x0,
})
Method(PTS_, 1) {
    If(Arg0) {
        FANS(Arg0)
        \_TZ_.TRMS(Arg0)
    }
    OEMS(Arg0)
}
Method(WAK_, 1) {
    FANW(Arg0)
    \_TZ_.TRMW(Arg0)
    OEMW(Arg0)
}

}
/*
APIC: Length=84, Revision=1, Checksum=111,
	OEMID=A M I, OEM Table ID=OEMAPIC, OEM Revision=0x7000301,
	Creator ID=MSFT, Creator Revision=0x97
 */
/*
	Local APIC ADDR=0xfee00000
	Flags={PC-AT}

	Type=Local APIC
	ACPI CPU=1
	Flags={ENABLED}
	APIC ID=0

	Type=IO APIC
	APIC ID=1
	INT BASE=0
	ADDR=0xfec00000

	Type=INT Override
	BUS=0
	IRQ=0
	INTR=2
	Flags={Polarity=conforming, Trigger=conforming}

	Type=INT Override
	BUS=0
	IRQ=9
	INTR=9
	Flags={Polarity=active-hi, Trigger=level}
 */
/*
OEMB: Length=77, Revision=1, Checksum=67,
	OEMID=A M I, OEM Table ID=OEMBIOS, OEM Revision=0x7000301,
	Creator ID=MSFT, Creator Revision=0x97
 */

--Dxnq1zWXvFF0Q93v
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment; filename="xp7310.dmesg"

Copyright (c) 1992-2003 The FreeBSD Project.
Copyright (c) 1979, 1980, 1983, 1986, 1988, 1989, 1991, 1992, 1993, 1994
	The Regents of the University of California. All rights reserved.
FreeBSD 5.1-RELEASE #0: Thu Jun  5 02:55:42 GMT 2003
    root@wv1u.btc.adaptec.com:/usr/obj/usr/src/sys/GENERIC
Preloaded elf kernel "/boot/kernel/kernel" at 0xc06d4000.
Preloaded elf module "/boot/kernel/acpi.ko" at 0xc06d41cc.
Calibrating clock(s) ... i8254 clock: 1193164 Hz
CLK_USE_I8254_CALIBRATION not specified - using default frequency
Timecounter "i8254"  frequency 1193182 Hz
Calibrating TSC clock ... TSC clock: 1000039712 Hz
Timecounter "TSC"  frequency 1000039712 Hz
CPU: Intel(R) Pentium(R) M processor 1000MHz (1000.04-MHz 686-class CPU)
  Origin = "GenuineIntel"  Id = 0x695  Stepping = 5
  Features=0xa7e9fbbf<FPU,VME,DE,PSE,TSC,MSR,MCE,CX8,APIC,SEP,MTRR,PGE,MCA,CMOV,PAT,CLFLUSH,DTS,ACPI,MMX,FXSR,SSE,SSE2,TM,PBE>
real memory  = 527695872 (503 MB)
Physical memory chunk(s):
0x0000000000001000 - 0x000000000009efff, 647168 bytes (158 pages)
0x00000000006fb000 - 0x000000001ee40fff, 510943232 bytes (124742 pages)
avail memory = 505167872 (481 MB)
pnpbios: Found PnP BIOS data at 0xc00f2df0
pnpbios: Entry = f0000:39ca  Rev = 1.0
Other BIOS signatures found:
wlan: <802.11 Link Layer>
null: <null device, zero device>
random: <entropy source>
mem: <memory & I/O>
Pentium Pro MTRR support enabled
npx0: <math processor> on motherboard
npx0: INT 16 interface
acpi0: <A M I  OEMRSDT > on motherboard
pci_open(1):	mode 1 addr port (0x0cf8) is 0x8000005c
pci_open(1a):	mode1res=0x80000000 (0x80000000)
pci_cfgcheck:	device 0 [class=060000] [hdr=80] is there (id=35808086)
pcibios: No call entry point
pcibios: No call entry point
AcpiOsDerivePciId: bus 1 dev 3 func 0
AcpiOsDerivePciId: bus 0 dev 31 func 0
AcpiOsDerivePciId: bus 0 dev 31 func 0
acpi0: power button is handled as a fixed feature programming model.
ACPI timer looks GOOD min = 2, max = 3, width = 1
ACPI timer looks GOOD min = 2, max = 3, width = 1
ACPI timer looks GOOD min = 2, max = 3, width = 1
ACPI timer looks GOOD min = 2, max = 3, width = 1
ACPI timer looks GOOD min = 2, max = 3, width = 1
ACPI timer looks GOOD min = 2, max = 3, width = 1
ACPI timer looks GOOD min = 2, max = 3, width = 1
ACPI timer looks GOOD min = 2, max = 3, width = 1
ACPI timer looks GOOD min = 2, max = 3, width = 1
ACPI timer looks GOOD min = 2, max = 3, width = 1
Timecounter "ACPI-fast"  frequency 3579545 Hz
AcpiOsDerivePciId: bus 0 dev 31 func 0
acpi_timer0: <24-bit timer at 3.579545MHz> port 0xe408-0xe40b on acpi0
acpi_cpu0: <CPU> on acpi0
acpi_tz0: <thermal zone> on acpi0
acpi_tz0: _CRT value is absurd, ignored (255.0C)
acpi_tz0: _PSV value is absurd, ignored (255.0C)
acpi_tz0: _ACx value is absurd, ignored (255.0C)
pcib0: <ACPI Host-PCI bridge> port 0xcf8-0xcff on acpi0
---- initial configuration ------------------------
\\_SB_.LNKA irq   5: [  3  4  5  6  7 11 12] low,level,sharable 0.2.0
\\_SB_.LNKC irq   7: [  3  4  5  6  7 12] low,level,sharable 0.31.0
\\_SB_.LNKB irq   0: [  3  4  5  6  7 12] low,level,sharable 0.31.1
\\_SB_.LNKA irq   5: [  3  4  5  6  7 11 12] low,level,sharable 0.29.0
\\_SB_.LNKD irq   4: [  3  4  5  6  7 12] low,level,sharable 0.29.1
\\_SB_.LNKC irq   7: [  3  4  5  6  7 12] low,level,sharable 0.29.2
\\_SB_.LNKH irq   3: [  3  4  5  6  7 12] low,level,sharable 0.29.3
---- before setting priority for links ------------
\\_SB_.LNKB:
	interrupts:	     3     4     5     6     7    12
	penalty:	  1210  1210   310  1110  1310  1110
	references:	1
	priority:	0
---- before fixup boot-disabled links -------------
\\_SB_.LNKB:
	interrupts:	     3     4     5     6     7    12
	penalty:	  1210  1210   310  1110  1310  1110
	references:	1
	priority:	1043
---- after fixup boot-disabled links --------------
---- arbitrated configuration ---------------------
\\_SB_.LNKA irq   5: [  3  4  5  6  7 11 12] low,level,sharable 0.2.0
\\_SB_.LNKC irq   7: [  3  4  5  6  7 12] low,level,sharable 0.31.0
\\_SB_.LNKB irq   5: [  3  4  5  6  7 12] low,level,sharable 0.31.1
\\_SB_.LNKA irq   5: [  3  4  5  6  7 11 12] low,level,sharable 0.29.0
\\_SB_.LNKD irq   4: [  3  4  5  6  7 12] low,level,sharable 0.29.1
\\_SB_.LNKC irq   7: [  3  4  5  6  7 12] low,level,sharable 0.29.2
\\_SB_.LNKH irq   3: [  3  4  5  6  7 12] low,level,sharable 0.29.3
pci0: <ACPI PCI bus> on pcib0
pci0: physical bus=0
	map[10]: type 3, range 32, base 00000000, size  0, enabled
found->	vendor=0x8086, dev=0x3580, revid=0x02
	bus=0, slot=0, func=0
	class=06-00-00, hdrtype=0x00, mfdev=1
	cmdreg=0x0106, statreg=0x2090, cachelnsz=0 (dwords)
	lattimer=0x00 (0 ns), mingnt=0x00 (0 ns), maxlat=0x00 (0 ns)
found->	vendor=0x8086, dev=0x3584, revid=0x02
	bus=0, slot=0, func=1
	class=08-80-00, hdrtype=0x00, mfdev=0
	cmdreg=0x0006, statreg=0x0080, cachelnsz=0 (dwords)
	lattimer=0x00 (0 ns), mingnt=0x00 (0 ns), maxlat=0x00 (0 ns)
found->	vendor=0x8086, dev=0x3585, revid=0x02
	bus=0, slot=0, func=3
	class=08-80-00, hdrtype=0x00, mfdev=1
	cmdreg=0x0006, statreg=0x0080, cachelnsz=0 (dwords)
	lattimer=0x00 (0 ns), mingnt=0x00 (0 ns), maxlat=0x00 (0 ns)
	map[10]: type 3, range 32, base f0000000, size 27, enabled
	map[14]: type 1, range 32, base feb00000, size 19, enabled
	map[18]: type 4, range 32, base 0000dc00, size  3, enabled
found->	vendor=0x8086, dev=0x3582, revid=0x02
	bus=0, slot=2, func=0
	class=03-00-00, hdrtype=0x00, mfdev=1
	cmdreg=0x0007, statreg=0x0090, cachelnsz=0 (dwords)
	lattimer=0x00 (0 ns), mingnt=0x00 (0 ns), maxlat=0x00 (0 ns)
	intpin=a, irq=5
	powerspec 1  supports D0 D1 D3  current D0
	map[10]: type 3, range 32, base e8000000, size 27, enabled
	map[14]: type 1, range 32, base fea80000, size 19, enabled
found->	vendor=0x8086, dev=0x3582, revid=0x02
	bus=0, slot=2, func=1
	class=03-80-00, hdrtype=0x00, mfdev=1
	cmdreg=0x0007, statreg=0x0090, cachelnsz=0 (dwords)
	lattimer=0x00 (0 ns), mingnt=0x00 (0 ns), maxlat=0x00 (0 ns)
	powerspec 1  supports D0 D1 D3  current D0
	map[20]: type 4, range 32, base 0000d480, size  5, enabled
found->	vendor=0x8086, dev=0x24c2, revid=0x03
	bus=0, slot=29, func=0
	class=0c-03-00, hdrtype=0x00, mfdev=1
	cmdreg=0x0005, statreg=0x0280, cachelnsz=0 (dwords)
	lattimer=0x00 (0 ns), mingnt=0x00 (0 ns), maxlat=0x00 (0 ns)
	intpin=a, irq=5
	map[20]: type 4, range 32, base 0000d800, size  5, enabled
found->	vendor=0x8086, dev=0x24c4, revid=0x03
	bus=0, slot=29, func=1
	class=0c-03-00, hdrtype=0x00, mfdev=0
	cmdreg=0x0005, statreg=0x0280, cachelnsz=0 (dwords)
	lattimer=0x00 (0 ns), mingnt=0x00 (0 ns), maxlat=0x00 (0 ns)
	intpin=b, irq=4
	map[20]: type 4, range 32, base 0000d880, size  5, enabled
found->	vendor=0x8086, dev=0x24c7, revid=0x03
	bus=0, slot=29, func=2
	class=0c-03-00, hdrtype=0x00, mfdev=0
	cmdreg=0x0005, statreg=0x0280, cachelnsz=0 (dwords)
	lattimer=0x00 (0 ns), mingnt=0x00 (0 ns), maxlat=0x00 (0 ns)
	intpin=c, irq=7
	map[10]: type 1, range 32, base febff800, size 10, enabled
found->	vendor=0x8086, dev=0x24cd, revid=0x03
	bus=0, slot=29, func=7
	class=0c-03-20, hdrtype=0x00, mfdev=0
	cmdreg=0x0106, statreg=0x0290, cachelnsz=0 (dwords)
	lattimer=0x00 (0 ns), mingnt=0x00 (0 ns), maxlat=0x00 (0 ns)
	intpin=d, irq=3
	powerspec 2  supports D0 D3  current D0
found->	vendor=0x8086, dev=0x2448, revid=0x83
	bus=0, slot=30, func=0
	class=06-04-00, hdrtype=0x01, mfdev=0
	cmdreg=0x0107, statreg=0x8080, cachelnsz=0 (dwords)
	lattimer=0x00 (0 ns), mingnt=0x06 (1500 ns), maxlat=0x00 (0 ns)
found->	vendor=0x8086, dev=0x24cc, revid=0x03
	bus=0, slot=31, func=0
	class=06-01-00, hdrtype=0x00, mfdev=1
	cmdreg=0x000f, statreg=0x0280, cachelnsz=0 (dwords)
	lattimer=0x00 (0 ns), mingnt=0x00 (0 ns), maxlat=0x00 (0 ns)
	map[10]: type 4, range 32, base 00000000, size  3, enabled
	map[14]: type 4, range 32, base 00000000, size  2, enabled
	map[18]: type 4, range 32, base 00000000, size  3, enabled
	map[1c]: type 4, range 32, base 00000000, size  2, enabled
	map[20]: type 4, range 32, base 0000ffa0, size  4, enabled
found->	vendor=0x8086, dev=0x24ca, revid=0x03
	bus=0, slot=31, func=1
	class=01-01-8a, hdrtype=0x00, mfdev=0
	cmdreg=0x0005, statreg=0x0280, cachelnsz=0 (dwords)
	lattimer=0x00 (0 ns), mingnt=0x00 (0 ns), maxlat=0x00 (0 ns)
	intpin=a, irq=255
	map[10]: type 4, range 32, base 0000e000, size  8, enabled
	map[14]: type 4, range 32, base 0000e100, size  6, enabled
found->	vendor=0x8086, dev=0x24c5, revid=0x03
	bus=0, slot=31, func=5
	class=04-01-00, hdrtype=0x00, mfdev=0
	cmdreg=0x0005, statreg=0x0290, cachelnsz=0 (dwords)
	lattimer=0x00 (0 ns), mingnt=0x00 (0 ns), maxlat=0x00 (0 ns)
	intpin=b, irq=255
	powerspec 2  supports D0 D3  current D0
	map[10]: type 4, range 32, base 0000e200, size  8, enabled
	map[14]: type 4, range 32, base 0000e300, size  7, enabled
found->	vendor=0x8086, dev=0x24c6, revid=0x03
	bus=0, slot=31, func=6
	class=07-03-00, hdrtype=0x00, mfdev=0
	cmdreg=0x0005, statreg=0x0290, cachelnsz=0 (dwords)
	lattimer=0x00 (0 ns), mingnt=0x00 (0 ns), maxlat=0x00 (0 ns)
	intpin=b, irq=255
	powerspec 2  supports D0 D3  current D0
pci0: <base peripheral> at device 0.1 (no driver attached)
pci0: <base peripheral> at device 0.3 (no driver attached)
agp0: <Intel 8285xM (85xGM GMCH) SVGA controller> port 0xdc00-0xdc07 mem 0xfeb00000-0xfeb7ffff,0xf0000000-0xf7ffffff irq 5 at device 2.0 on pci0
agp0: detected 8060k stolen memory
agp0: aperture size is 128M
pci0: <display> at device 2.1 (no driver attached)
uhci0: <Intel 82801DB (ICH4) USB controller USB-A> port 0xd480-0xd49f irq 5 at device 29.0 on pci0
usb0: <Intel 82801DB (ICH4) USB controller USB-A> on uhci0
usb0: USB revision 1.0
uhub0: Intel UHCI root hub, class 9/0, rev 1.00/1.00, addr 1
uhub0: 2 ports with 2 removable, self powered
uhci1: <Intel 82801DB (ICH4) USB controller USB-B> port 0xd800-0xd81f irq 4 at device 29.1 on pci0
usb1: <Intel 82801DB (ICH4) USB controller USB-B> on uhci1
usb1: USB revision 1.0
uhub1: Intel UHCI root hub, class 9/0, rev 1.00/1.00, addr 1
uhub1: 2 ports with 2 removable, self powered
uhci2: <Intel 82801DB (ICH4) USB controller USB-C> port 0xd880-0xd89f irq 7 at device 29.2 on pci0
usb2: <Intel 82801DB (ICH4) USB controller USB-C> on uhci2
usb2: USB revision 1.0
uhub2: Intel UHCI root hub, class 9/0, rev 1.00/1.00, addr 1
uhub2: 2 ports with 2 removable, self powered
pci0: <serial bus, USB> at device 29.7 (no driver attached)
pcibios: No call entry point
pcib1: <ACPI PCI-PCI bridge> at device 30.0 on pci0
pcib1:   secondary bus     1
pcib1:   subordinate bus   1
pcib1:   I/O decode        0xc000-0xcfff
pcib1:   memory decode     0xfe700000-0xfe8fffff
pcib1:   prefetched decode 0xde500000-0xde6fffff
---- initial configuration ------------------------
\\_SB_.LNKE irq   5: [  3  4  5  6  7 12] low,level,sharable 1.8.0
\\_SB_.LNKB irq   5: [  3  4  5  6  7 12] low,level,sharable 1.3.0
\\_SB_.LNKC irq   7: [  3  4  5  6  7 12] low,level,sharable 1.3.1
\\_SB_.LNKC irq   7: [  3  4  5  6  7 12] low,level,sharable 1.5.0
\\_SB_.LNKD irq   4: [  3  4  5  6  7 12] low,level,sharable 1.5.1
---- before setting priority for links ------------
---- before fixup boot-disabled links -------------
---- after fixup boot-disabled links --------------
---- arbitrated configuration ---------------------
\\_SB_.LNKE irq   5: [  3  4  5  6  7 12] low,level,sharable 1.8.0
\\_SB_.LNKB irq   5: [  3  4  5  6  7 12] low,level,sharable 1.3.0
\\_SB_.LNKC irq   7: [  3  4  5  6  7 12] low,level,sharable 1.3.1
\\_SB_.LNKC irq   7: [  3  4  5  6  7 12] low,level,sharable 1.5.0
\\_SB_.LNKD irq   4: [  3  4  5  6  7 12] low,level,sharable 1.5.1
pci1: <ACPI PCI bus> on pcib1
pci1: physical bus=1
found->	vendor=0x1180, dev=0x0475, revid=0xb8
	bus=1, slot=3, func=0
	class=06-07-00, hdrtype=0x02, mfdev=1
	cmdreg=0x0007, statreg=0x0210, cachelnsz=0 (dwords)
	lattimer=0x20 (960 ns), mingnt=0x80 (32000 ns), maxlat=0x07 (1750 ns)
	intpin=a, irq=255
	powerspec 2  supports D0 D1 D2 D3  current D0
	map[10]: type 1, range 32, base fe8ff000, size 11, enabled
found->	vendor=0x1180, dev=0x0551, revid=0x00
	bus=1, slot=3, func=1
	class=0c-00-10, hdrtype=0x00, mfdev=1
	cmdreg=0x0106, statreg=0x0210, cachelnsz=0 (dwords)
	lattimer=0x40 (1920 ns), mingnt=0x02 (500 ns), maxlat=0x04 (1000 ns)
	intpin=b, irq=7
	powerspec 2  supports D0 D3  current D0
	map[10]: type 1, range 32, base fe8fd000, size 12, enabled
found->	vendor=0x8086, dev=0x1043, revid=0x04
	bus=1, slot=5, func=0
	class=02-80-00, hdrtype=0x00, mfdev=0
	cmdreg=0x0116, statreg=0x0290, cachelnsz=16 (dwords)
	lattimer=0x40 (1920 ns), mingnt=0x02 (500 ns), maxlat=0x22 (8500 ns)
	intpin=a, irq=7
	powerspec 2  supports D0 D3  current D0
	map[10]: type 1, range 32, base fe8fe000, size 12, enabled
	map[14]: type 4, range 32, base 0000cc00, size  6, enabled
found->	vendor=0x8086, dev=0x103e, revid=0x83
	bus=1, slot=8, func=0
	class=02-00-00, hdrtype=0x00, mfdev=0
	cmdreg=0x0117, statreg=0x0290, cachelnsz=16 (dwords)
	lattimer=0x40 (1920 ns), mingnt=0x08 (2000 ns), maxlat=0x38 (14000 ns)
	intpin=a, irq=5
	powerspec 2  supports D0 D1 D2 D3  current D0
cbb0: <RF5C475 PCI-CardBus Bridge> at device 3.0 on pci1
pcib1: device cbb0 requested decoded memory range 0xfe700000-0xfe8fffff
cardbus0: <CardBus bus> on cbb0
pccard0: <16-bit PCCard bus> on cbb0
pcib1: matched entry for 1.3.INTA (source \\_SB_.LNKB)
pcib1: slot 3 INTA is routed to irq 5
fwohci0: <Ricoh R5C551> mem 0xfe8ff000-0xfe8ff7ff irq 7 at device 3.1 on pci1
fwohci0: latency timer 64 -> 64.
fwohci0: cache size 0 -> 8.
pcib1: device fwohci0 requested decoded memory range 0xfe8ff000-0xfe8ff7ff
fwohci0: OHCI version 1.0 (ROM=1)
fwohci0: No. of Isochronous channel is 4.
fwohci0: EUI64 00:e0:18:00:03:0b:a4:64
fwohci0: resetting OHCI...done (loop=0)
fwohci0: fwphy_rddata: loop=27, retry=0
fwohci0: fwphy_rddata: loop=1, retry=0
fwohci0: Phy 1394a available S400, 2 ports.
fwohci0: fwphy_rddata: loop=1, retry=0
fwohci0: Enable 1394a Enhancements
fwohci0: fwphy_rddata: loop=1, retry=0
fwohci0: fwphy_rddata: loop=1, retry=0
fwohci0: fwphy_rddata: loop=1, retry=0
fwohci0: fwphy_rddata: loop=1, retry=0
fwohci0: fwphy_rddata: loop=1, retry=0
fwohci0: Link S400, max_rec 2048 bytes.
fwohci0: BUS_OPT 0xf800a002 -> 0xf800a002
fwohci0: fwohci_set_intr: 1
firewire0: <IEEE1394(FireWire) bus> on fwohci0
if_fwe0: <Ethernet over FireWire> on firewire0
if_fwe0: Fake Ethernet address: 02:e0:18:0b:a4:64
fwe0: bpf attached
sbp0: <SBP2/SCSI over firewire> on firewire0
sbp_attach (cold=1)
fwohci0: Initiate bus reset
fwohci0: fwphy_rddata: loop=1, retry=0
fwohci0: fwphy_rddata: loop=1, retry=0
pci1: <network> at device 5.0 (no driver attached)
fxp0: <Intel 82801DB (ICH4) Pro/100 VM Ethernet> port 0xcc00-0xcc3f mem 0xfe8fe000-0xfe8fefff irq 5 at device 8.0 on pci1
pcib1: device fxp0 requested decoded memory range 0xfe8fe000-0xfe8fefff
fxp0: using memory space register mapping
fxp0: Ethernet address 00:80:88:03:be:e7
fxp0: PCI IDs: 8086 103e 1043 1745 0083
fxp0: Dynamic Standby mode is disabled
miibus0: <MII bus> on fxp0
inphy0: <i82562EM 10/100 media interface> on miibus0
inphy0:  10baseT, 10baseT-FDX, 100baseTX, 100baseTX-FDX, auto
fxp0: bpf attached
isab0: <PCI-ISA bridge> at device 31.0 on pci0
isa0: <ISA bus> on isab0
atapci0: <Intel ICH4 UDMA100 controller> port 0xffa0-0xffaf,0-0x3,0-0x7,0-0x3,0-0x7 at device 31.1 on pci0
ata0: pre reset mask=03 ostat0=50 ostat2=00
ata0-master: ATAPI 00 00
ata0-slave: ATAPI 00 00
ata0: after reset mask=03 stat0=50 stat1=00
ata0-master: ATA 01 a5
ata0: devices=01
ata0: at 0x1f0 irq 14 on atapci0
ata1: pre reset mask=03 ostat0=00 ostat2=00
ata1-master: ATAPI 74 74
ata1-slave: ATAPI 74 74
ata1: after reset mask=03 stat0=74 stat1=74
ata1: devices=00
ata1: at 0x170 irq 15 on atapci0
pci0: <multimedia, audio> at device 31.5 (no driver attached)
pci0: <simple comms> at device 31.6 (no driver attached)
acpi_button0: <Power Button> on acpi0
acpi_lid0: <Control Method Lid Switch> on acpi0
acpi_acad0: <AC adapter> on acpi0
acpi_cmbat0: <Control method Battery> on acpi0
acpi_cmbat1: <Control method Battery> on acpi0
atkbdc0: <Keyboard controller (i8042)> port 0x64,0x60 irq 1 on acpi0
atkbd0: <AT Keyboard> flags 0x1 irq 1 on atkbdc0
atkbd: the current kbd controller command byte 0065
atkbd: keyboard ID 0x41ab (2)
kbd0 at atkbd0
kbd0: atkbd0, AT 101/102 (2), config:0x1, flags:0x3d0000
psm0: unable to allocate IRQ
psmcpnp0 irq 12 on acpi0
psm0: current command byte:0065
psm0: <PS/2 Mouse> irq 12 on atkbdc0
psm0: model Generic PS/2 mouse, device ID 0-00, 2 buttons
psm0: config:00000000, flags:00000000, packet size:3
psm0: syncmask:c0, syncbits:00
acpi_ec0: <embedded controller> port 0x66,0x62 on acpi0
ata: ata0 already exists; skipping it
ata: ata1 already exists; skipping it
atkbdc: atkbdc0 already exists; skipping it
Trying Read_Port at 203
Trying Read_Port at 243
Trying Read_Port at 283
Trying Read_Port at 2c3
Trying Read_Port at 303
Trying Read_Port at 343
Trying Read_Port at 383
Trying Read_Port at 3c3
ex_isa_identify()
sc: sc0 already exists; skipping it
vga: vga0 already exists; skipping it
isa_probe_children: disabling PnP devices
isa_probe_children: probing non-PnP devices
orm0: <Option ROMs> at iomem 0xcd000-0xce7ff,0xc0000-0xccfff on isa0
pmtimer0 on isa0
adv0: not probed (disabled)
aha0: not probed (disabled)
aic0: not probed (disabled)
bt0: not probed (disabled)
cs0: not probed (disabled)
ed0: not probed (disabled)
fdc0: ready for input in output
fdc0: cmd 3 failed at out byte 1 of 3
fdc0 failed to probe at port 0x3f7,0x3f0-0x3f5 irq 6 drq 2 on isa0
fe0: not probed (disabled)
ie0: not probed (disabled)
le0: not probed (disabled)
lnc0: not probed (disabled)
pcic0 failed to probe at port 0x3e0 iomem 0xd0000 on isa0
pcic1: not probed (disabled)
ppc0: parallel port not found.
ppc0: <Parallel port> failed to probe at irq 7 on isa0
sc0: <System console> at flags 0x100 on isa0
sc0: VGA <16 virtual consoles, flags=0x300>
sc0: fb0, kbd0, terminal emulator: sc (syscons terminal)
sio0: configured irq 4 not in bitmap of probed irqs 0
sio0: port may not be enabled
sio0: irq maps: 0 0 0 0
sio0: probe failed test(s): 0 1 2 4 6 7 9
sio0 at port 0x3f8-0x3ff irq 4 flags 0x10 on isa0
sio0: type 8250 or not responding
sio1: configured irq 3 not in bitmap of probed irqs 0
sio1: port may not be enabled
sio1: irq maps: 0 0 0 0
sio1: probe failed test(s): 0 1 2 4 6 7 9
sio1 failed to probe at port 0x2f8-0x2ff irq 3 on isa0
sio2: not probed (disabled)
sio3: not probed (disabled)
sn0: not probed (disabled)
vga0: <Generic ISA VGA> at port 0x3c0-0x3df iomem 0xa0000-0xbffff on isa0
fb0: vga0, vga, type:VGA (5), flags:0x7007f
fb0: port:0x3c0-0x3df, crtc:0x3d4, mem:0xa0000 0x20000
fb0: init mode:24, bios mode:3, current mode:24
fb0: window:0xc00b8000 size:32k gran:32k, buf:0 size:32k
vga0: vga: WARNING: video mode switching is not fully supported on this adapter
VGA parameters upon power-up
50 18 10 00 00 00 03 00 02 67 5f 4f 50 82 55 81 
bf 1f 00 4f 0d 0e 00 00 07 80 9c 8e 8f 28 1f 96 
b9 a3 ff 00 01 02 03 04 05 14 07 38 39 3a 3b 3c 
3d 3e 3f 04 00 0f 08 00 00 00 00 00 10 0e 00 ff 
VGA parameters in BIOS for mode 24
50 18 10 00 10 00 03 00 02 67 5f 4f 50 82 55 81 
bf 1f 00 4f 0d 0e 00 00 00 00 9c 8e 8f 28 1f 96 
b9 a3 ff 00 01 02 03 04 05 14 07 38 39 3a 3b 3c 
3d 3e 3f 0c 00 0f 08 00 00 00 00 00 10 0e 00 ff 
EGA/VGA parameters to be used for mode 24
50 18 10 00 00 00 03 00 02 67 5f 4f 50 82 55 81 
bf 1f 00 4f 0d 0e 00 00 07 80 9c 8e 8f 28 1f 96 
b9 a3 ff 00 01 02 03 04 05 14 07 38 39 3a 3b 3c 
3d 3e 3f 04 00 0f 08 00 00 00 00 00 10 0e 00 ff 
vt0: not probed (disabled)
isa_probe_children: probing PnP devices
Device configuration finished.
procfs registered
Timecounters tick every 10.000 msec
lo0: bpf attached
fwohci0: BUS reset
sbp_post_busreset
fwohci0: node_id=0xc800ffc0, gen=1, CYCLEMASTER mode
firewire0: 1 nodes, maxhop <= 0, cable IRM = 0 (me)
fwohci0: fw_set_bus_manager: 0->0 (loop=0)
firewire0: bus manager 0 (me)
send phy_config root_node=-1 gap_count=5
fwohci0: maxdesc: 2
fwohci0: start AT DMA status=0
acpi_cpu0: set speed to 100.0%
acpi_cpu: throttling enabled, 8 steps (100% to 12.5%), currently 100.0%
acpi_acad0: acline initialization start
acpi_acad0: On Line
acpi_acad0: acline initialization done, tried 1 times
acpi_cmbat0: battery initialization start
acpi_cmbat1: battery initialization start
ad0: success setting UDMA100 on Intel ICH4 chip
ad0: <IC25N040ATMR04-0/MO2OAD0A> ATA-6 disk at ata0-master
ad0: 38154MB (78140160 sectors), 77520 C, 16 H, 63 S, 512 B
ad0: 16 secs/int, 1 depth queue, UDMA100
ad0: piomode=12 dmamode=34 udmamode=69 cblid=1
GEOM: new disk ad0
ar: FreeBSD check1 failed
[0] f:00 typ:27 s(CHS):0/1/1 e(CHS):287/254/63 s:63 l:4626657
[1] f:00 typ:28 s(CHS):288/0/1 e(CHS):1023/254/63 s:4626720 l:59167395
[2] f:80 typ:165 s(CHS):1023/255/63 e(CHS):1023/254/63 s:63794115 l:14346045
[3] f:00 typ:0 s(CHS):0/0/0 e(CHS):0/0/0 s:0 l:0
GEOM: Configure ad0s1, start 32256 length 2368848384 end 2368880639
GEOM: Configure ad0s2, start 2368880640 length 30293706240 end 32662586879
GEOM: Configure ad0s3, start 32662586880 length 7345175040 end 40007761919
acpi_cmbat0: battery initialization done, tried 1 times
GEOM: Configure ad0s3a, start 629145600 length 6716029440 end 7345175039
GEOM: Configure ad0s3b, start 0 length 629145600 end 629145599
GEOM: Configure ad0s3c, start 0 length 7345175040 end 7345175039
acpi_cmbat1: battery initialization done, tried 1 times
bus_explore done
sbp_post_explore (sbp_cold=2)
(probe0:sbp0:0:0:0): error 22
(probe0:sbp0:0:0:0): Unretryable Error
(probe1:sbp0:0:1:0): error 22
(probe1:sbp0:0:1:0): Unretryable Error
(probe2:sbp0:0:2:0): error 22
(probe2:sbp0:0:2:0): Unretryable Error
(probe3:sbp0:0:3:0): error 22
(probe3:sbp0:0:3:0): Unretryable Error
(probe4:sbp0:0:4:0): error 22
(probe4:sbp0:0:4:0): Unretryable Error
(probe5:sbp0:0:5:0): error 22
(probe5:sbp0:0:5:0): Unretryable Error
(probe6:sbp0:0:6:0): error 22
(probe6:sbp0:0:6:0): Unretryable Error
Mounting root from ufs:/dev/ad0s3a
start_init: trying /sbin/init
acpi_tz0: _CRT value is absurd, ignored (255.0C)
acpi_tz0: _PSV value is absurd, ignored (255.0C)
acpi_tz0: _ACx value is absurd, ignored (255.0C)
acpi_tz0: _CRT value is absurd, ignored (255.0C)
acpi_tz0: _PSV value is absurd, ignored (255.0C)
acpi_tz0: _ACx value is absurd, ignored (255.0C)

--Dxnq1zWXvFF0Q93v
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment; filename="xp7310.hw.acpi"

hw.acpi.supported_sleep_state: S1 S3 S4 S5 
hw.acpi.power_button_state: S5
hw.acpi.sleep_button_state: S1
hw.acpi.lid_switch_state: S1
hw.acpi.standby_state: S1
hw.acpi.suspend_state: S3
hw.acpi.sleep_delay: 0
hw.acpi.s4bios: 1
hw.acpi.verbose: 1
hw.acpi.disable_on_poweroff: 1
hw.acpi.cpu.max_speed: 8
hw.acpi.cpu.current_speed: 8
hw.acpi.cpu.performance_speed: 8
hw.acpi.cpu.economy_speed: 4
hw.acpi.thermal.min_runtime: 0
hw.acpi.thermal.polling_rate: 30
hw.acpi.thermal.tz0.temperature: 3332
hw.acpi.thermal.tz0.active: -1
hw.acpi.thermal.tz0.thermal_flags: 0
hw.acpi.thermal.tz0._PSV: -1
hw.acpi.thermal.tz0._HOT: -1
hw.acpi.thermal.tz0._CRT: -1
hw.acpi.thermal.tz0._ACx: -1 -1 -1 -1 -1 -1 -1 -1 -1 -1
hw.acpi.acline: 1
hw.acpi.battery.life: 100
hw.acpi.battery.time: -1
hw.acpi.battery.state: 2
hw.acpi.battery.units: 2
hw.acpi.battery.info_expire: 5

--Dxnq1zWXvFF0Q93v--
