X-Git-Url: https://review.openocd.org/gitweb?a=blobdiff_plain;f=src%2Fopenocd.c;h=834b11d92fbb6c409261a010805b6118ecaba1d1;hb=b31d83c6c7eb274144acc7c40ea4bf8424b6b1e0;hp=99ee6527ed352e5edac3ff73cdc9e9cf1d507f94;hpb=002e3fcbdbb22686278abf242668431ac653a449;p=openocd.git diff --git a/src/openocd.c b/src/openocd.c index 99ee6527ed..834b11d92f 100644 --- a/src/openocd.c +++ b/src/openocd.c @@ -39,6 +39,7 @@ #include "server.h" #include "telnet_server.h" #include "gdb_server.h" +#include "tcl_server.h" #include #include @@ -49,9 +50,49 @@ #include #include +#ifdef _WIN32 +#include +#else +#include +#endif + +#ifdef __ECOS +/* Jim is provied by eCos */ +#include +#else #define JIM_EMBEDDED #include "jim.h" +#endif + +#include "replacements.h" +int launchTarget(struct command_context_s *cmd_ctx) +{ + int retval; + /* Try to examine & validate jtag chain, though this may require a reset first + * in which case we continue setup */ + jtag_init(cmd_ctx); + + /* try to examine target at this point. If it fails, perhaps a reset will + * bring it up later on via a telnet/gdb session */ + target_examine(cmd_ctx); + + retval=flash_init_drivers(cmd_ctx); + if (retval!=ERROR_OK) + return retval; + LOG_DEBUG("flash init complete"); + + retval=nand_init(cmd_ctx); + if (retval!=ERROR_OK) + return retval; + LOG_DEBUG("NAND init complete"); + + retval=pld_init(cmd_ctx); + if (retval!=ERROR_OK) + return retval; + LOG_DEBUG("pld init complete"); + return retval; +} /* Give TELNET a way to find out what version this is */ int handle_version_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) @@ -77,7 +118,6 @@ int handle_daemon_startup_command(struct command_context_s *cmd_ctx, char *cmd, return ERROR_OK; } - void exit_handler(void) { /* close JTAG interface */ @@ -85,7 +125,6 @@ void exit_handler(void) jtag->quit(); } - /* OpenOCD can't really handle failure of this command. Patches welcome! :-) */ int handle_init_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { @@ -99,7 +138,6 @@ int handle_init_command(struct command_context_s *cmd_ctx, char *cmd, char **arg command_set_output_handler(cmd_ctx, configuration_output_handler, NULL); atexit(exit_handler); - if (target_init(cmd_ctx) != ERROR_OK) return ERROR_FAIL; @@ -123,7 +161,6 @@ int handle_init_command(struct command_context_s *cmd_ctx, char *cmd, char **arg LOG_DEBUG("jtag examine complete"); } } - if (flash_init_drivers(cmd_ctx) != ERROR_OK) return ERROR_FAIL; @@ -143,30 +180,192 @@ int handle_init_command(struct command_context_s *cmd_ctx, char *cmd, char **arg /* initialize telnet subsystem */ telnet_init("Open On-Chip Debugger"); gdb_init(); + tcl_init(); /* allows tcl to just connect without going thru telnet */ return ERROR_OK; } -/* implementations of OpenOCD that uses multithreading needs to lock OpenOCD while calling - * OpenOCD fn's. No-op in vanilla OpenOCD - */ -void lockBigLock() -{ -} -void unlockBigLock() +Jim_Interp *interp; +command_context_t *active_cmd_ctx; + +static int new_int_array_element(Jim_Interp * interp, const char *varname, int idx, u32 val) { -} + char *namebuf; + Jim_Obj *nameObjPtr, *valObjPtr; + int result; + namebuf = alloc_printf("%s(%d)", varname, idx ); + + nameObjPtr = Jim_NewStringObj(interp, namebuf, -1); + valObjPtr = Jim_NewIntObj(interp, val ); + Jim_IncrRefCount(nameObjPtr); + Jim_IncrRefCount(valObjPtr); + result = Jim_SetVariable(interp, nameObjPtr, valObjPtr); + Jim_DecrRefCount(interp, nameObjPtr); + Jim_DecrRefCount(interp, valObjPtr); + free(namebuf); + // printf( "%s = 0%08x\n", namebuf, val ); + return result; +} +static int Jim_Command_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *argv) +{ + target_t *target; + long l; + u32 width; + u32 len; + u32 addr; + u32 count; + u32 v; + const char *varname; + u8 buffer[4096]; + int i,n,e,retval; + + /* argv[1] = name of array to receive the data + * argv[2] = desired width + * argv[3] = memory address + * argv[4] = length in bytes to read + */ + if( argc != 5 ){ + Jim_WrongNumArgs( interp, 1, argv, "varname width addr nelems" ); + return JIM_ERR; + } + varname = Jim_GetString( argv[1], &len ); + /* given "foo" get space for worse case "foo(%d)" .. add 20 */ + e = Jim_GetLong( interp, argv[2], &l ); + width = l; + if( e != JIM_OK ){ + return e; + } + + e = Jim_GetLong( interp, argv[3], &l ); + addr = l; + if( e != JIM_OK ){ + return e; + } + e = Jim_GetLong( interp, argv[4], &l ); + len = l; + if( e != JIM_OK ){ + return e; + } + switch(width){ + case 8: + width = 1; + break; + case 16: + width = 2; + break; + case 32: + width = 4; + break; + default: + Jim_SetResult(interp, + Jim_NewEmptyStringObj(interp)); + Jim_AppendStrings( interp, Jim_GetResult(interp), + "Invalid width param, must be 8/16/32", NULL ); + return JIM_ERR; + } + if( len == 0 ){ + Jim_SetResult(interp, + Jim_NewEmptyStringObj(interp)); + Jim_AppendStrings( interp, Jim_GetResult(interp), + "mem2array: zero width read?", NULL ); + return JIM_ERR; + } + if( (addr + (len * width)) < addr ){ + Jim_SetResult(interp, + Jim_NewEmptyStringObj(interp)); + Jim_AppendStrings( interp, Jim_GetResult(interp), + "mem2array: addr + len - wraps to zero?", NULL ); + return JIM_ERR; + } + /* absurd transfer size? */ + if( len > 65536 ){ + Jim_SetResult(interp, + Jim_NewEmptyStringObj(interp)); + Jim_AppendStrings( interp, Jim_GetResult(interp), + "mem2array: absurd > 64K item request", NULL ); + return JIM_ERR; + } + + if( (width == 1) || + ((width == 2) && ((addr & 1) == 0)) || + ((width == 4) && ((addr & 3) == 0)) ){ + /* all is well */ + } else { + char buf[100]; + Jim_SetResult(interp, + Jim_NewEmptyStringObj(interp)); + sprintf( buf, + "mem2array address: 0x%08x is not aligned for %d byte reads", + addr, width ); + + Jim_AppendStrings( interp, Jim_GetResult(interp), + buf , NULL ); + return JIM_ERR; + } + target = get_current_target( active_cmd_ctx ); + + /* Transfer loop */ + + /* index counter */ + n = 0; + /* assume ok */ + e = JIM_OK; + while( len ){ + + /* Slurp... in buffer size chunks */ + + count = len; /* in objects.. */ + if( count > (sizeof(buffer)/width)){ + count = (sizeof(buffer)/width); + } + + retval = target->type->read_memory( target, + addr, + width, + count, + buffer ); + + if( retval != ERROR_OK ){ + /* BOO !*/ + LOG_ERROR("mem2array: Read @ 0x%08x, w=%d, cnt=%d, failed", + addr, width, count ); + Jim_SetResult(interp, + Jim_NewEmptyStringObj(interp)); + Jim_AppendStrings( interp, Jim_GetResult(interp), + "mem2array: cannot read memory", NULL ); + e = JIM_ERR; + len = 0; + } else { + v = 0; /* shut up gcc */ + for( i = 0 ; i < count ; i++, n++ ){ + switch(width){ + case 4: + v = target_buffer_get_u32( target, &buffer[i*width] ); + break; + case 2: + v = target_buffer_get_u16( target, &buffer[i*width] ); + break; + case 1: + v = buffer[i] & 0x0ff; + break; + } + new_int_array_element( interp, varname, n, v ); + } + len -= count; + } + } + Jim_SetResult(interp, + Jim_NewEmptyStringObj(interp)); -Jim_Interp *interp; -command_context_t *active_cmd_ctx; + return JIM_OK; +} -static void tcl_output(void *privData, const char *file, int line, - const char *function, const char *string) +static void tcl_output(void *privData, const char *file, int line, const char *function, const char *string) { Jim_Obj *tclOutput=(Jim_Obj *)privData; @@ -237,19 +436,13 @@ int jim_command(command_context_t *context, char *line) return retval; } -static int startLoop=0; +int startLoop=0; -static int -Jim_Command_openocd_ignore(Jim_Interp *interp, - int argc, - Jim_Obj *const *argv, - int ignore) +static int Jim_Command_openocd_ignore(Jim_Interp *interp, int argc, Jim_Obj *const *argv, int ignore) { int retval; char *cmd = (char*)Jim_GetString(argv[1], NULL); - lockBigLock(); - Jim_Obj *tclOutput = Jim_NewStringObj(interp, "", 0); if (startLoop) @@ -268,35 +461,22 @@ Jim_Command_openocd_ignore(Jim_Interp *interp, log_remove_callback(tcl_output, tclOutput); Jim_SetResult(interp, tclOutput); - unlockBigLock(); return (ignore||(retval==ERROR_OK))?JIM_OK:JIM_ERR; } -static int -Jim_Command_openocd(Jim_Interp *interp, - int argc, - Jim_Obj *const *argv) +static int Jim_Command_openocd(Jim_Interp *interp, int argc, Jim_Obj *const *argv) { return Jim_Command_openocd_ignore(interp, argc, argv, 1); } -static int -Jim_Command_openocd_throw(Jim_Interp *interp, - int argc, - Jim_Obj *const *argv) +static int Jim_Command_openocd_throw(Jim_Interp *interp, int argc, Jim_Obj *const *argv) { return Jim_Command_openocd_ignore(interp, argc, argv, 0); } - - - /* find full path to file */ -static int -Jim_Command_find(Jim_Interp *interp, - int argc, - Jim_Obj *const *argv) +static int Jim_Command_find(Jim_Interp *interp, int argc, Jim_Obj *const *argv) { if (argc!=2) return JIM_ERR; @@ -311,10 +491,7 @@ Jim_Command_find(Jim_Interp *interp, return JIM_OK; } -static int -Jim_Command_echo(Jim_Interp *interp, - int argc, - Jim_Obj *const *argv) +static int Jim_Command_echo(Jim_Interp *interp, int argc, Jim_Obj *const *argv) { if (argc!=2) return JIM_ERR; @@ -323,26 +500,117 @@ Jim_Command_echo(Jim_Interp *interp, return JIM_OK; } +static size_t openocd_jim_fwrite(const void *_ptr, size_t size, size_t n, void *cookie) +{ + size_t nbytes; + const char *ptr; + + /* make it a char easier to read code */ + ptr = _ptr; + + nbytes = size * n; + if( nbytes == 0 ){ + return 0; + } + + if( !active_cmd_ctx ){ + /* FIXME: Where should this go? */ + return n; + } + + /* do we have to chunk it? */ + if( ptr[ nbytes ] == 0 ){ + /* no it is a C style string */ + command_output_text( active_cmd_ctx, ptr ); + return strlen(ptr); + } + /* GRR we must chunk - not null terminated */ + while( nbytes ){ + char chunk[128+1]; + int x; + + x = nbytes; + if( x > 128 ){ + x = 128; + } + /* copy it */ + memcpy( chunk, ptr, x ); + /* terminate it */ + chunk[n] = 0; + /* output it */ + command_output_text( active_cmd_ctx, chunk ); + ptr += x; + nbytes -= x; + } + + return n; +} + +static size_t openocd_jim_fread(void *ptr, size_t size, size_t n, void *cookie ) +{ + /* TCL wants to read... tell him no */ + return 0; +} + +static int openocd_jim_vfprintf(void *cookie, const char *fmt, va_list ap) +{ + char *cp; + int n; + + n = -1; + if( active_cmd_ctx ){ + cp = alloc_vprintf( fmt, ap ); + if( cp ){ + command_output_text( active_cmd_ctx, cp ); + n = strlen(cp); + free(cp); + } + } + return n; +} + +static int openocd_jim_fflush(void *cookie) +{ + /* nothing to flush */ + return 0; +} + +static char* openocd_jim_fgets(char *s, int size, void *cookie) +{ + /* not supported */ + errno = ENOTSUP; + return NULL; +} + void initJim(void) { - Jim_InitEmbedded(); - - /* Create an interpreter */ - interp = Jim_CreateInterp(); - /* Add all the Jim core commands */ - Jim_RegisterCoreCommands(interp); Jim_CreateCommand(interp, "openocd", Jim_Command_openocd, NULL, NULL); Jim_CreateCommand(interp, "openocd_throw", Jim_Command_openocd_throw, NULL, NULL); Jim_CreateCommand(interp, "find", Jim_Command_find, NULL, NULL); Jim_CreateCommand(interp, "echo", Jim_Command_echo, NULL, NULL); + Jim_CreateCommand(interp, "mem2array", Jim_Command_mem2array, NULL, NULL ); + + /* Set Jim's STDIO */ + interp->cookie_stdin = NULL; + interp->cookie_stdout = NULL; + interp->cookie_stderr = NULL; + interp->cb_fwrite = openocd_jim_fwrite; + interp->cb_fread = openocd_jim_fread ; + interp->cb_vfprintf = openocd_jim_vfprintf; + interp->cb_fflush = openocd_jim_fflush; + interp->cb_fgets = openocd_jim_fgets; } -int main(int argc, char *argv[]) +/* after command line parsing */ +void initJim2(void) { - initJim(); + Jim_Eval(interp, "source [find tcl/commands.tcl]"); +} + +command_context_t *setup_command_handler() +{ + command_context_t *cmd_ctx; - /* initialize commandline interface */ - command_context_t *cmd_ctx, *cfg_cmd_ctx; cmd_ctx = command_init(); register_command(cmd_ctx, NULL, "version", handle_version_command, @@ -354,6 +622,7 @@ int main(int argc, char *argv[]) server_register_commands(cmd_ctx); telnet_register_commands(cmd_ctx); gdb_register_commands(cmd_ctx); + tcl_register_commands(cmd_ctx); /* tcl server commands */ log_register_commands(cmd_ctx); jtag_register_commands(cmd_ctx); interpreter_register_commands(cmd_ctx); @@ -364,7 +633,9 @@ int main(int argc, char *argv[]) pld_register_commands(cmd_ctx); if (log_init(cmd_ctx) != ERROR_OK) - return EXIT_FAILURE; + { + exit(-1); + } LOG_DEBUG("log init complete"); LOG_OUTPUT( OPENOCD_VERSION "\n" ); @@ -385,6 +656,31 @@ int main(int argc, char *argv[]) register_command(cmd_ctx, NULL, "init", handle_init_command, COMMAND_ANY, "initializes target and servers - nop on subsequent invocations"); + return cmd_ctx; +} + +/* +normally this is the main() function entry, but if OpenOCD is linked +into application, then this fn will not be invoked, but rather that +application will have it's own implementation of main(). +*/ +int openocd_main(int argc, char *argv[]) +{ +#ifdef JIM_EMBEDDED + Jim_InitEmbedded(); + /* Create an interpreter */ + interp = Jim_CreateInterp(); + /* Add all the Jim core commands */ + Jim_RegisterCoreCommands(interp); +#endif + + initJim(); + + /* initialize commandline interface */ + command_context_t *cmd_ctx; + cmd_ctx=setup_command_handler(); + + command_context_t *cfg_cmd_ctx; cfg_cmd_ctx = copy_command_context(cmd_ctx); cfg_cmd_ctx->mode = COMMAND_CONFIG; command_set_output_handler(cfg_cmd_ctx, configuration_output_handler, NULL); @@ -392,7 +688,7 @@ int main(int argc, char *argv[]) if (parse_cmdline_args(cfg_cmd_ctx, argc, argv) != ERROR_OK) return EXIT_FAILURE; - Jim_Eval(interp, "source [find tcl/commands.tcl]"); + initJim2(); if (parse_config_file(cfg_cmd_ctx) != ERROR_OK) return EXIT_FAILURE; @@ -404,8 +700,7 @@ int main(int argc, char *argv[]) if (daemon_startup) command_run_line(cmd_ctx, "reset"); - - + startLoop=1; /* handle network connections */ @@ -421,4 +716,3 @@ int main(int argc, char *argv[]) return EXIT_SUCCESS; } -