~lzh/A133.git

/*
 * Copyright (C) 2019 Allwinner.
 * weidonghui <weidonghui@allwinnertech.com>
 *
 * SUNXI AXP  Driver
 *
 * SPDX-License-Identifier: GPL-2.0+
 */
 
#include <common.h>
#include <sunxi_power/bmu_axp2101.h>
#include <sunxi_power/axp.h>
#include <asm/arch/pmic_bus.h>
 
static int bmu_axp2101_probe(void)
{
    u8 bmu_chip_id;
    if (pmic_bus_init(AXP2101_DEVICE_ADDR, AXP2101_RUNTIME_ADDR)) {
        tick_printf("%s pmic_bus_init fail\n", __func__);
        return -1;
    }
    if (pmic_bus_read(AXP2101_RUNTIME_ADDR, AXP2101_VERSION, &bmu_chip_id)) {
        tick_printf("%s pmic_bus_read fail\n", __func__);
        return -1;
    }
    bmu_chip_id &= 0XCF;
    if (bmu_chip_id == 0x47) {
        /*bmu type AXP21*/
        tick_printf("BMU: AXP21\n");
        return 0;
    }
    return -1;
}
 
int bmu_axp2101_set_power_off(void)
{
    u8 reg_value;
    int set_vol = 3300;
 
    if (pmic_bus_read(AXP2101_RUNTIME_ADDR, AXP2101_VOFF_THLD, &reg_value)) {
        return -1;
    }
    reg_value &= 0xf8;
    if (set_vol >= 2600 && set_vol <= 3300) {
        reg_value |= (set_vol - 2600) / 100;
    } else if (set_vol <= 2600) {
        reg_value |= 0x00;
    } else {
        reg_value |= 0x07;
    }
    if (pmic_bus_write(AXP2101_RUNTIME_ADDR, AXP2101_VOFF_THLD, reg_value)) {
        return -1;
    }
 
    return 0;
}
 
/*
    boot_source    0x20        help            return
 
    power low    BIT0        boot button        AXP_BOOT_SOURCE_BUTTON
    irq        BIT1        IRQ LOW            AXP_BOOT_SOURCE_IRQ_LOW
    usb        BIT2        VBUS    insert        AXP_BOOT_SOURCE_VBUS_USB
    charge        BIT3        charge to 3.3v        AXP_BOOT_SOURCE_CHARGER
    battery        BIT4        battary in        AXP_BOOT_SOURCE_BATTERY
*/
int bmu_axp2101_get_poweron_source(void)
{
    uchar reg_value;
    if (pmic_bus_read(AXP2101_RUNTIME_ADDR, AXP2101_PWRON_STATUS, &reg_value)) {
        return -1;
    }
    switch (reg_value) {
    case (1 << AXP_BOOT_SOURCE_BUTTON): return AXP_BOOT_SOURCE_BUTTON;
    case (1 << AXP_BOOT_SOURCE_IRQ_LOW): return AXP_BOOT_SOURCE_IRQ_LOW;
    case (1 << AXP_BOOT_SOURCE_VBUS_USB): return AXP_BOOT_SOURCE_VBUS_USB;
    case (1 << AXP_BOOT_SOURCE_CHARGER): return AXP_BOOT_SOURCE_CHARGER;
    case (1 << AXP_BOOT_SOURCE_BATTERY): return AXP_BOOT_SOURCE_BATTERY;
    default: return -1;
    }
 
}
 
int bmu_axp2101_set_coulombmeter_onoff(int onoff)
{
    u8 reg_value;
 
    if (pmic_bus_read(AXP2101_RUNTIME_ADDR, AXP2101_FUEL_GAUGE_CTL,
              &reg_value)) {
        return -1;
    }
    if (!onoff)
        reg_value &= ~(0x01 << 3);
    else
        reg_value |= (0x01 << 3);
 
    if (pmic_bus_write(AXP2101_RUNTIME_ADDR, AXP2101_FUEL_GAUGE_CTL,
               reg_value)) {
        return -1;
    }
    return 0;
}
 
int bmu_axp2101_get_axp_bus_exist(void)
{
    u8 reg_value;
    if (pmic_bus_read(AXP2101_RUNTIME_ADDR, AXP2101_COMM_STATUS0, &reg_value)) {
        return -1;
    }
    /*bit1: 0: vbus not power,  1: power good*/
    if (reg_value & 0x20) {
        return AXP_VBUS_EXIST;
    }
    return 0;
}
 
int bmu_axp2101_get_battery_vol(void)
{
    u8 reg_value_h = 0, reg_value_l = 0;
    int i, vtemp[3];
 
    for (i = 0; i < 3; i++) {
        if (pmic_bus_read(AXP2101_RUNTIME_ADDR, AXP2101_BAT_AVERVOL_H6,
                  &reg_value_h)) {
            return -1;
        }
        if (pmic_bus_read(AXP2101_RUNTIME_ADDR, AXP2101_BAT_AVERVOL_L8,
                  &reg_value_l)) {
            return -1;
        }
        /*step 1mv*/
        vtemp[i] = ((reg_value_h & 0x3F) << 8) | reg_value_l;
    }
    if (vtemp[0] > vtemp[1]) {
        vtemp[0] = vtemp[0] ^ vtemp[1];
        vtemp[1] = vtemp[0] ^ vtemp[1];
        vtemp[0] = vtemp[0] ^ vtemp[1];
    }
    if (vtemp[1] > vtemp[2]) {
        vtemp[1] = vtemp[2] ^ vtemp[1];
        vtemp[2] = vtemp[2] ^ vtemp[1];
        vtemp[1] = vtemp[2] ^ vtemp[1];
    }
    if (vtemp[0] > vtemp[1]) {
        vtemp[0] = vtemp[0] ^ vtemp[1];
        vtemp[1] = vtemp[0] ^ vtemp[1];
        vtemp[0] = vtemp[0] ^ vtemp[1];
    }
    return vtemp[1];
}
 
int bmu_axp2101_get_battery_capacity(void)
{
    u8 reg_value;
 
    if (pmic_bus_read(AXP2101_RUNTIME_ADDR, AXP2101_BAT_PERCEN_CAL,
              &reg_value)) {
        return -1;
    }
    return reg_value;
}
 
int bmu_axp2101_get_battery_probe(void)
{
    u8 reg_value;
 
    if (pmic_bus_read(AXP2101_RUNTIME_ADDR, AXP2101_COMM_STATUS0, &reg_value)) {
        return -1;
    }
 
    if (reg_value & 0x08)
        return 1;
 
    return -1;
}
 
int bmu_axp2101_set_vbus_current_limit(int current)
{
    u8 reg_value;
    if (pmic_bus_read(AXP2101_RUNTIME_ADDR, AXP2101_VBUS_CUR_SET, &reg_value)) {
        return -1;
    }
    reg_value &= 0xf8;
 
    if (current >= 2000) {
        /*limit to 2000mA */
        reg_value |= 0x05;
    } else if (current >= 1500) {
        /* limit to 1500mA */
        reg_value |= 0x04;
    } else if (current >= 1000) {
        /* limit to 1000mA */
        reg_value |= 0x03;
    } else if (current >= 900) {
        /*limit to 900mA */
        reg_value |= 0x02;
    } else if (current >= 500) {
        /*limit to 500mA */
        reg_value |= 0x01;
    } else if (current >= 100) {
        /*limit to 100mA */
        reg_value |= 0x0;
    } else
        reg_value |= 0x01;
 
    tick_printf("Input current:%d mA\n", current);
    if (pmic_bus_write(AXP2101_RUNTIME_ADDR, AXP2101_VBUS_CUR_SET, reg_value)) {
        return -1;
    }
    return 0;
}
 
int bmu_axp2101_get_vbus_current_limit(void)
{
    uchar reg_value;
    if (pmic_bus_read(AXP2101_RUNTIME_ADDR, AXP2101_VBUS_CUR_SET, &reg_value)) {
        return -1;
    }
    reg_value &= 0x07;
    if (reg_value == 0x05) {
        printf("limit to 2000mA \n");
        return 2000;
    } else if (reg_value == 0x04) {
        printf("limit to 1500mA \n");
        return 1500;
    } else if (reg_value == 0x03) {
        printf("limit to 1000mA \n");
        return 1000;
    } else if (reg_value == 0x02) {
        printf("limit to 900mA \n");
        return 900;
    } else if (reg_value == 0x01) {
        printf("limit to 500mA \n");
        return 500;
    } else if (reg_value == 0x00) {
        printf("limit to 100mA \n");
        return 100;
    } else {
        printf("do not limit current \n");
        return 0;
    }
}
int bmu_axp2101_set_charge_current_limit(int current)
{
    u8 reg_value;
    int step;
 
    if (pmic_bus_read(AXP2101_RUNTIME_ADDR, AXP2101_CHARGE1, &reg_value)) {
        return -1;
    }
    reg_value &= ~0x1f;
    if (current > 2000) {
        current = 2000;
    }
    if (current <= 200)
        step = current / 25;
    else
        step = (current / 100) + 6;
 
    reg_value |= (step & 0x1f);
    if (pmic_bus_write(AXP2101_RUNTIME_ADDR, AXP2101_CHARGE1, reg_value)) {
        return -1;
    }
 
    return 0;
}
 
unsigned char bmu_axp2101_get_reg_value(unsigned char reg_addr)
{
    u8 reg_value;
    if (pmic_bus_read(AXP2101_RUNTIME_ADDR, reg_addr, &reg_value)) {
        return -1;
    }
    return reg_value;
}
 
unsigned char bmu_axp2101_set_reg_value(unsigned char reg_addr, unsigned char reg_value)
{
    unsigned char reg;
    if (pmic_bus_write(AXP2101_RUNTIME_ADDR, reg_addr, reg_value)) {
        return -1;
    }
    if (pmic_bus_read(AXP2101_RUNTIME_ADDR, reg_addr, &reg)) {
        return -1;
    }
    return reg;
}
 
 
U_BOOT_AXP_BMU_INIT(bmu_axp2101) = {
    .bmu_name          = "bmu_axp2101",
    .probe              = bmu_axp2101_probe,
    .set_power_off          = bmu_axp2101_set_power_off,
    .get_poweron_source       = bmu_axp2101_get_poweron_source,
    .get_axp_bus_exist    = bmu_axp2101_get_axp_bus_exist,
    .set_coulombmeter_onoff   = bmu_axp2101_set_coulombmeter_onoff,
    .get_battery_vol      = bmu_axp2101_get_battery_vol,
    .get_battery_capacity     = bmu_axp2101_get_battery_capacity,
    .get_battery_probe    = bmu_axp2101_get_battery_probe,
    .set_vbus_current_limit   = bmu_axp2101_set_vbus_current_limit,
    .get_vbus_current_limit   = bmu_axp2101_get_vbus_current_limit,
    .set_charge_current_limit = bmu_axp2101_set_charge_current_limit,
    .get_reg_value       = bmu_axp2101_get_reg_value,
    .set_reg_value       = bmu_axp2101_set_reg_value,
};