static int s5pc210_phy_control(int on)
{
int ret = 0;
u32 val = 0;
struct pmic *p = get_pmic();
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;
}
int power_init_board(void)
{
struct pmic *p;
int ret;
unsigned int reg, rev_id;
ret = power_pfuze3000_init(I2C_PMIC);
if (ret)
return ret;
p = pmic_get("PFUZE3000");
ret = pmic_probe(p);
if (ret)
return ret;
pmic_reg_read(p, PFUZE3000_DEVICEID, ®);
pmic_reg_read(p, 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_read(p, PFUZE3000_LDOGCTL, ®);
reg |= 0x1;
pmic_reg_write(p, PFUZE3000_LDOGCTL, reg);
return 0;
}
void power_init(void)
{
unsigned int val;
struct pmic *p;
pmic_init();
p = get_pmic();
/* Set VDDA to 1.25V */
pmic_reg_read(p, REG_SW_2, &val);
val &= ~SWX_OUT_MASK;
val |= SWX_OUT_1_25;
pmic_reg_write(p, REG_SW_2, val);
/*
* Need increase VCC and VDDA to 1.3V
* according to MX53 IC TO2 datasheet.
*/
if (is_soc_rev(CHIP_REV_2_0) == 0) {
/* Set VCC to 1.3V for TO2 */
pmic_reg_read(p, REG_SW_1, &val);
val &= ~SWX_OUT_MASK;
val |= SWX_OUT_1_30;
pmic_reg_write(p, REG_SW_1, val);
/* Set VDDA to 1.3V for TO2 */
pmic_reg_read(p, REG_SW_2, &val);
val &= ~SWX_OUT_MASK;
val |= SWX_OUT_1_30;
pmic_reg_write(p, REG_SW_2, val);
}
}
void ldo_mode_set(int ldo_bypass)
{
unsigned int value;
u32 vddarm;
struct pmic *p = pfuze;
if (!p) {
printf("No PMIC found!\n");
return;
}
/* switch to ldo_bypass mode */
if (ldo_bypass) {
prep_anatop_bypass();
/* decrease VDDARM to 1.275V */
pmic_reg_read(pfuze, PFUZE300_SW1BVOLT, &value);
value &= ~0x1f;
value |= PFUZE300_SW1AB_SETP(1275);
pmic_reg_write(pfuze, PFUZE300_SW1BVOLT, value);
set_anatop_bypass(1);
vddarm = PFUZE300_SW1AB_SETP(1175);
pmic_reg_read(pfuze, PFUZE300_SW1BVOLT, &value);
value &= ~0x1f;
value |= vddarm;
pmic_reg_write(pfuze, PFUZE300_SW1BVOLT, value);
finish_anatop_bypass();
printf("switch to ldo_bypass mode!\n");
}
}
void ldo_mode_set(int ldo_bypass)
{
unsigned int value;
struct pmic *p = pfuze;
if (!p) {
printf("No PMIC found!\n");
return;
}
/* switch to ldo_bypass mode */
if (ldo_bypass) {
/* decrease VDDARM to 1.15V */
pmic_reg_read(p, PFUZE100_SW1ABVOL, &value);
value &= ~0x3f;
value |= PFUZE100_SW1ABC_SETP(11500);
pmic_reg_write(p, PFUZE100_SW1ABVOL, value);
/* decrease VDDSOC to 1.15V */
pmic_reg_read(p, PFUZE100_SW1CVOL, &value);
value &= ~0x3f;
value |= PFUZE100_SW1ABC_SETP(11500);
pmic_reg_write(p, PFUZE100_SW1CVOL, value);
set_anatop_bypass(1);
printf("switch to ldo_bypass mode!\n");
}
}
void pmic_88pm886_base_init(struct pmic *p_base)
{
u32 data;
/* disable watchdog */
pmic_update_bits(p_base, 0x1d, (1 << 0), (1 << 0));
/*----following setting is for Audio Codec ---*/
/* enable 32Khz low jitter XO_LJ = 1 */
pmic_update_bits(p_base, 0x21, (1 << 5), (1 << 5));
/* enable USE_XO = 1 */
pmic_update_bits(p_base, 0xd0, (1 << 7), (1 << 7));
/* output 32k from XO */
pmic_update_bits(p_base, 0xe2, 0xf, 0xa);
/* read-clear interruption registers */
pmic_reg_read(p_base, PM886_REG_INT1, &data);
pmic_reg_read(p_base, PM886_REG_INT2, &data);
pmic_reg_read(p_base, PM886_REG_INT3, &data);
pmic_reg_read(p_base, PM886_REG_INT4, &data);
/*
* print out power up/down log and save in memory
* the power up log has little change vesus to
* 88pm820/88pm860
*/
get_powerup_down_log(g_chip);
}
int rtc_get(struct rtc_time *rtc)
{
u32 day1, day2, time;
int tim, i = 0;
struct pmic *p = pmic_get("FSL_PMIC");
int ret;
if (!p)
return -1;
do {
ret = pmic_reg_read(p, REG_RTC_DAY, &day1);
if (ret < 0)
return -1;
ret = pmic_reg_read(p, REG_RTC_TIME, &time);
if (ret < 0)
return -1;
ret = pmic_reg_read(p, REG_RTC_DAY, &day2);
if (ret < 0)
return -1;
} while (day1 != day2 && i++ < 3);
tim = day1 * 86400 + time;
rtc_to_tm(tim, rtc);
rtc->tm_yday = 0;
rtc->tm_isdst = 0;
return 0;
}
int power_init_board(void)
{
struct pmic *p;
unsigned int reg, ret;
p = pfuze_common_init(I2C_PMIC);
if (!p)
return -ENODEV;
ret = pfuze_mode_init(p, APS_PFM);
if (ret < 0)
return ret;
/* Increase VGEN3 from 2.5 to 2.8V */
pmic_reg_read(p, PFUZE100_VGEN3VOL, ®);
reg &= ~LDO_VOL_MASK;
reg |= LDOB_2_80V;
pmic_reg_write(p, PFUZE100_VGEN3VOL, reg);
/* Increase VGEN5 from 2.8 to 3V */
pmic_reg_read(p, PFUZE100_VGEN5VOL, ®);
reg &= ~LDO_VOL_MASK;
reg |= LDOB_3_00V;
pmic_reg_write(p, PFUZE100_VGEN5VOL, reg);
return 0;
}
static int pfuze100_regulator_mode(struct udevice *dev, int op, int *opmode)
{
int val;
struct pfuze100_regulator_platdata *plat = dev_get_platdata(dev);
struct pfuze100_regulator_desc *desc = plat->desc;
if (op == PMIC_OP_GET) {
if (desc->type == REGULATOR_TYPE_BUCK) {
if (!strcmp(dev->name, "swbst")) {
val = pmic_reg_read(dev->parent,
desc->vsel_reg);
if (val < 0)
return val;
val &= SWBST_MODE_MASK;
val >>= SWBST_MODE_SHIFT;
*opmode = val;
return 0;
}
val = pmic_reg_read(dev->parent,
desc->vsel_reg +
PFUZE100_MODE_OFFSET);
if (val < 0)
return val;
val &= SW_MODE_MASK;
val >>= SW_MODE_SHIFT;
*opmode = val;
return 0;
} else if (desc->type == REGULATOR_TYPE_LDO) {
/* setup board specific PMIC */
int power_init_board(void)
{
struct pmic *p;
u32 reg;
int ret;
power_pfuze100_init(1);
p = pmic_get("PFUZE100");
if (!p)
return -EINVAL;
ret = pmic_probe(p);
if (ret)
return ret;
pmic_reg_read(p, PFUZE100_DEVICEID, ®);
printf("PMIC: PFUZE100 ID=0x%02x\n", reg);
/* Set SWBST to 5.0V and enable (for USB) */
pmic_reg_read(p, PFUZE100_SWBSTCON1, ®);
reg &= ~(SWBST_MODE_MASK | SWBST_VOL_MASK);
reg |= (SWBST_5_00V | SWBST_MODE_AUTO);
pmic_reg_write(p, PFUZE100_SWBSTCON1, reg);
return 0;
}
void pmic_88pm880_base_init(struct pmic *p_base)
{
u32 data;
/* disable watchdog */
pmic_update_bits(p_base, PM880_REG_WDOG, PM880_REG_WDOG_DIS, PM880_REG_WDOG_DIS);
/*----following setting is for Audio Codec ---*/
/* enable 32Khz low jitter XO_LJ = 1 */
pmic_update_bits(p_base, PM880_REG_LOWPOWER2, PM880_REG_XO_LJ, PM880_REG_XO_LJ);
/* enable USE_XO = 1 */
pmic_update_bits(p_base, PM880_REG_RTC_CTRL1, PM880_REG_USE_XO, PM880_REG_USE_XO);
/* output 32k from XO */
pmic_update_bits(p_base, PM880_REG_AON_CTRL2, PM880_CLK32K2_SEL_MASK, PM880_CLK32K2_SEL_32);
/* read-clear interruption registers */
pmic_reg_read(p_base, PM880_REG_INT1, &data);
pmic_reg_read(p_base, PM880_REG_INT2, &data);
pmic_reg_read(p_base, PM880_REG_INT3, &data);
pmic_reg_read(p_base, PM880_REG_INT4, &data);
/* turn on cfd clock, so we could turn off CFD_PLS_EN later */
pmic_update_bits(p_base, PM880_REG_CLK_CTRL_1, PM880_CFD_CLK_EN, PM880_CFD_CLK_EN);
/*
* print out power up/down log and save in memory
* the power up log has little change vesus to
* 88pm820/88pm860/88pm880
*/
get_powerup_down_log(g_chip);
}
void exynos_lcd_power_on(void)
{
struct udevice *dev;
int ret;
u8 reg;
ret = pmic_get("max8998-pmic", &dev);
if (ret) {
puts("Failed to get MAX8998!\n");
return;
}
reg = pmic_reg_read(dev, MAX8998_REG_ONOFF3);
reg |= MAX8998_LDO17;
ret = pmic_reg_write(dev, MAX8998_REG_ONOFF3, reg);
if (ret) {
puts("MAX8998 LDO setting error\n");
return;
}
reg = pmic_reg_read(dev, MAX8998_REG_ONOFF2);
reg |= MAX8998_LDO7;
ret = pmic_reg_write(dev, MAX8998_REG_ONOFF2, reg);
if (ret) {
puts("MAX8998 LDO setting error\n");
return;
}
}
static int pmic_clk_enable(struct clk_hw *hw)
{
struct pmic_clk *clk_pmic = container_of(hw, struct pmic_clk, hw);
u32 reg_val = 0;
unsigned long rfclk_flag = 0;
spin_lock_irqsave(&g_pmic_xoinfo.xorf_lock, rfclk_flag);
/* 打开前写0 */
pmic_reg_read(clk_pmic->freq_addr_offset, ®_val);
reg_val &= (~(clk_pmic->freq_mask));
pmic_reg_write(clk_pmic->freq_addr_offset, reg_val);
/*enable clk*/
pmic_mutli_core_lock();
pmic_reg_read(clk_pmic->en_dis_offset, ®_val);
reg_val |= (((u32)0x1) << clk_pmic->en_dis_bit);
pmic_reg_write(clk_pmic->en_dis_offset, reg_val);
pmic_mutli_core_unlock();
/*delay 6us*/
udelay(clk_pmic->delay_us);
/* 打开后写1 */
pmic_reg_read(clk_pmic->freq_addr_offset, ®_val);
reg_val |= clk_pmic->freq_mask;
pmic_reg_write(clk_pmic->freq_addr_offset, reg_val);
spin_unlock_irqrestore(&g_pmic_xoinfo.xorf_lock, rfclk_flag);
return 0;
}
static int power_init(void)
{
unsigned int val;
int ret = -1;
struct pmic *p;
if (!i2c_probe(CONFIG_SYS_DIALOG_PMIC_I2C_ADDR)) {
pmic_dialog_init();
p = get_pmic();
/* Set VDDA to 1.25V */
val = DA9052_BUCKCORE_BCOREEN | DA_BUCKCORE_VBCORE_1_250V;
ret = pmic_reg_write(p, DA9053_BUCKCORE_REG, val);
ret |= pmic_reg_read(p, DA9053_SUPPLY_REG, &val);
val |= DA9052_SUPPLY_VBCOREGO;
ret |= pmic_reg_write(p, DA9053_SUPPLY_REG, val);
/* Set Vcc peripheral to 1.30V */
ret |= pmic_reg_write(p, DA9053_BUCKPRO_REG, 0x62);
ret |= pmic_reg_write(p, DA9053_SUPPLY_REG, 0x62);
}
if (!i2c_probe(CONFIG_SYS_FSL_PMIC_I2C_ADDR)) {
pmic_init();
p = get_pmic();
/* Set VDDGP to 1.25V for 1GHz on SW1 */
pmic_reg_read(p, REG_SW_0, &val);
val = (val & ~SWx_VOLT_MASK_MC34708) | SWx_1_250V_MC34708;
ret = pmic_reg_write(p, REG_SW_0, val);
/* Set VCC as 1.30V on SW2 */
pmic_reg_read(p, REG_SW_1, &val);
val = (val & ~SWx_VOLT_MASK_MC34708) | SWx_1_300V_MC34708;
ret |= pmic_reg_write(p, REG_SW_1, val);
/* Set global reset timer to 4s */
pmic_reg_read(p, REG_POWER_CTL2, &val);
val = (val & ~TIMER_MASK_MC34708) | TIMER_4S_MC34708;
ret |= pmic_reg_write(p, REG_POWER_CTL2, val);
/* Set VUSBSEL and VUSBEN for USB PHY supply*/
pmic_reg_read(p, REG_MODE_0, &val);
val |= (VUSBSEL_MC34708 | VUSBEN_MC34708);
ret |= pmic_reg_write(p, REG_MODE_0, val);
/* Set SWBST to 5V in auto mode */
val = SWBST_AUTO;
ret |= pmic_reg_write(p, SWBST_CTRL, val);
}
return ret;
}
void board_pmic_power_fixup(struct pmic *p_power)
{
u32 val;
/* Set VCC_main(buck1) as 1.2v*/
val = 0x30;
pmic_reg_write(p_power, 0x3c, val);
pmic_reg_write(p_power, 0x3d, val);
pmic_reg_write(p_power, 0x3e, val);
pmic_reg_write(p_power, 0x3f, val);
/* Set buck4 as 1.8V */
val = 0x54;
pmic_reg_write(p_power, 0x42, val);
pmic_reg_write(p_power, 0x43, val);
pmic_reg_write(p_power, 0x44, val);
pmic_reg_write(p_power, 0x45, val);
/* Set buck1 ramp up speed to 12.5mV/us */
pmic_reg_read(p_power, 0x78, &val);
val &= ~(7 << 3);
val |= (0x6 << 3);
pmic_reg_write(p_power, 0x78, val);
/* Set buck1 audio mode as 0.8V */
val = 0x10;
pmic_reg_write(p_power, 0x38, val);
/* enable buck1 sleep modewhen SLEEpn = '0' */
pmic_reg_read(p_power, 0x5a, &val);
val &= 0xfc;
val |= 0x2;
pmic_reg_write(p_power, 0x5a, val);
/* Set LDO8 as 3.1V for LCD */
marvell88pm_set_ldo_vol(p_power, 8, 3100000);
/* Set LDO12 as 3.0V for SD IO/bus */
marvell88pm_set_ldo_vol(p_power, 12, 3000000);
/* Set LDO13 as 3.0V for SD Card */
marvell88pm_set_ldo_vol(p_power, 13, 3000000);
/* Set LDO14 as 3.0V for eMMC */
marvell88pm_set_ldo_vol(p_power, 14, 3000000);
/* Set LDO15 as 1.8V for LCD */
marvell88pm_set_ldo_vol(p_power, 15, 1800000);
/* Set vbuck1 sleep voltage is 0.8V */
val = 0x10;
pmic_reg_write(p_power, 0x30, val);
}
void ldo_mode_set(int ldo_bypass)
{
u32 value;
int is_400M;
struct pmic *p = pfuze;
if (!p) {
printf("No pmic!\n");
return;
}
/* swith to ldo_bypass mode */
if (ldo_bypass) {
prep_anatop_bypass();
/* decrease VDDARM to 1.1V */
pmic_reg_read(p, PFUZE100_SW1ABVOL, &value);
value &= ~0x3f;
value |= 0x20;
pmic_reg_write(p, PFUZE100_SW1ABVOL, value);
/* increase VDDSOC to 1.3V */
pmic_reg_read(p, PFUZE100_SW1CVOL, &value);
value &= ~0x3f;
value |= 0x28;
pmic_reg_write(p, PFUZE100_SW1CVOL, value);
is_400M = set_anatop_bypass(0);
/*
* MX6SL: VDDARM:1.175V@800M; VDDSOC:1.175V@800M
* VDDARM:0.975V@400M; VDDSOC:1.175V@400M
*/
pmic_reg_read(p, PFUZE100_SW1ABVOL, &value);
value &= ~0x3f;
if (is_400M)
value |= 0x1b;
else
value |= 0x23;
pmic_reg_write(p, PFUZE100_SW1ABVOL, value);
/* decrease VDDSOC to 1.175V */
pmic_reg_read(p, PFUZE100_SW1CVOL, &value);
value &= ~0x3f;
value |= 0x23;
pmic_reg_write(p, PFUZE100_SW1CVOL, value);
finish_anatop_bypass();
printf("switch to ldo_bypass mode!\n");
}
}
static int s5pc1xx_phy_control(int on)
{
struct udevice *dev;
static int status;
int reg, ret;
ret = pmic_get("max8998-pmic", &dev);
if (ret)
return ret;
if (on && !status) {
reg = pmic_reg_read(dev, MAX8998_REG_ONOFF1);
reg |= MAX8998_LDO3;
ret = pmic_reg_write(dev, MAX8998_REG_ONOFF1, reg);
if (ret) {
puts("MAX8998 LDO setting error!\n");
return -EINVAL;
}
reg = pmic_reg_read(dev, MAX8998_REG_ONOFF2);
reg |= MAX8998_LDO8;
ret = pmic_reg_write(dev, MAX8998_REG_ONOFF2, reg);
if (ret) {
puts("MAX8998 LDO setting error!\n");
return -EINVAL;
}
status = 1;
} else if (!on && status) {
reg = pmic_reg_read(dev, MAX8998_REG_ONOFF1);
reg &= ~MAX8998_LDO3;
ret = pmic_reg_write(dev, MAX8998_REG_ONOFF1, reg);
if (ret) {
puts("MAX8998 LDO setting error!\n");
return -EINVAL;
}
reg = pmic_reg_read(dev, MAX8998_REG_ONOFF2);
reg &= ~MAX8998_LDO8;
ret = pmic_reg_write(dev, MAX8998_REG_ONOFF2, reg);
if (ret) {
puts("MAX8998 LDO setting error!\n");
return -EINVAL;
}
status = 0;
}
udelay(10000);
return 0;
}
static int adc_power_control(int on)
{
struct udevice *dev;
int ret;
u8 reg;
ret = pmic_get("max8998-pmic", &dev);
if (ret) {
puts("Failed to get MAX8998!\n");
return ret;
}
reg = pmic_reg_read(dev, MAX8998_REG_ONOFF1);
if (on)
reg |= MAX8998_LDO4;
else
reg &= ~MAX8998_LDO4;
ret = pmic_reg_write(dev, MAX8998_REG_ONOFF1, reg);
if (ret) {
puts("MAX8998 LDO setting error\n");
return -EINVAL;
}
return 0;
}
static int onkey_state(struct pmic *p_base)
{
u32 status_reg1;
pmic_reg_read(p_base, PM880_REG_STATUS, &status_reg1);
return (status_reg1 & ONKEY_STATUS)?1:0;
}
static int power_key_pressed(u32 reg)
{
struct pmic *pmic;
u32 status;
u32 mask;
pmic = pmic_get(KEY_PWR_PMIC_NAME);
if (!pmic) {
printf("%s: Not found\n", KEY_PWR_PMIC_NAME);
return 0;
}
if (pmic_probe(pmic))
return 0;
if (reg == KEY_PWR_STATUS_REG)
mask = KEY_PWR_STATUS_MASK;
else
mask = KEY_PWR_INTERRUPT_MASK;
if (pmic_reg_read(pmic, reg, &status))
return 0;
return !!(status & mask);
}
static int power_chrg_get_type(struct pmic *p)
{
unsigned int val;
unsigned int charge_type, charger;
/* if probe failed, return cable none */
if (pmic_probe(p))
return CHARGER_NO;
pmic_reg_read(p, MAX77693_MUIC_STATUS2, &val);
charge_type = val & MAX77693_MUIC_CHG_MASK;
switch (charge_type) {
case MAX77693_MUIC_CHG_NO:
charger = CHARGER_NO;
break;
case MAX77693_MUIC_CHG_USB:
case MAX77693_MUIC_CHG_USB_D:
charger = CHARGER_USB;
break;
case MAX77693_MUIC_CHG_TA:
case MAX77693_MUIC_CHG_TA_1A:
charger = CHARGER_TA;
break;
case MAX77693_MUIC_CHG_TA_500:
charger = CHARGER_TA_500;
break;
default:
charger = CHARGER_UNKNOWN;
break;
}
return charger;
}
/**
* Interface to enable/disable PMIC USB type detection
*
* @pdata Pointer to the charger type detection driver data structure
* @enable Whether to enable/disable USB type detection
* return 0 on success, otherwise error code
*/
static int pmic_usb_enable_usb_det(struct pmic_usb_det_data *pdata, bool enable)
{
int ret;
u8 reg;
if (!pdata || !pdata->pdev)
return -EINVAL;
ret = pmic_reg_read(DEV3, USBPHYCTRL, ®);
if (ret) {
dev_err(pdata->pdev, "%s - fail to read DEV3 USBPHYCTRL\n",
__func__);
return ret;
}
if (enable) {
set_field(reg, USBPHYRSTB_O, 1, CLEAR);
set_field(reg, CTYP_DIS_O, 1, CLEAR);
} else {
set_field(reg, USBPHYRSTB_O, 1, SET);
set_field(reg, CTYP_DIS_O, 1, SET);
}
ret = pmic_reg_write(DEV3, USBPHYCTRL, reg);
if (ret) {
dev_err(pdata->pdev, "%s - fail to write DEV3 USBPHYCTRL\n",
__func__);
return ret;
}
return 0;
}
static int lp873x_buck_enable(struct udevice *dev, int op, bool *enable)
{
int ret;
unsigned int adr;
struct dm_regulator_uclass_platdata *uc_pdata;
uc_pdata = dev_get_uclass_platdata(dev);
adr = uc_pdata->ctrl_reg;
ret = pmic_reg_read(dev->parent, adr);
if (ret < 0)
return ret;
if (op == PMIC_OP_GET) {
ret &= LP873X_BUCK_MODE_MASK;
if (ret)
*enable = true;
else
*enable = false;
return 0;
} else if (op == PMIC_OP_SET) {
if (*enable)
ret |= LP873X_BUCK_MODE_MASK;
else
ret &= ~(LP873X_BUCK_MODE_MASK);
ret = pmic_reg_write(dev->parent, adr, ret);
if (ret)
return ret;
}
return 0;
}
int max77686_set_buck_voltage(struct pmic *p, int buck, ulong uV)
{
unsigned int val, adr;
int hex, ret;
if (buck < 5 || buck > 9) {
printf("%s: %d is an unsupported bucket number\n",
__func__, buck);
return -EINVAL;
}
adr = max77686_buck_addr[buck] + 1;
hex = max77686_buck_volt2hex(buck, uV);
if (hex < 0)
return hex;
ret = pmic_reg_read(p, adr, &val);
if (ret)
return ret;
val &= ~MAX77686_BUCK_VOLT_MASK;
ret |= pmic_reg_write(p, adr, val | hex);
return ret;
}
/**
* Set the power state for a FET
*
* @param pmic pmic structure for the tps65090
* @param fet_id Fet number to set (1..MAX_FET_NUM)
* @param set 1 to power on FET, 0 to power off
* @return -EIO if we got a comms error, -EAGAIN if the FET failed to
* change state. If all is ok, returns 0.
*/
static int tps65090_fet_set(struct pmic *pmic, int fet_id, bool set)
{
int retry;
u32 reg, value;
value = FET_CTRL_ADENFET | FET_CTRL_WAIT;
if (set)
value |= FET_CTRL_ENFET;
if (pmic_reg_write(pmic, REG_FET1_CTRL + fet_id - 1, value))
return -EIO;
/* Try reading until we get a result */
for (retry = 0; retry < MAX_CTRL_READ_TRIES; retry++) {
if (pmic_reg_read(pmic, REG_FET1_CTRL + fet_id - 1, ®))
return -EIO;
/* Check that the fet went into the expected state */
if (!!(reg & FET_CTRL_PGFET) == set)
return 0;
/* If we got a timeout, there is no point in waiting longer */
if (reg & FET_CTRL_TOFET)
break;
mdelay(1);
}
debug("FET %d: Power good should have set to %d but reg=%#02x\n",
fet_id, set, reg);
return -EAGAIN;
}
int max77686_set_ldo_voltage(struct pmic *p, int ldo, ulong uV)
{
unsigned int val, ret, hex, adr;
if (ldo < 1 || ldo > 26) {
printf("%s: %d is wrong ldo number\n", __func__, ldo);
return -1;
}
adr = MAX77686_REG_PMIC_LDO1CTRL1 + ldo - 1;
hex = max77686_ldo_volt2hex(ldo, uV);
if (!hex)
return -1;
ret = pmic_reg_read(p, adr, &val);
if (ret)
return ret;
val &= ~MAX77686_LDO_VOLT_MASK;
val |= hex;
ret |= pmic_reg_write(p, adr, val);
return ret;
}
int max77686_set_ldo_mode(struct pmic *p, int ldo, char opmode)
{
unsigned int val, ret, adr, mode;
if (ldo < 1 || 26 < ldo) {
printf("%s: %d is wrong ldo number\n", __func__, ldo);
return -1;
}
adr = MAX77686_REG_PMIC_LDO1CTRL1 + ldo - 1;
/* mode */
switch (opmode) {
case OPMODE_OFF:
mode = MAX77686_LDO_MODE_OFF;
break;
case OPMODE_STANDBY:
switch (ldo) {
case 2:
case 6:
case 7:
case 8:
case 10:
case 11:
case 12:
case 14:
case 15:
case 16:
mode = MAX77686_LDO_MODE_STANDBY;
break;
default:
mode = 0xff;
}
break;
case OPMODE_LPM:
mode = MAX77686_LDO_MODE_LPM;
break;
case OPMODE_ON:
mode = MAX77686_LDO_MODE_ON;
break;
default:
mode = 0xff;
}
if (mode == 0xff) {
printf("%s: %d is not supported on LDO%d\n",
__func__, opmode, ldo);
return -1;
}
ret = pmic_reg_read(p, adr, &val);
if (ret)
return ret;
val &= ~MAX77686_LDO_MODE_MASK;
val |= mode;
ret |= pmic_reg_write(p, adr, val);
return ret;
}
/**
* Interface to enable/disable USBID and ACA detection
*
* @pdata Pointer to the charger type detection driver data structure
* @id_enable Whether to enable/disable USBID detection
* @aca_enable Whether to enable/disable ACA detection
* return 0 on success, otherwise error code
*/
static int pmic_usb_enable_id_aca_det(struct pmic_usb_det_data *pdata,
bool id_enable, bool aca_enable)
{
int ret;
u8 reg;
if (!pdata || !pdata->pdev)
return -EINVAL;
ret = pmic_reg_read(DEV3, USBIDCTRL, ®);
if (ret) {
dev_err(pdata->pdev, "%s - fail to read DEV3 USBIDCTRL\n",
__func__);
return ret;
}
if (id_enable) {
set_field(reg, USB_IDEN_O, 1, SET);
if (aca_enable)
set_field(reg, ACA_DETEN_O, 1, SET);
} else {
set_field(reg, USB_IDEN_O, 1, CLEAR);
set_field(reg, ACA_DETEN_O, 1, CLEAR);
}
ret = pmic_reg_write(DEV3, USBIDCTRL, reg);
if (ret) {
dev_err(pdata->pdev, "%s - fail to write DEV3 USBIDCTRL\n",
__func__);
return ret;
}
return 0;
}
static int palmas_ldo_bypass_enable(struct udevice *dev, bool enabled)
{
int type = dev_get_driver_data(dev_get_parent(dev));
struct dm_regulator_uclass_platdata *p;
unsigned int adr;
int reg;
if (type == TPS65917) {
/* bypass available only on LDO1 and LDO2 */
if (dev->driver_data > 2)
return -ENOTSUPP;
} else if (type == TPS659038) {
/* bypass available only on LDO9 */
if (dev->driver_data != 9)
return -ENOTSUPP;
}
p = dev_get_uclass_platdata(dev);
adr = p->ctrl_reg;
reg = pmic_reg_read(dev->parent, adr);
if (reg < 0)
return reg;
if (enabled)
reg |= PALMAS_LDO_BYPASS_EN;
else
reg &= ~PALMAS_LDO_BYPASS_EN;
return pmic_reg_write(dev->parent, adr, reg);
}
/* setup board specific PMIC */
int power_init_board(void)
{
struct pmic *p;
u32 id1, id2, i;
int ret;
char const *lv_mipi;
/* configure I2C multiplexer */
gpio_direction_output(MX6Q_QMX6_PFUZE_MUX, 1);
power_pfuze100_init(I2C_PMIC);
p = pmic_get("PFUZE100");
if (!p)
return -EINVAL;
ret = pmic_probe(p);
if (ret)
return ret;
pmic_reg_read(p, PFUZE100_DEVICEID, &id1);
pmic_reg_read(p, PFUZE100_REVID, &id2);
printf("PFUZE100 Rev. [%02x/%02x] detected\n", id1, id2);
if (id2 >= 0x20)
return 0;
/* set level of MIPI if specified */
lv_mipi = getenv("lv_mipi");
if (lv_mipi)
return 0;
for (i = 0; i < ARRAY_SIZE(mipi_levels); i++) {
if (!strcmp(mipi_levels[i].name, lv_mipi)) {
printf("set MIPI level %s\n",
mipi_levels[i].name);
ret = pmic_reg_write(p, PFUZE100_VGEN4VOL,
mipi_levels[i].value);
if (ret)
return ret;
}
}
return 0;
}