remove flash.h from tree

[fw/openocd] / src / openocd.c

diff --git a/src/openocd.c b/src/openocd.c
index 79a30e77e176e4fb44a4f2a6303e1bcdd8a65fa5..e500ba6081a9182dbea9d91127e77ea28411e8f3 100644 (file)
--- a/src/openocd.c
+++ b/src/openocd.c
@@ -29,17 +29,19 @@
 #endif
 
 #include "openocd.h"
-#include "jtag.h"
-#include "configuration.h"
-#include "xsvf.h"
-#include "svf.h"
-#include "nand.h"
-#include "pld.h"
-#include "mflash.h"
-
-#include "server.h"
-#include "gdb_server.h"
-#include "httpd.h"
+#include <jtag/jtag.h>
+#include <helper/ioutil.h>
+#include <helper/configuration.h>
+#include <xsvf/xsvf.h>
+#include <svf/svf.h>
+#include <flash/nor/core.h>
+#include <flash/nand.h>
+#include <pld/pld.h>
+#include <flash/mflash.h>
+
+#include <server/server.h>
+#include <server/gdb_server.h>
+#include <server/httpd.h>
 
 #ifdef HAVE_STRINGS_H
 #include <strings.h>
@@ -85,8 +87,6 @@ static int log_target_callback_event_handler(struct target *target, enum target_
        return ERROR_OK;
 }
 
-int ioutil_init(struct command_context *cmd_ctx);
-
 static bool init_at_startup = true;
 
 COMMAND_HANDLER(handle_noinit_command)
@@ -111,11 +111,9 @@ COMMAND_HANDLER(handle_init_command)
 
        initialized = 1;
 
-       command_context_mode(CMD_CTX, COMMAND_EXEC);
-
-       if (target_init(CMD_CTX) != ERROR_OK)
+       retval = command_run_line(CMD_CTX, "target init");
+       if (ERROR_OK != retval)
                return ERROR_FAIL;
-       LOG_DEBUG("target init complete");
 
        if ((retval = jtag_interface_init(CMD_CTX)) != ERROR_OK)
        {
@@ -124,19 +122,21 @@ COMMAND_HANDLER(handle_init_command)
        }
        LOG_DEBUG("jtag interface init complete");
 
-       /* Try to initialize & examine the JTAG chain at this point, but
-        * continue startup regardless */
-       command_context_mode(CMD_CTX, COMMAND_CONFIG);
+       /* Try to initialize & examine the JTAG chain at this point,
+        * but continue startup regardless.  Note that platforms
+        * need to be able to provide JTAG event handlers that use
+        * a variety of JTAG operations in order to do that...
+        */
+       command_context_mode(CMD_CTX, COMMAND_EXEC);
        if (command_run_line(CMD_CTX, "jtag init") == ERROR_OK)
        {
-               command_context_mode(CMD_CTX, COMMAND_EXEC);
                LOG_DEBUG("Examining targets...");
                if (target_examine() != ERROR_OK)
                        LOG_DEBUG("target examination failed");
-               command_context_mode(CMD_CTX, COMMAND_CONFIG);
        }
        else
                LOG_WARNING("jtag initialization failed; try 'jtag init' again.");
+       command_context_mode(CMD_CTX, COMMAND_CONFIG);
 
        if (command_run_line(CMD_CTX, "flash init") != ERROR_OK)
                return ERROR_FAIL;
@@ -175,7 +175,7 @@ static const struct command_registration openocd_command_handlers[] = {
        {
                .name = "init",
                .handler = &handle_init_command,
-               .mode = COMMAND_CONFIG,
+               .mode = COMMAND_ANY,
                .help = "Initializes configured targets and servers.  "
                        "Changes command mode from CONFIG to EXEC.  "
                        "Unless 'noinit' is called, this command is "
@@ -185,6 +185,11 @@ static const struct command_registration openocd_command_handlers[] = {
        COMMAND_REGISTRATION_DONE
 };
 
+int openocd_register_commands(struct command_context *cmd_ctx)
+{
+       return register_commands(cmd_ctx, NULL, openocd_command_handlers);
+}
+
 struct command_context *global_cmd_ctx;
 
 /* NB! this fn can be invoked outside this file for non PC hosted builds */
@@ -193,45 +198,44 @@ struct command_context *setup_command_handler(Jim_Interp *interp)
        log_init();
        LOG_DEBUG("log_init: complete");
 
-       struct command_context *cmd_ctx;
+       const char *startup = openocd_startup_tcl;
+       struct command_context *cmd_ctx = command_init(startup, interp);
 
-       global_cmd_ctx = cmd_ctx = command_init(openocd_startup_tcl, interp);
-
-       register_commands(cmd_ctx, NULL, openocd_command_handlers);
        /* register subsystem commands */
-       server_register_commands(cmd_ctx);
-       gdb_register_commands(cmd_ctx);
-       log_register_commands(cmd_ctx);
-       jtag_register_commands(cmd_ctx);
-       xsvf_register_commands(cmd_ctx);
-       svf_register_commands(cmd_ctx);
-       target_register_commands(cmd_ctx);
-       flash_register_commands(cmd_ctx);
-       nand_register_commands(cmd_ctx);
-       pld_register_commands(cmd_ctx);
-       mflash_register_commands(cmd_ctx);
-
+       typedef int (*command_registrant_t)(struct command_context *cmd_ctx);
+       command_registrant_t command_registrants[] = {
+               &openocd_register_commands,
+               &server_register_commands,
+               &gdb_register_commands,
+               &log_register_commands,
+               &jtag_register_commands,
+               &xsvf_register_commands,
+               &svf_register_commands,
+               &target_register_commands,
+               &flash_register_commands,
+               &nand_register_commands,
+               &pld_register_commands,
+               &mflash_register_commands,
+               NULL
+       };
+       for (unsigned i = 0; NULL != command_registrants[i]; i++)
+       {
+               int retval = (*command_registrants[i])(cmd_ctx);
+               if (ERROR_OK != retval)
+               {
+                       command_done(cmd_ctx);
+                       return NULL;
+               }
+       }
        LOG_DEBUG("command registration: complete");
 
        LOG_OUTPUT(OPENOCD_VERSION "\n");
 
-       return cmd_ctx;
-}
+       global_cmd_ctx = cmd_ctx;
 
-#if !BUILD_HTTPD && !BUILD_ECOSBOARD
-/* implementations of OpenOCD that uses multithreading needs to know when
- * OpenOCD is sleeping. No-op in vanilla OpenOCD
- */
-void openocd_sleep_prelude(void)
-{
+       return cmd_ctx;
 }
 
-void openocd_sleep_postlude(void)
-{
-}
-#endif
-
-
 /* 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(). */
@@ -244,12 +248,8 @@ int openocd_main(int argc, char *argv[])
 
        cmd_ctx = setup_command_handler(NULL);
 
-#if BUILD_IOUTIL
        if (ioutil_init(cmd_ctx) != ERROR_OK)
-       {
                return EXIT_FAILURE;
-       }
-#endif
 
        LOG_OUTPUT("For bug reports, read\n\t"
                "http://openocd.berlios.de/doc/doxygen/bugs.html"
@@ -266,10 +266,8 @@ int openocd_main(int argc, char *argv[])
        if (ret != ERROR_OK)
                return EXIT_FAILURE;
 
-#if BUILD_HTTPD
        if (httpd_start(cmd_ctx) != ERROR_OK)
                return EXIT_FAILURE;
-#endif
 
        ret = server_init(cmd_ctx);
        if (ERROR_OK != ret)
@@ -288,9 +286,7 @@ int openocd_main(int argc, char *argv[])
 
        server_quit();
 
-#if BUILD_HTTPD
        httpd_stop();
-#endif
 
        unregister_all_commands(cmd_ctx, NULL);