NoctisX 发表于 2021-2-7 23:51

本帖最后由 NoctisX 于 2021-2-7 23:52 编辑

就是电池容量时不时会变化,有时候是2200 2100 2000 使用ACPIBatteryManager和SMCBatteryManager都这样

NoctisX 发表于 2021-2-8 00:34

我感觉重点应该在设计容量和当前容量

NoctisX 发表于 2021-2-8 00:46

给你看看我以前发生的错误 以前每次重启都会出现电池自检错误,进Mac会像楼主出现建议维修字样


yf512637021 发表于 2021-2-8 09:58

linioe 发表于 2021-2-7 22:25 https://www.pcbeta.com/static/image/common/back.gif
电池相关的方法一般在DSDT里面,当然也不排除在某个SSDT里面,但是你用这几个应该都不是本机的SSDT,所以 ...

   Method (_BIF, 0, NotSerialized)// _BIF: Battery Information            {
                IVBI ()
                If (ECOK)
                {
                  If (^^PCI0.LPCB.EC0.MBTS)
                  {
                        UBIF ()
                  }
                }

                Return (PBIF) /* \_SB_.BAT1.PBIF */
            }

            Method (_BIX, 0, NotSerialized)// _BIX: Battery Information Extended
            {
                IVBX ()
                If (ECOK)
                {
                  If (^^PCI0.LPCB.EC0.MBTS)
                  {
                        UBIX ()
                  }
                }

                Return (PBIX) /* \_SB_.BAT1.PBIX */
            }

            Method (IVBI, 0, NotSerialized)
            {
                PBIF = 0xFFFFFFFF
                PBIF = 0xFFFFFFFF
                PBIF = 0xFFFFFFFF
                PBIF = "Bad"
                PBIF = "      "
                PBIF = "Bad"
                PBIF = "Bad"
            }

            Name (LFCC, 0x1130)
            Method (UBIF, 0, Serialized)
            {
                If (ECOK)
                {
                  Acquire (^^PCI0.LPCB.EC0.MUT1, 0xFFFF)
                  Local0 = ^^PCI0.LPCB.EC0.BTDC /* \_SB_.PCI0.LPCB.EC0_.BTDC */
                  Local1 = ^^PCI0.LPCB.EC0.LFCC /* \_SB_.PCI0.LPCB.EC0_.LFCC */
                  Local2 = ^^PCI0.LPCB.EC0.BTDV /* \_SB_.PCI0.LPCB.EC0_.BTDV */
                  Local3 = ^^PCI0.LPCB.EC0.BTMD /* \_SB_.PCI0.LPCB.EC0_.BTMD */
                  Local4 = ^^PCI0.LPCB.EC0.BTMN /* \_SB_.PCI0.LPCB.EC0_.BTMN */
                  Local5 = ^^PCI0.LPCB.EC0.BTSN /* \_SB_.PCI0.LPCB.EC0_.BTSN */
                  Release (^^PCI0.LPCB.EC0.MUT1)
                  PBIF = Local0
                  PBIF = Local1
                  PBIF = Local2
                  LFCC = Local1
                  Local7 = (Local1 * 0x04)
                  Local7 /= 0x64
                  PBIF = Local7
                  PBIF = "LION"
                  Switch (Local3)
                  {
                        Case (One)
                        {
                            PBIF = "AL13D32"
                        }
                        Case (0x02)
                        {
                            PBIF = "AL14A32"
                        }
                        Case (0x03)
                        {
                            PBIF = "TW932SM"
                        }
                        Case (0x04)
                        {
                            PBIF = "AP13B8K"
                        }
                        Default
                        {
                            PBIF = "xxxxx"
                        }

                  }

                  Switch (Local4)
                  {
                        Case (0x03)
                        {
                            PBIF = "SANYO"
                        }
                        Case (0x04)
                        {
                            PBIF = "SONY"
                        }
                        Case (0x05)
                        {
                            PBIF = "PANASONIC"
                        }
                        Case (0x06)
                        {
                            PBIF = "SAMSUNG"
                        }
                        Case (0x07)
                        {
                            PBIF = "SIMPLO"
                        }
                        Case (0x08)
                        {
                            PBIF = "MOTOROLA"
                        }
                        Case (0x09)
                        {
                            PBIF = "CELXPERT"
                        }
                        Case (0x0A)
                        {
                            PBIF = "LGC"
                        }
                        Default
                        {
                            PBIF = "UNKNOWN"
                        }

                  }

                  PBIF = ITOS (ToBCD (Local5))
                }
            }

            Method (IVBX, 0, NotSerialized)
            {
                PBIX = 0xFFFFFFFF
                PBIX = 0xFFFFFFFF
                PBIX = 0xFFFFFFFF
                PBIX = "Bad"
                PBIX = "      "
                PBIX = "Bad"
                PBIX = "Bad"
            }

            Method (UBIX, 0, Serialized)
            {
                If (ECOK)
                {
                  Acquire (^^PCI0.LPCB.EC0.MUT1, 0xFFFF)
                  Local0 = ^^PCI0.LPCB.EC0.BTDC /* \_SB_.PCI0.LPCB.EC0_.BTDC */
                  Local1 = ^^PCI0.LPCB.EC0.LFCC /* \_SB_.PCI0.LPCB.EC0_.LFCC */
                  Local2 = ^^PCI0.LPCB.EC0.BTDV /* \_SB_.PCI0.LPCB.EC0_.BTDV */
                  Local3 = ^^PCI0.LPCB.EC0.BTMD /* \_SB_.PCI0.LPCB.EC0_.BTMD */
                  Local4 = ^^PCI0.LPCB.EC0.BTMN /* \_SB_.PCI0.LPCB.EC0_.BTMN */
                  Local5 = ^^PCI0.LPCB.EC0.BTSN /* \_SB_.PCI0.LPCB.EC0_.BTSN */
                  Release (^^PCI0.LPCB.EC0.MUT1)
                  PBIX = Local0
                  PBIX = Local1
                  PBIX = Local2
                  LFCC = Local1
                  Local7 = (Local1 * 0x04)
                  Local7 /= 0x64
                  PBIX = Local7
                  PBIX = "LION"
                  Switch (Local3)
                  {
                        Case (One)
                        {
                            PBIX = "AL13D32"
                        }
                        Case (0x02)
                        {
                            PBIX = "AL14A32"
                        }
                        Case (0x03)
                        {
                            PBIX = "TW932SM"
                        }
                        Case (0x04)
                        {
                            PBIX = "AP13B8K"
                        }
                        Default
                        {
                            PBIX = "UNKNOWN"
                        }

                  }

                  Switch (Local4)
                  {
                        Case (0x03)
                        {
                            PBIX = "SANYO"
                        }
                        Case (0x04)
                        {
                            PBIX = "SONY"
                        }
                        Case (0x05)
                        {
                            PBIX = "PANASONIC"
                        }
                        Case (0x06)
                        {
                            PBIX = "SAMSUNG"
                        }
                        Case (0x07)
                        {
                            PBIX = "SIMPLO"
                        }
                        Case (0x08)
                        {
                            PBIX = "MOTOROLA"
                        }
                        Case (0x09)
                        {
                            PBIX = "CELXPERT"
                        }
                        Case (0x0A)
                        {
                            PBIX = "LGC"
                        }
                        Default
                        {
                            PBIX = "UNKNOWN"
                        }

                  }

                  PBIX = ITOS (ToBCD (Local5))
                }
            }

            Name (RCAP, Zero)
            Method (_BST, 0, NotSerialized)// _BST: Battery Status
            {
                If (ECOK)
                {
                  Local0 = ^^PCI0.LPCB.EC0.MBTS /* \_SB_.PCI0.LPCB.EC0_.MBTS */
                  If ((Local0 == Zero))
                  {
                        PBST = Zero
                        PBST = 0xFFFFFFFF
                        PBST = 0xFFFFFFFF
                        PBST = 0xFFFFFFFF
                        RCAP = Zero
                        Return (PBST) /* \_SB_.BAT1.PBST */
                  }

                  Local1 = ^^PCI0.LPCB.EC0.MBRM /* \_SB_.PCI0.LPCB.EC0_.MBRM */
                  PBST = Local1
                  RCAP = Local1
                  Local3 = ^^PCI0.LPCB.EC0.MCUR /* \_SB_.PCI0.LPCB.EC0_.MCUR */
                  PBST = POSW (Local3)
                  If (^^PCI0.LPCB.EC0.MFCF)
                  {
                        PBST = Zero
                  }
                  ElseIf (^^PCI0.LPCB.EC0.MBPC)
                  {
                        PBST = 0x02
                  }
                  ElseIf (^^PCI0.LPCB.EC0.MBDX)
                  {
                        PBST = One
                  }
                  Else
                  {
                        PBST = Zero
                  }

                  PBST = ^^PCI0.LPCB.EC0.MBVG /* \_SB_.PCI0.LPCB.EC0_.MBVG */
                }
                Else
                {
                  PBST = Zero
                  PBST = 0xFFFFFFFF
                  PBST = 0xFFFFFFFF
                  PBST = 0xFFFFFFFF
                  RCAP = Zero
                }

                Return (PBST) /* \_SB_.BAT1.PBST */
            }
      }
    }

    Scope (_SB)
    {
      Device (LID0)
      {
            Name (_HID, EisaId ("PNP0C0D") /* Lid Device */)// _HID: Hardware ID
            Method (_LID, 0, NotSerialized)// _LID: Lid Status
            {
                If (^^PCI0.LPCB.EC0.LIDT)
                {
                  WTGP (0x53, Zero)
                  Return (Zero)
                }
                Else
                {
                  WTGP (0x53, One)
                  Return (One)
                }
            }
      }
    }

    Scope (_TZ)
    {
      ThermalZone (TZ01)
      {
            Method (_TMP, 0, NotSerialized)// _TMP: Temperature
            {
                If (\_SB.ECOK)
                {
                  Local0 = \_SB.PCI0.LPCB.EC0.CTMP
                  Return (((Local0 * 0x0A) + 0x0AAC))
                }
                Else
                {
                  Return (0x0C3C)
                }
            }

            Method (_PSV, 0, NotSerialized)// _PSV: Passive Temperature
            {
                If ((\_SB.PCI0.LPCB.EC0.TJMX == Zero))
                {
                  Return (0x0F5C)
                }
                ElseIf ((\_SB.PCI0.LPCB.EC0.TJMX == One))
                {
                  Return (0x0F5C)
                }
                ElseIf ((\_SB.PCI0.LPCB.EC0.TJMX == 0x02))
                {
                  Return (0x0F5C)
                }
                ElseIf ((\_SB.PCI0.LPCB.EC0.TJMX == 0x03))
                {
                  Return (0x0F5C)
                }
                ElseIf ((\_SB.PCI0.LPCB.EC0.TJMX == 0x04))
                {
                  Return (0x0F5C)
                }
                Else
                {
                  Return (0x0F5C)
                }
            }

            Name (_PSL, Package (0x01)// _PSL: Passive List
            {
                \_PR.CPU0
            })
            Name (_TSP, 0x28)// _TSP: Thermal Sampling Period
            Name (_TC1, 0x02)// _TC1: Thermal Constant 1
            Name (_TC2, 0x03)// _TC2: Thermal Constant 2
            Method (_CRT, 0, NotSerialized)// _CRT: Critical Temperature
            {
                If ((\_SB.PCI0.LPCB.EC0.TJMX == Zero))
                {
                  Return (0x0DFE)
                }
                ElseIf ((\_SB.PCI0.LPCB.EC0.TJMX == One))
                {
                  Return (0x0E30)
                }
                ElseIf ((\_SB.PCI0.LPCB.EC0.TJMX == 0x02))
                {
                  Return (0x0E94)
                }
                ElseIf ((\_SB.PCI0.LPCB.EC0.TJMX == 0x03))
                {
                  Return (0x0EC6)
                }
                ElseIf ((\_SB.PCI0.LPCB.EC0.TJMX == 0x04))
                {
                  Return (0x0DCC)
                }
                Else
                {
                  Return (0x0EB2)
                }
            }
      }
    }

    Scope (_SB.PCI0)
    {
      Name (PNLT, Buffer (0x0B)
      {
            /* 0000 */0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,// ........
            /* 0008 */0x00, 0x00, 0x00                                 // ...
      })
      Name (PNL7, Buffer (0x0A)
      {
            /* 0000 */0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,// ........
            /* 0008 */0x00, 0x00                                       // ..
      })
      Method (CRBL, 0, NotSerialized)
      {
            If ((OSYS >= 0x07DC))
            {
                PNLT = BCL0 /* \_SB_.BCL0 */
                PNLT = BCL1 /* \_SB_.BCL1 */
                PNLT = BCL2 /* \_SB_.BCL2 */
                PNLT = BCL3 /* \_SB_.BCL3 */
                PNLT = BCL4 /* \_SB_.BCL4 */
                PNLT = BCL5 /* \_SB_.BCL5 */
                PNLT = BCL6 /* \_SB_.BCL6 */
                PNLT = BCL7 /* \_SB_.BCL7 */
                PNLT = BCL8 /* \_SB_.BCL8 */
                PNLT = BCL9 /* \_SB_.BCL9 */
                PNLT = BLVA /* \_SB_.BLVA */
                ^GFX0.BLM0 = (BCL0 | 0x8000)
                ^GFX0.BLM1 = (BCL1 | 0x8A00)
                ^GFX0.BLM2 = (BCL2 | 0x9400)
                ^GFX0.BLM3 = (BCL3 | 0x9E00)
                ^GFX0.BLM4 = (BCL4 | 0xA800)
                ^GFX0.BLM5 = (BCL5 | 0xB200)
                ^GFX0.BLM6 = (BCL6 | 0xBC00)
                ^GFX0.BLM7 = (BCL7 | 0xC600)
                ^GFX0.BLM8 = (BCL8 | 0xD000)
                ^GFX0.BLM9 = (BCL9 | 0xDA00)
                ^GFX0.BLMA = (BLVA | 0xE400)
                If ((BBTP == One))
                {
                  ^GFX0.BLM5 = (BL86 | 0xB200)
                  ^GFX0.BLM6 = (BL87 | 0xBC00)
                  ^GFX0.BLM7 = (BL88 | 0xC600)
                  ^GFX0.BLM8 = (BL89 | 0xD000)
                  ^GFX0.BLM9 = (BL8A | 0xDA00)
                }

                ^GFX0.BLMX = Zero
            }
            Else
            {
                PNL7 = BCL0 /* \_SB_.BCL0 */
                PNL7 = BCL1 /* \_SB_.BCL1 */
                PNL7 = BCL2 /* \_SB_.BCL2 */
                PNL7 = BCL3 /* \_SB_.BCL3 */
                PNL7 = BCL4 /* \_SB_.BCL4 */
                PNL7 = BCL5 /* \_SB_.BCL5 */
                PNL7 = BCL6 /* \_SB_.BCL6 */
                PNL7 = BCL7 /* \_SB_.BCL7 */
                PNL7 = BCL8 /* \_SB_.BCL8 */
                PNL7 = BCL9 /* \_SB_.BCL9 */
                ^GFX0.BLM0 = (BCL0 | 0x8A00)
                ^GFX0.BLM1 = (BCL1 | 0x9400)
                ^GFX0.BLM2 = (BCL2 | 0x9E00)
                ^GFX0.BLM3 = (BCL3 | 0xA800)
                ^GFX0.BLM4 = (BCL4 | 0xB200)
                ^GFX0.BLM5 = (BCL5 | 0xBC00)
                ^GFX0.BLM6 = (BCL6 | 0xC600)
                ^GFX0.BLM7 = (BCL7 | 0xD000)
                ^GFX0.BLM8 = (BCL8 | 0xDA00)
                ^GFX0.BLM9 = (BCL9 | 0xE400)
                ^GFX0.BLMA = Zero
                ^GFX0.BLMX = Zero
            }
      }
    }

    Scope (_SB)
    {
      OperationRegion (EXCO, SystemIO, 0x72, 0x02)
      Field (EXCO, ByteAcc, NoLock, Preserve)
      {
            INDX,   8,
            DATA,   8
      }

      IndexField (INDX, DATA, ByteAcc, NoLock, Preserve)
      {
            Offset (0x80),
            CM2M,   32,
            Offset (0x87),
            RDWL,   1,
            RDBT,   1,
            RD3G,   1,
            TPDS,   1,
            PTWL,   1,
            PTBT,   1,
            PT3G,   1,
            RDTS,   1,
            Offset (0xEE),
            CSBM,   8,
            Offset (0xFF),
            Offset (0x100)
      }
    }

    Name (_S0, Package (0x04)// _S0_: S0 System State
    {
      Zero,
      Zero,
      Zero,
      Zero
    })
    If (SS1)
    {
      Name (_S1, Package (0x04)// _S1_: S1 System State
      {
            One,
            Zero,
            Zero,
            Zero
      })
    }

    If (SS3)
    {
      Name (_S3, Package (0x04)// _S3_: S3 System State
      {
            0x05,
            Zero,
            Zero,
            Zero
      })
    }

    If (SS4)
    {
      Name (_S4, Package (0x04)// _S4_: S4 System State
      {
            0x06,
            Zero,
            Zero,
            Zero
      })
    }

    Name (_S5, Package (0x04)// _S5_: S5 System State
    {
      0x07,
      Zero,
      Zero,
      Zero
    })
    Method (PTS, 1, NotSerialized)
    {
      If (Arg0){}
    }

    Method (WAK, 1, NotSerialized)
    {
    }
}
请问哪个是

linioe 发表于 2021-2-8 16:38

yf512637021 发表于 2021-2-8 09:58 https://www.pcbeta.com/static/image/common/back.gif
Method (_BIF, 0, NotSerialized)// _BIF: Battery Information            {
                IVB ...

_BIF方法调用的是UBIF方法,PBIF的值是EC中的^^PCI0.LPCB.EC0.BTDC(应该是BatteryDesignCapacity 电池设计容量)PBIF的值是EC中的^^PCI0.LPCB.EC0.LFCC(应该是LastFullChargeCapacity 现有容量)
_BIX方法调用的是UBIX方法,PBIX的值是EC中的^^PCI0.LPCB.EC0.BTDC(应该是BatteryDesignCapacity 电池设计容量)PBIX的值是EC中的^^PCI0.LPCB.EC0.LFCC(应该是LastFullChargeCapacity 现有容量)
主要是看这几个地方
另外看不到你的EC域的变量是否需要拆分,请参考这篇文章
https://xstar-dev.github.io/hackintosh_advanced/Guide_For_Battery_Hotpatch.html

linioe 发表于 2021-2-8 16:45

linioe 发表于 2021-2-7 18:08 https://www.pcbeta.com/static/image/common/back.gif
这个问题我之前遇到过,如果你也是黑苹果,希望可以给你提供一些参考。
升级11.0.1后,电池出现维修提示, ...

这里有个错误,_BIX方法的返回值索引0x02才是设计容量,_BIF方法的返回值索引0x01是设计容量,因为_BIX是_BIF的扩展方法,所以在返回值数组最前面加了一个值导致索引延后一位
SMCBatteryManager和ACPIBatteryManager应该都会先调用_BIX方法,而我的DSDT把_BIF和_BIX的具体实现放在一起了,导致我疏忽了,特地在此更正

linioe 发表于 2021-2-8 16:53

NoctisX 发表于 2021-2-8 00:46 https://www.pcbeta.com/static/image/common/back.gif
给你看看我以前发生的错误 以前每次重启都会出现电池自检错误,进Mac会像楼主出现建议维修字样

电池容量不准确可能和电池老化有关,还有开机自检问题应该还是因为电池容量过低,毕竟50%的损耗,所以后续可能还会出现。
另外我之前的因为电池现有容量远小于设计容量导致提示维修的猜测应该也不对,因为你的已经损耗50%了还是正常,你能说一下怎么加的_BIX方法让提示消失的吗?也可以给大家做一个参考

linioe 发表于 2021-2-8 17:26

我自己修改了一下我的DSDT,把设计容量翻倍,重启后电池健康度变为52%,系统出现卡顿,HDMI输出也不好用了,但是确实没有出现提示维修字样,所以电池损耗确实不是提示维修的原因。
但是如果电池损耗过大可能确实会被降低性能

NoctisX 发表于 2021-2-8 19:28

linioe 发表于 2021-2-8 16:53 https://www.pcbeta.com/static/image/common/back.gif
电池容量不准确可能和电池老化有关,还有开机自检问题应该还是因为电池容量过低,毕竟50%的损耗,所以后续 ...

我其实是不会制作电池补丁的{:5_287:},电量不足的提示是使用smcbatterymanager会出现,但是ACPIbatterymanager却不会,后来逛了会GitHub,看到一个相似机型的EFI ,除了cpu不一样,外型上主板结构一模一样,后面我对比了hotpatch,都是一样的,使用了smcbatterymanager基本上没有问题。

问题出现了,电池循环计数显示0 ,重启会出现楼上我说的自检错误 建议维修 ,最近几天,群友新做的电池补丁使用acpibatterymanager能显示了循环计数,smc会出现电量不足提示,我想了想,从相似机型的电池补丁基础上添加了_BIX ,BTIX 是ec下面的电池 ,在dsdt里面直接复制过来的,使用smc电池驱动重启过后循环计数出来了,测试了一会电量不足提示到电量20%才出现,就剩下最后的自检错误暂时不知道会不会来了

我的EFI https://github.com/TzeKitKwok/HP-Zhan-66-Pro-G1
相似机型 https://github.com/KirillSerogodsky/HP-ProBook-430-440-450-G6-Hackintosh

scwuyf 发表于 2021-3-6 19:22

本帖最后由 scwuyf 于 2021-3-7 22:14 编辑

linioe 发表于 2021-2-8 17:26 https://www.pcbeta.com/static/image/common/back.gif
我自己修改了一下我的DSDT,把设计容量翻倍,重启后电池健康度变为52%,系统出现卡顿,HDMI输出也不好用了, ...
能否帮忙做个热补丁,解决电池显示建议维修,谢谢。升级到bigsur前不需要电池补丁,都正常。

linioe 发表于 2021-3-8 18:33

scwuyf 发表于 2021-3-6 19:22 https://www.pcbeta.com/static/image/common/back.gif
能否帮忙做个热补丁,解决电池显示建议维修,谢谢。升级到bigsur前不需要电池补丁,都正常。

我的情况不具备普遍性,已经自己尝试过电池损耗大不是显示建议维修的原因。
不过升级之后显示建议维修倒是和我一样,你可以自己先尝试按照网上的教程看看需不需要打补丁,确定不需要拆分的咱们再做讨论。你可以把dsdt发给我看看。

genghui68 发表于 2021-9-19 10:34

我加载了LPC也遇到同样的问题,束手无策。

极地 发表于 2021-9-22 17:50

看看,回去试试

yzi668 发表于 2022-4-15 21:21

linioe 发表于 2021-2-7 18:22 https://bbs.pcbeta.com/static/image/common/back.gif
mAh乘以电池电压就是mWh,所以还要知道你的电池的电压

您好,我也是提示建议维修,您们说的我看的一脸懵逼,请问下,能教我解决下嘛,谢谢

linioe 发表于 2022-4-17 15:34

yzi668 发表于 2022-4-15 21:21 https://bbs.pcbeta.com/static/image/common/back.gif
您好,我也是提示建议维修,您们说的我看的一脸懵逼,请问下,能教我解决下嘛,谢谢

之前我已经验证过了电池损耗不是显示维修的原因,我的这个不能读取设计容量的问题是个例,你还是要想办法找到合适的电池补丁,你要是不介意可以把用的DSDT和SSDT发给我

某腦 发表于 2022-4-26 22:10

11.1也有这问题

panzerz 发表于 2023-1-16 23:10

linioe 发表于 2022-4-17 15:34 https://bbs.pcbeta.com/static/image/common/back.gif
之前我已经验证过了电池损耗不是显示维修的原因,我的这个不能读取设计容量的问题是个例,你还是要想办法 ...

大佬帮我看看
页: 1 [2]
查看完整版本: big sur电池显示建议维修怎么解决?