ACPI Error: Argument count mismatch for method P8XH 4 2 (20100528/dmextern-387)
/*
 * Intel ACPI Component Architecture
 * AML Disassembler version 20100528
 *
 * Disassembly of SSDT4.dat, Tue Nov 15 18:16:34 2011
 *
 *
 * Original Table Header:
 *     Signature        "SSDT"
 *     Length           0x00000578 (1400)
 *     Revision         0x01
 *     Checksum         0x10
 *     OEM ID           "SgRef"
 *     OEM Table ID     "SgTabl"
 *     OEM Revision     0x00001000 (4096)
 *     Compiler ID      "INTL"
 *     Compiler Version 0x20091112 (537465106)
 */
DefinitionBlock ("SSDT4.aml", "SSDT", 1, "SgRef", "SgTabl", 0x00001000)
{
    External (PWOK)
    External (SGMD)
    External (P8XH, MethodObj)    // 4 Arguments
    External (PWEN)
    External (HLRS)
    External (GPRW, IntObj)
    External (\GBAS, MethodObj)    // 1 Arguments
    External (\EECP, MethodObj)    // 1 Arguments
    External (\XBAS, MethodObj)    // 1 Arguments
    External (\_SB_.WMI_)
    External (\_SB_.WMI_.EVNT)
    External (\_SB_.PCI0.PEG0, DeviceObj)
    External (\_SB_.PCI0.GFX0, DeviceObj)
    External (\_SB_.PCI0.GFX0._DOD, IntObj)
    External (\_SB_.PCI0.GFX0.HDSM, IntObj)
    External (\_SB_.PCI0.PEG0.PEGP, DeviceObj)
    External (\_SB_.PCI0.LPCB.EC__.FCMD)
    External (\_SB_.PCI0.LPCB.EC__.FDAT)
    External (\_SB_.PCI0.PEG0.PEGP._ADR)

    Scope (\_SB.PCI0.GFX0)
    {
        Method (_DSM, 4, Serialized)
        {
            If (LEqual (Arg0, Buffer (0x10)
                    {
                        /* 0000 */    0xD3, 0x73, 0xD8, 0x7E, 0xD0, 0xC2, 0x4F, 0x4E, 
                        /* 0008 */    0xA8, 0x54, 0x0F, 0x13, 0x17, 0xB0, 0x1C, 0x2C
                    }))
            {
                Return (One)
            }

            If (CondRefOf (\_SB.PCI0.GFX0.HDSM))
            {
                Return (\_SB.PCI0.GFX0.HDSM)
                Arg0
                Arg1
                Arg2
                Arg3
            }
        }
    }

    Scope (\_SB.PCI0.PEG0)
    {
        OperationRegion (RPCI, PCI_Config, Zero, 0xF0)
        Field (RPCI, DWordAcc, Lock, Preserve)
        {
                    Offset (0xB0), 
            ASPM,   2, 
                ,   2, 
            LNKD,   1
        }

        OperationRegion (RPCX, SystemMemory, \XBAS (0x8400), Field (RPCX, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x8214), 
                        Offset (0x8216), 
                LNKS,   4
            })
        Device (PEGA)
        {
            Name (_ADR, One)
            OperationRegion (ACAP, PCI_Config, \EECP (0x14), Field (ACAP, DWordAcc, NoLock, Preserve)
                {
                            Offset (0x10), 
                    LCT1,   16
                })
            Method (_PRW, 0, NotSerialized)
            {
                Return (GPRW)
                0x09
                0x04
            }
        }
    }

    Scope (\_SB.PCI0.PEG0.PEGP)
    {
        Name (ELCT, Zero)
        Name (HVID, Zero)
        Name (HDID, Zero)
        OperationRegion (PCIS, PCI_Config, Zero, 0xF0)
        Field (PCIS, DWordAcc, Lock, Preserve)
        {
            DVID,   16, 
                    Offset (0x2C), 
            SVID,   16, 
            SDID,   16, 
                    Offset (0x4C), 
            WVID,   16, 
            WDID,   16
        }

        OperationRegion (GPIO, SystemIO, \GBAS (0x60), Field (GPIO, ByteAcc, Lock, Preserve)
            {
                        Offset (0x0C), 
                LVL0,   32, 
                        Offset (0x38), 
                LVL1,   32, 
                        Offset (0x48), 
                LVL2,   32
            })
        OperationRegion (PCAP, PCI_Config, \EECP (0x14), Field (PCAP, DWordAcc, NoLock, Preserve)
            {
                        Offset (0x10), 
                LCTL,   16
            })
        Method (_INI, 0, NotSerialized)
        {
            Store (Zero, \_SB.PCI0.PEG0.PEGP._ADR)
        }

        Method (SGON, 0, Serialized)
        {
            Sleep (0x01F4)
            Store (One, \_SB.PCI0.LPCB.EC.FDAT)
            Store (0xBF, \_SB.PCI0.LPCB.EC.FCMD)
            Sleep (0x03E8)
            SGPO (HLRS, One)
            SGPO (PWEN, One)
            Or (LVL1, 0x02, LVL1)
            And (LVL1, 0xFFFB, LVL1)
            P8XH (Zero, 0x33, Sleep (0x012C), SGPO (HLRS, Zero))
            Sleep (0x64)
            Store (Zero, LNKD)
            While (LLess (LNKS, 0x07))
            {
                Sleep (One)
            }

            Store (HVID, WVID)
            Store (HDID, WDID)
            Or (And (ELCT, 0x43), And (LCTL, 0xFFBC), LCTL)
            Or (And (ELCT, 0x43), And (\_SB.PCI0.PEG0.PEGA.LCT1, 0xFFBC), \_SB.PCI0.PEG0.PEGA.LCT1)
            Store (0xED, \_SB.WMI.EVNT)
            Notify (\_SB.WMI, 0xD0)
            Return (One)
        }

        Method (SGOF, 0, Serialized)
        {
            Store (LCTL, ELCT)
            Store (SVID, HVID)
            Store (SDID, HDID)
            Store (One, LNKD)
            While (LNotEqual (LNKS, Zero))
            {
                Sleep (One)
            }

            SGPO (HLRS, One)
            SGPO (PWEN, Zero)
            Sleep (0x01F4)
            Store (Zero, \_SB.PCI0.LPCB.EC.FDAT)
            Store (0xBF, \_SB.PCI0.LPCB.EC.FCMD)
            Sleep (0x03E8)
            And (LVL1, 0xFFFD, LVL1)
            Or (LVL1, 0x04, LVL1)
            P8XH (Zero, 0x34, Return (Zero))
        }

        Method (SGST, 0, Serialized)
        {
            If (And (SGMD, 0x0F))
            {
                If (LEqual (SGPI (PWOK), One))
                {
                    Return (0x0F)
                }

                Return (Zero)
            }

            If (LNotEqual (DVID, 0xFFFF))
            {
                Return (0x0F)
            }

            Return (Zero)
        }

        Method (_DOD, 0, NotSerialized)
        {
            Return (\_SB.PCI0.GFX0._DOD)
        }

        Method (SGPI, 1, Serialized)
        {
            ShiftRight (Arg0, 0x07, Local1)
            And (Arg0, 0x7F, Arg0)
            If (LLess (Arg0, 0x20))
            {
                Store (\_SB.PCI0.PEG0.PEGP.LVL0, Local0)
                ShiftRight (Local0, Arg0, Local0)
            }
            Else
            {
                If (LLess (Arg0, 0x40))
                {
                    Store (\_SB.PCI0.PEG0.PEGP.LVL1, Local0)
                    ShiftRight (Local0, Subtract (Arg0, 0x20), Local0)
                }
                Else
                {
                    Store (\_SB.PCI0.PEG0.PEGP.LVL2, Local0)
                    ShiftRight (Local0, Subtract (Arg0, 0x40), Local0)
                }
            }

            If (LEqual (Local1, Zero))
            {
                Not (Local0, Local0)
            }

            Return (And (Local0, One))
        }

        Method (SGPO, 2, Serialized)
        {
            ShiftRight (Arg0, 0x07, Local3)
            And (Arg0, 0x7F, Arg0)
            If (LEqual (Local3, Zero))
            {
                And (Not (Arg1), One, Arg1)
            }

            If (LLess (Arg0, 0x20))
            {
                ShiftLeft (Arg1, Arg0, Local0)
                ShiftLeft (One, Arg0, Local1)
                And (\_SB.PCI0.PEG0.PEGP.LVL0, Not (Local1), Local2)
                Or (Local2, Local0, \_SB.PCI0.PEG0.PEGP.LVL0)
            }
            Else
            {
                If (LLess (Arg0, 0x40))
                {
                    ShiftLeft (Arg1, Subtract (Arg0, 0x20), Local0)
                    ShiftLeft (One, Subtract (Arg0, 0x20), Local1)
                    And (\_SB.PCI0.PEG0.PEGP.LVL1, Not (Local1), Local2)
                    Or (Local2, Local0, \_SB.PCI0.PEG0.PEGP.LVL1)
                }
                Else
                {
                    ShiftLeft (Arg1, Subtract (Arg0, 0x40), Local0)
                    ShiftLeft (One, Subtract (Arg0, 0x40), Local1)
                    And (\_SB.PCI0.PEG0.PEGP.LVL2, Not (Local1), Local2)
                    Or (Local2, Local0, \_SB.PCI0.PEG0.PEGP.LVL2)
                }
            }

            Return (One)
        }
    }
}