src/openocd.c

   1 /***************************************************************************
   2  *   Copyright (C) 2005 by Dominic Rath                                    *
   3  *   Dominic.Rath@gmx.de                                                   *
   4  *                                                                         *
   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.                                   *
   9  *                                                                         *
  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.                          *
  14  *                                                                         *
  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  ***************************************************************************/
  20
  21 #define OPENOCD_VERSION "Open On-Chip Debugger " VERSION " (" PKGBLDDATE ") svn:" PKGBLDREV
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include "config.h"
  25 #endif
  26
  27 #include "log.h"
  28 #include "types.h"
  29 #include "jtag.h"
  30 #include "configuration.h"
  31 #include "interpreter.h"
  32 #include "xsvf.h"
  33 #include "target.h"
  34 #include "flash.h"
  35 #include "nand.h"
  36 #include "pld.h"
  37
  38 #include "command.h"
  39 #include "server.h"
  40 #include "telnet_server.h"
  41 #include "gdb_server.h"
  42
  43 #include <sys/time.h>
  44 #include <sys/types.h>
  45 #include <strings.h>
  46 #include <stdio.h>
  47 #include <stdlib.h>
  48 #include <string.h>
  49 #include <unistd.h>
  50 #include <errno.h>
  51
  52 #define JIM_EMBEDDED
  53 #include "jim.h"
  54
  55
  56 /* Give TELNET a way to find out what version this is */
  57 int handle_version_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
  58 {
  59         command_print(cmd_ctx, OPENOCD_VERSION);
  60
  61         return ERROR_OK;
  62 }
  63
  64 static int daemon_startup = 0;
  65
  66 int handle_daemon_startup_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
  67 {
  68         if (argc==0)
  69                 return ERROR_OK;
  70         if (argc > 1 )
  71                 return ERROR_COMMAND_SYNTAX_ERROR;
  72
  73         daemon_startup = strcmp("reset", args[0])==0;
  74
  75         command_print(cmd_ctx, OPENOCD_VERSION);
  76
  77         return ERROR_OK;
  78 }
  79
  80
  81 void exit_handler(void)
  82 {
  83         /* close JTAG interface */
  84         if (jtag && jtag->quit)
  85                 jtag->quit();
  86 }
  87
  88
  89 /* OpenOCD can't really handle failure of this command. Patches welcome! :-) */
  90 int handle_init_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
  91 {
  92         int retval;
  93         static int initialized=0;
  94         if (initialized)
  95                 return ERROR_OK;
  96
  97         initialized=1;
  98
  99         command_set_output_handler(cmd_ctx, configuration_output_handler, NULL);
 100
 101         atexit(exit_handler);
 102
 103
 104         if (target_init(cmd_ctx) != ERROR_OK)
 105                 return ERROR_FAIL;
 106         LOG_DEBUG("target init complete");
 107
 108         if ((retval=jtag_interface_init(cmd_ctx)) != ERROR_OK)
 109         {
 110                 /* we must be able to set up the jtag interface */
 111                 return retval;
 112         }
 113         LOG_DEBUG("jtag interface init complete");
 114
 115         /* Try to initialize & examine the JTAG chain at this point, but
 116          * continue startup regardless
 117          */
 118         if (jtag_init(cmd_ctx) == ERROR_OK)
 119         {
 120                 LOG_DEBUG("jtag init complete");
 121                 if (target_examine(cmd_ctx) == ERROR_OK)
 122                 {
 123                         LOG_DEBUG("jtag examine complete");
 124                 }
 125         }
 126
 127
 128         if (flash_init_drivers(cmd_ctx) != ERROR_OK)
 129                 return ERROR_FAIL;
 130         LOG_DEBUG("flash init complete");
 131
 132         if (nand_init(cmd_ctx) != ERROR_OK)
 133                 return ERROR_FAIL;
 134         LOG_DEBUG("NAND init complete");
 135
 136         if (pld_init(cmd_ctx) != ERROR_OK)
 137                 return ERROR_FAIL;
 138         LOG_DEBUG("pld init complete");
 139
 140         /* initialize tcp server */
 141         server_init();
 142
 143         /* initialize telnet subsystem */
 144         telnet_init("Open On-Chip Debugger");
 145         gdb_init();
 146
 147         return ERROR_OK;
 148 }
 149
 150
 151 /* implementations of OpenOCD that uses multithreading needs to lock OpenOCD while calling
 152  * OpenOCD fn's. No-op in vanilla OpenOCD
 153  */
 154 void lockBigLock()
 155 {
 156 }
 157 void unlockBigLock()
 158 {
 159 }
 160
 161
 162
 163
 164
 165 Jim_Interp *interp;
 166 command_context_t *active_cmd_ctx;
 167
 168 static void tcl_output(void *privData, const char *file, int line,
 169                 const char *function, const char *string)
 170 {
 171         Jim_Obj *tclOutput=(Jim_Obj *)privData;
 172
 173         Jim_AppendString(interp, tclOutput, string, strlen(string));
 174 }
 175
 176 /* try to execute as Jim command, otherwise fall back to standard command.
 177
 178         Note that even if the Jim command caused an error, then we succeeded
 179         to execute it, hence this fn pretty much always returns ERROR_OK.
 180
 181  */
 182 int jim_command(command_context_t *context, char *line)
 183 {
 184         int retval=ERROR_OK;
 185         active_cmd_ctx=context;
 186         int retcode=Jim_Eval(interp, line);
 187         active_cmd_ctx=NULL;
 188
 189         const char *result;
 190         int reslen;
 191     result = Jim_GetString(Jim_GetResult(interp), &reslen);
 192     if (retcode == JIM_ERR) {
 193             int len, i;
 194
 195             LOG_USER_N("Runtime error, file \"%s\", line %d:" JIM_NL,
 196                     interp->errorFileName, interp->errorLine);
 197             LOG_USER_N("    %s" JIM_NL,
 198                     Jim_GetString(interp->result, NULL));
 199             Jim_ListLength(interp, interp->stackTrace, &len);
 200             for (i = 0; i < len; i+= 3) {
 201                 Jim_Obj *objPtr;
 202                 const char *proc, *file, *line;
 203
 204                 Jim_ListIndex(interp, interp->stackTrace, i, &objPtr, JIM_NONE);
 205                 proc = Jim_GetString(objPtr, NULL);
 206                 Jim_ListIndex(interp, interp->stackTrace, i+1, &objPtr,
 207                         JIM_NONE);
 208                 file = Jim_GetString(objPtr, NULL);
 209                 Jim_ListIndex(interp, interp->stackTrace, i+2, &objPtr,
 210                         JIM_NONE);
 211                 line = Jim_GetString(objPtr, NULL);
 212                 LOG_USER_N("In procedure '%s' called at file \"%s\", line %s" JIM_NL,
 213                         proc, file, line);
 214             }
 215     } else if (retcode == JIM_EXIT) {
 216         // ignore.
 217         //exit(Jim_GetExitCode(interp));
 218     } else {
 219         if (reslen) {
 220                 int i;
 221                 char buff[256+1];
 222                 for (i=0; i<reslen; i+=256)
 223                 {
 224                         int chunk;
 225                         chunk=reslen-i;
 226                         if (chunk>256)
 227                                 chunk=256;
 228                         strncpy(buff, result, chunk);
 229                         buff[chunk]=0;
 230                 LOG_USER_N("%s", buff);
 231                 }
 232                 LOG_USER_N("%s", "\n");
 233         }
 234     }
 235         return retval;
 236 }
 237
 238 static int startLoop=0;
 239
 240 static int
 241 Jim_Command_openocd_ignore(Jim_Interp *interp,
 242                                    int argc,
 243                                    Jim_Obj *const *argv,
 244                                    int ignore)
 245 {
 246         int retval;
 247     char *cmd = (char*)Jim_GetString(argv[1], NULL);
 248
 249         lockBigLock();
 250
 251     Jim_Obj *tclOutput = Jim_NewStringObj(interp, "", 0);
 252
 253     if (startLoop)
 254     {
 255         // We don't know whether or not the telnet/gdb server is running...
 256         target_call_timer_callbacks_now();
 257     }
 258
 259         log_add_callback(tcl_output, tclOutput);
 260     retval=command_run_line_internal(active_cmd_ctx, cmd);
 261
 262     if (startLoop)
 263     {
 264         target_call_timer_callbacks_now();
 265     }
 266         log_remove_callback(tcl_output, tclOutput);
 267
 268         Jim_SetResult(interp, tclOutput);
 269     unlockBigLock();
 270
 271     return (ignore||(retval==ERROR_OK))?JIM_OK:JIM_ERR;
 272 }
 273
 274 static int
 275 Jim_Command_openocd(Jim_Interp *interp,
 276                                    int argc,
 277                                    Jim_Obj *const *argv)
 278 {
 279         return Jim_Command_openocd_ignore(interp, argc, argv, 1);
 280 }
 281
 282 static int
 283 Jim_Command_openocd_throw(Jim_Interp *interp,
 284                                    int argc,
 285                                    Jim_Obj *const *argv)
 286 {
 287         return Jim_Command_openocd_ignore(interp, argc, argv, 0);
 288 }
 289
 290
 291
 292
 293 /* find full path to file */
 294 static int
 295 Jim_Command_find(Jim_Interp *interp,
 296                                    int argc,
 297                                    Jim_Obj *const *argv)
 298 {
 299         if (argc!=2)
 300                 return JIM_ERR;
 301         char *file = (char*)Jim_GetString(argv[1], NULL);
 302         char *full_path=find_file(file);
 303         if (full_path==NULL)
 304                 return JIM_ERR;
 305     Jim_Obj *result = Jim_NewStringObj(interp, full_path, strlen(full_path));
 306     free(full_path);
 307
 308         Jim_SetResult(interp, result);
 309         return JIM_OK;
 310 }
 311
 312
 313 void initJim(void)
 314 {
 315     Jim_InitEmbedded();
 316
 317     /* Create an interpreter */
 318     interp = Jim_CreateInterp();
 319     /* Add all the Jim core commands */
 320     Jim_RegisterCoreCommands(interp);
 321     Jim_CreateCommand(interp, "openocd", Jim_Command_openocd, NULL, NULL);
 322     Jim_CreateCommand(interp, "openocd_throw", Jim_Command_openocd_throw, NULL, NULL);
 323     Jim_CreateCommand(interp, "find", Jim_Command_find, NULL, NULL);
 324 }
 325
 326 int main(int argc, char *argv[])
 327 {
 328         initJim();
 329
 330         /* initialize commandline interface */
 331         command_context_t *cmd_ctx, *cfg_cmd_ctx;
 332         cmd_ctx = command_init();
 333
 334         register_command(cmd_ctx, NULL, "version", handle_version_command,
 335                                          COMMAND_EXEC, "show OpenOCD version");
 336         register_command(cmd_ctx, NULL, "daemon_startup", handle_daemon_startup_command, COMMAND_CONFIG,
 337                         "deprecated - use \"init\" and \"reset\" at end of startup script instead");
 338
 339         /* register subsystem commands */
 340         server_register_commands(cmd_ctx);
 341         telnet_register_commands(cmd_ctx);
 342         gdb_register_commands(cmd_ctx);
 343         log_register_commands(cmd_ctx);
 344         jtag_register_commands(cmd_ctx);
 345         interpreter_register_commands(cmd_ctx);
 346         xsvf_register_commands(cmd_ctx);
 347         target_register_commands(cmd_ctx);
 348         flash_register_commands(cmd_ctx);
 349         nand_register_commands(cmd_ctx);
 350         pld_register_commands(cmd_ctx);
 351
 352         if (log_init(cmd_ctx) != ERROR_OK)
 353                 return EXIT_FAILURE;
 354         LOG_DEBUG("log init complete");
 355
 356         LOG_OUTPUT( OPENOCD_VERSION "\n" );
 357
 358
 359         /* DANGER!!! make sure that the line below does not appear in a patch, do not remove */
 360         /* DANGER!!! make sure that the line below does not appear in a patch, do not remove */
 361         /* DANGER!!! make sure that the line below does not appear in a patch, do not remove */
 362         /* DANGER!!! make sure that the line below does not appear in a patch, do not remove */
 363         /* DANGER!!! make sure that the line below does not appear in a patch, do not remove */
 364         LOG_OUTPUT( "$URL$\n");
 365         /* DANGER!!! make sure that the line above does not appear in a patch, do not remove */
 366         /* DANGER!!! make sure that the line above does not appear in a patch, do not remove */
 367         /* DANGER!!! make sure that the line above does not appear in a patch, do not remove */
 368         /* DANGER!!! make sure that the line above does not appear in a patch, do not remove */
 369         /* DANGER!!! make sure that the line above does not appear in a patch, do not remove */
 370
 371         register_command(cmd_ctx, NULL, "init", handle_init_command,
 372                                          COMMAND_ANY, "initializes target and servers - nop on subsequent invocations");
 373
 374         cfg_cmd_ctx = copy_command_context(cmd_ctx);
 375         cfg_cmd_ctx->mode = COMMAND_CONFIG;
 376         command_set_output_handler(cfg_cmd_ctx, configuration_output_handler, NULL);
 377
 378         if (parse_cmdline_args(cfg_cmd_ctx, argc, argv) != ERROR_OK)
 379                 return EXIT_FAILURE;
 380
 381     Jim_Eval(interp, "source [find tcl/commands.tcl]");
 382
 383         if (parse_config_file(cfg_cmd_ctx) != ERROR_OK)
 384                 return EXIT_FAILURE;
 385
 386         command_done(cfg_cmd_ctx);
 387
 388         if (command_run_line(cmd_ctx, "init")!=ERROR_OK)
 389                 return EXIT_FAILURE;
 390
 391         if (daemon_startup)
 392                 command_run_line(cmd_ctx, "reset");
 393
 394
 395         startLoop=1;
 396
 397         /* handle network connections */
 398         server_loop(cmd_ctx);
 399
 400         /* shut server down */
 401         server_quit();
 402
 403         unregister_all_commands(cmd_ctx);
 404
 405         /* free commandline interface */
 406         command_done(cmd_ctx);
 407
 408         return EXIT_SUCCESS;
 409 }
 410