/*
*******************************************************************************
* usb_op_clock
*
* Description:
* void
*
* Parameters:
* void
*
* Return value:
* void
*
* note:
* void
*
*******************************************************************************
*/
int usb_close_clock(void)
{
u32 reg_value = 0;
/* AHB reset */
reg_value = readl(SUNXI_CCM_BASE + 0x2C0);
reg_value &= ~(1 << 24);
writel(reg_value, (SUNXI_CCM_BASE + 0x2C0));
__msdelay(10);
//关usb ahb时钟
reg_value = readl(SUNXI_CCM_BASE + 0x60);
reg_value &= ~(1 << 24);
writel(reg_value, (SUNXI_CCM_BASE + 0x60));
//等sie的时钟变稳
__msdelay(10);
//关USB phy时钟
reg_value = readl(SUNXI_CCM_BASE + 0xcc);
reg_value &= ~((1 << 0) | (1 << 8));
writel(reg_value, (SUNXI_CCM_BASE + 0xcc));
__msdelay(10);
return 0;
}
/*
*******************************************************************************
* usb_open_clock
*
* Description:
* void
*
* Parameters:
* void
*
* Return value:
* void
*
* note:
* void
*
*******************************************************************************
*/
int usb_open_clock(void)
{
u32 reg_value = 0;
//Enable module clock for USB phy0
reg_value = readl(SUNXI_CCM_BASE + 0xcc);
reg_value |= (1 << 0) | (1 << 8);
writel(reg_value, (SUNXI_CCM_BASE + 0xcc));
//delay some time
__msdelay(10);
//Gating AHB clock for USB_phy0
reg_value = readl(SUNXI_CCM_BASE + 0x60);
reg_value |= (1 << 24);
writel(reg_value, (SUNXI_CCM_BASE + 0x60));
//delay to wati SIE stable
__msdelay(10);
/* AHB reset */
reg_value = readl(SUNXI_CCM_BASE + 0x2C0);
reg_value |= (1 << 24);
writel(reg_value, (SUNXI_CCM_BASE + 0x2C0));
__msdelay(10);
return 0;
}
static int board_probe_power_level(void)
{
int power_status;
int power_start;
//清除power按键
axp_probe_key();
//获取电源状态
power_status = axp_get_power_vol_level();
debug("power status = %d\n", power_status);
if(power_status == BATTERY_RATIO_TOO_LOW_WITHOUT_DCIN)
{
tick_printf("battery power is low without no dc or ac, should be set off\n");
sunxi_bmp_display("bat\\low_pwr.bmp");
__msdelay(3000);
return -1;
}
power_start = 0;
//power_start的含义
//0: 不允许插火牛直接开机，必须通过判断：满足以下条件可以直接开机：长按power按键，前次是系统状态，如果电池电量过低，则不允许开机
//1: 任意状态下，允许插火牛直接开机，同时要求电池电量足够高
//2: 不允许插火牛直接开机，必须通过判断：满足以下条件可以直接开机：长按power按键，前次是系统状态，不要求电池电量
//3: 任意状态下，允许插火牛直接开机，不要求电池电量
script_parser_fetch(PMU_SCRIPT_NAME, "power_start", &power_start, 1);
debug("power start cause = %d\n", power_start);
if(power_status == BATTERY_RATIO_TOO_LOW_WITH_DCIN)//低电，同时带外部电源状态下
{
if(!(power_start & 0x02)) //需要判断当前电池电量，要求power_start的第1bit的值为0
{ //此种情况下，直接关机
tick_printf("battery low power with dc or ac, should charge longer\n");
sunxi_bmp_display("bat\\bempty.bmp");
__msdelay(3000);
return -2;
}
else
{
if(power_start == 3) //不需要判断当前电池电量，如果为3，则进入系统，如果为0，则进行后续判断
{
return 0;
}
}
}
else //电池电量足够情况下，或者没有电池
{
if(power_start & 0x01) //如果第0bit的值为1，则进入系统
{
return 0;
}
}
return 1;
}
void set_cpus_i2c_clock(void)
{
int reg_value = 0;
reg_value = readl(R_PRCE_APB0_RESET);
reg_value |= 0x01 << 6;
writel(reg_value,R_PRCE_APB0_RESET);
__msdelay(1);
reg_value = readl(R_PRCM_APB0_GATING);
reg_value |= 0x01 << 6;
writel(reg_value,R_PRCM_APB0_GATING);
__msdelay(1);
}
static int mmc_clk_io_onoff(int sdc_no, int onoff, const normal_gpio_cfg *gpio_info, int offset)
{
unsigned int rval;
struct sunxi_mmc_host* mmchost = &mmc_host[sdc_no];
if(sdc_no == 0)
{
/*
1. change the initial status of gpio-f;
2. change the bias voltage of gpio-f to 3.0V
*/
*(volatile unsigned int *)(0x06000800 + 0xB4) = 0x111111; //CFG0
*(volatile unsigned int *)(0x06000800 + 0xD0) = 0x555; //PULL0
*(volatile unsigned int *)(0x06000800 + 0xC4) = 0x3F; //DATA
__msdelay(5);
*(volatile unsigned int *)(0x06000800 + 0xC4) = 0x0;
__msdelay(5);
*(volatile unsigned int *)(0x06000800 + 0xC4) = 0x3F;
__msdelay(5);
*(volatile unsigned int *)(0x06000800 + 0x314) = 0xA; //BIAS
boot_set_gpio((void *)gpio_info, 8, 1);
}
else // if(sdc_no == 2)
{
boot_set_gpio((void *)(gpio_info + offset), 8, 1);
}
/* config ahb clock */
rval = readl(mmchost->hclkbase);
rval |= (1 << 8);
writel(rval, mmchost->hclkbase);
rval = readl(mmchost->hclkrst);
rval |= (1 << 8);
writel(rval, mmchost->hclkrst);
rval = readl(mmchost->commreg);
rval |= (1<<16)|(1<<18);
writel(rval, mmchost->commreg);
/* config mod clock */
writel(0x80000000, mmchost->mclkbase);
mmchost->mclk = 24000000;
dumphex32("ccmu", (char*)CCMM_REGS_BASE, 0x100);
dumphex32("gpio", (char*)PIOC_REGS_BASE, 0x100);
dumphex32("mmc", (char*)mmchost->reg, 0x100);
return 0;
}
/*
************************************************************************************************************
*
* function
*
* name :
*
* parmeters :
*
* return :
*
* note :
*
*
************************************************************************************************************
*/
int board_display_wait_lcd_open(void)
{
int ret;
int timedly = 5000;
int check_time = timedly/50;
uint arg[4] = { 0 };
do
{
ret = disp_ioctl(NULL, DISP_CMD_LCD_CHECK_OPEN_FINISH, (void*)arg);
if(ret == 1) //open already
{
break;
}
else if(ret == -1) //open falied
{
return -1;
}
__msdelay(50);
check_time --;
if(check_time <= 0)
{
return -1;
}
}
while(1);
return 0;
}
static int board_probe_battery_exist(void) //获取电池状态
{
int counter;
int dc_exist, bat_exist;
counter = 4;
do
{
dc_exist = 0;
bat_exist = 0;
axp_power_get_dcin_battery_exist(&dc_exist, &bat_exist);
printf("bat_exist=%d\n", bat_exist);
if(bat_exist == -1)
{
printf("bat is unknown\n");
__msdelay(500);
}
else
{
break;
}
}
while(counter --);
return bat_exist;
}
void set_debugmode_flag(void)
{
char c = 0;
int i = 0;
for(i = 0;i < 3;i++)
{
__msdelay(10);
if(sunxi_serial_tstc())
{
printf("key press :");
c = sunxi_serial_getc();
printf("0x%x \n",c);
break;
}
}
if(c == 's')
{
debug_mode = 1;
return ;
}
if(toc0_config->debug_mode)
debug_mode = 1;
else
debug_mode = 0;
return ;
}
/* ************************************************************************************************************ * * function * * name : 一键恢复的按键检测 * * parmeters : * * return : * * note : [email protected] * * ************************************************************************************************************ */ int check_boot_recovery_key(void) { user_gpio_set_t gpio_recovery; __u32 gpio_hd; int gpio_value = 0; int ret; ret = script_parser_fetch("system", "recovery_key", (int *)&gpio_recovery, sizeof(user_gpio_set_t)/4); if (!ret) { gpio_recovery.mul_sel = 0; //强制设置成输入 gpio_hd = gpio_request(&gpio_recovery, 1); if (gpio_hd) { int k; gpio_value = 0; for(k=0;k<4;k++) { gpio_value += gpio_read_one_pin_value(gpio_hd, 0); __msdelay(5); } if (!gpio_value) { printf("set to recovery\n"); return 0; } } } return 1; }
int mmc_send_status(struct mmc *mmc, int timeout)
{
struct mmc_cmd cmd;
int err;
cmd.cmdidx = MMC_CMD_SEND_STATUS;
cmd.resp_type = MMC_RSP_R1;
cmd.cmdarg = mmc->rca << 16;
cmd.flags = 0;
do {
err = mmc_send_cmd(mmc, &cmd, NULL);
if (err){
mmcinfo("mmc %d Send status failed\n",mmc->control_num);
return err;
}
else if (cmd.response[0] & MMC_STATUS_RDY_FOR_DATA)
break;
__msdelay(1);
if (cmd.response[0] & MMC_STATUS_MASK) {
mmcinfo("mmc %d Status Error: 0x%08X\n",mmc->control_num, cmd.response[0]);
return COMM_ERR;
}
} while (timeout--);
if (!timeout) {
mmcinfo("mmc %d Timeout waiting card ready\n",mmc->control_num);
return TIMEOUT;
}
return 0;
}
/*
************************************************************************************************************
*
* function
*
* name :
*
* parmeters :
*
* return :
*
* note :
*
*
************************************************************************************************************
*/
int main(void)
{
__s32 dram_size=0;
timer_init();
//serial init
sunxi_serial_init(fes1_head.prvt_head.uart_port, (void *)fes1_head.prvt_head.uart_ctrl, 2);
set_pll();
//enable gpio gate
set_gpio_gate();
//dram init
printf("beign to init dram\n");
#ifdef FPGA_PLATFORM
dram_size = mctl_init((void *)fes1_head.prvt_head.dram_para);
#else
dram_size = init_DRAM(0, (void *)fes1_head.prvt_head.dram_para);
#endif
if (dram_size)
{
note_dram_log(1);
printf("init dram ok\n");
}
else
{
note_dram_log(0);
printf("init dram fail\n");
}
__msdelay(10);
return dram_size;
}
/*
************************************************************************************************************
*
* function
*
* name :
*
* parmeters :
*
* return :
*
* note :
*
*
************************************************************************************************************
*/
int board_display_wait_lcd_close(void)
{
int ret;
int timedly = 5000;
int check_time = timedly/50;
uint arg[4] = { 0 };
uint cmd = 0;
#if defined(CONFIG_VIDEO_SUNXI_V3)
cmd = DISP_LCD_CHECK_CLOSE_FINISH;
#else
cmd = DISP_CMD_LCD_CHECK_CLOSE_FINISH;
#endif
do
{
ret = disp_ioctl(NULL, cmd, (void*)arg);
if(ret == 1) //open already
{
break;
}
else if(ret == -1) //open falied
{
return -1;
}
__msdelay(50);
check_time --;
if(check_time <= 0)
{
return -1;
}
}
while(1);
return 0;
}
int check_boot_recovery_key(void)
{
user_gpio_set_t gpio_recovery;
__u32 gpio_hd;
int ret;
int gpio_value = 0;
int used = 0;
int mode = 0;
if(uboot_spare_head.boot_data.work_mode != WORK_MODE_BOOT)
{
return 0;
}
ret = script_parser_fetch("recovery_para", "used", (int *)&used, sizeof(int) / 4);
if (ret || !used)
{
printf("[recovery] no use\n");
return 0;
}
ret = script_parser_fetch("recovery_para", "recovery_key", (int *)&gpio_recovery, sizeof(user_gpio_set_t) / 4);
if (!ret)
{
gpio_recovery.mul_sel = 0; //强制设置成输入
gpio_hd = gpio_request(&gpio_recovery, 1);
if (gpio_hd)
{
int time;
gpio_value = 0;
for(time = 0; time < 4; time++)
{
gpio_value += gpio_read_one_pin_value(gpio_hd, 0);
__msdelay(5);
}
if (!gpio_value)
{
script_parser_fetch("recovery_para", "mode", (int *)&mode, sizeof(int) / 4);
if (mode == ONEKEY_USB_RECOVERY)
{
printf("set to one key usb recovery\n");
write_usb_recovery_to_misc();
}
else if (mode == ONEKEY_SPRITE_RECOVERY)
{
printf("set to one key sprite recovery\n");
setenv("bootcmd", "sprite_recovery");
}
else
{
printf("[recovery] no option for one key recovery's mode\n");
}
}
}
}
return 0;
}
/*
*******************************************************************************
* __boot
*
* Description:
* void
*
* Parameters:
* void
*
* Return value:
* void
*
* note:
* void
*
*******************************************************************************
*/
static void __boot(void)
{
char response[68];
if(all_download_bytes > CFG_FASTBOOT_MKBOOTIMAGE_PAGE_SIZE)
{
char start[32];
char *bootm[3] = { "bootm", NULL, NULL, };
char *go[3] = { "go", NULL, NULL, };
struct fastboot_boot_img_hdr *fb_hdr =
(struct fastboot_boot_img_hdr *) trans_data.base_recv_buffer;
/* Skip the mkbootimage header */
image_header_t *hdr =
(image_header_t *)
&trans_data.base_recv_buffer[CFG_FASTBOOT_MKBOOTIMAGE_PAGE_SIZE];
bootm[1] = go[1] = start;
sprintf(start, "0x%x", (uint)hdr);
printf("start addr %s\n", start);
/* Execution should jump to kernel so send the response
now and wait a bit. */
sprintf(response, "OKAY");
// fastboot_tx_status(response, strlen(response));
__msdelay (1000); /* 1 sec */
if (ntohl(hdr->ih_magic) == IH_MAGIC) {
/* Looks like a kernel.. */
printf ("Booting kernel..\n");
/*
* Check if the user sent a bootargs down.
* If not, do not override what is already there
*/
if (strlen ((char *) &fb_hdr->cmdline[0])) {
printf("Image has cmdline:");
printf("%s\n", &fb_hdr->cmdline[0]);
setenv ("bootargs", (char *) &fb_hdr->cmdline[0]);
}
do_bootm (NULL, 0, 2, bootm);
} else {
/* Raw image, maybe another uboot */
printf ("Booting raw image..\n");
do_go (NULL, 0, 2, go);
}
printf ("ERROR : bootting failed\n");
printf ("You should reset the board\n");
}
else
{
sprintf(response, "FAILinvalid boot image");
}
}
int check_physical_key_early(void)
{
user_gpio_set_t gpio_recovery;
__u32 gpio_hd;
int ret;
int gpio_value = 0;
int used = 0;
int mode = 0;
if(uboot_spare_head.boot_data.work_mode != WORK_MODE_BOOT)
{
return 0;
}
ret = script_parser_fetch("recovery_para", "used", (int *)&used, sizeof(int) / 4);
if (ret || !used)
{
printf("[recovery] no use\n");
return 0;
}
ret = script_parser_fetch("recovery_para", "recovery_key", (int *)&gpio_recovery, sizeof(user_gpio_set_t) / 4);
if (!ret)
{
gpio_recovery.mul_sel = 0; //强制设置成输入
gpio_hd = gpio_request(&gpio_recovery, 1);
if (gpio_hd)
{
int time;
gpio_value = 0;
for(time = 0; time < 4; time++)
{
gpio_value += gpio_read_one_pin_value(gpio_hd, 0);
__msdelay(5);
}
if (!gpio_value)
{
printf("[box recovery] find the key\n");
script_parser_fetch("recovery_para", "mode", (int *)&mode, sizeof(int) / 4);
if (mode == ONEKEY_USB_RECOVERY_MODE)
{
gd->key_pressd_value = USB_RECOVERY_KEY_VALUE;
}
else if (mode == ONEKEY_SPRITE_RECOVERY_MODE)
{
gd->key_pressd_value = SPRITE_RECOVERY_KEY_VALUE;
uboot_spare_head.boot_data.work_mode = WORK_MODE_SPRITE_RECOVERY;
}
else
{
printf("[recovery] no option for one key recovery's mode (%d)\n", mode);
}
}
}
}
return 0;
}
/*
************************************************************************************************************
*
* function
*
* name :
*
* parmeters :
*
* return :
*
* note :
*
*
************************************************************************************************************
*/
static int boot0_clear_env(void)
{
reset_pll();
mmu_turn_off();
__msdelay(10);
return 0;
}
void set_i2c_clock(void)
{
int reg_value = 0;
#if !defined(CONFIG_ARCH_SUN5I)||!defined(CONFIG_ARCH_SUN7I)
/* reset i2c clock */
/* reset apb2 twi0*/
reg_value = readl(CCMU_BUS_SOFT_RST_REG4);
reg_value |= 0x01 << bus_num;
writel(reg_value, CCMU_BUS_SOFT_RST_REG4);
__msdelay(1);
#endif
reg_value = readl(CCMU_BUS_CLK_GATING_REG3);
reg_value &= ~(1<<bus_num);
writel(reg_value,CCMU_BUS_CLK_GATING_REG3);
__msdelay(1);
reg_value |= (1 << bus_num);
writel(reg_value,CCMU_BUS_CLK_GATING_REG3);
}
/*
*******************************************************************************
* __fastboot_reboot
*
* Description:
* void
*
* Parameters:
* void
*
* Return value:
* void
*
* note:
* void
*
*******************************************************************************
*/
static int __fastboot_reboot(int word_mode)
{
char response[8];
sprintf(response,"OKAY");
__sunxi_fastboot_send_status(response, strlen(response));
__msdelay(1000); /* 1 sec */
sunxi_board_restart(word_mode);
return 0;
}
void hdmi_delay_ms(__u32 ms)
{
#if defined(__LINUX_PLAT__)
u32 timeout = ms*HZ/1000;
set_current_state(TASK_INTERRUPTIBLE);
schedule_timeout(timeout);
#elif defined(__UBOOT_OSAL__)
__msdelay(ms);
#endif
return ;
}
static int mmc_core_init(struct mmc *mmc)
{
struct sunxi_mmc_host* mmchost = (struct sunxi_mmc_host *)mmc->priv;
/* Reset controller */
writel(0x7, &mmchost->reg->gctrl);
while(readl(&mmchost->reg->gctrl)&0x7);
/* release eMMC reset signal */
writel(1, &mmchost->reg->hwrst);
writel(0, &mmchost->reg->hwrst);
__msdelay(1);
writel(1, &mmchost->reg->hwrst);
return 0;
}
/*
**********************************************************************************************************************
* i2c_init
*
* Description:
*
* Arguments :
*
* Returns : none
*
* Notes : none
*
**********************************************************************************************************************
*/
void i2c_exit(void)
{
#ifndef CONFIG_CPUS_I2C
int reg_value = 0;
reg_value = readl(CCMU_BUS_CLK_GATING_REG3);
reg_value &= ~(1<<bus_num);
writel(reg_value,CCMU_BUS_CLK_GATING_REG3);
#else
int reg_value = 0;
reg_value = *((unsigned int *)(R_PRCE_APB0_RESET));
reg_value &= ~(0x01 << 6);
*((unsigned int *)(R_PRCE_APB0_RESET)) = reg_value;
__msdelay(1);
reg_value = *((unsigned int *)(R_PRCM_APB0_GATING));
reg_value &= ~(0x01 << 6);
*((unsigned int *)(R_PRCM_APB0_GATING)) = reg_value;
__msdelay(1);
#endif
return ;
}/*
int mmc_go_idle(struct mmc* mmc)
{
struct mmc_cmd cmd;
int err;
__msdelay(1);
cmd.cmdidx = MMC_CMD_GO_IDLE_STATE;
cmd.cmdarg = 0;
cmd.resp_type = MMC_RSP_NONE;
cmd.flags = 0;
err = mmc_send_cmd(mmc, &cmd, NULL);
if (err){
mmcinfo("mmc %d go idle failed\n",mmc->control_num);
return err;
}
__msdelay(2);
return 0;
}
void DSI_delay_ms(__u32 ms)
{
#ifdef __LINUX_PLAT__
__u32 timeout = ms*HZ/1000;
set_current_state(TASK_INTERRUPTIBLE);
schedule_timeout(timeout);
#endif
#ifdef __BOOT_OSAL__
wBoot_timer_delay(ms);//assume cpu runs at 1000Mhz,10 clock one cycle
#endif
#ifdef __UBOOT_OSAL__
__msdelay(ms);
#endif
}
__s32 disp_mipipll_init(void)
{
MipiPllCtl = (__ccmu_mipi_pll_reg0040_t *)0x01c20040;
MipipllBias = (__ccmu_mipi_pll_bias_reg0240_t *)0x01c20240;
MipiPllCtl->PLLEn = 0;
MipiPllCtl->Ldo1En = 0;
MipiPllCtl->Ldo2En = 0;
MipiPllCtl->Ldo1En = 1;
MipiPllCtl->Ldo2En = 1;
MipiPllCtl->PllSrc = 0; //pll3
MipipllBias->pllvdd_ldo_out_ctrl = 0x7; //1.45v
__msdelay(2);
MipiPllCtl->PLLEn = 1;
return 0;
}
/*
************************************************************************************************************
*
* function
*
* name : sprite_cartoon_screen_set
*
* parmeters :
*
* return :
*
* note :
*
*
************************************************************************************************************
*/
int sprite_cartoon_screen_set(void)
{
#ifdef CONFIG_FPGA
return 0;
#else
/* 初始化图形参数 */
sprite_source.screen_width = borad_display_get_screen_width();
sprite_source.screen_height = borad_display_get_screen_height();
if((sprite_source.screen_width < 40) || (sprite_source.screen_height < 40))
{
printf("sunxi cartoon error: invalid screen width or height\n");
return -1;
}
sprite_source.screen_size = sprite_source.screen_width * sprite_source.screen_height * 4;
sprite_source.screen_buf = malloc(sprite_source.screen_size);
sprite_source.color = SPRITE_CARTOON_GUI_GREEN;
if(!sprite_source.screen_buf)
{
return -1;
}
memset(sprite_source.screen_buf, 0, sprite_source.screen_size);
board_display_framebuffer_set(sprite_source.screen_width, sprite_source.screen_height, 32, (void *)sprite_source.screen_buf);
#if defined(CONFIG_VIDEO_SUNXI_V3)
disp_layer_config *layer_para;
layer_para = (disp_layer_config *)gd->layer_para;
layer_para->info.alpha_mode = 0;
board_display_layer_para_set();
#elif defined(CONFIG_VIDEO_SUNXI_V2)
disp_layer_info *layer_para;
layer_para = (disp_layer_info *)gd->layer_para;
layer_para->alpha_mode = 0;
#else
__disp_layer_info_t *layer_para;
layer_para = (__disp_layer_info_t *)gd->layer_para;
layer_para->alpha_en = 0;
#endif
__msdelay(5);
return 0;
#endif
}
void fes1_entry(void)
{
cpu_init_s();
timer_init();
UART_open( fes1_head.prvt_head.uart_port, (void *)fes1_head.prvt_head.uart_ctrl, 24*1000*1000 );
UART_printf2("begin init dram\n");
if(init_DRAM(0, (void *)fes1_head.prvt_head.dram_para))
{
note_dram_log();
UART_printf2("init dram ok\n");
}
else
{
UART_printf2("init dram fail\n");
}
__msdelay(10);
return;
}
/*
************************************************************************************************************
*
* function
*
* name :
*
* parmeters :
*
* return :
*
* note :
*
*
************************************************************************************************************
*/
int main(void)
{
__s32 dram_size=0;
timer_init();
#ifdef CONFIG_ARCH_SUN9IW1P1
if(readl(CCM_PLL1_C0_CTRL))
{
set_pll();
}
#elif defined(CONFIG_ARCH_SUN8IW6P1)
if(readl(CCMU_PLL_C0CPUX_CTRL_REG))
{
set_pll();
}
#else
set_pll();
#endif
//serial init
sunxi_serial_init(fes1_head.prvt_head.uart_port, (void *)fes1_head.prvt_head.uart_ctrl, 2);
//enable gpio gate
set_gpio_gate();
//dram init
printf("beign to init dram\n");
dram_size = init_DRAM(0, (void *)fes1_head.prvt_head.dram_para);
if (dram_size)
{
note_dram_log(1);
printf("init dram ok\n");
}
else
{
note_dram_log(0);
printf("init dram fail\n");
}
__msdelay(10);
return dram_size;
}
static int mmc_update_clk(struct sunxi_mmc_host* mmchost)
{
struct mmc_reg_v4p1 *reg = (struct mmc_reg_v4p1 *)mmchost->reg;
unsigned int cmd;
unsigned timeout = 1000;
writel(readl(®->clkcr)|(0x1<<31), ®->clkcr);
cmd = (1U << 31) | (1 << 21) | (1 << 13);
writel(cmd, ®->cmd);
while((readl(®->cmd)&0x80000000) && --timeout){
__msdelay(1);
}
if (!timeout){
MMCINFO("mmc %d update clk failed\n",mmchost->mmc_no);
dumphex32("mmc", (char*)reg, 0x100);
return -1;
}
writel(readl(®->clkcr) & (~(0x1<<31)), ®->clkcr);
writel(readl(®->rint), ®->rint);
return 0;
}
/*
**********************************************************************************************************************
* i2c_init
*
* Description:
*
* Arguments :
*
* Returns : none
*
* Notes : none
*
**********************************************************************************************************************
*/
void i2c_exit(uint bus_id)
{
bus_id = bus_id;
#if defined(CONFIG_ARCH_SUN9IW1P1)
uint reg_value = 0;
reg_value = *((unsigned int *)CCM_APB1_GATE0_CTRL);
reg_value &= ~(0x01 << bus_id);
*((unsigned int *)CCM_APB1_GATE0_CTRL) = reg_value ;
#else
#if defined(CONFIG_ARCH_SUN8IW6P1)
uint reg_value = 0;
reg_value = *((unsigned int *)CCMU_BUS_CLK_GATING_REG3);
reg_value &= ~(0x01 << bus_id);
*((unsigned int *)CCMU_BUS_CLK_GATING_REG3) = reg_value ;
#else
struct sunxi_ccm_reg *ccm_reg = (struct sunxi_ccm_reg *)SUNXI_CCM_BASE;
/* close i2c clock */
ccm_reg->apb1_gate &= ~1;
#endif
#endif
__msdelay(1);
return ;
}
/**
*
*SUSB_Dev_Core_Rest - Issues core soft reset and PHY reset
*
*@hUSB:USBC_open_otg获得的句柄, 记录了USBC所需要的一些关键数据
*
*/
void SUSB_Dev_Core_Rest(void)
{
__u32 reg = 0;
/*Put Core in Reset*/
reg = readl(SUSB_GCTL);
reg |= SUSB_GCTL_CORESOFTRESET;
writel(reg, SUSB_GCTL);
/*Assert USB3 PHY reset*/
reg = readl(SUSB_GUSB3PIPECTL(0));
reg |= SUSB_GUSB3PIPECTL_PHYSOFTRST;
writel(reg, SUSB_GUSB3PIPECTL(0));
/*Assert USB2 PHY reset*/
reg = readl(SUSB_GUSB2PHYCFG(0));
reg |= SUSB_GUSB2PHYCFG_PHYSOFTRST;
writel(reg, SUSB_GUSB2PHYCFG(0));
__msdelay(10);
/*Clear USB3 PHY reset*/
reg = readl(SUSB_GUSB3PIPECTL(0));
reg &= ~SUSB_GUSB3PIPECTL_PHYSOFTRST;
writel(reg, SUSB_GUSB3PIPECTL(0));
/*Clear USB2 PHY reset*/
reg = readl(SUSB_GUSB2PHYCFG(0));
reg &= ~SUSB_GUSB2PHYCFG_PHYSOFTRST;
writel(reg, SUSB_GUSB2PHYCFG(0));
/*Clear the Core Reset*/
reg = readl(SUSB_GCTL);
reg &= ~SUSB_GCTL_CORESOFTRESET;
writel(reg, SUSB_GCTL);
}
