X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Fjtag%2Fjtag.h;h=db7cd5c9d78e8aa564146ea14cbe06d2650abbc3;hp=1dfefdef595da991ce8836dfe9d8e0fb5716a382;hb=740b9e25b410c164e661d0334a9ea4168406726b;hpb=d70d9634bf6ab73ec4f2ac1e77012785770b460a diff --git a/src/jtag/jtag.h b/src/jtag/jtag.h index 1dfefdef59..db7cd5c9d7 100644 --- a/src/jtag/jtag.h +++ b/src/jtag/jtag.h @@ -2,7 +2,7 @@ * Copyright (C) 2005 by Dominic Rath * * Dominic.Rath@gmx.de * * * -* Copyright (C) 2007,2008 Øyvind Harboe * +* Copyright (C) 2007-2010 Øyvind Harboe * * oyvind.harboe@zylin.com * * * * This program is free software; you can redistribute it and/or modify * @@ -23,9 +23,8 @@ #ifndef JTAG_H #define JTAG_H -#include "binarybuffer.h" -#include "log.h" - +#include +#include #ifdef _DEBUG_JTAG_IO_ #define DEBUG_JTAG_IO(expr ...) \ @@ -39,17 +38,6 @@ #define DEBUG_JTAG_IOZ 64 #endif -/*-------------------------------------------------------*/ - -/** - * 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) - /*------------------------------------------------------*/ /** @@ -120,15 +108,11 @@ extern tap_state_t cmd_queue_cur_state; * * The allocated, modified, and intmp fields are internal work space. */ -typedef struct scan_field_s -{ - /// A pointer to the tap structure to which this field refers. - jtag_tap_t* tap; - +struct scan_field { /// The number of bits this field specifies (up to 32) int num_bits; /// A pointer to value to be scanned into the device - uint8_t* out_value; + const uint8_t* out_value; /// A pointer to a 32-bit memory location for data scanned out uint8_t* in_value; @@ -143,15 +127,9 @@ typedef struct scan_field_s 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; @@ -175,24 +153,27 @@ struct jtag_tap_s /// 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); @@ -226,11 +207,16 @@ enum jtag_event { 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; }; /** @@ -253,7 +239,7 @@ int jtag_call_event_callbacks(enum jtag_event event); /// @returns The current JTAG speed setting. -int jtag_get_speed(void); +int jtag_get_speed(int *speed); /** * Given a @a speed setting, use the interface @c speed_div callback to @@ -319,25 +305,26 @@ void jtag_set_verify_capture_ir(bool enable); /// @returns True if IR scan verification will be performed. bool jtag_will_verify_capture_ir(void); -/** - * Initialize interface upon startup. Return a successful no-op upon - * subsequent invocations. - */ -int jtag_interface_init(struct command_context_s* cmd_ctx); +/** Initialize debug adapter upon startup. */ +int adapter_init(struct command_context* cmd_ctx); + +/// Shutdown the debug adapter upon program exit. +int adapter_quit(void); -/// Shutdown the JTAG interface upon program exit. -int jtag_interface_quit(void); +/// Set ms to sleep after jtag_execute_queue() flushes queue. Debug +/// purposes. +void jtag_set_flush_queue_sleep(int ms); /** * 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 @@ -364,21 +351,21 @@ int jtag_init_inner(struct command_context_s *cmd_ctx); * subsequent DR SCANs. * */ -void jtag_add_ir_scan(int num_fields, - scan_field_t* fields, tap_state_t endstate); +void jtag_add_ir_scan(struct jtag_tap* tap, + 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); +void jtag_add_ir_scan_noverify(struct jtag_tap* tap, + 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. + * Scan out the bits in ir scan mode. + * + * If in_bits == NULL, discard incoming bits. */ -void jtag_add_plain_ir_scan(int num_fields, - const scan_field_t* fields, tap_state_t endstate); +void jtag_add_plain_ir_scan(int num_bits, const uint8_t *out_bits, uint8_t *in_bits, + tap_state_t endstate); /** @@ -390,7 +377,7 @@ void jtag_add_plain_ir_scan(int num_fields, * 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. @@ -398,18 +385,18 @@ void jtag_alloc_in_value32(scan_field_t *field); * specified there. For bypassed TAPs, the function generates a dummy * 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); +void jtag_add_dr_scan(struct jtag_tap* tap, int num_fields, + 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); +void jtag_add_dr_scan_check(struct jtag_tap* tap, int num_fields, + 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. + * Scan out the bits in ir scan mode. + * + * If in_bits == NULL, discard incoming bits. */ -void jtag_add_plain_dr_scan(int num_fields, - const scan_field_t* fields, tap_state_t endstate); +void jtag_add_plain_dr_scan(int num_bits, + const uint8_t *out_bits, uint8_t *in_bits, tap_state_t endstate); /** * Defines the type of data passed to the jtag_callback_t interface. @@ -431,24 +418,9 @@ typedef void (*jtag_callback1_t)(jtag_callback_data_t data0); 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 @@ -462,23 +434,21 @@ typedef int (*jtag_callback_t)(jtag_callback_data_t data0, * * 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, @@ -553,8 +523,8 @@ int jtag_add_statemove(tap_state_t goal_state); * to @a endstate (unless it is also TAP_IDLE). * * @param num_cycles Number of cycles in TAP_IDLE state. This argument - * may be 0, in which case this routine will navigate to @a endstate - * via TAP_IDLE. + * may be 0, in which case this routine will navigate to @a endstate + * via TAP_IDLE. * @param endstate The final state. */ void jtag_add_runtest(int num_cycles, tap_state_t endstate); @@ -584,30 +554,14 @@ void jtag_add_runtest(int num_cycles, tap_state_t endstate); */ void jtag_add_reset(int req_tlr_or_trst, int srst); - -/** - * Function jtag_set_end_state - * - * Set a global variable to \a state if \a state != TAP_INVALID. - * - * Return the value of the global variable. - * - **/ -tap_state_t jtag_set_end_state(tap_state_t state); -/** - * Function jtag_get_end_state - * - * Return the value of the global variable for end state - * - **/ -tap_state_t jtag_get_end_state(void); void jtag_add_sleep(uint32_t us); +int jtag_add_tms_seq(unsigned nbits, const uint8_t *seq, enum tap_state t); /** - * Function jtag_add_stable_clocks + * Function jtag_add_clocks * first checks that the state in which the clocks are to be issued is - * stable, then queues up clock_count clocks for transmission. + * stable, then queues up num_cycles clocks for transmission. */ void jtag_add_clocks(int num_cycles); @@ -657,7 +611,7 @@ int jtag_srst_asserted(int* srst_asserted); * @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); @@ -702,9 +656,6 @@ 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); /** @@ -714,8 +665,6 @@ void jtag_add_dr_out(jtag_tap_t* tap, * called with a non-zero error code. */ void jtag_set_error(int error); -/// @returns The current value of jtag_error -int jtag_get_error(void); /** * Resets jtag_error to ERROR_OK, returning its previous value. * @returns The previous value of @c jtag_error. @@ -725,7 +674,7 @@ int jtag_error_clear(void); /** * Return true if it's safe for a background polling task to access the * JTAG scan chain. Polling may be explicitly disallowed, and is also - * unsafe while nTRST is active or the JTAG clock is gated off., + * unsafe while nTRST is active or the JTAG clock is gated off. */ bool is_jtag_poll_safe(void); @@ -739,4 +688,11 @@ bool jtag_poll_get_enabled(void); */ 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 + +bool transport_is_jtag(void); + #endif /* JTAG_H */