#ifndef JTAG_H
#define JTAG_H
-#include "binarybuffer.h"
-#include "log.h"
-
+#include <helper/binarybuffer.h>
+#include <helper/log.h>
#ifdef _DEBUG_JTAG_IO_
#define DEBUG_JTAG_IO(expr ...) \
#define DEBUG_JTAG_IOZ 64
#endif
-/*-----<Macros>--------------------------------------------------*/
-
-/**
- * When given an array, compute its DIMension; in other words, the
- * number of elements in the array
- */
-#define DIM(x) (sizeof(x)/sizeof((x)[0]))
-
-/** Calculate the number of bytes required to hold @a n TAP scan bits */
-#define TAP_SCAN_BYTES(n) CEIL(n, 8)
-
/*-----</Macros>-------------------------------------------------*/
/**
*
* The allocated, modified, and intmp fields are internal work space.
*/
-typedef struct scan_field_s
-{
+struct scan_field {
/// A pointer to the tap structure to which this field refers.
- jtag_tap_t* tap;
+ struct jtag_tap* tap;
/// The number of bits this field specifies (up to 32)
int num_bits;
int modified;
/// temporary storage for performing value checks synchronously
uint8_t intmp[4];
-} scan_field_t;
-
-typedef struct jtag_tap_event_action_s jtag_tap_event_action_t;
+};
-/* this is really: typedef jtag_tap_t */
-/* But - the typedef is done in "types.h" */
-/* due to "forward declaration reasons" */
-struct jtag_tap_s
-{
+struct jtag_tap {
const char* chip;
const char* tapname;
const char* dotted_name;
/// Number of expected identification codes
uint8_t expected_ids_cnt;
+ /// Flag saying whether to ignore version field in expected_ids[]
+ bool ignore_version;
+
/// current instruction
uint8_t* cur_instr;
/// Bypass register selected
int bypass;
- jtag_tap_event_action_t *event_action;
+ struct jtag_tap_event_action *event_action;
- jtag_tap_t* next_tap;
+ struct jtag_tap* next_tap;
};
-void jtag_tap_init(jtag_tap_t *tap);
-void jtag_tap_free(jtag_tap_t *tap);
+void jtag_tap_init(struct jtag_tap *tap);
+void jtag_tap_free(struct jtag_tap *tap);
-jtag_tap_t* jtag_all_taps(void);
-const char *jtag_tap_name(const jtag_tap_t *tap);
-jtag_tap_t* jtag_tap_by_string(const char* dotted_name);
-jtag_tap_t* jtag_tap_by_jim_obj(Jim_Interp* interp, Jim_Obj* obj);
-jtag_tap_t* jtag_tap_next_enabled(jtag_tap_t* p);
+struct jtag_tap* jtag_all_taps(void);
+const char *jtag_tap_name(const struct jtag_tap *tap);
+struct jtag_tap* jtag_tap_by_string(const char* dotted_name);
+struct jtag_tap* jtag_tap_by_jim_obj(Jim_Interp* interp, Jim_Obj* obj);
+struct jtag_tap* jtag_tap_next_enabled(struct jtag_tap* p);
unsigned jtag_tap_count_enabled(void);
unsigned jtag_tap_count(void);
JTAG_TAP_EVENT_DISABLE,
};
-struct jtag_tap_event_action_s
+struct jtag_tap_event_action
{
- enum jtag_event event;
- Jim_Obj* body;
- jtag_tap_event_action_t* next;
+ /// The event for which this action will be triggered.
+ enum jtag_event event;
+ /// The interpreter to use for evaluating the @c body.
+ Jim_Interp *interp;
+ /// Contains a script to 'eval' when the @c event is triggered.
+ Jim_Obj *body;
+ // next action in linked list
+ struct jtag_tap_event_action *next;
};
/**
* Initialize interface upon startup. Return a successful no-op upon
* subsequent invocations.
*/
-int jtag_interface_init(struct command_context_s* cmd_ctx);
+int jtag_interface_init(struct command_context* cmd_ctx);
/// Shutdown the JTAG interface upon program exit.
int jtag_interface_quit(void);
* Initialize JTAG chain using only a RESET reset. If init fails,
* try reset + init.
*/
-int jtag_init(struct command_context_s* cmd_ctx);
+int jtag_init(struct command_context* cmd_ctx);
/// reset, then initialize JTAG chain
-int jtag_init_reset(struct command_context_s* cmd_ctx);
-int jtag_register_commands(struct command_context_s* cmd_ctx);
-int jtag_init_inner(struct command_context_s *cmd_ctx);
+int jtag_init_reset(struct command_context* cmd_ctx);
+int jtag_register_commands(struct command_context* cmd_ctx);
+int jtag_init_inner(struct command_context *cmd_ctx);
/**
* @file
*
*/
void jtag_add_ir_scan(int num_fields,
- scan_field_t* fields, tap_state_t endstate);
+ struct scan_field* fields, tap_state_t endstate);
/**
* The same as jtag_add_ir_scan except no verification is performed out
* the output values.
*/
void jtag_add_ir_scan_noverify(int num_fields,
- const scan_field_t *fields, tap_state_t state);
+ const struct scan_field *fields, tap_state_t state);
/**
* Duplicate the scan fields passed into the function into an IR SCAN
* command. This function assumes that the caller handles extra fields
* for bypassed TAPs.
*/
void jtag_add_plain_ir_scan(int num_fields,
- const scan_field_t* fields, tap_state_t endstate);
+ const struct scan_field* fields, tap_state_t endstate);
/**
* allocation method is used, for the synchronous case the temporary 32
* bits come from the input field itself.
*/
-void jtag_alloc_in_value32(scan_field_t *field);
+void jtag_alloc_in_value32(struct scan_field *field);
/**
* Generate a DR SCAN using the fields passed to the function.
* 1-bit field. The bypass status of TAPs is set by jtag_add_ir_scan().
*/
void jtag_add_dr_scan(int num_fields,
- const scan_field_t* fields, tap_state_t endstate);
+ const struct scan_field* fields, tap_state_t endstate);
/// A version of jtag_add_dr_scan() that uses the check_value/mask fields
void jtag_add_dr_scan_check(int num_fields,
- scan_field_t* fields, tap_state_t endstate);
+ struct scan_field* fields, tap_state_t endstate);
/**
* Duplicate the scan fields passed into the function into a DR SCAN
* command. Unlike jtag_add_dr_scan(), this function assumes that the
* caller handles extra fields for bypassed TAPs.
*/
void jtag_add_plain_dr_scan(int num_fields,
- const scan_field_t* fields, tap_state_t endstate);
+ const struct scan_field* fields, tap_state_t endstate);
/**
* Defines the type of data passed to the jtag_callback_t interface.
void jtag_add_callback(jtag_callback1_t, jtag_callback_data_t data0);
-
-/**
- * Defines the interface of the JTAG callback mechanism.
- *
- * @param in the pointer to the data clocked in
- * @param data1 An integer big enough to use as an @c int or a pointer.
- * @param data2 An integer big enough to use as an @c int or a pointer.
- * @param data3 An integer big enough to use as an @c int or a pointer.
- * @returns an error code
- */
-typedef int (*jtag_callback_t)(jtag_callback_data_t data0,
- jtag_callback_data_t data1,
- jtag_callback_data_t data2,
- jtag_callback_data_t data3);
-
-
/**
- * This callback can be executed immediately the queue has been flushed.
+ * Defines the interface of the JTAG callback mechanism. Such
+ * callbacks can be executed once the queue has been flushed.
*
* The JTAG queue can be executed synchronously or asynchronously.
* Typically for USB, the queue is executed asynchronously. For
*
* If the execution of the queue fails before the callbacks, then --
* depending on driver implementation -- the callbacks may or may not be
- * invoked. @todo Can we make this behavior consistent?
+ * invoked.
*
- * The strange name is due to C's lack of overloading using function
- * arguments.
+ * @todo Make that behavior consistent.
*
- * @param f The callback function to add.
* @param data0 Typically used to point to the data to operate on.
* Frequently this will be the data clocked in during a shift operation.
* @param data1 An integer big enough to use as an @c int or a pointer.
* @param data2 An integer big enough to use as an @c int or a pointer.
* @param data3 An integer big enough to use as an @c int or a pointer.
- *
+ * @returns an error code
*/
-void jtag_add_callback4(jtag_callback_t f, jtag_callback_data_t data0,
- jtag_callback_data_t data1, jtag_callback_data_t data2,
- jtag_callback_data_t data3);
-
+typedef int (*jtag_callback_t)(jtag_callback_data_t data0,
+ jtag_callback_data_t data1,
+ jtag_callback_data_t data2,
+ jtag_callback_data_t data3);
/**
* Run a TAP_RESET reset where the end state is TAP_RESET,
* @param mask Pointer to scan mask; may be NULL.
* @returns Nothing, but calls jtag_set_error() on any error.
*/
-void jtag_check_value_mask(scan_field_t *field, uint8_t *value, uint8_t *mask);
+void jtag_check_value_mask(struct scan_field *field, uint8_t *value, uint8_t *mask);
void jtag_sleep(uint32_t us);
* There is no jtag_add_dr_outin() version of this fn that also allows
* clocking data back in. Patches gladly accepted!
*/
-void jtag_add_dr_out(jtag_tap_t* tap,
- int num_fields, const int* num_bits, const uint32_t* value,
- tap_state_t end_state);
/**
*/
void jtag_poll_set_enabled(bool value);
+
+/* The minidriver may have inline versions of some of the low
+ * level APIs that are used in inner loops. */
+#include <jtag/minidriver.h>
+
#endif /* JTAG_H */