target: Use proper data types for timer callback
[openocd.git] / src / target / target.h
index 914d62f..36b131a 100644 (file)
@@ -2,12 +2,18 @@
  *   Copyright (C) 2005 by Dominic Rath                                    *
  *   Dominic.Rath@gmx.de                                                   *
  *                                                                         *
- *   Copyright (C) 2007,2008,2009 Øyvind Harboe                            *
+ *   Copyright (C) 2007-2010 Øyvind Harboe                                 *
  *   oyvind.harboe@zylin.com                                               *
  *                                                                         *
  *   Copyright (C) 2008 by Spencer Oliver                                  *
  *   spen@spen-soft.co.uk                                                  *
  *                                                                         *
+ *   Copyright (C) 2011 by Broadcom Corporation                            *
+ *   Evan Hunter - ehunter@broadcom.com                                    *
+ *                                                                         *
+ *   Copyright (C) ST-Ericsson SA 2011                                     *
+ *   michel.jaouen@stericsson.com : smp minimum support                    *
+ *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
- *   along with this program; if not, write to the                         *
- *   Free Software Foundation, Inc.,                                       *
- *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>. *
  ***************************************************************************/
-#ifndef TARGET_H
-#define TARGET_H
 
-#include <stddef.h>
+#ifndef OPENOCD_TARGET_TARGET_H
+#define OPENOCD_TARGET_TARGET_H
 
-#include "breakpoints.h"
-#include "algorithm.h"
-#include "command.h"
+#include <helper/list.h>
 
 struct reg;
 struct trace;
 struct command_context;
-
-
-/**
- * Cast a member of a structure out to the containing structure.
- * @param ptr The pointer to the member.
- * @param type The type of the container struct this is embedded in.
- * @param member The name of the member within the struct.
- *
- * This is a mechanism which is used throughout the Linux kernel.
- */
-#define container_of(ptr, type, member) ({                     \
-       const typeof( ((type *)0)->member ) *__mptr = (ptr);    \
-       (type *)( (char *)__mptr - offsetof(type,member) );})
+struct breakpoint;
+struct watchpoint;
+struct mem_param;
+struct reg_param;
+struct target_list;
+struct gdb_fileio_info;
 
 /*
  * TARGET_UNKNOWN = 0: we don't know anything about the target yet
@@ -62,9 +56,7 @@ struct command_context;
  * also see: target_state_name();
  */
 
-
-enum target_state
-{
+enum target_state {
        TARGET_UNKNOWN = 0,
        TARGET_RUNNING = 1,
        TARGET_HALTED = 2,
@@ -72,105 +64,183 @@ enum target_state
        TARGET_DEBUG_RUNNING = 4,
 };
 
-extern const Jim_Nvp nvp_target_state[];
-
 enum nvp_assert {
        NVP_DEASSERT,
        NVP_ASSERT,
 };
 
-extern const Jim_Nvp nvp_assert[];
-
-enum target_reset_mode
-{
+enum target_reset_mode {
        RESET_UNKNOWN = 0,
        RESET_RUN = 1,          /* reset and let target run */
        RESET_HALT = 2,         /* reset and halt target out of reset */
        RESET_INIT = 3,         /* reset and halt target out of reset, then run init script */
 };
 
-extern const Jim_Nvp nvp_reset_mode[];
-
-enum target_debug_reason
-{
+enum target_debug_reason {
        DBG_REASON_DBGRQ = 0,
        DBG_REASON_BREAKPOINT = 1,
        DBG_REASON_WATCHPOINT = 2,
        DBG_REASON_WPTANDBKPT = 3,
        DBG_REASON_SINGLESTEP = 4,
        DBG_REASON_NOTHALTED = 5,
-       DBG_REASON_UNDEFINED = 6
+       DBG_REASON_EXIT = 6,
+       DBG_REASON_UNDEFINED = 7,
 };
 
-extern const Jim_Nvp nvp_target_debug_reason[];
-
-enum target_endianess
-{
+enum target_endianness {
        TARGET_ENDIAN_UNKNOWN = 0,
        TARGET_BIG_ENDIAN = 1, TARGET_LITTLE_ENDIAN = 2
 };
 
-extern const Jim_Nvp nvp_target_endian[];
-
-struct working_area
-{
-       uint32_t address;
+struct working_area {
+       target_addr_t address;
        uint32_t size;
-       int free;
+       bool free;
        uint8_t *backup;
        struct working_area **user;
        struct working_area *next;
 };
 
-// target_type.h contains the full definitionof struct targe_type
-struct target
-{
-       struct target_type *type;                               /* target type definition (name, access functions) */
-       const char *cmd_name;                           /* tcl Name of target */
+struct gdb_service {
+       struct target *target;
+       /*  field for smp display  */
+       /*  element 0 coreid currently displayed ( 1 till n) */
+       /*  element 1 coreid to be displayed at next resume 1 till n 0 means resume
+        *  all cores core displayed  */
+       int32_t core[2];
+};
+
+/* target back off timer */
+struct backoff_timer {
+       int times;
+       int count;
+};
+
+/* split target registers into multiple class */
+enum target_register_class {
+       REG_CLASS_ALL,
+       REG_CLASS_GENERAL,
+};
+
+/* target_type.h contains the full definition of struct target_type */
+struct target {
+       struct target_type *type;                       /* target type definition (name, access functions) */
+       char *cmd_name;                         /* tcl Name of target */
        int target_number;                                      /* DO NOT USE!  field to be removed in 2010 */
-       struct jtag_tap *tap;                                   /* where on the jtag chain is this */
-       const char *variant;                            /* what varient of this chip is it? */
+       struct jtag_tap *tap;                           /* where on the jtag chain is this */
+       int32_t coreid;                                         /* which device on the TAP? */
+
+       /** Should we defer examine to later */
+       bool defer_examine;
+
+       /**
+        * Indicates whether this target has been examined.
+        *
+        * Do @b not access this field directly, use target_was_examined()
+        * or target_set_examined().
+        */
+       bool examined;
+
+       /**
+        * true if the  target is currently running a downloaded
+        * "algorithm" instead of arbitrary user code. OpenOCD code
+        * invoking algorithms is trusted to maintain correctness of
+        * any cached state (e.g. for flash status), which arbitrary
+        * code will have no reason to know about.
+        */
+       bool running_alg;
+
        struct target_event_action *event_action;
 
        int reset_halt;                                         /* attempt resetting the CPU into the halted mode? */
-       uint32_t working_area;                                  /* working area (initialized RAM). Evaluated
+       target_addr_t working_area;                             /* working area (initialised RAM). Evaluated
                                                                                 * upon first allocation from virtual/physical address. */
        bool working_area_virt_spec;            /* virtual address specified? */
-       uint32_t working_area_virt;                     /* virtual address */
-       bool working_area_phys_spec;            /* virtual address specified? */
-       uint32_t working_area_phys;                     /* physical address */
+       target_addr_t working_area_virt;                        /* virtual address */
+       bool working_area_phys_spec;            /* physical address specified? */
+       target_addr_t working_area_phys;                        /* physical address */
        uint32_t working_area_size;                     /* size in bytes */
-       uint32_t backup_working_area;                   /* whether the content of the working area has to be preserved */
+       uint32_t backup_working_area;           /* whether the content of the working area has to be preserved */
        struct working_area *working_areas;/* list of allocated working areas */
        enum target_debug_reason debug_reason;/* reason why the target entered debug state */
-       enum target_endianess endianness;       /* target endianess */
-       // also see: target_state_name()
+       enum target_endianness endianness;      /* target endianness */
+       /* also see: target_state_name() */
        enum target_state state;                        /* the current backend-state (running, halted, ...) */
        struct reg_cache *reg_cache;            /* the first register cache of the target (core regs) */
-       struct breakpoint *breakpoints; /* list of breakpoints */
-       struct watchpoint *watchpoints; /* list of watchpoints */
+       struct breakpoint *breakpoints;         /* list of breakpoints */
+       struct watchpoint *watchpoints;         /* list of watchpoints */
        struct trace *trace_info;                       /* generic trace information */
-       struct debug_msg_receiver *dbgmsg;/* list of debug message receivers */
-       uint32_t dbg_msg_enabled;                               /* debug message status */
+       struct debug_msg_receiver *dbgmsg;      /* list of debug message receivers */
+       uint32_t dbg_msg_enabled;                       /* debug message status */
        void *arch_info;                                        /* architecture specific information */
+       void *private_config;                           /* pointer to target specific config data (for jim_configure hook) */
        struct target *next;                            /* next target in list */
 
-       int display;                                            /* display async info in telnet session. Do not display
+       bool verbose_halt_msg;                          /* display async info in telnet session. Do not display
                                                                                 * lots of halted/resumed info when stepping in debugger. */
        bool halt_issued;                                       /* did we transition to halted state? */
-       long long halt_issued_time;                     /* Note time when halt was issued */
+       int64_t halt_issued_time;                       /* Note time when halt was issued */
+
+                                                                               /* ARM v7/v8 targets with ADIv5 interface */
+       bool dbgbase_set;                                       /* By default the debug base is not set */
+       uint32_t dbgbase;                                       /* Really a Cortex-A specific option, but there is no
+                                                                                * system in place to support target specific options
+                                                                                * currently. */
+       bool has_dap;                                           /* set to true if target has ADIv5 support */
+       bool dap_configured;                            /* set to true if ADIv5 DAP is configured */
+       bool tap_configured;                            /* set to true if JTAG tap has been configured
+                                                                                * through -chain-position */
+
+       struct rtos *rtos;                                      /* Instance of Real Time Operating System support */
+       bool rtos_auto_detect;                          /* A flag that indicates that the RTOS has been specified as "auto"
+                                                                                * and must be detected when symbols are offered */
+       struct backoff_timer backoff;
+       int smp;                                                        /* add some target attributes for smp support */
+       struct target_list *head;
+       /* the gdb service is there in case of smp, we have only one gdb server
+        * for all smp target
+        * the target attached to the gdb is changing dynamically by changing
+        * gdb_service->target pointer */
+       struct gdb_service *gdb_service;
+
+       /* file-I/O information for host to do syscall */
+       struct gdb_fileio_info *fileio_info;
+
+       char *gdb_port_override;                        /* target-specific override for gdb_port */
+
+       /* The semihosting information, extracted from the target. */
+       struct semihosting *semihosting;
+};
+
+struct target_list {
+       struct target *target;
+       struct target_list *next;
+};
+
+struct gdb_fileio_info {
+       char *identifier;
+       uint64_t param_1;
+       uint64_t param_2;
+       uint64_t param_3;
+       uint64_t param_4;
 };
 
-enum target_event
+/** Returns a description of the endianness for the specified target. */
+static inline const char *target_endianness(struct target *target)
 {
-       /* LD historical names
-        * - Prior to the great TCL change
-        * - June/July/Aug 2008
-        * - Duane Ellis */
-       TARGET_EVENT_OLD_gdb_program_config,
-       TARGET_EVENT_OLD_pre_reset,
-       TARGET_EVENT_OLD_post_reset,
-       TARGET_EVENT_OLD_pre_resume,
+       return (target->endianness == TARGET_ENDIAN_UNKNOWN) ? "unknown" :
+                       (target->endianness == TARGET_BIG_ENDIAN) ? "big endian" : "little endian";
+}
+
+/** Returns the instance-specific name of the specified target. */
+static inline const char *target_name(struct target *target)
+{
+       return target->cmd_name;
+}
+
+const char *debug_reason_name(struct target *t);
+
+enum target_event {
 
        /* allow GDB to do stuff before others handle the halted event,
         * this is in lieu of defining ordering of invocation of events,
@@ -192,13 +262,10 @@ enum target_event
 
        TARGET_EVENT_RESET_START,
        TARGET_EVENT_RESET_ASSERT_PRE,
+       TARGET_EVENT_RESET_ASSERT,      /* C code uses this instead of SRST */
        TARGET_EVENT_RESET_ASSERT_POST,
        TARGET_EVENT_RESET_DEASSERT_PRE,
        TARGET_EVENT_RESET_DEASSERT_POST,
-       TARGET_EVENT_RESET_HALT_PRE,
-       TARGET_EVENT_RESET_HALT_POST,
-       TARGET_EVENT_RESET_WAIT_PRE,
-       TARGET_EVENT_RESET_WAIT_POST,
        TARGET_EVENT_RESET_INIT,
        TARGET_EVENT_RESET_END,
 
@@ -215,92 +282,156 @@ enum target_event
        TARGET_EVENT_GDB_FLASH_ERASE_END,
        TARGET_EVENT_GDB_FLASH_WRITE_START,
        TARGET_EVENT_GDB_FLASH_WRITE_END,
+
+       TARGET_EVENT_TRACE_CONFIG,
 };
 
 struct target_event_action {
        enum target_event event;
-       Jim_Obj *body;
+       struct Jim_Interp *interp;
+       struct Jim_Obj *body;
        int has_percent;
        struct target_event_action *next;
- };
+};
 
-struct target_event_callback
-{
+bool target_has_event_action(struct target *target, enum target_event event);
+
+struct target_event_callback {
        int (*callback)(struct target *target, enum target_event event, void *priv);
        void *priv;
        struct target_event_callback *next;
 };
 
-struct target_timer_callback
-{
+struct target_reset_callback {
+       struct list_head list;
+       void *priv;
+       int (*callback)(struct target *target, enum target_reset_mode reset_mode, void *priv);
+};
+
+struct target_trace_callback {
+       struct list_head list;
+       void *priv;
+       int (*callback)(struct target *target, size_t len, uint8_t *data, void *priv);
+};
+
+enum target_timer_type {
+       TARGET_TIMER_TYPE_ONESHOT,
+       TARGET_TIMER_TYPE_PERIODIC
+};
+
+struct target_timer_callback {
        int (*callback)(void *priv);
-       int time_ms;
-       int periodic;
+       unsigned int time_ms;
+       enum target_timer_type type;
+       bool removed;
        struct timeval when;
        void *priv;
        struct target_timer_callback *next;
 };
 
+struct target_memory_check_block {
+       target_addr_t address;
+       uint32_t size;
+       uint32_t result;
+};
+
 int target_register_commands(struct command_context *cmd_ctx);
-int target_register_user_commands(struct command_context *cmd_ctx);
-int target_init(struct command_context *cmd_ctx);
 int target_examine(void);
-int handle_target(void *priv);
-int target_process_reset(struct command_context *cmd_ctx,
-               enum target_reset_mode reset_mode);
 
 int target_register_event_callback(
                int (*callback)(struct target *target,
-                               enum target_event event, void *priv),
+               enum target_event event, void *priv),
                void *priv);
 int target_unregister_event_callback(
                int (*callback)(struct target *target,
-                               enum target_event event, void *priv),
+               enum target_event event, void *priv),
+               void *priv);
+
+int target_register_reset_callback(
+               int (*callback)(struct target *target,
+               enum target_reset_mode reset_mode, void *priv),
                void *priv);
+int target_unregister_reset_callback(
+               int (*callback)(struct target *target,
+               enum target_reset_mode reset_mode, void *priv),
+               void *priv);
+
+int target_register_trace_callback(
+               int (*callback)(struct target *target,
+               size_t len, uint8_t *data, void *priv),
+               void *priv);
+int target_unregister_trace_callback(
+               int (*callback)(struct target *target,
+               size_t len, uint8_t *data, void *priv),
+               void *priv);
+
+/* Poll the status of the target, detect any error conditions and report them.
+ *
+ * Also note that this fn will clear such error conditions, so a subsequent
+ * invocation will then succeed.
+ *
+ * These error conditions can be "sticky" error conditions. E.g. writing
+ * to memory could be implemented as an open loop and if memory writes
+ * fails, then a note is made of it, the error is sticky, but the memory
+ * write loop still runs to completion. This improves performance in the
+ * normal case as there is no need to verify that every single write succeed,
+ * yet it is possible to detect error conditions.
+ */
 int target_poll(struct target *target);
-int target_resume(struct target *target, int current, uint32_t address,
+int target_resume(struct target *target, int current, target_addr_t address,
                int handle_breakpoints, int debug_execution);
 int target_halt(struct target *target);
 int target_call_event_callbacks(struct target *target, enum target_event event);
+int target_call_reset_callbacks(struct target *target, enum target_reset_mode reset_mode);
+int target_call_trace_callbacks(struct target *target, size_t len, uint8_t *data);
 
 /**
  * The period is very approximate, the callback can happen much more often
  * or much more rarely than specified
  */
 int target_register_timer_callback(int (*callback)(void *priv),
-               int time_ms, int periodic, void *priv);
+               unsigned int time_ms, enum target_timer_type type, void *priv);
 int target_unregister_timer_callback(int (*callback)(void *priv), void *priv);
-
 int target_call_timer_callbacks(void);
 /**
  * Invoke this to ensure that e.g. polling timer callbacks happen before
- * a syncrhonous command completes.
+ * a synchronous command completes.
  */
 int target_call_timer_callbacks_now(void);
 
-struct target* get_current_target(struct command_context *cmd_ctx);
+struct target *get_target_by_num(int num);
+struct target *get_current_target(struct command_context *cmd_ctx);
+struct target *get_current_target_or_null(struct command_context *cmd_ctx);
 struct target *get_target(const char *id);
 
 /**
- * Get the target name.
+ * Get the target type name.
  *
  * This routine is a wrapper for the target->type->name field.
+ * Note that this is not an instance-specific name for his target.
  */
-const char *target_get_name(struct target *target);
+const char *target_type_name(struct target *target);
 
 /**
- * Examine the specified @a target.
+ * Examine the specified @a target, letting it perform any
+ * Initialisation that requires JTAG access.
  *
  * This routine is a wrapper for target->type->examine.
  */
 int target_examine_one(struct target *target);
-/// @returns @c true if the target has been examined.
-bool target_was_examined(struct target *target);
-/// Sets the @c examined flag for the given target.
-void target_set_examined(struct target *target);
-/// Reset the @c examined flag for the given target.
-void target_reset_examined(struct target *target);
 
+/** @returns @c true if target_set_examined() has been called. */
+static inline bool target_was_examined(struct target *target)
+{
+       return target->examined;
+}
+
+/** Sets the @c examined flag for the given target. */
+/** Use in target->type->examine() after one-time setup is done. */
+static inline void target_set_examined(struct target *target)
+{
+       target->examined = true;
+}
 
 /**
  * Add the @a breakpoint for @a target.
@@ -310,10 +441,25 @@ void target_reset_examined(struct target *target);
 int target_add_breakpoint(struct target *target,
                struct breakpoint *breakpoint);
 /**
+ * Add the @a ContextID breakpoint  for @a target.
+ *
+ * This routine is a wrapper for target->type->add_context_breakpoint.
+ */
+int target_add_context_breakpoint(struct target *target,
+               struct breakpoint *breakpoint);
+/**
+ * Add the @a ContextID & IVA breakpoint  for @a target.
+ *
+ * This routine is a wrapper for target->type->add_hybrid_breakpoint.
+ */
+int target_add_hybrid_breakpoint(struct target *target,
+               struct breakpoint *breakpoint);
+/**
  * Remove the @a breakpoint for @a target.
  *
  * This routine is a wrapper for target->type->remove_breakpoint.
  */
+
 int target_remove_breakpoint(struct target *target,
                struct breakpoint *breakpoint);
 /**
@@ -332,12 +478,35 @@ int target_remove_watchpoint(struct target *target,
                struct watchpoint *watchpoint);
 
 /**
+ * Find out the just hit @a watchpoint for @a target.
+ *
+ * This routine is a wrapper for target->type->hit_watchpoint.
+ */
+int target_hit_watchpoint(struct target *target,
+               struct watchpoint **watchpoint);
+
+/**
+ * Obtain the architecture for GDB.
+ *
+ * This routine is a wrapper for target->type->get_gdb_arch.
+ */
+const char *target_get_gdb_arch(struct target *target);
+
+/**
  * Obtain the registers for GDB.
  *
  * This routine is a wrapper for target->type->get_gdb_reg_list.
  */
 int target_get_gdb_reg_list(struct target *target,
-               struct reg **reg_list[], int *reg_list_size);
+               struct reg **reg_list[], int *reg_list_size,
+               enum target_register_class reg_class);
+
+/**
+ * Check if @a target allows GDB connections.
+ *
+ * Some target do not implement the necessary code required by GDB.
+ */
+bool target_supports_gdb_connection(struct target *target);
 
 /**
  * Step the target.
@@ -345,7 +514,7 @@ int target_get_gdb_reg_list(struct target *target,
  * This routine is a wrapper for target->type->step.
  */
 int target_step(struct target *target,
-               int current, uint32_t address, int handle_breakpoints);
+               int current, target_addr_t address, int handle_breakpoints);
 /**
  * Run an algorithm on the @a target given.
  *
@@ -358,31 +527,70 @@ int target_run_algorithm(struct target *target,
                int timeout_ms, void *arch_info);
 
 /**
+ * Starts an algorithm in the background on the @a target given.
+ *
+ * This routine is a wrapper for target->type->start_algorithm.
+ */
+int target_start_algorithm(struct target *target,
+               int num_mem_params, struct mem_param *mem_params,
+               int num_reg_params, struct reg_param *reg_params,
+               uint32_t entry_point, uint32_t exit_point,
+               void *arch_info);
+
+/**
+ * Wait for an algorithm on the @a target given.
+ *
+ * This routine is a wrapper for target->type->wait_algorithm.
+ */
+int target_wait_algorithm(struct target *target,
+               int num_mem_params, struct mem_param *mem_params,
+               int num_reg_params, struct reg_param *reg_params,
+               uint32_t exit_point, int timeout_ms,
+               void *arch_info);
+
+/**
+ * This routine is a wrapper for asynchronous algorithms.
+ *
+ */
+int target_run_flash_async_algorithm(struct target *target,
+               const uint8_t *buffer, uint32_t count, int block_size,
+               int num_mem_params, struct mem_param *mem_params,
+               int num_reg_params, struct reg_param *reg_params,
+               uint32_t buffer_start, uint32_t buffer_size,
+               uint32_t entry_point, uint32_t exit_point,
+               void *arch_info);
+
+/**
  * Read @a count items of @a size bytes from the memory of @a target at
  * the @a address given.
  *
  * This routine is a wrapper for target->type->read_memory.
  */
 int target_read_memory(struct target *target,
-               uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer);
+               target_addr_t address, uint32_t size, uint32_t count, uint8_t *buffer);
+int target_read_phys_memory(struct target *target,
+               target_addr_t address, uint32_t size, uint32_t count, uint8_t *buffer);
 /**
  * Write @a count items of @a size bytes to the memory of @a target at
- * the @a address given.
+ * the @a address given. @a address must be aligned to @a size
+ * in target memory.
+ *
+ * The endianness is the same in the host and target memory for this
+ * function.
+ *
+ * \todo TODO:
+ * Really @a buffer should have been defined as "const void *" and
+ * @a buffer should have been aligned to @a size in the host memory.
+ *
+ * This is not enforced via e.g. assert's today and e.g. the
+ * target_write_buffer fn breaks this assumption.
  *
  * This routine is wrapper for target->type->write_memory.
  */
 int target_write_memory(struct target *target,
-               uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer);
-
-/**
- * Write @a count items of 4 bytes to the memory of @a target at
- * the @a address given.  Because it operates only on whole words,
- * this should be faster than target_write_memory().
- *
- * This routine is wrapper for target->type->bulk_write_memory.
- */
-int target_bulk_write_memory(struct target *target,
-               uint32_t address, uint32_t count, uint8_t *buffer);
+               target_addr_t address, uint32_t size, uint32_t count, const uint8_t *buffer);
+int target_write_phys_memory(struct target *target,
+               target_addr_t address, uint32_t size, uint32_t count, const uint8_t *buffer);
 
 /*
  * Write to target memory using the virtual address.
@@ -409,17 +617,40 @@ int target_bulk_write_memory(struct target *target,
  * peripheral registers which do not support byte operations.
  */
 int target_write_buffer(struct target *target,
-               uint32_t address, uint32_t size, uint8_t *buffer);
+               target_addr_t address, uint32_t size, const uint8_t *buffer);
 int target_read_buffer(struct target *target,
-               uint32_t address, uint32_t size, uint8_t *buffer);
+               target_addr_t address, uint32_t size, uint8_t *buffer);
 int target_checksum_memory(struct target *target,
-               uint32_t address, uint32_t size, uint32_t* crc);
+               target_addr_t address, uint32_t size, uint32_t *crc);
 int target_blank_check_memory(struct target *target,
-               uint32_t address, uint32_t size, uint32_t* blank);
+               struct target_memory_check_block *blocks, int num_blocks,
+               uint8_t erased_value);
 int target_wait_state(struct target *target, enum target_state state, int ms);
 
+/**
+ * Obtain file-I/O information from target for GDB to do syscall.
+ *
+ * This routine is a wrapper for target->type->get_gdb_fileio_info.
+ */
+int target_get_gdb_fileio_info(struct target *target, struct gdb_fileio_info *fileio_info);
+
+/**
+ * Pass GDB file-I/O response to target after finishing host syscall.
+ *
+ * This routine is a wrapper for target->type->gdb_fileio_end.
+ */
+int target_gdb_fileio_end(struct target *target, int retcode, int fileio_errno, bool ctrl_c);
+
+
+
 /** Return the *name* of this targets current state */
-const char *target_state_name( struct target *target );
+const char *target_state_name(struct target *target);
+
+/** Return the *name* of a target event enumeration value */
+const char *target_event_name(enum target_event event);
+
+/** Return the *name* of a target reset reason enumeration value */
+const char *target_reset_mode_name(enum target_reset_mode reset_mode);
 
 /* DANGER!!!!!
  *
@@ -434,36 +665,59 @@ const char *target_state_name( struct target *target );
  */
 int target_alloc_working_area(struct target *target,
                uint32_t size, struct working_area **area);
+/* Same as target_alloc_working_area, except that no error is logged
+ * when ERROR_TARGET_RESOURCE_NOT_AVAILABLE is returned.
+ *
+ * This allows the calling code to *try* to allocate target memory
+ * and have a fallback to another behaviour(slower?).
+ */
+int target_alloc_working_area_try(struct target *target,
+               uint32_t size, struct working_area **area);
 int target_free_working_area(struct target *target, struct working_area *area);
-int target_free_working_area_restore(struct target *target,
-               struct working_area *area, int restore);
 void target_free_all_working_areas(struct target *target);
-void target_free_all_working_areas_restore(struct target *target, int restore);
+uint32_t target_get_working_area_avail(struct target *target);
 
-extern struct target *all_targets;
+/**
+ * Free all the resources allocated by targets and the target layer
+ */
+void target_quit(void);
 
-extern struct target_event_callback *target_event_callbacks;
-extern struct target_timer_callback *target_timer_callbacks;
+extern struct target *all_targets;
 
+uint64_t target_buffer_get_u64(struct target *target, const uint8_t *buffer);
 uint32_t target_buffer_get_u32(struct target *target, const uint8_t *buffer);
+uint32_t target_buffer_get_u24(struct target *target, const uint8_t *buffer);
 uint16_t target_buffer_get_u16(struct target *target, const uint8_t *buffer);
-uint8_t  target_buffer_get_u8 (struct target *target, const uint8_t *buffer);
+void target_buffer_set_u64(struct target *target, uint8_t *buffer, uint64_t value);
 void target_buffer_set_u32(struct target *target, uint8_t *buffer, uint32_t value);
+void target_buffer_set_u24(struct target *target, uint8_t *buffer, uint32_t value);
 void target_buffer_set_u16(struct target *target, uint8_t *buffer, uint16_t value);
-void target_buffer_set_u8 (struct target *target, uint8_t *buffer, uint8_t  value);
 
-int target_read_u32(struct target *target, uint32_t address, uint32_t *value);
-int target_read_u16(struct target *target, uint32_t address, uint16_t *value);
-int target_read_u8(struct target *target, uint32_t address, uint8_t *value);
-int target_write_u32(struct target *target, uint32_t address, uint32_t value);
-int target_write_u16(struct target *target, uint32_t address, uint16_t value);
-int target_write_u8(struct target *target, uint32_t address, uint8_t value);
+void target_buffer_get_u64_array(struct target *target, const uint8_t *buffer, uint32_t count, uint64_t *dstbuf);
+void target_buffer_get_u32_array(struct target *target, const uint8_t *buffer, uint32_t count, uint32_t *dstbuf);
+void target_buffer_get_u16_array(struct target *target, const uint8_t *buffer, uint32_t count, uint16_t *dstbuf);
+void target_buffer_set_u64_array(struct target *target, uint8_t *buffer, uint32_t count, const uint64_t *srcbuf);
+void target_buffer_set_u32_array(struct target *target, uint8_t *buffer, uint32_t count, const uint32_t *srcbuf);
+void target_buffer_set_u16_array(struct target *target, uint8_t *buffer, uint32_t count, const uint16_t *srcbuf);
+
+int target_read_u64(struct target *target, target_addr_t address, uint64_t *value);
+int target_read_u32(struct target *target, target_addr_t address, uint32_t *value);
+int target_read_u16(struct target *target, target_addr_t address, uint16_t *value);
+int target_read_u8(struct target *target, target_addr_t address, uint8_t *value);
+int target_write_u64(struct target *target, target_addr_t address, uint64_t value);
+int target_write_u32(struct target *target, target_addr_t address, uint32_t value);
+int target_write_u16(struct target *target, target_addr_t address, uint16_t value);
+int target_write_u8(struct target *target, target_addr_t address, uint8_t value);
+
+int target_write_phys_u64(struct target *target, target_addr_t address, uint64_t value);
+int target_write_phys_u32(struct target *target, target_addr_t address, uint32_t value);
+int target_write_phys_u16(struct target *target, target_addr_t address, uint16_t value);
+int target_write_phys_u8(struct target *target, target_addr_t address, uint8_t value);
 
 /* Issues USER() statements with target state information */
 int target_arch_state(struct target *target);
 
 void target_handle_event(struct target *t, enum target_event e);
-void target_all_handle_event(enum target_event e);
 
 #define ERROR_TARGET_INVALID   (-300)
 #define ERROR_TARGET_INIT_FAILED (-301)
@@ -476,9 +730,8 @@ void target_all_handle_event(enum target_event e);
 #define ERROR_TARGET_TRANSLATION_FAULT (-309)
 #define ERROR_TARGET_NOT_RUNNING (-310)
 #define ERROR_TARGET_NOT_EXAMINED (-311)
+#define ERROR_TARGET_DUPLICATE_BREAKPOINT (-312)
 
-extern const Jim_Nvp nvp_error_target[];
-
-const char *target_strerror_safe(int err);
+extern bool get_target_reset_nag(void);
 
-#endif /* TARGET_H */
+#endif /* OPENOCD_TARGET_TARGET_H */