property/cmd_cboot.c

   1 #include <config.h>
   2 #include <common.h>
   3 #include <command.h>
   4 #include <linux/types.h>
   5 #include <linux/keypad.h>
   6 #include <linux/key_code.h>
   7 #include <boot_mode.h>
   8 #include <android_bootimg.h>
   9 #include <asm/arch/gpio.h>
  10 #include "tizen_misc.h"
  11
  12 #define COMMAND_MAX 128
  13
  14 #define DEBUG
  15 #ifdef DEBUG
  16 #define DBG(fmt...) printf(fmt)
  17 #else
  18 #define DBG(fmt...)
  19 #endif
  20
  21 extern int power_button_pressed(void);
  22 extern int charger_connected(void);
  23 extern int alarm_triggered(void);
  24 extern int cali_file_check(void);
  25 extern int get_mode_from_gpio(void);
  26 extern unsigned check_reboot_mode(void);
  27 extern int pctool_mode_detect(void);
  28 extern unsigned int get_pwr_key_cnt(void);
  29 #ifdef CONFIG_TIZEN
  30 boot_mode_enum_type tizen_check_keypad(void);
  31 #endif
  32 #ifdef CONFIG_LCD_LOGO
  33 extern void draw_image(int mode);
  34 extern void lcd_display(void);
  35 extern void MMU_DisableIDCM(void);
  36 #endif
  37 extern void cmd_mode_regist(CBOOT_MODE_ENTRY *array);
  38 extern void power_down_devices(unsigned pd_cmd);
  39 //extern void CHG_LateInit(void);
  40 //extern void CHG_LowBatChg(void);
  41
  42
  43 int boot_pwr_check(void)
  44 {
  45     static int total_cnt = 0;
  46     if(!power_button_pressed())
  47       total_cnt ++;
  48     return total_cnt;
  49 }
  50 #define mdelay(_ms) udelay(_ms*1000)
  51
  52 extern CBOOT_FUNC s_boot_func_array[CHECK_BOOTMODE_FUN_NUM] ;
  53
  54 static unsigned _reboot_mode_check(void)
  55 {
  56     static unsigned rst_mode = 0, check_times=0;
  57     if(!check_times)
  58     {
  59         rst_mode = check_reboot_mode();
  60         check_times++;
  61     }
  62     DBG("_reboot_mode_check rst_mode=0x%x\n",rst_mode);
  63     return rst_mode;
  64 }
  65
  66
  67 // 0 get mode from calibration detect
  68 boot_mode_enum_type get_mode_from_pctool (void){
  69         int ret = CMD_NONE;
  70     if(cali_file_check() && !boot_pwr_check())
  71         {
  72                 ret = pctool_mode_detect();
  73                 if(ret < 0)
  74                         return CMD_NONE;
  75                 else
  76                         return ret;
  77     }
  78         return CMD_NONE;
  79 }
  80
  81 #ifndef CONFIG_MACH_CORI
  82 #if !defined(CONFIG_KANAS_W) && !defined(CONFIG_KANAS_TD)
  83 boot_mode_enum_type get_mode_from_bat_low (void){
  84         while(is_bat_low()) {
  85                 if(charger_connected()) {
  86                         DBG("cboot:low battery,charging...\n");
  87                         mdelay(200);
  88                         //CHG_LowBatChg();
  89                 }else{
  90                         DBG("cboot:low battery and shutdown\n");
  91                         return CMD_POWER_DOWN_DEVICE;
  92                 }
  93         }
  94         if(charger_connected()){
  95                 //CHG_LateInit();
  96         }
  97         return CMD_NONE;
  98 }
  99 #endif
 100 #endif
 101
 102 #ifdef CONFIG_SPRD_SYSDUMP
 103 boot_mode_enum_type write_sysdump_before_boot_extend (void){
 104     unsigned rst_mode = _reboot_mode_check();
 105     write_sysdump_before_boot(rst_mode);
 106     return CMD_NONE;
 107 }
 108 #endif
 109
 110 // 1 get mode from file
 111 boot_mode_enum_type get_mode_from_file_extend (void){
 112     switch(get_mode_from_file()){
 113         case RECOVERY_MODE:
 114             DBG("cboot:get mode from file:recovery\n");
 115             return CMD_RECOVERY_MODE;
 116         default:
 117         return CMD_NONE;
 118     }
 119     return CMD_NONE;
 120 }
 121
 122 // 2 get mode from watch dog
 123 boot_mode_enum_type get_mode_from_watchdog (void){
 124     unsigned rst_mode = _reboot_mode_check();
 125     int flag;
 126
 127     switch(rst_mode){
 128         case RECOVERY_MODE:
 129             return CMD_RECOVERY_MODE;
 130         case FASTBOOT_MODE:
 131             return  CMD_FASTBOOT_MODE;
 132         case NORMAL_MODE:
 133             return CMD_NORMAL_MODE;
 134         case WATCHDOG_REBOOT:
 135             return CMD_WATCHDOG_REBOOT;
 136         case UNKNOW_REBOOT_MODE:
 137             return CMD_UNKNOW_REBOOT_MODE;
 138         case PANIC_REBOOT:
 139             return CMD_PANIC_REBOOT;
 140         case AUTODLOADER_REBOOT:
 141             return CMD_AUTODLOADER_REBOOT;
 142         case SPECIAL_MODE:
 143             return CMD_SPECIAL_MODE;
 144         case EXT_RSTN_REBOOT_MODE:
 145             return CMD_NORMAL_MODE;
 146         case IQ_REBOOT_MODE:
 147             return CMD_IQ_REBOOT_MODE;
 148         case ALARM_MODE:
 149         if((flag = alarm_flag_check())){
 150             DBG("get_mode_from_watchdog flag=%d\n", flag);
 151             if(flag == 1){
 152                 return CMD_ALARM_MODE;
 153             }
 154             else if(flag == 2){
 155                 return CMD_NORMAL_MODE;
 156             }
 157         }
 158         default:
 159             return CMD_NONE;
 160     }
 161 }
 162
 163 // 3 get mode from alarm register
 164 boot_mode_enum_type  get_mode_from_alarm_register(void){
 165     int flag;
 166
 167     if(alarm_triggered() && (flag = alarm_flag_check())){
 168         DBG("get_mode_from_alarm_register flag=%d\n", flag);
 169         if(flag == 1){
 170             return CMD_ALARM_MODE;
 171         }
 172         else if(flag == 2){
 173             return CMD_NORMAL_MODE;
 174         }
 175     }else{
 176         return CMD_NONE;
 177     }
 178
 179         return CMD_NONE;
 180 }
 181
 182 // 4 get mode from charger
 183 boot_mode_enum_type  get_mode_from_charger(void){
 184     if(charger_connected()){
 185         DBG("get mode from charger\n");
 186         return CMD_CHARGE_MODE;
 187     }else{
 188         return CMD_NONE;
 189     }
 190 }
 191
 192 // 5 get mode from keypad
 193 boot_mode_enum_type  get_mode_from_keypad(void){
 194     uint32_t key_mode = 0;
 195     uint32_t key_code = 0;
 196     volatile int i;
 197
 198     if(boot_pwr_check() >= get_pwr_key_cnt()){
 199         mdelay(50);
 200         DBG("cboot:power key is down");
 201         for(i=0; i<10;i++){
 202 #ifdef CONFIG_TIZEN
 203                         key_code = tizen_check_keypad();
 204 #else
 205             key_code = board_key_scan();
 206 #endif
 207             DBG("cboot:key_scan times=%d\n",i);
 208             if(key_code != KEY_RESERVED)
 209                 break;
 210         }
 211 #ifdef CONFIG_TIZEN
 212                 return key_code;
 213 #endif
 214         key_mode = check_key_boot(key_code);
 215         DBG("cboot:get mode from keypad:0x%x\n",key_code);
 216         switch(key_mode){
 217             case BOOT_FASTBOOT:
 218                 return  CMD_FASTBOOT_MODE;
 219             case BOOT_RECOVERY:
 220                 return CMD_RECOVERY_MODE;
 221             case BOOT_CALIBRATE:
 222                 return CMD_ENGTEST_MODE;
 223             case BOOT_FACTORYTEST:
 224                 return CMD_FACTORYTEST_MODE;
 225                         case BOOT_THOR_DOWNLOAD:
 226                                 return CMD_THOR_MODE;
 227             default:
 228                 return CMD_NORMAL_MODE;
 229         }
 230     }else{
 231         return CMD_NONE;
 232     }
 233 }
 234
 235 // 6 get mode from gpio
 236 boot_mode_enum_type  get_mode_from_gpio_extend(void){
 237     if (get_mode_from_gpio()) {
 238         DBG("pbint2 triggered, do normal mode\n");
 239         return CMD_NORMAL_MODE;
 240     }else{
 241         return CMD_NONE;
 242     }
 243 }
 244
 245 #ifdef CONFIG_TIZEN
 246 extern int tizen_reboot_check(void);
 247 extern int tizen_reboot_recovery_check(void);
 248 #endif
 249
 250 int do_cboot(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
 251 {
 252     volatile int i;
 253     boot_mode_enum_type bootmode = CMD_NONE;
 254     CBOOT_MODE_ENTRY boot_mode_array[20] ={0};
 255
 256     if(argc > 2)
 257         goto usage;
 258
 259 #ifdef CONFIG_AUTOBOOT
 260     normal_mode();
 261 #endif
 262     for (i=0;  i<CHECK_BOOTMODE_FUN_NUM; i++){
 263         if (0 != s_boot_func_array[i]){
 264             DBG("cboot: i=%d\n", i);
 265             bootmode = s_boot_func_array[i]();
 266             if(CMD_NONE == bootmode){
 267                 boot_pwr_check();
 268                 continue;
 269             }else{
 270                 break;
 271             }
 272         }
 273 #ifndef CONFIG_TIZEN
 274 // get mode from argument
 275         else if(2 == argc){
 276             DBG("cboot:get mode from argument:%s\n",argv[1]);
 277             if(!strcmp(argv[1],"normal")){
 278                 bootmode = CMD_NORMAL_MODE;
 279                 break;
 280             }
 281             if(!strcmp(argv[1],"recovery")){
 282                 bootmode = CMD_RECOVERY_MODE;
 283                 break;
 284             }
 285             if(!strcmp(argv[1],"fastboot")){
 286                 bootmode = CMD_FASTBOOT_MODE;
 287                 break;
 288             }
 289             if(!strcmp(argv[1],"charge")){
 290                 bootmode = CMD_CHARGE_MODE;
 291                 break;
 292             }
 293         }else{
 294             bootmode = CMD_POWER_DOWN_DEVICE;
 295             break;
 296         }
 297 #endif
 298     }
 299     DBG("do_cboot:boot mode is %d\n",bootmode);
 300
 301 #ifdef CONFIG_TIZEN
 302         if (bootmode == CMD_NONE || bootmode == CMD_CHARGE_MODE) {
 303                 if (bootmode == CMD_NONE)
 304                         bootmode = CMD_NORMAL_MODE;
 305                 if (tizen_reboot_check()) {
 306                         bootmode = CMD_THOR_MODE;
 307                         DBG("do_cboot:boot mode is %d\n",bootmode);
 308                 } else if (tizen_reboot_recovery_check()) {
 309 #ifdef CONFIG_RAMDISK_BOOT
 310                         bootmode = CMD_RECOVERY_MODE;
 311 #else
 312                         bootmode = CMD_NORMAL_MODE;
 313 #endif
 314                         DBG("do_cboot:boot mode is %d\n",bootmode);
 315                 }
 316
 317         }
 318 #endif
 319
 320 #ifdef CONFIG_LCD_LOGO
 321         switch (bootmode) {
 322         case CMD_THOR_MODE:
 323                 draw_image(1);
 324                 break;
 325         case CMD_NORMAL_MODE:
 326                 switch (check_pm_status()) {
 327                 case PM_STATE_LPM:
 328                         draw_image(2);
 329                         break;
 330                 case PM_STATE_NORMAL:
 331                 default:
 332                         draw_image(0);
 333                 }
 334                 break;
 335         default:
 336                 draw_image(0);
 337         }
 338         lcd_display();
 339         MMU_DisableIDCM();
 340 #endif /* CONFIG_LCD_LOGO */
 341
 342     cmd_mode_regist(boot_mode_array);
 343     if((bootmode > CMD_POWER_DOWN_DEVICE) && (0 != boot_mode_array[bootmode])){
 344         /* goto main_loop() if any input is hit from console */
 345         if (tstc())
 346                 return 0;
 347         DBG("do_cboot: enter boot mode\n");
 348         boot_mode_array[bootmode]();
 349     }else{
 350         DBG("do_cboot: power down device\n");
 351         power_down_devices(0);
 352         while(1);
 353     }
 354
 355     usage:
 356         cmd_usage(cmdtp);
 357         return 1;
 358 }
 359
 360 U_BOOT_CMD(
 361             cboot, CONFIG_SYS_MAXARGS, 1, do_cboot,
 362             "choose boot mode",
 363             "mode: \nrecovery, fastboot, dloader, charge, normal, vlx, caliberation.\n"
 364             "cboot could enter a mode specified by the mode descriptor.\n"
 365             "it also could enter a proper mode automatically depending on "
 366             "the environment\n"
 367           );