/*
set charge current
0. disable charging
1. usb charging, 500mA
2. usb adapter charging, 2A
3. ac adapter charging , 3A
*/
int pmic_rk808_charger_setting(int current)
{
debug("%s charger_type = %d\n",__func__,current);
i2c_set_bus_num(rk808.pmic->bus);
i2c_init (RK808_I2C_SPEED, 0x6b);
debug("%s charge ic id = 0x%x\n",__func__,i2c_reg_read(0x6b,0x0a));
switch (current){
case 0:
//disable charging
break;
case 1:
//set charger current to 500ma
break;
case 2:
//set charger current to 1.5A
i2c_reg_write(0x6b,0,(i2c_reg_read(0x6b,0)&0xf8)|0x6);/* Input Current Limit 2A */
break;
case 3:
//set charger current to 1.5A
i2c_reg_write(0x6b,0,(i2c_reg_read(0x6b,0)&0xf8)|0x7);/* Input Current Limit 3A */
break;
default:
break;
}
return 0;
}
long int initdram (int board_type)
{
int m, row, col, bank, i;
unsigned long start, end;
uint32_t mccr1;
uint32_t mear1 = 0, emear1 = 0, msar1 = 0, emsar1 = 0;
uint32_t mear2 = 0, emear2 = 0, msar2 = 0, emsar2 = 0;
uint8_t mber = 0;
i2c_init(CFG_I2C_SPEED, CFG_I2C_SLAVE);
if (i2c_reg_read (0x50, 2) != 0x04) return 0; /* Memory type */
m = i2c_reg_read (0x50, 5); /* # of physical banks */
row = i2c_reg_read (0x50, 3); /* # of rows */
col = i2c_reg_read (0x50, 4); /* # of columns */
bank = i2c_reg_read (0x50, 17); /* # of logical banks */
CONFIG_READ_WORD(MCCR1, mccr1);
mccr1 &= 0xffff0000;
start = CFG_SDRAM_BASE;
end = start + (1 << (col + row + 3) ) * bank - 1;
for (i = 0; i < m; i++) {
mccr1 |= ((row == 13)? 2 : (bank == 4)? 0 : 3) << i * 2;
if (i < 4) {
msar1 |= ((start >> 20) & 0xff) << i * 8;
emsar1 |= ((start >> 28) & 0xff) << i * 8;
mear1 |= ((end >> 20) & 0xff) << i * 8;
emear1 |= ((end >> 28) & 0xff) << i * 8;
} else {
void pmic_ricoh619_shut_down(void)
{
i2c_set_bus_num(ricoh619.pmic->bus);
i2c_init (CONFIG_SYS_I2C_SPEED, ricoh619.pmic->hw.i2c.addr);
i2c_set_bus_speed(CONFIG_SYS_I2C_SPEED);
i2c_reg_write(ricoh619.pmic->hw.i2c.addr, 0xe0, i2c_reg_read(ricoh619.pmic->hw.i2c.addr,0xe0) & 0xfe);
i2c_reg_write(ricoh619.pmic->hw.i2c.addr, 0x0f, i2c_reg_read(ricoh619.pmic->hw.i2c.addr,0x0f) & 0xfe);
i2c_reg_write(ricoh619.pmic->hw.i2c.addr, 0x0e, i2c_reg_read(ricoh619.pmic->hw.i2c.addr,0x0e) | 0x01);
}
static void rtc_write (uchar reg, uchar val, boolean_t set)
{
if (set == TRUE) {
val |= i2c_reg_read (CONFIG_SYS_I2C_RTC_ADDR, reg);
i2c_reg_write (CONFIG_SYS_I2C_RTC_ADDR, reg, val);
} else {
val = i2c_reg_read (CONFIG_SYS_I2C_RTC_ADDR, reg) & ~val;
i2c_reg_write (CONFIG_SYS_I2C_RTC_ADDR, reg, val);
}
}
static void dp501_link_training(u8 addr)
{
u8 val;
val = i2c_reg_read(addr, 0x51);
i2c_reg_write(addr, 0x5d, val); /* set link_bw */
val = i2c_reg_read(addr, 0x52);
i2c_reg_write(addr, 0x5e, val); /* set lane_cnt */
val = i2c_reg_read(addr, 0x53);
i2c_reg_write(addr, 0x5c, val); /* set downspread_ctl */
i2c_reg_write(addr, 0x5f, 0x0d); /* start training */
}
static int rk818_regulator_set_voltage(int num_regulator,
int min_uV, int max_uV)
{
const int *vol_map;
int min_vol = min_uV / 1000;
u16 val;
int num =0;
if (num_regulator < 4){
if (num_regulator == 2)
return 0;
val = rk818_dcdc_select_min_voltage(min_uV,max_uV,num_regulator);
i2c_reg_write(RK818_I2C_ADDR, rk818_BUCK_SET_VOL_REG(num_regulator),
(i2c_reg_read(RK818_I2C_ADDR, rk818_BUCK_SET_VOL_REG(num_regulator)) & 0x3f) | val);
debug("1 %s %d dcdc_vol = %08x\n", __func__, num_regulator, i2c_reg_read(RK818_I2C_ADDR, rk818_BUCK_SET_VOL_REG(num_regulator)));
return 0;
}else if (num_regulator == 6){
vol_map = ldo3_voltage_map;
num = 15;
}
else if (num_regulator == 9 || num_regulator == 10){
vol_map = ldo6_voltage_map;
num = 17;
}
else {
vol_map = ldo_voltage_map;
num = 16;
}
if (min_vol < vol_map[0] ||
min_vol > vol_map[num])
return -EINVAL;
for (val = 0; val <= num; val++){
if (vol_map[val] >= min_vol)
break;
}
if (num_regulator == 12) {
i2c_reg_write(RK818_I2C_ADDR, rk818_LDO_SET_VOL_REG(num_regulator),
((i2c_reg_read(RK818_I2C_ADDR, rk818_LDO_SET_VOL_REG(num_regulator)) & (~0x1f)) | val));
}
else
i2c_reg_write(RK818_I2C_ADDR, rk818_LDO_SET_VOL_REG(num_regulator),
((i2c_reg_read(RK818_I2C_ADDR, rk818_LDO_SET_VOL_REG(num_regulator)) & (~0x3f)) | val));
debug("1 %s %d %d ldo_vol =%08x\n", __func__, num_regulator, val, i2c_reg_read(RK818_I2C_ADDR, rk818_LDO_SET_VOL_REG(num_regulator)));
return 0;
}
/*
* Process the board specific 'pwrman' command.
*/
int do_pwrman(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
u8 val;
int i;
if (argc == 1) {
ethernut5_print_power();
} else if (argc == 2 && strcmp(argv[1], "reset") == 0) {
at91_set_pio_output(AT91_PIO_PORTB, 8, 1);
udelay(100);
at91_set_pio_output(AT91_PIO_PORTB, 8, 0);
udelay(100000);
} else if (argc == 2 && strcmp(argv[1], "temp") == 0) {
ethernut5_print_celsius();
} else if (argc == 2 && strcmp(argv[1], "vaux") == 0) {
ethernut5_print_voltage();
} else if (argc == 2 && strcmp(argv[1], "version") == 0) {
ethernut5_print_version();
} else if (strcmp(argv[1], "led") == 0) {
/* Control the green status LED. Blink frequency unit
** is 0.1s, very roughly. */
if (argc == 2) {
/* No more arguments, output current settings. */
val = i2c_reg_read(PWRMAN_I2C_ADDR, PWRMAN_REG_LEDCTL);
printf("led %u %u\n", val >> 4, val & 15);
} else {
/* reset the DA9030 watchdog */
void hw_watchdog_reset(void)
{
uchar addr = (uchar) DA9030_I2C_ADDR, val = 0;
val = i2c_reg_read(addr, SYS_CONTROL_A);
val |= SYS_CONTROL_A_WATCHDOG;
i2c_reg_write(addr, SYS_CONTROL_A, val);
}
/* program the regulator (MC34VR500) to support deep sleep */
void ls1twr_program_regulator(void)
{
unsigned int i2c_bus;
u8 i2c_device_id;
#define LS1TWR_I2C_BUS_MC34VR500 1
#define MC34VR500_ADDR 0x8
#define MC34VR500_DEVICEID 0x4
#define MC34VR500_DEVICEID_MASK 0x0f
i2c_bus = i2c_get_bus_num();
i2c_set_bus_num(LS1TWR_I2C_BUS_MC34VR500);
i2c_device_id = i2c_reg_read(MC34VR500_ADDR, 0x0) &
MC34VR500_DEVICEID_MASK;
if (i2c_device_id != MC34VR500_DEVICEID) {
printf("The regulator (MC34VR500) does not exist. The device does not support deep sleep.\n");
return;
}
i2c_reg_write(MC34VR500_ADDR, 0x31, 0x4);
i2c_reg_write(MC34VR500_ADDR, 0x4d, 0x4);
i2c_reg_write(MC34VR500_ADDR, 0x6d, 0x38);
i2c_reg_write(MC34VR500_ADDR, 0x6f, 0x37);
i2c_reg_write(MC34VR500_ADDR, 0x71, 0x30);
i2c_set_bus_num(i2c_bus);
}
int ricoh619_poll_pwr_key_sta(void)
{
i2c_set_bus_num(ricoh619.pmic->bus);
i2c_init(CONFIG_SYS_I2C_SPEED, ricoh619.pmic->hw.i2c.addr);
i2c_set_bus_speed(CONFIG_SYS_I2C_SPEED);
return i2c_reg_read(ricoh619.pmic->hw.i2c.addr, 0x14) & 0x01;
}
void pmic_rk808_shut_down(void)
{
u8 reg;
i2c_set_bus_num(0);
reg = i2c_reg_read(0x1b, 0x4b);
i2c_reg_write(0x1b, 0x4b, (reg |(0x1 <<3)));
}
static int rt5025_pre_init(unsigned char bus,uchar addr)
{
debug("%s,line=%d\n", __func__,__LINE__);
i2c_set_bus_num(bus);
i2c_init(RT5025_I2C_SPEED, addr);
i2c_set_bus_speed(RT5025_I2C_SPEED);
i2c_reg_write(addr, RT5025_REG_CHGCTL2, i2c_reg_read(addr, RT5025_REG_CHGCTL2) | 0xf0); /*set chg time*/
i2c_reg_write(addr, 0x17, i2c_reg_read(addr, 0x17) & 0x1f); /*power off 2.8v*/
i2c_reg_write(addr, 0x52,i2c_reg_read(addr,0x52)|0x02); /*no action when vref*/
i2c_reg_write(addr, 0x08, (i2c_reg_read(addr,0x08) & 0x03) |0x40); /*set arm 1.1v*/
i2c_reg_write(addr, 0x09, (i2c_reg_read(addr,0x09) & 0x01) |0x20); /*set logic 1.1v*/
// i2c_reg_write(addr, RT5025_REG_LDOONOFF,
// i2c_reg_read(addr, RT5025_REG_LDOONOFF) |RT5025_LDOEN_MASK6); /*enable ldo6*/
return 0;
}
static void _status_cb(unsigned char reg, unsigned char *data)
{
if (data[0] & BIT0)
{
i2c_bus_init(MPU6050_ADDR);
i2c_reg_read(REG_ACCEL_XOUT_H, 14, _raw_cb);
}
}
static void dp501_clrbits(u8 addr, u8 reg, u8 mask)
{
u8 val;
val = i2c_reg_read(addr, reg);
clrbits_8(&val, mask);
i2c_reg_write(addr, reg, val);
}
void board_get_enetaddr (uchar * addr)
{
int i;
volatile immap_t *immap = (immap_t *) CFG_IMMR;
volatile cpm8xx_t *cpm = &immap->im_cpm;
unsigned int rccrtmp;
char default_mac_addr[] = { 0x00, 0x08, 0x01, 0x02, 0x03, 0x04 };
for (i = 0; i < 6; i++)
addr[i] = default_mac_addr[i];
printf ("There is an error in the i2c driver .. /n");
printf ("You need to fix it first....../n");
rccrtmp = cpm->cp_rccr;
cpm->cp_rccr |= 0x0020;
i2c_reg_read (0xa0, 0);
printf ("seep = '-%c-%c-%c-%c-%c-%c-'\n",
i2c_reg_read (0xa0, 0), i2c_reg_read (0xa0, 0),
i2c_reg_read (0xa0, 0), i2c_reg_read (0xa0, 0),
i2c_reg_read (0xa0, 0), i2c_reg_read (0xa0, 0));
cpm->cp_rccr = rccrtmp;
}
void pmic_rt5025_shut_down(void)
{
i2c_set_bus_num(rt5025.pmic->bus);
i2c_init (RT5025_I2C_SPEED, rt5025.pmic->hw.i2c.addr);
i2c_set_bus_speed(RT5025_I2C_SPEED);
i2c_reg_write(rt5025.pmic->hw.i2c.addr, RT5025_REG_CHANNELH, 0x00);
i2c_reg_write(rt5025.pmic->hw.i2c.addr, RT5025_REG_CHANNELH, 0x80);
i2c_reg_write(rt5025.pmic->hw.i2c.addr, RT5025_REG_MISC3, i2c_reg_read(rt5025.pmic->hw.i2c.addr, RT5025_REG_MISC3) | 0x80);
}
void pmic_rk818_shut_down(void)
{
u8 reg;
i2c_set_bus_num(rk818.pmic->bus);
i2c_init (RK818_I2C_SPEED, rk818.pmic->hw.i2c.addr);
i2c_set_bus_speed(RK818_I2C_SPEED);
reg = i2c_reg_read(rk818.pmic->hw.i2c.addr, RK818_DEVCTRL_REG);
i2c_reg_write(rk818.pmic->hw.i2c.addr, RK818_DEVCTRL_REG, (reg |(0x1 <<0)));
}
int16_t get_shunt_voltage(uint8_t regAddr)
{
union {
uint16_t uint16;
int16_t int16;
} vshunt;
vshunt.uint16 = i2c_reg_read(regAddr);
return vshunt.int16 >> 3;
}
/* initialize the DA9030 Power Controller */
static void init_DA9030()
{
uchar addr = (uchar) DA9030_I2C_ADDR, val = 0;
CKENB |= CKENB_7_GPIO;
udelay(100);
/* Rising Edge on EXTON to reset DA9030 */
GPIO17 = 0x8800; /* configure GPIO17, no pullup, -down */
GPDR0 |= (1<<17); /* GPIO17 is output */
GSDR0 = (1<<17);
GPCR0 = (1<<17); /* drive GPIO17 low */
GPSR0 = (1<<17); /* drive GPIO17 high */
#if CFG_DA9030_EXTON_DELAY
udelay((unsigned long) CFG_DA9030_EXTON_DELAY); /* wait for DA9030 */
#endif
GPCR0 = (1<<17); /* drive GPIO17 low */
/* reset the watchdog and go active (0xec) */
val = (SYS_CONTROL_A_HWRES_ENABLE |
(0x6<<4) |
SYS_CONTROL_A_WDOG_ACTION |
SYS_CONTROL_A_WATCHDOG);
if(i2c_write(addr, SYS_CONTROL_A, 1, &val, 1)) {
printf("Error accessing DA9030 via i2c.\n");
return;
}
i2c_reg_write(addr, REG_CONTROL_1_97, 0xfd); /* disable LDO1, enable LDO6 */
i2c_reg_write(addr, LDO2_3, 0xd1); /* LDO2 =1,9V, LDO3=3,1V */
i2c_reg_write(addr, LDO4_5, 0xcc); /* LDO2 =1,9V, LDO3=3,1V */
i2c_reg_write(addr, LDO6_SIMCP, 0x3e); /* LDO6=3,2V, SIMCP = 5V support */
i2c_reg_write(addr, LDO7_8, 0xc9); /* LDO7=2,7V, LDO8=3,0V */
i2c_reg_write(addr, LDO9_12, 0xec); /* LDO9=3,0V, LDO12=3,2V */
i2c_reg_write(addr, BUCK, 0x0c); /* Buck=1.2V */
i2c_reg_write(addr, REG_CONTROL_2_98, 0x7f); /* All LDO'S on 8,9,10,11,12,14 */
i2c_reg_write(addr, LDO_10_11, 0xcc); /* LDO10=3.0V LDO11=3.0V */
i2c_reg_write(addr, LDO_15, 0xae); /* LDO15=1.8V, dislock first 3bit */
i2c_reg_write(addr, LDO_14_16, 0x05); /* LDO14=2.8V, LDO16=NB */
i2c_reg_write(addr, LDO_18_19, 0x9c); /* LDO18=3.0V, LDO19=2.7V */
i2c_reg_write(addr, LDO_17_SIMCP0, 0x2c); /* LDO17=3.0V, SIMCP=3V support */
i2c_reg_write(addr, BUCK2_DVC1, 0x9a); /* Buck2=1.5V plus Update support of 520 MHz */
i2c_reg_write(addr, REG_CONTROL_2_18, 0x43); /* Ball on */
i2c_reg_write(addr, MISC_CONTROLB, 0x08); /* session valid enable */
i2c_reg_write(addr, USBPUMP, 0xc1); /* start pump, ignore HW signals */
val = i2c_reg_read(addr, STATUS);
if(val & STATUS_CHDET)
printf("Charger detected, turning on LED.\n");
else {
printf("No charger detetected.\n");
/* undervoltage? print error and power down */
}
}
static int rk818_pre_init(unsigned char bus,uchar addr)
{
debug("%s,line=%d\n", __func__,__LINE__);
i2c_set_bus_num(bus);
i2c_init(RK818_I2C_SPEED, addr);
i2c_set_bus_speed(RK818_I2C_SPEED);
i2c_reg_write(addr, 0xa1,i2c_reg_read(addr,0xa1)|0x70); /*close charger when usb low then 3.4V*/
i2c_reg_write(addr, 0x52,i2c_reg_read(addr,0x52)|0x02); /*no action when vref*/
i2c_reg_write(addr, RK818_DCDC_EN_REG,
i2c_reg_read(addr, RK818_DCDC_EN_REG) |0x60); /*enable switch & ldo9*/
// i2c_reg_write(addr, RK818_LDO_EN_REG,
// i2c_reg_read(addr, RK818_LDO_EN_REG) |0x28);
/**********enable clkout2****************/
i2c_reg_write(addr,RK818_CLK32OUT_REG,0x01);
return 0;
}
int rk818_regulator_enable(int num_regulator)
{
if (num_regulator < 4)
i2c_reg_write(RK818_I2C_ADDR, RK818_DCDC_EN_REG,
i2c_reg_read(RK818_I2C_ADDR, RK818_DCDC_EN_REG) |(1 << num_regulator)); //enable dcdc
else if (num_regulator == 12)
i2c_reg_write(RK818_I2C_ADDR, RK818_DCDC_EN_REG,
i2c_reg_read(RK818_I2C_ADDR,RK818_DCDC_EN_REG) |(1 << 5)); //enable ldo9
else if (num_regulator == 13)
i2c_reg_write(RK818_I2C_ADDR, RK818_DCDC_EN_REG,
i2c_reg_read(RK818_I2C_ADDR,RK818_DCDC_EN_REG) |(1 << 6)); //enable ldo10
else
i2c_reg_write(RK818_I2C_ADDR, RK818_LDO_EN_REG,
i2c_reg_read(RK818_I2C_ADDR,RK818_LDO_EN_REG) |(1 << (num_regulator -4))); //enable ldo
debug("1 %s %d dcdc_en = %08x ldo_en =%08x\n", __func__, num_regulator, i2c_reg_read(RK818_I2C_ADDR,RK818_DCDC_EN_REG), i2c_reg_read(RK818_I2C_ADDR,RK818_LDO_EN_REG));
return 0;
}
int pmic_rk808_init(unsigned char bus)
{
int ret;
if (!rk808.pmic) {
ret = rk808_parse_dt(gd->fdt_blob);
if (ret < 0)
return ret;
}
rk808.pmic->interface = PMIC_I2C;
//enable lcdc power ldo, and enable other ldo
i2c_set_bus_num(rk808.pmic->bus);
charger_init(0);
i2c_init(RK808_I2C_SPEED, rk808.pmic->hw.i2c.addr);
i2c_set_bus_speed(RK808_I2C_SPEED);
i2c_reg_write(0x1b,0x23,i2c_reg_read(0x1b,0x23)|0x60);
i2c_reg_write(0x1b,0x45,0x02);
i2c_reg_write(0x1b,0x24,i2c_reg_read(0x1b,0x24)|0x28);
return 0;
}
void ethernut5_print_celsius(void)
{
int val;
/* Read ADC value from LM50 and return Celsius degrees. */
val = i2c_reg_read(PWRMAN_I2C_ADDR, PWRMAN_REG_TEMP);
val *= 5000; /* 100mV/degree with 5V reference */
val += 128; /* 8 bit resolution */
val /= 256;
val -= 450; /* Celsius offset, still x10 */
/* Output full degrees. */
printf("%d\n", (val + 5) / 10);
}
int mpu6050_init(void)
{
memset(&raw_offset, 0, sizeof(raw_offset));
i2c_bus_init(MPU6050_ADDR);
i2c_reg_read(REG_WHO_AM_I, 1, _who_am_i_cb);
//config data ready interruption
P1DIR |= BIT5;//input
P2IE |= BIT5;//enable interruption
P2IES &= ~BIT5;//0 = low to high | 1 = high to low
P2IFG &= ~BIT5;//clean int
return 0;
}
void ethernut5_print_power(void)
{
u8 flags;
int i;
flags = i2c_reg_read(PWRMAN_I2C_ADDR, PWRMAN_REG_ENA);
for (i = 0; i < 2; i++) {
if (flags) {
print_flagged_features(flags);
printf("%s\n", i ? "off" : "on");
}
flags = ~flags;
}
}
void ethernut5_print_voltage(void)
{
int val;
/* Read ADC value from divider and return voltage. */
val = i2c_reg_read(PWRMAN_I2C_ADDR, PWRMAN_REG_VAUX);
/* Resistors are 100k and 12.1k */
val += 5;
val *= 180948;
val /= 100000;
val++;
/* Calculation was done in 0.1V units. */
printf("%d\n", (val + 5) / 10);
}
static int w83782d_hwmon_init(void)
{
u8 buf;
if (i2c_read(CONFIG_SYS_I2C_W83782G_ADDR, W83782D_REG_CFG, 1, &buf, 1))
return -1;
i2c_reg_write(CONFIG_SYS_I2C_W83782G_ADDR, W83782D_REG_CFG, 0x80);
i2c_reg_write(CONFIG_SYS_I2C_W83782G_ADDR, W83782D_REG_BANK_SEL, 0);
i2c_reg_write(CONFIG_SYS_I2C_W83782G_ADDR, W83782D_REG_ADCCLK, 0x40);
buf = i2c_reg_read(CONFIG_SYS_I2C_W83782G_ADDR, W83782D_REG_BEEP_CTRL);
i2c_reg_write(CONFIG_SYS_I2C_W83782G_ADDR, W83782D_REG_BEEP_CTRL,
buf | 0x80);
i2c_reg_write(CONFIG_SYS_I2C_W83782G_ADDR, W83782D_REG_BEEP_CTRL2, 0);
i2c_reg_write(CONFIG_SYS_I2C_W83782G_ADDR, W83782D_REG_PWMOUT1, 0x47);
i2c_reg_write(CONFIG_SYS_I2C_W83782G_ADDR, W83782D_REG_VBAT, 0x01);
buf = i2c_reg_read(CONFIG_SYS_I2C_W83782G_ADDR, W83782D_REG_CFG);
i2c_reg_write(CONFIG_SYS_I2C_W83782G_ADDR, W83782D_REG_CFG,
(buf & 0xf4) | 0x01);
return 0;
}
/*
* Enable Ethernut 5 power management.
*
* This function must be called during board initialization.
* While we are using u-boot's I2C subsystem, it may be required
* to enable the serial port before calling this function,
* in particular when debugging is enabled.
*
* If board specific commands are not available, we will activate
* all board components.
*/
void ethernut5_power_init(void)
{
pwrman_minor = i2c_reg_read(PWRMAN_I2C_ADDR, PWRMAN_REG_VERS);
pwrman_major = pwrman_minor >> 4;
pwrman_minor &= 15;
#ifndef CONFIG_CMD_BSP
/* Do not modify anything, if we do not have a known version. */
if (pwrman_major == 2) {
/* Without board specific commands we enable all features. */
i2c_reg_write(PWRMAN_I2C_ADDR, PWRMAN_REG_ENA, ~PWRMAN_ETHRST);
i2c_reg_write(PWRMAN_I2C_ADDR, PWRMAN_REG_DIS, PWRMAN_ETHRST);
}
#endif
}
static int ricoh619_i2c_probe(u32 bus, u32 addr)
{
uchar val;
int ret;
i2c_set_bus_num(bus);
i2c_init (RICOH619_I2C_SPEED, 0);
ret = i2c_probe(addr);
if (ret < 0)
return -ENODEV;
val = i2c_reg_read(addr, 0x36);
if ((val == 0xff) || (val == 0))
return -ENODEV;
else
return 0;
}
static int rt5025_i2c_probe(u32 bus, u32 addr)
{
char val;
int ret;
i2c_set_bus_num(bus);
i2c_init(RT5025_I2C_SPEED, 0);
ret = i2c_probe(addr);
if (ret < 0)
return -ENODEV;
val = i2c_reg_read(addr, 0x00);
if (val != 0x81)
return -ENODEV;
else
return 0;
}
