int power_init_board(void)
{
struct pmic *p;
int ret;
unsigned int reg;
ret = power_max77696_init(I2C_PMIC);
if (ret)
return ret;
p = pmic_get("MAX77696");
if (!p)
return -EINVAL;
ret = pmic_reg_read(p, CID, ®);
if (ret)
return ret;
printf("PMIC: MAX77696 detected, rev=0x%x\n", reg);
return pmic_probe(p);
}
static int lcd_power(void)
{
int ret = 0;
struct pmic *p = pmic_get("MAX8997_PMIC");
if (!p)
return -ENODEV;
if (pmic_probe(p))
return 0;
/* LDO15 voltage: 2.2v */
ret |= pmic_reg_write(p, MAX8997_REG_LDO15CTRL, 0x1c | EN_LDO);
/* LDO13 voltage: 3.0v */
ret |= pmic_reg_write(p, MAX8997_REG_LDO13CTRL, 0x2c | EN_LDO);
if (ret) {
puts("MAX8997 LDO setting error!\n");
return -1;
}
return 0;
}
static int mipi_power(void)
{
int ret = 0;
struct pmic *p = pmic_get("MAX8997_PMIC");
if (!p)
return -ENODEV;
if (pmic_probe(p))
return 0;
/* LDO3 voltage: 1.1v */
ret |= pmic_reg_write(p, MAX8997_REG_LDO3CTRL, 0x6 | EN_LDO);
/* LDO4 voltage: 1.8v */
ret |= pmic_reg_write(p, MAX8997_REG_LDO4CTRL, 0x14 | EN_LDO);
if (ret) {
puts("MAX8997 LDO setting error!\n");
return -1;
}
return 0;
}
static int pmic_charger_state(struct pmic *p, int state, int current)
{
unsigned char fc;
u32 val = 0;
if (pmic_probe(p))
return -1;
if (state == PMIC_CHARGER_DISABLE) {
puts("Disable the charger.\n");
pmic_reg_read(p, MAX8997_REG_MBCCTRL2, &val);
val &= ~(MBCHOSTEN | VCHGR_FC);
pmic_reg_write(p, MAX8997_REG_MBCCTRL2, val);
return -1;
}
if (current < CHARGER_MIN_CURRENT || current > CHARGER_MAX_CURRENT) {
printf("%s: Wrong charge current: %d [mA]\n",
__func__, current);
return -1;
}
fc = (current - CHARGER_MIN_CURRENT) / CHARGER_CURRENT_RESOLUTION;
fc = fc & 0xf; /* up to 950 mA */
printf("Enable the charger @ %d [mA]\n", fc * CHARGER_CURRENT_RESOLUTION
+ CHARGER_MIN_CURRENT);
val = fc | MBCICHFCSET;
pmic_reg_write(p, MAX8997_REG_MBCCTRL4, val);
pmic_reg_read(p, MAX8997_REG_MBCCTRL2, &val);
val = MBCHOSTEN | VCHGR_FC; /* enable charger & fast charge */
pmic_reg_write(p, MAX8997_REG_MBCCTRL2, val);
return 0;
}
int power_init_board(void)
{
int ret;
unsigned int reg, rev_id;
ret = power_pfuze3000_init(I2C_PMIC);
if (ret)
return ret;
pfuze = pmic_get("PFUZE3000");
ret = pmic_probe(pfuze);
if (ret)
return ret;
pmic_reg_read(pfuze, PFUZE3000_DEVICEID, ®);
pmic_reg_read(pfuze, PFUZE3000_REVID, &rev_id);
printf("PMIC: PFUZE3000 DEV_ID=0x%x REV_ID=0x%x\n", reg, rev_id);
/* disable Low Power Mode during standby mode */
pmic_reg_write(pfuze, PFUZE3000_LDOGCTL, 0x1);
return 0;
}
int mipi_power(void)
{
#ifndef CONFIG_DM_I2C /* TODO(maintainer): Convert to driver model */
int ret = 0;
struct pmic *p = pmic_get("MAX8997_PMIC");
if (!p)
return -ENODEV;
if (pmic_probe(p))
return 0;
/* LDO3 voltage: 1.1v */
ret |= pmic_reg_write(p, MAX8997_REG_LDO3CTRL, 0x6 | EN_LDO);
/* LDO4 voltage: 1.8v */
ret |= pmic_reg_write(p, MAX8997_REG_LDO4CTRL, 0x14 | EN_LDO);
if (ret) {
puts("MAX8997 LDO setting error!\n");
return -1;
}
#endif
return 0;
}
int board_late_init(void)
{
struct pmic *p;
u32 reg;
setenv("board_name", tqma6_get_boardname());
/*
* configure PFUZE100 PMIC:
* TODO: should go to power_init_board if bus switching is
* fixed in generic power code
*/
power_pfuze100_init(TQMA6_PFUZE100_I2C_BUS);
p = pmic_get("PFUZE100");
if (p && !pmic_probe(p)) {
pmic_reg_read(p, PFUZE100_DEVICEID, ®);
printf("PMIC: PFUZE100 ID=0x%02x\n", reg);
}
tqma6_bb_board_late_init();
return 0;
}
static int pm830_fg_check_battery(struct pmic *p, struct pmic *bat)
{
struct power_battery *pb = bat->pbat;
u32 val;
int ret = 0;
if (pmic_probe(p)) {
printf("Can't find 88pm830 fuel gauge\n");
return -1;
}
ret |= pmic_reg_read(p, PM830_REG_STATUS, &val);
pb->bat->version = val;
pm830_fg_update_battery(p, bat);
debug("fg ver: 0x%x\n", pb->bat->version);
printf(" voltage: %d.%6.6d [V]\n",
pb->bat->voltage_uV / 1000000,
pb->bat->voltage_uV % 1000000);
return ret;
}
int power_init_board(void)
{
struct pmic *p;
int ret;
unsigned int reg;
ret = power_pfuze100_init(I2C_PMIC);
if (ret)
return -ENODEV;
p = pmic_get("PFUZE100");
ret = pmic_probe(p);
if (ret)
return -ENODEV;
pmic_reg_read(p, PFUZE100_DEVICEID, ®);
printf("PMIC: PFUZE100 ID=0x%02x\n", reg);
pmic_reg_read(p, PFUZE100_SW3AVOL, ®);
if ((reg & 0x3f) != 0x18) {
reg &= ~0x3f;
reg |= 0x18;
pmic_reg_write(p, PFUZE100_SW3AVOL, reg);
}
ret = pfuze_mode_init(p, APS_PFM);
if (ret < 0)
return ret;
/* set SW3A standby mode to off */
pmic_reg_read(p, PFUZE100_SW3AMODE, ®);
reg &= ~0xf;
reg |= APS_OFF;
pmic_reg_write(p, PFUZE100_SW3AMODE, reg);
return 0;
}
int power_init_board(void)
{
int ret;
unsigned int reg, rev_id;
ret = power_pfuze300_init(I2C_PMIC);
if (ret)
return ret;
pfuze = pmic_get("PFUZE300");
ret = pmic_probe(pfuze);
if (ret)
return ret;
pmic_reg_read(pfuze, PFUZE300_DEVICEID, ®);
pmic_reg_read(pfuze, PFUZE300_REVID, &rev_id);
printf("PMIC: PFUZE300 DEV_ID=0x%x REV_ID=0x%x\n", reg, rev_id);
/* disable Low Power Mode during standby mode */
pmic_reg_read(pfuze, PFUZE300_LDOGCTL, ®);
reg |= 0x1;
pmic_reg_write(pfuze, PFUZE300_LDOGCTL, reg);
/* SW1B step ramp up time from 2us to 4us/25mV */
reg = 0x40;
pmic_reg_write(pfuze, PFUZE300_SW1BCONF, reg);
/* SW1B mode to APS/PFM */
reg = 0xc;
pmic_reg_write(pfuze, PFUZE300_SW1BMODE, reg);
/* SW1B standby voltage set to 0.975V */
reg = 0xb;
pmic_reg_write(pfuze, PFUZE300_SW1BSTBY, reg);
return 0;
}
static int s5pc210_phy_control(int on)
{
int ret = 0;
struct pmic *p = pmic_get("MAX8998_PMIC");
if (!p)
return -ENODEV;
if (pmic_probe(p))
return -1;
if (on) {
ret |= pmic_set_output(p,
MAX8998_REG_BUCK_ACTIVE_DISCHARGE3,
MAX8998_SAFEOUT1, LDO_ON);
ret |= pmic_set_output(p, MAX8998_REG_ONOFF1,
MAX8998_LDO3, LDO_ON);
ret |= pmic_set_output(p, MAX8998_REG_ONOFF2,
MAX8998_LDO8, LDO_ON);
} else {
ret |= pmic_set_output(p, MAX8998_REG_ONOFF2,
MAX8998_LDO8, LDO_OFF);
ret |= pmic_set_output(p, MAX8998_REG_ONOFF1,
MAX8998_LDO3, LDO_OFF);
ret |= pmic_set_output(p,
MAX8998_REG_BUCK_ACTIVE_DISCHARGE3,
MAX8998_SAFEOUT1, LDO_OFF);
}
if (ret) {
puts("MAX8998 LDO setting error!\n");
return -1;
}
return 0;
}
static int s5pc210_phy_control(int on)
{
int ret = 0;
u32 val = 0;
struct pmic *p = pmic_get("MAX8997_PMIC");
if (!p)
return -ENODEV;
if (pmic_probe(p))
return -1;
if (on) {
ret |= pmic_set_output(p, MAX8997_REG_SAFEOUTCTRL,
ENSAFEOUT1, LDO_ON);
ret |= pmic_reg_read(p, MAX8997_REG_LDO3CTRL, &val);
ret |= pmic_reg_write(p, MAX8997_REG_LDO3CTRL, EN_LDO | val);
ret |= pmic_reg_read(p, MAX8997_REG_LDO8CTRL, &val);
ret |= pmic_reg_write(p, MAX8997_REG_LDO8CTRL, EN_LDO | val);
} else {
ret |= pmic_reg_read(p, MAX8997_REG_LDO8CTRL, &val);
ret |= pmic_reg_write(p, MAX8997_REG_LDO8CTRL, DIS_LDO | val);
ret |= pmic_reg_read(p, MAX8997_REG_LDO3CTRL, &val);
ret |= pmic_reg_write(p, MAX8997_REG_LDO3CTRL, DIS_LDO | val);
ret |= pmic_set_output(p, MAX8997_REG_SAFEOUTCTRL,
ENSAFEOUT1, LDO_OFF);
}
if (ret) {
puts("MAX8997 LDO setting error!\n");
return -1;
}
return 0;
}
static int s5pc1xx_phy_control(int on)
{
int ret;
static int status;
struct pmic *p = pmic_get("MAX8998_PMIC");
if (!p)
return -ENODEV;
if (pmic_probe(p))
return -1;
if (on && !status) {
ret = pmic_set_output(p, MAX8998_REG_ONOFF1,
MAX8998_LDO3, LDO_ON);
ret = pmic_set_output(p, MAX8998_REG_ONOFF2,
MAX8998_LDO8, LDO_ON);
if (ret) {
puts("MAX8998 LDO setting error!\n");
return -1;
}
status = 1;
} else if (!on && status) {
ret = pmic_set_output(p, MAX8998_REG_ONOFF1,
MAX8998_LDO3, LDO_OFF);
ret = pmic_set_output(p, MAX8998_REG_ONOFF2,
MAX8998_LDO8, LDO_OFF);
if (ret) {
puts("MAX8998 LDO setting error!\n");
return -1;
}
status = 0;
}
udelay(10000);
return 0;
}
/* setup board specific PMIC */
void setup_pmic(void)
{
struct pmic *p;
u32 reg;
i2c_set_bus_num(CONFIG_I2C_PMIC);
/* configure PFUZE100 PMIC */
if (!i2c_probe(CONFIG_POWER_PFUZE100_I2C_ADDR)) {
debug("probed PFUZE100@0x%x\n", CONFIG_POWER_PFUZE100_I2C_ADDR);
power_pfuze100_init(CONFIG_I2C_PMIC);
p = pmic_get("PFUZE100");
if (p && !pmic_probe(p)) {
pmic_reg_read(p, PFUZE100_DEVICEID, ®);
printf("PMIC: PFUZE100 ID=0x%02x\n", reg);
/* Set VGEN1 to 1.5V and enable */
pmic_reg_read(p, PFUZE100_VGEN1VOL, ®);
reg &= ~(LDO_VOL_MASK);
reg |= (LDOA_1_50V | LDO_EN);
pmic_reg_write(p, PFUZE100_VGEN1VOL, reg);
/* Set SWBST to 5.0V and enable */
pmic_reg_read(p, PFUZE100_SWBSTCON1, ®);
reg &= ~(SWBST_MODE_MASK | SWBST_VOL_MASK);
reg |= (SWBST_5_00V | (SWBST_MODE_AUTO << SWBST_MODE_SHIFT));
pmic_reg_write(p, PFUZE100_SWBSTCON1, reg);
}
}
/* configure LTC3676 PMIC */
else if (!i2c_probe(CONFIG_POWER_LTC3676_I2C_ADDR)) {
debug("probed LTC3676@0x%x\n", CONFIG_POWER_LTC3676_I2C_ADDR);
power_ltc3676_init(CONFIG_I2C_PMIC);
p = pmic_get("LTC3676_PMIC");
if (p && !pmic_probe(p)) {
puts("PMIC: LTC3676\n");
/*
* set board-specific scalar for max CPU frequency
* per CPU based on the LDO enabled Operating Ranges
* defined in the respective IMX6DQ and IMX6SDL
* datasheets. The voltage resulting from the R1/R2
* feedback inputs on Ventana is 1308mV. Note that this
* is a bit shy of the Vmin of 1350mV in the datasheet
* for LDO enabled mode but is as high as we can go.
*
* We will rely on an OS kernel driver to properly
* regulate these per CPU operating point and use LDO
* bypass mode when using the higher frequency
* operating points to compensate as LDO bypass mode
* allows the rails be 125mV lower.
*/
/* mask PGOOD during SW1 transition */
pmic_reg_write(p, LTC3676_DVB1B,
0x1f | LTC3676_PGOOD_MASK);
/* set SW1 (VDD_SOC) */
pmic_reg_write(p, LTC3676_DVB1A, 0x1f);
/* mask PGOOD during SW3 transition */
pmic_reg_write(p, LTC3676_DVB3B,
0x1f | LTC3676_PGOOD_MASK);
/* set SW3 (VDD_ARM) */
pmic_reg_write(p, LTC3676_DVB3A, 0x1f);
}
}
}
static int pmic_init_max8997(void)
{
struct pmic *p = pmic_get("MAX8997_PMIC");
int i = 0, ret = 0;
u32 val;
if (pmic_probe(p))
return -1;
/* BUCK1 VARM: 1.2V */
val = (1200000 - 650000) / 25000;
ret |= pmic_reg_write(p, MAX8997_REG_BUCK1DVS1, val);
val = ENBUCK | ACTIVE_DISCHARGE; /* DVS OFF */
ret |= pmic_reg_write(p, MAX8997_REG_BUCK1CTRL, val);
/* BUCK2 VINT: 1.1V */
val = (1100000 - 650000) / 25000;
ret |= pmic_reg_write(p, MAX8997_REG_BUCK2DVS1, val);
val = ENBUCK | ACTIVE_DISCHARGE; /* DVS OFF */
ret |= pmic_reg_write(p, MAX8997_REG_BUCK2CTRL, val);
/* BUCK3 G3D: 1.1V - OFF */
ret |= pmic_reg_read(p, MAX8997_REG_BUCK3CTRL, &val);
val &= ~ENBUCK;
ret |= pmic_reg_write(p, MAX8997_REG_BUCK3CTRL, val);
val = (1100000 - 750000) / 50000;
ret |= pmic_reg_write(p, MAX8997_REG_BUCK3DVS, val);
/* BUCK4 CAMISP: 1.2V - OFF */
ret |= pmic_reg_read(p, MAX8997_REG_BUCK4CTRL, &val);
val &= ~ENBUCK;
ret |= pmic_reg_write(p, MAX8997_REG_BUCK4CTRL, val);
val = (1200000 - 650000) / 25000;
ret |= pmic_reg_write(p, MAX8997_REG_BUCK4DVS, val);
/* BUCK5 VMEM: 1.2V */
val = (1200000 - 650000) / 25000;
for (i = 0; i < 8; i++)
ret |= pmic_reg_write(p, MAX8997_REG_BUCK5DVS1 + i, val);
val = ENBUCK | ACTIVE_DISCHARGE; /* DVS OFF */
ret |= pmic_reg_write(p, MAX8997_REG_BUCK5CTRL, val);
/* BUCK6 CAM AF: 2.8V */
/* No Voltage Setting Register */
/* GNSLCT 3.0X */
val = GNSLCT;
ret |= pmic_reg_write(p, MAX8997_REG_BUCK6CTRL, val);
/* BUCK7 VCC_SUB: 2.0V */
val = (2000000 - 750000) / 50000;
ret |= pmic_reg_write(p, MAX8997_REG_BUCK7DVS, val);
/* LDO1 VADC: 3.3V */
val = max8997_reg_ldo(3300000) | DIS_LDO; /* OFF */
ret |= pmic_reg_write(p, MAX8997_REG_LDO1CTRL, val);
/* LDO1 Disable active discharging */
ret |= pmic_reg_read(p, MAX8997_REG_LDO1CONFIG, &val);
val &= ~LDO_ADE;
ret |= pmic_reg_write(p, MAX8997_REG_LDO1CONFIG, val);
/* LDO2 VALIVE: 1.1V */
val = max8997_reg_ldo(1100000) | EN_LDO;
ret |= pmic_reg_write(p, MAX8997_REG_LDO2CTRL, val);
/* LDO3 VUSB/MIPI: 1.1V */
val = max8997_reg_ldo(1100000) | DIS_LDO; /* OFF */
ret |= pmic_reg_write(p, MAX8997_REG_LDO3CTRL, val);
/* LDO4 VMIPI: 1.8V */
val = max8997_reg_ldo(1800000) | DIS_LDO; /* OFF */
ret |= pmic_reg_write(p, MAX8997_REG_LDO4CTRL, val);
/* LDO5 VHSIC: 1.2V */
val = max8997_reg_ldo(1200000) | DIS_LDO; /* OFF */
ret |= pmic_reg_write(p, MAX8997_REG_LDO5CTRL, val);
/* LDO6 VCC_1.8V_PDA: 1.8V */
val = max8997_reg_ldo(1800000) | EN_LDO;
ret |= pmic_reg_write(p, MAX8997_REG_LDO6CTRL, val);
/* LDO7 CAM_ISP: 1.8V */
val = max8997_reg_ldo(1800000) | DIS_LDO; /* OFF */
ret |= pmic_reg_write(p, MAX8997_REG_LDO7CTRL, val);
/* LDO8 VDAC/VUSB: 3.3V */
val = max8997_reg_ldo(3300000) | DIS_LDO; /* OFF */
ret |= pmic_reg_write(p, MAX8997_REG_LDO8CTRL, val);
/* LDO9 VCC_2.8V_PDA: 2.8V */
val = max8997_reg_ldo(2800000) | EN_LDO;
ret |= pmic_reg_write(p, MAX8997_REG_LDO9CTRL, val);
/* LDO10 VPLL: 1.1V */
val = max8997_reg_ldo(1100000) | EN_LDO;
ret |= pmic_reg_write(p, MAX8997_REG_LDO10CTRL, val);
/* LDO11 TOUCH: 2.8V */
val = max8997_reg_ldo(2800000) | DIS_LDO; /* OFF */
ret |= pmic_reg_write(p, MAX8997_REG_LDO11CTRL, val);
/* LDO12 VTCAM: 1.8V */
val = max8997_reg_ldo(1800000) | DIS_LDO; /* OFF */
ret |= pmic_reg_write(p, MAX8997_REG_LDO12CTRL, val);
/* LDO13 VCC_3.0_LCD: 3.0V */
val = max8997_reg_ldo(3000000) | DIS_LDO; /* OFF */
ret |= pmic_reg_write(p, MAX8997_REG_LDO13CTRL, val);
/* LDO14 MOTOR: 3.0V */
val = max8997_reg_ldo(3000000) | DIS_LDO; /* OFF */
ret |= pmic_reg_write(p, MAX8997_REG_LDO14CTRL, val);
/* LDO15 LED_A: 2.8V */
val = max8997_reg_ldo(2800000) | DIS_LDO; /* OFF */
ret |= pmic_reg_write(p, MAX8997_REG_LDO15CTRL, val);
/* LDO16 CAM_SENSOR: 1.8V */
val = max8997_reg_ldo(1800000) | DIS_LDO; /* OFF */
ret |= pmic_reg_write(p, MAX8997_REG_LDO16CTRL, val);
/* LDO17 VTF: 2.8V */
val = max8997_reg_ldo(2800000) | DIS_LDO; /* OFF */
ret |= pmic_reg_write(p, MAX8997_REG_LDO17CTRL, val);
/* LDO18 TOUCH_LED 3.3V */
val = max8997_reg_ldo(3300000) | DIS_LDO; /* OFF */
ret |= pmic_reg_write(p, MAX8997_REG_LDO18CTRL, val);
/* LDO21 VDDQ: 1.2V */
val = max8997_reg_ldo(1200000) | EN_LDO;
ret |= pmic_reg_write(p, MAX8997_REG_LDO21CTRL, val);
/* SAFEOUT for both 1 and 2: 4.9V, Active discharge, Enable */
val = (SAFEOUT_4_90V << 0) | (SAFEOUT_4_90V << 2) |
ACTDISSAFEO1 | ACTDISSAFEO2 | ENSAFEOUT1 | ENSAFEOUT2;
ret |= pmic_reg_write(p, MAX8997_REG_SAFEOUTCTRL, val);
if (ret) {
puts("MAX8997 PMIC setting error!\n");
return -1;
}
return 0;
}
static int s5pc210_phy_control(int on)
{
int ret = 0;
unsigned int val;
struct pmic *p, *p_pmic, *p_muic;
p_pmic = pmic_get("MAX77686_PMIC");
if (!p_pmic)
return -ENODEV;
if (pmic_probe(p_pmic))
return -1;
p_muic = pmic_get("MAX77693_MUIC");
if (!p_muic)
return -ENODEV;
if (pmic_probe(p_muic))
return -1;
if (on) {
ret = s5m8767a_set_ldo_mode(S5M8767A_I2C_ADDR, 12, OPMODE_ON);
if (ret)
return -1;
p = pmic_get("MAX77693_PMIC");
if (!p)
return -ENODEV;
if (pmic_probe(p))
return -1;
/* SAFEOUT */
ret = pmic_reg_read(p, MAX77693_SAFEOUT, &val);
if (ret)
return -1;
val |= MAX77693_ENSAFEOUT1;
ret = pmic_reg_write(p, MAX77693_SAFEOUT, val);
if (ret)
return -1;
/* PATH: USB */
ret = pmic_reg_write(p_muic, MAX77693_MUIC_CONTROL1,
MAX77693_MUIC_CTRL1_DN1DP2);
} else {
ret = s5m8767a_set_ldo_mode(S5M8767A_I2C_ADDR, 12, OPMODE_LPM);
if (ret)
return -1;
/* PATH: UART */
ret = pmic_reg_write(p_muic, MAX77693_MUIC_CONTROL1,
MAX77693_MUIC_CTRL1_UT1UR2);
}
if (ret)
return -1;
return 0;
}
int power_init_board(void)
{
struct pmic *p;
set_ps_hold_ctrl();
i2c_init(CONFIG_SYS_I2C_SPEED, CONFIG_SYS_I2C_SLAVE);
if (pmic_init(I2C_PMIC))
return -1;
p = pmic_get("MAX77686_PMIC");
if (!p)
return -ENODEV;
if (pmic_probe(p))
return -1;
if (pmic_reg_update(p, MAX77686_REG_PMIC_32KHZ, MAX77686_32KHCP_EN))
return -1;
if (pmic_reg_update(p, MAX77686_REG_PMIC_BBAT,
MAX77686_BBCHOSTEN | MAX77686_BBCVS_3_5V))
return -1;
/* VDD_MIF */
if (pmic_reg_write(p, MAX77686_REG_PMIC_BUCK1OUT,
MAX77686_BUCK1OUT_1_05V)) {
debug("%s: PMIC %d register write failed\n", __func__,
MAX77686_REG_PMIC_BUCK1OUT);
return -1;
}
if (pmic_reg_update(p, MAX77686_REG_PMIC_BUCK1CRTL,
MAX77686_BUCK1CTRL_EN))
return -1;
/* VDD_ARM */
if (pmic_reg_write(p, MAX77686_REG_PMIC_BUCK2DVS1,
MAX77686_BUCK2DVS1_1_3V)) {
debug("%s: PMIC %d register write failed\n", __func__,
MAX77686_REG_PMIC_BUCK2DVS1);
return -1;
}
if (pmic_reg_update(p, MAX77686_REG_PMIC_BUCK2CTRL1,
MAX77686_BUCK2CTRL_ON))
return -1;
/* VDD_INT */
if (pmic_reg_write(p, MAX77686_REG_PMIC_BUCK3DVS1,
MAX77686_BUCK3DVS1_1_0125V)) {
debug("%s: PMIC %d register write failed\n", __func__,
MAX77686_REG_PMIC_BUCK3DVS1);
return -1;
}
if (pmic_reg_update(p, MAX77686_REG_PMIC_BUCK3CTRL,
MAX77686_BUCK3CTRL_ON))
return -1;
/* VDD_G3D */
if (pmic_reg_write(p, MAX77686_REG_PMIC_BUCK4DVS1,
MAX77686_BUCK4DVS1_1_2V)) {
debug("%s: PMIC %d register write failed\n", __func__,
MAX77686_REG_PMIC_BUCK4DVS1);
return -1;
}
if (pmic_reg_update(p, MAX77686_REG_PMIC_BUCK4CTRL1,
MAX77686_BUCK3CTRL_ON))
return -1;
/* VDD_LDO2 */
if (pmic_reg_update(p, MAX77686_REG_PMIC_LDO2CTRL1,
MAX77686_LD02CTRL1_1_5V | EN_LDO))
return -1;
/* VDD_LDO3 */
if (pmic_reg_update(p, MAX77686_REG_PMIC_LDO3CTRL1,
MAX77686_LD03CTRL1_1_8V | EN_LDO))
return -1;
/* VDD_LDO5 */
if (pmic_reg_update(p, MAX77686_REG_PMIC_LDO5CTRL1,
MAX77686_LD05CTRL1_1_8V | EN_LDO))
return -1;
/* VDD_LDO10 */
if (pmic_reg_update(p, MAX77686_REG_PMIC_LDO10CTRL1,
MAX77686_LD10CTRL1_1_8V | EN_LDO))
return -1;
return 0;
}
int power_init_board(void)
{
int ret;
u32 rev_id, value;
ret = power_pfuze100_init(I2C_PMIC);
if (ret)
return ret;
pfuze = pmic_get("PFUZE100");
if (!pfuze)
return -ENODEV;
ret = pmic_probe(pfuze);
if (ret)
return ret;
ret = pfuze_mode_init(pfuze, APS_PFM);
if (ret < 0)
return ret;
pmic_reg_read(pfuze, PFUZE100_DEVICEID, &value);
pmic_reg_read(pfuze, PFUZE100_REVID, &rev_id);
printf("PMIC: PFUZE200! DEV_ID=0x%x REV_ID=0x%x\n", value, rev_id);
/*
* Our PFUZE0200 is PMPF0200X0AEP, the Pre-programmed OTP
* Configuration is F0.
* Default VOLT:
* VSNVS_VOLT | 3.0V
* SW1AB | 1.375V
* SW2 | 3.3V
* SW3A | 1.5V
* SW3B | 1.5V
* VGEN1 | 1.5V
* VGEN2 | 1.5V
* VGEN3 | 2.5V
* VGEN4 | 1.8V
* VGEN5 | 2.8V
* VGEN6 | 3.3V
*
* According to schematic, we need SW3A 1.35V, SW3B 3.3V,
* VGEN1 1.2V, VGEN2 1.5V, VGEN3 2.8V, VGEN4 1.8V,
* VGEN5 3.3V, VGEN6 3.0V.
*
* Here we just use the default VOLT, but not configure
* them, when needed, configure them to our requested voltage.
*/
/* set SW1AB standby volatage 1.3V */
pmic_reg_read(pfuze, PFUZE100_SW1ABSTBY, &value);
value &= ~0x3f;
value |= PFUZE100_SW1ABC_SETP(13000);
pmic_reg_write(pfuze, PFUZE100_SW1ABSTBY, value);
/* set SW1AB/VDDARM step ramp up time from 16us to 4us/25mV */
pmic_reg_read(pfuze, PFUZE100_SW1ABCONF, &value);
value &= ~0xc0;
value |= 0x40;
pmic_reg_write(pfuze, PFUZE100_SW1ABCONF, value);
/* Enable power of VGEN5 3V3 */
pmic_reg_read(pfuze, PFUZE100_VGEN5VOL, &value);
value &= ~0x1F;
value |= 0x1F;
pmic_reg_write(pfuze, PFUZE100_VGEN5VOL, value);
return 0;
}
static int pm830_battery_init(struct pmic *bat_,
struct pmic *fg_,
struct pmic *chrg_,
struct pmic *muic_)
{
struct pmic *p = chrg_;
int ret, version;
u32 data;
if (!p) {
printf("Charger invalid\n");
return -1;
}
bat_->pbat->fg = fg_;
bat_->pbat->chrg = chrg_;
bat_->pbat->muic = muic_;
if (fg_)
bat_->fg = fg_->fg;
if (chrg_)
bat_->chrg = chrg_->chrg;
if (muic_)
bat_->chrg->chrg_type = muic_->chrg->chrg_type;
/* init PM830 */
if (pmic_probe(p)) {
printf("Can't find 88pm830 battery\n");
return -1;
}
/* read chip version */
ret = pmic_reg_read(p, PM830_REG_PMIC_ID, &data);
if (ret != 0) {
printf("read Lipari ID error: return ...\n");
return -1;
} else
printf("Lipari ID = 0x%x\n", data);
version = data;
/* set charging sequence */
data = 0x7;
pmic_reg_write(p, PM830_REG_MISC1, data);
data = 0x6a;
pmic_reg_write(p, PM830_REG_FG_CTRL1, data);
data = 0x1;
pmic_reg_write(p, PM830_REG_FG_CTRL2, data);
data = 0x7b;
pmic_reg_write(p, PM830_REG_INT1MSK, data);
/* change battery short threshold to 2.0v */
data = 0x9;
pmic_reg_write(p, PM830_REG_CHG_CTRL2, data);
data = 0x1f;
pmic_reg_write(p, PM830_REG_CHG_CTRL4, data);
data = 0x6f;
pmic_reg_write(p, PM830_REG_CHG_CTRL5, data);
data = 0x88;
pmic_reg_write(p, PM830_REG_CHG_CTRL6, data);
data = 0x02;
pmic_reg_write(p, PM830_REG_CHG_CTRL7, data);
data = 0x07;
pmic_reg_write(p, PM830_REG_CHG_CTRL8, data);
/* enable VBUS_SW */
data = 0x01;
pmic_reg_write(p, PM830_REG_CHG_CTRL3, data);
/* read and clear interruption registers */
pmic_reg_read(p, PM830_REG_INT1, &data);
pmic_reg_read(p, PM830_REG_INT2, &data);
pmic_reg_read(p, PM830_REG_INT3, &data);
/* enable MPPT loop */
data = 0x02;
pmic_reg_write(p, PM830_REG_MPPT_CTRL1, data);
data = 0xff;
pmic_reg_write(p, PM830_REG_MPPT_CTRL2, data);
if (version > PM830_A1_VERSION) {
/* disable charger watchdog and clear SUPPL_PRE_DIS bit */
pmic_reg_read(p, PM830_REG_CHG_CTRL9, &data);
data |= 0x10;
pmic_reg_write(p, PM830_REG_CHG_CTRL9, data);
pmic_reg_read(p, PM830_REG_CHG_CTRL2, &data);
data &= ~0x40;
pmic_reg_write(p, PM830_REG_CHG_CTRL2, data);
}
return 0;
}
