packages/redboot/v2_0/src/main.c

   1 //==========================================================================
   2 //
   3 //      main.c
   4 //
   5 //      RedBoot main routine
   6 //
   7 //==========================================================================
   8 //####ECOSGPLCOPYRIGHTBEGIN####
   9 // -------------------------------------------
  10 // This file is part of eCos, the Embedded Configurable Operating System.
  11 // Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004 Red Hat, Inc.
  12 // Copyright (C) 2002, 2003, 2004 Gary Thomas
  13 // Copyright (C) 2003, 2004, 2005, 2006 eCosCentric Limited
  14 //
  15 // eCos is free software; you can redistribute it and/or modify it under
  16 // the terms of the GNU General Public License as published by the Free
  17 // Software Foundation; either version 2 or (at your option) any later version.
  18 //
  19 // eCos is distributed in the hope that it will be useful, but WITHOUT ANY
  20 // WARRANTY; without even the implied warranty of MERCHANTABILITY or
  21 // FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  22 // for more details.
  23 //
  24 // You should have received a copy of the GNU General Public License along
  25 // with eCos; if not, write to the Free Software Foundation, Inc.,
  26 // 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  27 //
  28 // As a special exception, if other files instantiate templates or use macros
  29 // or inline functions from this file, or you compile this file and link it
  30 // with other works to produce a work based on this file, this file does not
  31 // by itself cause the resulting work to be covered by the GNU General Public
  32 // License. However the source code for this file must still be made available
  33 // in accordance with section (3) of the GNU General Public License.
  34 //
  35 // This exception does not invalidate any other reasons why a work based on
  36 // this file might be covered by the GNU General Public License.
  37 // -------------------------------------------
  38 //####ECOSGPLCOPYRIGHTEND####
  39 //==========================================================================
  40 //#####DESCRIPTIONBEGIN####
  41 //
  42 // Author(s):    gthomas
  43 // Contributors: gthomas, tkoeller, eCosCentric
  44 // Date:         2000-07-14
  45 // Purpose:
  46 // Description:
  47 //
  48 // This code is part of RedBoot (tm).
  49 //
  50 //####DESCRIPTIONEND####
  51 //
  52 //==========================================================================
  53
  54 #define  DEFINE_VARS
  55 #include <redboot.h>
  56 #include <cyg/hal/hal_arch.h>
  57 #include <cyg/hal/hal_intr.h>
  58 #include <cyg/hal/hal_if.h>
  59 #include <cyg/hal/hal_cache.h>
  60 #include CYGHWR_MEMORY_LAYOUT_H
  61
  62 #ifdef CYGPKG_IO_ETH_DRIVERS
  63 #include <cyg/io/eth/eth_drv.h>            // Logical driver interfaces
  64 #endif
  65
  66 #include <cyg/hal/hal_tables.h>
  67 #include <cyg/infra/cyg_ass.h>         // assertion macros
  68 #include <cyg/infra/cyg_type.h>
  69 #ifdef CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS
  70 #ifdef CYGBLD_HAL_PLATFORM_STUB_H
  71 #include CYGBLD_HAL_PLATFORM_STUB_H
  72 #else
  73 #include <cyg/hal/plf_stub.h>
  74 #endif
  75 // GDB interfaces
  76 extern void breakpoint(void);
  77 #endif
  78
  79 // Builtin Self Test (BIST)
  80 externC void bist(void);
  81
  82 // Path to code run from a go command or to GDB stubs
  83 static void trampoline(unsigned long entry);
  84
  85 // Return path for code run from a go command or for GDB stubs
  86 static void return_to_redboot(int status);
  87
  88 // Address of area where current context is saved before executing
  89 // trampoline procedure
  90 static void * saved_context;
  91
  92 // Status returned after trampoline execution
  93 static int return_status;
  94
  95
  96 // CLI command processing (defined in this file)
  97 RedBoot_cmd("version",
  98             "Display RedBoot version information",
  99             "",
 100             do_version
 101     );
 102 RedBoot_cmd("help",
 103             "Help about help?",
 104             "[<topic>]",
 105             do_help
 106     );
 107
 108 static char go_usage[] = "[-w <timeout>] [-c] "
 109 #ifdef CYGPKG_IO_ETH_DRIVERS
 110                       "[-n] "
 111 #endif
 112                       "[entry]";
 113
 114 RedBoot_cmd("go",
 115             "Execute code at a location",
 116             go_usage,
 117             do_go
 118     );
 119 #ifdef HAL_PLATFORM_RESET
 120 RedBoot_cmd("reset",
 121             "Reset the system",
 122             "",
 123             do_reset
 124     );
 125 #endif
 126 #ifdef CYGSEM_REDBOOT_VARIABLE_BAUD_RATE
 127 RedBoot_cmd("baudrate",
 128             "Set/Query the system console baud rate",
 129             "[-b <rate>]",
 130             do_baud_rate
 131     );
 132 #endif
 133
 134 // Define table boundaries
 135 CYG_HAL_TABLE_BEGIN( __RedBoot_INIT_TAB__, RedBoot_inits );
 136 CYG_HAL_TABLE_END( __RedBoot_INIT_TAB_END__, RedBoot_inits );
 137 extern struct init_tab_entry __RedBoot_INIT_TAB__[], __RedBoot_INIT_TAB_END__;
 138
 139 CYG_HAL_TABLE_BEGIN( __RedBoot_CMD_TAB__, RedBoot_commands );
 140 CYG_HAL_TABLE_END( __RedBoot_CMD_TAB_END__, RedBoot_commands );
 141 extern struct cmd __RedBoot_CMD_TAB__[], __RedBoot_CMD_TAB_END__;
 142
 143 CYG_HAL_TABLE_BEGIN( __RedBoot_IDLE_TAB__, RedBoot_idle );
 144 CYG_HAL_TABLE_END( __RedBoot_IDLE_TAB_END__, RedBoot_idle );
 145 extern struct idle_tab_entry __RedBoot_IDLE_TAB__[], __RedBoot_IDLE_TAB_END__;
 146
 147 #ifdef HAL_ARCH_PROGRAM_NEW_STACK
 148 extern void HAL_ARCH_PROGRAM_NEW_STACK(void *fun);
 149 #endif
 150
 151 //
 152 // [Null] Builtin [Power On] Self Test
 153 //
 154 void bist(void) CYGBLD_ATTRIB_WEAK;
 155
 156 void
 157 bist(void)
 158 {
 159 }
 160
 161 //
 162 // 'version' command
 163 //
 164 void
 165 do_version(int argc, char *argv[])
 166 {
 167 #if CYGBLD_REDBOOT_MAX_MEM_SEGMENTS > 1
 168     int seg;
 169 #endif
 170 #ifdef CYGPKG_REDBOOT_FLASH
 171     externC void _flash_info(void);
 172 #endif
 173     char *version = CYGACC_CALL_IF_MONITOR_VERSION();
 174
 175     diag_printf(version);
 176 #ifdef HAL_PLATFORM_CPU
 177     diag_printf("Platform: %s (%s) %s\n", HAL_PLATFORM_BOARD, HAL_PLATFORM_CPU, HAL_PLATFORM_EXTRA);
 178 #endif
 179     diag_printf("Copyright (C) 2000, 2001, 2002, 2003, 2004 Red Hat, Inc.\n");
 180     diag_printf("Copyright (C) 2003, 2004, 2005, 2006 eCosCentric Limited\n\n");
 181     diag_printf("RAM: %p-%p, ", (void*)ram_start, (void*)ram_end);
 182     diag_printf("[%p-%p]", mem_segments[0].start, mem_segments[0].end);
 183     diag_printf(" available\n");
 184 #if CYGBLD_REDBOOT_MAX_MEM_SEGMENTS > 1
 185     for (seg = 1;  seg < CYGBLD_REDBOOT_MAX_MEM_SEGMENTS;  seg++) {
 186         if (mem_segments[seg].start != NO_MEMORY) {
 187             diag_printf("     %p-%p, ", mem_segments[seg].start, mem_segments[seg].end);
 188             diag_printf("[%p-%p]", mem_segments[seg].start, mem_segments[seg].end);
 189             diag_printf(" available\n");
 190         }
 191     }
 192 #endif
 193 #ifdef CYGPKG_REDBOOT_FLASH
 194     _flash_info();
 195 #endif
 196 }
 197
 198 //
 199 // This function is called when RedBoot is idle (waiting for user
 200 // input).  It will call any registered "idle" routines, e.g. scan
 201 // for incoming network connections, blank an LCD screen, etc.
 202 //
 203 void
 204 do_idle(bool is_idle)
 205 {
 206     struct idle_tab_entry *idle_entry;
 207
 208     for (idle_entry = __RedBoot_IDLE_TAB__;
 209          idle_entry != &__RedBoot_IDLE_TAB_END__;  idle_entry++) {
 210         (*idle_entry->fun)(is_idle);
 211     }
 212 }
 213
 214 // Wrapper used by diag_printf()
 215 static void
 216 _mon_write_char(char c, void *param)
 217 {
 218     if (c == '\n') {
 219         mon_write_char('\r');
 220     }
 221     mon_write_char(c);
 222 }
 223
 224 //
 225 // Handle illegal memory accesses (and other abort conditions)
 226 //
 227 static hal_jmp_buf error_jmpbuf;
 228 #ifdef CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS
 229 __externC void* volatile __mem_fault_handler;
 230
 231 static void error_handler(void)
 232 {
 233     hal_longjmp(error_jmpbuf, 1);
 234 }
 235 #endif
 236
 237
 238 //
 239 // This is the main entry point for RedBoot
 240 //
 241
 242 void
 243 cyg_start(void)
 244 {
 245     int res = 0;
 246     bool prompt = true;
 247     static char line[CYGPKG_REDBOOT_MAX_CMD_LINE];
 248     char *command;
 249     struct cmd *cmd;
 250     int cur;
 251     struct init_tab_entry *init_entry;
 252     extern char RedBoot_version[];
 253 #if CYGBLD_REDBOOT_MAX_MEM_SEGMENTS > 1
 254     int seg;
 255 #endif
 256
 257     // Export version information
 258     CYGACC_CALL_IF_MONITOR_VERSION_SET(RedBoot_version);
 259
 260     CYGACC_CALL_IF_MONITOR_RETURN_SET(return_to_redboot);
 261
 262     // Make sure the channels are properly initialized.
 263     diag_init_putc(_mon_write_char);
 264     hal_if_diag_init();
 265
 266     // Force console to output raw text - but remember the old setting
 267     // so it can be restored if interaction with a debugger is
 268     // required.
 269     cur = CYGACC_CALL_IF_SET_CONSOLE_COMM(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT);
 270     CYGACC_CALL_IF_SET_CONSOLE_COMM(CYGNUM_HAL_VIRTUAL_VECTOR_DEBUG_CHANNEL);
 271 #ifdef CYGPKG_REDBOOT_ANY_CONSOLE
 272     console_selected = false;
 273 #endif
 274     console_echo = true;
 275
 276     ram_start = (unsigned char *)CYGMEM_REGION_ram;
 277     ram_end = (unsigned char *)(CYGMEM_REGION_ram+CYGMEM_REGION_ram_SIZE);
 278 #ifdef HAL_MEM_REAL_REGION_TOP
 279     {
 280         unsigned char *ram_end_tmp = ram_end;
 281         ram_end = HAL_MEM_REAL_REGION_TOP( ram_end_tmp );
 282     }
 283 #endif
 284 #ifdef CYGMEM_SECTION_heap1
 285     workspace_start = (unsigned char *)CYGMEM_SECTION_heap1;
 286     workspace_end = (unsigned char *)(CYGMEM_SECTION_heap1+CYGMEM_SECTION_heap1_SIZE);
 287 #else
 288     workspace_start = (unsigned char *)CYGMEM_REGION_ram;
 289     workspace_end = (unsigned char *)(CYGMEM_REGION_ram+CYGMEM_REGION_ram_SIZE);
 290 #endif
 291
 292     if (ram_end < workspace_end) {
 293         // when *less* SDRAM is installed than the possible maximum,
 294         // but the heap1 region remains greater...
 295         workspace_end = ram_end;
 296     }
 297
 298     workspace_end_init=workspace_end;
 299
 300     // Nothing has ever been loaded into memory
 301     entry_address = (unsigned long)NO_MEMORY;
 302
 303     bist();
 304
 305 #if defined(CYGPRI_REDBOOT_ZLIB_FLASH) && defined(CYGOPT_REDBOOT_FIS_ZLIB_COMMON_BUFFER)
 306     fis_zlib_common_buffer =
 307     workspace_end -= CYGNUM_REDBOOT_FIS_ZLIB_COMMON_BUFFER_SIZE;
 308 #endif
 309
 310 #ifdef CYGFUN_REDBOOT_BOOT_SCRIPT
 311     script_timeout = CYGNUM_REDBOOT_BOOT_SCRIPT_DEFAULT_TIMEOUT;
 312 #endif
 313
 314     for (init_entry = __RedBoot_INIT_TAB__; init_entry != &__RedBoot_INIT_TAB_END__; init_entry++) {
 315         (*init_entry->fun)();
 316     }
 317
 318     mem_segments[0].start = workspace_start;
 319     mem_segments[0].end = workspace_end;
 320 #if CYGBLD_REDBOOT_MAX_MEM_SEGMENTS > 1
 321     for (seg = 1;  seg < CYGBLD_REDBOOT_MAX_MEM_SEGMENTS;  seg++) {
 322         cyg_plf_memory_segment(seg, &mem_segments[seg].start, &mem_segments[seg].end);
 323     }
 324 #endif
 325
 326 #ifdef CYGSEM_REDBOOT_PLF_STARTUP
 327
 328     cyg_plf_redboot_startup();
 329 #endif
 330     do_version(0,0);
 331
 332 #ifdef CYGFUN_REDBOOT_BOOT_SCRIPT
 333 # ifdef CYGDAT_REDBOOT_DEFAULT_BOOT_SCRIPT
 334     if (!script) {
 335         script = CYGDAT_REDBOOT_DEFAULT_BOOT_SCRIPT;
 336     }
 337 # endif
 338     if (script) {
 339         // Give the guy a chance to abort any boot script
 340         unsigned char *hold_script = script;
 341         int script_timeout_ms = script_timeout * CYGNUM_REDBOOT_BOOT_SCRIPT_TIMEOUT_RESOLUTION;
 342         diag_printf("== Executing boot script in %d.%03d seconds - enter ^C to abort\n",
 343                     script_timeout_ms / 1000, script_timeout_ms % 1000);
 344         script = NULL;
 345         res = _GETS_CTRLC;  // Treat 0 timeout as ^C
 346         while (script_timeout_ms >= CYGNUM_REDBOOT_CLI_IDLE_TIMEOUT) {
 347             res = _rb_gets(line, sizeof(line), CYGNUM_REDBOOT_CLI_IDLE_TIMEOUT);
 348             if (res >= _GETS_OK) {
 349                 diag_printf("== Executing boot script in %d.%03d seconds - enter ^C to abort\n",
 350                             script_timeout_ms / 1000, script_timeout_ms % 1000);
 351             } else if (res != _GETS_TIMEOUT) {
 352                 break;
 353             }
 354             script_timeout_ms -= CYGNUM_REDBOOT_CLI_IDLE_TIMEOUT;
 355         }
 356         if (res == _GETS_CTRLC) {
 357             script = NULL;  // Disable script
 358         } else {
 359             script = hold_script;  // Re-enable script
 360         }
 361     }
 362 #endif
 363     CYG_ASSERT(workspace_start < workspace_end,
 364                "negative workspace size");
 365     while (true) {
 366         if (prompt) {
 367             diag_printf("RedBoot> ");
 368             prompt = false;
 369         }
 370 #if CYGNUM_REDBOOT_CMD_LINE_EDITING != 0
 371         cmd_history = true;  // Enable history collection
 372 #endif
 373         res = _rb_gets(line, sizeof(line), CYGNUM_REDBOOT_CLI_IDLE_TIMEOUT);
 374 #if CYGNUM_REDBOOT_CMD_LINE_EDITING != 0
 375         cmd_history = false;  // Enable history collection
 376 #endif
 377         if (res == _GETS_TIMEOUT) {
 378             // No input arrived
 379         } else {
 380 #ifdef CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS
 381             if (res == _GETS_GDB) {
 382                 int dbgchan;
 383                 hal_virtual_comm_table_t *__chan;
 384                 int i;
 385                 // Special case of '$' - need to start GDB protocol
 386                 gdb_active = true;
 387                 // Mask interrupts on all channels
 388                 for (i = 0;  i < CYGNUM_HAL_VIRTUAL_VECTOR_NUM_CHANNELS;  i++) {
 389                     CYGACC_CALL_IF_SET_CONSOLE_COMM(i);
 390                     __chan = CYGACC_CALL_IF_CONSOLE_PROCS();
 391                     CYGACC_COMM_IF_CONTROL( *__chan, __COMMCTL_IRQ_DISABLE );
 392                 }
 393
 394                 CYGACC_CALL_IF_SET_CONSOLE_COMM(cur);
 395
 396                 // set up a temporary context that will take us to the trampoline
 397                 HAL_THREAD_INIT_CONTEXT(workspace_end,
 398                                         breakpoint, trampoline,0);
 399
 400                 // switch context to trampoline (get GDB stubs started)
 401                 HAL_THREAD_SWITCH_CONTEXT(&saved_context, &workspace_end);
 402
 403                 gdb_active = false;
 404
 405                 dbgchan = CYGACC_CALL_IF_SET_DEBUG_COMM(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT);
 406                 CYGACC_CALL_IF_SET_CONSOLE_COMM(dbgchan);
 407             } else
 408 #endif // CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS
 409             {
 410                 expand_aliases(line, sizeof(line));
 411                 command = line;
 412                 if ((*command == '#') || (*command == '=')) {
 413                     // Special cases
 414                     if (*command == '=') {
 415                         // Print line on console
 416                         diag_printf("%s\n", &line[2]);
 417                     }
 418                 } else {
 419                     while (strlen(command) > 0) {
 420                         if ((cmd = parse(&command, &argc, &argv[0])) != NULL) {
 421                             // Try to handle aborts - messy because of the stack unwinding...
 422 #ifdef CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS
 423                             __mem_fault_handler = error_handler;
 424 #endif
 425                             if (hal_setjmp(error_jmpbuf)) {
 426                                 diag_printf("** command abort - illegal memory access?\n");
 427                             } else {
 428                                 (cmd->fun)(argc, argv);
 429                             }
 430 #ifdef CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS
 431                             __mem_fault_handler = 0;
 432 #endif
 433                         } else {
 434                             diag_printf("** Error: Illegal command: \"%s\"\n", argv[0]);
 435                         }
 436                     }
 437                 }
 438                 prompt = true;
 439             }
 440         }
 441     }
 442 }
 443
 444 void
 445 show_help(struct cmd *cmd, struct cmd *cmd_end, char *which, char *pre)
 446 {
 447     bool show;
 448     int len = 0;
 449
 450     if (which) {
 451         len = strlen(which);
 452     }
 453     while (cmd != cmd_end) {
 454         show = true;
 455         if (which && (strncasecmp(which, cmd->str, len) != 0)) {
 456             show = false;
 457         }
 458         if (show) {
 459             diag_printf("%s\n  %s %s %s\n", cmd->help, pre, cmd->str, cmd->usage);
 460             if ((cmd->sub_cmds != NULL) && (which != NULL)) {
 461                 show_help(cmd->sub_cmds, cmd->sub_cmds_end, 0, cmd->str);
 462             }
 463         }
 464         cmd++;
 465     }
 466 }
 467
 468 void
 469 do_help(int argc, char *argv[])
 470 {
 471     struct cmd *cmd;
 472     char *which = NULL;
 473
 474     if (!scan_opts(argc, argv, 1, 0, 0, &which, OPTION_ARG_TYPE_STR, "<topic>")) {
 475         diag_printf("Invalid argument\n");
 476         return;
 477     }
 478     cmd = __RedBoot_CMD_TAB__;
 479     show_help(cmd, &__RedBoot_CMD_TAB_END__, which, "");
 480     return;
 481 }
 482
 483 static void
 484 trampoline(unsigned long entry)
 485 {
 486     typedef void code_fun(void);
 487     code_fun *fun = (code_fun *)entry;
 488     unsigned long oldints;
 489
 490     HAL_DISABLE_INTERRUPTS(oldints);
 491
 492 #ifdef HAL_ARCH_PROGRAM_NEW_STACK
 493     HAL_ARCH_PROGRAM_NEW_STACK(fun);
 494 #else
 495     (*fun)();
 496 #endif
 497
 498     HAL_THREAD_LOAD_CONTEXT(&saved_context);
 499 }
 500
 501 static void
 502 return_to_redboot(int status)
 503 {
 504     CYGARC_HAL_SAVE_GP();
 505
 506     return_status = status;
 507     HAL_THREAD_LOAD_CONTEXT(&saved_context);
 508     // never returns
 509
 510     // need this to balance above CYGARC_HAL_SAVE_GP on
 511     // some platforms. It will never run, though.
 512     CYGARC_HAL_RESTORE_GP();
 513 }
 514
 515 void
 516 do_go(int argc, char *argv[])
 517 {
 518     int i, cur, num_options = 0;
 519     unsigned long entry;
 520     unsigned long oldints;
 521     bool wait_time_set;
 522     int  wait_time, res;
 523     bool cache_enabled = false;
 524 #ifdef CYGPKG_IO_ETH_DRIVERS
 525     bool stop_net = false;
 526 #endif
 527     struct option_info opts[3];
 528     char line[8];
 529     hal_virtual_comm_table_t *__chan;
 530
 531 #ifdef CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS
 532     __mem_fault_handler = 0; // Let GDB handle any faults directly
 533 #endif
 534     entry = entry_address;  // Default from last 'load' operation
 535     init_opts(&opts[num_options++], 'w', true, OPTION_ARG_TYPE_NUM,
 536               &wait_time, &wait_time_set, "wait timeout");
 537     init_opts(&opts[num_options++], 'c', false, OPTION_ARG_TYPE_FLG,
 538               &cache_enabled, NULL, "go with caches enabled");
 539 #ifdef CYGPKG_IO_ETH_DRIVERS
 540     init_opts(&opts[num_options++], 'n', false, OPTION_ARG_TYPE_FLG,
 541               &stop_net, NULL, "go with network driver stopped");
 542 #endif
 543
 544     CYG_ASSERT(num_options <= NUM_ELEMS(opts), "Too many options");
 545
 546     if (!scan_opts(argc, argv, 1, opts, num_options, &entry,
 547                    OPTION_ARG_TYPE_NUM, "starting address")) {
 548         return;
 549     }
 550     if (entry == (unsigned long)NO_MEMORY) {
 551         err_printf("No entry point known - aborted\n");
 552         return;
 553     }
 554     if (wait_time_set) {
 555         int script_timeout_ms = wait_time * 1000;
 556 #ifdef CYGSEM_REDBOOT_FLASH_CONFIG
 557         unsigned char *hold_script = script;
 558         script = NULL;
 559 #endif
 560         diag_printf("About to start execution at %p - abort with ^C within %d seconds\n",
 561                     (void *)entry, wait_time);
 562         while (script_timeout_ms >= CYGNUM_REDBOOT_CLI_IDLE_TIMEOUT) {
 563             res = _rb_gets(line, sizeof(line), CYGNUM_REDBOOT_CLI_IDLE_TIMEOUT);
 564             if (res == _GETS_CTRLC) {
 565 #ifdef CYGSEM_REDBOOT_FLASH_CONFIG
 566                 script = hold_script;  // Re-enable script
 567 #endif
 568                 return;
 569             }
 570             script_timeout_ms -= CYGNUM_REDBOOT_CLI_IDLE_TIMEOUT;
 571         }
 572     }
 573
 574     // Mask interrupts on all channels
 575     cur = CYGACC_CALL_IF_SET_CONSOLE_COMM(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT);
 576     for (i = 0;  i < CYGNUM_HAL_VIRTUAL_VECTOR_NUM_CHANNELS;  i++) {
 577         CYGACC_CALL_IF_SET_CONSOLE_COMM(i);
 578         __chan = CYGACC_CALL_IF_CONSOLE_PROCS();
 579         CYGACC_COMM_IF_CONTROL( *__chan, __COMMCTL_IRQ_DISABLE );
 580     }
 581     CYGACC_CALL_IF_SET_CONSOLE_COMM(cur);
 582
 583     __chan = CYGACC_CALL_IF_CONSOLE_PROCS();
 584     CYGACC_COMM_IF_CONTROL(*__chan, __COMMCTL_ENABLE_LINE_FLUSH);
 585
 586 #ifdef CYGPKG_IO_ETH_DRIVERS
 587     if (stop_net)
 588         eth_drv_stop();
 589 #endif
 590
 591     HAL_DISABLE_INTERRUPTS(oldints);
 592     HAL_DCACHE_SYNC();
 593     if (!cache_enabled) {
 594         HAL_ICACHE_DISABLE();
 595         HAL_DCACHE_DISABLE();
 596         HAL_DCACHE_SYNC();
 597     }
 598     HAL_ICACHE_INVALIDATE_ALL();
 599     HAL_DCACHE_INVALIDATE_ALL();
 600     // set up a temporary context that will take us to the trampoline
 601     HAL_THREAD_INIT_CONTEXT(workspace_end,
 602                             entry, trampoline, 0);
 603
 604     // switch context to trampoline
 605     HAL_THREAD_SWITCH_CONTEXT(&saved_context, &workspace_end);
 606
 607     // we get back here by way of return_to_redboot()
 608
 609     // undo the changes we made before switching context
 610     if (!cache_enabled) {
 611         HAL_ICACHE_ENABLE();
 612         HAL_DCACHE_ENABLE();
 613     }
 614
 615     CYGACC_COMM_IF_CONTROL(*__chan, __COMMCTL_DISABLE_LINE_FLUSH);
 616
 617     HAL_RESTORE_INTERRUPTS(oldints);
 618
 619     diag_printf("\nProgram completed with status %d\n", return_status);
 620 }
 621
 622 #ifdef HAL_PLATFORM_RESET
 623 void
 624 do_reset(int argc, char *argv[])
 625 {
 626     diag_printf("... Resetting.");
 627     CYGACC_CALL_IF_DELAY_US(2*100000);
 628     diag_printf("\n");
 629     CYGACC_CALL_IF_RESET();
 630     diag_printf("!! oops, RESET not working on this platform\n");
 631 }
 632 #endif
 633
 634 #ifdef CYGSEM_REDBOOT_VARIABLE_BAUD_RATE
 635 #ifdef CYGSEM_REDBOOT_FLASH_CONFIG
 636 #include <flash_config.h>
 637 #endif
 638
 639 static int
 640 set_comm_baud_rate(hal_virtual_comm_table_t *chan, int rate)
 641 {
 642     int current_rate;
 643
 644     current_rate = CYGACC_COMM_IF_CONTROL(*chan, __COMMCTL_GETBAUD);
 645     if (rate != current_rate)
 646         return CYGACC_COMM_IF_CONTROL(*chan, __COMMCTL_SETBAUD, rate);
 647
 648     return 0;
 649 }
 650
 651 int
 652 set_console_baud_rate(int rate)
 653 {
 654     int ret = -1;
 655 #ifdef CYGPKG_REDBOOT_ANY_CONSOLE
 656     if (!console_selected) {
 657         int cur = CYGACC_CALL_IF_SET_CONSOLE_COMM(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT);
 658         int i;
 659         // Set baud for all channels
 660         for (i = 0;  i < CYGNUM_HAL_VIRTUAL_VECTOR_COMM_CHANNELS;  i++) {
 661             CYGACC_CALL_IF_SET_CONSOLE_COMM(i);
 662             ret = set_comm_baud_rate(CYGACC_CALL_IF_CONSOLE_PROCS(), rate);
 663             if (ret < 0)
 664                 break;
 665         }
 666         CYGACC_CALL_IF_SET_CONSOLE_COMM(cur);
 667     } else
 668 #endif
 669     ret = set_comm_baud_rate(CYGACC_CALL_IF_CONSOLE_PROCS(), rate);
 670
 671     if (ret < 0)
 672         diag_printf("Setting console baud rate to %d failed\n", rate);
 673
 674     return ret;
 675 }
 676
 677 static void
 678 _sleep(int ms)
 679 {
 680     int i;
 681     for (i = 0;  i < ms;  i++) {
 682         CYGACC_CALL_IF_DELAY_US((cyg_int32)1000);
 683     }
 684 }
 685
 686 void
 687 do_baud_rate(int argc, char *argv[])
 688 {
 689     int new_rate, ret, old_rate;
 690     bool new_rate_set;
 691     hal_virtual_comm_table_t *__chan;
 692     struct option_info opts[1];
 693 #ifdef CYGSEM_REDBOOT_FLASH_CONFIG
 694     struct config_option opt;
 695 #endif
 696
 697     init_opts(&opts[0], 'b', true, OPTION_ARG_TYPE_NUM,
 698               &new_rate, &new_rate_set, "new baud rate");
 699     if (!scan_opts(argc, argv, 1, opts, 1, 0, 0, "")) {
 700         return;
 701     }
 702     __chan = CYGACC_CALL_IF_CONSOLE_PROCS();
 703     if (new_rate_set) {
 704         diag_printf("Baud rate will be changed to %d - update your settings\n", new_rate);
 705         _sleep(500);  // Give serial time to flush
 706         old_rate = CYGACC_COMM_IF_CONTROL(*__chan, __COMMCTL_GETBAUD);
 707         ret = set_console_baud_rate(new_rate);
 708         if (ret < 0) {
 709             if (old_rate > 0) {
 710                 // Try to restore
 711                 set_console_baud_rate(old_rate);
 712                 _sleep(500);  // Give serial time to flush
 713                 diag_printf("\nret = %d\n", ret);
 714             }
 715             return;  // Couldn't set the desired rate
 716         }
 717         // Make sure this new rate works or back off to previous value
 718         // Sleep for a few seconds, then prompt to see if it works
 719         _sleep(3000);  // Give serial time to flush
 720         if (!verify_action_with_timeout(5000, "Baud rate changed to %d", new_rate)) {
 721             _sleep(500);  // Give serial time to flush
 722             set_console_baud_rate(old_rate);
 723             _sleep(500);  // Give serial time to flush
 724             return;
 725         }
 726 #ifdef CYGSEM_REDBOOT_FLASH_CONFIG
 727         opt.type = CONFIG_INT;
 728         opt.enable = NULL;
 729         opt.enable_sense = 1;
 730         opt.key = "console_baud_rate";
 731         opt.dflt = new_rate;
 732         flash_add_config(&opt, true);
 733 #endif
 734     } else {
 735         ret = CYGACC_COMM_IF_CONTROL(*__chan, __COMMCTL_GETBAUD);
 736         diag_printf("Baud rate = ");
 737         if (ret <= 0) {
 738             diag_printf("unknown\n");
 739         } else {
 740             diag_printf("%d\n", ret);
 741         }
 742     }
 743 }
 744 #endif
 745
 746 //
 747 // Validate an address to see if it is within any known RAM area
 748 //
 749 bool
 750 valid_address(unsigned char *addr)
 751 {
 752     int seg;
 753
 754     for (seg = 0;  seg < CYGBLD_REDBOOT_MAX_MEM_SEGMENTS;  seg++) {
 755         if (mem_segments[seg].start != NO_MEMORY) {
 756             if ((addr >= mem_segments[seg].start) && (addr < mem_segments[seg].end)) {
 757                 return true;
 758             }
 759         }
 760     }
 761     return false;
 762 }