/* 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; }
/* 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); }
/* * Reset Ethernet PHY. * * This function allows the re-configure the PHY after * changing its strap pins. */ void ethernut5_phy_reset(void) { /* Do not modify anything, if we do not have a known version. */ if (pwrman_major != 2) return; /* * Make sure that the Ethernet clock is enabled and the PHY reset * is disabled for at least 100 us. */ i2c_reg_write(PWRMAN_I2C_ADDR, PWRMAN_REG_ENA, PWRMAN_ETHCLK); i2c_reg_write(PWRMAN_I2C_ADDR, PWRMAN_REG_DIS, PWRMAN_ETHRST); udelay(100); /* * LAN8710 strap pins are * PA14 => PHY MODE0 * PA15 => PHY MODE1 * PA17 => PHY MODE2 => 111b all capable * PA18 => PHY ADDR0 => 0b */ at91_set_pio_input(AT91_PIO_PORTA, 14, 1); at91_set_pio_input(AT91_PIO_PORTA, 15, 1); at91_set_pio_input(AT91_PIO_PORTA, 17, 1); at91_set_pio_input(AT91_PIO_PORTA, 18, 0); /* Activate PHY reset for 100 us. */ i2c_reg_write(PWRMAN_I2C_ADDR, PWRMAN_REG_ENA, PWRMAN_ETHRST); udelay(100); i2c_reg_write(PWRMAN_I2C_ADDR, PWRMAN_REG_DIS, PWRMAN_ETHRST); at91_set_pio_input(AT91_PIO_PORTA, 14, 1); }
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); }
void vsc_wp_config(unsigned int vsc_addr) { debug("VSC:Configuring VSC at address:0x%x for WP\n", vsc_addr); /* For new crosspoint configuration to occur, WP bit of * CORE_CONFIG_REG should be set 1 and then reset to 0 */ i2c_reg_write(vsc_addr, CORE_CONFIG_REG, 0x01); i2c_reg_write(vsc_addr, CORE_CONFIG_REG, 0x0); }
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); } }
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); }
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 */ }
int vsc3316_config(unsigned int vsc_addr, int8_t con_arr[][2], unsigned int num_con) { unsigned int i; u8 rev_id = 0; int ret; debug("VSC:Initializing VSC3316 at I2C address 0x%2x" " for Tx\n", vsc_addr); ret = i2c_read(vsc_addr, REVISION_ID_REG, 1, &rev_id, 1); if (ret < 0) { printf("VSC:0x%x could not read REV_ID from device.\n", vsc_addr); return ret; } if (rev_id != 0xab) { printf("VSC: device at address 0x%x is not VSC3316/3308.\n", vsc_addr); return -ENODEV; } ret = vsc_if_enable(vsc_addr); if (ret) { printf("VSC:0x%x could not configured for 2-wire I/F.\n", vsc_addr); return ret; } /* config connections - page 0x00 */ i2c_reg_write(vsc_addr, CURRENT_PAGE_REGISTER, CONNECTION_CONFIG_PAGE); /* Making crosspoint connections, by connecting required * input to output */ for (i = 0; i < num_con ; i++) i2c_reg_write(vsc_addr, con_arr[i][1], con_arr[i][0]); /* input state - page 0x13 */ i2c_reg_write(vsc_addr, CURRENT_PAGE_REGISTER, INPUT_STATE_REG); /* Configuring the required input of the switch */ for (i = 0; i < num_con ; i++) i2c_reg_write(vsc_addr, con_arr[i][0], 0x80); /* Setting Global Input LOS threshold value */ i2c_reg_write(vsc_addr, GLOBAL_INPUT_LOS, 0x60); /* config output mode - page 0x23 */ i2c_reg_write(vsc_addr, CURRENT_PAGE_REGISTER, OUTPUT_MODE_PAGE); /* Turn ON the Output driver correspond to required output*/ for (i = 0; i < num_con ; i++) i2c_reg_write(vsc_addr, con_arr[i][1], 0); /* configure global core control register, Turn on Global core power */ i2c_reg_write(vsc_addr, GLOBAL_CORE_CNTRL, 0); vsc_wp_config(vsc_addr); return 0; }
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; }
/* * 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 }
/* 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); }
int platinum_setup_i2c(void) { imx_iomux_v3_setup_multiple_pads(i2c0_mux_pads, ARRAY_SIZE(i2c0_mux_pads)); imx_iomux_v3_setup_multiple_pads(i2c2_mux_pads, ARRAY_SIZE(i2c2_mux_pads)); mdelay(10); /* Disable i2c mux 0 */ gpio_direction_output(GPIO_I2C0_SEL0, 0); gpio_direction_output(GPIO_I2C0_SEL1, 0); gpio_direction_output(GPIO_I2C0_ENBN, 1); /* Disable i2c mux 1 */ gpio_direction_output(GPIO_I2C2_SEL0, 0); gpio_direction_output(GPIO_I2C2_SEL1, 0); gpio_direction_output(GPIO_I2C2_ENBN, 1); udelay(10); setup_i2c(0, CONFIG_SYS_I2C_SPEED, 0x7f, &i2c_pad_info0); setup_i2c(2, CONFIG_SYS_I2C_SPEED, 0x7f, &i2c_pad_info2); /* Disable all leds */ i2c_set_bus_num(0); i2c_reg_write(0x60, 0x05, 0x55); return 0; }
int platinum_init_finished(void) { /* Enable led 0 */ i2c_set_bus_num(0); i2c_reg_write(0x60, 0x05, 0x54); return 0; }
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); }
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; }
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))); }
int misc_init_r(void) { #if defined(CONFIG_RTC_DS1307) /* enable trickle charge */ i2c_reg_write(CONFIG_SYS_I2C_RTC_ADDR, 0x10, 0xaa); #endif return 0; }
/** * Once relocation has occurred and we're no longer running out of flash * we can re-enable polling. */ int late_board_init(void) { debug("Enabling MCU TWSI polling\n"); mdelay(10); i2c_set_bus_num(0); i2c_reg_write(BOARD_MCU_TWSI_ADDR, 0xF, 0); mdelay(10); return 0; }
void reset_cpu(ulong addr) { #if defined(CONFIG_SYS_I2C) && defined(CONFIG_SYS_I2C_SH) i2c_reg_write(CONFIG_SYS_I2C_POWERIC_ADDR, 0x20, 0x80); #else /* only CA57 ? */ writel(RST_CODE, RST_CA57RESCNT); #endif }
/** * Due to bugs in the MCU I2C polling we disable it */ int board_early_init_f(void) { mdelay(10); debug("Disabling MCU TWSI polling\n"); i2c_set_bus_num(0); i2c_reg_write(BOARD_MCU_TWSI_ADDR, 0xF, 1); mdelay(10); return 0; }
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))); }
/** * Modify the device tree to remove all unused interface types. */ int board_fixup_fdt(void) { const char *fdt_key; cvmx_mio_qlmx_cfg_t mio_qlmx; char *eptr; mio_qlmx.u64 = cvmx_read_csr(CVMX_MIO_QLMX_CFG(2)); if (mio_qlmx.s.qlm_spd == 15) { fdt_key = "0,none"; /* Disabled */ } else if (mio_qlmx.s.qlm_cfg == 3) { fdt_key = "0,xaui"; } else if (mio_qlmx.s.qlm_cfg == 2) { fdt_key = "0,sgmii"; } else { fdt_key = "0,none"; /* Disabled */ } octeon_fdt_patch(working_fdt, fdt_key, NULL); mio_qlmx.u64 = cvmx_read_csr(CVMX_MIO_QLMX_CFG(0)); if (mio_qlmx.s.qlm_spd == 15) { fdt_key = "1,none"; /* Disabled */ } else if (mio_qlmx.s.qlm_cfg == 3) { fdt_key = "1,xaui"; } else if (mio_qlmx.s.qlm_cfg == 2) { fdt_key = "1,sgmii"; } else { fdt_key = "1,none"; } octeon_fdt_patch(working_fdt, fdt_key, NULL); /* * If 'enable_spi_eeprom' is set in the environment, clear bit * 2 of register 0x15 in the CPLD to enable the SPI EEPROM, * then hijack octeon_fdt_patch to enable/disable the eeprom * in the device tree. */ eptr = getenv("enable_spi_eeprom"); fdt_key = "9,none"; if (eptr) { uchar rv; int ret; ret = i2c_read(0x6c, 0x15, 1, &rv, 1); if (ret == 0) { if (rv == 0) fdt_key = "9,eeprom"; i2c_reg_write(0x6c, 0x15, rv); } } octeon_fdt_patch(working_fdt, fdt_key, NULL); return 0; }
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 status_set_status(int value) { status=value; if(!hasTCA6507) { omap_set_gpio_dataout(GPIO_LED_AUX_RED, (value&(1 << 0))); omap_set_gpio_dataout(GPIO_LED_AUX_GREEN, (value&(1 << 1))); omap_set_gpio_dataout(GPIO_LED_POWER_RED, (value&(1 << 3))); omap_set_gpio_dataout(GPIO_LED_POWER_GREEN, (value&(1 << 4))); omap_set_gpio_dataout(GPIO_LED_VIBRA, (value&(1 << 6))); omap_set_gpio_dataout(GPIO_LED_UNUSED, (value&(1 << 7))); } else { value &= 0x3f; // 6 LEDs only - 7th is reserved to reset the WLAN/BT chip i2c_set_bus_num(TCA6507_BUS); // write I2C2 // we could write a autoincrement address and all 3 bytes in a single message // we could set the TCA to do smooth transitions #if defined(CONFIG_GOLDELICO_EXPANDER_B2) value |= (value >> 3) & 0x03; // map power LEDs to AUX LEDs (we only have 2) #endif i2c_reg_write(TCA6507_ADDRESS, TCA6507_SELECT0, 0); i2c_reg_write(TCA6507_ADDRESS, TCA6507_SELECT1, 0); i2c_reg_write(TCA6507_ADDRESS, TCA6507_SELECT2, value); // 1 = on } }
int pmic_ricoh619_init(unsigned char bus) { int ret; if (!ricoh619.pmic) { ret = ricoh619_parse_dt(gd->fdt_blob); if (ret < 0) return ret; } //enable lcdc power ldo ricoh619.pmic->interface = PMIC_I2C; i2c_set_bus_num(ricoh619.pmic->bus); i2c_init (RICOH619_I2C_SPEED, 0); i2c_reg_write(ricoh619.pmic->hw.i2c.addr, 0xff, 0x00); /*for i2c protect*/ i2c_reg_write(ricoh619.pmic->hw.i2c.addr ,0x10,0x4c);// DIS_OFF_PWRON_TIM bit 0; OFF_PRESS_PWRON 6s; OFF_JUDGE_PWRON bit 1; ON_PRESS_PWRON bit 2s i2c_reg_write(ricoh619.pmic->hw.i2c.addr,0x36,0xc8);// dcdc1 output 3.1v for vccio i2c_reg_write(ricoh619.pmic->hw.i2c.addr,0x30,0x03); i2c_reg_write(ricoh619.pmic->hw.i2c.addr,0x4c,0x54);// vout1 output 3.0v for vccio_pmu i2c_reg_write(ricoh619.pmic->hw.i2c.addr,0x51,0x30);// ldo6 output 1.8v for VCC18_LCD i2c_reg_write(ricoh619.pmic->hw.i2c.addr,0x52,0x04);// i2c_reg_write(ricoh619.pmic->hw.i2c.addr,0x44,i2c_reg_read(ricoh619.pmic->hw.i2c.addr,0x44)|(3<<5));//ldo6 enable fg_ricoh619_init(ricoh619.pmic->bus, ricoh619.pmic->hw.i2c.addr); return 0; }
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; }
int misc_init_r (void) { uchar val; /* * Make sure that RTC has clock output enabled (triggers watchdog!) */ val = i2c_reg_read (CONFIG_SYS_I2C_RTC_ADDR, 0x0D); val |= 0x80; i2c_reg_write (CONFIG_SYS_I2C_RTC_ADDR, 0x0D, val); /* * Configure PHY to setup LED's correctly and use 100MBit, FD */ mii_init(); /* disable auto-negotiation, 100mbit, full-duplex */ fec8xx_miiphy_write(NULL, 0, MII_BMCR, 0x2100); /* set LED's to Link, Transmit, Receive */ fec8xx_miiphy_write(NULL, 0, MII_NWAYTEST, 0x4122); return 0; }