S5PV210 uboot fastboot_shutdown 干什么用的？

Wince.Android

S5PV210 uboot fastboot_shutdown 干什么用的？ [复制链接]

在S5PV210 fastboot 的代码里面有

/* Cleans up the board specific fastboot */
void fastboot_shutdown(void)
{
        DBG0("\n");
        /* when operation is done, usbd must be stopped */
        fboot_usb_stop();
}


int fboot_usb_stop (void)
{
        DBG0("\n");
        /* dont used in usb high speed, but used in common file cmd_usbd.c  */
        fboot_usb_core_soft_reset();
        fboot_usb_phy_off();
        return 0;
}
void fboot_usb_core_soft_reset(void)
{
        u32 tmp;
        DBG0("\n");

        writel(CORE_SOFT_RESET, S5P_OTG_GRSTCTL);

        do
        {
                tmp = readl(S5P_OTG_GRSTCTL);
        }while(!(tmp & AHB_MASTER_IDLE));

}

/* OTG PHY Power Off */
void fboot_usb_phy_off(void) {
#if defined(CONFIG_S5PC110)
        writel(readl(S5P_OTG_PHYPWR)|(0x18), S5P_OTG_PHYPWR);
        writel(readl(USB_PHY_CONTROL)&~(1<<0), USB_PHY_CONTROL);
#elif defined(CONFIG_S5PC100)
        writel(readl(S5P_OTG_PHYPWR)|(0x3<<3), S5P_OTG_PHYPWR);
        OTHERS_REG &= ~(1<<16);
#else
#error "* CFG_ERROR : you have to select C100 or C110 for Android Fastboot"
#endif
}

1. 
   
2. 
   
3. int do_fastboot (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
   
4. {
   
5.         int ret = 1;
   
6.         int check_timeout = 0;
   
7.         uint64_t timeout_endtime = 0;
   
8.         uint64_t timeout_ticks = 0;
   
9.         long timeout_seconds = -1;
   
10.         int continue_from_disconnect = 0;
    
11. 
    
12.         if (set_partition_table())
    
13.                 return 1;
    
14. 
    
15. 
    
16.         /* Time out */
    
17.         if (2 == argc)
    
18.         {
    
19.                 long try_seconds;
    
20.                 char *try_seconds_end;
    
21.                 /* Check for timeout */
    
22.                 try_seconds = simple_strtol(argv[1], &try_seconds_end, 10);
    
23.                 if ((try_seconds_end != argv[1]) && (try_seconds >= 0))
    
24.                 {
    
25.                         check_timeout = 1;
    
26.                         timeout_seconds = try_seconds;
    
27.                         printf("Fastboot inactivity timeout %ld seconds\n", timeout_seconds);
    
28.                 }
    
29.         }
    
30. 
    
31.         if (1 == check_timeout)
    
32.         {
    
33.                 timeout_ticks = (uint64_t) (timeout_seconds * get_tbclk());
    
34.         }
    
35. 
    
36. 
    
37.         do
    
38.         {
    
39.                 continue_from_disconnect = 0;
    
40. 
    
41.                 /* Initialize the board specific support */
    
42.                 if (0 == fastboot_init(&interface))
    
43.                 {
    
44.                         int poll_status;
    
45. 
    
46.                         /* If we got this far, we are a success */
    
47.                         ret = 0;
    
48. 
    
49.                         timeout_endtime = get_ticks();
    
50.                         timeout_endtime += timeout_ticks;
    
51. 
    
52.                         LCD_turnon();
    
53. 
    
54.                         while (1)
    
55.                         {
    
56.                                 uint64_t current_time = 0;
    
57.                                 poll_status = fastboot_poll();
    
58. 
    
59.                                 if (1 == check_timeout)
    
60.                                         current_time = get_ticks();
    
61. 
    
62.                                 /* Check if the user wanted to terminate with ^C */
    
63.                                 if ((poll_status != FASTBOOT_OK) && (ctrlc()))
    
64.                                 {
    
65.                                         printf("Fastboot ended by user\n");
    
66.                                         continue_from_disconnect = 0;
    
67.                                         break;
    
68.                                 }
    
69. 
    
70.                                 if (FASTBOOT_ERROR == poll_status)
    
71.                                 {
    
72.                                         /* Error */
    
73.                                         printf("Fastboot error \n");
    
74.                                         break;
    
75.                                 }
    
76.                                 else if (FASTBOOT_DISCONNECT == poll_status)
    
77.                                 {
    
78.                                         /* break, cleanup and re-init */
    
79.                                         printf("Fastboot disconnect detected\n");
    
80.                                         continue_from_disconnect = 1;
    
81.                                         break;
    
82.                                 }
    
83.                                 else if ((1 == check_timeout) &&
    
84.                                            (FASTBOOT_INACTIVE == poll_status))
    
85.                                 {
    
86.                                         /* No activity */
    
87.                                         if (current_time >= timeout_endtime)
    
88.                                         {
    
89.                                                 printf("Fastboot inactivity detected\n");
    
90.                                                 break;
    
91.                                         }
    
92.                                 }
    
93.                                 else
    
94.                                 {
    
95.                                         /* Something happened */
    
96.                                         /* Actual works of parsing are done by rx_handler */
    
97.                                         if (1 == check_timeout)
    
98.                                         {
    
99.                                                 /* Update the timeout endtime */
    
100.                                                 timeout_endtime = current_time;
     
101.                                                 timeout_endtime += timeout_ticks;
     
102.                                         }
     
103.                                 }
     
104.                         } /* while (1) */
     
105.                 }
     
106. 
     
107. <b><font color="#ff8c00">                /* Reset the board specific support */
     
108.                 fastboot_shutdown();</font></b>
     
109. 
     
110.                 LCD_setfgcolor(0x000010);
     
111.                 LCD_setleftcolor(0x000010);
     
112.                 LCD_setprogress(100);
     
113. 
     
114.                 /* restart the loop if a disconnect was detected */
     
115.         } while (continue_from_disconnect);
     
116. 
     
117.         return ret;
     
118. }
     

复制代码

Wince.Android

这个相当于复位一下，fastboot 完成以后，仅此而已！