Gitiles
Code Review Sign In
192.168.1.100 / T106_DC / 7ccf8376fe57d58025e2b80b82b0cde26a8cff83 / . / boot / common / src / uboot / drivers / power / zx234290.c
blob: e8f083ff9b04ab19f08acffcd560489d600ece1e [file] [log] [blame]
/*********************************************************************
Copyright 2016 by ZIXC Corporation.
*
* FileName:: zx234290.c
* File Mark:
* Description:
* Others:
* Version:
* Author:
* Date:
* History 1:
* Date:
* Version:
* Author:
* Modification:
* History 2:
**********************************************************************/
#include <common.h>
#include <errno.h>
#include <command.h>
#include <malloc.h>
#include <asm/io.h>
#include <boot_mode.h>
#include <i2c.h>
#include <drvs_gpio.h>
#include <power.h>
#include <zx234290.h>
#include <zx234502.h>
#include <watchdog.h>
int zx234290_write_flag(UINT8 val);
#define PIN_PSHOLD_NUM GPIO24
#define GPIO_PSHOLD_FUNC_SEL GPIO24_GPIO24
static boot_reason_t s_boot_reason = UNKNOWN_BOOT_REASON;
/*******************************************************************************
* Function: zx234290_i2c_read_reg
* Description:
* Parameters:
* Input:
*
* Output:
*
* Returns:
*
*
* Others:
********************************************************************************/
int zx234290_i2c_read_reg(ushort reg, uchar *val)
{
return i2c_read(0, ZX234290_I2C_SLAVE_ADDR, reg, 8, val, 1);
}
/*******************************************************************************
* Function: zx234290_i2c_write_reg
* Description:
* Parameters:
* Input:
*
* Output:
*
* Returns:
*
*
* Others:
********************************************************************************/
int zx234290_i2c_write_reg(ushort reg, uchar *val)
{
return i2c_write(0, ZX234290_I2C_SLAVE_ADDR, reg, 8, val, 1);
}
int zx234290_reset_flag(void)
{
#if 0
int ret = 0;
int val = 0;
/*
int val = 0xff;
ret = zx234290_i2c_write_reg(0x0f,&val);
*/
ret = zx234290_i2c_read_reg(BUCK_MODE_CONTROL0, &val);
val &= (~0x30);
ret += zx234290_i2c_write_reg(BUCK_MODE_CONTROL0, &val);
return ret;
#else
return zx234290_write_flag(ZX234290_USER_RST_UNDEFINE);
#endif
}
int zx234290_write_flag(UINT8 val)
{
#if 0
int ret = 0;
int tmp = 0;
if(val > 3)
{
return -1;
}
ret = zx234290_i2c_read_reg(BUCK_MODE_CONTROL0, &tmp);
tmp &= (~0x30);
tmp |= (val<<4);
ret += zx234290_i2c_write_reg(BUCK_MODE_CONTROL0, &tmp);
return ret;
#else
int ret = 0;
uchar tmp = 0;
/*
ret = zx234290_i2c_read_reg(ZX234290_REG_ADDR_USER_RESERVED, &tmp);
tmp &= ~(0x03<<2);
tmp |= (val<<2);
*/
tmp = val;
ret |= zx234290_i2c_write_reg(ZX234290_REG_USER, &tmp);
return ret;
#endif
}
void zx234290_set_rtc_alarm_off(void)
{
int ret = 0;
uchar tmp = 0;
//set alarm active bit 1 disable
ret = zx234290_i2c_read_reg(ZX234290_REG_ADDR_ALARM_MINUTE, &tmp);
tmp |= (1<<ZX234290_RTC_AlARM_ACTIVATED_LSH);
ret |= zx234290_i2c_write_reg(ZX234290_REG_ADDR_ALARM_MINUTE, &tmp);
ret |= zx234290_i2c_read_reg(ZX234290_REG_ADDR_ALARM_HOUR, &tmp);
tmp |= (1<<ZX234290_RTC_AlARM_ACTIVATED_LSH);
ret |= zx234290_i2c_write_reg(ZX234290_REG_ADDR_ALARM_HOUR, &tmp);
ret |= zx234290_i2c_read_reg(ZX234290_REG_ADDR_ALARM_DAY, &tmp);
tmp |= (1<<ZX234290_RTC_AlARM_ACTIVATED_LSH);
ret |= zx234290_i2c_write_reg(ZX234290_REG_ADDR_ALARM_DAY, &tmp);
ret = zx234290_i2c_read_reg(ZX234290_REG_ADDR_ALARM_WEEK, &tmp);
tmp |= (1<<ZX234290_RTC_AlARM_ACTIVATED_LSH);
ret |= zx234290_i2c_write_reg(ZX234290_REG_ADDR_ALARM_WEEK, &tmp);
ret |= zx234290_i2c_read_reg(ZX234290_REG_ADDR_ALARM_SECOND, &tmp);
tmp |= (1<<ZX234290_RTC_AlARM_ACTIVATED_LSH);
ret |= zx234290_i2c_write_reg(ZX234290_REG_ADDR_ALARM_SECOND, &tmp);
/*disable AIE bit && AF*/
ret |= zx234290_i2c_read_reg(ZX234290_REG_RTC_CONTROL2, &tmp);
tmp &= ~(RTC_CONTROL2_AIE|RTC_CONTROL2_AF);
ret |= zx234290_i2c_write_reg(ZX234290_REG_RTC_CONTROL2, &tmp);
if(ret)
printf( "[%s] fail ret=%d...\n", __FUNCTION__, ret);
}
/*******************************************************************************
* Function: zx234290_get_boot_reason
* Description:
* Parameters:
* Input:
*
* Output:
*
* Returns:
*
*
* Others:
********************************************************************************/
int zx234290_get_boot_reason(boot_reason_t *boot_reason)
{
if (boot_reason == NULL)
{
return -1;
}
if(s_boot_reason == UNKNOWN_BOOT_REASON)
{
return -EIO;
}
*boot_reason = s_boot_reason;
return 0;
}
/*******************************************************************************
* Function: zx234290_get_boot_reason
* Description:
* Parameters:
* Input:
*
* Output:
*
* Returns:
*
*
* Others:
********************************************************************************/
static int zx234290_get_boot_reason_prev(void)
{
int ret = 0;
uchar reg_user = ZX234290_USER_RST_UNDEFINE;
uchar reg_start = 0;
uchar reg_write = 0;
/* ¶Á²¢ÇåSTART_UP_STATUS */
ret = zx234290_i2c_read_reg(START_UP_STATUS, &reg_start);
if( ret != 0 )
{
return -EIO;
}
printf( " [%s][START_UP_STATUS = 0x%X] ...\n", __FUNCTION__, reg_start);
(*(volatile unsigned long *)(START_UP_STATUS_BASE))=reg_start;
/* ¶Á²¢ÇåZX234290_REG_USER */
ret = zx234290_i2c_read_reg(ZX234290_REG_USER, &reg_user);
if(reg_user != ZX234290_USER_RST_UNDEFINE)
{
reg_write = ZX234290_USER_RST_UNDEFINE; /* write back the reset value */
ret |= zx234290_i2c_write_reg(ZX234290_REG_USER, &reg_write);
}
if ( ret != 0 )
{
return -EIO;
}
printf( " [%s][USER_RESERVED = 0x%X] ...\n", __FUNCTION__, reg_user);
(*(volatile unsigned long *)(USER_RESERVED_BASE)) =reg_user;
/* 1. Õý³£¿ª»ú¼ì²â */
if( reg_start & PWR_ON_START_UP )
/* ϵͳÖØÆô,Èç¹ûZX234290_REG_USER²»Îª³õÖµ£¬ÔòΪÖØÆô */
{
s_boot_reason = RB_POWER_KEY;
return 0;
}
else if( reg_start & PS_HOLD_START_UP )
{
s_boot_reason = RB_USB_INSERT;
/* ZX234290_REG_USERΪÉϵ縴λֵ»ò·Ç·¨Öµ */
return 0;
}
else if( reg_start & RTC_ALARM_START_UP )
/* 2. Õý³£¿ª»ú¼ì²â */
{
uchar rtc_ctrl2 = 0xF0;
ret = zx234290_i2c_read_reg(ZX234290_REG_RTC_CONTROL2, &rtc_ctrl2);
printf( " [%s][RTC_CONTROL2 = 0x%X]\n", __FUNCTION__, rtc_ctrl2);
if (rtc_ctrl2 & RTC_CONTROL2_AF) {
s_boot_reason = RB_RTC;
zx234290_set_rtc_alarm_off();
} else if (rtc_ctrl2 & RTC_CONTROL2_TF) {
s_boot_reason = RB_RESET_NOMAL;
}
return ret;
}
else if( reg_start & LLP_RESTART_UP )
{
s_boot_reason = RB_POWER_KEY_LONG;
return 0;
}
/* reg_startΪ0£¬¼´reg_start¶ÁÇåÖ®ºóδµôµç£¬¼´ÏµÍ³ÖØÆô */
/* 2. ÖØÆô¼ì²â */
/* ϵͳÖØÆô,Èç¹ûZX234290_REG_USER²»Îª³õÖµ£¬ÔòΪÖØÆô */
switch (reg_user)
{
case ZX234290_USER_RST_TO_NORMAL:
{
s_boot_reason = RB_RESET_NOMAL;
return 0;
}
case ZX234290_USER_RST_TO_CHARGER:
{
s_boot_reason = RB_RESET_USB_OFF;
return 0;
}
case ZX234290_USER_RST_TO_ALARM:
{
s_boot_reason = RB_RESET_ALARM;
return 0;
}
/* ZX234290_REG_USERΪÉϵ縴λֵ»ò·Ç·¨Öµ */
default:
{
if ((reg_user & 0xF0) == ZX234290_WDT_RST_FLAG) {
s_boot_reason = reg_user;
return 0;
}
break;
}
}
s_boot_reason = RB_USB_INSERT;
return 0;
}
/*******************************************************************************
* Function: zx234290_ps_hold_pull_on
* Description:
* Parameters:
* Input:
*
* Output:
*
* Returns:
*
*
* Others:
********************************************************************************/
int zx234290_ps_hold_pull_on(void)
{
zDrvGpio_PullUpDown(PIN_PSHOLD_NUM, 0);
//gpio_set_reuse(PS_HOLD_PIN, 0);
zDrvGpio_SetFunc(PIN_PSHOLD_NUM,GPIO_PSHOLD_FUNC_SEL);
zDrvGpio_SetDirection(PIN_PSHOLD_NUM,GPIO_IN); //set output;v3 gpio24(pshold) direction is reverse
zDrvGpio_SetOutputValue(PIN_PSHOLD_NUM,GPIO_HIGH);
return 0;
}
/*******************************************************************************
* Function: zx234290_ps_hold_pull_off
* Description:
* Parameters:
* Input:
*
* Output:
*
* Returns:
*
*
* Others:
********************************************************************************/
int zx234290_ps_hold_pull_off(void)
{
zDrvGpio_PullUpDown(PIN_PSHOLD_NUM, 0);
//gpio_set_reuse(PS_HOLD_PIN, 0);
//gpio_direction_output(PS_HOLD_PIN, GPIO_LOW);
zDrvGpio_SetFunc(PIN_PSHOLD_NUM,GPIO_PSHOLD_FUNC_SEL);
zDrvGpio_SetDirection(PIN_PSHOLD_NUM,GPIO_IN); //set output;v3 gpio24(pshold) direction is reverse
zDrvGpio_SetOutputValue(PIN_PSHOLD_NUM,GPIO_LOW);
return 0;
}
/*******************************************************************************
* Function: zx234290_power_off
* Description:
* Parameters:
* Input:
*
* Output:
*
* Returns:
*
*
* Others:
********************************************************************************/
int zx234290_power_off(void)
{
return zx234290_ps_hold_pull_off();
}
/*******************************************************************************
* Function:
* Description:
* Parameters:
* Input:
*
* Output:
*
* Returns:
*
*
* Others:
********************************************************************************/
int pmu_init(void)
{
int ret = 0;
uchar reg_val = 0;
struct pmu_opt pmu = {NULL};
/* GPIO init */
//gpio_set_reuse(PS_HOLD_PIN, 0x0);
//gpio_direction_output(PS_HOLD_PIN,GPIO_LOW);
// gpio_set_reuse(POWER_KEY_PIN,0x0);
// gpio_direction_input(POWER_KEY_PIN);
// gpio_noaction(POWER_KEY_PIN);
/* register pmu opt */
pmu.read_reg = zx234290_i2c_read_reg;
pmu.write_reg = zx234290_i2c_write_reg;
pmu.get_boot_reason = zx234290_get_boot_reason;
pmu.ps_hold_pull_on = pmu_pull_on_ps_hold;
pmu.ps_hold_pull_off = pmu_pull_off_ps_hold;
pmu.power_off = zx234290_power_off;
ret = register_pmu_opt(&pmu);
if( ret != 0 )
{
return -EIO;
}
ret = zx234290_get_boot_reason_prev();
ret +=zx234290_i2c_read_reg(ZX234297_REG_ADDR_SINK_CONTROL,&reg_val);
if(reg_val==0x7f){//means 296G C
reg_val = 0xff;//define to 296
ret+=zx234290_i2c_write_reg(ZX234297_REG_ADDR_SINK_CONTROL,&reg_val);
}
if (ret != SUCCESS)
{
printf( "[%s]set 0x29 error ret=0x%x!\n", __FUNCTION__,ret);
}
return ret;
}
/* ================================================================================
* pmu_init:
*/
int pmu_pull_off_ps_hold(void)
{
return zx234290_ps_hold_pull_off();
}
/* ================================================================================
* pmu_init:
*/
int pmu_pull_on_ps_hold(void)
{
return zx234290_ps_hold_pull_on();
}
/* ================================================================================
* system_power_off:
*/
void system_power_off(void)
{
zx234290_power_off();
}
int zx234290_get_adc2_voltage(void)
{
int nTempAdc = 0, ret = -1;
int adcReadInt = -1;
int msb=0, lsb=0;
int num;
uchar status_a=0;
uchar adcEnable = 0x28;
uchar sys_ctrl;
ret = zx234290_i2c_read_reg(ZX234290_REG_SYS_CTRL, &sys_ctrl);
if (ret != SUCCESS)
{
return -EIO;
}
sys_ctrl = (sys_ctrl & (1 << 7)) | adcEnable;
/*enable adc*/
#if 0
ret = zx234290_i2c_write_reg(ZX234290_REG_SYS_CTRL,&sys_ctrl);
if (ret != SUCCESS)
{
return -EIO;
}
#else
for(num=1; num <= 50; num++)
{
ret = zx234290_i2c_write_reg(ZX234290_REG_SYS_CTRL, &sys_ctrl);
if (ret != SUCCESS)
{
return -EIO;
}
udelay((100000/3000)*5); /* delay 5ms */
ret = zx234290_i2c_read_reg(ZX234290_REG_ADDR_STSA, &status_a);
if (ret != SUCCESS)
{
return -EIO;
}
if(status_a & 0x04)
{
printf( "adc2 get adc,break num =%d ...\n", num);
break;
}
}
#endif
udelay((100000/3000)*20); /* delay 20ms */
/*read adc*/
ret = zx234290_i2c_read_reg(ZX234290_REG_ADC_ADC2MSB, &msb);
if (ret != SUCCESS)
{
return -EIO;
}
ret = zx234290_i2c_read_reg(ZX234290_REG_ADC_ADC2LSB, &lsb);
if (ret != SUCCESS)
{
return -EIO;
}
/*clear int*/
ret = zx234290_i2c_read_reg(ZX234290_REG_INTA, &adcReadInt);
if (ret != SUCCESS)
{
return -EIO;
}
ret =zx234290_i2c_read_reg(ZX234290_REG_INTB, &adcReadInt);
if (ret != SUCCESS)
{
return -EIO;
}
nTempAdc = ((msb<<4)|(lsb>>4));
nTempAdc = (int)((double)(5000-0)*(nTempAdc)/4096);
return nTempAdc;
}
int zx234290_get_adc1_voltage(void) /*read adc1*/
{
int nTempAdc = 0,adcEnable = 0,ret = -1;
int adcReadInt = -1;
int msb=0, lsb=0;
int num;
uchar status_a=0;
adcEnable = 0x30; /*read adc1*/
uchar sys_ctrl;
ret = zx234290_i2c_read_reg(ZX234290_REG_SYS_CTRL, &sys_ctrl);
if (ret != SUCCESS)
{
return -EIO;
}
sys_ctrl = (sys_ctrl & (1 << 7)) | adcEnable;
/*enable adc*/
#if 0
ret = zx234290_i2c_write_reg(ZX234290_REG_SYS_CTRL,&sys_ctrl);
if (ret != SUCCESS)
{
return -EIO;
}
#else
for(num=1; num <= 50; num++)
{
ret = zx234290_i2c_write_reg(ZX234290_REG_SYS_CTRL, &sys_ctrl);
if (ret != SUCCESS)
{
return -EIO;
}
udelay((100000/3000)*5); /* delay 5ms */
ret = zx234290_i2c_read_reg(ZX234290_REG_ADDR_STSA, &status_a);
if (ret != SUCCESS)
{
return -EIO;
}
if(status_a & 0x04)
{
printf( "adc1 get adc,break num =%d ...\n", num);
break;
}
}
#endif
udelay((100000/3000)*20); /* delay 20ms */
/*read adc*/
ret = zx234290_i2c_read_reg(ZX234290_REG_ADC_ADC1MSB, &msb);
if (ret != SUCCESS)
{
return -EIO;
}
ret = zx234290_i2c_read_reg(ZX234290_REG_ADC_ADC1LSB, &lsb);
if (ret != SUCCESS)
{
return -EIO;
}
/*clear int*/
ret = zx234290_i2c_read_reg(ZX234290_REG_INTA, &adcReadInt);
if (ret != SUCCESS)
{
return -EIO;
}
ret =zx234290_i2c_read_reg(ZX234290_REG_INTB, &adcReadInt);
if (ret != SUCCESS)
{
return -EIO;
}
nTempAdc = ((msb<<4)|(lsb>>4));
nTempAdc = (int)((double)(5000-0)*(nTempAdc)/4096);
return nTempAdc;
}
int zx234290_get_vbat_voltage(void)
{
int nTempAdc = 0,adcEnable = 0,ret = -1;
int adcReadInt = -1;
int msb=0, lsb=0;
int num;
uchar status_a=0;
//adcEnable = 0x30;
adcEnable = 0x20;
uchar sys_ctrl;
ret = zx234290_i2c_read_reg(ZX234290_REG_SYS_CTRL, &sys_ctrl);
if (ret != SUCCESS)
{
return -EIO;
}
sys_ctrl = (sys_ctrl & (1 << 7)) | adcEnable;
#if 0
ret = zx234290_i2c_write_reg(ZX234290_REG_SYS_CTRL,&sys_ctrl);
if (ret != SUCCESS)
{
return -EIO;
}
#else
for(num=1; num <= 50; num++)
{
ret = zx234290_i2c_write_reg(ZX234290_REG_SYS_CTRL, &sys_ctrl);
if (ret != SUCCESS)
{
return -EIO;
}
udelay((100000/3000)*5); /* delay 5ms */
ret = zx234290_i2c_read_reg(ZX234290_REG_ADDR_STSA, &status_a);
if (ret != SUCCESS)
{
return -EIO;
}
if(status_a & 0x04)
{
printf( "vbat get adc,break num =%d ...\n", num);
break;
}
}
#endif
//ret = zx234290_i2c_read_reg(ZX234290_REG_ADC_ADC1MSB, &msb);
ret = zx234290_i2c_read_reg(ZX234290_REG_ADC_VBATMSB, &msb);
if (ret != SUCCESS)
{
return -EIO;
}
//ret = zx234290_i2c_read_reg(ZX234290_REG_ADC_ADC1LSB, &lsb);
ret = zx234290_i2c_read_reg(ZX234290_REG_ADC_VBATLSB, &lsb);
if (ret != SUCCESS)
{
return -EIO;
}
ret = zx234290_i2c_read_reg(ZX234290_REG_INTA, &adcReadInt);
if (ret != SUCCESS)
{
return -EIO;
}
ret =zx234290_i2c_read_reg(ZX234290_REG_INTB, &adcReadInt);
if (ret != SUCCESS)
{
return -EIO;
}
nTempAdc = ((msb<<4)|(lsb>>4));
nTempAdc = (int)((double)(5000-0)*(nTempAdc)/4096);
return nTempAdc;
}
int zx234290_set_llp_enable(void)
{
int ret = -1;
ushort reg=ZX234290_REG_ADDR_PWRON;
uchar val=0x05;
ret = zx234290_i2c_write_reg(reg, &val);
if (ret != SUCCESS)
{
return -EIO;
}
return ret;
}
/*get the poweron key state 0x1<<5: poweron press 0:poweron up*/
int zx234290_get_poweron_state(void)
{
int val = 0,ret = -1;
uchar reg = 0;
ret = zx234290_i2c_read_reg(STATUS_A,&reg);
if (ret != SUCCESS)
{
return -EIO;
}
val = reg&STATUS_PWR_ON;
return val;
}
/* get the rtc_alarm status: bit0 in reg 0x05 */
int zx234290_get_rtc_state(void)
{
int val = 0,ret = -1;
uchar reg = 0;
ret = zx234290_i2c_read_reg(STATUS_B, &reg);
if (ret != SUCCESS)
{
return -EIO;
}
val = reg & STATUS_RTC_ALARM;
return val;
}
/* Set or clear SoftOn bit in ZX234290_REG_SYS_CTRL */
int zx234290_set_softon(int on)
{
uchar reg = 0;
int ret;
ret = zx234290_i2c_read_reg(ZX234290_REG_SYS_CTRL, &reg);
if (ret != SUCCESS)
{
return -EIO;
}
if ((reg >> 7) != on) {
reg ^= (0x01<<7);
ret = zx234290_i2c_write_reg(ZX234290_REG_SYS_CTRL, &reg);
if (ret != SUCCESS)
{
return -EIO;
}
}
return 0;
}
/*set ldo8 SD VOL*/
int zx234290_set_ldo8_voltage(T_ZDrvZx234290_VldoD vol)
{
int ret = 0;
unsigned char reg_addr=0, reg_val=0;
if(vol > VLDOD_MAX)
{
return -EINVAL;
}
reg_addr = ZX234290_REG_ADDR_LDO78_VOL;
ret = zx234290_i2c_read_reg(reg_addr,&reg_val);
if (ret != SUCCESS)
{
return -EIO;
}
reg_val &= ~(0xf<<ZX234290_LDO8_VSEL_LSH);
reg_val |= (vol<<ZX234290_LDO8_VSEL_LSH);
ret = zx234290_i2c_write_reg(reg_addr, &reg_val);
if (ret != SUCCESS)
{
return -EIO;
}
return 0;
}
int zx234290_set_ldo8_sleep_voltage(T_ZDrvZx234290_VldoD vol)
{
int ret = 0;
unsigned char reg_addr=0, reg_val=0;
if(vol > VLDOD_MAX)
{
return -EINVAL;
}
reg_addr = ZX234290_REG_ADDR_LDO78_VOL;
ret = zx234290_i2c_read_reg(reg_addr,&reg_val);
if (ret != SUCCESS)
{
return -EIO;
}
reg_val &= ~(0xf<<ZX234290_LDO8_SLP_VSEL_LSH);
reg_val |= (vol<<ZX234290_LDO8_SLP_VSEL_LSH);
ret = zx234290_i2c_write_reg(reg_addr, &reg_val);
if (ret != SUCCESS)
{
return -EIO;
}
return 0;
}
/* clear SoftOn bit in ZX234290_REG_SYS_CTRL bit7 */
int zx234290_ldo8_enable(int enable)
{
int ret = -1;
uchar reg = 0;
ret = zx234290_i2c_read_reg(ZX234290_REG_LDO_EN1, &reg);
if (ret != SUCCESS)
{
return -EIO;
}
reg &= ~(0x01<<7);
reg |= (enable<<7);
ret = zx234290_i2c_write_reg(ZX234290_REG_LDO_EN1, &reg);
if (ret != SUCCESS)
{
return -EIO;
}
return 0;
}
int zx234290_set_sink(T_ZX234290_SINK sink_num, int is_on, T_ZX234297_SINK_CURRENT sink_current)
{
int ret = 0;
unsigned char lsh_on, lsh_current;
uchar reg = 0;
ret = zx234290_i2c_read_reg(ZX234297_REG_ADDR_SINK_CONTROL, &reg);
if (ret != SUCCESS)
{
return -EIO;
}
if(0xff==reg){
printf("pmu zx234296 no sink\n");
return SUCCESS;
}
if (sink_num == SINK_1) {
lsh_on = ZX234297_SINK1_ON_LSH;
lsh_current = ZX234297_SINK1_CURRENT_LSH;
} else if (sink_num == SINK_2) {
lsh_on = ZX234297_SINK2_ON_LSH;
lsh_current = ZX234297_SINK2_CURRENT_LSH;
} else
return -EINVAL;
if (is_on) {
if (sink_current >= SINK_CURRENT_MAX)
sink_current = SINK_CURRENT_120MA;
ret = zx234290_i2c_read_reg(ZX234297_REG_ADDR_SINK_CONTROL, &reg);
if (ret != SUCCESS)
{
return -EIO;
}
reg &= ~(0xf<<lsh_current);
reg |= (sink_current<<lsh_current);
ret = zx234290_i2c_write_reg(ZX234297_REG_ADDR_SINK_CONTROL, &reg);
if (ret != SUCCESS)
{
return -EIO;
}
}
is_on = !!is_on;
ret = zx234290_i2c_read_reg(ZX234290_REG_ADDR_LDO_EN2, &reg);
if (ret != SUCCESS)
{
return -EIO;
}
reg &= ~(0x1<<lsh_on);
reg |= (is_on<<lsh_on);
ret = zx234290_i2c_write_reg(ZX234290_REG_ADDR_LDO_EN2, &reg);
if (ret != SUCCESS)
{
return -EIO;
}
return 0;
}
#if 0
int zx234290_SetVldo8(Zx234290_VldoD vol)
{
int reg = 0,val = 0,ret = -1;
ret = zx234290_i2c_read_reg(ZX234290_REG_LD78_VOL, &reg);
if (ret != SUCCESS)
{
return -EIO;
}
BOOT_PRINTF(UBOOT_ERR, "********First REG0x15=0x%x!!!\n",reg);
reg &= 0xf;/*00001111*/
reg |= (vol<<4);
ret = zx234290_i2c_write_reg(ZX234290_REG_LD78_VOL, &reg);
if (ret != SUCCESS)
{
return -EIO;
}
ret = zx234290_i2c_read_reg(ZX234290_REG_LD78_VOL, &reg);
if (ret != SUCCESS)
{
return -EIO;
}
BOOT_PRINTF(UBOOT_ERR, "********Last REG0x15=0x%x!!!\n",reg);
return 0;
}
#endif