arm_adi_v5: mem_ap_write error propagation

[fw/openocd] / src / target / target.h

diff --git a/src/target/target.h b/src/target/target.h
index 4151c228b6b0479b9cdb1ea0c835803bac38bbd1..4a48e5aad6c08c892d16e57d9d3d3fde1b74e83c 100644 (file)
--- a/src/target/target.h
+++ b/src/target/target.h
@@ -2,7 +2,7 @@
  *   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                                  *
@@ -117,6 +117,14 @@ struct target
         */
        bool examined;
 
+       /** true iff the  target is currently running a downloaded
+        *  "algorithm" instetad 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? */
@@ -239,11 +247,7 @@ struct target_timer_callback
 };
 
 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 target_process_reset(struct command_context *cmd_ctx,
-               enum target_reset_mode reset_mode);
 
 int target_register_event_callback(
                int (*callback)(struct target *target,
@@ -265,7 +269,6 @@ int target_call_event_callbacks(struct target *target, enum target_event event);
  */
 int target_register_timer_callback(int (*callback)(void *priv),
                int time_ms, int periodic, void *priv);
-int target_unregister_timer_callback(int (*callback)(void *priv), void *priv);
 
 int target_call_timer_callbacks(void);
 /**
@@ -371,7 +374,18 @@ int target_read_memory(struct target *target,
                uint32_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.
  */
@@ -438,23 +452,23 @@ 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 behavior(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);
 
 extern struct target *all_targets;
 
-extern struct target_event_callback *target_event_callbacks;
-extern struct target_timer_callback *target_timer_callbacks;
-
 uint32_t target_buffer_get_u32(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_u32(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);
@@ -467,7 +481,6 @@ int target_write_u8(struct target *target, uint32_t address, uint8_t value);
 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)
@@ -481,6 +494,6 @@ void target_all_handle_event(enum target_event e);
 #define ERROR_TARGET_NOT_RUNNING (-310)
 #define ERROR_TARGET_NOT_EXAMINED (-311)
 
-const char *target_strerror_safe(int err);
+extern bool get_target_reset_nag(void);
 
 #endif /* TARGET_H */