#ifndef TARGET_H
#define TARGET_H
-#include <stddef.h>
-
-#include "breakpoints.h"
-#include "algorithm.h"
-#include "command.h"
+#include "types.h"
+#include "jim.h"
struct reg;
struct trace;
-struct command_context_s;
+struct command_context;
+struct breakpoint;
+struct watchpoint;
+struct mem_param;
+struct reg_param;
-/**
- * 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) );})
-
/*
* TARGET_UNKNOWN = 0: we don't know anything about the target yet
* TARGET_RUNNING = 1: the target is executing user code
const 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? */
+ const char *variant; /* what variant of this chip is it? */
+
+ /**
+ * Indicates whether this target has been examined.
+ *
+ * Do @b not access this field directly, use target_was_examined()
+ * or target_set_examined().
+ */
+ bool examined;
+
struct target_event_action *event_action;
int reset_halt; /* attempt resetting the CPU into the halted mode? */
struct target_event_action {
enum target_event event;
- Jim_Obj *body;
+ struct Jim_Obj *body;
int has_percent;
struct target_event_action *next;
};
struct target_timer_callback *next;
};
-int target_register_commands(struct command_context_s *cmd_ctx);
-int target_register_user_commands(struct command_context_s *cmd_ctx);
-int target_init(struct command_context_s *cmd_ctx);
+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_s *cmd_ctx,
+int target_process_reset(struct command_context *cmd_ctx,
enum target_reset_mode reset_mode);
int target_register_event_callback(
*/
int target_call_timer_callbacks_now(void);
-struct target* get_current_target(struct command_context_s *cmd_ctx);
+struct target* get_current_target(struct command_context *cmd_ctx);
struct target *get_target(const char *id);
/**
const char *target_get_name(struct target *target);
/**
- * Examine the specified @a target.
+ * Examine the specified @a target, letting it perform any
+ * initialization 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.