X-Git-Url: https://review.openocd.org/gitweb?a=blobdiff_plain;f=src%2Fjtag%2Fjtag.h;h=84290ca7e189c0fc7288b4fb60618b209116d4db;hb=71d76b0a74bee78bd9aade2957e92c6b420372b9;hp=9c4acd70505aeb9ff3bbe13a1ca5be3b5387c4a0;hpb=ab9dfffdb5ecc2033d5d19c6e51c8b4fa10c9c9b;p=openocd.git diff --git a/src/jtag/jtag.h b/src/jtag/jtag.h index 9c4acd7050..84290ca7e1 100644 --- a/src/jtag/jtag.h +++ b/src/jtag/jtag.h @@ -23,37 +23,78 @@ #ifndef JTAG_H #define JTAG_H -#include "types.h" #include "binarybuffer.h" #include "log.h" -#include "command.h" - -#if 0 -#define _DEBUG_JTAG_IO_ +#ifdef _DEBUG_JTAG_IO_ +#define DEBUG_JTAG_IO(expr ...) LOG_DEBUG(expr) +#else +#define DEBUG_JTAG_IO(expr ...) #endif #ifndef DEBUG_JTAG_IOZ #define DEBUG_JTAG_IOZ 64 #endif +/*-------------------------------------------------------*/ + +/** When given an array, compute its DIMension, i.e. 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) + +/*------------------------------------------------------*/ + -/* 16 Tap States, from page 21 of ASSET InterTech, Inc.'s svf.pdf + +/* + * Tap states from ARM7TDMI-S Technical reference manual. + * Also, validated against several other ARM core technical manuals. + * + * N.B. tap_get_tms_path() was changed to reflect this corrected + * numbering and ordering of the TAP states. + * + * DANGER!!!! some interfaces care about the actual numbers used + * as they are handed off directly to hardware implementations. */ -enum tap_state { + +typedef enum tap_state +{ +#if BUILD_ECOSBOARD +/* 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, TAP_DRPAUSE = 5, TAP_DREXIT2 = 6, TAP_DRUPDATE = 7, TAP_IRSELECT = 9, TAP_IRCAPTURE = 10, TAP_IRSHIFT = 11, TAP_IREXIT1 = 12, - TAP_IRPAUSE = 13, TAP_IREXIT2 = 14, TAP_IRUPDATE = 15 -}; - -typedef enum tap_state tap_state_t; + TAP_IRPAUSE = 13, TAP_IREXIT2 = 14, TAP_IRUPDATE = 15, -typedef unsigned BOOL; -#define TRUE 1 -#define FALSE 0 + TAP_NUM_STATES = 16, TAP_INVALID = -1, +#else + /* Proper ARM recommended numbers */ + TAP_DREXIT2 = 0x0, + TAP_DREXIT1 = 0x1, + TAP_DRSHIFT = 0x2, + TAP_DRPAUSE = 0x3, + TAP_IRSELECT = 0x4, + TAP_DRUPDATE = 0x5, + TAP_DRCAPTURE = 0x6, + TAP_DRSELECT = 0x7, + TAP_IREXIT2 = 0x8, + TAP_IREXIT1 = 0x9, + TAP_IRSHIFT = 0xa, + TAP_IRPAUSE = 0xb, + TAP_IDLE = 0xc, + TAP_IRUPDATE = 0xd, + TAP_IRCAPTURE = 0xe, + TAP_RESET = 0x0f, + + TAP_NUM_STATES = 0x10, + + TAP_INVALID = -1, +#endif +} tap_state_t; typedef struct tap_transition_s { @@ -137,6 +178,25 @@ tap_state_t tap_get_end_state(void); */ int tap_get_tms_path(tap_state_t from, tap_state_t to); + +/** + * Function int tap_get_tms_path_len + * returns the total number of bits that represents a TMS path + * transition as given by the function tap_get_tms_path(). + * + * For at least one interface (JLink) it's not OK to simply "pad" TMS sequences + * to fit a whole byte. (I suspect this is a general TAP problem within OOCD.) + * Padding TMS causes all manner of instability that's not easily + * discovered. Using this routine we can apply EXACTLY the state transitions + * required to make something work - no more - no less. + * + * @param from is the starting state + * @param to is the resultant or final state + * @return int - the total number of bits in a transition. + */ +int tap_get_tms_path_len(tap_state_t from, tap_state_t to); + + /** * Function tap_move_ndx * when given a stable state, returns an index from 0-5. The index corresponds to a @@ -154,9 +214,9 @@ int tap_move_ndx(tap_state_t astate); /** * Function tap_is_state_stable - * returns TRUE if the \a astate is stable. + * returns true if the \a astate is stable. */ -BOOL tap_is_state_stable(tap_state_t astate); +bool tap_is_state_stable(tap_state_t astate); /** * Function tap_state_transition @@ -165,7 +225,7 @@ BOOL tap_is_state_stable(tap_state_t astate); * @param tms is either zero or non-zero, just like a real TMS line in a jtag interface. * @return tap_state_t - the next state a TAP would enter. */ -tap_state_t tap_state_transition(tap_state_t current_state, BOOL tms); +tap_state_t tap_state_transition(tap_state_t current_state, bool tms); /** * Function tap_state_name @@ -173,6 +233,25 @@ tap_state_t tap_state_transition(tap_state_t current_state, BOOL tms); */ const char* tap_state_name(tap_state_t state); +#ifdef _DEBUG_JTAG_IO_ +/** + * @brief Prints verbose TAP state transitions for the given TMS/TDI buffers. + * @param tms_buf must points to a buffer containing the TMS bitstream. + * @param tdi_buf must points to a buffer containing the TDI bitstream. + * @param tap_len must specify the length of the TMS/TDI bitstreams. + * @param start_tap_state must specify the current TAP state. + * @returns the final TAP state; pass as @a start_tap_state in following call. + */ +tap_state_t jtag_debug_state_machine(const void *tms_buf, const void *tdi_buf, + unsigned tap_len, tap_state_t start_tap_state); +#else +static inline tap_state_t jtag_debug_state_machine(const void *tms_buf, + const void *tdi_buf, unsigned tap_len, tap_state_t start_tap_state) +{ + return start_tap_state; +} +#endif // _DEBUG_JTAG_IO_ + /*-----------------------------------------------*/ @@ -189,13 +268,16 @@ typedef struct scan_field_s jtag_tap_t* tap; /* tap pointer this instruction refers to */ int num_bits; /* number of bits this field specifies (up to 32) */ u8* out_value; /* value to be scanned into the device */ - u8* out_mask; /* only masked bits care */ u8* in_value; /* pointer to a 32-bit memory location to take data scanned out */ - /* in_check_value/mask, in_handler_error_handler, in_handler_priv can be used by the in handler, otherwise they contain garbage */ - u8* in_check_value; /* used to validate scan results */ - u8* in_check_mask; /* check specified bits against check_value */ - in_handler_t in_handler; /* process received buffer using this handler */ - void* in_handler_priv; /* additional information for the in_handler */ + + u8* check_value; /* Used together with jtag_add_dr_scan_check() to check data clocked + in */ + u8* check_mask; /* mask to go with check_value */ + + /* internal work space */ + int allocated; /* in_value has been allocated for the queue */ + int modified; /* did we modify the in_value? */ + u8 intmp[4]; /* temporary storage for checking synchronously */ } scan_field_t; enum scan_type { @@ -313,7 +395,6 @@ struct jtag_tap_s }; extern jtag_tap_t* jtag_AllTaps(void); extern jtag_tap_t* jtag_TapByPosition(int n); -extern jtag_tap_t* jtag_TapByPosition(int n); extern jtag_tap_t* jtag_TapByString(const char* dotted_name); extern jtag_tap_t* jtag_TapByJimObj(Jim_Interp* interp, Jim_Obj* obj); extern jtag_tap_t* jtag_TapByAbsPosition(int abs_position); @@ -479,21 +560,121 @@ extern int jtag_register_commands(struct command_context_s* cmd_ctx); * */ extern void jtag_add_ir_scan(int num_fields, scan_field_t* fields, tap_state_t endstate); +/* same as jtag_add_ir_scan except no verify is performed */ +extern void jtag_add_ir_scan_noverify(int num_fields, scan_field_t *fields, tap_state_t state); extern int interface_jtag_add_ir_scan(int num_fields, scan_field_t* fields, tap_state_t endstate); extern void jtag_add_dr_scan(int num_fields, scan_field_t* fields, tap_state_t endstate); + +/* 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. + * + * 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. + */ + +#ifndef HAVE_JTAG_MINIDRIVER_H +extern void jtag_alloc_in_value32(scan_field_t *field); +#else +static __inline__ void jtag_alloc_in_value32(scan_field_t *field) +{ + field->in_value=field->intmp; +} +#endif + + + +/* This version of jtag_add_dr_scan() uses the check_value/mask fields */ +extern void jtag_add_dr_scan_check(int num_fields, scan_field_t* fields, tap_state_t endstate); extern int interface_jtag_add_dr_scan(int num_fields, scan_field_t* fields, tap_state_t endstate); extern void jtag_add_plain_ir_scan(int num_fields, scan_field_t* fields, tap_state_t endstate); extern int interface_jtag_add_plain_ir_scan(int num_fields, scan_field_t* fields, tap_state_t endstate); extern void jtag_add_plain_dr_scan(int num_fields, scan_field_t* fields, tap_state_t endstate); extern int interface_jtag_add_plain_dr_scan(int num_fields, scan_field_t* fields, tap_state_t endstate); + +/* Simplest/typical callback - do some conversion on the data clocked in. + * This callback is for such conversion that can not fail. + * For conversion types or checks that can + * fail, use the jtag_callback_t variant */ +typedef void (*jtag_callback1_t)(u8 *in); + +#ifndef HAVE_JTAG_MINIDRIVER_H +/* A simpler version of jtag_add_callback4 */ +extern void jtag_add_callback(jtag_callback1_t, u8 *in); +#else +/* implemented by minidriver */ +#endif + +/* This type can store an integer safely by a normal cast on 64 and + * 32 bit systems. */ +typedef intptr_t jtag_callback_data_t; + +/* The generic callback mechanism. + * + * The callback is invoked with three arguments. The first argument is + * the pointer to the data clocked in. + */ +typedef int (*jtag_callback_t)(u8 *in, 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. Note that + * the JTAG queue can either be executed synchronously or asynchronously. Typically + * for USB the queue is executed asynchronously. For low latency interfaces, the + * queue may be executed synchronously. + * + * These callbacks are typically executed *after* the *entire* JTAG queue has been + * executed for e.g. USB interfaces. + * + * The callbacks are guaranteeed to be invoked in the order that they were queued. + * + * The strange name is due to C's lack of overloading using function arguments + * + * The callback mechansim is very general and does not really make any assumptions + * about what the callback does and what the arguments are. + * + * in - typically used to point to the data to operate on. More often than not + * this will be the data clocked in during a shift operation + * + * data1 - an integer that is big enough to be used either as an 'int' or + * cast to/from a pointer + * + * data2 - an integer that is big enough to be used either as an 'int' or + * cast to/from a pointer + * + * Why stop at 'data2' for arguments? Somewhat historical reasons. This is + * sufficient to implement the jtag_check_value_mask(), besides the + * line is best drawn somewhere... + * + * If the execution of the queue fails before the callbacks, then the + * callbacks may or may not be invoked depending on driver implementation. + */ +#ifndef HAVE_JTAG_MINIDRIVER_H +extern void jtag_add_callback4(jtag_callback_t, u8 *in, jtag_callback_data_t data1, jtag_callback_data_t data2, jtag_callback_data_t data3); +#else +/* implemented by minidriver */ +#endif + + /* run a TAP_RESET reset. End state is TAP_RESET, regardless * of start state. */ extern void jtag_add_tlr(void); extern int interface_jtag_add_tlr(void); -/* Do not use jtag_add_pathmove() unless you need to, but do use it +/* Application code *must* assume that interfaces will + * implement transitions between states with different + * paths and path lengths through the state diagram. The + * path will vary across interface and also across versions + * of the same interface over time. Even if the OpenOCD code + * is unchanged, the actual path taken may vary over time + * and versions of interface firmware or PCB revisions. + * + * Use jtag_add_pathmove() when specific transition sequences + * are required. + * + * Do not use jtag_add_pathmove() unless you need to, but do use it * if you have to. * * DANGER! If the target is dependent upon a particular sequence @@ -605,13 +786,43 @@ int interface_jtag_add_clocks(int num_cycles); */ extern int jtag_execute_queue(void); +/* same as jtag_execute_queue() but does not clear the error flag */ +extern void jtag_execute_queue_noclear(void); + +/* this flag is set when an error occurs while executing the queue. cleared + * by jtag_execute_queue() + * + * this flag can also be set from application code if some error happens + * during processing that should be reported during 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; +} + + + /* can be implemented by hw+sw */ extern int interface_jtag_execute_queue(void); extern int jtag_power_dropout(int* dropout); extern int jtag_srst_asserted(int* srst_asserted); /* JTAG support functions */ -extern void jtag_set_check_value(scan_field_t* field, u8* value, u8* mask, error_handler_t* in_error_handler); +struct invalidstruct +{ + +}; + +/* execute jtag queue and check value and use mask if mask is != NULL. invokes + * jtag_set_error() with any error. */ +extern void jtag_check_value_mask(scan_field_t *field, u8 *value, u8 *mask); extern enum scan_type jtag_scan_type(scan_command_t* cmd); extern int jtag_scan_size(scan_command_t* cmd); extern int jtag_read_buffer(u8* buffer, scan_command_t* cmd); @@ -647,7 +858,7 @@ void jtag_tap_handle_event(jtag_tap_t* tap, enum jtag_tap_event e); /* jtag_add_dr_out() is a faster version of jtag_add_dr_scan() * - * Current or end_state can not be TAP_RESET. end_state can be -1 + * 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. * @@ -670,7 +881,7 @@ extern void interface_jtag_add_dr_out(jtag_tap_t* tap, int num_fields, const int static __inline__ void jtag_add_dr_out(jtag_tap_t* tap, int num_fields, const int* num_bits, const u32* value, tap_state_t end_state) { - if (end_state != -1) + if (end_state != TAP_INVALID) cmd_queue_end_state = end_state; cmd_queue_cur_state = cmd_queue_end_state; interface_jtag_add_dr_out(tap, num_fields, num_bits, value, cmd_queue_end_state);