1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19 ***************************************************************************/
21 #define OPENOCD_VERSION "Open On-Chip Debugger " VERSION " (" PKGBLDDATE ") svn:" PKGBLDREV
30 #include "configuration.h"
39 #include "telnet_server.h"
40 #include "gdb_server.h"
41 #include "tcl_server.h"
44 #include <sys/types.h>
59 /* Jim is provied by eCos */
60 #include <cyg/jimtcl/jim.h>
66 #include "replacements.h"
69 /* Give TELNET a way to find out what version this is */
70 int handle_version_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
72 command_print(cmd_ctx, OPENOCD_VERSION);
77 static int daemon_startup = 0;
79 int handle_daemon_startup_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
84 return ERROR_COMMAND_SYNTAX_ERROR;
86 daemon_startup = strcmp("reset", args[0])==0;
88 command_print(cmd_ctx, OPENOCD_VERSION);
93 void exit_handler(void)
95 /* close JTAG interface */
96 if (jtag && jtag->quit)
100 /* OpenOCD can't really handle failure of this command. Patches welcome! :-) */
101 int handle_init_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
104 static int initialized=0;
110 command_set_output_handler(cmd_ctx, configuration_output_handler, NULL);
112 atexit(exit_handler);
114 if (target_init(cmd_ctx) != ERROR_OK)
116 LOG_DEBUG("target init complete");
118 if ((retval=jtag_interface_init(cmd_ctx)) != ERROR_OK)
120 /* we must be able to set up the jtag interface */
123 LOG_DEBUG("jtag interface init complete");
125 /* Try to initialize & examine the JTAG chain at this point, but
126 * continue startup regardless */
127 if (jtag_init(cmd_ctx) == ERROR_OK)
129 LOG_DEBUG("jtag init complete");
130 if (target_examine(cmd_ctx) == ERROR_OK)
132 LOG_DEBUG("jtag examine complete");
136 if (flash_init_drivers(cmd_ctx) != ERROR_OK)
138 LOG_DEBUG("flash init complete");
140 if (nand_init(cmd_ctx) != ERROR_OK)
142 LOG_DEBUG("NAND init complete");
144 if (pld_init(cmd_ctx) != ERROR_OK)
146 LOG_DEBUG("pld init complete");
148 /* initialize tcp server */
151 /* initialize telnet subsystem */
152 telnet_init("Open On-Chip Debugger");
154 tcl_init(); /* allows tcl to just connect without going thru telnet */
160 command_context_t *active_cmd_ctx;
162 static int new_int_array_element(Jim_Interp * interp, const char *varname, int idx, u32 val)
165 Jim_Obj *nameObjPtr, *valObjPtr;
168 namebuf = alloc_printf("%s(%d)", varname, idx);
172 nameObjPtr = Jim_NewStringObj(interp, namebuf, -1);
173 valObjPtr = Jim_NewIntObj(interp, val);
174 if (!nameObjPtr || !valObjPtr)
180 Jim_IncrRefCount(nameObjPtr);
181 Jim_IncrRefCount(valObjPtr);
182 result = Jim_SetVariable(interp, nameObjPtr, valObjPtr);
183 Jim_DecrRefCount(interp, nameObjPtr);
184 Jim_DecrRefCount(interp, valObjPtr);
186 /* printf("%s(%d) <= 0%08x\n", varname, idx, val); */
190 static int Jim_Command_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
203 /* argv[1] = name of array to receive the data
204 * argv[2] = desired width
205 * argv[3] = memory address
206 * argv[4] = count of times to read
209 Jim_WrongNumArgs(interp, 1, argv, "varname width addr nelems");
212 varname = Jim_GetString(argv[1], &len);
213 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
215 e = Jim_GetLong(interp, argv[2], &l);
221 e = Jim_GetLong(interp, argv[3], &l);
226 e = Jim_GetLong(interp, argv[4], &l);
242 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
243 Jim_AppendStrings( interp, Jim_GetResult(interp), "Invalid width param, must be 8/16/32", NULL );
247 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
248 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: zero width read?", NULL);
251 if ((addr + (len * width)) < addr) {
252 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
253 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: addr + len - wraps to zero?", NULL);
256 /* absurd transfer size? */
258 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
259 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: absurd > 64K item request", NULL);
264 ((width == 2) && ((addr & 1) == 0)) ||
265 ((width == 4) && ((addr & 3) == 0))) {
269 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
270 sprintf(buf, "mem2array address: 0x%08x is not aligned for %d byte reads", addr, width);
271 Jim_AppendStrings(interp, Jim_GetResult(interp), buf , NULL);
275 target = get_current_target(active_cmd_ctx);
284 /* Slurp... in buffer size chunks */
286 count = len; /* in objects.. */
287 if (count > (sizeof(buffer)/width)) {
288 count = (sizeof(buffer)/width);
291 retval = target->type->read_memory( target, addr, width, count, buffer );
292 if (retval != ERROR_OK) {
294 LOG_ERROR("mem2array: Read @ 0x%08x, w=%d, cnt=%d, failed", addr, width, count);
295 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
296 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: cannot read memory", NULL);
300 v = 0; /* shut up gcc */
301 for (i = 0 ;i < count ;i++, n++) {
304 v = target_buffer_get_u32(target, &buffer[i*width]);
307 v = target_buffer_get_u16(target, &buffer[i*width]);
310 v = buffer[i] & 0x0ff;
313 new_int_array_element(interp, varname, n, v);
319 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
324 static int get_int_array_element(Jim_Interp * interp, const char *varname, int idx, u32 *val)
327 Jim_Obj *nameObjPtr, *valObjPtr;
331 namebuf = alloc_printf("%s(%d)", varname, idx);
335 nameObjPtr = Jim_NewStringObj(interp, namebuf, -1);
342 Jim_IncrRefCount(nameObjPtr);
343 valObjPtr = Jim_GetVariable(interp, nameObjPtr, JIM_ERRMSG);
344 Jim_DecrRefCount(interp, nameObjPtr);
346 if (valObjPtr == NULL)
349 result = Jim_GetLong(interp, valObjPtr, &l);
350 /* printf("%s(%d) => 0%08x\n", varname, idx, val); */
355 static int Jim_Command_array2mem(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
368 /* argv[1] = name of array to get the data
369 * argv[2] = desired width
370 * argv[3] = memory address
371 * argv[4] = count to write
374 Jim_WrongNumArgs(interp, 1, argv, "varname width addr nelems");
377 varname = Jim_GetString(argv[1], &len);
378 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
380 e = Jim_GetLong(interp, argv[2], &l);
386 e = Jim_GetLong(interp, argv[3], &l);
391 e = Jim_GetLong(interp, argv[4], &l);
407 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
408 Jim_AppendStrings( interp, Jim_GetResult(interp), "Invalid width param, must be 8/16/32", NULL );
412 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
413 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: zero width read?", NULL);
416 if ((addr + (len * width)) < addr) {
417 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
418 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: addr + len - wraps to zero?", NULL);
421 /* absurd transfer size? */
423 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
424 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: absurd > 64K item request", NULL);
429 ((width == 2) && ((addr & 1) == 0)) ||
430 ((width == 4) && ((addr & 3) == 0))) {
434 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
435 sprintf(buf, "array2mem address: 0x%08x is not aligned for %d byte reads", addr, width);
436 Jim_AppendStrings(interp, Jim_GetResult(interp), buf , NULL);
440 target = get_current_target(active_cmd_ctx);
449 /* Slurp... in buffer size chunks */
451 count = len; /* in objects.. */
452 if (count > (sizeof(buffer)/width)) {
453 count = (sizeof(buffer)/width);
456 v = 0; /* shut up gcc */
457 for (i = 0 ;i < count ;i++, n++) {
458 get_int_array_element(interp, varname, n, &v);
461 target_buffer_set_u32(target, &buffer[i*width], v);
464 target_buffer_set_u16(target, &buffer[i*width], v);
467 buffer[i] = v & 0x0ff;
473 retval = target->type->write_memory(target, addr, width, count, buffer);
474 if (retval != ERROR_OK) {
476 LOG_ERROR("array2mem: Write @ 0x%08x, w=%d, cnt=%d, failed", addr, width, count);
477 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
478 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: cannot read memory", NULL);
484 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
490 static int openocd_retval;
492 /* try to execute as Jim command, otherwise fall back to standard command.
493 * Note that even if the Jim command caused an error, then we succeeded
494 * to execute it, hence this fn pretty much always returns ERROR_OK. */
495 int jim_command(command_context_t *context, char *line)
500 active_cmd_ctx = context;
501 openocd_retval=ERROR_OK;
502 retcode = Jim_Eval(interp, line);
504 if (retcode == JIM_ERR) {
505 if (openocd_retval!=ERROR_COMMAND_CLOSE_CONNECTION)
507 /* We do not print the connection closed error message */
508 Jim_PrintErrorMessage(interp);
510 if (openocd_retval==ERROR_OK)
512 /* It wasn't a low level OpenOCD command that failed */
515 return openocd_retval;
519 result = Jim_GetString(Jim_GetResult(interp), &reslen);
521 if (retcode == JIM_EXIT) {
523 /* exit(Jim_GetExitCode(interp)); */
528 for (i = 0; i < reslen; i += 256)
534 strncpy(buff, result+i, chunk);
536 LOG_USER_N("%s", buff);
538 LOG_USER_N("%s", "\n");
544 /* find full path to file */
545 static int Jim_Command_find(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
549 const char *file = Jim_GetString(argv[1], NULL);
550 char *full_path = find_file(file);
551 if (full_path == NULL)
553 Jim_Obj *result = Jim_NewStringObj(interp, full_path, strlen(full_path));
556 Jim_SetResult(interp, result);
560 static int Jim_Command_echo(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
564 char *str = (char*)Jim_GetString(argv[1], NULL);
571 static size_t openocd_jim_fwrite(const void *_ptr, size_t size, size_t n, void *cookie)
576 /* make it a char easier to read code */
584 if (!active_cmd_ctx) {
585 /* TODO: Where should this go? */
589 /* do we have to chunk it? */
590 if (ptr[nbytes] == 0) {
591 /* no it is a C style string */
592 command_output_text(active_cmd_ctx, ptr);
595 /* GRR we must chunk - not null terminated */
605 memcpy(chunk, ptr, x);
609 command_output_text(active_cmd_ctx, chunk);
617 static size_t openocd_jim_fread(void *ptr, size_t size, size_t n, void *cookie )
619 /* TCL wants to read... tell him no */
623 static int openocd_jim_vfprintf(void *cookie, const char *fmt, va_list ap)
629 if (active_cmd_ctx) {
630 cp = alloc_vprintf(fmt, ap);
632 command_output_text(active_cmd_ctx, cp);
640 static int openocd_jim_fflush(void *cookie)
642 /* nothing to flush */
646 static char* openocd_jim_fgets(char *s, int size, void *cookie)
653 void add_jim(const char *name, int (*cmd)(Jim_Interp *interp, int argc, Jim_Obj *const *argv), const char *help)
655 Jim_CreateCommand(interp, name, cmd, NULL, NULL);
657 /* FIX!!! it would be prettier to invoke add_help_text...
658 accumulate help text in Tcl helptext list. */
659 Jim_Obj *helptext=Jim_GetGlobalVariableStr(interp, "ocd_helptext", JIM_ERRMSG);
660 if (Jim_IsShared(helptext))
661 helptext = Jim_DuplicateObj(interp, helptext);
663 Jim_Obj *cmd_entry=Jim_NewListObj(interp, NULL, 0);
665 Jim_Obj *cmd_list=Jim_NewListObj(interp, NULL, 0);
666 Jim_ListAppendElement(interp, cmd_list, Jim_NewStringObj(interp, name, -1));
668 Jim_ListAppendElement(interp, cmd_entry, cmd_list);
669 Jim_ListAppendElement(interp, cmd_entry, Jim_NewStringObj(interp, help, -1));
670 Jim_ListAppendElement(interp, helptext, cmd_entry);
673 extern unsigned const char startup_tcl[];
677 Jim_CreateCommand(interp, "openocd_find", Jim_Command_find, NULL, NULL);
678 Jim_CreateCommand(interp, "echo", Jim_Command_echo, NULL, NULL);
679 Jim_CreateCommand(interp, "mem2array", Jim_Command_mem2array, NULL, NULL );
680 Jim_CreateCommand(interp, "array2mem", Jim_Command_array2mem, NULL, NULL );
682 /* Set Jim's STDIO */
683 interp->cookie_stdin = NULL;
684 interp->cookie_stdout = NULL;
685 interp->cookie_stderr = NULL;
686 interp->cb_fwrite = openocd_jim_fwrite;
687 interp->cb_fread = openocd_jim_fread ;
688 interp->cb_vfprintf = openocd_jim_vfprintf;
689 interp->cb_fflush = openocd_jim_fflush;
690 interp->cb_fgets = openocd_jim_fgets;
694 if (Jim_Eval(interp, startup_tcl)==JIM_ERR)
696 LOG_ERROR("Failed to run startup.tcl (embedded into OpenOCD compile time)");
697 Jim_PrintErrorMessage(interp);
702 command_context_t *setup_command_handler(void)
704 command_context_t *cmd_ctx;
706 cmd_ctx = command_init();
708 register_command(cmd_ctx, NULL, "version", handle_version_command,
709 COMMAND_EXEC, "show OpenOCD version");
710 register_command(cmd_ctx, NULL, "daemon_startup", handle_daemon_startup_command, COMMAND_CONFIG,
711 "deprecated - use \"init\" and \"reset\" at end of startup script instead");
713 /* register subsystem commands */
714 server_register_commands(cmd_ctx);
715 telnet_register_commands(cmd_ctx);
716 gdb_register_commands(cmd_ctx);
717 tcl_register_commands(cmd_ctx); /* tcl server commands */
718 log_register_commands(cmd_ctx);
719 jtag_register_commands(cmd_ctx);
720 xsvf_register_commands(cmd_ctx);
721 target_register_commands(cmd_ctx);
722 flash_register_commands(cmd_ctx);
723 nand_register_commands(cmd_ctx);
724 pld_register_commands(cmd_ctx);
726 if (log_init(cmd_ctx) != ERROR_OK)
730 LOG_DEBUG("log init complete");
732 LOG_OUTPUT( OPENOCD_VERSION "\n" );
735 register_command(cmd_ctx, NULL, "init", handle_init_command,
736 COMMAND_ANY, "initializes target and servers - nop on subsequent invocations");
741 /* normally this is the main() function entry, but if OpenOCD is linked
742 * into application, then this fn will not be invoked, but rather that
743 * application will have it's own implementation of main(). */
744 int openocd_main(int argc, char *argv[])
748 /* Create an interpreter */
749 interp = Jim_CreateInterp();
750 /* Add all the Jim core commands */
751 Jim_RegisterCoreCommands(interp);
756 /* initialize commandline interface */
757 command_context_t *cmd_ctx;
758 cmd_ctx=setup_command_handler();
760 /* DANGER!!! make sure that the line below does not appear in a patch, do not remove */
761 /* DANGER!!! make sure that the line below does not appear in a patch, do not remove */
762 /* DANGER!!! make sure that the line below does not appear in a patch, do not remove */
763 /* DANGER!!! make sure that the line below does not appear in a patch, do not remove */
764 /* DANGER!!! make sure that the line below does not appear in a patch, do not remove */
765 LOG_OUTPUT( "$URL$\n");
766 /* DANGER!!! make sure that the line above does not appear in a patch, do not remove */
767 /* DANGER!!! make sure that the line above does not appear in a patch, do not remove */
768 /* DANGER!!! make sure that the line above does not appear in a patch, do not remove */
769 /* DANGER!!! make sure that the line above does not appear in a patch, do not remove */
770 /* DANGER!!! make sure that the line above does not appear in a patch, do not remove */
772 command_context_t *cfg_cmd_ctx;
773 cfg_cmd_ctx = copy_command_context(cmd_ctx);
774 cfg_cmd_ctx->mode = COMMAND_CONFIG;
775 command_set_output_handler(cfg_cmd_ctx, configuration_output_handler, NULL);
777 active_cmd_ctx=cfg_cmd_ctx;
780 if (parse_cmdline_args(cfg_cmd_ctx, argc, argv) != ERROR_OK)
783 if (parse_config_file(cfg_cmd_ctx) != ERROR_OK)
786 active_cmd_ctx=cmd_ctx;
788 command_done(cfg_cmd_ctx);
790 if (command_run_line(cmd_ctx, "init")!=ERROR_OK)
794 command_run_line(cmd_ctx, "reset");
796 /* handle network connections */
797 server_loop(cmd_ctx);
799 /* shut server down */
802 unregister_all_commands(cmd_ctx);
804 /* free commandline interface */
805 command_done(cmd_ctx);