Beispiel #1
0
int main(int argc, char *argv[]) {
    init_cmd();
    add_cmd("times", do_times, "Multiply");
    add_cmd("plus", do_plus, "Add");
    add_param("value", &value, "Value", NULL);
    add_quit_helper(app_quit);
    run_console(NULL);
    finish_cmd();
    return 0;
}
Beispiel #2
0
 virtual int console_main(int argc, char_t** argv, char_t** env) {
     int err = 0, err2 = 0;
     if (!(err = before_get_cgi_form(argc, argv, env))) {
         if (!(err = get_cgi_form(argc, argv, env))) {
             if (!(err = before_run_console(argc, argv, env))) {
                 if (!(err = run_console(argc, argv, env))) {
                 }
                 if ((err2 = after_run_console(argc, argv, env)) && (!err)) {
                     err = err2;
                 }
             }
         }
         if ((err2 = after_get_cgi_form(argc, argv, env)) && (!err)) {
             err = err2;
         }
     }
     return err;
 }
Beispiel #3
0
void app_main()
{
    init_peripherals();
   
    motor_a = new Motor(MCPWM_UNIT_0, MCPWM_TIMER_0, MCPWM0A, MCPWM0B, GPIO_PWM0A_OUT, GPIO_PWM0B_OUT);
    motor_b = new Motor(MCPWM_UNIT_0, MCPWM_TIMER_1, MCPWM1A, MCPWM1B, GPIO_PWM1A_OUT, GPIO_PWM1B_OUT);

    printf("Press a key to enter console\n");
    bool debug = false;
    for (int i = 0; i < 20; ++i)
    {
        if (getchar() != EOF)
        {
            debug = true;
            break;
        }
        vTaskDelay(100/portTICK_PERIOD_MS);
    }
    if (debug)
        run_console();        // never returns
    printf("\nStarting application\n");
    
    xTaskCreate(&main_loop, "Main loop", 10240, NULL, 1, &xMainTask);
}
Beispiel #4
0
/*f main
 */
extern int main( int argc, char **argv )
{
	int i, okay, gdb_enabled;
	int cycles;
    int r;
    unsigned int regs[16];
    char *symbol_map;
    char *eth_device;
    unsigned int memory_regions[8][3];
    unsigned int execution_regions[8][3];
    file_desc files_to_load [8];
    int nfiles_to_load = 0;
    int must_launch_minicom = 0;
    int use_single_pipeline = 0;

    memset (files_to_load, 0, sizeof(files_to_load));

    /*b Set default values
     */
    for (i=0; i<8; i++)
    {
        memory_regions[i][0] = 0;
        memory_regions[i][1] = 0;
        memory_regions[i][2] = 100;
        execution_regions[i][0] = 0;
        execution_regions[i][1] = 0;
        execution_regions[i][2] = 0;
    }
//	f=stdin;
	cycles=1000;
	gdb_enabled = 0;
    symbol_map = "../../os/linux/System.map";
    eth_device = "eth3";
    for (i=0; i<16; i++)
    {
        regs[i] = 0xdeadcafe;
    }
    
//    tty_fd = run_console ();

//    ether_init(eth_device);
    
    /*b Parse arguments
     */
	for (i=1; i<argc; i++)
	{
        /*b '--'
         */
        if (!strcmp( argv[i], "--" ))
        {
            files_to_load[nfiles_to_load++].fp = stdin;
            continue;
        }
        /*b '-a'
         */
        if (!strcmp( argv[i], "-a" ))
        {
            i++;
            if (i<argc)
            {
                int base;
                if (sscanf( argv[i], "%x", &base)!=1)
                {
                    fprintf( stderr, "Failed to parse '%s' for base address of load\n", argv[i] );
                }
                files_to_load[nfiles_to_load].addr = base;
            }
            continue;
        }
        /*b '-b'
         */
        if (!strcmp( argv[i], "-b" ))
        {
            files_to_load[nfiles_to_load].binary=1;
            continue;
        }
        /*b '-d'
         */
        if (!strcmp( argv[i], "-d" ))
        {
            i++;
            if (i<argc)
            {
                if (sscanf( argv[i], "%d", &debug_level)!=1)
                {
                    fprintf( stderr, "Failed to parse '%s' for debug mask\n", argv[i] );
                }
            }
            continue;
        }
        /*b '-e'
         */
        if (!strcmp( argv[i], "-e" ))
        {
            i++;
            if (i<argc)
            {
                eth_device = argv[i];
            }
            continue;
        }
        /*b '-f'
         */
        if (!strcmp( argv[i], "-f" ))
        {
            i++;
            if (i<argc)
            {
                FILE * fp = fopen(argv[i],"r");
                if (!fp)
                {
                    fprintf( stderr, "Failed to open file '%s'\n", argv[i] );
                }
                files_to_load[nfiles_to_load].name = argv[i];
                files_to_load[nfiles_to_load++].fp = fp;
            }
            continue;
        }
        /*b '-g'
         */
        if (!strncmp (argv[i], "-g", 2))
        {
            gdb_enabled = 1;
            continue;
        }
        /*b '-h'
         */
        if (!strncmp (argv[i], "-h", 2))
        {
            usage();
            exit(0);
        }
        /*b '-r'
         */
        if (!strncmp( argv[i], "-r", 2 ))
        {
            i++;
            if (i<argc)
            {
                if (sscanf( argv[i-1], "-r%d", &r)!=1)
                {
                    fprintf( stderr, "Failed to parse '%s' for register initialization\n", argv[i] );
                }
                regs[r&0xf] = strtoul(argv[i], NULL, 0);
            }
            continue;
        }
        /*b '-s'
         */
        if (!strncmp( argv[i], "-s", 2 ))
        {
            i++;
            if (i<argc)
            {
                symbol_map = argv[i];
            }
            continue;
        }
        /*b '-t'
         */
        if (!strcmp( argv[i], "-t" ))
        {
            i++;
            if (i<argc)
            {
                if (sscanf( argv[i], "%d", &cycles)!=1)
                {
                    fprintf( stderr, "Failed to parse '%s' for length of run\n", argv[i] );
                }
            }
            continue;
        }
        /*b '-S'
         */
        if (!strcmp( argv[i], "-S" ))
        {
            use_single_pipeline=1;
            continue;
        }
        /*b '-M'
         */
        if (!strcmp( argv[i], "-M" ))
        {
            i+=3;
            if (i<argc)
            {
                int j;
                for (j=0; j<8; j++)
                {
                    if (memory_regions[j][2]>4)
                    {
                        break;
                    }
                }
                if (j<8)
                {
                    if ( (sscanf( argv[i-2], "%08x", &memory_regions[j][0])!=1) ||
                         (sscanf( argv[i-1], "%08x", &memory_regions[j][1])!=1) ||
                         (sscanf( argv[i], "%d", &memory_regions[j][2])!=1) )
                    {
                        fprintf( stderr, "Failed to parse arguments (hex start, hex end, int level) for memory tracing\n" );
                    }
                }
            }
            continue;
        }
        /*b '-T'
         */
        if (!strcmp( argv[i], "-T" ))
        {
            i+=3;
            if (i<argc)
            {
                int j;
                if ((sscanf( argv[i-2], "%d", &j )==1) && (j>=0) && (j<8))
                {
                    if ( (sscanf( argv[i-1], "%08x", &execution_regions[j][0])!=1) ||
                         (sscanf( argv[i], "%08x", &execution_regions[j][1])!=1) )
                    {
                        fprintf( stderr, "Failed to parse arguments (region, hex start, hex end) for exec tracing\n" );
                    }
                    else
                    {
                        execution_regions[j][2] = 1;
                    }
                }
            }
            continue;
        }
        /*b '-m'
         */
        if (!strcmp (argv[i], "-m"))
        {
            must_launch_minicom = 1;
        }
        /*b All done
         */
	}

    /*b Connect to system components (console, ethernet)
     */
    tty_fd = run_console();
    if (must_launch_minicom)
        launch_minicom();
    ether_init(eth_device);

    /*b Build system
     */
   	ram = new c_ram_model( 1<<24 ); // Create RAM of size 1<<24 = 16MB
   	memory = new c_memory_model();

    if (0 && use_single_pipeline)
    {
//        c_gip_pipeline_single *gip_single;
//        gip_single = new c_gip_pipeline_single( memory );
//        gip = (c_execution_model_class *)gip_single;
    }
    else
    {
        c_gip_full *gip_full;
        gip_full = new c_gip_full( memory );
        gip = (c_execution_model_class *)gip_full;
    }

   	zero_page_ram = new c_ram_model( 1<<24 ); // Create zero-pagee RAM of size 1<<24 = 16MB
   	mmio = new c_mmio_model( gip ); // Create our standard MMIO model

    zero_page_ram->register_with_memory_map( memory, 0x00000000, 0x10000000 ); // Register zero-page RAM at 0x00000000 to 0xd0000000
    ram->register_with_memory_map( memory, 0xc0000000, 0x10000000 ); // Register RAM at 0xc0000000 to 0xd0000000
    mmio->register_with_memory_map( memory, 0xff000000, 0x00ffffff ); // Register MMIO at 0xff000000 to 0xfffffff
    memory->register_debug_handler( NULL, memory_model_debug );

//    microkernel * ukernel = new microkernel(gip);
//    gip->register_microkernel (ukernel);
    
    /*b Load code and symbols
     */
    for (i = 0; i < nfiles_to_load; i++)
    {
	file_desc * fdp = files_to_load + i;
	if (fdp->binary)
	{
		printf ("Loading binary file '%s' at %08x\n", fdp->name, fdp->addr);
        gip->load_code_binary( fdp->fp, fdp->addr );
	}
	else
	{
		printf ("Loading text file '%s' at %08x\n", fdp->name, fdp->addr);
        gip->load_code( fdp->fp, fdp->addr );
	}
    }
    for (i=0; i<16; i++)
    {
        gip->set_register( i, regs[i] );
    }
    symbol_initialize( symbol_map );

    /*b Set a signal handler
     */
    signal (SIGUSR1, handle_user1);
    signal (SIGUSR2, handle_user2);
    
    /*b Enable memory logging and tracing of GIP
     */
//    memory->set_log_file( "memory_model.log" );
    for (i=0; i<8; i++)
    {
        if (memory_regions[i][2]<4)
        {
            memory->set_log_level( memory_regions[i][0], memory_regions[i][1]-memory_regions[i][0], memory_regions[i][2] );
        }
    }

    gip->trace_set_file( "gip_exec_trace.log" );
    for (i=0; i<8; i++)
    {
        if (execution_regions[i][2])
        {
            gip->trace_region( i, execution_regions[i][0], execution_regions[i][1] ); // Trace execution in main ram
        }
    }

    /*b Initialize GDB server if required
     */
    if (gdb_enabled)
    {
	    printf ("Starting GDB interface...\n");
        gdb_stub_init( gip, memory, mmio );
    }
    else
    {
        gdb_stub_disable();
    }
    
    /*b Run until completion, or forever if under gdb
     */
//    time_to_next_irq = 100000;
    if (gdb_enabled)
    {
        int next_timer = get_ticks() + 1;
        int instruction_count;
        while (1)
        {
            if (sigusr1)
            {
                sigusr1 = 0;
                gdb_trap (5);
            }
            instruction_count = gdb_poll( okay );
            if (instruction_count<=0)
            {
                instruction_count = 100000;
            }

            if (instruction_count > 50) instruction_count = 50;
//            if (instruction_count > time_to_next_irq)
//                instruction_count = time_to_next_irq;
	    
            int actual_count = gip->step( &okay, instruction_count );

//            time_to_next_irq -= actual_count;

//	    if (ether_poll())
//		ukernel->handle_interrupt (2);
	    
//	    if (keyboard_poll ())
//		    ukernel->handle_interrupt (1);
	    
            if (get_ticks() > next_timer)
            {
                next_timer++;
//		    ukernel->handle_interrupt (0);

            }
        }
    }
    else
    {
        int next_timer = get_ticks() + 1;
//	struct timeval tv;
        int instruction_count;
        int actual_count;
        int total_instructions = 0;
        int start_time = get_ticks();
	
        okay = 0;
        while ((cycles>0) && (!okay))
        {
            if (sigusr1)
            {
                sigusr1 = 0;
            }

            instruction_count = cycles;

//            if (instruction_count > time_to_next_irq)
//              instruction_count = time_to_next_irq;
	   
//	    if (instruction_count > 500) instruction_count = 500;
            if (instruction_count > 50) instruction_count = 50;
	    
            actual_count = gip->step( &okay, instruction_count );
            cycles -= actual_count;
            total_instructions += actual_count;
	    
//	    if (ether_poll())
//		    ukernel->handle_interrupt (2);

//	    if (keyboard_poll ())
//		    ukernel->handle_interrupt (1);

            if (get_ticks() > next_timer)
            {
                next_timer++;
//		    ukernel->handle_interrupt (0);

            }
        }
    }

    /*b Done
     */
}
Beispiel #5
0
static void
prompt_and_wait()
{
	char* menu_files[MAX_MENU_LEVEL] = { NULL };
	char* menu_scripts[MAX_MENU_LEVEL] = { NULL };
	int menu_sel[MAX_MENU_LEVEL] = { 0 };
	unsigned int menu_level = 0;  
	int menu_result;
  
  //always ensure if mountings are good
  ensure_common_roots_mounted();
  
	//initialize the recovery -> either call the script for initalization, or switch to full version
#if !OPEN_RCVR_VERSION_LITE
	run_shell_script("/bin/init_recovery.sh "OPEN_RECOVERY_PHONE_SWITCH, 1, NULL);
#endif 

  menu_files[0] = malloc(strlen(MAIN_MENU_FILE)+1);
  strcpy(menu_files[0], MAIN_MENU_FILE);
  ui_led_blink(1);
  create_menu(menu_files[0], menu_scripts[0]);
  ui_led_toggle(0);
  int title_length;  
	char** headers;
	headers = prepend_title(MENU_HEADERS, &title_length);
	int override_initial_selection = -1;	
	
	int call_finish_in_loop = 1;
			
  for (;;) {  

		if (call_finish_in_loop)
		{
			finish_recovery(NULL);
			call_finish_in_loop = 0;
		}

		int menu_item;		
		
		if (override_initial_selection != -1)
		{
			menu_item = get_menu_selection(headers, MENU_ITEMS, MENU_ITEMS_SELECTABLE, title_length, override_initial_selection, 0);
			override_initial_selection = -1;
		}
		else
    	menu_item = get_menu_selection(headers, MENU_ITEMS, MENU_ITEMS_SELECTABLE, title_length, 0, 0);

    // Parse open recovery commands
    int chosen_item = select_action(menu_item);
    chosen_item = device_perform_action(chosen_item);

		//if tag, menu, or scripted menu -> don't hide menu
		//do it here explicitly, it would be a mess in the switch
		if (chosen_item != ITEM_TAG && chosen_item != ITEM_NEW_MENU 
		    && chosen_item != ITEM_NEW_MENU_SCRIPTED)
			hide_menu_selection();

		fprintf(stderr, "Menu: %d, %d, %s\n", menu_item, chosen_item, MENU_ITEMS_TARGET[menu_item]);

    switch (chosen_item) {
    	case ITEM_REBOOT:
       	return;

      case ITEM_WIPE_DATA:
        wipe_data(ui_text_visible());

        if (!ui_text_visible()) 
        	return;
        	
        ui_set_background(BACKGROUND_ICON_ERROR);
        break;

      case ITEM_WIPE_CACHE:
        ui_print("\n-- Wiping cache...\n");
				ui_led_blink(1);
        erase_root("CACHE:");
        ensure_common_roots_mounted();
				ui_led_toggle(0);
        ui_print("Cache wipe complete.\n");
        if (!ui_text_visible()) 
        	return;
        ui_set_background(BACKGROUND_ICON_ERROR);
        break;

      case ITEM_APPLY_SDCARD:
      
      	//HACK for "error: a label can only be part of a statement and a declaration is not a statement"
      	//the rule is retarted, the follwing "dummy" statement is cut in optimization
      	override_initial_selection=override_initial_selection; 
      
      	//confirm it	
      	char* confirm_headers[] = { "Confirm installing update package?",
      															 MENU_ITEMS[menu_item],
      															 "",
      															 NULL
      														};
      	char* confirm_items[] = { "Yes", "No", NULL };
      	int confirm_item = show_interactive_menu(confirm_headers, confirm_items);
      	
      	if (confirm_item == 1) //YES!
      	{      	
		      ui_print("\n-- Install from sdcard...\n");
		      ui_led_blink(1);
		      ensure_common_roots_unmounted();
		      ensure_root_path_mounted("SDCARD:");
		      set_sdcard_update_bootloader_message();
		      call_finish_in_loop = 1;
		      int status = install_package(MENU_ITEMS_TARGET[menu_item]);
		      ensure_common_roots_mounted();
		      if (status != INSTALL_SUCCESS) 
		      {
						ui_set_background(BACKGROUND_ICON_ERROR);
						ui_print("Installation aborted.\n");
		      } 
		      else if (!ui_text_visible()) 
	          return;  // reboot if logs aren't visible
		      else 
		      {
		        if (firmware_update_pending()) 
		        {
	        		ui_set_background(BACKGROUND_ICON_ERROR);
	            ui_print("\nReboot via menu to complete\n"
	                     "installation.\n");
		        } 
		        else 
		        {
	        		ui_set_background(BACKGROUND_ICON_ERROR);
	            ui_print("\nInstall from sdcard complete.\n");
		        }
		      }
		      
		      create_menu(menu_files[menu_level], menu_scripts[menu_level]);
		      free(headers);
		      headers = prepend_title(MENU_HEADERS, &title_length);
		      ui_led_toggle(0);
		    }
        
        override_initial_selection = menu_item;											
 				break; 

      case ITEM_SHELL_SCRIPT:
        ui_print("\n-- Shell script...\n");
        ui_print("%s\n", MENU_ITEMS_TARGET[menu_item]);
				ui_led_blink(1);
				ensure_common_roots_mounted();
				
				run_shell_script(MENU_ITEMS_TARGET[menu_item], 1, NULL);
				create_menu(menu_files[menu_level], menu_scripts[menu_level]);
				free(headers);
				headers = prepend_title(MENU_HEADERS, &title_length);
				
				ui_led_toggle(0);
        ui_print("Done.\n");
				
				override_initial_selection = menu_item;											
 				break; 
				
			case ITEM_TAG:
			
				if (MENU_ITEMS_TAG[menu_item] == 0x00)
				{
					int tag_fd = creat(MENU_ITEMS_TARGET[menu_item], 0644);
					if (tag_fd < 0)
						LOGE("Failed to set the tag.\n");
					else
					{
						MENU_ITEMS_TAG[menu_item] = 0x01;
						MENU_ITEMS[menu_item][1] = 'X';
						close(tag_fd);
					}					 
				}
				else if (MENU_ITEMS_TAG[menu_item] == 0x01) //just a little check if 0xFF aint there if bug is present
				{
					remove(MENU_ITEMS_TARGET[menu_item]);
					MENU_ITEMS_TAG[menu_item] = 0x00;
					MENU_ITEMS[menu_item][1] = ' '; 
				}
			
				override_initial_selection = menu_item;											
 				break; 

      case ITEM_NEW_MENU:
				if (menu_level + 1 >= MAX_MENU_LEVEL)
				{
					//too much menus, ignore
					break;
				}
							
				ui_led_blink(1);
				if (!strcmp(MENU_ITEMS_TARGET[menu_item], ".."))
				{
					if (menu_level)
					{
						free(menu_files[menu_level]);
						menu_files[menu_level] = NULL;
						
						if (menu_scripts[menu_level])
						{
							free(menu_scripts[menu_level]);
							menu_scripts[menu_level] = NULL;
						}
						
						menu_sel[menu_level] = 0;
						menu_level--;
						override_initial_selection = menu_sel[menu_level];
					}
				}
				else
				{
					menu_sel[menu_level] = menu_item;
					menu_level++;
					menu_files[menu_level] = malloc(strlen(MENU_ITEMS_TARGET[menu_item]) + 1);
					strcpy(menu_files[menu_level], MENU_ITEMS_TARGET[menu_item]);				
				}
					
				ensure_common_roots_mounted();	
				menu_result = create_menu(menu_files[menu_level], menu_scripts[menu_level]);
				
				//if fail, remove the new menu
				if (menu_result && menu_level)
				{
					free(menu_files[menu_level]);
					menu_files[menu_level] = NULL;
					
					if (menu_scripts[menu_level])
					{
						free(menu_scripts[menu_level]);
						menu_scripts[menu_level] = NULL;
					}
					
					menu_level--;
				}
				
				free(headers);
				headers = prepend_title(MENU_HEADERS, &title_length);
				ui_led_toggle(0);
				break;
			
			case ITEM_NEW_MENU_SCRIPTED:
			
				if (menu_level + 1 >= MAX_MENU_LEVEL)
				{
					//too much menus, ignore
					break;
				}
			
				ui_led_blink(1);
				char cmdBuff[MAX_LINE_LENGTH];
				strcpy(cmdBuff, MENU_ITEMS_TARGET[menu_item]);
				char* ptr;
										
				//menufile:script
				ptr = strtok(cmdBuff, ":");
				if (ptr != NULL)
				{
					menu_sel[menu_level] = menu_item;
					menu_level++;
					menu_files[menu_level] = malloc(strlen(ptr) + 1);
					strcpy(menu_files[menu_level], ptr);						
					
					ptr = strtok(NULL, "");
					if (ptr != NULL)
					{
						if (ptr[0] == '/' || (ptr[0] == '\"' && ptr[1] == '/'))
						{
							menu_scripts[menu_level] = malloc(strlen(ptr) + 1);
							strcpy(menu_scripts[menu_level], ptr);					
						}
						else
						{
							menu_scripts[menu_level] = malloc(strlen(CUSTOM_SHELL_SCRIPT_PATH) + strlen(ptr) + 2);
						
							if (ptr[0] == '\"')
								sprintf(menu_scripts[menu_level], "\"%s/%s", CUSTOM_SHELL_SCRIPT_PATH, ptr+1);
							else
								sprintf(menu_scripts[menu_level], "%s/%s", CUSTOM_SHELL_SCRIPT_PATH, ptr);

						}
					}
					
					ensure_common_roots_mounted();
					menu_result = create_menu(menu_files[menu_level], menu_scripts[menu_level]);
					
					//if fail, remove the new menu
					if (menu_result && menu_level)
					{
						free(menu_files[menu_level]);
						menu_files[menu_level] = NULL;
						
						if (menu_scripts[menu_level])
						{
							free(menu_scripts[menu_level]);
							menu_scripts[menu_level] = NULL;
						}
						
						menu_level--;
					}
					
					free(headers);
					headers = prepend_title(MENU_HEADERS, &title_length);
				}
					
				ui_led_toggle(0);
				break;
			
			case ITEM_CONSOLE:
#if OPEN_RECOVERY_HAVE_CONSOLE
				ensure_common_roots_mounted();
				
				ui_print("Opening console...\n");
				int console_error = run_console(NULL);
				
				if (console_error)
					if (console_error == CONSOLE_FORCE_QUIT)
						ui_print("Console was forcibly closed.\n");
					else if (console_error == CONSOLE_FAILED_START)
						ui_print("Console failed to start.\n");
					else
					{
						ui_print("Closing console...\n"); //don't bother printing error to UI
						fprintf(stderr, "Console closed with error %d.\n", console_error);
					}		
				else
					ui_print("Closing console...\n");
					
				create_menu(menu_files[menu_level], menu_scripts[menu_level]);
				free(headers);
				headers = prepend_title(MENU_HEADERS, &title_length);
#else
				LOGE("This phone doesn't support console.\n");
#endif
				override_initial_selection = menu_item;											
 				break; 
			
			case ITEM_ERROR:
				LOGE("Unknown command: %s.\n", MENU_ITEMS_ACTION[menu_item]);
				break;
    }
  }
}