unified MX27, MX25, MX37 trees
[karo-tx-redboot.git] / 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 }