X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Fjtag%2Fjtag.h;h=7702d6ca81ec2b6d6dc82820cb3ae94256f09792;hp=978682269a45864a2f37159f9e25afd1dc7d6525;hb=cc2d4f015f72d7c30d613b50572eb9f31fac515a;hpb=d19643f7743f845783721fe6c09c6b69fa097bc6 diff --git a/src/jtag/jtag.h b/src/jtag/jtag.h index 978682269a..7702d6ca81 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 * @@ -16,38 +16,27 @@ * 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 . * ***************************************************************************/ -#ifndef JTAG_H -#define JTAG_H -#include "binarybuffer.h" -#include "log.h" +#ifndef OPENOCD_JTAG_JTAG_H +#define OPENOCD_JTAG_JTAG_H +#include +#include #ifdef _DEBUG_JTAG_IO_ -#define DEBUG_JTAG_IO(expr ...) LOG_DEBUG(expr) +#define DEBUG_JTAG_IO(expr ...) \ + do { if (1) LOG_DEBUG(expr); } while (0) #else -#define DEBUG_JTAG_IO(expr ...) +#define DEBUG_JTAG_IO(expr ...) \ + do { if (0) LOG_DEBUG(expr); } while (0) #endif #ifndef DEBUG_JTAG_IOZ #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) - /*------------------------------------------------------*/ /** @@ -55,14 +44,17 @@ * * These definitions were gleaned from the ARM7TDMI-S Technical * Reference Manual and validated against several other ARM core - * technical manuals. tap_get_tms_path() is sensitive to this numbering - * and ordering of the TAP states; furthermore, some interfaces require - * specific numbers be used, as they are handed-off directly to their - * hardware implementations. + * technical manuals. + * + * FIXME some interfaces require specific numbers be used, as they + * are handed-off directly to their hardware implementations. + * Fix those drivers to map as appropriate ... then pick some + * sane set of numbers here (where 0/uninitialized == INVALID). */ -typedef enum tap_state -{ -#if BUILD_ECOSBOARD +typedef enum tap_state { + TAP_INVALID = -1, + +#if BUILD_ZY1000 /* These are the old numbers. Leave as-is for now... */ TAP_RESET = 0, TAP_IDLE = 8, TAP_DRSELECT = 1, TAP_DRCAPTURE = 2, TAP_DRSHIFT = 3, TAP_DREXIT1 = 4, @@ -70,7 +62,6 @@ typedef enum tap_state TAP_IRSELECT = 9, TAP_IRCAPTURE = 10, TAP_IRSHIFT = 11, TAP_IREXIT1 = 12, TAP_IRPAUSE = 13, TAP_IREXIT2 = 14, TAP_IRUPDATE = 15, - TAP_NUM_STATES = 16, TAP_INVALID = -1, #else /* Proper ARM recommended numbers */ TAP_DREXIT2 = 0x0, @@ -90,9 +81,6 @@ typedef enum tap_state TAP_IRCAPTURE = 0xe, TAP_RESET = 0x0f, - TAP_NUM_STATES = 0x10, - - TAP_INVALID = -1, #endif } tap_state_t; @@ -100,9 +88,12 @@ typedef enum tap_state * Function tap_state_name * Returns a string suitable for display representing the JTAG tap_state */ -const char* tap_state_name(tap_state_t state); +const char *tap_state_name(tap_state_t state); + +/** Provides user-friendly name lookup of TAP states. */ +tap_state_t tap_state_by_name(const char *name); -/// The current TAP state of the pending JTAG command queue. +/** The current TAP state of the pending JTAG command queue. */ extern tap_state_t cmd_queue_cur_state; /** @@ -112,153 +103,156 @@ extern tap_state_t cmd_queue_cur_state; * * In addition, this structure includes a value and mask that is used by * jtag_add_dr_scan_check() to validate the value that was scanned out. - * - * 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; - - /// The number of bits this field specifies (up to 32) +struct scan_field { + /** The number of bits this field specifies */ int num_bits; - /// A pointer to value to be scanned into the device - u8* out_value; - /// A pointer to a 32-bit memory location for data scanned out - u8* in_value; - - /// The value used to check the data scanned out. - u8* check_value; - /// The mask to go with check_value - u8* check_mask; - - /// in_value has been allocated for the queue - int allocated; - /// Indicates we modified the in_value. - int modified; - /// temporary storage for performing value checks synchronously - u8 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 decloration reasons" */ -struct jtag_tap_s -{ - const char* chip; - const char* tapname; - const char* dotted_name; + /** A pointer to value to be scanned into the device */ + const uint8_t *out_value; + /** A pointer to a 32-bit memory location for data scanned out */ + uint8_t *in_value; + + /** The value used to check the data scanned out. */ + uint8_t *check_value; + /** The mask to go with check_value */ + uint8_t *check_mask; +}; + +struct jtag_tap { + char *chip; + char *tapname; + char *dotted_name; int abs_chain_position; - /// Is this TAP enabled? - int enabled; + /** Is this TAP disabled after JTAG reset? */ + bool disabled_after_reset; + /** Is this TAP currently enabled? */ + bool enabled; int ir_length; /**< size of instruction register */ - u32 ir_capture_value; - u8* expected; /**< Capture-IR expected value */ - u32 ir_capture_mask; - u8* expected_mask; /**< Capture-IR expected mask */ - u32 idcode; - /**< device identification code */ - - /// Array of expected identification codes */ - u32* expected_ids; - /// Number of expected identification codes - u8 expected_ids_cnt; - - /// current instruction - u8* cur_instr; - /// Bypass register selected + uint32_t ir_capture_value; + uint8_t *expected; /**< Capture-IR expected value */ + uint32_t ir_capture_mask; + uint8_t *expected_mask; /**< Capture-IR expected mask */ + uint32_t idcode; /**< device identification code */ + /** not all devices have idcode, + * we'll discover this during chain examination */ + bool hasidcode; + + /** Array of expected identification codes */ + uint32_t *expected_ids; + /** 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; -}; -extern jtag_tap_t* jtag_all_taps(void); -extern const char *jtag_tap_name(const jtag_tap_t *tap); -extern jtag_tap_t* jtag_tap_by_string(const char* dotted_name); -extern jtag_tap_t* jtag_tap_by_jim_obj(Jim_Interp* interp, Jim_Obj* obj); -extern jtag_tap_t* jtag_tap_by_position(unsigned abs_position); -extern unsigned jtag_tap_count_enabled(void); -extern unsigned jtag_tap_count(void); - -static __inline__ jtag_tap_t* jtag_tap_next_enabled(jtag_tap_t* p) -{ - if (p == NULL) - { - /* start at the head of list */ - p = jtag_all_taps(); - } - else - { - /* start *after* this one */ - p = p->next_tap; - } - while (p) - { - if (p->enabled) - { - break; - } - else - { - p = p->next_tap; - } - } - - return p; -} - - -enum reset_line_mode { - LINE_OPEN_DRAIN = 0x0, - LINE_PUSH_PULL = 0x1, + struct jtag_tap *next_tap; + /* dap instance if some null if no instance , initialized to 0 by calloc*/ + struct adiv5_dap *dap; + /* private pointer to support none-jtag specific functions */ + void *priv; }; -/* - * There are three cases when JTAG_TRST_ASSERTED callback is invoked. The - * event is invoked *after* TRST is asserted(or queued rather). It is illegal - * to communicate with the JTAG interface during the callback(as there is - * currently a queue being built). - * - * - TMS reset - * - SRST pulls TRST - * - TRST asserted - * - **/ +void jtag_tap_init(struct jtag_tap *tap); +void jtag_tap_free(struct jtag_tap *tap); + +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_by_position(unsigned abs_position); +struct jtag_tap *jtag_tap_next_enabled(struct jtag_tap *p); +unsigned jtag_tap_count_enabled(void); +unsigned jtag_tap_count(void); + +/* + * - TRST_ASSERTED triggers two sets of callbacks, after operations to + * reset the scan chain -- via TMS+TCK signaling, or deasserting the + * nTRST signal -- are queued: + * + * + Callbacks in C code fire first, patching internal state + * + Then post-reset event scripts fire ... activating JTAG circuits + * via TCK cycles, exiting SWD mode via TMS sequences, etc + * + * During those callbacks, scan chain contents have not been validated. + * JTAG operations that address a specific TAP (primarily DR/IR scans) + * must *not* be queued. + * + * - TAP_EVENT_SETUP is reported after TRST_ASSERTED, and after the scan + * chain has been validated. JTAG operations including scans that + * target specific TAPs may be performed. + * + * - TAP_EVENT_ENABLE and TAP_EVENT_DISABLE implement TAP activation and + * deactivation outside the core using scripted code that understands + * the specific JTAG router type. They might be triggered indirectly + * from EVENT_SETUP operations. + */ enum jtag_event { - JTAG_TRST_ASSERTED + JTAG_TRST_ASSERTED, + JTAG_TAP_EVENT_SETUP, + JTAG_TAP_EVENT_ENABLE, + JTAG_TAP_EVENT_DISABLE, }; -enum jtag_tap_event { - JTAG_TAP_EVENT_ENABLE, - JTAG_TAP_EVENT_DISABLE +struct jtag_tap_event_action { + /** 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; }; -extern const Jim_Nvp nvp_jtag_tap_event[]; +/** + * Defines the function signature requide for JTAG event callback + * functions, which are added with jtag_register_event_callback() + * and removed jtag_unregister_event_callback(). + * @param event The event to handle. + * @param prive A pointer to data that was passed to + * jtag_register_event_callback(). + * @returns Must return ERROR_OK on success, or an error code on failure. + * + * @todo Change to return void or define a use for its return code. + */ +typedef int (*jtag_event_handler_t)(enum jtag_event event, void *priv); -struct jtag_tap_event_action_s -{ - enum jtag_tap_event event; - Jim_Obj* body; - jtag_tap_event_action_t* next; -}; +int jtag_register_event_callback(jtag_event_handler_t f, void *x); +int jtag_unregister_event_callback(jtag_event_handler_t f, void *x); -extern int jtag_trst; -extern int jtag_srst; +int jtag_call_event_callbacks(enum jtag_event event); -typedef struct jtag_event_callback_s -{ - int (*callback)(enum jtag_event event, void* priv); - void* priv; - struct jtag_event_callback_s* next; -} jtag_event_callback_t; -extern jtag_event_callback_t* jtag_event_callbacks; +/** @returns The current JTAG speed setting. */ +int jtag_get_speed(int *speed); -extern int jtag_speed; -extern int jtag_speed_post_reset; +/** + * Given a @a speed setting, use the interface @c speed_div callback to + * adjust the setting. + * @param speed The speed setting to convert back to readable KHz. + * @returns ERROR_OK if the interface has not been initialized or on success; + * otherwise, the error code produced by the @c speed_div callback. + */ +int jtag_get_speed_readable(int *speed); + +/** Attempt to configure the interface for the specified KHz. */ +int jtag_config_khz(unsigned khz); + +/** + * Attempt to enable RTCK/RCLK. If that fails, fallback to the + * specified frequency. + */ +int jtag_config_rclk(unsigned fallback_speed_khz); + +/** Retreives the clock speed of the JTAG interface in KHz. */ +unsigned jtag_get_speed_khz(void); enum reset_types { RESET_NONE = 0x0, @@ -269,28 +263,59 @@ enum reset_types { RESET_TRST_PULLS_SRST = 0x8, RESET_TRST_OPEN_DRAIN = 0x10, RESET_SRST_PUSH_PULL = 0x20, + RESET_SRST_NO_GATING = 0x40, + RESET_CNCT_UNDER_SRST = 0x80 }; -extern enum reset_types jtag_reset_config; +enum reset_types jtag_get_reset_config(void); +void jtag_set_reset_config(enum reset_types type); -/** - * Initialize interface upon startup. Return a successful no-op upon - * subsequent invocations. - */ -extern int jtag_interface_init(struct command_context_s* cmd_ctx); +void jtag_set_nsrst_delay(unsigned delay); +unsigned jtag_get_nsrst_delay(void); + +void jtag_set_ntrst_delay(unsigned delay); +unsigned jtag_get_ntrst_delay(void); -/// Shutdown the JTAG interface upon program exit. -extern int jtag_interface_quit(void); +void jtag_set_nsrst_assert_width(unsigned delay); +unsigned jtag_get_nsrst_assert_width(void); + +void jtag_set_ntrst_assert_width(unsigned delay); +unsigned jtag_get_ntrst_assert_width(void); + +/** @returns The current state of TRST. */ +int jtag_get_trst(void); +/** @returns The current state of SRST. */ +int jtag_get_srst(void); + +/** Enable or disable data scan verification checking. */ +void jtag_set_verify(bool enable); +/** @returns True if data scan verification will be performed. */ +bool jtag_will_verify(void); + +/** Enable or disable verification of IR scan checking. */ +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 debug adapter upon startup. */ +int adapter_init(struct command_context *cmd_ctx); + +/** Shutdown the debug adapter upon program exit. */ +int adapter_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. */ -extern int jtag_init(struct command_context_s* cmd_ctx); +int jtag_init(struct command_context *cmd_ctx); -/// reset, then initialize JTAG chain -extern int jtag_init_reset(struct command_context_s* cmd_ctx); -extern int jtag_register_commands(struct command_context_s* cmd_ctx); +/** reset, then initialize JTAG chain */ +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 @@ -317,30 +342,21 @@ extern int jtag_register_commands(struct command_context_s* cmd_ctx); * subsequent DR SCANs. * */ -extern 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. */ -extern void jtag_add_ir_scan_noverify(int num_fields, const scan_field_t *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. - */ -extern void jtag_add_plain_ir_scan(int num_fields, const scan_field_t* fields, tap_state_t endstate); - - +void jtag_add_ir_scan_noverify(struct jtag_tap *tap, + const struct scan_field *fields, tap_state_t state); /** - * Set in_value to point to 32 bits of memory to scan into. This - * function is a way to handle the case of synchronous and asynchronous - * JTAG queues. + * Scan out the bits in ir scan mode. * - * In the event of an asynchronous queue execution the queue buffer - * allocation method is used, for the synchronous case the temporary 32 - * bits come from the input field itself. + * If in_bits == NULL, discard incoming bits. */ -extern void jtag_alloc_in_value32(scan_field_t *field); +void jtag_add_plain_ir_scan(int num_bits, const uint8_t *out_bits, uint8_t *in_bits, + tap_state_t endstate); /** * Generate a DR SCAN using the fields passed to the function. @@ -348,30 +364,18 @@ extern 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(). */ -extern void jtag_add_dr_scan(int num_fields, const scan_field_t* fields, tap_state_t endstate); -/// A version of jtag_add_dr_scan() that uses the check_value/mask fields -extern void jtag_add_dr_scan_check(int num_fields, scan_field_t* 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. - */ -extern void jtag_add_plain_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(struct jtag_tap *tap, int num_fields, + struct scan_field *fields, tap_state_t endstate); /** - * Defines a simple JTAG callback that can allow conversions on data - * scanned in from an interface. + * Scan out the bits in ir scan mode. * - * This callback should only be used for conversion that cannot fail. - * For conversion types or checks that can fail, use the more complete - * variant: jtag_callback_t. + * If in_bits == NULL, discard incoming bits. */ -typedef void (*jtag_callback1_t)(u8 *in); - -/// A simpler version of jtag_add_callback4(). -extern void jtag_add_callback(jtag_callback1_t, u8 *in); - +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. @@ -380,19 +384,22 @@ extern void jtag_add_callback(jtag_callback1_t, u8 *in); typedef intptr_t jtag_callback_data_t; /** - * Defines the interface of the JTAG callback mechanism. + * Defines a simple JTAG callback that can allow conversions on data + * scanned in from an interface. * - * @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 + * This callback should only be used for conversion that cannot fail. + * For conversion types or checks that can fail, use the more complete + * variant: jtag_callback_t. */ -typedef int (*jtag_callback_t)(u8 *in, jtag_callback_data_t data1, jtag_callback_data_t data2, jtag_callback_data_t data3); +typedef void (*jtag_callback1_t)(jtag_callback_data_t data0); + +/** A simpler version of jtag_add_callback4(). */ +void jtag_add_callback(jtag_callback1_t, jtag_callback_data_t data0); /** - * 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 @@ -406,29 +413,27 @@ typedef int (*jtag_callback_t)(u8 *in, jtag_callback_data_t data1, jtag_callback * * 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 in Typically used to point to the data to operate on. + * @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 */ -extern void jtag_add_callback4(jtag_callback_t f, u8 *in, - 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, * regardless of the start state. */ -extern void jtag_add_tlr(void); +void jtag_add_tlr(void); /** * Application code *must* assume that interfaces will @@ -478,7 +483,18 @@ extern void jtag_add_tlr(void); * - ERROR_JTAG_TRANSITION_INVALID -- The path includes invalid * state transitions. */ -extern void jtag_add_pathmove(int num_states, const tap_state_t* path); +void jtag_add_pathmove(int num_states, const tap_state_t *path); + +/** + * jtag_add_statemove() moves from the current state to @a goal_state. + * + * @param goal_state The final TAP state. + * @return ERROR_OK on success, or an error code on failure. + * + * Moves from the current state to the goal \a state. + * Both states must be stable. + */ +int jtag_add_statemove(tap_state_t goal_state); /** * Goes to TAP_IDLE (if we're not already there), cycle @@ -486,11 +502,11 @@ extern void jtag_add_pathmove(int num_states, const tap_state_t* path); * 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. */ -extern void jtag_add_runtest(int num_cycles, tap_state_t endstate); +void jtag_add_runtest(int num_cycles, tap_state_t endstate); /** * A reset of the TAP state machine can be requested. @@ -515,36 +531,19 @@ extern void jtag_add_runtest(int num_cycles, tap_state_t endstate); * are undefined, but when srst_pulls_trst or vice versa, * then trst & srst *must* be asserted together. */ -extern void jtag_add_reset(int req_tlr_or_trst, int srst); - +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. - * - **/ -extern 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 - * - **/ -extern tap_state_t jtag_get_end_state(void); -extern void jtag_add_sleep(u32 us); +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); - /** * For software FIFO implementations, the queued commands can be executed * during this call or earlier. A sw queue might decide to push out @@ -555,7 +554,7 @@ void jtag_add_clocks(int num_cycles); * matter if the operation was executed *before* jtag_execute_queue(), * jtag_execute_queue() will still return an error code. * - * All jtag_add_xxx() calls that have in_handler!=NULL will have been + * All jtag_add_xxx() calls that have in_handler != NULL will have been * executed when this fn returns, but if what has been queued only * clocks data out, without reading anything back, then JTAG could * be running *after* jtag_execute_queue() returns. The API does @@ -565,46 +564,20 @@ void jtag_add_clocks(int num_cycles); * jtag_add_xxx() commands can either be executed immediately or * at some time between the jtag_add_xxx() fn call and jtag_execute_queue(). */ -extern int jtag_execute_queue(void); +int jtag_execute_queue(void); -/* same as jtag_execute_queue() but does not clear the error flag */ -extern void jtag_execute_queue_noclear(void); +/** same as jtag_execute_queue() but does not clear the error flag */ +void jtag_execute_queue_noclear(void); -/** - * The jtag_error variable is set when an error occurs while executing - * the queue. - * - * This flag can also be set from application code, if an error happens - * during processing that should be reported during jtag_execute_queue(). - * - * It is cleared by jtag_execute_queue(). - */ -extern int jtag_error; - -static __inline__ void jtag_set_error(int error) -{ - if ((error==ERROR_OK)||(jtag_error!=ERROR_OK)) - { - /* keep first error */ - return; - } - jtag_error=error; -} +/** @returns the number of times the scan queue has been flushed */ +int jtag_get_flush_queue_count(void); -/** - * Resets jtag_error to ERROR_OK, returning its previous value. - * @returns The previous value of @c jtag_error. - */ -static inline int jtag_error_clear(void) -{ - int temp = jtag_error; - jtag_error = ERROR_OK; - return temp; -} +/** Report Tcl event to all TAPs */ +void jtag_notify_event(enum jtag_event); -/* can be implemented by hw+sw */ -extern int jtag_power_dropout(int* dropout); -extern int jtag_srst_asserted(int* srst_asserted); +/* can be implemented by hw + sw */ +int jtag_power_dropout(int *dropout); +int jtag_srst_asserted(int *srst_asserted); /* JTAG support functions */ @@ -615,15 +588,9 @@ extern 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. */ -extern void jtag_check_value_mask(scan_field_t *field, u8 *value, u8 *mask); +void jtag_check_value_mask(struct scan_field *field, uint8_t *value, uint8_t *mask); -extern void jtag_sleep(u32 us); -extern int jtag_call_event_callbacks(enum jtag_event event); -extern int jtag_register_event_callback(int (* callback)(enum jtag_event event, void* priv), void* priv); - -extern int jtag_verify_capture_ir; - -void jtag_tap_handle_event(jtag_tap_t* tap, enum jtag_tap_event e); +void jtag_sleep(uint32_t us); /* * The JTAG subsystem defines a number of error codes, @@ -638,84 +605,45 @@ void jtag_tap_handle_event(jtag_tap_t* tap, enum jtag_tap_event e); #define ERROR_JTAG_DEVICE_ERROR (-107) #define ERROR_JTAG_STATE_INVALID (-108) #define ERROR_JTAG_TRANSITION_INVALID (-109) +#define ERROR_JTAG_INIT_SOFT_FAIL (-110) /** - * jtag_add_dr_out() is a version of jtag_add_dr_scan() which - * only scans data out. It operates on 32 bit integers instead - * of 8 bit, which makes it a better impedance match with - * the calling code which often operate on 32 bit integers. - * - * Current or end_state can not be TAP_RESET. end_state can be TAP_INVALID - * - * num_bits[i] is the number of bits to clock out from value[i] LSB first. - * - * If the device is in bypass, then that is an error condition in - * the caller code that is not detected by this fn, whereas - * jtag_add_dr_scan() does detect it. Similarly if the device is not in - * bypass, data must be passed to it. - * - * If anything fails, then jtag_error will be set and jtag_execute() will - * return an error. There is no way to determine if there was a failure - * during this function call. - * - * This is an inline fn to speed up embedded hosts. Also note that - * interface_jtag_add_dr_out() can be a *small* inline function for - * embedded hosts. - * - * There is no jtag_add_dr_outin() version of this fn that also allows - * clocking data back in. Patches gladly accepted! + * Set the current JTAG core execution error, unless one was set + * by a previous call previously. Driver or application code must + * use jtag_error_clear to reset jtag_error once this routine has been + * called with a non-zero error code. */ -extern void jtag_add_dr_out(jtag_tap_t* tap, - int num_fields, const int* num_bits, const u32* value, - tap_state_t end_state); +void jtag_set_error(int error); +/** + * Resets jtag_error to ERROR_OK, returning its previous value. + * @returns The previous value of @c jtag_error. + */ +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. + */ +bool is_jtag_poll_safe(void); /** - * jtag_add_statemove() moves from the current state to @a goal_state. - * - * @param goal_state The final TAP state. - * @return ERROR_OK on success, or an error code on failure. - * - * Moves from the current state to the goal \a state. - * - * This needs to be handled according to the xsvf spec, see the XSTATE - * command description. From the XSVF spec, pertaining to XSTATE: - * - * For special states known as stable states (Test-Logic-Reset, - * Run-Test/Idle, Pause-DR, Pause- IR), an XSVF interpreter follows - * predefined TAP state paths when the starting state is a stable state - * and when the XSTATE specifies a new stable state. See the STATE - * command in the [Ref 5] for the TAP state paths between stable - * states. - * - * For non-stable states, XSTATE should specify a state that is only one - * TAP state transition distance from the current TAP state to avoid - * undefined TAP state paths. A sequence of multiple XSTATE commands can - * be issued to transition the TAP through a specific state path. - * - * @note Unless @c tms_bits holds a path that agrees with [Ref 5] in the - * above spec, then this code is not fully conformant to the xsvf spec. - * This puts a burden on tap_get_tms_path() function from the xsvf spec. - * If in doubt, you should confirm that that burden is being met. - * - * Otherwise, @a goal_state must be immediately reachable in one clock - * cycle, and does not need to be a stable state. + * Return flag reporting whether JTAG polling is disallowed. */ -extern int jtag_add_statemove(tap_state_t goal_state); +bool jtag_poll_get_enabled(void); -/// @returns the number of times the scan queue has been flushed -int jtag_get_flush_queue_count(void); +/** + * Assign flag reporting whether JTAG polling is disallowed. + */ +void jtag_poll_set_enabled(bool value); -void jtag_set_nsrst_delay(unsigned delay); -unsigned jtag_get_nsrst_delay(void); -void jtag_set_ntrst_delay(unsigned delay); -unsigned jtag_get_ntrst_delay(void); +/* The minidriver may have inline versions of some of the low + * level APIs that are used in inner loops. */ +#include -void jtag_set_speed_khz(unsigned speed); -unsigned jtag_get_speed_khz(void); +bool transport_is_jtag(void); -void jtag_set_verify(bool enable); -bool jtag_will_verify(void); +int jim_jtag_newtap(Jim_Interp *interp, int argc, Jim_Obj *const *argv); -#endif /* JTAG_H */ +#endif /* OPENOCD_JTAG_JTAG_H */