/* setup board specific PMIC */
int power_init_board(void)
{
int rc;
#ifndef CONFIG_DM_I2C
struct pmic *p = NULL;
#endif
if (board_is_idk()) {
rc = power_tps62362_init(0);
if (rc)
goto done;
#ifndef CONFIG_DM_I2C
p = pmic_get("TPS62362");
if (!p || pmic_probe(p))
goto done;
#endif
puts("PMIC: TPS62362\n");
} else {
rc = power_tps65218_init(0);
if (rc)
goto done;
#ifndef CONFIG_DM_I2C
p = pmic_get("TPS65218_PMIC");
if (!p || pmic_probe(p))
goto done;
#endif
puts("PMIC: TPS65218\n");
}
done:
return 0;
}
int pmic_88pm880_init(struct pmic_chip_desc *chip)
{
struct pmic *p_base, *p_buck, *p_ldo, *p_gpadc, *p_led;
if (!chip) {
printf("---%s: chip is empty.\n", __func__);
return -EINVAL;
}
/*------------base page setting-----------*/
p_base = pmic_get(chip->base_name);
if (!p_base)
return -1;
if (pmic_probe(p_base))
return -1;
pmic_88pm880_base_init(p_base);
board_pmic_base_fixup(p_base);
/*------------gpadc page setting -----------*/
p_gpadc = pmic_get(chip->gpadc_name);
if (!p_gpadc)
return -1;
if (pmic_probe(p_gpadc))
return -1;
pmic_88pm880_gpadc_init(p_gpadc);
board_pmic_gpadc_fixup(p_gpadc);
/*------------buck page setting -----------*/
p_buck = pmic_get(chip->buck_name);
if (!p_buck)
return -1;
if (pmic_probe(p_buck))
return -1;
pmic_88pm880_buck_init(p_buck);
board_pmic_buck_fixup(p_buck);
/*------------ldo page setting ------------*/
p_ldo = pmic_get(chip->ldo_name);
if (!p_ldo)
return -1;
if (pmic_probe(p_ldo))
return -1;
pmic_88pm880_ldo_init(p_ldo);
board_pmic_ldo_fixup(p_ldo);
/*------------led page setting ------------*/
p_led = pmic_get(chip->led_name);
if (!p_led)
return -1;
if (pmic_probe(p_led))
return -1;
pmic_88pm880_led_init(p_led);
printf("PMIC init done!\n");
return 0;
}
int exynos_power_init(void)
{
struct udevice *dev;
int ret;
ret = pmic_get("max77686", &dev);
if (!ret) {
/* TODO([email protected]): Move into the clock/pmic API */
ret = pmic_clrsetbits(dev, MAX77686_REG_PMIC_32KHZ, 0,
MAX77686_32KHCP_EN);
if (ret)
return ret;
ret = pmic_clrsetbits(dev, MAX77686_REG_PMIC_BBAT, 0,
MAX77686_BBCHOSTEN | MAX77686_BBCVS_3_5V);
if (ret)
return ret;
} else {
ret = pmic_get("s5m8767-pmic", &dev);
/* TODO([email protected]): Use driver model to access clock */
#ifdef CONFIG_PMIC_S5M8767
if (!ret)
s5m8767_enable_32khz_cp(dev);
#endif
}
if (ret == -ENODEV)
return 0;
ret = regulators_enable_boot_on(false);
if (ret)
return ret;
ret = exynos_set_regulator("vdd_mif", 1100000);
if (ret)
return ret;
/*
* This would normally be 1.3V, but since we are running slowly 1.1V
* is enough. For spring it helps reduce CPU temperature and avoid
* hangs with the case open. 1.1V is minimum voltage borderline for
* chained bootloaders.
*/
ret = exynos_set_regulator("vdd_arm", 1100000);
if (ret)
return ret;
ret = exynos_set_regulator("vdd_int", 1012500);
if (ret)
return ret;
ret = exynos_set_regulator("vdd_g3d", 1200000);
if (ret)
return ret;
return 0;
}
int press_onkey_check(struct pmic_chip_desc *chip, int bootdelay)
{
int pressed;
int flag = 0;
struct pmic *p_base;
p_base = pmic_get(chip->base_name);
if (!p_base || pmic_probe(p_base)) {
printf("access pmic failed...\n");
return 0;
}
pressed = onkey_state(p_base);
while (bootdelay > 0) {
int i = 0;
--bootdelay;
if (pressed == 0) {
flag = 1;
break;
}
for (i = 0; i < 2; ++i)
udelay(10000);
pressed = onkey_state(p_base);
}
if (flag == 1) {
printf("Power key is pressed by mistake.Power down device here.\n");
pmic_pm880_powerdown(p_base);
return 0;
} else
return flag;
}
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;
}
int board_usb_init(int index, enum usb_init_type init)
{
#ifdef CONFIG_CMD_USB
struct pmic *p_pmic;
/* Set Ref freq 0 => 24MHz, 1 => 26MHz*/
/* Odroid Us have it at 24MHz, Odroid Xs at 26MHz */
if (gd->board_type == ODROID_TYPE_U3)
gpio_direction_output(EXYNOS4X12_GPIO_X30, 0);
else
gpio_direction_output(EXYNOS4X12_GPIO_X30, 1);
/* Disconnect, Reset, Connect */
gpio_direction_output(EXYNOS4X12_GPIO_X34, 0);
gpio_direction_output(EXYNOS4X12_GPIO_X35, 0);
gpio_direction_output(EXYNOS4X12_GPIO_X35, 1);
gpio_direction_output(EXYNOS4X12_GPIO_X34, 1);
/* Power off and on BUCK8 for LAN9730 */
debug("LAN9730 - Turning power buck 8 OFF and ON.\n");
p_pmic = pmic_get("MAX77686_PMIC");
if (p_pmic && !pmic_probe(p_pmic)) {
max77686_set_buck_voltage(p_pmic, 8, 750000);
max77686_set_buck_voltage(p_pmic, 8, 3300000);
}
#endif
debug("USB_udc_probe\n");
return s3c_udc_probe(&s5pc210_otg_data);
}
/* 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;
}
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 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;
}
}
/* Test PMIC I/O */
static int dm_test_power_pmic_io(struct unit_test_state *uts)
{
const char *name = "sandbox_pmic";
uint8_t out_buffer, in_buffer;
struct udevice *dev;
int reg_count, i;
ut_assertok(pmic_get(name, &dev));
reg_count = pmic_reg_count(dev);
ut_asserteq(reg_count, SANDBOX_PMIC_REG_COUNT);
/*
* Test PMIC I/O - write and read a loop counter.
* usually we can't write to all PMIC's registers in the real hardware,
* but we can to the sandbox pmic.
*/
for (i = 0; i < reg_count; i++) {
out_buffer = i;
ut_assertok(pmic_write(dev, i, &out_buffer, 1));
ut_assertok(pmic_read(dev, i, &in_buffer, 1));
ut_asserteq(out_buffer, in_buffer);
}
return 0;
}
static int power_init(void)
{
struct udevice *dev;
int ret;
ret = pmic_get("mc34708", &dev);
if (ret) {
printf("%s: mc34708 not found !\n", __func__);
return ret;
}
/* Set VDDGP to 1.110V for 800 MHz on SW1 */
pmic_clrsetbits(dev, REG_SW_0, SWx_VOLT_MASK_MC34708,
SWx_1_110V_MC34708);
/* Set VCC as 1.30V on SW2 */
pmic_clrsetbits(dev, REG_SW_1, SWx_VOLT_MASK_MC34708,
SWx_1_300V_MC34708);
/* Set global reset timer to 4s */
pmic_clrsetbits(dev, REG_POWER_CTL2, TIMER_MASK_MC34708,
TIMER_4S_MC34708);
return ret;
}
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);
}
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 exynos_power_init(void)
{
struct udevice *dev;
int ret;
ret = pmic_get("max77686", &dev);
if (!ret) {
/* TODO([email protected]): Move into the clock/pmic API */
ret = pmic_clrsetbits(dev, MAX77686_REG_PMIC_32KHZ, 0,
MAX77686_32KHCP_EN);
if (ret)
return ret;
ret = pmic_clrsetbits(dev, MAX77686_REG_PMIC_BBAT, 0,
MAX77686_BBCHOSTEN | MAX77686_BBCVS_3_5V);
if (ret)
return ret;
} else {
ret = pmic_get("s5m8767-pmic", &dev);
/* TODO([email protected]): Use driver model to access clock */
#ifdef CONFIG_PMIC_S5M8767
if (!ret)
s5m8767_enable_32khz_cp(dev);
#endif
}
if (ret == -ENODEV)
return 0;
ret = regulators_enable_boot_on(false);
if (ret)
return ret;
ret = exynos_set_regulator("vdd_mif", 1100000);
if (ret)
return ret;
ret = exynos_set_regulator("vdd_arm", 1300000);
if (ret)
return ret;
ret = exynos_set_regulator("vdd_int", 1012500);
if (ret)
return ret;
ret = exynos_set_regulator("vdd_g3d", 1200000);
if (ret)
return ret;
return 0;
}
int g_dnl_board_usb_cable_connected(void)
{
struct pmic *muic = pmic_get("MAX77693_MUIC");
if (!muic)
return 0;
return !!muic->chrg->chrg_type(muic);
}
int usb_cable_connected(void)
{
struct pmic *muic = pmic_get("MAX8997_MUIC");
if (!muic)
return 0;
return !!muic->chrg->chrg_type(muic);
}
static int s5pc210_phy_control(int on)
{
struct udevice *dev;
int reg, ret;
ret = pmic_get("max8997-pmic", &dev);
if (ret)
return ret;
if (on) {
reg = pmic_reg_read(dev, MAX8997_REG_SAFEOUTCTRL);
reg |= ENSAFEOUT1;
ret = pmic_reg_write(dev, MAX8997_REG_SAFEOUTCTRL, reg);
if (ret) {
puts("MAX8997 setting error!\n");
return ret;
}
reg = pmic_reg_read(dev, MAX8997_REG_LDO3CTRL);
reg |= EN_LDO;
ret = pmic_reg_write(dev, MAX8997_REG_LDO3CTRL, reg);
if (ret) {
puts("MAX8997 setting error!\n");
return ret;
}
reg = pmic_reg_read(dev, MAX8997_REG_LDO8CTRL);
reg |= EN_LDO;
ret = pmic_reg_write(dev, MAX8997_REG_LDO8CTRL, reg);
if (ret) {
puts("MAX8997 setting error!\n");
return ret;
}
} else {
reg = pmic_reg_read(dev, MAX8997_REG_LDO8CTRL);
reg &= DIS_LDO;
ret = pmic_reg_write(dev, MAX8997_REG_LDO8CTRL, reg);
if (ret) {
puts("MAX8997 setting error!\n");
return ret;
}
reg = pmic_reg_read(dev, MAX8997_REG_LDO3CTRL);
reg &= DIS_LDO;
ret = pmic_reg_write(dev, MAX8997_REG_LDO3CTRL, reg);
if (ret) {
puts("MAX8997 setting error!\n");
return ret;
}
reg = pmic_reg_read(dev, MAX8997_REG_SAFEOUTCTRL);
reg &= ~ENSAFEOUT1;
ret = pmic_reg_write(dev, MAX8997_REG_SAFEOUTCTRL, reg);
if (ret) {
puts("MAX8997 setting error!\n");
return ret;
}
}
return 0;
}
/* setup board specific PMIC */
int power_init_board(void)
{
struct pmic *p;
if (board_is_idk()) {
power_tps62362_init(I2C_PMIC);
p = pmic_get("TPS62362");
if (p && !pmic_probe(p))
puts("PMIC: TPS62362\n");
} else {
power_tps65218_init(I2C_PMIC);
p = pmic_get("TPS65218_PMIC");
if (p && !pmic_probe(p))
puts("PMIC: TPS65218\n");
}
return 0;
}
int power_init_board(void)
{
struct pmic *p;
int ret;
unsigned int reg;
ret = power_pfuze100_init(I2C_PMIC);
if (ret)
return ret;
p = pmic_get("PFUZE100");
ret = pmic_probe(p);
if (ret)
return ret;
pmic_reg_read(p, PFUZE100_DEVICEID, ®);
printf("PMIC: PFUZE100 ID=0x%02x\n", reg);
/* 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);
/* Set SW1AB stanby volage to 0.975V */
pmic_reg_read(p, PFUZE100_SW1ABSTBY, ®);
reg &= ~SW1x_STBY_MASK;
reg |= SW1x_0_975V;
pmic_reg_write(p, PFUZE100_SW1ABSTBY, reg);
/* Set SW1AB/VDDARM step ramp up time from 16us to 4us/25mV */
pmic_reg_read(p, PFUZE100_SW1ABCONF, ®);
reg &= ~SW1xCONF_DVSSPEED_MASK;
reg |= SW1xCONF_DVSSPEED_4US;
pmic_reg_write(p, PFUZE100_SW1ABCONF, reg);
/* Set SW1C standby voltage to 0.975V */
pmic_reg_read(p, PFUZE100_SW1CSTBY, ®);
reg &= ~SW1x_STBY_MASK;
reg |= SW1x_0_975V;
pmic_reg_write(p, PFUZE100_SW1CSTBY, reg);
/* Set SW1C/VDDSOC step ramp up time from 16us to 4us/25mV */
pmic_reg_read(p, PFUZE100_SW1CCONF, ®);
reg &= ~SW1xCONF_DVSSPEED_MASK;
reg |= SW1xCONF_DVSSPEED_4US;
pmic_reg_write(p, PFUZE100_SW1CCONF, reg);
return 0;
}
int mipi_power(void)
{
struct pmic *p = pmic_get("MAX77686_PMIC");
/* LDO8 VMIPI_1.0V_AP */
s5m8767a_set_ldo_mode(p, 8, OPMODE_ON);
/* LDO10 VMIPI_1.8V_AP */
s5m8767a_set_ldo_mode(p, 10, OPMODE_ON);
return 0;
}
static unsigned char helandkb_recovery_reg_write(unsigned char value)
{
struct pmic *pmic_base;
pmic_base = pmic_get(MARVELL_PMIC_BASE);
if (!pmic_base || pmic_probe(pmic_base)
|| pmic_reg_write(pmic_base, 0xef, value))
printf("write rtc register error\n");
return 0;
}
static int pmic_init_max77686(void)
{
struct pmic *p = pmic_get("MAX77686_PMIC");
if (pmic_probe(p))
return -1;
/* BUCK/LDO Output Voltage */
max77686_set_ldo_voltage(p, 21, 2800000); /* LDO21 VTF_2.8V */
max77686_set_ldo_voltage(p, 23, 3300000); /* LDO23 TSP_AVDD_3.3V*/
max77686_set_ldo_voltage(p, 24, 1800000); /* LDO24 TSP_VDD_1.8V */
/* BUCK/LDO Output Mode */
max77686_set_buck_mode(p, 1, OPMODE_STANDBY); /* BUCK1 VMIF_1.1V_AP */
max77686_set_buck_mode(p, 2, OPMODE_ON); /* BUCK2 VARM_1.0V_AP */
max77686_set_buck_mode(p, 3, OPMODE_ON); /* BUCK3 VINT_1.0V_AP */
max77686_set_buck_mode(p, 4, OPMODE_ON); /* BUCK4 VG3D_1.0V_AP */
max77686_set_buck_mode(p, 5, OPMODE_ON); /* BUCK5 VMEM_1.2V_AP */
max77686_set_buck_mode(p, 6, OPMODE_ON); /* BUCK6 VCC_SUB_1.35V*/
max77686_set_buck_mode(p, 7, OPMODE_ON); /* BUCK7 VCC_SUB_2.0V */
max77686_set_buck_mode(p, 8, OPMODE_OFF); /* VMEM_VDDF_2.85V */
max77686_set_buck_mode(p, 9, OPMODE_OFF); /* CAM_ISP_CORE_1.2V*/
max77686_set_ldo_mode(p, 1, OPMODE_LPM); /* LDO1 VALIVE_1.0V_AP*/
max77686_set_ldo_mode(p, 2, OPMODE_STANDBY); /* LDO2 VM1M2_1.2V_AP */
max77686_set_ldo_mode(p, 3, OPMODE_LPM); /* LDO3 VCC_1.8V_AP */
max77686_set_ldo_mode(p, 4, OPMODE_LPM); /* LDO4 VCC_2.8V_AP */
max77686_set_ldo_mode(p, 5, OPMODE_OFF); /* LDO5_VCC_1.8V_IO */
max77686_set_ldo_mode(p, 6, OPMODE_STANDBY); /* LDO6 VMPLL_1.0V_AP */
max77686_set_ldo_mode(p, 7, OPMODE_STANDBY); /* LDO7 VPLL_1.0V_AP */
max77686_set_ldo_mode(p, 8, OPMODE_LPM); /* LDO8 VMIPI_1.0V_AP */
max77686_set_ldo_mode(p, 9, OPMODE_OFF); /* CAM_ISP_MIPI_1.2*/
max77686_set_ldo_mode(p, 10, OPMODE_LPM); /* LDO10 VMIPI_1.8V_AP*/
max77686_set_ldo_mode(p, 11, OPMODE_STANDBY); /* LDO11 VABB1_1.8V_AP*/
max77686_set_ldo_mode(p, 12, OPMODE_LPM); /* LDO12 VUOTG_3.0V_AP*/
max77686_set_ldo_mode(p, 13, OPMODE_OFF); /* LDO13 VC2C_1.8V_AP */
max77686_set_ldo_mode(p, 14, OPMODE_STANDBY); /* VABB02_1.8V_AP */
max77686_set_ldo_mode(p, 15, OPMODE_STANDBY); /* LDO15 VHSIC_1.0V_AP*/
max77686_set_ldo_mode(p, 16, OPMODE_STANDBY); /* LDO16 VHSIC_1.8V_AP*/
max77686_set_ldo_mode(p, 17, OPMODE_OFF); /* CAM_SENSOR_CORE_1.2*/
max77686_set_ldo_mode(p, 18, OPMODE_OFF); /* CAM_ISP_SEN_IO_1.8V*/
max77686_set_ldo_mode(p, 19, OPMODE_OFF); /* LDO19 VT_CAM_1.8V */
max77686_set_ldo_mode(p, 20, OPMODE_ON); /* LDO20 VDDQ_PRE_1.8V*/
max77686_set_ldo_mode(p, 21, OPMODE_OFF); /* LDO21 VTF_2.8V */
max77686_set_ldo_mode(p, 22, OPMODE_OFF); /* LDO22 VMEM_VDD_2.8V*/
max77686_set_ldo_mode(p, 23, OPMODE_OFF); /* LDO23 TSP_AVDD_3.3V*/
max77686_set_ldo_mode(p, 24, OPMODE_OFF); /* LDO24 TSP_VDD_1.8V */
max77686_set_ldo_mode(p, 25, OPMODE_OFF); /* LDO25 VCC_3.3V_LCD */
max77686_set_ldo_mode(p, 26, OPMODE_OFF); /*LDO26 VCC_3.0V_MOTOR*/
return 0;
}
int pmic_88pm886_init(struct pmic_chip_desc *chip)
{
struct pmic *p_base, *p_power, *p_gpadc;
if (!chip) {
printf("---%s: chip is empty.\n", __func__);
return -EINVAL;
}
/*------------base page setting-----------*/
p_base = pmic_get(chip->base_name);
if (!p_base)
return -1;
if (pmic_probe(p_base))
return -1;
pmic_88pm886_base_init(p_base);
board_pmic_base_fixup(p_base);
/*------------gpadc page setting -----------*/
p_gpadc = pmic_get(chip->gpadc_name);
if (!p_gpadc)
return -1;
if (pmic_probe(p_gpadc))
return -1;
pmic_88pm886_gpadc_init(p_gpadc);
board_pmic_gpadc_fixup(p_gpadc);
/*------------power page setting -----------*/
p_power = pmic_get(chip->power_name);
if (!p_power)
return -1;
if (pmic_probe(p_power))
return -1;
pmic_88pm886_power_init(p_power);
board_pmic_power_fixup(p_power);
printf("PMIC init done!\n");
return 0;
}
int g_dnl_board_usb_cable_connected(void)
{
#ifndef CONFIG_DM_I2C /* TODO(maintainer): Convert to driver model */
struct pmic *muic = pmic_get("MAX8997_MUIC");
if (!muic)
return 0;
return !!muic->chrg->chrg_type(muic);
#else
return false;
#endif
}
void exynos_lcd_power_on(void)
{
struct pmic *p = pmic_get("MAX8998_PMIC");
if (!p)
return;
if (pmic_probe(p))
return;
pmic_set_output(p, MAX8998_REG_ONOFF3, MAX8998_LDO17, LDO_ON);
pmic_set_output(p, MAX8998_REG_ONOFF2, MAX8998_LDO7, LDO_ON);
}
void exynos_lcd_power_on(void)
{
struct pmic *p = pmic_get("MAX77686_PMIC");
/* LCD_2.2V_EN: GPC0[1] */
gpio_set_pull(EXYNOS4X12_GPIO_C01, S5P_GPIO_PULL_UP);
gpio_direction_output(EXYNOS4X12_GPIO_C01, 1);
/* LDO25 VCC_3.1V_LCD */
pmic_probe(p);
s5m8767a_set_ldo_voltage(p, 25, 3100000);
s5m8767a_set_ldo_mode(p, 25, OPMODE_LPM);
}
/* Test PMIC get method */
static int dm_test_power_pmic_get(struct unit_test_state *uts)
{
const char *name = "sandbox_pmic";
struct udevice *dev;
ut_assertok(pmic_get(name, &dev));
ut_assertnonnull(dev);
/* Check PMIC's name */
ut_asserteq_str(name, dev->name);
return 0;
}
static void pmic_88pm886_stepping_fixup(struct pmic_chip_desc *chip)
{
struct pmic *p_base, *p_battery, *p_test;
p_base = pmic_get(chip->base_name);
p_battery = pmic_get(chip->battery_name);
p_test = pmic_get(MARVELL_PMIC_TEST);
/* WA for A0 to prevent OV_VBAT fault and support dead battery case */
if (chip->chip_id == 0x00) {
if (p_battery && !pmic_probe(p_battery)) {
/* set BATTEMP_MON2_DIS */
pmic_update_bits(p_battery, PM886_CHG_CONFIG1,
PM886_BATTEMP_MON2_DIS, PM886_BATTEMP_MON2_DIS);
/* disable OV_VBAT */
pmic_update_bits(p_battery, PM886_CHG_CONFIG3, PM886_OV_VBAT_EN, 0);
}
if (p_base && p_test && !pmic_probe(p_base) && !pmic_probe(p_test)) {
/* open test page */
pmic_reg_write(p_base, 0x1f, 0x1);
/* change the defaults to disable OV_VBAT */
pmic_reg_write(p_test, 0x50, 0x2a);
pmic_reg_write(p_test, 0x51, 0x0c);
/* change defaults to enable charging */
pmic_reg_write(p_test, 0x52, 0x28);
pmic_reg_write(p_test, 0x53, 0x01);
/* change defaults to disable OV_VSYS1 and UV_VSYS1 */
pmic_reg_write(p_test, 0x54, 0x23);
pmic_reg_write(p_test, 0x55, 0x14);
pmic_reg_write(p_test, 0x58, 0xbb);
pmic_reg_write(p_test, 0x59, 0x08);
/* close test page */
pmic_reg_write(p_base, 0x1f, 0x0);
/* disable OV_VSYS1 and UV_VSYS1 */
pmic_reg_write(p_base, PM886_REG_LOWPOWER4, 0x14);
}
}
}
static int init_pmic_lcd(void)
{
struct udevice *dev;
unsigned char val;
int ret = 0;
ret = pmic_get("max8998-pmic", &dev);
if (ret) {
puts("Failed to get MAX8998 for init_pmic_lcd()!\n");
return ret;
}
/* LDO7 1.8V */
val = 0x02; /* (1800 - 1600) / 100; */
ret |= pmic_reg_write(dev, MAX8998_REG_LDO7, val);
/* LDO17 3.0V */
val = 0xe; /* (3000 - 1600) / 100; */
ret |= pmic_reg_write(dev, MAX8998_REG_LDO17, val);
/* Disable unneeded regulators */
/*
* ONOFF1
* Buck1 ON, Buck2 OFF, Buck3 ON, Buck4 ON
* LDO2 ON, LDO3 OFF, LDO4 OFF, LDO5 ON
*/
val = 0xB9;
ret |= pmic_reg_write(dev, MAX8998_REG_ONOFF1, val);
/* ONOFF2
* LDO6 OFF, LDO7 ON, LDO8 OFF, LDO9 ON,
* LDO10 OFF, LDO11 OFF, LDO12 OFF, LDO13 OFF
*/
val = 0x50;
ret |= pmic_reg_write(dev, MAX8998_REG_ONOFF2, val);
/* ONOFF3
* LDO14 OFF, LDO15 OFF, LGO16 OFF, LDO17 OFF
* EPWRHOLD OFF, EBATTMON OFF, ELBCNFG2 OFF, ELBCNFG1 OFF
*/
val = 0x00;
ret |= pmic_reg_write(dev, MAX8998_REG_ONOFF3, val);
if (ret) {
puts("LCD pmic initialisation error!\n");
return -EINVAL;
}
return 0;
}
static int pfuze_init(void)
{
struct pmic *p;
int ret;
unsigned int reg;
ret = power_pfuze100_init(I2C_PMIC);
if (ret)
return ret;
p = pmic_get("PFUZE100");
ret = pmic_probe(p);
if (ret)
return ret;
pmic_reg_read(p, PFUZE100_DEVICEID, ®);
printf("PMIC: PFUZE100 ID=0x%02x\n", reg);
/* Set SW1AB standby voltage to 0.975V */
pmic_reg_read(p, PFUZE100_SW1ABSTBY, ®);
reg &= ~0x3f;
reg |= 0x1b;
pmic_reg_write(p, PFUZE100_SW1ABSTBY, reg);
/* Set SW1AB/VDDARM step ramp up time from 16us to 4us/25mV */
pmic_reg_read(p, PUZE_100_SW1ABCONF, ®);
reg &= ~0xc0;
reg |= 0x40;
pmic_reg_write(p, PUZE_100_SW1ABCONF, reg);
/* Set SW1C standby voltage to 0.975V */
pmic_reg_read(p, PFUZE100_SW1CSTBY, ®);
reg &= ~0x3f;
reg |= 0x1b;
pmic_reg_write(p, PFUZE100_SW1CSTBY, reg);
/* Set SW1C/VDDSOC step ramp up time from 16us to 4us/25mV */
pmic_reg_read(p, PFUZE100_SW1CCONF, ®);
reg &= ~0xc0;
reg |= 0x40;
pmic_reg_write(p, PFUZE100_SW1CCONF, reg);
/* Enable power of VGEN5 3V3, needed for SD3 */
pmic_reg_read(p, PFUZE100_VGEN5VOL, ®);
reg &= ~0x1F;
reg |= 0x1F;
pmic_reg_write(p, PFUZE100_VGEN5VOL, reg);
return 0;
}
