Bug 124412

Summary: [acpi] power off error on Toshiba M40 laptop
Product: Base System Reporter: Wayne Chapeskie <waynec>
Component: kernAssignee: freebsd-acpi (Nobody) <acpi>
Status: Closed FIXED    
Severity: Affects Only Me    
Priority: Normal    
Version: 7.0-RELEASE   
Hardware: Any   
OS: Any   
Attachments:
Description Flags
toshiba-m40.dsdt none

Description Wayne Chapeskie 2008-06-09 10:50:04 UTC
	Powering the system off with ACPI does not work; power does
	not shut off; it is necessary to remove the battery to shut
	the machine off.

	Background:  ACPI support for this machine has been improving
	with recent releases.  The ACPI BIOS was blacklisted before
	6.2; 6.2 tried to enable ACPI by default, but the hard disk
	was not recognized.  After the major ACPI code update in early
	2007, ACPI seemed to mostly work in 7-CURRENT snapshots.  In
	7.0, ACPI seems to be mostly working, with the exception of
	this power problem.

Fix: Workarounds: Either
	    - disable ACPI, or
	    - use shutdown -r to shutdown and start a reboot; power
	      down when bootany asks for a partition to boot from.

	Attachments:
	    dmesg-v	- verbose dmesg boot messages
	    toshiba-m40.dsdt
	    toshiba-m40.asl
		- DSDT and ASL produced under 7.0 by:
		  acpidump -t -d -o toshiba-m40.dsdt >toshiba-m40.asl
	DSDT tables, ASL output, and verbose dmesg boot messages are
	attached.



/*
  RSD PTR: OEM=TOSINV, ACPI_Rev=1.0x (0)
	RSDT=0x3fff89f7, cksum=64
 */
/*
  RSDT: Length=52, Revision=1, Checksum=133,
	OEMID=INSYDE, OEM Table ID=RSDT_000, OEM Revision=0x100,
	Creator ID=ABCD, Creator Revision=0x10200
	Entries={ 0x3ffffb30, 0x3ffffbc0, 0x3fff8be5, 0x3fff8a2b }
 */
/*
  FACP: Length=116, Revision=1, Checksum=89,
	OEMID=TOSINV, OEM Table ID=FACP_000, OEM Revision=0x100,
	Creator ID=0000, Creator Revision=0x10200
 	FACS=0x3fffffc0, DSDT=0x3fff9040
	INT_MODEL=PIC
	Preferred_PM_Profile=Unspecified (0)
	SCI_INT=9
	SMI_CMD=0xb2, ACPI_ENABLE=0xe0, ACPI_DISABLE=0xe1, S4BIOS_REQ=0xe2
	PSTATE_CNT=0x80
	PM1a_EVT_BLK=0x1000-0x1003
	PM1a_CNT_BLK=0x1004-0x1005
	PM2_CNT_BLK=0x1020-0x1020
	PM_TMR_BLK=0x1008-0x100b
	GPE0_BLK=0x1028-0x102f
	CST_CNT=0x85
	P_LVL2_LAT=1 us, P_LVL3_LAT=85 us
	FLUSH_SIZE=0, FLUSH_STRIDE=0
	DUTY_OFFSET=1, DUTY_WIDTH=3
	DAY_ALRM=13, MON_ALRM=0, CENTURY=50
	IAPC_BOOT_ARCH={LEGACY_DEV,8042}
	Flags={WBINVD,PROC_C1,SLP_BUTTON,RTC_S4,DCK_CAP}
 */
/*
  FACS:	Length=64, HwSig=0x00000000, Firm_Wake_Vec=0x00000000
	Global_Lock=
	Flags=
	Version=0
 */
/*
  DSDT: Length=27365, Revision=1, Checksum=36,
	OEMID=TOSINV, OEM Table ID=SONOMA, OEM Revision=0x1004,
	Creator ID=INTL, Creator Revision=0x2002036
 */
/*
  MCFG: Length=60, Revision=1, Checksum=175,
	OEMID=INSYDE, OEM Table ID=MCFG_000, OEM Revision=0x30303030,
	Creator ID=0000, Creator Revision=0x30303030

	Base Address= 0x00000000e0000000
	Segment Group= 0x0000
	Start Bus= 0
	End Bus= 255
 */
/*
  SSDT: Length=633, Revision=1, Checksum=211,
	OEMID=PmRef, OEM Table ID=Cpu0Ist, OEM Revision=0x3000,
	Creator ID=INTL, Creator Revision=0x20030522
 */
/*
  SSDT: Length=442, Revision=1, Checksum=12,
	OEMID=PmRef, OEM Table ID=Cpu0Cst, OEM Revision=0x3001,
	Creator ID=INTL, Creator Revision=0x20030522
 */
/*
 * Intel ACPI Component Architecture
 * AML Disassembler version 20070320
 *
 * Disassembly of /tmp/acpidump.cahi93, Sun Jun  8 20:14:33 2008
 *
 *
 * Original Table Header:
 *     Signature        "DSDT"
 *     Length           0x00006ED0 (28368)
 *     Revision         0x01
 *     OEM ID           "TOSINV"
 *     OEM Table ID     "SONOMA  "
 *     OEM Revision     0x00001004 (4100)
 *     Creator ID       "INTL"
 *     Creator Revision 0x02002036 (33562678)
 */
DefinitionBlock ("/tmp/acpidump.aml", "DSDT", 1, "TOSINV", "SONOMA  ", 0x00001004)
{
    OperationRegion (PRT0, SystemIO, 0x80, 0x04)
    Field (PRT0, DWordAcc, Lock, Preserve)
    {
        P80H,   32
    }

    OperationRegion (IO_T, SystemIO, 0x0800, 0x10)
    Field (IO_T, ByteAcc, NoLock, Preserve)
    {
                Offset (0x02), 
                Offset (0x04), 
                Offset (0x06), 
                Offset (0x08), 
        TRP0,   8, 
                Offset (0x0A), 
                Offset (0x0B), 
                Offset (0x0C), 
                Offset (0x0D), 
                Offset (0x0E), 
                Offset (0x0F), 
                Offset (0x10)
    }

    OperationRegion (GPIO, SystemIO, 0x1300, 0x3C)
    Field (GPIO, ByteAcc, NoLock, Preserve)
    {
        GU00,   8, 
        GU01,   8, 
        GU02,   8, 
        GU03,   8, 
        GIO0,   8, 
        GIO1,   8, 
        GIO2,   8, 
        GIO3,   8, 
                Offset (0x0C), 
        GL00,   8, 
        GL01,   8, 
            ,   5, 
        GP21,   1, 
            ,   1, 
        GP23,   1, 
            ,   1, 
        GP25,   1, 
                Offset (0x10), 
                Offset (0x18), 
        GB00,   8, 
        GB01,   8, 
        GB02,   8, 
        GB03,   8, 
                Offset (0x2C), 
        GIV0,   8, 
        GIV1,   8, 
        GIV2,   8, 
        GIV3,   8, 
        GU04,   8, 
        GU05,   8, 
        GU06,   8, 
        GU07,   8, 
        GIO4,   8, 
        GIO5,   8, 
        GIO6,   8, 
        GIO7,   8, 
            ,   1, 
        GP33,   1, 
                Offset (0x39), 
        GL05,   8, 
        GL06,   8, 
        GL07,   8
    }

    OperationRegion (MBOX, SystemMemory, 0x3FFFFC00, 0x0100)
    Field (MBOX, AnyAcc, Lock, Preserve)
    {
        MYOS,   16, 
        SMIF,   8, 
        PRM0,   8, 
        PRM1,   8, 
        SCIF,   8, 
        PRM2,   8, 
        PRM3,   8, 
        LCKF,   8, 
        PRM4,   8, 
        PRM5,   8, 
        P80D,   32, 
        LIDS,   8, 
        PWRS,   8, 
        DBGS,   8, 
                Offset (0x14), 
        ACTT,   8, 
        PSVT,   8, 
        TC1V,   8, 
        TC2V,   8, 
        TSPV,   8, 
        CRTT,   8, 
                Offset (0x1E), 
        BNUM,   8, 
        B0SC,   8, 
        B1SC,   8, 
        B2SC,   8, 
        B0SS,   8, 
        B1SS,   8, 
        B2SS,   8, 
                Offset (0x28), 
        WTHT,   8, 
                Offset (0x3C), 
        IGDS,   8, 
        TLST,   8, 
        CADL,   8, 
        PADL,   8, 
        CSTE,   16, 
        NSTE,   16, 
        SSTE,   16, 
        NDID,   8, 
        DID1,   32, 
        DID2,   32, 
        DID3,   32, 
        DID4,   32, 
        DID5,   32, 
                Offset (0x67), 
        BLCS,   8, 
        BRTL,   8, 
                Offset (0x82), 
        UTYP,   2, 
            ,   2, 
            ,   3, 
                Offset (0x83), 
        CMAD,   3, 
            ,   1, 
        CMBD,   3, 
                Offset (0x84), 
        PTYP,   2, 
        EPDA,   1, 
            ,   1, 
        LPTE,   2, 
            ,   1, 
        EPPT,   1, 
            ,   6, 
        AUEN,   1, 
        AU97,   1, 
        EHT,    8, 
        PCT,    1, 
        ALSS,   1, 
        EMAS,   1, 
                Offset (0x88), 
            ,   7, 
        KBDW,   1, 
        CLMT,   2, 
                Offset (0x8A), 
            ,   6, 
        WLAN,   1, 
                Offset (0x8B), 
        E_TV,   1, 
        EPRT,   1, 
        EFIR,   1, 
        E394,   1, 
        S510,   1, 
                Offset (0x8C), 
        CFGD,   16, 
                Offset (0x96), 
        ALSE,   8, 
        ALAF,   8, 
        LLOW,   8, 
        LHIH,   8, 
                Offset (0x9B), 
        EMAE,   8, 
        EMAP,   16, 
        EMAL,   16, 
                Offset (0xAA), 
        D400,   8, 
                Offset (0xB4), 
        GTF0,   56, 
        GTF2,   56, 
        IDEM,   8
    }

    OperationRegion (RCRB, SystemMemory, 0xF0008000, 0x4000)
    Field (RCRB, DWordAcc, Lock, Preserve)
    {
                Offset (0x1000), 
                Offset (0x3000), 
                Offset (0x3404), 
        HPAS,   2, 
            ,   5, 
        HPAE,   1, 
                Offset (0x3418), 
            ,   1, 
        PATD,   1, 
        SATD,   1, 
        SMBD,   1, 
        AZAD,   1, 
        A97D,   1, 
                Offset (0x341A), 
        RP1D,   1, 
        RP2D,   1, 
        RP3D,   1, 
        RP4D,   1
    }

    Mutex (MUTX, 0x00)
    Name (_S0, Package (0x03)
    {
        0x00, 
        0x00, 
        0x00
    })
    Name (_S3, Package (0x03)
    {
        0x05, 
        0x05, 
        0x00
    })
    Name (_S4, Package (0x03)
    {
        0x06, 
        0x06, 
        0x00
    })
    Name (_S5, Package (0x03)
    {
        0x07, 
        0x07, 
        0x00
    })
    Name (\PDC0, 0x80000000)
    Name (\PDC1, 0x80000000)
    Scope (\_PR)
    {
        Processor (CPU0, 0x00, 0x00001010, 0x06) {}
        Processor (CPU1, 0x01, 0x00001010, 0x06) {}
    }

    Name (\DSEN, 0x01)
    Name (\ECON, 0x00)
    Name (\GPIC, 0x00)
    Name (\CTYP, 0x00)
    Name (\L01C, 0x00)
    Method (\_PIC, 1, NotSerialized)
    {
        Store (Arg0, GPIC)
    }

    Method (\_PTS, 1, NotSerialized)
    {
        Store (0x01, PBST)
        While (PBST)
        {
            Store (0x01, PBST)
        }

        If (LEqual (DBGS, 0x00)) {}
        If (LEqual (Arg0, 0x03))
        {
            Store (\_SB.RDEC (0x92), Local0)
            Store (And (Local0, 0x01), LIDS)
            Store (\_SB.RDEC (0xB6), Local0)
            If (KBDW)
            {
                Store (Or (Local0, 0x02), Local0)
            }
            Else
            {
                Store (And (Local0, 0xFD), Local0)
            }

            Store (Or (Local0, 0x01), Local0)
            \_SB.WREC (0xB6, Local0)
            \_SB.GSMI (0x0A)
            \_SB.GSMI (0x0D)
            \_SB.GSMI (0x24)
            Store (0x53, P80H)
        }
        Else
        {
            If (LEqual (Arg0, 0x04))
            {
                Store (\_SB.RDEC (0xB6), Local0)
                Store (Or (Local0, 0x01), Local0)
                \_SB.WREC (0xB6, Local0)
                Store (\_SB.RDEC (0xB8), Local0)
                Store (Or (Local0, 0x02), Local0)
                \_SB.WREC (0xB8, Local0)
                \_SB.GSMI (0x0A)
                Store (0x01, MBS4)
                \_SB.GSMI (0x24)
                Store (0x54, P80H)
            }
            Else
            {
                If (LEqual (Arg0, 0x05))
                {
                    \_SB.GSMI (0x0A)
                    \_SB.GSMI (0x24)
                    Store (0x55, P80H)
                }
            }
        }
    }

    Method (\_WAK, 1, NotSerialized)
    {
        Store (\_SB.RDEC (0x92), Local0)
        Store (And (Local0, 0x20), Local0)
        ShiftRight (Local0, 0x05, Local0)
        If (Local0)
        {
            Notify (\_SB.BAT1, 0x80)
        }

        If (LEqual (Arg0, 0x03))
        {
            \_SB.GSMI (0x00)
            Store (0x00, GUID)
            Notify (\_SB.AC, 0x00)
            Notify (\_SB.BAT1, 0x81)
            Notify (\_SB.PCI0.USB1, 0x00)
            Notify (\_SB.PCI0.USB2, 0x00)
            Notify (\_SB.PCI0.USB3, 0x00)
            Notify (\_SB.PCI0.USB4, 0x00)
            Notify (\_SB.PCI0.RP02, 0x00)
            \_SB.GSMI (0x28)
            If (APMD)
            {
                Notify (\_SB.PWRB, 0x02)
                Store (0x00, APMD)
            }

            If (E394)
            {
                Notify (\_SB.PCI0.PCIB.FCRD, 0x01)
            }

            Store (\_SB.RDEC (0x92), Local0)
            Store (And (Local0, 0x08), Local0)
            ShiftRight (Local0, 0x03, Local0)
            Store (Local0, S_AC)
            Store (0xE3, P80H)
            Return (0x00)
        }
        Else
        {
            If (LEqual (Arg0, 0x04))
            {
                \_SB.GSMI (0x04)
                If (E394)
                {
                    If (\_SB.PCI0.PCIB.FCRD.MEMB)
                    {
                        \_SB.GSMI (0x13)
                        Store (0x01, GUID)
                    }
                }

                Notify (\_SB.AC, 0x00)
                Notify (\_SB.BAT1, 0x81)
                Notify (\_SB.PCI0.USB1, 0x00)
                Notify (\_SB.PCI0.USB2, 0x00)
                Notify (\_SB.PCI0.USB3, 0x00)
                Notify (\_SB.PCI0.USB4, 0x00)
                Notify (\_SB.PCI0.RP02, 0x00)
                Store (\_SB.RDEC (0xA2), Local0)
                If (LNotEqual (Local0, 0x00))
                {
                    Notify (\_SB.PWRB, 0x02)
                }

                Store (0x00, BNUM)
                Store (0x00, MBS4)
                Store (\_SB.RDEC (0x92), Local0)
                Store (And (Local0, 0x08), Local0)
                ShiftRight (Local0, 0x03, Local0)
                Store (Local0, S_AC)
                Store (0xE4, P80H)
                Return (0x00)
            }
            Else
            {
                Store (0xE5, P80H)
                Return (0x00)
            }
        }
    }

    Scope (\_GPE)
    {
        Method (_L01, 0, NotSerialized)
        {
            Add (L01C, 0x01, L01C)
            If (\_SB.PCI0.RP01.HPCS)
            {
                If (\_SB.PCI0.RP01.PDC1)
                {
                    Store (0x01, \_SB.PCI0.RP01.PDC1)
                }

                Store (0x01, \_SB.PCI0.RP01.HPCS)
            }

            If (\_SB.PCI0.RP02.HPCS)
            {
                If (LEqual (\_SB.PCI0.RP02.PDS2, 0x01))
                {
                    Store (0x00, \_SB.PCI0.RP02.RPLD)
                }
                Else
                {
                    Store (0x01, \_SB.PCI0.RP02.RPLD)
                }

                If (\_SB.PCI0.RP02.PDC2)
                {
                    Store (0x01, \_SB.PCI0.RP02.PDC2)
                }

                Store (0x01, \_SB.PCI0.RP02.HPCS)
            }

            If (\_SB.PCI0.RP03.HPCS)
            {
                If (\_SB.PCI0.RP03.PDC3)
                {
                    Store (0x01, \_SB.PCI0.RP03.PDC3)
                }

                Store (0x01, \_SB.PCI0.RP03.HPCS)
            }

            If (\_SB.PCI0.RP04.HPCS)
            {
                If (\_SB.PCI0.RP04.PDC4)
                {
                    Store (0x01, \_SB.PCI0.RP04.PDC4)
                }

                Store (0x01, \_SB.PCI0.RP04.HPCS)
            }

            If (D400)
            {
                Name (TBF3, Buffer (0x05)
                {
                    0x07, 0x66, 0x66, 0x40, 0x01
                })
                CreateByteField (TBF3, 0x01, CLCK)
                If (LEqual (\_SB.PCI0.RP01.PDS1, 0x00))
                {
                    And (CLCK, 0xFB, CLCK)
                }

                If (LEqual (\_SB.PCI0.RP02.PDS2, 0x00))
                {
                    And (CLCK, 0xBF, CLCK)
                }

                If (LEqual (\_SB.PCI0.RP03.PDS3, 0x00))
                {
                    And (CLCK, 0xFD, CLCK)
                }

                If (LEqual (\_SB.PCI0.RP04.PDS4, 0x00))
                {
                    And (CLCK, 0xDF, CLCK)
                }

                \_SB.PCI0.SBUS.SBLW (0xDC, 0x00, TBF3, 0x00)
                Stall (0x64)
            }

            Store (GP23, Local0)
            Store (GP33, Local1)
            Store (GP25, Local2)
            Sleep (0x0140)
            Store (\_SB.PCI0.RP01.PDS1, GP23)
            Store (\_SB.PCI0.RP02.PDS2, GP33)
            Store (\_SB.PCI0.RP03.PDS3, GP25)
            Sleep (0x64)
            If (LNotEqual (GP23, Local0))
            {
                Notify (\_SB.PCI0.RP01, 0x00)
            }

            If (LNotEqual (GP33, Local1))
            {
                Notify (\_SB.PCI0.RP02, 0x00)
            }

            If (LNotEqual (GP25, Local2))
            {
                Notify (\_SB.PCI0.RP03, 0x00)
            }
        }

        Method (_L03, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.USB1, 0x02)
        }

        Method (_L04, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.USB2, 0x02)
        }

        Method (_L05, 0, NotSerialized)
        {
            If (AZAD)
            {
                Notify (\_SB.PCI0.MODM, 0x02)
            }
            Else
            {
            }
        }

        Method (_L07, 0, NotSerialized)
        {
            Store (0x20, \_SB.PCI0.SBUS.HSTS)
        }

        Method (_L08, 0, NotSerialized)
        {
        }

        Method (_L09, 0, NotSerialized)
        {
            If (\_SB.PCI0.RP01.PSP1)
            {
                Store (0x01, \_SB.PCI0.RP01.PSP1)
                Store (0x01, \_SB.PCI0.RP01.PMCS)
                Notify (\_SB.PCI0.RP01, 0x02)
            }

            If (\_SB.PCI0.RP02.PSP2)
            {
                Store (0x01, \_SB.PCI0.RP02.PSP2)
                Store (0x01, \_SB.PCI0.RP02.PMCS)
                Notify (\_SB.PCI0.RP02, 0x02)
            }

            If (\_SB.PCI0.RP03.PSP3)
            {
                Store (0x01, \_SB.PCI0.RP03.PSP3)
                Store (0x01, \_SB.PCI0.RP03.PMCS)
                Notify (\_SB.PCI0.RP03, 0x02)
            }

            If (\_SB.PCI0.RP04.PSP4)
            {
                Store (0x01, \_SB.PCI0.RP04.PSP4)
                Store (0x01, \_SB.PCI0.RP04.PMCS)
                Notify (\_SB.PCI0.RP04, 0x02)
            }
        }

        Method (_L0B, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.PCIB, 0x02)
        }

        Method (_L0C, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.USB3, 0x02)
        }

        Method (_L0D, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.USB7, 0x02)
        }

        Method (_L0E, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.USB4, 0x02)
        }

        Method (_L18, 0, NotSerialized)
        {
            Store (\_SB.RDEC (0x92), Local0)
            Store (And (Local0, 0x01), Local0)
            If (LEqual (Local0, LIDS))
            {
                Notify (\_SB.PCI0.LPCB.PS2K, 0x80)
                Notify (\_SB.PWRB, 0x02)
            }
            Else
            {
                Notify (\_SB.LID0, 0x80)
            }
        }
    }

    OperationRegion (SMIO, SystemIO, 0xB2, 0x02)
    Field (SMIO, ByteAcc, NoLock, Preserve)
    {
        APMC,   8, 
        APMD,   8
    }

    OperationRegion (PMIO, SystemIO, 0x1000, 0x80)
    Field (PMIO, DWordAcc, NoLock, Preserve)
    {
                Offset (0x01), 
        PBST,   1, 
                Offset (0x02), 
                Offset (0x10), 
            ,   1, 
        THRO,   3, 
        ETHR,   1
    }

    Name (\DFEC, 0x00)
    Name (\ACPS, 0x00)
    Name (\SACP, 0x00)
    Name (\SMIS, 0x00)
    Name (\PIOE, 0x00)
    Name (\SR18, 0x00)
    Name (\SR19, 0x00)
    Name (\ECSY, 0x00)
    Name (\BSTA, 0x00)
    Name (\SCCT, 0x00)
    Name (\PRST, 0x00)
    Name (\GUID, 0x00)
    Name (\TICO, 0x00)
    Name (\DKOT, 0x00)
    Name (\MSAV, 0x00)
    OperationRegion (XCMO, SystemIO, 0x72, 0x02)
    Field (XCMO, ByteAcc, NoLock, Preserve)
    {
        CINX,   8, 
        CDAT,   8
    }

    IndexField (CINX, CDAT, ByteAcc, NoLock, Preserve)
    {
                Offset (0x60), 
        MX01,   8, 
        MX02,   8
    }

    OperationRegion (ECMB, SystemIO, 0x0300, 0x02)
    Field (ECMB, ByteAcc, NoLock, Preserve)
    {
        MINX,   8, 
        MDAT,   8
    }

    IndexField (MINX, MDAT, ByteAcc, NoLock, Preserve)
    {
                Offset (0x82), 
        MBCD,   8, 
                Offset (0x8E), 
        O_RB,   1, 
            ,   3, 
        MBS3,   1, 
            ,   2, 
        MBS4,   1, 
            ,   2, 
        DKAP,   1, 
            ,   3, 
        S_AC,   1, 
                Offset (0x90), 
            ,   5, 
        MBTS,   1, 
                Offset (0x91), 
                Offset (0x92), 
            ,   1, 
        BPW0,   6, 
                Offset (0x93), 
            ,   1, 
        FPW1,   6, 
                Offset (0x94), 
                Offset (0x95), 
            ,   1, 
        LPW2,   6, 
                Offset (0x96), 
                Offset (0xA0), 
        SC_R,   8, 
        BINX,   8, 
        BDAT,   8, 
        BCMD,   8, 
                Offset (0xA8), 
        MCID,   8
    }

    Name (CTPB, Buffer (0x0B)
    {
        /* 0000 */    0x2D, 0x31, 0x37, 0x40, 0x49, 0x4F, 0x52, 0x57, 
        /* 0008 */    0x64, 0x66, 0x69
    })
    Name (MTPB, Buffer (0x0B)
    {
        /* 0000 */    0x2D, 0x31, 0x37, 0x40, 0x49, 0x4F, 0x52, 0x57, 
        /* 0008 */    0x64, 0x66, 0x69
    })
    Name (PTPB, Buffer (0x0B)
    {
        /* 0000 */    0x2D, 0x31, 0x37, 0x40, 0x49, 0x4F, 0x58, 0x5C, 
        /* 0008 */    0x52, 0x56, 0x69
    })
    Name (BTPB, Buffer (0x0B)
    {
        /* 0000 */    0x32, 0x36, 0x49, 0x4F, 0x52, 0x57, 0x5A, 0x5E, 
        /* 0008 */    0x3D, 0x46, 0x69
    })
    Name (FTPB, Buffer (0x0B)
    {
        /* 0000 */    0x2D, 0x31, 0x37, 0x40, 0x43, 0x4A, 0x4C, 0x50, 
        /* 0008 */    0x55, 0x57, 0x5A
    })
    Name (STPB, Buffer (0x0B)
    {
        /* 0000 */    0x2D, 0x31, 0x37, 0x40, 0x43, 0x4A, 0x4C, 0x50, 
        /* 0008 */    0x48, 0x4E, 0x5A
    })
    Name (TTPB, Buffer (0x0B)
    {
        /* 0000 */    0x32, 0x36, 0x43, 0x47, 0x47, 0x4C, 0x4C, 0x50, 
        /* 0008 */    0x3D, 0x44, 0x5A
    })
    Name (TRON, 0x00)
    Method (CHGT, 1, NotSerialized)
    {
        Store (\_SB.RDEC (0xD7), Local0)
        Store (And (Local0, 0x01), Local0)
        If (LEqual (Local0, 0x01))
        {
            If (LEqual (Arg0, 0x00))
            {
                Store (FTPB, CTPB)
            }

            If (LEqual (Arg0, 0x01))
            {
                Store (STPB, CTPB)
            }

            If (LEqual (Arg0, 0x02))
            {
                Store (TTPB, CTPB)
            }
        }
        Else
        {
            If (LEqual (Arg0, 0x00))
            {
                Store (MTPB, CTPB)
            }

            If (LEqual (Arg0, 0x01))
            {
                Store (PTPB, CTPB)
            }

            If (LEqual (Arg0, 0x02))
            {
                Store (BTPB, CTPB)
            }
        }

        CreateByteField (CTPB, 0x08, PSPL)
        CreateByteField (CTPB, 0x09, PSPH)
        CreateByteField (CTPB, 0x0A, CRTT)
        Store (PSPL, PASL)
        Store (PSPH, PASH)
        Store (PASH, PTMP)
        Store (CRTT, CTTP)
        \_SB.WREC (0xC2, PASH)
        \_SB.WREC (0xC1, PASL)
    }

    Name (\TPOK, 0x00)
    Name (PLCY, 0x01)
    Name (CTMP, 0x00)
    Name (TFST, 0x00)
    Name (EAC0, 0x2D)
    Name (TMPL, 0x2D)
    Name (TMPH, 0x46)
    Name (CFSP, 0x00)
    Name (PTMP, 0x68)
    Name (PASH, 0x5A)
    Name (PASL, 0x5A)
    Name (CTTP, 0x69)
    Method (STEV, 1, NotSerialized)
    {
        CreateByteField (CTPB, 0x00, TPL0)
        CreateByteField (CTPB, 0x01, TPH0)
        CreateByteField (CTPB, 0x02, TPL1)
        CreateByteField (CTPB, 0x03, TPH1)
        CreateByteField (CTPB, 0x04, TPL2)
        CreateByteField (CTPB, 0x05, TPH2)
        CreateByteField (CTPB, 0x06, TPL3)
        CreateByteField (CTPB, 0x07, TPH3)
        CreateByteField (CTPB, 0x08, PSPL)
        CreateByteField (CTPB, 0x09, PSPH)
        CreateByteField (CTPB, 0x0A, CRTT)
        Store (TPL0, EAC0)
        Store (Arg0, Local0)
        If (LLess (Local0, TPH0))
        {
            Store (0x00, TMPL)
            Store (TPH0, TMPH)
            Store (0x00, CFSP)
        }
        Else
        {
            If (LAnd (LLess (Local0, TPH1), LGreater (Local0, TPL0)))
            {
                Store (TPL0, TMPL)
                Store (TPH1, TMPH)
                Store (0x01, CFSP)
            }
            Else
            {
                If (LAnd (LLess (Local0, TPH2), LGreater (Local0, TPL1)))
                {
                    Store (TPL1, TMPL)
                    Store (TPH2, TMPH)
                    Store (0x02, CFSP)
                }
                Else
                {
                    If (LAnd (LLess (Local0, TPH3), LGreater (Local0, TPL2)))
                    {
                        Store (TPL2, TMPL)
                        Store (TPH3, TMPH)
                        Store (0x03, CFSP)
                    }
                    Else
                    {
                        Store (TPL3, TMPL)
                        Store (CRTT, TMPH)
                        Store (0x04, CFSP)
                    }
                }
            }
        }

        \_SB.WREC (0x9D, TMPL)
        \_SB.WREC (0x9E, TMPH)
        \_SB.WREC (0xA0, CFSP)
    }

    Name (F1ST, 0x00)
    Scope (\_TZ)
    {
        PowerResource (PFA1, 0x00, 0x0000)
        {
            Method (_STA, 0, NotSerialized)
            {
                Return (F1ST)
            }

            Method (_ON, 0, NotSerialized)
            {
                Store (0x01, F1ST)
            }

            Method (_OFF, 0, NotSerialized)
            {
                Store (0x00, F1ST)
            }
        }

        Device (FAN1)
        {
            Name (_HID, EisaId ("PNP0C0B"))
            Name (_UID, 0x02)
            Name (_PR0, Package (0x01)
            {
                \_TZ.PFA1
            })
        }

        Name (ETCB, 0x00)
        ThermalZone (TZCR)
        {
            Method (_TMP, 0, Serialized)
            {
                If (LEqual (SC_R, 0x77))
                {
                    Return (0x0C80)
                }

                If (ECON)
                {
                    If (DFEC)
                    {
                        Store (0x00, DFEC)
                        Return (0x0C80)
                    }

                    Store (\_SB.RDEC (0x9C), Local0)
                    Store (Local0, CTMP)
                    If (LEqual (TPOK, 0x00))
                    {
                        Store (\_SB.RDEC (0x9D), Local1)
                        Store (\_SB.RDEC (0x9E), Local2)
                        If (LOr (LNotEqual (TMPL, Local1), LNotEqual (TMPH, Local2)))
                        {
                            STEV (Local0)
                        }
                        Else
                        {
                            Store (0x01, TPOK)
                        }
                    }

                    If (LEqual (TFST, 0x00))
                    {
                        CHGT (CLMT)
                        Store (0x01, TFST)
                        STEV (CTMP)
                    }
                    Else
                    {
                        Store (TMPH, Local1)
                        Store (TMPL, Local2)
                        If (LOr (LLess (Local0, Local2), LGreater (Local0, Local1)))
                        {
                            STEV (CTMP)
                        }
                        Else
                        {
                            Store (\_SB.RDEC (0x9E), Local0)
                            If (LNotEqual (Local0, TMPH))
                            {
                                STEV (CTMP)
                            }
                        }
                    }

                    Return (Add (0x0AAC, Multiply (CTMP, 0x0A)))
                }
                Else
                {
                    Return (0x0C80)
                }
            }

            Method (_AC1, 0, NotSerialized)
            {
                Store (EAC0, Local0)
                Add (Local0, 0x0111, Local0)
                Multiply (Local0, 0x0A, Local0)
                Return (Local0)
            }

            Name (_AL1, Package (0x01)
            {
                \_TZ.FAN1
            })
            Method (_CRT, 0, NotSerialized)
            {
                Return (Add (0x0AAC, Multiply (CTTP, 0x0A)))
            }

            Method (_SCP, 1, NotSerialized)
            {
                Store (Arg0, PLCY)
            }

            Name (_PSL, Package (0x01)
            {
                \_PR.CPU0
            })
            Name (_TSP, 0x96)
        }

        ThermalZone (TZVR)
        {
            Method (_TMP, 0, Serialized)
            {
                If (ECON)
                {
                    Store (\_SB.RDEC (0xCB), Local0)
                    Return (Add (0x0AAC, Multiply (Local0, 0x0A)))
                }
                Else
                {
                    Return (0x0C80)
                }
            }

            Method (_CRT, 0, NotSerialized)
            {
                Return (Add (0x0AAC, Multiply (CTTP, 0x0A)))
            }
        }

        ThermalZone (TZVL)
        {
            Method (_TMP, 0, Serialized)
            {
                If (ECON)
                {
                    Store (\_SB.RDEC (0xCF), Local0)
                    Return (Add (0x0AAC, Multiply (Local0, 0x0A)))
                }
                Else
                {
                    Return (0x0C80)
                }
            }

            Method (_CRT, 0, NotSerialized)
            {
                Return (Add (0x0AAC, Multiply (CTTP, 0x0A)))
            }
        }

        ThermalZone (TZCL)
        {
            Method (_TMP, 0, Serialized)
            {
                If (ECON)
                {
                    Store (\_SB.RDEC (0xCE), Local0)
                    Return (Add (0x0AAC, Multiply (Local0, 0x0A)))
                }
                Else
                {
                    Return (0x0C80)
                }
            }

            Method (_CRT, 0, NotSerialized)
            {
                Return (Add (0x0AAC, Multiply (CTTP, 0x0A)))
            }
        }
    }

    Method (GETP, 1, Serialized)
    {
        If (LEqual (And (Arg0, 0x09), 0x00))
        {
            Return (0xFFFFFFFF)
        }

        If (LEqual (And (Arg0, 0x09), 0x08))
        {
            Return (0x0384)
        }

        ShiftRight (And (Arg0, 0x0300), 0x08, Local0)
        ShiftRight (And (Arg0, 0x3000), 0x0C, Local1)
        Return (Multiply (0x1E, Subtract (0x09, Add (Local0, Local1))
            ))
    }

    Method (GDMA, 5, Serialized)
    {
        If (Arg0)
        {
            If (LAnd (Arg1, Arg4))
            {
                Return (0x14)
            }

            If (LAnd (Arg2, Arg4))
            {
                Return (Multiply (Subtract (0x04, Arg3), 0x0F))
            }

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

        Return (0xFFFFFFFF)
    }

    Method (GETT, 1, Serialized)
    {
        Return (Multiply (0x1E, Subtract (0x09, Add (And (ShiftRight (Arg0, 0x02
            ), 0x03), And (Arg0, 0x03)))))
    }

    Method (GETF, 3, Serialized)
    {
        Name (TMPF, 0x00)
        If (Arg0)
        {
            Or (TMPF, 0x01, TMPF)
        }

        If (And (Arg2, 0x02))
        {
            Or (TMPF, 0x02, TMPF)
        }

        If (Arg1)
        {
            Or (TMPF, 0x04, TMPF)
        }

        If (And (Arg2, 0x20))
        {
            Or (TMPF, 0x08, TMPF)
        }

        If (And (Arg2, 0x4000))
        {
            Or (TMPF, 0x10, TMPF)
        }

        Return (TMPF)
    }

    Method (SETP, 3, Serialized)
    {
        If (LGreater (Arg0, 0xF0))
        {
            Return (0x08)
        }
        Else
        {
            If (And (Arg1, 0x02))
            {
                If (LAnd (LLessEqual (Arg0, 0x78), And (Arg2, 0x02)))
                {
                    Return (0x2301)
                }

                If (LAnd (LLessEqual (Arg0, 0xB4), And (Arg2, 0x01)))
                {
                    Return (0x2101)
                }
            }

            Return (0x1001)
        }
    }

    Method (SDMA, 1, Serialized)
    {
        If (LLessEqual (Arg0, 0x14))
        {
            Return (0x01)
        }

        If (LLessEqual (Arg0, 0x1E))
        {
            Return (0x02)
        }

        If (LLessEqual (Arg0, 0x2D))
        {
            Return (0x01)
        }

        If (LLessEqual (Arg0, 0x3C))
        {
            Return (0x02)
        }

        If (LLessEqual (Arg0, 0x5A))
        {
            Return (0x01)
        }

        Return (0x00)
    }

    Method (SETT, 3, Serialized)
    {
        If (And (Arg1, 0x02))
        {
            If (LAnd (LLessEqual (Arg0, 0x78), And (Arg2, 0x02)))
            {
                Return (0x0B)
            }

            If (LAnd (LLessEqual (Arg0, 0xB4), And (Arg2, 0x01)))
            {
                Return (0x09)
            }
        }

        Return (0x04)
    }

    Scope (\_SB)
    {
        Device (AC)
        {
            Name (_HID, "ACPI0003")
            Name (_PCL, Package (0x02)
            {
                \_SB, 
                \_SB.BAT1
            })
            Method (_PSR, 0, NotSerialized)
            {
                If (LEqual (SC_R, 0x77))
                {
                    Return (0x01)
                }
                Else
                {
                    If (ECON)
                    {
                        Store (\_SB.RDEC (0x92), Local0)
                        Store (And (Local0, 0x08), Local0)
                        ShiftRight (Local0, 0x03, Local0)
                        Store (0x00, \_SB.PCI0.LPCB.C4C3)
                        Return (Local0)
                    }
                    Else
                    {
                        Return (One)
                    }
                }
            }

            Method (_STA, 0, NotSerialized)
            {
                Return (0x0F)
            }
        }

        Name (BIF1, Package (0x0D)
        {
            0x01, 
            0xFFFFFFFF, 
            0xFFFFFFFF, 
            0x01, 
            0xFFFFFFFF, 
            0xFFFFFFFF, 
            0xFFFFFFFF, 
            0xFFFFFFFF, 
            0xFFFFFFFF, 
            " ", 
            " ", 
            "Li-I", 
            ""
        })
        Name (BST1, Package (0x04)
        {
            0x01, 
            0x0FFFFFFF, 
            0x0FFFFFFF, 
            0x2B5C
        })
        Device (BAT1)
        {
            Name (_HID, EisaId ("PNP0C0A"))
            Name (_UID, 0x01)
            Name (_PCL, Package (0x01)
            {
                \_SB
            })
            Method (_STA, 0, NotSerialized)
            {
                If (LEqual (DFEC, 0x01))
                {
                    If (BSTA)
                    {
                        Return (0x1F)
                    }
                    Else
                    {
                        Return (0x0F)
                    }
                }

                If (ECON)
                {
                    Store (\_SB.RDEC (0x94), Local0)
                    Store (And (Local0, 0x01), Local0)
                    Store (Local0, BSTA)
                    If (LEqual (Local0, 0x01))
                    {
                        Return (0x1F)
                    }
                    Else
                    {
                        Return (0x0F)
                    }
                }
                Else
                {
                    Return (0x0F)
                }
            }

            Method (_BIF, 0, NotSerialized)
            {
                If (LEqual (DFEC, 0x01))
                {
                    Return (BIF1)
                }

                If (ECON)
                {
                    Store (\_SB.RDEC (0xAA), Local0)
                    Store (\_SB.RDEC (0xAB), Local5)
                    ShiftLeft (Local5, 0x08, Local5)
                    Add (Local0, Local5, Local0)
                    Store (\_SB.RDEC (0xAC), Local1)
                    Store (\_SB.RDEC (0xAD), Local5)
                    ShiftLeft (Local5, 0x08, Local5)
                    Add (Local1, Local5, Local1)
                    Store (Local1, Index (BIF1, 0x01))
                    Store (Local0, Index (BIF1, 0x02))
                    Store (0x3A98, Index (BIF1, 0x04))
                    Store (0x00, Local2)
                    Store (Local2, Index (BIF1, 0x05))
                    Store (0x00, Local4)
                    Store (Local4, Index (BIF1, 0x06))
                    Subtract (Local2, Local4, Local6)
                    Store (Local6, Index (BIF1, 0x07))
                    Subtract (Local0, Local2, Local7)
                    Store (Local7, Index (BIF1, 0x08))
                    Store (\_SB.RDEC (0xDF), Local0)
                    Store (And (Local0, 0x0F), Local0)
                    If (LEqual (Local0, 0x01))
                    {
                        Store ("PA3400U-1BAS/BRS", Index (BIF1, 0x09))
                    }
                    Else
                    {
                        Store ("PA3399U-1BAS/BRS", Index (BIF1, 0x09))
                    }

                    Store (\_SB.RDEC (0xB9), Local0)
                    Store (\_SB.RDEC (0xBA), Local5)
                    ShiftLeft (Local5, 0x08, Local5)
                    Add (Local0, Local5, Local0)
                    Store (ITOS (Local0), Local1)
                    Store (Local1, Index (BIF1, 0x0A))
                }
                Else
                {
                    Store (0xFFFFFFFF, Index (BIF1, 0x01))
                    Store (0xFFFFFFFF, Index (BIF1, 0x04))
                }

                Return (BIF1)
            }

            Method (_BST, 0, NotSerialized)
            {
                If (LEqual (SC_R, 0x77))
                {
                    Store (0x02, Index (BST1, 0x00))
                    Store (0x05DC, Index (BST1, 0x01))
                    Store (0x39D0, Index (BST1, 0x02))
                    Store (0x39D0, Index (BST1, 0x03))
                    Return (BST1)
                }

                If (LEqual (DFEC, 0x01))
                {
                    Return (BST1)
                }

                If (ECON)
                {
                    Store (\_SB.RDEC (0x94), Local1)
                    Store (And (Local1, 0x10), Local1)
                    ShiftRight (Local1, 0x04, Local1)
                    Store (\_SB.RDEC (0x95), Local0)
                    Store (And (Local0, 0x01), Local0)
                    ShiftLeft (Local1, 0x01, Local2)
                    Or (Local0, Local2, Local3)
                    Store (\_SB.RDEC (0xC6), Local2)
                    Multiply (Local2, 0x0100, Local1)
                    Store (\_SB.RDEC (0xC5), Local0)
                    Add (Local1, Local0, Local1)
                    Store (Local1, Index (BST1, 0x01))
                    Store (And (\_SB.RDEC (0xA4), 0x7F), Local0)
                    If (LLess (Local0, 0x0F))
                    {
                        Or (Local3, 0x04, Local3)
                    }

                    Store (Local3, Index (BST1, 0x00))
                    Store (DerefOf (Index (BIF1, 0x02)), Local1)
                    Multiply (Local1, Local0, Local2)
                    Divide (Local2, 0x64, Local3, Local2)
                    Add (Local2, 0x0A, Local2)
                    Store (Local2, Index (BST1, 0x02))
                    Store (DerefOf (Index (BIF1, 0x04)), Local3)
                    Store (Local3, Index (BST1, 0x03))
                }
                Else
                {
                    Store (0x01, Index (BST1, 0x00))
                    Store (0xFFFFFFFF, Index (BST1, 0x01))
                    Store (0xFFFFFFFF, Index (BST1, 0x02))
                    Store (0xFFFFFFFF, Index (BST1, 0x03))
                }

                Return (BST1)
            }
        }

        Method (ITOS, 1, NotSerialized)
        {
            Store ("", Local0)
            Store (0x04, Local1)
            While (Local1)
            {
                Decrement (Local1)
                And (ShiftRight (Arg0, ShiftLeft (Local1, 0x02)), 0x0F, Local4)
                Store (DerefOf (Index (CHAR, Local4)), Local2)
                Concatenate (Local0, Local2, Local5)
                Store (Local5, Local0)
            }

            Return (Local0)
        }

        Name (CHAR, Package (0x10)
        {
            "0", 
            "1", 
            "2", 
            "3", 
            "4", 
            "5", 
            "6", 
            "7", 
            "8", 
            "9", 
            "A", 
            "B", 
            "C", 
            "D", 
            "E", 
            "F"
        })
        Device (LID0)
        {
            Name (_HID, EisaId ("PNP0C0D"))
            Method (_LID, 0, NotSerialized)
            {
                If (ECON)
                {
                    Store (\_SB.RDEC (0x92), Local0)
                    Store (And (Local0, 0x01), Local0)
                    If (Local0)
                    {
                        Return (0x00)
                    }
                    Else
                    {
                        Return (0x01)
                    }
                }
                Else
                {
                    Return (0x01)
                }
            }

            Name (_PRW, Package (0x02)
            {
                0x18, 
                0x04
            })
        }

        Device (PWRB)
        {
            Name (_HID, EisaId ("PNP0C0C"))
        }

        Device (PCI0)
        {
            Method (_INI, 0, NotSerialized)
            {
                Store (0x01, DKOT)
                Store (0x01, GUID)
                If (CondRefOf (_OSI, Local0))
                {
                    Store (0x00, MYOS)
                    If (LAnd (CFGD, 0x4000))
                    {
                        Store (0x32, SMIF)
                        Store (0x00, TRP0)
                    }
                }
                Else
                {
                    If (LEqual (SizeOf (_OS), 0x14))
                    {
                        Store (0x01, MYOS)
                    }
                    Else
                    {
                        If (LEqual (SizeOf (_OS), 0x27))
                        {
                            Store (0x02, MYOS)
                        }
                        Else
                        {
                            Store (0x03, MYOS)
                        }
                    }
                }
            }

            Method (_S3D, 0, NotSerialized)
            {
                Return (0x02)
            }

            Method (_S4D, 0, NotSerialized)
            {
                Return (0x02)
            }

            Name (_HID, EisaId ("PNP0A08"))
            Name (_CID, 0x030AD041)
            Name (_ADR, 0x00)
            Name (_BBN, 0x00)
            OperationRegion (HBUS, PCI_Config, 0x40, 0xC0)
            Field (HBUS, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x50), 
                    ,   4, 
                PM0H,   2, 
                        Offset (0x51), 
                PM1L,   2, 
                    ,   2, 
                PM1H,   2, 
                        Offset (0x52), 
                PM2L,   2, 
                    ,   2, 
                PM2H,   2, 
                        Offset (0x53), 
                PM3L,   2, 
                    ,   2, 
                PM3H,   2, 
                        Offset (0x54), 
                PM4L,   2, 
                    ,   2, 
                PM4H,   2, 
                        Offset (0x55), 
                PM5L,   2, 
                    ,   2, 
                PM5H,   2, 
                        Offset (0x56), 
                PM6L,   2, 
                    ,   2, 
                PM6H,   2, 
                        Offset (0x57), 
                    ,   7, 
                HENA,   1, 
                        Offset (0x5C), 
                    ,   3, 
                TOUD,   5
            }

            Name (BUF0, ResourceTemplate ()
            {
                WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode,
                    0x0000,             // Granularity
                    0x0000,             // Range Minimum
                    0x00FF,             // Range Maximum
                    0x0000,             // Translation Offset
                    0x0100,             // Length
                    0x00,, )
                DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                    0x00000000,         // Granularity
                    0x00000000,         // Range Minimum
                    0x00000CF7,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00000CF8,         // Length
                    0x00,, , TypeStatic)
                IO (Decode16,
                    0x0CF8,             // Range Minimum
                    0x0CF8,             // Range Maximum
                    0x01,               // Alignment
                    0x08,               // Length
                    )
                DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                    0x00000000,         // Granularity
                    0x00000D00,         // Range Minimum
                    0x0000FFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x0000F300,         // Length
                    0x00,, , TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000A0000,         // Range Minimum
                    0x000BFFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00020000,         // Length
                    0x00,, , AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000C0000,         // Range Minimum
                    0x000C3FFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    0x00,, _Y00, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000C4000,         // Range Minimum
                    0x000C7FFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    0x00,, _Y01, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000C8000,         // Range Minimum
                    0x000CBFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    0x00,, _Y02, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000CC000,         // Range Minimum
                    0x000CFFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    0x00,, _Y03, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000D0000,         // Range Minimum
                    0x000D3FFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    0x00,, _Y04, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000D4000,         // Range Minimum
                    0x000D7FFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    0x00,, _Y05, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000D8000,         // Range Minimum
                    0x000DBFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    0x00,, _Y06, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000DC000,         // Range Minimum
                    0x000DFFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    0x00,, _Y07, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000E0000,         // Range Minimum
                    0x000E3FFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    0x00,, _Y08, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000E4000,         // Range Minimum
                    0x000E7FFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    0x00,, _Y09, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000E8000,         // Range Minimum
                    0x000EBFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    0x00,, _Y0A, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000EC000,         // Range Minimum
                    0x000EFFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00004000,         // Length
                    0x00,, _Y0B, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x000F0000,         // Range Minimum
                    0x000FFFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00010000,         // Length
                    0x00,, _Y0C, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Granularity
                    0x00000000,         // Range Minimum
                    0xFEBFFFFF,         // Range Maximum
                    0x00000000,         // Translation Offset
                    0x00000000,         // Length
                    0x00,, _Y0D, AddressRangeMemory, TypeStatic)
            })
            Method (_CRS, 0, Serialized)
            {
                If (PM1L)
                {
                    CreateDWordField (BUF0, \_SB.PCI0._Y00._LEN, C0LN)
                    Store (Zero, C0LN)
                }

                If (LEqual (PM1L, 0x01))
                {
                    CreateBitField (BUF0, \_SB.PCI0._Y00._RW, C0RW)
                    Store (Zero, C0RW)
                }

                If (PM1H)
                {
                    CreateDWordField (BUF0, \_SB.PCI0._Y01._LEN, C4LN)
                    Store (Zero, C4LN)
                }

                If (LEqual (PM1H, 0x01))
                {
                    CreateBitField (BUF0, \_SB.PCI0._Y01._RW, C4RW)
                    Store (Zero, C4RW)
                }

                If (PM2L)
                {
                    CreateDWordField (BUF0, \_SB.PCI0._Y02._LEN, C8LN)
                    Store (Zero, C8LN)
                }

                If (LEqual (PM2L, 0x01))
                {
                    CreateBitField (BUF0, \_SB.PCI0._Y02._RW, C8RW)
                    Store (Zero, C8RW)
                }

                If (PM2H)
                {
                    CreateDWordField (BUF0, \_SB.PCI0._Y03._LEN, CCLN)
                    Store (Zero, CCLN)
                }

                If (LEqual (PM2H, 0x01))
                {
                    CreateBitField (BUF0, \_SB.PCI0._Y03._RW, CCRW)
                    Store (Zero, CCRW)
                }

                If (PM3L)
                {
                    CreateDWordField (BUF0, \_SB.PCI0._Y04._LEN, D0LN)
                    Store (Zero, D0LN)
                }

                If (LEqual (PM3L, 0x01))
                {
                    CreateBitField (BUF0, \_SB.PCI0._Y04._RW, D0RW)
                    Store (Zero, D0RW)
                }

                If (PM3H)
                {
                    CreateDWordField (BUF0, \_SB.PCI0._Y05._LEN, D4LN)
                    Store (Zero, D4LN)
                }

                If (LEqual (PM3H, 0x01))
                {
                    CreateBitField (BUF0, \_SB.PCI0._Y05._RW, D4RW)
                    Store (Zero, D4RW)
                }

                If (PM4L)
                {
                    CreateDWordField (BUF0, \_SB.PCI0._Y06._LEN, D8LN)
                    Store (Zero, D8LN)
                }

                If (LEqual (PM4L, 0x01))
                {
                    CreateBitField (BUF0, \_SB.PCI0._Y06._RW, D8RW)
                    Store (Zero, D8RW)
                }

                If (PM4H)
                {
                    CreateDWordField (BUF0, \_SB.PCI0._Y07._LEN, DCLN)
                    Store (Zero, DCLN)
                }

                If (LEqual (PM4H, 0x01))
                {
                    CreateBitField (BUF0, \_SB.PCI0._Y07._RW, DCRW)
                    Store (Zero, DCRW)
                }

                If (PM5L)
                {
                    CreateDWordField (BUF0, \_SB.PCI0._Y08._LEN, E0LN)
                    Store (Zero, E0LN)
                }

                If (LEqual (PM5L, 0x01))
                {
                    CreateBitField (BUF0, \_SB.PCI0._Y08._RW, E0RW)
                    Store (Zero, E0RW)
                }

                If (PM5H)
                {
                    CreateDWordField (BUF0, \_SB.PCI0._Y09._LEN, E4LN)
                    Store (Zero, E4LN)
                }

                If (LEqual (PM5H, 0x01))
                {
                    CreateBitField (BUF0, \_SB.PCI0._Y09._RW, E4RW)
                    Store (Zero, E4RW)
                }

                If (PM6L)
                {
                    CreateDWordField (BUF0, \_SB.PCI0._Y0A._LEN, E8LN)
                    Store (Zero, E8LN)
                }

                If (LEqual (PM6L, 0x01))
                {
                    CreateBitField (BUF0, \_SB.PCI0._Y0A._RW, E8RW)
                    Store (Zero, E8RW)
                }

                If (PM6H)
                {
                    CreateDWordField (BUF0, \_SB.PCI0._Y0B._LEN, ECLN)
                    Store (Zero, ECLN)
                }

                If (LEqual (PM6H, 0x01))
                {
                    CreateBitField (BUF0, \_SB.PCI0._Y0B._RW, ECRW)
                    Store (Zero, ECRW)
                }

                If (PM0H)
                {
                    CreateDWordField (BUF0, \_SB.PCI0._Y0C._LEN, F0LN)
                    Store (Zero, F0LN)
                }

                If (LEqual (PM0H, 0x01))
                {
                    CreateBitField (BUF0, \_SB.PCI0._Y0C._RW, F0RW)
                    Store (Zero, F0RW)
                }

                CreateDWordField (BUF0, \_SB.PCI0._Y0D._MIN, M1MN)
                CreateDWordField (BUF0, \_SB.PCI0._Y0D._MAX, M1MX)
                CreateDWordField (BUF0, \_SB.PCI0._Y0D._LEN, M1LN)
                ShiftLeft (TOUD, 0x1B, M1MN)
                Add (Subtract (M1MX, M1MN), 0x01, M1LN)
                Return (BUF0)
            }

            Method (_PRT, 0, NotSerialized)
            {
                If (GPIC)
                {
                    Return (Package (0x0E)
                    {
                        Package (0x04)
                        {
                            0x0001FFFF, 
                            0x00, 
                            0x00, 
                            0x10
                        }, 

                        Package (0x04)
                        {
                            0x001CFFFF, 
                            0x00, 
                            0x00, 
                            0x11
                        }, 

                        Package (0x04)
                        {
                            0x001CFFFF, 
                            0x01, 
                            0x00, 
                            0x10
                        }, 

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

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

                        Package (0x04)
                        {
                            0x001DFFFF, 
                            0x00, 
                            0x00, 
                            0x17
                        }, 

                        Package (0x04)
                        {
                            0x001DFFFF, 
                            0x01, 
                            0x00, 
                            0x13
                        }, 

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

                        Package (0x04)
                        {
                            0x001DFFFF, 
                            0x03, 
                            0x00, 
                            0x10
                        }, 

                        Package (0x04)
                        {
                            0x001EFFFF, 
                            0x00, 
                            0x00, 
                            0x11
                        }, 

                        Package (0x04)
                        {
                            0x001EFFFF, 
                            0x01, 
                            0x00, 
                            0x14
                        }, 

                        Package (0x04)
                        {
                            0x001FFFFF, 
                            0x00, 
                            0x00, 
                            0x12
                        }, 

                        Package (0x04)
                        {
                            0x001FFFFF, 
                            0x01, 
                            0x00, 
                            0x13
                        }, 

                        Package (0x04)
                        {
                            0x001FFFFF, 
                            0x02, 
                            0x00, 
                            0x10
                        }
                    })
                }
                Else
                {
                    Return (Package (0x0E)
                    {
                        Package (0x04)
                        {
                            0x0001FFFF, 
                            0x00, 
                            \_SB.PCI0.LPCB.LNKA, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x001CFFFF, 
                            0x00, 
                            \_SB.PCI0.LPCB.LNKB, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x001CFFFF, 
                            0x01, 
                            \_SB.PCI0.LPCB.LNKA, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x001CFFFF, 
                            0x02, 
                            \_SB.PCI0.LPCB.LNKC, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x001CFFFF, 
                            0x03, 
                            \_SB.PCI0.LPCB.LNKD, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x001DFFFF, 
                            0x00, 
                            \_SB.PCI0.LPCB.LNKH, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x001DFFFF, 
                            0x01, 
                            \_SB.PCI0.LPCB.LNKD, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x001DFFFF, 
                            0x02, 
                            \_SB.PCI0.LPCB.LNKC, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x001DFFFF, 
                            0x03, 
                            \_SB.PCI0.LPCB.LNKA, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x001EFFFF, 
                            0x00, 
                            \_SB.PCI0.LPCB.LNKB, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x001EFFFF, 
                            0x01, 
                            \_SB.PCI0.LPCB.LNKE, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x001FFFFF, 
                            0x00, 
                            \_SB.PCI0.LPCB.LNKC, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x001FFFFF, 
                            0x01, 
                            \_SB.PCI0.LPCB.LNKD, 
                            0x00
                        }, 

                        Package (0x04)
                        {
                            0x001FFFFF, 
                            0x02, 
                            \_SB.PCI0.LPCB.LNKA, 
                            0x00
                        }
                    })
                }
            }

            Device (PDRC)
            {
                Name (_HID, EisaId ("PNP0C02"))
                Name (_UID, 0x01)
                Name (_CRS, ResourceTemplate ()
                {
                    Memory32Fixed (ReadWrite,
                        0xE0000000,         // Address Base
                        0x10000000,         // Address Length
                        )
                    Memory32Fixed (ReadWrite,
                        0xFED14000,         // Address Base
                        0x00004000,         // Address Length
                        )
                    Memory32Fixed (ReadWrite,
                        0xFED18000,         // Address Base
                        0x00001000,         // Address Length
                        )
                    Memory32Fixed (ReadWrite,
                        0xFED19000,         // Address Base
                        0x00001000,         // Address Length
                        )
                    Memory32Fixed (ReadWrite,
                        0xF0008000,         // Address Base
                        0x00004000,         // Address Length
                        )
                    Memory32Fixed (ReadWrite,
                        0xFEC00000,         // Address Base
                        0x00001000,         // Address Length
                        )
                    Memory32Fixed (ReadWrite,
                        0xFEE00000,         // Address Base
                        0x00001000,         // Address Length
                        )
                    Memory32Fixed (ReadWrite,
                        0xFED20000,         // Address Base
                        0x00070000,         // Address Length
                        )
                })
            }

            Device (PEGP)
            {
                Name (_ADR, 0x00010000)
                Device
Comment 1 Mark Linimon freebsd_committer freebsd_triage 2008-06-09 18:34:35 UTC
Responsible Changed
From-To: freebsd-bugs->freebsd-acpi

Over to maintainer(s).
Comment 2 Andriy Gapon freebsd_committer freebsd_triage 2010-12-05 15:20:03 UTC
Is this still an issue?
-- 
Andriy Gapon
Comment 3 Jaakko Heinonen freebsd_committer freebsd_triage 2011-11-27 11:44:51 UTC
State Changed
From-To: open->closed

Feedback timeout.