/**
 *
 * @license MIT License
 *
 * Copyright (c) 2024 lewis he
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * @file      PowersBQ25896.tpp
 * @author    Lewis He (lewishe@outlook.com)
 * @date      2024-10-29
 *
 */
#if defined(ARDUINO)
#include <Arduino.h>
#else
#include <math.h>
#endif /*ARDUINO*/
#include "XPowersCommon.tpp"
#include "REG/GeneralPPMConstants.h"
#include "REG/BQ25896Constants.h"

class PowersBQ25896 :
    public XPowersCommon<PowersBQ25896>
{
    friend class XPowersCommon<PowersBQ25896>;
public:

    enum BusStatus {
        BUS_STATE_NOINPUT,
        BUS_STATE_USB_SDP,
        BUS_STATE_ADAPTER,
        BUS_STATE_OTG
    } ;

    enum ChargeStatus {
        CHARGE_STATE_NO_CHARGE,
        CHARGE_STATE_PRE_CHARGE,
        CHARGE_STATE_FAST_CHARGE,
        CHARGE_STATE_DONE,
        CHARGE_STATE_UNKOWN,
    } ;

    enum NTCStatus {
        BUCK_NTC_NORMAL = 0,
        BUCK_NTC_WARM = 2,
        BUCK_NTC_COOL = 3,
        BUCK_NTC_COLD = 5,
        BUCK_NTC_HOT = 6,
    };

    enum BoostNTCStatus {
        BOOST_NTC_NORMAL = 0,
        BOOST_NTC_COLD = 5,
        BOOST_NTC_HOT = 6,
    };

    enum WatchdogConfig {
        TIMER_OUT_40SEC,      //40 Second
        TIMER_OUT_80SEC,      //80 Second
        TIMER_OUT_160SEC,     //160 Second
    } ;

    enum MeasureMode {
        ONE_SHORT,
        CONTINUOUS,
    };

    enum BoostFreq {
        BOOST_FREQ_1500KHZ,
        BOOST_FREQ_500KHZ,
    };

    enum ExitBoostModeVolt {
        MINI_VOLT_2V9,
        MINI_VOLT_2V5
    };

    enum FastChargeThreshold {
        FAST_CHG_THR_2V8,
        FAST_CHG_THR_3V0
    };

    enum RechargeThresholdOffset {
        RECHARGE_OFFSET_100MV,
        RECHARGE_OFFSET_200MV
    };

    enum FastChargeTimer {
        FAST_CHARGE_TIMER_5H,
        FAST_CHARGE_TIMER_8H,
        FAST_CHARGE_TIMER_12H,
        FAST_CHARGE_TIMER_20H,
    };

    enum JeitaLowTemperatureCurrent {
        JEITA_LOW_TEMP_50,  //50% of ICHG (REG04[6:0])
        JEITA_LOW_TEMP_20,  //20% of ICHG (REG04[6:0])
    };

    enum BoostCurrentLimit {
        BOOST_CUR_LIMIT_500MA,
        BOOST_CUR_LIMIT_750MA,
        BOOST_CUR_LIMIT_1200MA,
        BOOST_CUR_LIMIT_1400MA,
        BOOST_CUR_LIMIT_1650MA,
        BOOST_CUR_LIMIT_1875MA,
        BOOST_CUR_LIMIT_2150MA,
    } ;

#if defined(ARDUINO)
    PowersBQ25896(TwoWire &w, int sda = SDA, int scl = SCL, uint8_t addr = BQ25896_SLAVE_ADDRESS)
    {
        __wire = &w;
        __sda = sda;
        __scl = scl;
        __addr = addr;
    }
#endif

    PowersBQ25896(uint8_t addr, iic_fptr_t readRegCallback, iic_fptr_t writeRegCallback)
    {
        thisReadRegCallback = readRegCallback;
        thisWriteRegCallback = writeRegCallback;
        __addr = addr;
    }

    PowersBQ25896()
    {
#if defined(ARDUINO)
        __wire = &Wire;
        __sda = SDA;
        __scl = SCL;
#endif
        __addr = BQ25896_SLAVE_ADDRESS;
    }

    ~PowersBQ25896()
    {
        log_d("~PowersBQ25896");
        deinit();
    }

#if defined(ARDUINO)
    bool init(TwoWire &w, int sda = SDA, int scl = SCL, uint8_t addr = BQ25896_SLAVE_ADDRESS)
    {
        __wire = &w;
        __sda = sda;
        __scl = scl;
        __addr = addr;
        __irq_mask = 0;
        return begin();
    }
#endif

    const char *getChipName()
    {
        return getChipID() == BQ25896_DEV_REV ? "BQ25896" : "Unknown";
    }

    bool init()
    {
        return begin();
    }

    void deinit()
    {
        end();
    }

    /***************************************************
     * POWERS_PPM_REG_00H ✅
     **************************************************/
    // USB input path is disabled and can only be reset by disconnecting
    // the power supply, otherwise the power cannot be turned on
    void enterHizMode()
    {
        setRegisterBit(POWERS_PPM_REG_00H, 7);
    }

    void exitHizMode()
    {
        clrRegisterBit(POWERS_PPM_REG_00H, 7);
    }

    bool isHizMode()
    {
        return getRegisterBit(POWERS_PPM_REG_00H, 7);
    }

    // Enable ILIM Pin
    void enableCurrentLimitPin()
    {
        setRegisterBit(POWERS_PPM_REG_00H, 6);
    }

    void disableCurrentLimitPin()
    {
        clrRegisterBit(POWERS_PPM_REG_00H, 6);
    }

    bool isEnableCurrentLimitPin()
    {
        return getRegisterBit(POWERS_PPM_REG_00H, 6);
    }

    // Input Current Limit
    // Offset: 100mA
    // Range: 100mA (000000) – 3.25A (111111)
    // Default:0001000 (500mA)
    // (Actual input current limit is the lower of I2C or ILIM pin)
    // IINLIM bits are changed automaticallly after input source
    // type detection is completed
    // bq25896
    // PSEL = Hi (USB500) = 500mA
    // PSEL = Lo = 3.25A
    bool setInputCurrentLimit(uint16_t milliampere)
    {
        if (milliampere % POWERS_BQ25896_IN_CURRENT_STEP) {
            log_e("Mistake ! The steps is must %u mA", POWERS_BQ25896_IN_CURRENT_STEP);
            return false;
        }
        if (milliampere < POWERS_BQ25896_IN_CURRENT_MIN) {
            milliampere = POWERS_BQ25896_IN_CURRENT_MIN;
        }
        if (milliampere > POWERS_BQ25896_IN_CURRENT_MAX) {
            milliampere = POWERS_BQ25896_IN_CURRENT_MAX;
        }
        int val = readRegister(POWERS_PPM_REG_00H);
        if (val == -1)
            return false;
        val &= 0xC0;
        milliampere = ((milliampere - POWERS_BQ25896_IN_CURRENT_MIN) / POWERS_BQ25896_IN_CURRENT_STEP);
        val |=  milliampere;
        return writeRegister(POWERS_PPM_REG_00H, val) != -1;
    }

    uint32_t getInputCurrentLimit()
    {
        int val = readRegister(POWERS_PPM_REG_00H);
        if (val == -1)
            return false;
        val &= 0x3F;
        return (val * POWERS_BQ25896_IN_CURRENT_STEP) + POWERS_BQ25896_IN_CURRENT_MIN;
    }

    /***************************************************
     * POWERS_PPM_REG_01H ✅
     **************************************************/

    // Boost Mode Hot Temperature Monitor Threshold
    // 0x0 – VBHOT1 Threshold (34.75%) (default)
    // 0x01 – VBHOT0 Threshold (Typ. 37.75%)
    // 0x02 – VBHOT2 Threshold (Typ. 31.25%)
    // 0x03 – Disable boost mode thermal protection
    void setBoostModeHotTemperatureMonitorThreshold(uint8_t params)
    {
        int val = readRegister(POWERS_PPM_REG_01H);
        if (val == -1)return;
        val &= 0x3F;
        val |=  (params << 6);
        writeRegister(POWERS_PPM_REG_01H, val);
    }

    // Boost Mode Cold Temperature Monitor Threshold
    // 0 – VBCOLD0 Threshold (Typ. 77%) (default)
    // 1 – VBCOLD1 Threshold (Typ. 80%)
    void setBoostModeColdTemperatureMonitorThreshold(uint8_t params)
    {
        int val = readRegister(POWERS_PPM_REG_01H);
        if (val == -1)return;
        val &= 0xDF;
        val |=  ((params & 0x01) << 5);
        writeRegister(POWERS_PPM_REG_01H, val);
    }

    // Input Voltage Limit Offset
    // Default: 600mV (00110)
    // Range: 0mV – 3100mV
    // Minimum VINDPM threshold is clamped at 3.9V
    // Maximum VINDPM threshold is clamped at 15.3V
    // When VBUS at noLoad is ≤ 6V, the VINDPM_OS is used to calculate VINDPM threhold
    // When VBUS at noLoad is > 6V, the VINDPM_OS multiple by 2 is used to calculate VINDPM threshold.
    void setInputVoltageLimitOffset(uint16_t millivolt)
    {
        if (millivolt % POWERS_BQ25896_IN_CURRENT_OFFSET_STEP) {
            log_e("Mistake ! The steps is must %u mA", POWERS_BQ25896_IN_CURRENT_OFFSET_STEP);
            return;
        }
        if (millivolt > POWERS_BQ25896_IN_CURRENT_OFFSET_MAX) {
            millivolt = POWERS_BQ25896_IN_CURRENT_OFFSET_MAX;
        }
        int val = readRegister(POWERS_PPM_REG_01H);
        val &= 0xE0;
        millivolt = (millivolt  / POWERS_BQ25896_IN_CURRENT_OFFSET_STEP);
        val |=  millivolt;
        writeRegister(POWERS_PPM_REG_01H, val);
    }

    /***************************************************
     * POWERS_PPM_REG_02H  ✅
     **************************************************/
    bool enableMeasure(MeasureMode mode = CONTINUOUS)
    {
        int val = readRegister(POWERS_PPM_REG_02H);
        switch (mode) {
        case CONTINUOUS:
            val |= _BV(6);
            break;
        case ONE_SHORT:
            val &= (~_BV(6));
        default:
            break;
        }
        val |= _BV(7);
        return writeRegister(POWERS_PPM_REG_02H, val) != -1;
    }

    bool disableMeasure()
    {
        int val = readRegister(POWERS_PPM_REG_02H);
        if (val == -1) {
            return false;
        }
        val &= (~_BV(7));
        val &= (~_BV(6));
        return writeRegister(POWERS_PPM_REG_02H, val) != 1;
    }

    bool setBoostFreq(BoostFreq freq)
    {
        switch (freq) {
        case BOOST_FREQ_500KHZ:
            return setRegisterBit(POWERS_PPM_REG_02H, 5);
        case BOOST_FREQ_1500KHZ:
            return clrRegisterBit(POWERS_PPM_REG_02H, 5);
        default:
            break;
        }
        return false;
    }

    BoostFreq getBoostFreq()
    {
        return getRegisterBit(POWERS_PPM_REG_02H, 5) ?
               BOOST_FREQ_500KHZ :
               BOOST_FREQ_1500KHZ;
    }

    // Input Current Optimizer (ICO) Enable
    void enableInputCurrentOptimizer()
    {
        setRegisterBit(POWERS_PPM_REG_02H, 4);
    }

    // Input Current Optimizer (ICO) Disable
    void disableInputCurrentOptimizer()
    {
        clrRegisterBit(POWERS_PPM_REG_02H, 4);
    }

    // Enable Force Input Detection , Force PSEL detection
    void enableInputDetection()
    {
        setRegisterBit(POWERS_PPM_REG_02H, 1);
    }

    // Disable Force Input Detection ,  Not in PSEL detection (default)
    void disableInputDetection()
    {
        clrRegisterBit(POWERS_PPM_REG_02H, 1);
    }

    // Get Force DP/DM detection
    bool isEnableInputDetection()
    {
        return getRegisterBit(POWERS_PPM_REG_02H, 1);
    }

    // Enable PSEL detection when VBUS is plugged-in (default)
    void enableAutomaticInputDetection()
    {
        setRegisterBit(POWERS_PPM_REG_02H, 0);
    }

    // Disable PSEL detection when VBUS is plugged-in
    void disableAutomaticInputDetection()
    {
        clrRegisterBit(POWERS_PPM_REG_02H, 0);
    }

    // Get DPDM detection when BUS is plugged-in.
    bool isEnableAutomaticInputDetection()
    {
        return getRegisterBit(POWERS_PPM_REG_02H, 0);
    }


    /***************************************************
     * POWERS_PPM_REG_03H ✅
     **************************************************/

    // Return  Battery Load status
    bool isEnableBatLoad()
    {
        return getRegisterBit(POWERS_PPM_REG_03H, 7);
    }

    // Battery Load Disable
    void disableBatLoad()
    {
        clrRegisterBit(POWERS_PPM_REG_03H, 7);
    }

    // Battery Load Enable
    void enableBatLoad()
    {
        setRegisterBit(POWERS_PPM_REG_03H, 7);
    }

    void feedWatchdog()
    {
        setRegisterBit(POWERS_PPM_REG_03H, 6);
    }

    bool isEnableOTG()
    {
        return getRegisterBit(POWERS_PPM_REG_03H, 5);
    }

    void disableOTG()
    {
        clrRegisterBit(POWERS_PPM_REG_03H, 5);
        /*
        * After turning on the OTG function, the charging function will
        * be automatically disabled. If the user does not disable the charging
        * function, the charging function will be automatically enabled after
        * turning off the OTG output.
        * */
        if (!__user_disable_charge) {
            setRegisterBit(POWERS_PPM_REG_03H, 4);
        }
    }

    bool enableOTG()
    {
        if (isVbusIn())
            return false;
        return setRegisterBit(POWERS_PPM_REG_03H, 5);
    }

    bool isEnableCharge()
    {
        return getRegisterBit(POWERS_PPM_REG_03H, 4);
    }

    void disableCharge()
    {
        __user_disable_charge = true;
        clrRegisterBit(POWERS_PPM_REG_03H, 4);
    }

    void enableCharge()
    {
        __user_disable_charge = false;
        setRegisterBit(POWERS_PPM_REG_03H, 4);
    }

    bool setSysPowerDownVoltage(uint16_t millivolt)
    {
        if (millivolt % POWERS_BQ25896_SYS_VOL_STEPS) {
            log_e("Mistake ! The steps is must %u mV", POWERS_BQ25896_SYS_VOL_STEPS);
            return false;
        }
        if (millivolt < POWERS_BQ25896_SYS_VOFF_VOL_MIN) {
            log_e("Mistake ! SYS minimum output voltage is  %umV", POWERS_BQ25896_SYS_VOFF_VOL_MIN);
            return false;
        } else if (millivolt > POWERS_BQ25896_SYS_VOFF_VOL_MAX) {
            log_e("Mistake ! SYS maximum output voltage is  %umV", POWERS_BQ25896_SYS_VOFF_VOL_MAX);
            return false;
        }
        int val = readRegister(POWERS_PPM_REG_03H);
        if (val == -1)return false;
        val &= 0xF1;
        val |= (millivolt - POWERS_BQ25896_SYS_VOFF_VOL_MIN) / POWERS_BQ25896_SYS_VOL_STEPS;
        val <<= 1;
        return 0 ==  writeRegister(POWERS_PPM_REG_03H, val);

    }

    uint16_t getSysPowerDownVoltage()
    {
        int val = readRegister(POWERS_PPM_REG_03H);
        if (val == -1)return 0;
        val &= 0x0E;
        val >>= 1;
        return (val * POWERS_BQ25896_SYS_VOL_STEPS) + POWERS_BQ25896_SYS_VOFF_VOL_MIN;
    }

    // Minimum Battery Voltage (falling) to exit boost mode
    void setExitBoostModeVoltage(enum ExitBoostModeVolt params)
    {
        switch (params) {
        case MINI_VOLT_2V9:
            clrRegisterBit(POWERS_PPM_REG_03H, 0);
            break;
        case MINI_VOLT_2V5:
            setRegisterBit(POWERS_PPM_REG_03H, 0);
            break;
        default:
            break;
        }
    }

    /***************************************************
     * POWERS_PPM_REG_04H ✅
     **************************************************/

    void enableCurrentPulseControl()
    {
        setRegisterBit(POWERS_PPM_REG_04H, 7);
    }

    void disableCurrentPulseControl()
    {
        clrRegisterBit(POWERS_PPM_REG_04H, 7);
    }

    uint16_t getChargerConstantCurr()
    {
        int val = readRegister(POWERS_PPM_REG_04H);
        val &= 0x7F;
        return val * POWERS_BQ25896_FAST_CHG_CUR_STEP;
    }

    /**
     * @brief  setChargerConstantCurr
     * @note
     * @param  milliampere: Range:0~3008 mA / step:64mA
     * @retval true : success false : failed
     */
    bool setChargerConstantCurr(uint16_t milliampere)
    {
        if (milliampere % POWERS_BQ25896_FAST_CHG_CUR_STEP) {
            log_e("Mistake ! The steps is must %u mA", POWERS_BQ25896_FAST_CHG_CUR_STEP);
            return false;
        }
        if (milliampere > POWERS_BQ25896_FAST_CHG_CURRENT_MAX) {
            milliampere = POWERS_BQ25896_FAST_CHG_CURRENT_MAX;
        }
        int val = readRegister(POWERS_PPM_REG_04H);
        val &= 0x80;
        val |= (milliampere / POWERS_BQ25896_FAST_CHG_CUR_STEP);
        return  writeRegister(POWERS_PPM_REG_04H, val) != -1;
    }

    /***************************************************
     * POWERS_PPM_REG_05H ✅
     **************************************************/

    //Precharge Current Limit Range: 64mA ~ 1024mA ,step:64mA
    bool setPrechargeCurr(uint16_t milliampere)
    {
        if (milliampere % POWERS_BQ25896_PRE_CHG_CUR_STEP) {
            log_e("Mistake ! The steps is must %u mA", POWERS_BQ25896_PRE_CHG_CUR_STEP);
            return false;
        }
        if (milliampere < POWERS_BQ25896_PRE_CHG_CURRENT_MIN) {
            milliampere = POWERS_BQ25896_PRE_CHG_CURRENT_MIN;
        }
        if (milliampere > POWERS_BQ25896_PRE_CHG_CURRENT_MAX) {
            milliampere = POWERS_BQ25896_PRE_CHG_CURRENT_MAX;
        }
        int val = readRegister(POWERS_PPM_REG_05H);
        val &= 0x0F;
        milliampere = ((milliampere - POWERS_BQ25896_PRE_CHG_CUR_BASE) / POWERS_BQ25896_PRE_CHG_CUR_STEP);
        val |=  milliampere << 4;
        return writeRegister(POWERS_PPM_REG_05H, val) != -1;
    }

    uint16_t getPrechargeCurr(void)
    {
        int val = readRegister(POWERS_PPM_REG_05H);
        val &= 0xF0;
        val >>= 4;
        return POWERS_BQ25896_PRE_CHG_CUR_STEP + (val * POWERS_BQ25896_PRE_CHG_CUR_STEP);
    }

    //Precharge Current Limit Range: 64mA ~ 1024mA ,step:64mA
    bool setTerminationCurr(uint16_t milliampere)
    {
        if (milliampere % POWERS_BQ25896_TERM_CHG_CUR_STEP) {
            log_e("Mistake ! The steps is must %u mA", POWERS_BQ25896_TERM_CHG_CUR_STEP);
            return false;
        }
        if (milliampere < POWERS_BQ25896_TERM_CHG_CURRENT_MIN) {
            milliampere = POWERS_BQ25896_TERM_CHG_CURRENT_MIN;
        }
        if (milliampere > POWERS_BQ25896_TERM_CHG_CURRENT_MAX) {
            milliampere = POWERS_BQ25896_TERM_CHG_CURRENT_MAX;
        }
        int val = readRegister(POWERS_PPM_REG_05H);
        val &= 0xF0;
        milliampere = ((milliampere - POWERS_BQ25896_TERM_CHG_CUR_BASE) / POWERS_BQ25896_TERM_CHG_CUR_STEP);
        val |=  milliampere;
        return writeRegister(POWERS_PPM_REG_05H, val) != -1;
    }

    uint16_t getTerminationCurr(void)
    {
        int val = readRegister(POWERS_PPM_REG_05H);
        val &= 0x0F;
        return POWERS_BQ25896_TERM_CHG_CUR_STEP + (val * POWERS_BQ25896_TERM_CHG_CUR_STEP);
    }


    /***************************************************
     * POWERS_PPM_REG_06H ✅
     **************************************************/
    uint16_t getChargeTargetVoltage()
    {
        int val = readRegister(POWERS_PPM_REG_06H);
        val = (val & 0xFC) >> 2;
        if (val > 0x30) {
            return POWERS_BQ25896_FAST_CHG_VOL_MAX;
        }
        return val * POWERS_BQ25896_CHG_VOL_STEP + POWERS_BQ25896_CHG_VOL_BASE;
    }

    // Charge Voltage Limit Range:3840 ~ 4608mV ,step:16 mV
    bool setChargeTargetVoltage(uint16_t millivolt)
    {
        if (millivolt % POWERS_BQ25896_CHG_VOL_STEP) {
            log_e("Mistake ! The steps is must %u mV", POWERS_BQ25896_CHG_VOL_STEP);
            return false;
        }
        if (millivolt < POWERS_BQ25896_FAST_CHG_VOL_MIN) {
            millivolt = POWERS_BQ25896_FAST_CHG_VOL_MIN;
        }
        if (millivolt > POWERS_BQ25896_FAST_CHG_VOL_MAX) {
            millivolt = POWERS_BQ25896_FAST_CHG_VOL_MAX;
        }
        int val = readRegister(POWERS_PPM_REG_06H);
        val &= 0x03;
        val |= (((millivolt - POWERS_BQ25896_CHG_VOL_BASE) / POWERS_BQ25896_CHG_VOL_STEP) << 2);
        return  writeRegister(POWERS_PPM_REG_06H, val) != -1;
    }

    // Battery Precharge to Fast Charge Threshold
    void setFastChargeThreshold(enum FastChargeThreshold  threshold)
    {
        switch (threshold) {
        case FAST_CHG_THR_2V8:
            clrRegisterBit(POWERS_PPM_REG_06H, 1);
            break;
        case FAST_CHG_THR_3V0:
            setRegisterBit(POWERS_PPM_REG_06H, 1);
            break;
        default:
            break;
        }
    }

    // Battery Recharge Threshold Offset(below Charge Voltage Limit)
    void setBatteryRechargeThresholdOffset(enum RechargeThresholdOffset offset)
    {
        switch (offset) {
        case RECHARGE_OFFSET_100MV:
            clrRegisterBit(POWERS_PPM_REG_06H, 0);
            break;
        case RECHARGE_OFFSET_200MV:
            setRegisterBit(POWERS_PPM_REG_06H, 0);
            break;
        default:
            break;
        }
    }

    /***************************************************
     * POWERS_PPM_REG_07H ✅
     **************************************************/

    // Charging Termination Enable
    void enableChargingTermination()
    {
        setRegisterBit(POWERS_PPM_REG_07H, 7);
    }

    // Charging Termination Enable
    void disableChargingTermination()
    {
        clrRegisterBit(POWERS_PPM_REG_07H, 7);
    }

    // Charging Termination Enable
    bool isEnableChargingTermination()
    {
        return getRegisterBit(POWERS_PPM_REG_07H, 7);
    }

    // STAT Pin function
    void disableStatPin()
    {
        setRegisterBit(POWERS_PPM_REG_07H, 6);
    }

    void enableStatPin()
    {
        clrRegisterBit(POWERS_PPM_REG_07H, 6);
    }

    bool isEnableStatPin()
    {
        return getRegisterBit(POWERS_PPM_REG_07H, 6) == false;
    }

    // I2C Watchdog Timer Setting
    bool isEnableWatchdog()
    {
        int regVal = readRegister(POWERS_PPM_REG_07H);
        if (regVal == -1) {
            log_e("Config watch dog failed!");
            return false;
        }
        regVal >>= 4;
        return regVal & 0x03;
    }

    void disableWatchdog()
    {
        int regVal = readRegister(POWERS_PPM_REG_07H);
        regVal  &= 0xCF;
        writeRegister(POWERS_PPM_REG_07H, regVal);
    }

    void enableWatchdog(enum WatchdogConfig val)
    {
        int regVal = readRegister(POWERS_PPM_REG_07H);
        regVal  &= 0xCF;
        switch (val) {
        case TIMER_OUT_40SEC:
            writeRegister(POWERS_PPM_REG_07H, regVal | 0x10);
            break;
        case TIMER_OUT_80SEC:
            writeRegister(POWERS_PPM_REG_07H, regVal | 0x20);
            break;
        case TIMER_OUT_160SEC:
            writeRegister(POWERS_PPM_REG_07H, regVal | 0x30);
            break;
        default:
            break;
        }
    }

    void disableChargingSafetyTimer()
    {
        clrRegisterBit(POWERS_PPM_REG_07H, 3);
    }

    void enableChargingSafetyTimer()
    {
        setRegisterBit(POWERS_PPM_REG_07H, 3);
    }

    bool isEnableChargingSafetyTimer()
    {
        return getRegisterBit(POWERS_PPM_REG_07H, 3);
    }

    void setFastChargeTimer(FastChargeTimer timer)
    {
        int val;
        switch (timer) {
        case FAST_CHARGE_TIMER_5H:
        case FAST_CHARGE_TIMER_8H:
        case FAST_CHARGE_TIMER_12H:
        case FAST_CHARGE_TIMER_20H:
            val = readRegister(POWERS_PPM_REG_07H);
            if (val == -1)
                return;
            val &= 0xF1;
            val |= (timer << 1);
            writeRegister(POWERS_PPM_REG_07H, val);
            break;
        default:
            break;
        }
    }

    FastChargeTimer getFastChargeTimer()
    {
        int val = readRegister(POWERS_PPM_REG_07H);
        return static_cast<FastChargeTimer>((val & 0x0E) >> 1);
    }

    // JEITA Low Temperature Current Setting
    // JEITA（Japan Electronics and Information Technology Industries Association）
    // https://en.wikipedia.org/wiki/Japan_Electronics_and_Information_Technology_Industries_Association
    void setJeitaLowTemperatureCurrent(enum JeitaLowTemperatureCurrent params)
    {
        switch (params) {
        case JEITA_LOW_TEMP_50:
            clrRegisterBit(POWERS_PPM_REG_07H, 0);
            break;
        case JEITA_LOW_TEMP_20:
            setRegisterBit(POWERS_PPM_REG_07H, 0);
            break;
        default:
            break;
        }
    }

    /***************************************************
     * POWERS_PPM_REG_08H ✅
     **************************************************/
    // IR Compensation Resistor Setting
    // Range: 0 – 140mΩ
    // Default: 0Ω (000) (i.e. Disable IRComp)
    void setIRCompensationResistor(uint16_t params)
    {
        if (params % POWERS_BQ25896_BAT_COMP_STEPS) {
            log_e("Mistake ! The steps is must %u mA", POWERS_BQ25896_BAT_COMP_STEPS);
            return;
        }
        if (params > POWERS_BQ25896_TERM_CHG_CURRENT_MAX) {
            params = POWERS_BQ25896_TERM_CHG_CURRENT_MAX;
        }
        int val = readRegister(POWERS_PPM_REG_08H);
        if (val == -1)return;
        val &= 0x1F;
        params = (params  / POWERS_BQ25896_BAT_COMP_STEPS);
        val |=  (params << 5);
        writeRegister(POWERS_PPM_REG_08H, val);
    }

    // IR Compensation Voltage Clamp
    // above VREG (REG06[7:2])
    // Offset: 0mV
    // Range: 0-224mV
    // Default: 0mV (000)
    void setIRCompensationVoltageClamp(uint16_t params)
    {
        if (params % POWERS_BQ25896_VCLAMP_STEPS) {
            log_e("Mistake ! The steps is must %u mA", POWERS_BQ25896_VCLAMP_STEPS);
            return;
        }
        if (params > POWERS_BQ25896_TERM_CHG_CURRENT_MAX) {
            params = POWERS_BQ25896_TERM_CHG_CURRENT_MAX;
        }
        int val = readRegister(POWERS_PPM_REG_08H);
        if (val == -1)return;
        val &= 0xE3;
        params = (params  / POWERS_BQ25896_VCLAMP_STEPS);
        val |=  (params << 2);
        writeRegister(POWERS_PPM_REG_08H, val);
    }

    // Thermal Regulation Threshold
    // 0x0 – 60°C
    // 0x1 – 80°C
    // 0x2 – 100°C
    // 0x3 – 120°C (default)
    void setThermalRegulationThreshold(uint8_t params)
    {
        int val = readRegister(POWERS_PPM_REG_08H);
        if (val == -1)return;
        val &= 0xE3;
        val |=  (params);
        writeRegister(POWERS_PPM_REG_08H, val);
    }

    /***************************************************
     * POWERS_PPM_REG_09H
     **************************************************/
    // Force Start Input Current Optimizer (ICO)
    // 0 – Do not force ICO (default)
    // 1 – Force ICO
    // Note: This bit is can only be set only and always returns to 0 after ICO starts
    void forceInputCurrentOptimizer(bool force)
    {
        force ? setRegisterBit(POWERS_PPM_REG_09H, 7) : clrRegisterBit(POWERS_PPM_REG_09H, 7);
    }

    // Safety Timer Setting during DPM or Thermal Regulation
    // 0 – Safety timer not slowed by 2X during input DPM or thermal regulation
    // 1 – Safety timer slowed by 2X during input DPM or thermal regulation (default)
    void setThermalRegulation(uint8_t params)
    {
        params ? setRegisterBit(POWERS_PPM_REG_09H, 6) : clrRegisterBit(POWERS_PPM_REG_09H, 6) ;
    }


    // Turn off the battery power supply path. It can only be turned off when the
    // battery is powered. It cannot be turned off when USB is connected.
    // The device can only be powered on by pressing the PWR button or by connecting the power supply.
    void shutdown()
    {
        disableBatterPowerPath();
    }

    // Close battery power path
    void disableBatterPowerPath()
    {
        setRegisterBit(POWERS_PPM_REG_09H, 5);       //Force BATFET Off : BATFET_DIS
    }

    // Enable battery power path
    void enableBatterPowerPath()
    {
        clrRegisterBit(POWERS_PPM_REG_09H, 5);       //Force BATFET Off : BATFET_DIS
    }

    // JEITA High Temperature Voltage Setting
    // JEITA（Japan Electronics and Information Technology Industries Association）
    // https://en.wikipedia.org/wiki/Japan_Electronics_and_Information_Technology_Industries_Association
    // 0 – Set Charge Voltage to VREG-200mV during JEITA hig temperature(default)
    // 1 – Set Charge Voltage to VREG during JEITA high temperature
    void setJeitaHighTemperature(uint8_t params)
    {
        params ? setRegisterBit(POWERS_PPM_REG_09H, 4) : clrRegisterBit(POWERS_PPM_REG_09H, 4) ;
    }

    // BATFET turn off delay control
    // 0 – BATFET turn off immediately when BATFET_DIS bit is set (default)
    // 1 – BATFET turn off delay by tSM_DLY when BATFET_DIS bit is set
    void setTurnOffDelay(uint8_t params)
    {
        params ? setRegisterBit(POWERS_PPM_REG_09H, 3) : clrRegisterBit(POWERS_PPM_REG_09H, 3) ;
    }

    // BATFET full system reset enable
    // 0 – Disable BATFET full system reset
    // 1 – Enable BATFET full system reset (default)
    void setFullSystemReset(uint8_t params)
    {
        params ? setRegisterBit(POWERS_PPM_REG_09H, 2) : clrRegisterBit(POWERS_PPM_REG_09H, 2) ;
    }

    // Current pulse control voltage up enable
    // 0 – Disable (default)
    // 1 – Enable
    // Note: This bit is can only be set when EN_PUMPX bit is set and returns to 0 after current pulse control sequence is completed
    void setCurrentPulseControlVoltageUp(uint8_t params)
    {
        params ? setRegisterBit(POWERS_PPM_REG_09H, 1) : clrRegisterBit(POWERS_PPM_REG_09H, 1) ;
    }

    // Current pulse control voltage down enable
    // 0 – Disable (default)
    // 1 – Enable
    // Note: This bit is can only be set when EN_PUMPX bit is set and returns to 0 after current pulse control sequence is completed
    void setCurrentPulseControlVoltageDown(uint8_t params)
    {
        params ? setRegisterBit(POWERS_PPM_REG_09H, 0) : clrRegisterBit(POWERS_PPM_REG_09H, 0) ;
    }

    /***************************************************
     * POWERS_PPM_REG_0AH ✅
     **************************************************/

    // Boost Mode Voltage Regulation: 4550mV ~ 5510mV
    bool setBoostVoltage(uint16_t millivolt)
    {
        if (millivolt % POWERS_BQ25896_BOOTS_VOL_STEP) {
            log_e("Mistake ! The steps is must %u mV", POWERS_BQ25896_BOOTS_VOL_STEP);
            return false;
        }
        if (millivolt < POWERS_BQ25896_BOOST_VOL_MIN) {
            millivolt = POWERS_BQ25896_BOOST_VOL_MIN;
        }
        if (millivolt > POWERS_BQ25896_BOOST_VOL_MAX) {
            millivolt = POWERS_BQ25896_BOOST_VOL_MAX;
        }
        int val = readRegister(POWERS_PPM_REG_0AH);
        val &= 0xF0;
        val |= (((millivolt - POWERS_BQ25896_BOOTS_VOL_BASE) / POWERS_BQ25896_BOOTS_VOL_STEP) << 4);
        return  writeRegister(POWERS_PPM_REG_0AH, val) != -1;
    }

    // Boost Current Limit: 500mA ~ 150 mA
    bool setBoostCurrentLimit(BoostCurrentLimit milliampere)
    {
        if (milliampere > BOOST_CUR_LIMIT_2150MA) {
            return false;
        }
        int val = readRegister(POWERS_PPM_REG_0AH);
        val &= 0x03;
        val |= milliampere;
        return  writeRegister(POWERS_PPM_REG_0AH, val) != -1;
    }

    // PFM mode allowed in boost mode
    // 0 – Allow PFM in boost mode (default)
    // 1 – Disable PFM in boost mode
    void setBoostModeUsePFM(bool enable)
    {
        enable ? clrRegisterBit(POWERS_PPM_REG_0AH, 3) : setRegisterBit(POWERS_PPM_REG_0AH, 3);
    }


    /***************************************************
     * POWERS_PPM_REG_0BH ✅
     **************************************************/

    bool isOTG()
    {
        return getBusStatus() == BUS_STATE_OTG;
    }

    bool isCharging(void)
    {
        return chargeStatus() != CHARGE_STATE_NO_CHARGE;
    }

    bool isChargeDone()
    {
        return chargeStatus() == CHARGE_STATE_DONE;
    }

    bool isPowerGood()
    {
        return getRegisterBit(POWERS_PPM_REG_0BH, 2);
    }

    BusStatus getBusStatus()
    {
        int val =  readRegister(POWERS_PPM_REG_0BH);
        return static_cast<BusStatus>((val >> 5) & 0x07);
    }

    const char *getBusStatusString()
    {
        BusStatus status = getBusStatus();
        switch (status) {
        case BUS_STATE_NOINPUT:
            return "No input";
        case BUS_STATE_USB_SDP:
            return "USB Host SDP";
        case BUS_STATE_ADAPTER:
            return "Adapter";
        case BUS_STATE_OTG:
            return "OTG";
        default:
            return "Unknown";
        }
    }

    ChargeStatus chargeStatus()
    {
        int val =  readRegister(POWERS_PPM_REG_0BH);
        if (val == -1)return CHARGE_STATE_UNKOWN;
        return static_cast<ChargeStatus>((val >> 3) & 0x03);
    }

    const char *getChargeStatusString()
    {
        ChargeStatus status = chargeStatus();
        switch (status) {
        case CHARGE_STATE_NO_CHARGE:
            return "Not Charging";
        case CHARGE_STATE_PRE_CHARGE:
            return "Pre-charge";
        case CHARGE_STATE_FAST_CHARGE:
            return "Fast Charging";
        case CHARGE_STATE_DONE:
            return "Charge Termination Done";
        default:
            return "Unknown";
        }
    }

    // VSYS Regulation Status
    // 0 – Not in VSYSMIN regulation (BAT > VSYSMIN)
    // 1 – In VSYSMIN regulation (BAT < VSYSMIN)
    bool getVsysRegulationStatus()
    {
        return getRegisterBit(POWERS_PPM_REG_0BH, 0);
    }

    const char *getVsysRegulationStatusString()
    {
        if (getVsysRegulationStatus()) {
            return "BAT < VSYSMIN";
        }
        return "BAT > VSYSMIN";
    }

    /***************************************************
     * POWERS_PPM_REG_0CH ✅
     **************************************************/

    // After reading the register, all will be cleared
    uint8_t getFaultStatus(void)
    {
        int val = readRegister(POWERS_PPM_REG_0CH);
        if (val == -1) {
            return 0;
        }
        __irq_mask = val;
        return __irq_mask;
    }

    // Watchdog Fault Status
    // 0 – Normal
    // 1- Watchdog timer expiration
    bool isWatchdogFault()
    {
        return POWERS_BQ25896_IRQ_WTD_FAULT(__irq_mask);
    }

    // Boost Mode Fault Status
    // 0 – Normal
    // 1 – VBUS overloaded in OTG, or VBUS OVP, or battery is too low in boost mode
    bool isBoostFault()
    {
        return POWERS_BQ25896_IRQ_BOOST_FAULT(__irq_mask);
    }

    // Charge Fault Status
    // 00 – Normal
    // 01 – Input fault (VBUS > VACOV or VBAT < VBUS < VVBUSMIN(typical 3.8V)
    // 10 - Thermal shutdown
    // 11 – Charge Safety Timer Expiration
    uint8_t isChargeFault()
    {
        return POWERS_BQ25896_IRQ_CHG_FAULT(__irq_mask);
    }

    // Battery Fault Status
    // 0 – Normal
    // 1 – BATOVP (VBAT > VBATOVP)
    bool isBatteryFault()
    {
        return POWERS_BQ25896_IRQ_BAT_FAULT(__irq_mask);
    }

    // NTC Fault Status
    bool isNTCFault()
    {
        return POWERS_BQ25896_IRQ_NTC_FAULT(__irq_mask);
    }

    // NTC Fault Status string
    uint8_t getNTCStatus()
    {
        return (__irq_mask & 0x07);
    }

    const char *getNTCStatusString()
    {
        uint8_t status = getNTCStatus();
        if (isOTG()) {
            // Boost mode
            switch (status) {
            case BOOST_NTC_NORMAL:
                return "Boost mode NTC normal";
            case BOOST_NTC_COLD:
                return "Boost mode NTC cold";
            case BOOST_NTC_HOT:
                return "Boost mode NTC hot";
            default:
                break;
            }
        } else {
            // Buck mode
            switch (status) {
            case BUCK_NTC_NORMAL:
                return "Buck mode NTC normal";
            case BUCK_NTC_WARM:
                return "Buck mode NTC warm";
            case BUCK_NTC_COOL:
            case BUCK_NTC_COLD:
                return "Buck mode NTC cold";
            case BUCK_NTC_HOT:
                return "Buck mode NTC hot";
            default:
                break;
            }
        }
        return "Unknown";
    }

    // Debug
    void getReadOnlyRegisterValue()
    {
#ifdef ARDUINO //debug ..
        static uint8_t last_val[8] = {0};
        const uint8_t regis[] = {
            POWERS_PPM_REG_0BH,
            POWERS_PPM_REG_0CH,
            // POWERS_PPM_REG_0EH, //BATTERY VOLTAGE
            // POWERS_PPM_REG_0FH, //SYSTEM VOLTAGE
            // POWERS_PPM_REG_10H, //NTC PERCENTAGE
            // POWERS_PPM_REG_11H, //VBUS VOLTAGE
            POWERS_PPM_REG_12H,
            POWERS_PPM_REG_13H
        };
        Serial.println();
        Serial.println("-------------------------");
        for (uint32_t i = 0; i < sizeof(regis) / sizeof(regis[0]); ++i) {
            int val = readRegister(regis[i]);
            if (val == -1) {
                continue;
            }
            if (last_val[i] != val) {
                Serial.printf("\t---> REG%02X Prev:0x%02X ", regis[i], last_val[i]);
                Serial.print(" BIN:"); Serial.print(last_val[i], BIN);
                Serial.printf(" Curr: 0x%02X", val);
                Serial.print(" BIN:"); Serial.println(val, BIN);
                last_val[i] = val;
            }
            Serial.printf("\tREG%02XH:0x%X BIN:0b", regis[i], val);
            Serial.println(val, BIN);
        }
        Serial.println("-------------------------");
#endif
    }

    /***************************************************
     * POWERS_PPM_REG_0DH ✅
     **************************************************/
    // VINDPM Threshold Setting Method
    // 0 – Run Relative VINDPM Threshold (default)
    // 1 – Run Absolute VINDPM Threshold
    // Note: Register is reset to default value when input source is plugged-in
    void setVinDpmThresholdSetting(bool relative)
    {
        relative ? clrRegisterBit(POWERS_PPM_REG_0DH, 7) : setRegisterBit(POWERS_PPM_REG_0DH, 7);
    }

    // Absolute VINDPM Threshold
    bool setVinDpmThreshold(uint16_t millivolt)
    {
        if (millivolt % POWERS_BQ25896_VINDPM_VOL_STEPS) {
            log_e("Mistake ! The steps is must %u mV", POWERS_BQ25896_VINDPM_VOL_STEPS);
            return false;
        }
        if (millivolt < POWERS_BQ25896_VINDPM_VOL_MIN) {
            millivolt = POWERS_BQ25896_VINDPM_VOL_MIN;
        }
        if (millivolt > POWERS_BQ25896_VINDPM_VOL_MAX) {
            millivolt = POWERS_BQ25896_VINDPM_VOL_MAX;
        }
        int val = readRegister(POWERS_PPM_REG_0DH);
        val &= 0x80;
        val |= (((millivolt - POWERS_BQ25896_VINDPM_VOL_BASE) / POWERS_BQ25896_VINDPM_VOL_STEPS));
        return  writeRegister(POWERS_PPM_REG_0DH, val) != -1;
    }

    /***************************************************
     * POWERS_PPM_REG_0EH ✅
     **************************************************/
    // Thermal Regulation Status
    // true – Normal
    // false – In Thermal Regulation
    bool isThermalRegulationNormal()
    {
        return getRegisterBit(POWERS_PPM_REG_0EH, 7) == false;
    }

    // ADC conversion of Battery Voltage /mv
    uint16_t getBattVoltage()
    {
        int val = readRegister(POWERS_PPM_REG_0EH);
        if (val == -1)return 0;
        val = POWERS_BQ25896_VBAT_MASK_VAL(val);
        if (val == 0)return 0;
        return (val * POWERS_BQ25896_VBAT_VOL_STEP) + POWERS_BQ25896_VBAT_BASE_VAL;
    }

    /***************************************************
     * POWERS_PPM_REG_0FH ✅
     **************************************************/

    // ADC conversion of System Voltage (VSYS)
    uint16_t getSystemVoltage()
    {
        int val = readRegister(POWERS_PPM_REG_0FH);
        if (val == -1 || val == 0)return 0;
        return (POWERS_BQ25896_VSYS_MASK_VAL(val) * POWERS_BQ25896_VSYS_VOL_STEP) + POWERS_BQ25896_VSYS_BASE_VAL;
    }

    /***************************************************
    * POWERS_PPM_REG_10H ✅
    **************************************************/

    // ADC conversion of TS Voltage (TS) as percentage of REGN
    float getNTCPercentage()
    {
        int val = readRegister(POWERS_PPM_REG_10H);
        if (val == -1)return 0;
        return (POWERS_BQ25896_NTC_MASK_VAL(val) * POWERS_BQ25896_NTC_VOL_STEP) + POWERS_BQ25896_NTC_BASE_VAL;
    }

    /***************************************************
     * POWERS_PPM_REG_11H ✅
     **************************************************/

    // VBUS Good Status
    bool isVbusIn()
    {
        return getRegisterBit(POWERS_PPM_REG_11H, 7);
    }

    // ADC conversion of VBUS voltage (VBUS)
    uint16_t getVbusVoltage()
    {
        if (!isVbusIn()) {
            return 0;
        }
        int val = readRegister(POWERS_PPM_REG_11H);
        return (POWERS_BQ25896_VBUS_MASK_VAL(val) * POWERS_BQ25896_VBUS_VOL_STEP) + POWERS_BQ25896_VBUS_BASE_VAL;
    }

    /***************************************************
     * POWERS_PPM_REG_12H ✅
     **************************************************/

    // ADC conversion of Charge Current (IBAT) when VBAT > VBATSHORT
    //* If the charger is disconnected, the value in the register
    //* will remain the last value and will not be updated to 0.
    uint16_t getChargeCurrent()
    {
        ChargeStatus status = chargeStatus();
        if (status == CHARGE_STATE_NO_CHARGE) {
            log_e("CHARGE_STATE_NO_CHARGE...");
            return 0;
        }
        int val = readRegister(POWERS_PPM_REG_12H);
        if (val == 0 || val == -1) {
            log_e("read reg failed !...");
            return 0;
        }
        val = (val & 0x7F);
        return (val * POWERS_BQ25896_CHG_STEP_VAL) ;
    }

    /***************************************************
     * POWERS_PPM_REG_13H ✅
     **************************************************/
    // VINDPM Status : DynamicPower-Path Management and Dynamic Power Management
    bool isDynamicPowerManagement()
    {
        return getRegisterBit(POWERS_PPM_REG_13H, 7);
    }

    // IINDPM Status
    bool isInputCurrentLimit()
    {
        return getRegisterBit(POWERS_PPM_REG_13H, 6);
    }

    // Input Current Limit in effect while Input Current Optimizer (ICO) is enabled
    // Range: 100 ~ 3250 mA
    bool setInputCurrentLimitOptimizer(uint16_t milliampere)
    {
        if (milliampere % POWERS_BQ25896_IN_CURRENT_OPT_STEP) {
            log_e("Mistake ! The steps is must %u mA", POWERS_BQ25896_IN_CURRENT_OPT_STEP);
            return false;
        }
        if (milliampere < POWERS_BQ25896_IN_CURRENT_OPT_MIN) {
            milliampere = POWERS_BQ25896_IN_CURRENT_OPT_MIN;
        }
        if (milliampere > POWERS_BQ25896_IN_CURRENT_OPT_MAX) {
            milliampere = POWERS_BQ25896_IN_CURRENT_OPT_MAX;
        }
        int val = readRegister(POWERS_PPM_REG_13H);
        if (val == -1)
            return false;
        val &= 0x3F;
        milliampere = ((milliampere - POWERS_BQ25896_IN_CURRENT_OPT_MIN) / POWERS_BQ25896_IN_CURRENT_STEP);
        val |=  milliampere;
        return writeRegister(POWERS_PPM_REG_13H, val) != -1;
    }

    /***************************************************
     * POWERS_PPM_REG_14H ✅
     **************************************************/
    void resetDefault()
    {
        setRegisterBit(POWERS_PPM_REG_14H, 7);
    }

    // Input Current Optimizer (ICO) Status
    // true – Optimization is in progress
    // false – Maximum Input Current Detected
    bool isInputCurrentOptimizer()
    {
        return getRegisterBit(POWERS_PPM_REG_14H, 6) ;
    }

    // Device Revision:Default 10
    uint8_t getChipID()
    {
        int val = readRegister(POWERS_PPM_REG_14H);
        if (val == -1)return 0;
        return (val & 0x03);
    }

    // Device Configuration
    uint8_t getDeviceConfig()
    {
        int val = readRegister(POWERS_PPM_REG_14H);
        if (val == -1)return 0;
        return (val >> 3) & 0x03;
    }

private:

    bool initImpl()
    {
        __user_disable_charge = false;

        uint8_t rev = getChipID();
        if (rev != BQ25896_DEV_REV) {
            return false;
        }
        // Set the minimum operating voltage. Below this voltage, the PMU will protect
        // setSysPowerDownVoltage(3300);

        //Default disable Watchdog
        disableWatchdog();

        return true;
    }

    bool __user_disable_charge;
    uint32_t __irq_mask;
};