Probook 4530s fan noise : DSDT table edition ?

alefried · ‎11-23-2011

I have a HP probook 4530s, almost new.

I am dispointed by the fans, that are constantly running, whatever the load or the temperature, at a quite high level, leading to an annoying noise...

I tried different options in the BIOS (fan always on on AC, powercontrol ...)

I updated th BIOS to F.20, the latest proposed for my computer.

I tuned my configuration (ubuntu 11.10), to reach a baseline power consumption of 6-8 watts, and a standard T° around 35-45°C.

Notice that i have the same problem under Win7.

The problem remains 😞 !

I have found some new clues recently , and there should be something to do with DSDT table. Among other things, it seems that it is possible to patch this file to correct the issue.
a nice post had been posted here, detailing a procedure : blog
as a ubuntu user, I have been digging quite a lot there too : lesswatts.org
finally, this one is not bad too : hot patch on linux

I tried the procedure described in the blog, but i got stuck at the edition of the .dsl file. Indeed, i cannot find the place where the fan speeds are specified... I wish a HP developper reads this and would indicate where this could be ! (package name / line number, whatever helps, and if possible few explanations)

Please post if you have found interesting stuff dealing dsdt table and ways to understand / modify it on recent hp laptops / BIOS (i use F.20)

thanks

makvool · ‎11-30-2011

Exactly the same problem here, which is quite annoying. I hope we can get an official answer from HP for a workaround for this, and hopefully an updated BIOS which resolves the problem.

Wronskian · ‎12-03-2011

Came here looking for answers to the same exact problem!

I've had the laptop for about 4 months and the fan started reaching excessive levels about 2 months in. At first it was just fine. I don't know what happened.

brozur · ‎12-27-2011

The same on my HP... 2 months was quite silence, then sound like blender. It must be some f...ing upgrade... Because temperature is OK.

I thing it's a BIOS. I have F20 but its impossible to downgrade it. DSDT the same, no info on web...

For sure HP ProBook 4530s is very bad notebook! (Sorry, maybe for deaf people is OK)
And technicians in HP Support are total incompetent.

HP NO MORE!

mmurciato · ‎01-01-2012

I am experiencing the same problem.

Why can't we downgrade from F20?

Isn't any workaround to do it?

Thanks

thebrightestday · ‎01-06-2012

IS THERE ANYTHING NEW on updating bios, because the latest bios has no new methods for fan management!

I bought a new HP 4530s and it is really noisy by default.

It is very frustrating that company like HP have this issue, this is supposed to be a PROBOOK, but it's fan can not be controlled by any third party software, and it also has no it's own control, which is frivolous, at least to say.

nicopulse · ‎01-08-2012

I have the same problem on my HP Probook 4530s,

I get the dsdt.asl file whit this method : http://notebookequus.blogspot.com/2008/09/patching-dsdt-table.html

But i cant find the fan speed in the file...

I just find a long part with ThermalZone function at line 1180... but I do not know what to change...

Does anyone know?

Nico,

from France

jovan84 · ‎01-08-2012

I also have same problem with my 4530s. I tried everything except changing of DSDT table.

I afraid of it. I hope new fersion of BIOS will be available soon.

thebrightestday · ‎01-08-2012

@nicopulse

My DSDT table looks like this. (hp 4530s)

It is not the same code as decribed in manual.

Does anyone knows how to modify this?

// CreatorID=INTL	CreatorRev=20.6.2322
// FileLength=148953	FileChkSum=0x74

DefinitionBlock("dsdt.aml", "DSDT", 0x02, "HPQOEM", "167C    ", 0x00000001)
{
    Name(FMBL, 0x1)
    Name(LSTA, 0x0)
    Name(IDPM, 0x0)
    Method(\HPTS, 0x1, NotSerialized)
    {
        Store(Arg0, SLPT)
        \_SB_.ODGW(Or(0x5400, Arg0, ))
        If(LEqual(Arg0, 0x5))
        {
            \_SB_.SSMI(0xea82, Arg0, 0x0, 0x0, 0x0)
        }
        If(LGreater(Arg0, 0x0))
        {
            \_SB_.SSMI(0xea83, 0x0, 0x0, 0x0, 0x0)
            If(LNot(LEqual(Arg0, 0x3)))
            {
                Store(0x0, \_SB_.PCI0.LPCB.EC0_.HSST)
            }
            PPTS(Arg0)
            If(LNot(LEqual(Arg0, 0x5)))
            {
                \_SB_.PCI0.LPCB.EC0_.BTDR(0x0)
                Store(0x1, \_SB_.NFBS)
                If(LEqual(Arg0, 0x3))
                {
                    Store(\_SB_.LID_._LID(), LSTA)
                    If(LNot(LEqual(And(PNHM, 0xf0ff0, ), 0x106e0)))
                    {
                        Store(\APMC, IDPM)
                    }
                }
            }
        }
    }
    Method(\HWAK, 0x1, NotSerialized)
    {
        Store(0x0, SLPT)
        \_SB_.ODGW(Or(0x5600, Arg0, ))
        If(LEqual(Arg0, 0x3))
        {
            \_SB_.SSMI(0xea80, 0x0, 0x0, 0x0, 0x0)
        }
        \_SB_.PCI0.LPCB.EC0_.ITLB()
        \_SB_.PCI0.LPCB.EC0_.RPPC(0x1)
        If(\_SB_.PCI0.LPCB.EC0_.ECRG)
        {
            Acquire(\_SB_.PCI0.LPCB.EC0_.ECMX, 0xffff)
            Store(0x1, \_SB_.PCI0.LPCB.EC0_.ACPI)
            Store(0x0, \_SB_.PCI0.LPCB.EC0_.SLPT)
            Release(\_SB_.PCI0.LPCB.EC0_.ECMX)
        }
        If(LGreater(Arg0, 0x2))
        {
            \_TZ_.RETD()
            \_TZ_.INTM(0x1)
            Store(0x1, \_SB_.NFBS)
            If(LEqual(Arg0, 0x3))
            {
                Store(\_SB_.LID_._LID(), Local0)
                If(XOr(Local0, LSTA, ))
                {
                    \_SB_.PCI0.GFX0.GLID(Local0)
                }
                If(LNot(LEqual(And(PNHM, 0xf0ff0, ), 0x106e0)))
                {
                    Store(IDPM, \APMC)
                }
            }
            If(LEqual(Arg0, 0x4))
            {
                \_SB_.WMID.WGWE(0x5, 0x0)
            }
        }
        If(LOr(LEqual(Arg0, 0x4), LEqual(\WCOS(), 0x1)))
        {
            Notify(\_SB_.SLPB, 0x2)
        }
        Store(\_SB_.PCI0.LPCB.EC0_.GACS(), Local2)
        \_SB_.PCI0.LPCB.EC0_.PWUP(0x3, 0xff)
        Store(\_SB_.PCI0.LPCB.EC0_.GBAP(), Local1)
        Store(\_SB_.PCI0.LPCB.EC0_.GACS(), Local3)
        Store(Local3, PWRS)
        XOr(Local2, Local3, Local3)
        If(LGreater(Arg0, 0x2))
        {
            Notify(\_SB_.AC__, 0x80)
            PCNT()
        }
        If(LEqual(Local3, 0x0))
        {
            If(LEqual(Arg0, 0x4))
            {
                XOr(Local2, 0x1, \_SB_.ACST)
            }
        }
        PWAK(Arg0)
        \_SB_.VWAK(Arg0)
        Store(\_SB_.HST1.GHID(), Local0)
        \_SB_.PCI0.ACEL.ITAL()
    }
    Method(PCNT, 0x0, Serialized)
    {
        If(LGreater(TCNT, 0x1))
        {
            If(And(PDC0, 0x18, ))
            {
                Notify(\_PR_.CPU0, 0x81)
            }
            If(And(PDC1, 0x18, ))
            {
                Notify(\_PR_.CPU1, 0x81)
            }
            If(And(PDC2, 0x18, ))
            {
                Notify(\_PR_.CPU2, 0x81)
            }
            If(And(PDC3, 0x18, ))
            {
                Notify(\_PR_.CPU3, 0x81)
            }
            If(And(PDC4, 0x18, ))
            {
                Notify(\_PR_.CPU4, 0x81)
            }
            If(And(PDC5, 0x18, ))
            {
                Notify(\_PR_.CPU5, 0x81)
            }
            If(And(PDC6, 0x18, ))
            {
                Notify(\_PR_.CPU6, 0x81)
            }
            If(And(PDC7, 0x18, ))
            {
                Notify(\_PR_.CPU7, 0x81)
            }
        }
        Else
        {
            Notify(\_PR_.CPU0, 0x81)
        }
    }
    Mutex(MUTX, 0x0)
    Method(P8XH, 0x2, Serialized)
    {
        If(LEqual(Arg0, 0x0))
        {
            \_SB_.ODBG(Arg1)
            Store(Or(And(P80D, 0xffffff00, ), Arg1, ), P80D)
        }
        If(LEqual(Arg0, 0x1))
        {
            \_SB_.ODG1(Arg1)
            Store(Or(And(P80D, 0xffff00ff, ), ShiftLeft(Arg1, 0x8, ), ), P80D)
        }
        If(LEqual(Arg0, 0x2))
        {
            Store(Or(And(P80D, 0xff00ffff, ), ShiftLeft(Arg1, 0x10, ), ), P80D)
        }
        If(LEqual(Arg0, 0x3))
        {
            Store(Or(And(P80D, 0xffffff, ), ShiftLeft(Arg1, 0x18, ), ), P80D)
        }
    }
    OperationRegion(SPRT, SystemIO, 0xb2, 0x2)
    Field(SPRT, ByteAcc, Lock, Preserve)
    {
        SSMP, 8
    }
    Method(\_PIC, 0x1, NotSerialized)
    {
        Store(Arg0, GPIC)
    }
    Method(_PTS, 0x1, NotSerialized)
    {
        HPTS(Arg0)
        If(LEqual(Arg0, 0x3))
        {
            If(LAnd(DTSE, LGreater(TCNT, 0x1)))
            {
                TRAP(0x2, 0x1e)
            }
        }
    }
    Method(_WAK, 0x1, NotSerialized)
    {
        HWAK(Arg0)
        \_SB_.PCI0.POSC(OSCC, 0x0)
        If(LEqual(Arg0, 0x3))
        {
        }
        If(LOr(LEqual(Arg0, 0x3), LEqual(Arg0, 0x4)))
        {
            If(LAnd(DTSE, LGreater(TCNT, 0x1)))
            {
                TRAP(0x2, 0x14)
            }
            If(And(CFGD, 0x1000000, ))
            {
                If(LAnd(And(CFGD, 0xf0, ), LAnd(LEqual(OSYS, 0x7d1), LNot(And(PDC0, 0x10, )))))
                {
                    TRAP(0x1, 0x48)
                }
            }
            If(LEqual(OSYS, 0x7d2))
            {
                If(And(CFGD, 0x1, ))
                {
                    If(LGreater(\_PR_.CPU0._PPC, 0x0))
                    {
                        Subtract(\_PR_.CPU0._PPC, 0x1, \_PR_.CPU0._PPC)
                        PNOT()
                        Add(\_PR_.CPU0._PPC, 0x1, \_PR_.CPU0._PPC)
                        PNOT()
                    }
                    Else
                    {
                        Add(\_PR_.CPU0._PPC, 0x1, \_PR_.CPU0._PPC)
                        PNOT()
                        Subtract(\_PR_.CPU0._PPC, 0x1, \_PR_.CPU0._PPC)
                        PNOT()
                    }
                }
            }
        }
        Return(Package(0x2)
        {
            0x0,
            0x0
        })
    }
    Method(GETB, 0x3, Serialized)
    {
        Multiply(Arg0, 0x8, Local0)
        Multiply(Arg1, 0x8, Local1)
        CreateField(Arg2, Local0, Local1, TBF3)
        Return(TBF3)
    }
    Method(PNOT, 0x0, Serialized)
    {
        If(LGreater(TCNT, 0x1))
        {
            If(And(PDC0, 0x8, ))
            {
                Notify(\_PR_.CPU0, 0x80)
                If(And(PDC0, 0x10, ))
                {
                    Sleep(0x64)
                    Notify(\_PR_.CPU0, 0x81)
                }
            }
            If(And(PDC1, 0x8, ))
            {
                Notify(\_PR_.CPU1, 0x80)
                If(And(PDC1, 0x10, ))
                {
                    Sleep(0x64)
                    Notify(\_PR_.CPU1, 0x81)
                }
            }
            If(And(PDC2, 0x8, ))
            {
                Notify(\_PR_.CPU2, 0x80)
                If(And(PDC2, 0x10, ))
                {
                    Sleep(0x64)
                    Notify(\_PR_.CPU2, 0x81)
                }
            }
            If(And(PDC3, 0x8, ))
            {
                Notify(\_PR_.CPU3, 0x80)
                If(And(PDC3, 0x10, ))
                {
                    Sleep(0x64)
                    Notify(\_PR_.CPU3, 0x81)
                }
            }
            If(And(PDC4, 0x8, ))
            {
                Notify(\_PR_.CPU4, 0x80)
                If(And(PDC4, 0x10, ))
                {
                    Sleep(0x64)
                    Notify(\_PR_.CPU4, 0x81)
                }
            }
            If(And(PDC5, 0x8, ))
            {
                Notify(\_PR_.CPU5, 0x80)
                If(And(PDC5, 0x10, ))
                {
                    Sleep(0x64)
                    Notify(\_PR_.CPU5, 0x81)
                }
            }
            If(And(PDC6, 0x8, ))
            {
                Notify(\_PR_.CPU6, 0x80)
                If(And(PDC6, 0x10, ))
                {
                    Sleep(0x64)
                    Notify(\_PR_.CPU6, 0x81)
                }
            }
            If(And(PDC7, 0x8, ))
            {
                Notify(\_PR_.CPU7, 0x80)
                If(And(PDC7, 0x10, ))
                {
                    Sleep(0x64)
                    Notify(\_PR_.CPU7, 0x81)
                }
            }
        }
        Else
        {
            Notify(\_PR_.CPU0, 0x80)
            Sleep(0x64)
            Notify(\_PR_.CPU0, 0x81)
        }
    }
    Method(TRAP, 0x2, Serialized)
    {
        Store(Arg1, SMIF)
        If(LEqual(Arg0, 0x1))
        {
            Store(0x0, TRP0)
        }
        If(LEqual(Arg0, 0x2))
        {
            Store(Arg1, DTSF)
            Store(0x0, TRPD)
            Return(DTSF)
        }
        Return(SMIF)
    }
    Scope(\_SB_)
    {
        Method(_INI, 0x0, NotSerialized)
        {
            Store(0x7d0, OSYS)
            If(CondRefOf(_OSI, Local0))
            {
                If(_OSI("Linux"))
                {
                    Store(0x3e8, OSYS)
                }
                If(_OSI("Windows 2001"))
                {
                    Store(0x7d1, OSYS)
                }
                If(_OSI("Windows 2001 SP1"))
                {
                    Store(0x7d1, OSYS)
                }
                If(_OSI("Windows 2001 SP2"))
                {
                    Store(0x7d2, OSYS)
                }
                If(_OSI("Windows 2006"))
                {
                    Store(0x7d6, OSYS)
                }
                If(_OSI("Windows 2009"))
                {
                    Store(0x7d9, OSYS)
                }
            }
            \_TZ_.BOTT()
            \_TZ_.RETD()
            Store(0x1, PFLV)
        }
    }
    OperationRegion(GNVS, SystemMemory, 0xbcf9b918, 0x19f)
    Field(GNVS, AnyAcc, Lock, Preserve)
    {
        OSYS, 16,
        SMIF, 8,
        PRM0, 8,
        PRM1, 8,
        SCIF, 8,
        PRM2, 8,
        PRM3, 8,
        LCKF, 8,
        PRM4, 8,
        PRM5, 8,
        P80D, 32,
        LIDS, 8,
        PWRS, 8,
        DBGS, 8,
        THOF, 8,
        ACT1, 8,
        ACTT, 8,
        PSVT, 8,
        TC1V, 8,
        TC2V, 8,
        TSPV, 8,
        CRTT, 8,
        DTSE, 8,
        DTS1, 8,
        DTS2, 8,
        DTSF, 8,
        Offset(0x28),
        APIC, 8,
        TCNT, 8,
        PCP0, 8,
        PCP1, 8,
        PPCM, 8,
        PPMF, 32,
        C67L, 8,
        NATP, 8,
        CMAP, 8,
        CMBP, 8,
        LPTP, 8,
        FDCP, 8,
        CMCP, 8,
        CIRP, 8,
        SMSC, 8,
        W381, 8,
        SMC1, 8,
        IGDS, 8,
        TLST, 8,
        CADL, 8,
        PADL, 8,
        CSTE, 16,
        NSTE, 16,
        SSTE, 16,
        NDID, 8,
        DID1, 32,
        DID2, 32,
        DID3, 32,
        DID4, 32,
        DID5, 32,
        KSV0, 32,
        KSV1, 8,
        , 16,
        DCLK, 16,
        FSBF, 16,
        , 8,
        BLCS, 8,
        BRTL, 8,
        ALSE, 8,
        ALAF, 8,
        LLOW, 8,
        LHIH, 8,
        , 8,
        EMAE, 8,
        EMAP, 16,
        EMAL, 16,
        , 8,
        MEFE, 8,
        DSTS, 8,
        , 16,
        TPMP, 8,
        TPME, 8,
        Offset(0x82),
        GTF0, 56,
        GTF2, 56,
        IDEM, 8,
        GTF1, 56,
        BID_, 8,
        Offset(0xaa),
        ASLB, 32,
        IBTT, 8,
        IPAT, 8,
        ITVF, 8,
        ITVM, 8,
        IPSC, 8,
        IBLC, 8,
        IBIA, 8,
        ISSC, 8,
        I409, 8,
        I509, 8,
        I609, 8,
        I709, 8,
        IPCF, 8,
        IDMS, 8,
        IF1E, 8,
        HVCO, 8,
        NXD1, 32,
        NXD2, 32,
        NXD3, 32,
        NXD4, 32,
        NXD5, 32,
        NXD6, 32,
        NXD7, 32,
        NXD8, 32,
        GSMI, 8,
        PAVP, 8,
        , 8,
        OSCC, 8,
        NEXP, 8,
        SDGV, 8,
        SDDV, 8,
        Offset(0xeb),
        DSEN, 8,
        ECON, 8,
        GPIC, 8,
        CTYP, 8,
        L01C, 8,
        VFN0, 8,
        VFN1, 8,
        Offset(0x100),
        NVGA, 32,
        NVHA, 32,
        AMDA, 32,
        DID6, 32,
        DID7, 32,
        DID8, 32,
        EBAS, 32,
        CPSP, 32,
        EECP, 32,
        EVCP, 32,
        XBAS, 32,
        OBS1, 32,
        OBS2, 32,
        OBS3, 32,
        OBS4, 32,
        OBS5, 32,
        OBS6, 32,
        OBS7, 32,
        OBS8, 32,
        Offset(0x157),
        ATMC, 8,
        PTMC, 8,
        ATRA, 8,
        PTRA, 8,
        PNHM, 32,
        TBAB, 32,
        TBAH, 32,
        RTIP, 8,
        TSOD, 8,
        ATPC, 8,
        PTPC, 8,
        PFLV, 8,
        BREV, 8,
        SGMD, 8,
        SGFL, 8,
        PWOK, 8,
        HLRS, 8,
        DSEL, 8,
        ESEL, 8,
        PSEL, 8,
        PWEN, 8,
        PRST, 8,
        MXD1, 32,
        MXD2, 32,
        MXD3, 32,
        MXD4, 32,
        MXD5, 32,
        MXD6, 32,
        MXD7, 32,
        MXD8, 32,
        GBAS, 16,
        Offset(0x19d),
        ALFP, 8,
        IMON, 8
    }
    OperationRegion(ASMA, SystemMemory, 0xbcfbc018, 0x1060)
    Field(ASMA, AnyAcc, NoLock, Preserve)
    {
        ASMB, 33536
    }
    OperationRegion(AF10, SystemMemory, 0xbcfbe018, 0xa17)
    Field(AF10, AnyAcc, Lock, Preserve)
    {
        STAT, 32,
        EVAL, 8,
        ASTL, 8,
        ASTG, 256,
        OWNT, 640,
        PROD, 640,
        MODL, 640,
        PTYP, 640,
        PFRQ, 640,
        MEMS, 640,
        DATE, 640,
        FAMI, 640,
        SERL, 640,
        VREV, 640,
        VRE2, 640,
        KBCD, 640,
        HDDS, 160,
        HDDM, 320,
        CDAT, 136,
        CSTS, 8,
        CYCL, 8,
        PBSN, 144,
        SBSN, 144,
        BSTS, 8,
        BORD, 72,
        APST, 8,
        OAPW, 3200,
        NAPW, 3200,
        SECO, 32,
        SECS, 32,
        SKUN, 128,
        SVID, 80,
        SSID, 32,
        BTFC, 160,
        WLFC, 160,
        WWFC, 160,
        GPFC, 160,
        UUID, 256,
        CFID, 208,
        PWDL, 16,
        USRN, 264,
        ROLE, 32,
        CMDV, 32,
        KBDL, 32,
        HASH, 160,
        SPSF, 8,
        FMOD, 8,
        NBDL, 8,
        MBDL, 8,
        NBAD, 8,
        MBAD, 8,
        WUFI, 24,
        LFND, 1296,
        ATIM, 48,
        PCID, 512,
        PCVR, 40,
        CURL, 1040,
        RDSP, 8,
        FCM_, 32,
        MPMC, 8,
        SBCT, 120,
        TXTC, 8,
        AMTC, 8,
        CPRV, 120,
        BKPR, 8,
        SNMD, 8
    }
    OperationRegion(HPDF, SystemMemory, 0xbcfbfe18, 0x17c)
    Field(HPDF, AnyAcc, Lock, Preserve)
    {
        SLPT, 4,
        WHOS, 4,
        SDFG, 4,
        LEGF, 1,
        KCDB, 1,
        KLDB, 1,
        TPMX, 1,
        FOAL, 1,
        AEDA, 1,
        ALSF, 1,
        WOLD, 1,
        HSED, 1,
        HDEN, 1,
        MDEN, 1,
        ICPT, 1,
        PMCS, 1,
        UWKD, 1,
        INQW, 1,
        ILUX, 1,
        ITPS, 1,
        FCIN, 1,
        ASFG, 2,
        WDPE, 8,
        WDSA, 16,
        WDST, 16,
        WDGN, 16,
        WDSS, 16,
        WLBN, 8,
        PRDT, 8,
        LPDP, 16,
        EAX_, 32,
        EBX_, 32,
        ECX_, 32,
        EDX_, 32,
        REFS, 32,
        SSCI, 8,
        SBFC, 8,
        TJMX, 8,
        TRCN, 8,
        DCAP, 8,
        LOTR, 160,
        HITR, 160,
        WABN, 8,
        WADN, 8,
        WAFN, 8,
        DTCD, 32,
        BDCP, 8,
        TBRB, 32,
        OHCB, 32,
        EDID, 2048,
        ESTA, 8,
        VRMS, 32,
        VRMB, 32,
        SGME, 8,
        AMNS, 32,
        AMNP, 32,
        AMVS, 32,
        AMVP, 32
    }
    OperationRegion(HPD2, SystemMemory, 0xbce6cf18, 0x6d)
    Field(HPD2, AnyAcc, Lock, Preserve)
    {
        CFPS, 8,
        CMDS, 8,
        BRID, 8,
        F11_, 1,
        RSVD, 31,
        WLDA, 768,
        WLFL, 8,
        WLIX, 8,
        BTIX, 8,
        WWIX, 8,
        W2IX, 8,
        GPSI, 8
    }
    OperationRegion(HPBR, SystemMemory, 0xbcfbbf18, 0x7e)
    Field(HPBR, AnyAcc, Lock, Preserve)
    {
        PAID, 32,
        PHSZ, 8,
        PVSZ, 8,
        BRCT, 8,
        BCCT, 8,
        BMAP, 88,
        BCLV, 216,
        BRLV, 200,
        BRNT, 400,
        BPWG, 16,
        BPWO, 16,
        PNLF, 8
    }
    Scope(\_GPE)
    {
        Method(_L01, 0x0, NotSerialized)
        {
            Add(L01C, 0x1, L01C)
            \_SB_.PCI0.RP01.HPLG()
            \_SB_.PCI0.RP02.HPLG()
            \_SB_.PCI0.RP03.HPLG()
            \_SB_.PCI0.RP04.HPLG()
            \_SB_.PCI0.RP05.HPLG()
            \_SB_.PCI0.RP06.HPLG()
            \_SB_.PCI0.RP07.HPLG()
            \_SB_.PCI0.RP08.HPLG()
        }
        Method(_L02, 0x0, NotSerialized)
        {
            Store(0x0, GPEC)
            Store(SSCI, Local0)
            If(Local0)
            {
                Store(0x0, SSCI)
                If(LEqual(Local0, 0x1))
                {
                    VFN4()
                }
                If(LEqual(Local0, 0x4))
                {
                    \_SB_.WMID.WGWE(Local0, 0x0)
                }
                If(LEqual(Local0, 0x5))
                {
                    \_SB_.WMID.WGWE(Local0, 0x0)
                }
                If(LEqual(Local0, 0x3))
                {
                    VBRE(0x87)
                }
                If(LEqual(Local0, 0x2))
                {
                    VBRE(0x86)
                }
            }
        }
        Method(_L09, 0x0, NotSerialized)
        {
            \_SB_.PCI0.RP01.PME_()
            \_SB_.PCI0.RP02.PME_()
            \_SB_.PCI0.RP03.PME_()
            \_SB_.PCI0.RP04.PME_()
            \_SB_.PCI0.RP05.PME_()
            \_SB_.PCI0.RP06.PME_()
            \_SB_.PCI0.RP07.PME_()
            \_SB_.PCI0.RP08.PME_()
        }
        Method(_L0B, 0x0, NotSerialized)
        {
            Notify(\_SB_.PCI0.PCIB, 0x2)
        }
        Method(_L0D, 0x0, NotSerialized)
        {
            If(\_SB_.PCI0.EHC1.PMES)
            {
                Store(0x1, \_SB_.PCI0.EHC1.PMES)
                Notify(\_SB_.PCI0.EHC1, 0x2)
            }
            If(\_SB_.PCI0.EHC2.PMES)
            {
                Store(0x1, \_SB_.PCI0.EHC2.PMES)
                Notify(\_SB_.PCI0.EHC2, 0x2)
            }
            If(\_SB_.PCI0.HDEF.PMES)
            {
                Store(0x1, \_SB_.PCI0.HDEF.PMES)
                Notify(\_SB_.PCI0.HDEF, 0x2)
            }
            Notify(\_SB_.PCI0.LANC, 0x2)
        }
        Method(_L13, 0x0, NotSerialized)
        {
            And(GPIE, Not(0x8, ), Local0)
            Store(Local0, GPIE)
            Or(GPL3, 0x10, Local0)
            Store(Local0, GPL3)
            Sleep(0x3e8)
            Notify(\_SB_.PCI0.SATA, 0x81)
        }
        Method(_L1D, 0x0, NotSerialized)
        {
            XOr(GIV_, 0x2000, Local0)
            Store(Local0, GIV_)
            VDET()
            \_SB_.WMID.WGWE(0x1, 0x0)
            Sleep(0x3e8)
            Notify(\_SB_.PCI0.EHC2, 0x0)
            Notify(\_SB_.PCI0.SATA, 0x0)
            DKET()
        }
        Method(HWWP, 0x1, Serialized)
        {
            If(LOr(LEqual(INQW, 0x0), LEqual(Arg0, 0x1)))
            {
                Store(0x0, Local0)
                If(And(GPL0, 0x400000, ))
                {
                    Store(0x1, Local0)
                }
                \_SB_.PCI0.LPCB.EC0_.HWWP(Local0)
            }
        }
    }
    Scope(\_PR_)
    {
        Processor(CPU0, 0x0, 0x410, 0x6)
        {
        }
        Processor(CPU1, 0x1, 0x410, 0x6)
        {
        }
        Processor(CPU2, 0x2, 0x410, 0x6)
        {
        }
        Processor(CPU3, 0x3, 0x410, 0x6)
        {
        }
        Processor(CPU4, 0x4, 0x410, 0x6)
        {
        }
        Processor(CPU5, 0x5, 0x410, 0x6)
        {
        }
        Processor(CPU6, 0x6, 0x410, 0x6)
        {
        }
        Processor(CPU7, 0x7, 0x410, 0x6)
        {
        }
    }
    Scope(\_TZ_)
    {
        Name(TRPC, Package(0x5)
        {
            Package(0x4)
            {
                0x60,
                0x63,
                0x63,
                0x80
            },
            Package(0x4)
            {
                0x65,
                0x6c,
                0x80,
                0x80
            },
            Package(0x4)
            {
                0x80,
                0x80,
                0x80,
                0x80
            },
            Package(0x4)
            {
                0x80,
                0x80,
                0x80,
                0x80
            },
            Package(0x4)
            {
                0x36,
                0x37,
                0x80,
                0x80
            }
        })
        Name(TRIP, Package(0x5)
        {
            Package(0x4)
            {
            },
            Package(0x4)
            {
            },
            Package(0x4)
            {
            },
            Package(0x4)
            {
            },
            Package(0x4)
            {
            }
        })
        Name(CLSH, Package(0x4)
        {
            0x62,
            0x69,
            0x80,
            0x80
        })
        Method(TRUP, 0x0, Serialized)
        {
            Name(_T_0, Zero)
            Store(PRDT, _T_0)
            If(LEqual(_T_0, 0x1))
            {
                Store(0x10cc, MRPM)
            }
            Else
            {
                If(LEqual(_T_0, 0x2))
                {
                    Store(0x10cc, MRPM)
                    Store(CLSH, Index(TRPC, 0x1, ))
                }
                Else
                {
                    If(LEqual(_T_0, 0x3))
                    {
                        Store(0x10cc, MRPM)
                    }
                }
            }
            Store(0x10cc, MRPM)
            If(LGreater(TJMX, 0x0))
            {
                Subtract(TJMX, 0x1, Local0)
                Store(Local0, Index(DerefOf(Index(TRPC, 0x0, )), 0x2, ))
                Store(Local0, Index(DerefOf(Index(TRPC, 0x0, )), 0x1, ))
                Subtract(TJMX, 0x4, Index(DerefOf(Index(TRPC, 0x0, )), 0x0, ))
            }
        }
        Method(INTM, 0x1, Serialized)
        {
            Store(0x0, Local0)
            OTHI(Arg0)
        }
        Name(WHTR, 0x1f)
        Name(OSTH, 0x0)
        Name(LARE, Package(0x6)
        {
        })
        Name(LARP, Package(0x6)
        {
        })
        Name(CUZO, Package(0x6)
        {
        })
        Name(LATR, Package(0x6)
        {
        })
        Mutex(THER, 0x0)
        Name(THSC, 0x1f)
        Name(MRPM, 0x1388)
        Method(BOTT, 0x0, Serialized)
        {
            TRUP()
            Store(SizeOf(TRPC), Local3)
            Store(DerefOf(Index(TRPC, 0x0, )), Local5)
            Store(SizeOf(Local5), Local4)
            Store(0x0, Local0)
            While(LLess(Local0, Local3))
            {
                Store(0x0, Local1)
                While(LLess(Local1, Local4))
                {
                    Store(DerefOf(Index(DerefOf(Index(TRPC, Local0, )), Local1, )), Local6)
                    Store(GETK(Local6), Local7)
                    Store(Local7, Index(DerefOf(Index(TRIP, Local0, )), Local1, ))
                    Increment(Local1)
                }
                Increment(Local0)
            }
        }
        Method(RETD, 0x0, Serialized)
        {
            Acquire(THER, 0xffff)
            Store(0x1f, THSC)
            Store(0x1f, WHTR)
            Store(0x0, Local0)
            While(LLess(Local0, 0x6))
            {
                Store(0x0, Index(LARE, Local0, ))
                Store(0x0, Index(LARP, Local0, ))
                Store(0xff, Index(CUZO, Local0, ))
                Store(0x0, Index(LATR, Local0, ))
                Increment(Local0)
            }
            Release(THER)
        }
        Method(OTHI, 0x1, Serialized)
        {
            ECTI(0x1)
            If(Arg0)
            {
                NTHS(0x1f)
            }
        }
        Name(OTID, 0x0)
        Method(ECTI, 0x1, Serialized)
        {
            Store(0x0, Local0)
            If(LEqual(Arg0, 0x1))
            {
                Store(0x1, OTID)
            }
            If(LAnd(\_SB_.PCI0.LPCB.EC0_.ECRG, OTID))
            {
                NTHS(0x1f)
                Store(0x0, OTID)
            }
        }
        Method(OSIT, 0x0, Serialized)
        {
            If(LEqual(OSTH, 0x0))
            {
                \_TZ_.INTM(0x0)
                Store(0x1, OSTH)
            }
        }
        Method(GETP, 0x2, Serialized)
        {
            Store(Arg1, Local0)
            If(LEqual(Arg1, 0x1))
            {
                Store(DerefOf(Index(CUZO, Arg0, )), Local3)
                If(LAnd(LGreater(Local3, 0x1), LNot(LEqual(Local3, 0xff))))
                {
                    Store(0x0, Local0)
                }
            }
            Store(DerefOf(Index(DerefOf(Index(TRIP, Arg0, )), Local0, )), Local2)
            Return(Local2)
        }
        Method(GETK, 0x1, Serialized)
        {
            Multiply(Arg0, 0xa, Local0)
            Add(Local0, 0xaac, Local1)
            Return(Local1)
        }
        Method(GTTP, 0x5, Serialized)
        {
            Store(Arg2, Local1)
            If(LAnd(LNot(LGreater(Arg0, 0x4)), \_SB_.PCI0.LPCB.EC0_.ECRG))
            {
                Acquire(\_SB_.PCI0.LPCB.EC0_.ECMX, 0xffff)
                Store(Arg1, \_SB_.PCI0.LPCB.EC0_.CRZN)
                Store(\_SB_.PCI0.LPCB.EC0_.TEMP, Local1)
                Release(\_SB_.PCI0.LPCB.EC0_.ECMX)
            }
            Store(Local1, Local2)
            If(LLess(Local1, Arg3))
            {
                If(LLess(DerefOf(Index(LARE, Arg0, )), Arg3))
                {
                    Store(Arg3, Index(LARP, Arg0, ))
                }
                Store(DerefOf(Index(LARP, Arg0, )), Local1)
            }
            Else
            {
                If(LGreater(Local1, Arg4))
                {
                    If(LGreater(DerefOf(Index(LARE, Arg0, )), Arg4))
                    {
                        Store(Arg4, Index(LARP, Arg0, ))
                    }
                    Store(DerefOf(Index(LARP, Arg0, )), Local1)
                }
            }
            Store(Local2, Index(LARE, Arg0, ))
            Store(Local1, Index(LARP, Arg0, ))
            Return(Local1)
        }
        Method(SETM, 0x3, Serialized)
        {
            Store(0x0, Local5)
            If(LNot(LGreater(Arg0, 0x4)))
            {
                Acquire(THER, 0xffff)
                Store(ShiftLeft(0x1, Arg0, ), Local7)
                If(LAnd(And(THSC, Local7, ), \_SB_.PCI0.LPCB.EC0_.ECRG))
                {
                    If(LAnd(DerefOf(Index(LATR, Arg0, )), LNot(LEqual(Arg0, 0x4))))
                    {
                        Add(Arg2, 0x2, Local4)
                    }
                    Else
                    {
                        Store(Arg2, Local4)
                    }
                    Store(DerefOf(Index(DerefOf(Index(TRPC, Arg0, )), 0x0, )), Local2)
                    Store(0x1, Local0)
                    While(LNot(LGreater(Local0, 0x3)))
                    {
                        Store(DerefOf(Index(DerefOf(Index(TRPC, Arg0, )), Local0, )), Local6)
                        If(LLess(Local4, Local6))
                        {
                            Break
                        }
                        Else
                        {
                            Increment(Local0)
                        }
                    }
                    If(LEqual(Local0, 0x1))
                    {
                        If(LGreater(Arg2, Local2))
                        {
                            If(LGreater(DerefOf(Index(LATR, Arg0, )), Local6))
                            {
                                Increment(Local0)
                            }
                        }
                    }
                    Store(DerefOf(Index(TRPC, Arg0, )), Local3)
                    Store(SizeOf(Local3), Local4)
                    If(LAnd(LNot(LEqual(Local0, DerefOf(Index(CUZO, Arg0, )))), LLess(Local0, Local4)))
                    {
                        Store(0x1, Local5)
                        Store(Local0, Index(CUZO, Arg0, ))
                        If(LLess(Arg0, 0x4))
                        {
                            Acquire(\_SB_.PCI0.LPCB.EC0_.ECMX, 0xffff)
                            Store(Arg1, \_SB_.PCI0.LPCB.EC0_.CRZN)
                            If(LEqual(DerefOf(Index(LATR, Arg0, )), 0x0))
                            {
                                Store(Local2, \_SB_.PCI0.LPCB.EC0_.PLTP)
                            }
                            Store(Local6, \_SB_.PCI0.LPCB.EC0_.PHTP)
                            Release(\_SB_.PCI0.LPCB.EC0_.ECMX)
                        }
                        Store(Local6, Index(LATR, Arg0, ))
                    }
                    And(THSC, Not(Local7, ), THSC)
                }
                Release(THER)
            }
            Return(Local5)
        }
        Method(CHOT, 0x1, Serialized)
        {
            If(And(DTCD, 0x20000, ))
            {
                Store(0xfac, Local0)
            }
            Else
            {
                Store(GETP(Arg0, 0x2), Local0)
            }
            Return(Local0)
        }
        ThermalZone(CPUZ)
        {
            Method(_HOT, 0x0, Serialized)
            {
                Return(CHOT(0x0))
            }
            Method(_CRT, 0x0, Serialized)
            {
                Return(GETP(0x0, 0x3))
            }
            Method(_TMP, 0x0, Serialized)
            {
                \_TZ_.OSIT()
                Store(0x0, Local0)
                Store(GTTP(0x0, 0x1, 0x10, 0x0, 0x7f), Local0)
                If(SETM(0x0, 0x1, Local0))
                {
                    Notify(\_TZ_.CPUZ, 0x81)
                }
                Return(GETK(Local0))
            }
        }
        ThermalZone(GFXZ)
        {
            Method(_PSV, 0x0, NotSerialized)
            {
                Return(GETP(0x1, 0x1))
            }
            Method(_PSL, 0x0, NotSerialized)
            {
                Return(PSL_())
            }
            Name(_TSP, 0x12c)
            Name(_TC1, 0x1)
            Name(_TC2, 0x2)
            Method(_CRT, 0x0, Serialized)
            {
                Return(GETP(0x1, 0x3))
            }
            Method(_TMP, 0x0, Serialized)
            {
                Store(0x0, Local0)
                Store(GTTP(0x1, 0x2, 0x10, 0x0, 0x7f), Local0)
                If(SETM(0x1, 0x2, Local0))
                {
                    Notify(\_TZ_.GFXZ, 0x81)
                }
                Return(GETK(Local0))
            }
        }
        ThermalZone(EXTZ)
        {
            Method(_CRT, 0x0, Serialized)
            {
                Return(GETP(0x2, 0x3))
            }
            Method(_TMP, 0x0, Serialized)
            {
                Store(0x0, Local0)
                Store(GTTP(0x2, 0x3, 0x10, 0x0, 0x7f), Local0)
                Return(GETK(Local0))
            }
        }
        ThermalZone(LOCZ)
        {
            Method(_CRT, 0x0, Serialized)
            {
                Return(GETP(0x3, 0x3))
            }
            Method(_TMP, 0x0, Serialized)
            {
                Store(0x0, Local0)
                Store(GTTP(0x3, 0x4, 0x10, 0x0, 0x7f), Local0)
                Return(GETK(Local0))
            }
        }
        ThermalZone(BATZ)
        {
            Method(_PSV, 0x0, NotSerialized)
            {
                Return(GETP(0x4, 0x1))
            }
            Method(_PSL, 0x0, NotSerialized)
            {
                Return(PSL_())
            }
            Name(_TSP, 0x12c)
            Name(_TC1, 0x32)
            Name(_TC2, 0x0)
            Method(_CRT, 0x0, Serialized)
            {
                Return(GETP(0x4, 0x3))
            }
            Method(_TMP, 0x0, Serialized)
            {
                Store(0x0, Local0)
                Store(GTTP(0x4, 0x5, 0x0, 0x0, 0x7f), Local0)
                If(SETM(0x4, 0x5, Local0))
                {
                    Notify(\_TZ_.BATZ, 0x81)
                }
                Return(GETK(Local0))
            }
        }
        Method(NTHS, 0x1, Serialized)
        {
            If(And(Arg0, 0x1, ))
            {
                Notify(CPUZ, 0x80)
            }
            If(And(Arg0, 0x2, ))
            {
                Notify(GFXZ, 0x80)
            }
            If(And(Arg0, 0x4, ))
            {
                Notify(EXTZ, 0x80)
            }
            If(And(Arg0, 0x8, ))
            {
                Notify(LOCZ, 0x80)
            }
            If(And(Arg0, 0x10, ))
            {
                Notify(BATZ, 0x80)
            }
        }
        Method(ECTE, 0x1, Serialized)
        {
            Store(0x0, Local1)
            If(Arg0)
            {
                If(And(Arg0, 0x1, ))
                {
                    Or(Local1, 0x1, Local1)
                }
                If(And(Arg0, 0x2, ))
                {
                    Or(Local1, 0x2, Local1)
                }
                If(And(Arg0, 0x4, ))
                {
                    Or(Local1, 0x4, Local1)
                }
                If(And(Arg0, 0x8, ))
                {
                    Or(Local1, 0x8, Local1)
                }
                If(And(Arg0, 0x10, ))
                {
                    Or(Local1, 0x10, Local1)
                }
            }
            Else
            {
                Or(Local1, 0x10, Local1)
            }
            Acquire(THER, 0xffff)
            Or(THSC, Local1, THSC)
            Release(THER)
            NTHS(Local1)
        }
        Method(GFRM, 0x0, Serialized)
        {
            Store(0x0, Local0)
            If(\_SB_.PCI0.LPCB.EC0_.ECRG)
            {
                Acquire(\_SB_.PCI0.LPCB.EC0_.ECMX, 0xffff)
                Store(\_SB_.PCI0.LPCB.EC0_.FRDC, Local0)
                Release(\_SB_.PCI0.LPCB.EC0_.ECMX)
                If(Local0)
                {
                    ShiftRight(Local0, 0x1, Local1)
                    Add(0x3c000, Local1, Local2)
                    Divide(Local2, Local0, Local1, Local0)
                }
            }
            Return(Local0)
        }
        Method(GTRM, 0x0, Serialized)
        {
            Store(0x0, Local0)
            If(\_SB_.PCI0.LPCB.EC0_.ECRG)
            {
                Acquire(\_SB_.PCI0.LPCB.EC0_.ECMX, 0xffff)
                Store(\_SB_.PCI0.LPCB.EC0_.FTGC, Local0)
                Release(\_SB_.PCI0.LPCB.EC0_.ECMX)
                If(Local0)
                {
                    ShiftRight(Local0, 0x1, Local1)
                    Add(0x3c000, Local1, Local2)
                    Divide(Local2, Local0, Local1, Local0)
                }
            }
            Return(Local0)
        }
        Method(GFSD, 0x0, Serialized)
        {
            Store(GFRM(), Local0)
            Multiply(Local0, 0x64, Local1)
            Divide(Local1, MRPM, Local1, Local2)
            Return(Local2)
        }
        Method(CTCT, 0x1, Serialized)
        {
            Multiply(Arg0, MRPM, Local1)
            Divide(Local1, 0x64, Local2, Local0)
            If(Local0)
            {
                ShiftRight(Local0, 0x1, Local1)
                Add(0x3c000, Local1, Local2)
                Divide(Local2, Local0, Local1, Local0)
            }
            If(LGreater(Local0, 0xf4))
            {
                Store(0xf4, Local0)
            }
            Return(Local0)
        }
        Method(PSL_, 0x0, Serialized)
        {
            If(And(CFGD, 0x1000000, ))
            {
                If(LEqual(TCNT, 0x8))
                {
                    Return(Package(0x8)
                    {
                        \_PR_.CPU0,
                        \_PR_.CPU1,
                        \_PR_.CPU2,
                        \_PR_.CPU3,
                        \_PR_.CPU4,
                        \_PR_.CPU5,
                        \_PR_.CPU6,
                        \_PR_.CPU7
                    })
                }
                If(LEqual(TCNT, 0x4))
                {
                    Return(Package(0x4)
                    {
                        \_PR_.CPU0,
                        \_PR_.CPU1,
                        \_PR_.CPU2,
                        \_PR_.CPU3
                    })
                }
                Return(Package(0x2)
                {
                    \_PR_.CPU0,
                    \_PR_.CPU1
                })
            }
            Else
            {
                Return(Package(0x1)
                {
                    \_PR_.CPU0
                })
            }
        }
        ThermalZone(PCHZ)
        {
            Method(_CRT, 0x0, Serialized)
            {
                Return(0xfac)
            }
            Method(_TMP, 0x0, Serialized)
            {
                Store(0x0, Local0)
                Store(GTTP(0x5, 0x0, PCHT, 0x0, 0x7f), Local0)
                Store(DerefOf(Index(DerefOf(Index(\_SB_.WMID.TSTV, 0x2, )), 0x2, )), Local1)
                If(LNot(LEqual(Local1, 0xff)))
                {
                    Store(Local1, Local0)
                }
                Return(GETK(Local0))
            }
        }
        Method(GDTP, 0x2, Serialized)
        {
            If(LOr(Arg1, DTZS()))
            {
                Store(\_SB_.PCI0.SBUS.SRDW(Arg0, 0x5), Local0)
                If(LEqual(Local0, 0xffffffff))
                {
                    Store(0x0, Local0)
                }
                Else
                {
                    If(And(Local0, 0x1000, ))
                    {
                        Store(0x0, Local0)
                    }
                    Else
                    {
                        ShiftRight(Local0, 0x4, Local0)
                        And(Local0, 0xff, Local0)
                    }
                }
                Return(\_TZ_.GETK(Local0))
            }
            Else
            {
                Return(0xaac)
            }
        }
        Method(DTZS, 0x0, NotSerialized)
        {
            If(And(DTCD, 0x10000, ))
            {
                Return(0xf)
            }
            Return(0x0)
        }
        ThermalZone(DM1Z)
        {
            Method(_STA, 0x0, NotSerialized)
            {
                Return(DTZS())
            }
            Method(_TMP, 0x0, Serialized)
            {
                Return(GDTP(0x30, 0x0))
            }
            Method(_CRT, 0x0, Serialized)
            {
                Return(0xfac)
            }
        }
        ThermalZone(DM2Z)
        {
            Method(_STA, 0x0, NotSerialized)
            {
                Return(DTZS())
            }
            Method(_TMP, 0x0, Serialized)
            {
                Return(GDTP(0x34, 0x0))
            }
            Method(_CRT, 0x0, Serialized)
            {
                Return(0xfac)
            }
        }
    }
    Name(\NIST, Package(0x10)
    {
        "0",
        "1",
        "2",
        "3",
        "4",
        "5",
        "6",
        "7",
        "8",
        "9",
        "A",
        "B",
        "C",
        "D",
        "E",
        "F"
    })
    Method(\ISTR, 0x2, NotSerialized)
    {
        Store(Arg0, Local0)
        Store("", Local7)
        Store(Arg1, Local4)
        While(LGreater(Local4, 0x0))
        {
            And(Local0, 0xf, Local1)
            Store(DerefOf(Index(\NIST, Local1, )), Local2)
            Concatenate(Local2, Local7, Local3)
            Store(Local3, Local7)
            ShiftRight(Local0, 0x4, Local0)
            Decrement(Local4)
        }
        Return(Local7)
    }
    Method(\SRCP, 0x2, NotSerialized)
    {
        Store(SizeOf(Arg0), Local7)
        If(LNot(LEqual(Local7, SizeOf(Arg1))))
        {
            Return(0x0)
        }
        Name(ST00, Buffer(Local7)
        {
        })
        Name(ST01, Buffer(Local7)
        {
        })
        Store(Arg0, ST00)
        Store(Arg1, ST01)
        Store(0x0, Local6)
        Store(0x1, Local0)
        While(LAnd(LNot(LEqual(Local6, Local7)), Local0))
        {
            Store(DerefOf(Index(ST00, Local6, )), Local2)
            Store(DerefOf(Index(ST01, Local6, )), Local3)
            Increment(Local6)
            If(LNot(LEqual(Local2, Local3)))
            {
                Store(0x0, Local0)
            }
        }
        Return(Local0)
    }
    Name(WOSI, 0xff)
    Name(OSID, Package(0x3)
    {
        "Microsoft Windows",
        "Microsoft WindowsME: Millennium Edition",
        "Microsoft Windows NT"
    })
    Method(\SRCM, 0x3, NotSerialized)
    {
        Name(ST00, Buffer(0x8c)
        {
        })
        Name(ST01, Buffer(0x8c)
        {
        })
        Store(Arg0, ST00)
        Store(Arg1, ST01)
        Store(0x0, Local6)
        Store(0x1, Local0)
        While(LAnd(LNot(LEqual(Local6, Arg2)), Local0))
        {
            Store(DerefOf(Index(ST00, Local6, )), Local2)
            Store(DerefOf(Index(ST01, Local6, )), Local3)
            Increment(Local6)
            If(LNot(LEqual(Local2, Local3)))
            {
                Store(0x0, Local0)
            }
        }
        Return(Local0)
    }
    Method(WCOS, 0x0, Serialized)
    {
        If(LEqual(WOSI, 0xff))
        {
            Store(\_OS_, Local0)
            Store(SizeOf(OSID), Local7)
            Store(0x0, Local1)
            While(LAnd(LLess(Local1, Local7), LEqual(WOSI, 0xff)))
            {
                Store(\SRCP(Local0, DerefOf(Index(OSID, Local1, ))), Local2)
                If(Local2)
                {
                    Add(Local1, 0x1, WOSI)
                }
                Else
                {
                    Increment(Local1)
                }
            }
            If(LEqual(WOSI, 0xff))
            {
                Store(0x0, WOSI)
            }
            If(LOr(LEqual(WOSI, 0x0), LEqual(WOSI, 0x3)))
            {
                If(CondRefOf(\_OSI, Local0))
                {
                    If(\_OSI("Windows 2001"))
                    {
                        Store(0x4, WOSI)
                    }
                    If(\_OSI("Windows 2001 SP1"))
                    {
                        Store(0x4, WOSI)
                    }
                    If(\_OSI("Windows 2001 SP2"))
                    {
                        Store(0x5, WOSI)
                    }
                    If(\_OSI("Windows 2006"))
                    {
                        Store(0x6, WOSI)
                    }
                    If(\_OSI("Windows 2009"))
                    {
                        Store(0x7, WOSI)
                    }
                }
            }
            Store(WOSI, WHOS)
        }
        Return(WOSI)
    }
    Method(UPRW, 0x2, Serialized)
    {
        Store(Package(0x2)
        {
            0x0,
            0x0
        }, Local0)
        Store(Arg0, Index(Local0, 0x0, ))
        If(LEqual(UWKD, 0x0))
        {
            Store(Arg1, Index(Local0, 0x1, ))
        }
        Return(Local0)
    }
    Name(EUPC, Package(0x4)
    {
        0xff,
        0xff,
        0x0,
        0x0
    })
    Name(EPLD, Buffer(0x10)
    {
	0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00
    })
    Method(CBRT, 0x2, Serialized)
    {
        Store(SizeOf(Arg0), Local6)
        Store(SizeOf(Arg1), Local7)
        If(LEqual(Local6, 0x0))
        {
            Store(Arg1, Local0)
            Return(Local0)
        }
        If(LEqual(Local7, 0x0))
        {
            Store(Arg0, Local0)
            Return(Local0)
        }
        Add(Local7, Local6, Local1)
        Subtract(Local1, 0x2, Local1)
        Store(Buffer(Local1)
        {
        }, Local0)
        Store(0x0, Local1)
        While(LLess(Local1, SizeOf(Arg0)))
        {
            Store(DerefOf(Index(Arg0, Local1, )), Index(Local0, Local1, ))
            Increment(Local1)
        }
        Subtract(Local1, 0x2, Local1)
        Store(0x0, Local2)
        While(LLess(Local2, SizeOf(Arg1)))
        {
            Store(DerefOf(Index(Arg1, Local2, )), Index(Local0, Local1, ))
            Increment(Local1)
            Increment(Local2)
        }
        Return(Local0)
    }
    Scope(\_SB_)
    {
        Mutex(MSMI, 0x0)
        Method(SSMI, 0x5, NotSerialized)
        {
            Acquire(MSMI, 0xffff)
            If(Arg4)
            {
                Acquire(\_GL_, 0xffff)
            }
            ShiftLeft(Arg0, 0x10, EAX_)
            Store(Arg1, EBX_)
            Store(Arg2, ECX_)
            Store(Arg3, EDX_)
            Store(0x0, REFS)
            \_SB_.PCI0.GSWS(Arg0)
            Store(REFS, Local0)
            If(Arg4)
            {
                Release(\_GL_)
            }
            Release(MSMI)
            Return(Local0)
        }
        Name(BCLI, 0x0)
        Name(BCLS, Package(0x3)
        {
            Package(0xd)
            {
            },
            Package(0x17)
            {
            },
            Package(0x1b)
            {
            }
        })
        Name(NITS, Package(0x3)
        {
            Buffer(0x16)
            {
            },
            Buffer(0x2a)
            {
            },
            Buffer(0x32)
            {
            }
        })
        Name(BCLC, 0x0)
        Method(BCL_, 0x0, Serialized)
        {
            If(LEqual(BCLC, 0x0))
            {
                If(LGreater(\WCOS(), 0x6))
                {
                    Store(BCCT, BRCT)
                }
                Store(0x0, Local7)
                If(LNot(LLess(BRCT, 0x15)))
                {
                    Store(0x1, BCLI)
                    Store(0x1, Local7)
                    If(LEqual(BRCT, 0x19))
                    {
                        Store(0x2, BCLI)
                    }
                }
                Store(0x0, Local1)
                If(And(DCAP, 0x10, ))
                {
                    Store(BRLV, Local0)
                    Store(0x0, Local5)
                    Store(BMAP, Local4)
                    While(LLess(Local1, BRCT))
                    {
                        If(Local7)
                        {
                            Store(Local1, Local3)
                        }
                        Else
                        {
                            Store(DerefOf(Index(Local4, Local1, )), Local3)
                        }
                        Store(DerefOf(Index(Local0, Local3, )), Local2)
                        Multiply(Local2, 0x64, Local3)
                        Divide(Add(Local3, 0x7f, ), 0xff, Local6, Local2)
                        Store(Local2, Index(DerefOf(Index(BCLS, BCLI, )), Add(Local1, 0x2, ), ))
                        If(LGreater(Local2, Local5))
                        {
                            Store(Local2, Local5)
                        }
                        Increment(Local1)
                    }
                    ShiftRight(BRCT, 0x1, Local3)
                    Store(DerefOf(Index(DerefOf(Index(BCLS, BCLI, )), Local3, )), Index(DerefOf(Index(BCLS, BCLI, )), 0x1, ))
                    Store(Local5, Index(DerefOf(Index(BCLS, BCLI, )), 0x0, ))

code goes on (I have limit in this post...)

usmanyo · ‎01-30-2012

Hey guys, i have a probook 4530s and had the same fan problem, but now its not there any more. The thing ive noticed is that if you switch between your intel chipset and your RADEON graphics card, the sound tends to go away, or atleast that is what happened in my case. But i dont know about other people who dont have the series with 1GB DEDICATED graphics card. The fan used to get really loud when i turned back to POWER SAVING GPU and used to get normal when i turned to HIGH PERFORMANCE GPU. I hope HP resolves this ASAP.

Thank you

Create an account on the HP Community to personalize your profile and ask a question